LinearOperator

class probnum.linops.LinearOperator(shape, dtype, *, matmul, rmatmul=None, apply=None, todense=None, transpose=None, inverse=None, rank=None, eigvals=None, cond=None, det=None, logabsdet=None, trace=None)

Bases: object

Composite base class for finite-dimensional linear operators.

This class provides a way to define finite-dimensional linear operators without explicitly constructing a matrix representation. Instead it suffices to define a matrix-vector product and a shape attribute. This avoids unnecessary memory usage and can often be more convenient to derive.

LinearOperator instances can be multiplied, added and exponentiated. This happens lazily: the result of these operations is a new, composite LinearOperator, that defers linear operations to the original operators and combines the results.

To construct a concrete LinearOperator, either pass appropriate callables to the constructor of this class, or subclass it.

A subclass must implement either one of the methods _matvec and _matmat, and the attributes/properties shape (pair of integers) and dtype (may be None). It may call the __init__ on this class to have these attributes validated. Implementing _matvec automatically implements _matmat (using a naive algorithm) and vice-versa.

Optionally, a subclass may implement _rmatvec or _adjoint to implement the Hermitian adjoint (conjugate transpose). As with _matvec and _matmat, implementing either _rmatvec or _adjoint implements the other automatically. Implementing _adjoint is preferable; _rmatvec is mostly there for backwards compatibility.

Parameters

• shape (ShapeLike) – Matrix dimensions (M, N).

• dtype (DTypeLike) – Data type of the operator.

• matmul (Callable[[np.ndarray], np.ndarray]) – Callable which computes the matrix-matrix product \(y = A V\), where \(A\) is the linear operator and \(V\) is an \(N \times K\) matrix. The callable must support broadcasted matrix products, i.e. the argument \(V\) might also be a stack of matrices in which case the broadcasting rules of np.matmul() must apply. Note that the argument to this callable is guaranteed to have at least two dimensions.

• rmatmul (Optional[Callable[[np.ndarray], np.ndarray]]) – Callable which implements the matrix-matrix product, i.e. \(A @ V\), where \(A\) is the linear operator and \(V\) is a matrix of shape (N, K).

• todense (Optional[Callable[[], np.ndarray]]) – Callable which returns a dense matrix representation of the linear operator as a np.ndarray. The output of this function must be equivalent to the output of A.matmat(np.eye(N, dtype=A.dtype)).

• rmatvec – Callable which implements the matrix-vector product with the adjoint of the operator, i.e. \(A^H v\), where \(A^H\) is the conjugate transpose of the linear operator \(A\) and \(v\) is a vector of shape (N,). This argument will be ignored if adjoint is given.

• rmatmat – Returns \(A^H V\), where \(V\) is a dense matrix with dimensions (M, K).

• apply (Callable[[np.ndarray, int], np.ndarray]) –

• transpose (Optional[Callable[[np.ndarray], 'LinearOperator']]) –

• inverse (Optional[Callable[[], 'LinearOperator']]) –

• rank (Optional[Callable[[], np.intp]]) –

• eigvals (Optional[Callable[[], np.ndarray]]) –

• cond (Optional[Callable[[Optional[Union[None, int, str, np.floating]]], np.number]]) –

• det (Optional[Callable[[], np.number]]) –

• logabsdet (Optional[Callable[[], np.flexible]]) –

• trace (Optional[Callable[[], np.number]]) –

See also

aslinop

Transform into a LinearOperator.

Examples

>>> import numpy as np
>>> from probnum.linops import LinearOperator

>>> @LinearOperator.broadcast_matvec
... def mv(v):
...     return np.array([2 * v[0] - v[1], 3 * v[1]])

>>> A = LinearOperator(shape=(2, 2), dtype=np.float_, matmul=mv)
>>> A
<LinearOperator with shape=(2, 2) and dtype=float64>

>>> A @ np.array([1., 2.])
array([0., 6.])
>>> A @ np.ones(2)
array([1., 3.])

Attributes Summary

T
dtype	Data type of the linear operator.
is_lower_triangular	Whether the LinearOperator represents a lower triangular matrix.
is_positive_definite	Whether the LinearOperator \(L \in \mathbb{R}^{n \times n}\) is (strictly) positive-definite, i.e. \(x^T L x > 0\) for \(x \in \mathbb{R}^n\).
is_square	Whether input dimension matches output dimension.
is_symmetric	Whether the LinearOperator \(L\) is symmetric, i.e. \(L = L^T\).
is_upper_triangular	Whether the LinearOperator represents an upper triangular matrix.
ndim	Number of linear operator dimensions.
shape	Shape of the linear operator.
size

Methods Summary

__call__(x[, axis])	Call self as a function.
astype(dtype[, order, casting, subok, copy])	Cast a linear operator to a different dtype.
broadcast_matmat(matmat)	Broadcasting for a (implicitly defined) matrix-matrix product.
broadcast_matvec(matvec)	Broadcasting for a (implicitly defined) matrix-vector product.
broadcast_rmatmat(rmatmat)
broadcast_rmatvec(rmatvec)
cholesky([lower])	Computes a Cholesky decomposition of the LinearOperator.
cond([p])	Compute the condition number of the linear operator.
det()	Determinant of the linear operator.
eigvals()	Eigenvalue spectrum of the linear operator.
inv()	Inverse of the linear operator.
logabsdet()	Log absolute determinant of the linear operator.
rank()	Rank of the linear operator.
symmetrize()	Compute or approximate the closest symmetric LinearOperator in the Frobenius norm.
todense([cache])	Dense matrix representation of the linear operator.
trace()	Trace of the linear operator.
transpose(*axes)	Transpose this linear operator.

Attributes Documentation

T

dtype

Data type of the linear operator.

is_lower_triangular

Whether the LinearOperator represents a lower triangular matrix.

If this is None, it is unknown whether the matrix is lower triangular or not.

is_positive_definite

Whether the LinearOperator \(L \in \mathbb{R}^{n \times n}\) is (strictly) positive-definite, i.e. \(x^T L x > 0\) for \(x \in \mathbb{R}^n\).

If this is None, it is unknown whether the matrix is positive-definite or not. Only symmetric operators can be positive-definite.

is_square

Whether input dimension matches output dimension.

is_symmetric

Whether the LinearOperator \(L\) is symmetric, i.e. \(L = L^T\).

If this is None, it is unknown whether the operator is symmetric or not. Only square operators can be symmetric.

is_upper_triangular

Whether the LinearOperator represents an upper triangular matrix.

If this is None, it is unknown whether the matrix is upper triangular or not.

ndim

Number of linear operator dimensions.

Defined analogously to numpy.ndarray.ndim.

shape

Shape of the linear operator.

Defined as a tuple of the output and input dimension of operator.

size

Methods Documentation

__call__(x, axis=None)

Call self as a function.

Parameters

• x (ndarray) –

• axis (Optional[int]) –

Return type

ndarray

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

Cast a linear operator to a different dtype.

Parameters

• dtype (DTypeLike) – Data type to which the linear operator is cast.

• order (str) – Memory layout order of the result.

• casting (str) – Controls what kind of data casting may occur.

• subok (bool) – If True, then sub-classes will be passed-through (default). False is currently not supported for linear operators.

• copy (bool) – Whether to return a new linear operator, even if dtype is the same.

Return type

LinearOperator

classmethod broadcast_matmat(matmat)

Broadcasting for a (implicitly defined) matrix-matrix product.

Convenience function / decorator to broadcast the definition of a matrix-matrix product to vectors. This can be used to easily construct a new linear operator only from a matrix-matrix product.

Parameters

matmat (Callable[[ndarray], ndarray]) –

Return type

Callable[[ndarray], ndarray]

classmethod broadcast_matvec(matvec)

Broadcasting for a (implicitly defined) matrix-vector product.

Convenience function / decorator to broadcast the definition of a matrix-vector product. This can be used to easily construct a new linear operator only from a matrix-vector product.

Parameters

matvec (Callable[[ndarray], ndarray]) –

Return type

Callable[[ndarray], ndarray]

classmethod broadcast_rmatmat(rmatmat)

Parameters

rmatmat (Callable[[ndarray], ndarray]) –

Return type

Callable[[ndarray], ndarray]

classmethod broadcast_rmatvec(rmatvec)

Parameters

rmatvec (Callable[[ndarray], ndarray]) –

Return type

Callable[[ndarray], ndarray]

cholesky(lower=True)

Computes a Cholesky decomposition of the LinearOperator.

The Cholesky decomposition of a symmetric positive-definite matrix \(A \in \mathbb{R}^{n \times n}\) is given by \(A = L L^T\), where the unique Cholesky factor \(L \in \mathbb{R}^{n \times n}\) of \(A\) is a lower triangular matrix with a positive diagonal.

As a side-effect, this method will set the value of is_positive_definite to True, if the computation of the Cholesky factorization succeeds. Otherwise, is_positive_definite will be set to False.

The result of this computation will be cached. If cholesky() is first called with lower=True first and afterwards with lower=False or vice-versa, the method simply returns the transpose of the cached value.

Parameters

lower (bool) – If this is set to False, this method computes and returns the upper triangular Cholesky factor \(U = L^T\), for which \(A = U^T U\). By default (True), the method computes the lower triangular Cholesky factor \(L\).

Returns

The lower or upper Cholesky factor of the LinearOperator, depending on the value of the parameter lower. The result will have its properties is_upper_triangular/is_lower_triangular set accordingly.

Return type

cholesky_factor

Raises

• numpy.linalg.LinAlgError – If the LinearOperator is not symmetric, i.e. if is_symmetric is not set to True.

• numpy.linalg.LinAlgError – If the LinearOperator is not positive definite.

cond(p=None)

Compute the condition number of the linear operator.

The condition number of the linear operator with respect to the p norm. It measures how much the solution \(x\) of the linear system \(Ax=b\) changes with respect to small changes in \(b\).

Parameters

p ({None, 1, , 2, , inf, 'fro'}, optional) –

Order of the norm:

p	norm for matrices
None	2-norm, computed directly via singular value decomposition
’fro’	Frobenius norm
np.inf	max(sum(abs(x), axis=1))
1	max(sum(abs(x), axis=0))
2	2-norm (largest sing. value)

Returns

The condition number of the linear operator. May be infinite.

Return type

cond

det()

Determinant of the linear operator.

Return type

inexact

eigvals()

Eigenvalue spectrum of the linear operator.

Return type

ndarray

inv()

Inverse of the linear operator.

Return type

LinearOperator

logabsdet()

Log absolute determinant of the linear operator.

Return type

inexact

rank()

Rank of the linear operator.

Return type

int64

symmetrize()

Compute or approximate the closest symmetric LinearOperator in the Frobenius norm.

The closest symmetric matrix to a given square matrix \(A\) in the Frobenius norm is given by

\[\operatorname{sym}(A) := \frac{1}{2} (A + A^T).\]

However, for efficiency reasons, it is preferrable to approximate this operator in some cases. For example, a Kronecker product \(K = A \otimes B\) is more efficiently symmetrized by means of

\begin{equation} \operatorname{sym}(A) \otimes \operatorname{sym}(B) = \operatorname{sym}(K) + \frac{1}{2} \left( \frac{1}{2} \left( A \otimes B^T + A^T \otimes B \right) - \operatorname{sym}(K) \right). \end{equation}

Returns

The closest symmetric LinearOperator in the Frobenius norm, or an approximation, which makes a reasonable trade-off between accuracy and efficiency (see above). The resulting LinearOperator will have its is_symmetric property set to True.

Return type

symmetrized_linop

Raises

numpy.linalg.LinAlgError – If this method is called on a non-square LinearOperator.

todense(cache=True)

Dense matrix representation of the linear operator.

This method can be computationally very costly depending on the shape of the linear operator. Use with caution.

Returns

matrix – Matrix representation of the linear operator.

Return type

np.ndarray

Parameters

cache (bool) –

trace()

Trace of the linear operator.

Computes the trace of a square linear operator \(\text{tr}(A) = \sum_{i-1}^n A_{ii}\).

Returns

trace – Trace of the linear operator.

Return type

float

Raises

LinAlgError : – If trace() is called on a non-square matrix.

transpose(*axes)

Transpose this linear operator.

Can be abbreviated self.T instead of self.transpose().

Parameters

axes (Union[int, Tuple[int]]) –

Return type

LinearOperator