mrpro.operators.ZeroOp

class mrpro.operators.ZeroOp[source]

Bases: LinearOperator

A constant zero operator.

This operator always returns zero when applied to a tensor. It is the neutral element of the addition of operators.

__init__(keep_shape: bool = False)[source]

Initialize the Zero Operator.

Returns a constant zero, either as a scalar or as a tensor of the same shape as the input, depending on the value of keep_shape. Returning a scalar can save memory and computation time in some cases.

Parameters:

keep_shape (bool, default: False) – If True, the shape of the input is kept. If False, the output is, regardless of the input shape, an integer scalar 0, which can broadcast to the input shape and dtype.

property H: LinearOperator[source]

Adjoint of the Zero Operator.

property gram: LinearOperator[source]

Gram operator.

For a LinearOperator \(A\), the self-adjoint Gram operator is defined as \(A^H A\).

Note

This is the inherited default implementation.

__call__(x: Tensor) → tuple[Tensor][source]

Apply the zero operator to the input tensor.

This operator returns a tensor of zeros. Depending on the keep_shape attribute set during initialization, the output will either be a tensor of zeros with the same shape as the input x, or a scalar zero.

Parameters:

x (Tensor) – Input tensor.

Returns:

• A tensor of zeros. This will be torch.zeros_like(x) if keep_shape is True, or torch.tensor(0) if keep_shape is False.

• .. note:: – Prefer calling the instance of the ZeroOp operator as operator(x) over directly calling this method. See this PyTorch discussion.

adjoint(x: Tensor) → tuple[Tensor][source]

Apply the adjoint of the zero operator.

Since the zero operator is self-adjoint (mapping everything to zero), this method behaves identically to the forward operation. It returns a tensor of zeros, either with the same shape as input x or as a scalar zero, depending on keep_shape.

Parameters:

x (Tensor) – Input tensor.

Returns:

A tensor of zeros. This will be torch.zeros_like(x) if keep_shape is True, or torch.tensor(0) if keep_shape is False.

forward(x: Tensor) → tuple[Tensor][source]

Apply forward of ZeroOp.

Note

Prefer calling the instance of the ZeroOp operator as operator(x) over directly calling this method. See this PyTorch discussion.

operator_norm(initial_value: Tensor, dim: Sequence[int] | None, max_iterations: int = 20, relative_tolerance: float = 1e-4, absolute_tolerance: float = 1e-5, callback: Callable[[Tensor], None] | None = None) → Tensor[source]

Power iteration for computing the operator norm of the operator.

Parameters:

• initial_value (Tensor) – initial value to start the iteration; must be element of the domain. if the initial value contains a zero-vector for one of the considered problems, the function throws an ValueError.

• dim (Sequence[int] | None) –

  The dimensions of the tensors on which the operator operates. The choice of dim determines how the operator norm is inperpreted. For example, for a matrix-vector multiplication with a batched matrix tensor of shape (batch1, batch2, row, column) and a batched input tensor of shape (batch1, batch2, row):

  • If dim=None, the operator is considered as a block diagonal matrix with batch1*batch2 blocks and the result is a tensor containing a single norm value (shape (1, 1, 1)).

  • If dim=(-1), batch1*batch2 matrices are considered, and for each a separate operator norm is computed.

  • If dim=(-2,-1), batch1 matrices with batch2 blocks are considered, and for each matrix a separate operator norm is computed.

  Thus, the choice of dim determines implicitly determines the domain of the operator.

• max_iterations (int, default: 20) – maximum number of iterations

• relative_tolerance (float, default: 1e-4) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.

• absolute_tolerance (float, default: 1e-5) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.

• callback (Callable[[Tensor], None] | None, default: None) – user-provided function to be called at each iteration

Returns:

An estimaton of the operator norm. Shape corresponds to the shape of the input tensor initial_value with the dimensions specified in dim reduced to a single value. The pointwise multiplication of initial_value with the result of the operator norm will always be well-defined.

__add__(other: LinearOperator | Tensor | complex) → LinearOperator[source]

__add__(other: Operator[Tensor, tuple[Tensor]]) → Operator[Tensor, tuple[Tensor]]

Operator addition.

Returns lambda x: self(x) + other(x) if other is a operator, lambda x: self(x) + other if other is a tensor

__and__(other: LinearOperator) → LinearOperatorMatrix[source]

Vertical stacking of two LinearOperators.

A&B is a LinearOperatorMatrix with two rows, with (A&B)(x) == (A(x), B(x)). See mrpro.operators.LinearOperatorMatrix for more information.

__matmul__(other: LinearOperator) → LinearOperator[source]

__matmul__(other: Operator[Unpack[Tin2], tuple[Tensor]] | Operator[Unpack[Tin2], tuple[Tensor, ...]]) → Operator[Unpack[Tin2], tuple[Tensor]]

Operator composition.

Returns lambda x: self(other(x))

__mul__(other: Tensor | complex) → LinearOperator[source]

Operator elementwise left multiplication with tensor/scalar.

Returns lambda x: self(x*other)

__or__(other: LinearOperator) → LinearOperatorMatrix[source]

Horizontal stacking of two LinearOperators.

A|B is a LinearOperatorMatrix with two columns, with (A|B)(x1,x2) == A(x1) + B(x2). See mrpro.operators.LinearOperatorMatrix for more information.

__radd__(other: Tensor | complex) → LinearOperator[source]

Operator addition.

Returns lambda x: self(x) + other*x

__rmul__(other: Tensor | complex) → LinearOperator[source]

Operator elementwise right multiplication with tensor/scalar.

Returns lambda x: other*self(x)