LinearOperator¶

class probnum.linops.LinearOperator(shape, dtype, *, matmul, rmatmul=None, apply=None, todense=None, conjugate=None, transpose=None, adjoint=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 (Union[Integral, Iterable[Integral]]) – Matrix dimensions (M, N).
dtype (Union[dtype, str]) – Data type of the operator.
matmul (Callable[[ndarray], 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[[ndarray], 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[[], 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).

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

`H`	Hermitian adjoint.
`T`	Transposed linear operator.
`dtype`	Data type of the linear operator.
`is_square`	Whether input dimension matches output dimension.
`ndim`	Number of linear operator dimensions.
`shape`	Shape of the linear operator.
`size`	rtype `int`

Methods Summary

`__call__`(x[, axis])	Call self as a function.
`adjoint`()	Hermitian adjoint.
`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)	rtype `Callable`[[`ndarray`], `ndarray`]
`broadcast_rmatvec`(rmatvec)	rtype `Callable`[[`ndarray`], `ndarray`]
`cond`([p])	Compute the condition number of the linear operator.
`conj`()	Complex conjugate linear operator.
`conjugate`()	Complex conjugate 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.
`todense`([cache])	Dense matrix representation of the linear operator.
`trace`()	Trace of the linear operator.
`transpose`()	Transpose this linear operator.

Attributes Documentation

H¶

Hermitian adjoint.

Return type: LinearOperator

T¶

Transposed linear operator.

Return type: LinearOperator

dtype¶

Data type of the linear operator.

Return type: dtype

is_square¶

Whether input dimension matches output dimension.

Return type: bool

ndim¶

Number of linear operator dimensions.

Defined analogously to numpy.ndarray.ndim.

Return type: int

shape¶

Shape of the linear operator.

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

Return type: Tuple[int, int]

size¶

Return type: int

Methods Documentation

__call__(x, axis=None)[source]¶

Call self as a function.

Return type: ndarray

adjoint()[source]¶

Hermitian adjoint.

Return type: LinearOperator

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)[source]¶

Cast a linear operator to a different dtype.

Parameters

dtype (Union[dtype, str]) – 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)[source]¶

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.

Return type: Callable[[ndarray], ndarray]

classmethod broadcast_matvec(matvec)[source]¶

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.

Return type: Callable[[ndarray], ndarray]

classmethod broadcast_rmatmat(rmatmat)[source]¶

Return type: Callable[[ndarray], ndarray]

classmethod broadcast_rmatvec(rmatvec)[source]¶

Return type: Callable[[ndarray], ndarray]

cond(p=None)[source]¶

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