Struct UnitCallable 

pub struct UnitCallable<M: Matrix> { /* private fields */ }

A dummy operator that returns the input vector. Can be used either as a NonLinearOp or LinearOp.

Implementations

impl<M: Matrix> UnitCallable<M>

pub fn new(n: usize, ctx: M::C) -> Self

Trait Implementations

impl<M: Matrix> BuilderOp for UnitCallable<M>

fn calculate_sparsity(&mut self, _y0: &Self::V, _t0: Self::T, _p: &Self::V)

fn set_nout(&mut self, nout: usize)

fn set_nparams(&mut self, _nparams: usize)

fn set_nstates(&mut self, nstates: usize)

impl<M: Matrix> Default for UnitCallable<M>

fn default() -> Self

Returns the “default value” for a type.

impl<M: Matrix> LinearOp for UnitCallable<M>

fn gemv_inplace(&self, x: &Self::V, _t: Self::T, beta: Self::T, y: &mut Self::V)

Compute the operator via a GEMV operation (i.e. y = A(t) * x + beta * y)

fn call_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::V)

Compute the operator y = A(t) * x at a given state and time, the default implementation uses Self::gemv_inplace.

fn matrix(&self, t: Self::T) -> Self::M

Compute the matrix representation of the operator A(t) and return it. See Self::matrix_inplace for a non-allocating version.

fn matrix_inplace(&self, t: Self::T, y: &mut Self::M)

Compute the matrix representation of the operator A(t) and store it in the matrix y. The default implementation of this method computes the matrix using Self::gemv_inplace, but it can be overriden for more efficient implementations.

fn _default_matrix_inplace(&self, t: Self::T, y: &mut Self::M)

Default implementation of the matrix computation, see Self::matrix_inplace.

fn sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

impl<M: Matrix> LinearOpSens for UnitCallable<M>

fn sens_mul_inplace( &self, _x: &Self::V, _t: Self::T, _v: &Self::V, y: &mut Self::V, )

Compute the product of the gradient of F wrt a parameter vector p with a given vector J_p(t) * x * v. Note that the vector v is of size nparams() and the result is of size nstates(). Default implementation returns zero and panics if nparams() is not zero.

fn sens_mul(&self, x: &Self::V, t: Self::T, v: &Self::V) -> Self::V

Compute the product of the partial gradient of F wrt a parameter vector p with a given vector \parial F/\partial p(x, t) * v, and return the result. Use [Self::sens_mul_inplace] to for a non-allocating version.

fn sens_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the gradient of the operator wrt a parameter vector p and store it in the matrix y. y should have been previously initialised using the output of Self::sens_sparsity. The default implementation of this method computes the gradient using Self::sens_mul_inplace, but it can be overriden for more efficient implementations.

fn _default_sens_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Default implementation of the gradient computation (this is the default for Self::sens_inplace).

fn sens(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the gradient of the operator wrt a parameter vector p and return it. See Self::sens_inplace for a non-allocating version.

fn sens_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

impl<M: Matrix> LinearOpTranspose for UnitCallable<M>

fn gemv_transpose_inplace( &self, x: &Self::V, _t: Self::T, beta: Self::T, y: &mut Self::V, )

Compute the transpose of the operator via a GEMV operation (i.e. y = A(t)^T * x + beta * y)

fn call_transpose_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::V)

Compute the transpose of the operator y = A(t)^T * x at a given state and time, the default implementation uses Self::gemv_transpose_inplace.

fn transpose_inplace(&self, t: Self::T, y: &mut Self::M)

Compute the matrix representation of the transpose of the operator A(t)^T and store it in the matrix y. The default implementation of this method computes the matrix using Self::gemv_transpose_inplace, but it can be overriden for more efficient implementations.

fn _default_transpose_inplace(&self, t: Self::T, y: &mut Self::M)

Default implementation of the tranpose computation, see Self::transpose_inplace.

fn transpose_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

impl<M: Matrix> NonLinearOp for UnitCallable<M>

fn call_inplace(&self, x: &Self::V, _t: Self::T, y: &mut Self::V)

Compute the operator F(x, t) at a given state and time.

fn call(&self, x: &Self::V, t: Self::T) -> Self::V

Compute the operator F(x, t) at a given state and time, and return the result. Use [Self::call_inplace] to for a non-allocating version.

impl<M: Matrix> NonLinearOpAdjoint for UnitCallable<M>

fn jac_transpose_mul_inplace( &self, _x: &Self::V, _t: Self::T, v: &Self::V, y: &mut Self::V, )

Compute the product of the transpose of the Jacobian with a given vector -J(x, t)^T * v. The default implementation fails with a panic, as this method is not implemented by default and should be implemented by the user if needed.

fn adjoint_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the Adjoint matrix -J^T(x, t) of the operator and store it in the matrix y. y should have been previously initialised using the output of Self::adjoint_sparsity. The default implementation of this method computes the Jacobian using Self::jac_transpose_mul_inplace, but it can be overriden for more efficient implementations.

fn _default_adjoint_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Default implementation of the Adjoint computation (this is the default for Self::adjoint_inplace).

fn adjoint(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the Adjoint matrix -J^T(x, t) of the operator and return it. See Self::adjoint_inplace for a non-allocating version.

fn adjoint_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

impl<M: Matrix> NonLinearOpJacobian for UnitCallable<M>

fn jac_mul_inplace( &self, _x: &Self::V, _t: Self::T, v: &Self::V, y: &mut Self::V, )

Compute the product of the Jacobian with a given vector J(x, t) * v.

fn jac_mul(&self, x: &Self::V, t: Self::T, v: &Self::V) -> Self::V

Compute the product of the Jacobian with a given vector J(x, t) * v, and return the result. Use [Self::jac_mul_inplace] to for a non-allocating version.

fn jacobian(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the Jacobian matrix J(x, t) of the operator and return it. See Self::jacobian_inplace for a non-allocating version.

fn jacobian_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

fn jacobian_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the Jacobian matrix J(x, t) of the operator and store it in the matrix y. y should have been previously initialised using the output of Self::jacobian_sparsity. The default implementation of this method computes the Jacobian using Self::jac_mul_inplace, but it can be overriden for more efficient implementations.

fn _default_jacobian_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Default implementation of the Jacobian computation (this is the default for Self::jacobian_inplace).

impl<M: Matrix> NonLinearOpSens for UnitCallable<M>

fn sens_mul_inplace( &self, _x: &Self::V, _t: Self::T, _v: &Self::V, y: &mut Self::V, )

Compute the product of the gradient of F wrt a parameter vector p with a given vector J_p(x, t) * v. Note that the vector v is of size nparams() and the result is of size nstates().

fn sens_mul(&self, x: &Self::V, t: Self::T, v: &Self::V) -> Self::V

Compute the product of the partial gradient of F wrt a parameter vector p with a given vector \parial F/\partial p(x, t) * v, and return the result. Use [Self::sens_mul_inplace] to for a non-allocating version.

fn sens_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the gradient of the operator wrt a parameter vector p and store it in the matrix y. y should have been previously initialised using the output of Self::sens_sparsity. The default implementation of this method computes the gradient using Self::sens_mul_inplace, but it can be overriden for more efficient implementations.

fn _default_sens_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Default implementation of the gradient computation (this is the default for Self::sens_inplace).

fn sens(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the gradient of the operator wrt a parameter vector p and return it. See Self::sens_inplace for a non-allocating version.

fn sens_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

impl<M: Matrix> NonLinearOpSensAdjoint for UnitCallable<M>

fn sens_transpose_mul_inplace( &self, _x: &Self::V, _t: Self::T, _v: &Self::V, y: &mut Self::V, )

Compute the product of the negative tramspose of the gradient of F wrt a parameter vector p with a given vector -J_p(x, t)^T * v.

fn sens_adjoint(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the negative transpose of the gradient of the operator wrt a parameter vector p and return it. See Self::sens_adjoint_inplace for a non-allocating version.

fn sens_adjoint_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the negative transpose of the gradient of the operator wrt a parameter vector p and store it in the matrix y. y should have been previously initialised using the output of Self::sens_adjoint_sparsity. The default implementation of this method computes the gradient using Self::sens_transpose_mul_inplace, but it can be overriden for more efficient implementations.

fn _default_sens_adjoint_inplace( &self, x: &Self::V, t: Self::T, y: &mut Self::M, )

Default implementation of the gradient computation (this is the default for Self::sens_adjoint_inplace).

fn sens_adjoint_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

impl<M: Matrix> Op for UnitCallable<M>

type T = <M as MatrixCommon>::T

type V = <M as MatrixCommon>::V

type M = M

type C = <M as MatrixCommon>::C

fn nstates(&self) -> usize

Return the number of input states of the operator.

fn nout(&self) -> usize

Return the number of outputs of the operator.

fn nparams(&self) -> usize

Return the number of parameters of the operator.

fn context(&self) -> &Self::C

return the context of the operator

fn statistics(&self) -> OpStatistics

Return statistics about the operator (e.g. how many times it was called, how many times the jacobian was computed, etc.)