# scipy.sparse.linalg.LinearOperator

class scipy.sparse.linalg.LinearOperator(*args, **kwargs)

  Common interface for performing matrix vector products

  Many iterative methods (e.g. cg, gmres) do not need to know the individual entries of a matrix to solve a linear system A*x=b. Such solvers only require the computation of matrix vector products, A*v where v is a dense vector. This class serves as an abstract interface between iterative solvers and matrix-like objects.

  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 tuple

      Matrix dimensions (M, N).

    matvec callable f(v)

      Returns returns A * v.

    rmatvec callable f(v)

      Returns A^H * v, where A^H is the conjugate transpose of A.

    matmat callable f(V)

      Returns A * V, where V is a dense matrix with dimensions (N, K).

    dtype dtype

      Data type of the matrix.

    rmatmat callable f(V)

      Returns A^H * V, where V is a dense matrix with dimensions (M, K).

  See also

  `aslinearoperator`

    Construct LinearOperators

  Notes

  The user-defined matvec() function must properly handle the case where v has shape (N,) as well as the (N,1) case. The shape of the return type is handled internally by LinearOperator.

  LinearOperator instances can also be multiplied, added with each other and exponentiated, all lazily: the result of these operations is always a new, composite LinearOperator, that defers linear operations to the original operators and combines the results.

  More details regarding how to subclass a LinearOperator and several examples of concrete LinearOperator instances can be found in the external project PyLops.

  Examples

      >>> import numpy as np
      >>> from scipy.sparse.linalg import LinearOperator
      >>> def mv(v):
      ...     return np.array([2*v[0], 3*v[1]])
      ...
      >>> A = LinearOperator((2,2), matvec=mv)
      >>> A
      <2x2 _CustomLinearOperator with dtype=float64>
      >>> A.matvec(np.ones(2))
      array([ 2.,  3.])
      >>> A * np.ones(2)
      array([ 2.,  3.])

  Attributes:
    args tuple

      For linear operators describing products etc. of other linear operators, the operands of the binary operation.

    ndim int

      Number of dimensions (this is always 2)

  Methods

  `__call__`(x) | Call self as a function.
  `adjoint`() | Hermitian adjoint.
  `dot`(x) | Matrix-matrix or matrix-vector multiplication.
  `matmat`(X) | Matrix-matrix multiplication.
  `matvec`(x) | Matrix-vector multiplication.
  `rmatmat`(X) | Adjoint matrix-matrix multiplication.
  `rmatvec`(x) | Adjoint matrix-vector multiplication.
  `transpose`() | Transpose this linear operator.

  __mul__ |