# tf.linalg.LinearOperator

<br />

|---|
| [![](https://www.tensorflow.org/images/GitHub-Mark-32px.png) View source on GitHub](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L55-L1197) |

Base class defining a \[batch of\] linear operator\[s\].

Inherits From: [`Module`](https://www.tensorflow.org/versions/r2.7/api_docs/python/tf/Module)

#### View aliases


**Compat aliases for migration**

See
[Migration guide](https://www.tensorflow.org/guide/migrate) for
more details.

[`tf.compat.v1.linalg.LinearOperator`](https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperator)

<br />

    tf.linalg.LinearOperator(
        dtype,
        graph_parents=None,
        is_non_singular=None,
        is_self_adjoint=None,
        is_positive_definite=None,
        is_square=None,
        name=None,
        parameters=None
    )

Subclasses of `LinearOperator` provide access to common methods on a
(batch) matrix, without the need to materialize the matrix. This allows:

- Matrix free computations
- Operators that take advantage of special structure, while providing a consistent API to users.

#### Subclassing

To enable a public method, subclasses should implement the leading-underscore
version of the method. The argument signature should be identical except for
the omission of `name="..."`. For example, to enable
`matmul(x, adjoint=False, name="matmul")` a subclass should implement
`_matmul(x, adjoint=False)`.

#### Performance contract

Subclasses should only implement the assert methods
(e.g. `assert_non_singular`) if they can be done in less than `O(N^3)`
time.

Class docstrings should contain an explanation of computational complexity.
Since this is a high-performance library, attention should be paid to detail,
and explanations can include constants as well as Big-O notation.

#### Shape compatibility

`LinearOperator` subclasses should operate on a \[batch\] matrix with
compatible shape. Class docstrings should define what is meant by compatible
shape. Some subclasses may not support batching.

#### Examples:

`x` is a batch matrix with compatible shape for `matmul` if

    operator.shape = [B1,...,Bb] + [M, N],  b >= 0,
    x.shape =   [B1,...,Bb] + [N, R]

`rhs` is a batch matrix with compatible shape for `solve` if

    operator.shape = [B1,...,Bb] + [M, N],  b >= 0,
    rhs.shape =   [B1,...,Bb] + [M, R]

#### Example docstring for subclasses.

This operator acts like a (batch) matrix `A` with shape
`[B1,...,Bb, M, N]` for some `b >= 0`. The first `b` indices index a
batch member. For every batch index `(i1,...,ib)`, `A[i1,...,ib, : :]` is
an `m x n` matrix. Again, this matrix `A` may not be materialized, but for
purposes of identifying and working with compatible arguments the shape is
relevant.

#### Examples:

    some_tensor = ... shape = ????
    operator = MyLinOp(some_tensor)

    operator.shape()
    ==> [2, 4, 4]

    operator.log_abs_determinant()
    ==> Shape [2] Tensor

    x = ... Shape [2, 4, 5] Tensor

    operator.matmul(x)
    ==> Shape [2, 4, 5] Tensor

#### Shape compatibility

This operator acts on batch matrices with compatible shape.
FILL IN WHAT IS MEANT BY COMPATIBLE SHAPE

#### Performance

FILL THIS IN

#### Matrix property hints

This `LinearOperator` is initialized with boolean flags of the form `is_X`,
for `X = non_singular, self_adjoint, positive_definite, square`.
These have the following meaning:

- If `is_X == True`, callers should expect the operator to have the property `X`. This is a promise that should be fulfilled, but is *not* a runtime assert. For example, finite floating point precision may result in these promises being violated.
- If `is_X == False`, callers should expect the operator to not have `X`.
- If `is_X == None` (the default), callers should have no expectation either way.

#### Initialization parameters

All subclasses of `LinearOperator` are expected to pass a `parameters`
argument to `super().__init__()`. This should be a `dict` containing
the unadulterated arguments passed to the subclass `__init__`. For example,
`MyLinearOperator` with an initializer should look like:

    def __init__(self, operator, is_square=False, name=None):
       parameters = dict(
           operator=operator,
           is_square=is_square,
           name=name
       )
       ...
       super().__init__(..., parameters=parameters)
     ```

     Users can then access `my_linear_operator.parameters` to see all arguments
     passed to its initializer.

    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2"><h2 class="add-link">Args</h2></th></tr>

    <tr>
    <td>
    `dtype`<a id="dtype"></a>
    </td>
    <td>
    The type of the this `LinearOperator`.  Arguments to `matmul` and
    `solve` will have to be this type.
    </td>
    </tr><tr>
    <td>
    `graph_parents`<a id="graph_parents"></a>
    </td>
    <td>
    (Deprecated) Python list of graph prerequisites of this
    `LinearOperator` Typically tensors that are passed during initialization
    </td>
    </tr><tr>
    <td>
    `is_non_singular`<a id="is_non_singular"></a>
    </td>
    <td>
     Expect that this operator is non-singular.
    </td>
    </tr><tr>
    <td>
    `is_self_adjoint`<a id="is_self_adjoint"></a>
    </td>
    <td>
     Expect that this operator is equal to its hermitian
    transpose.  If `dtype` is real, this is equivalent to being symmetric.
    </td>
    </tr><tr>
    <td>
    `is_positive_definite`<a id="is_positive_definite"></a>
    </td>
    <td>
     Expect that this operator is positive definite,
    meaning the quadratic form `x^H A x` has positive real part for all
    nonzero `x`.  Note that we do not require the operator to be
    self-adjoint to be positive-definite.  See:
    https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices
    </td>
    </tr><tr>
    <td>
    `is_square`<a id="is_square"></a>
    </td>
    <td>
     Expect that this operator acts like square [batch] matrices.
    </td>
    </tr><tr>
    <td>
    `name`<a id="name"></a>
    </td>
    <td>
    A name for this `LinearOperator`.
    </td>
    </tr><tr>
    <td>
    `parameters`<a id="parameters"></a>
    </td>
    <td>
    Python `dict` of parameters used to instantiate this
    `LinearOperator`.
    </td>
    </tr>
    </table>



    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2"><h2 class="add-link">Raises</h2></th></tr>

    <tr>
    <td>
    `ValueError`<a id="ValueError"></a>
    </td>
    <td>
     If any member of graph_parents is `None` or not a `Tensor`.
    </td>
    </tr><tr>
    <td>
    `ValueError`<a id="ValueError"></a>
    </td>
    <td>
     If hints are set incorrectly.
    </td>
    </tr>
    </table>





    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2"><h2 class="add-link">Attributes</h2></th></tr>

    <tr>
    <td>
    `H`<a id="H"></a>
    </td>
    <td>
    Returns the adjoint of the current `LinearOperator`.

    Given `A` representing this `LinearOperator`, return `A*`.
    Note that calling `self.adjoint()` and `self.H` are equivalent.
    </td>
    </tr><tr>
    <td>
    `batch_shape`<a id="batch_shape"></a>
    </td>
    <td>
    `TensorShape` of batch dimensions of this `LinearOperator`.

    If this operator acts like the batch matrix `A` with
    `A.shape = [B1,...,Bb, M, N]`, then this returns
    `TensorShape([B1,...,Bb])`, equivalent to `A.shape[:-2]`
    </td>
    </tr><tr>
    <td>
    `domain_dimension`<a id="domain_dimension"></a>
    </td>
    <td>
    Dimension (in the sense of vector spaces) of the domain of this operator.

    If this operator acts like the batch matrix `A` with
    `A.shape = [B1,...,Bb, M, N]`, then this returns `N`.
    </td>
    </tr><tr>
    <td>
    `dtype`<a id="dtype"></a>
    </td>
    <td>
    The `DType` of `Tensor`s handled by this `LinearOperator`.
    </td>
    </tr><tr>
    <td>
    `graph_parents`<a id="graph_parents"></a>
    </td>
    <td>
    List of graph dependencies of this `LinearOperator`. (deprecated)

    Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.
    Instructions for updating:
    Do not call `graph_parents`.
    </td>
    </tr><tr>
    <td>
    `is_non_singular`<a id="is_non_singular"></a>
    </td>
    <td>

    </td>
    </tr><tr>
    <td>
    `is_positive_definite`<a id="is_positive_definite"></a>
    </td>
    <td>

    </td>
    </tr><tr>
    <td>
    `is_self_adjoint`<a id="is_self_adjoint"></a>
    </td>
    <td>

    </td>
    </tr><tr>
    <td>
    `is_square`<a id="is_square"></a>
    </td>
    <td>
    Return `True/False` depending on if this operator is square.
    </td>
    </tr><tr>
    <td>
    `parameters`<a id="parameters"></a>
    </td>
    <td>
    Dictionary of parameters used to instantiate this `LinearOperator`.
    </td>
    </tr><tr>
    <td>
    `range_dimension`<a id="range_dimension"></a>
    </td>
    <td>
    Dimension (in the sense of vector spaces) of the range of this operator.

    If this operator acts like the batch matrix `A` with
    `A.shape = [B1,...,Bb, M, N]`, then this returns `M`.
    </td>
    </tr><tr>
    <td>
    `shape`<a id="shape"></a>
    </td>
    <td>
    `TensorShape` of this `LinearOperator`.

    If this operator acts like the batch matrix `A` with
    `A.shape = [B1,...,Bb, M, N]`, then this returns
    `TensorShape([B1,...,Bb, M, N])`, equivalent to `A.shape`.
    </td>
    </tr><tr>
    <td>
    `tensor_rank`<a id="tensor_rank"></a>
    </td>
    <td>
    Rank (in the sense of tensors) of matrix corresponding to this operator.

    If this operator acts like the batch matrix `A` with
    `A.shape = [B1,...,Bb, M, N]`, then this returns `b + 2`.
    </td>
    </tr>
    </table>



    ## Methods

    <h3 id="add_to_tensor"><code>add_to_tensor</code></h3>

    <a target="_blank" class="external" href="https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1084-L1097">View source</a>

    <pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
    <code>add_to_tensor(
        x, name=&#x27;add_to_tensor&#x27;
    )
    </code></pre>

    Add matrix represented by this operator to `x`.  Equivalent to `A + x`.


    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2">Args</th></tr>

    <tr>
    <td>
    `x`
    </td>
    <td>
     `Tensor` with same `dtype` and shape broadcastable to `self.shape`.
    </td>
    </tr><tr>
    <td>
    `name`
    </td>
    <td>
     A name to give this `Op`.
    </td>
    </tr>
    </table>



    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2">Returns</th></tr>
    <tr class="alt">
    <td colspan="2">
    A `Tensor` with broadcast shape and same `dtype` as `self`.
    </td>
    </tr>

    </table>



    <h3 id="adjoint"><code>adjoint</code></h3>

    <a target="_blank" class="external" href="https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L940-L955">View source</a>

    <pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
    <code>adjoint(
        name=&#x27;adjoint&#x27;
    )
    </code></pre>

    Returns the adjoint of the current `LinearOperator`.

    Given `A` representing this `LinearOperator`, return `A*`.
    Note that calling `self.adjoint()` and `self.H` are equivalent.

    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2">Args</th></tr>

    <tr>
    <td>
    `name`
    </td>
    <td>
     A name for this `Op`.
    </td>
    </tr>
    </table>



    <!-- Tabular view -->
     <table class="responsive fixed orange">
    <colgroup><col width="214px"><col></colgroup>
    <tr><th colspan="2">Returns</th></tr>
    <tr class="alt">
    <td colspan="2">
    `LinearOperator` which represents the adjoint of this `LinearOperator`.
    </td>
    </tr>

    </table>



    <h3 id="assert_non_singular"><code>assert_non_singular</code></h3>

    <a target="_blank" class="external" href="https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L548-L566">View source</a>

    <pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
    <code>assert_non_singular(
        name=&#x27;assert_non_singular&#x27;
    )
    </code></pre>

    Returns an `Op` that asserts this operator is non singular.

    This operator is considered non-singular if

ConditionNumber \< max{100, range_dimension, domain_dimension} \* eps,
eps := np.finfo(self.dtype.as_numpy_dtype).eps
\`\`\`

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A string name to prepend to created ops. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is singular. ||

<br />

### `assert_positive_definite`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L584-L599)

    assert_positive_definite(
        name='assert_positive_definite'
    )

Returns an `Op` that asserts this operator is positive definite.

Here, positive definite means that the quadratic form `x^H A x` has positive
real part for all nonzero `x`. Note that we do not require the operator to
be self-adjoint to be positive definite.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name to give this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not positive definite. ||

<br />

### `assert_self_adjoint`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L611-L625)

    assert_self_adjoint(
        name='assert_self_adjoint'
    )

Returns an `Op` that asserts this operator is self-adjoint.

Here we check that this operator is *exactly* equal to its hermitian
transpose.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A string name to prepend to created ops. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not self-adjoint. ||

<br />

### `batch_shape_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L362-L377)

    batch_shape_tensor(
        name='batch_shape_tensor'
    )

Shape of batch dimensions of this operator, determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns a `Tensor` holding
`[B1,...,Bb]`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `cholesky`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L985-L1008)

    cholesky(
        name='cholesky'
    )

Returns a Cholesky factor as a `LinearOperator`.

Given `A` representing this `LinearOperator`, if `A` is positive definite
self-adjoint, return `L`, where `A = L L^T`, i.e. the cholesky
decomposition.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `LinearOperator` which represents the lower triangular matrix in the Cholesky decomposition. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `ValueError` | When the `LinearOperator` is not hinted to be positive definite and self adjoint. |

<br />

### `cond`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1134-L1144)

    cond(
        name='cond'
    )

Returns the condition number of this linear operator.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. ||

<br />

### `determinant`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L744-L761)

    determinant(
        name='det'
    )

Determinant for every batch member.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_square` is `False`. |

<br />

### `diag_part`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1035-L1061)

    diag_part(
        name='diag_part'
    )

Efficiently get the \[batch\] diagonal part of this operator.

If this operator has shape `[B1,...,Bb, M, N]`, this returns a
`Tensor` `diagonal`, of shape `[B1,...,Bb, min(M, N)]`, where
`diagonal[b1,...,bb, i] = self.to_dense()[b1,...,bb, i, i]`.

    my_operator = LinearOperatorDiag([1., 2.])

    # Efficiently get the diagonal
    my_operator.diag_part()
    ==> [1., 2.]

    # Equivalent, but inefficient method
    tf.linalg.diag_part(my_operator.to_dense())
    ==> [1., 2.]

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `diag_part` | A `Tensor` of same `dtype` as self. |

<br />

### `domain_dimension_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L447-L463)

    domain_dimension_tensor(
        name='domain_dimension_tensor'
    )

Dimension (in the sense of vector spaces) of the domain of this operator.

Determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `N`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `eigvals`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1102-L1119)

    eigvals(
        name='eigvals'
    )

Returns the eigenvalues of this linear operator.

If the operator is marked as self-adjoint (via `is_self_adjoint`)
this computation can be more efficient.

> [!NOTE]
> **Note:** This currently only supports self-adjoint operators.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb, N]` `Tensor` of same `dtype` as `self`. ||

<br />

### `inverse`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L960-L983)

    inverse(
        name='inverse'
    )

Returns the Inverse of this `LinearOperator`.

Given `A` representing this `LinearOperator`, return a `LinearOperator`
representing `A^-1`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `LinearOperator` representing inverse of this matrix. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `ValueError` | When the `LinearOperator` is not hinted to be `non_singular`. |

<br />

### `log_abs_determinant`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L773-L790)

    log_abs_determinant(
        name='log_abs_det'
    )

Log absolute value of determinant for every batch member.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_square` is `False`. |

<br />

### `matmul`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L638-L691)

    matmul(
        x, adjoint=False, adjoint_arg=False, name='matmul'
    )

Transform \[batch\] matrix `x` with left multiplication: `x --> Ax`.

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    X = ... # shape [..., N, R], batch matrix, R > 0.

    Y = operator.matmul(X)
    Y.shape
    ==> [..., M, R]

    Y[..., :, r] = sum_j A[..., :, j] X[j, r]

<br />

<br />

<br />

| Args ||
|---|---|
| `x` | `LinearOperator` or `Tensor` with compatible shape and same `dtype` as `self`. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. |
| `adjoint_arg` | Python `bool`. If `True`, compute `A x^H` where `x^H` is the hermitian transpose (transposition and complex conjugation). |
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `LinearOperator` or `Tensor` with shape `[..., M, R]` and same `dtype` as `self`. ||

<br />

### `matvec`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L701-L734)

    matvec(
        x, adjoint=False, name='matvec'
    )

Transform \[batch\] vector `x` with left multiplication: `x --> Ax`.

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)

    X = ... # shape [..., N], batch vector

    Y = operator.matvec(X)
    Y.shape
    ==> [..., M]

    Y[..., :] = sum_j A[..., :, j] X[..., j]

<br />

<br />

<br />

| Args ||
|---|---|
| `x` | `Tensor` with compatible shape and same `dtype` as `self`. `x` is treated as a \[batch\] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. |
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `Tensor` with shape `[..., M]` and same `dtype` as `self`. ||

<br />

### `range_dimension_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L491-L507)

    range_dimension_tensor(
        name='range_dimension_tensor'
    )

Dimension (in the sense of vector spaces) of the range of this operator.

Determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `M`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `shape_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L328-L346)

    shape_tensor(
        name='shape_tensor'
    )

Shape of this `LinearOperator`, determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns a `Tensor` holding
`[B1,...,Bb, M, N]`, equivalent to [`tf.shape(A)`](https://www.tensorflow.org/versions/r2.7/api_docs/python/tf/shape).

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `solve`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L811-L884)

    solve(
        rhs, adjoint=False, adjoint_arg=False, name='solve'
    )

Solve (exact or approx) `R` (batch) systems of equations: `A X = rhs`.

The returned `Tensor` will be close to an exact solution if `A` is well
conditioned. Otherwise closeness will vary. See class docstring for details.

#### Examples:

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    # Solve R > 0 linear systems for every member of the batch.
    RHS = ... # shape [..., M, R]

    X = operator.solve(RHS)
    # X[..., :, r] is the solution to the r'th linear system
    # sum_j A[..., :, j] X[..., j, r] = RHS[..., :, r]

    operator.matmul(X)
    ==> RHS

<br />

<br />

<br />

| Args ||
|---|---|
| `rhs` | `Tensor` with same `dtype` as this operator and compatible shape. `rhs` is treated like a \[batch\] matrix meaning for every set of leading dimensions, the last two dimensions defines a matrix. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. |
| `adjoint_arg` | Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation). |
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_non_singular` or `is_square` is False. |

<br />

### `solvevec`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L892-L938)

    solvevec(
        rhs, adjoint=False, name='solve'
    )

Solve single equation with best effort: `A X = rhs`.

The returned `Tensor` will be close to an exact solution if `A` is well
conditioned. Otherwise closeness will vary. See class docstring for details.

#### Examples:

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    # Solve one linear system for every member of the batch.
    RHS = ... # shape [..., M]

    X = operator.solvevec(RHS)
    # X is the solution to the linear system
    # sum_j A[..., :, j] X[..., j] = RHS[..., :]

    operator.matvec(X)
    ==> RHS

<br />

<br />

<br />

| Args ||
|---|---|
| `rhs` | `Tensor` with same `dtype` as this operator. `rhs` is treated like a \[batch\] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility regarding batch dimensions. |
| `adjoint` | Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. |
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `[...,N]` and same `dtype` as `rhs`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_non_singular` or `is_square` is False. |

<br />

### `tensor_rank_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L406-L420)

    tensor_rank_tensor(
        name='tensor_rank_tensor'
    )

Rank (in the sense of tensors) of matrix corresponding to this operator.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `b + 2`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor`, determined at runtime. ||

<br />

### `to_dense`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1026-L1029)

    to_dense(
        name='to_dense'
    )

Return a dense (batch) matrix representing this operator.

### `trace`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L1066-L1078)

    trace(
        name='trace'
    )

Trace of the linear operator, equal to sum of `self.diag_part()`.

If the operator is square, this is also the sum of the eigenvalues.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. ||

<br />

### `__matmul__`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.7.4/tensorflow/python/ops/linalg/linear_operator.py#L693-L694)

    __matmul__(
        other
    )