Struct ParameterisedOp

pub struct ParameterisedOp<'a, C: Op> {
    pub op: &'a C,
    pub p: &'a C::V,
}

A wrapper for an operator that parameterises it with a parameter vector.

Fields

op: &'a C

p: &'a C::V

Implementations

impl<'a, C: Op> ParameterisedOp<'a, C>

pub fn new(op: &'a C, p: &'a C::V) -> Self

Trait Implementations

impl<M, I> ConstantOp for ParameterisedOp<'_, ConstantClosure<M, I>>

where M: Matrix, I: Fn(&M::V, M::T, &mut M::V),

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

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

impl<M, I, J> ConstantOp for ParameterisedOp<'_, ConstantClosureWithAdjoint<M, I, J>>

where M: Matrix, I: Fn(&M::V, M::T, &mut M::V), J: Fn(&M::V, M::T, &M::V, &mut M::V),

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

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

impl<M, I, J> ConstantOp for ParameterisedOp<'_, ConstantClosureWithSens<M, I, J>>

where M: Matrix, I: Fn(&M::V, M::T, &mut M::V), J: Fn(&M::V, M::T, &M::V, &mut M::V),

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

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

impl<M, I, J> ConstantOpSens for ParameterisedOp<'_, ConstantClosureWithSens<M, I, J>>

where M: Matrix, I: Fn(&M::V, M::T, &mut M::V), J: Fn(&M::V, M::T, &M::V, &mut M::V),

fn sens_mul_inplace(&self, 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_inplace(&self, 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, t: Self::T, y: &mut Self::M)

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

fn sens(&self, 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, I, J> ConstantOpSensAdjoint for ParameterisedOp<'_, ConstantClosureWithAdjoint<M, I, J>>

where M: Matrix, I: Fn(&M::V, M::T, &mut M::V), J: Fn(&M::V, M::T, &M::V, &mut M::V),

fn sens_transpose_mul_inplace(&self, t: Self::T, v: &Self::V, y: &mut Self::V)

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

fn sens_adjoint(&self, 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, 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, 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, F> LinearOp for ParameterisedOp<'_, LinearClosure<M, F>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, M::T, &mut M::V),

fn gemv_inplace(&self, x: &M::V, t: M::T, beta: M::T, y: &mut M::V)

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

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 sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

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 _default_matrix_inplace(&self, t: Self::T, y: &mut Self::M)

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

impl<M, F, G> LinearOp for ParameterisedOp<'_, LinearClosureWithAdjoint<M, F, G>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, M::T, &mut M::V),

fn gemv_inplace(&self, x: &M::V, t: M::T, beta: M::T, y: &mut M::V)

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

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 sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

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 _default_matrix_inplace(&self, t: Self::T, y: &mut Self::M)

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

impl<M: Matrix> LinearOp for ParameterisedOp<'_, 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 ParameterisedOp<'_, 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, F, G> LinearOpTranspose for ParameterisedOp<'_, LinearClosureWithAdjoint<M, F, G>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, M::T, &mut M::V),

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 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 transpose_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

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 _default_transpose_inplace(&self, t: Self::T, y: &mut Self::M)

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

impl<M: Matrix> LinearOpTranspose for ParameterisedOp<'_, 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, F, G> NonLinearOp for ParameterisedOp<'_, Closure<M, F, G>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn call_inplace(&self, x: &M::V, t: M::T, y: &mut M::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, F> NonLinearOp for ParameterisedOp<'_, ClosureNoJac<M, F>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V),

fn call_inplace(&self, x: &M::V, t: M::T, y: &mut M::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, F, G, H, I> NonLinearOp for ParameterisedOp<'_, ClosureWithAdjoint<M, F, G, H, I>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), I: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn call_inplace(&self, x: &M::V, t: M::T, y: &mut M::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, F, G, H> NonLinearOp for ParameterisedOp<'_, ClosureWithSens<M, F, G, H>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn call_inplace(&self, x: &M::V, t: M::T, y: &mut M::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> NonLinearOp for ParameterisedOp<'_, 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, F, G, H, I> NonLinearOpAdjoint for ParameterisedOp<'_, ClosureWithAdjoint<M, F, G, H, I>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), I: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

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 adjoint_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

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.

impl<M: Matrix> NonLinearOpAdjoint for ParameterisedOp<'_, 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, F, G> NonLinearOpJacobian for ParameterisedOp<'_, Closure<M, F, G>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn jac_mul_inplace(&self, x: &M::V, t: M::T, v: &M::V, y: &mut M::V)

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

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 jacobian_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

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 _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, F, G, H, I> NonLinearOpJacobian for ParameterisedOp<'_, ClosureWithAdjoint<M, F, G, H, I>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), I: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn jac_mul_inplace(&self, x: &M::V, t: M::T, v: &M::V, y: &mut M::V)

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

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 jacobian_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

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 _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, F, G, H> NonLinearOpJacobian for ParameterisedOp<'_, ClosureWithSens<M, F, G, H>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

fn jac_mul_inplace(&self, x: &M::V, t: M::T, v: &M::V, y: &mut M::V)

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

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 jacobian_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

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 _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> NonLinearOpJacobian for ParameterisedOp<'_, 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, F, G, H> NonLinearOpSens for ParameterisedOp<'_, ClosureWithSens<M, F, G, H>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

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_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 sens_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

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 _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.

impl<M: Matrix> NonLinearOpSens for ParameterisedOp<'_, 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, F, G, H, I> NonLinearOpSensAdjoint for ParameterisedOp<'_, ClosureWithAdjoint<M, F, G, H, I>>

where M: Matrix, F: Fn(&M::V, &M::V, M::T, &mut M::V), G: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), H: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V), I: Fn(&M::V, &M::V, M::T, &M::V, &mut M::V),

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_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 sens_adjoint_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

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 _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).

impl<M: Matrix> NonLinearOpSensAdjoint for ParameterisedOp<'_, 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<C: Op> Op for ParameterisedOp<'_, C>

type V = <C as Op>::V

type T = <C as Op>::T

type M = <C as Op>::M

type C = <C as Op>::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 statistics(&self) -> OpStatistics

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

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

return the context of the operator