Trait Integrable 

pub trait Integrable {
    type Point: Tensor;
    type Increment: Tensor;

    // Required method
    fn reconstruct(
        base: &Self::Point,
        increment: &Self::Increment,
    ) -> Result<Self::Point, TensorError>;

    // Provided method
    fn dexpinv(
        _sigma: &Self::Increment,
        increment: Self::Increment,
    ) -> Self::Increment { ... }
}

The geometry of one integrated state field: how an increment advances the state.

Self::Increment is an element of the field’s tangent space (its Lie algebra for a group-valued field). It equals Self::Point for a flat field, but not in general — e.g. F_p is a Reference → Intermediate map while its algebra element D_p Δt maps Intermediate → Intermediate.

Required Associated Types

type Point: Tensor

The state value this field carries.

type Increment: Tensor

The tangent/algebra element that advances a Self::Point.

Required Methods

fn reconstruct( base: &Self::Point, increment: &Self::Increment, ) -> Result<Self::Point, TensorError>

Advances base by increment.

Provided Methods

fn dexpinv( _sigma: &Self::Increment, increment: Self::Increment, ) -> Self::Increment

The RKMK correction: maps a rate-scaled increment to an algebra increment at the accumulated algebra element sigma. Flat fields are the identity.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<A, B> Integrable for Unimodular<A, B>

where TensorRank2<3, A, B, Dimensionless>: Tensor, TensorRank2<3, A, A, Dimensionless>: Tensor, for<'a> TensorRank2<3, A, A, Dimensionless>: Mul<&'a TensorRank2<3, A, B, Dimensionless>, Output = TensorRank2<3, A, B, Dimensionless>>,

type Point = TensorRank2<3, A, B>

type Increment = TensorRank2<3, A, A>

impl<Field> Integrable for List<Field>

where Field: Integrable, TensorVector<Field::Point>: Tensor<Item = Field::Point>, TensorVector<Field::Increment>: Tensor<Item = Field::Increment>,

type Point = TensorVector<<Field as Integrable>::Point>

type Increment = TensorVector<<Field as Integrable>::Increment>

impl<H, T> Integrable for Product<H, T>

where H: Integrable, T: Integrable, TensorTuple<H::Point, T::Point>: Tensor, TensorTuple<H::Increment, T::Increment>: Tensor,

type Point = TensorTuple<<H as Integrable>::Point, <T as Integrable>::Point>

type Increment = TensorTuple<<H as Integrable>::Increment, <T as Integrable>::Increment>

impl<T> Integrable for Flat<T>

where for<'a> T: Clone + Tensor + Add<&'a T, Output = T>,

type Point = T

type Increment = T