CQAlgorithm#

class CQAlgorithm(A, C_projection, Q_projection, algorithmic_relaxation=1.0, proximity_flag=True)[source]#

Bases: SplitFeasibility

Implementation for the CQ algorithm to solve split feasibility problems.

Parameters:

  • A (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]] | sparray) – Matrix connecting input and target space.

  • C_projection (Projection) – The projection operator onto the set C.

  • Q_projection (Projection) – The projection operator onto the set Q.

  • algorithmic_relaxation (float) – The relaxation parameter used by the algorithm, by default 1.0.

  • proximity_flag (bool) – A flag indicating whether to use this object for proximity calculations, by default True.

Attributes:
ALinearMapping

Linear mapping between input and target space.

C_projectionProjection

The projection operator onto the set C.

Q_projectionProjection

The projection operator onto the set Q.

proximitieslist

A list to store proximity values during the solve process.

algorithmic_relaxationnpt.NDArray or float, optional

The relaxation parameter used by the algorithm, by default 1.0.

proximity_flagbool

A flag indicating whether to use this object for proximity calculations.

Methods

map(x)

Maps the input space array to the target space via matrix multiplication.

map_back(y)

Transposed map of the target space array to the input space.

project(x[, y])

Projects the input array onto the feasible set.

proximity(x, proximity_measures)

Calculate proximity measures of point x to the set.

solve(x[, max_iter, prox_tol, del_prox_tol, ...])

Solves the split feasibility problem for a given input array.

step(x[, y])

Perform the (possibly relaxed) projection of input array 'x' onto the constraint.
map(x)#

Maps the input space array to the target space via matrix multiplication.

Parameters:

x (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – The input space array to be mapped.

Return type:

ndarray

Returns:

The corresponding target space array.

map_back(y)#

Transposed map of the target space array to the input space.

Parameters:

y (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – The target space array to map.

Return type:

ndarray

Returns:

The corresponding array in input space.

project(x, y=None)#

Projects the input array onto the feasible set.

Parameters:

  • x (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – The input array to project.

  • y (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]] | None) – An optional array for projection (default is None).

Return type:

tuple

Returns:

A (x, y) pair of projected arrays; y may be None.

proximity(x, proximity_measures)#

Calculate proximity measures of point x to the set.

Parameters:

x (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – Input array for which the proximity measure is to be calculated.

Return type:

float

Returns:

The proximity measures of the input array x.

solve(x, max_iter=10, prox_tol=1e-06, del_prox_tol=1e-08, del_prox_n=5, storage=False, storage_iters=None, proximity_measures=None, alternative_stopping_criterion=None, alternative_stopping_criterion_initial_call=None)#

Solves the split feasibility problem for a given input array.

Parameters:

  • x (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – Starting point for the algorithm.

  • max_iter (int) – The maximum number of iterations (default is 10).

  • prox_tol (float) – Stopping criterium for the feasibility seeking algorithm. Solution deemed feasible if the proximity drops below this value (default is 1e-6).

  • del_prox_tol (float) – The tolerance for the change in proximity over the last del_prox_n iterations, by default 1e-8.

  • del_prox_n (int) – The number of iterations to check for the change in proximity, by default 5.

  • storage (bool) – A flag indicating whether to store all intermediate solutions (default is False).

  • storage_iters (Union[List[int], int, None]) – Controls which iterations are stored (when storage=True). If None, all iterations are stored. If a list of ints, only those iteration indices are stored (0 = initial point). If an int, storage occurs every that many iterations.

  • proximity_measures (Optional[List]) – The proximity measures to calculate, by default None. Right now only the first in the list is used to check the feasibility.

  • alternative_stopping_criterion (Optional[Callable]) – Alternative stopping criterion.

  • alternative_stopping_criterion_initial_call (Optional[Callable]) – Initial call for an alternative stopping criterion.

Return type:

ndarray

Returns:

The solution after applying the feasibility seeking algorithm.

step(x, y=None)#

Perform the (possibly relaxed) projection of input array ‘x’ onto the constraint.

Parameters:

x (ndarray[tuple[Any, ...], dtype[TypeVar(_ScalarT, bound= generic)]]) – The input array to be projected.

Return type:

tuple

Returns:

The (possibly relaxed) projection of ‘x’ onto the constraint.