Trait Solve

pub trait Solve<A: Scalar> {
    // Required methods
    fn solve_inplace<'a, S: DataMut<Elem = A>>(
        &self,
        b: &'a mut ArrayBase<S, Ix1>,
    ) -> Result<&'a mut ArrayBase<S, Ix1>>;
    fn solve_t_inplace<'a, S: DataMut<Elem = A>>(
        &self,
        b: &'a mut ArrayBase<S, Ix1>,
    ) -> Result<&'a mut ArrayBase<S, Ix1>>;
    fn solve_h_inplace<'a, S: DataMut<Elem = A>>(
        &self,
        b: &'a mut ArrayBase<S, Ix1>,
    ) -> Result<&'a mut ArrayBase<S, Ix1>>;

    // Provided methods
    fn solve<S: Data<Elem = A>>(
        &self,
        b: &ArrayBase<S, Ix1>,
    ) -> Result<Array1<A>> { ... }
    fn solve_into<S: DataMut<Elem = A>>(
        &self,
        b: ArrayBase<S, Ix1>,
    ) -> Result<ArrayBase<S, Ix1>> { ... }
    fn solve_t<S: Data<Elem = A>>(
        &self,
        b: &ArrayBase<S, Ix1>,
    ) -> Result<Array1<A>> { ... }
    fn solve_t_into<S: DataMut<Elem = A>>(
        &self,
        b: ArrayBase<S, Ix1>,
    ) -> Result<ArrayBase<S, Ix1>> { ... }
    fn solve_h<S: Data<Elem = A>>(
        &self,
        b: &ArrayBase<S, Ix1>,
    ) -> Result<Array1<A>> { ... }
    fn solve_h_into<S: DataMut<Elem = A>>(
        &self,
        b: ArrayBase<S, Ix1>,
    ) -> Result<ArrayBase<S, Ix1>> { ... }
}

An interface for solving systems of linear equations.

There are three groups of methods:

• solve* (normal) methods solve A * x = b for x.
• solve_t* (transpose) methods solve A^T * x = b for x.
• solve_h* (Hermitian conjugate) methods solve A^H * x = b for x.

Within each group, there are three methods that handle ownership differently:

• * methods take a reference to b and return x as a new array.
• *_into methods take ownership of b, store the result in it, and return it.
• *_inplace methods take a mutable reference to b and store the result in that array.

If you plan to solve many equations with the same A matrix but different b vectors, it’s faster to factor the A matrix once using the Factorize trait, and then solve using the LUFactorized struct.

Required Methods

fn solve_inplace<'a, S: DataMut<Elem = A>>( &self, b: &'a mut ArrayBase<S, Ix1>, ) -> Result<&'a mut ArrayBase<S, Ix1>>

Solves a system of linear equations A * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of columns of A.

fn solve_t_inplace<'a, S: DataMut<Elem = A>>( &self, b: &'a mut ArrayBase<S, Ix1>, ) -> Result<&'a mut ArrayBase<S, Ix1>>

Solves a system of linear equations A^T * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

fn solve_h_inplace<'a, S: DataMut<Elem = A>>( &self, b: &'a mut ArrayBase<S, Ix1>, ) -> Result<&'a mut ArrayBase<S, Ix1>>

Solves a system of linear equations A^H * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

Provided Methods

fn solve<S: Data<Elem = A>>(&self, b: &ArrayBase<S, Ix1>) -> Result<Array1<A>>

Solves a system of linear equations A * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of columns of A.

fn solve_into<S: DataMut<Elem = A>>( &self, b: ArrayBase<S, Ix1>, ) -> Result<ArrayBase<S, Ix1>>

Solves a system of linear equations A * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of columns of A.

fn solve_t<S: Data<Elem = A>>(&self, b: &ArrayBase<S, Ix1>) -> Result<Array1<A>>

Solves a system of linear equations A^T * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

fn solve_t_into<S: DataMut<Elem = A>>( &self, b: ArrayBase<S, Ix1>, ) -> Result<ArrayBase<S, Ix1>>

Solves a system of linear equations A^T * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

fn solve_h<S: Data<Elem = A>>(&self, b: &ArrayBase<S, Ix1>) -> Result<Array1<A>>

Solves a system of linear equations A^H * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

fn solve_h_into<S: DataMut<Elem = A>>( &self, b: ArrayBase<S, Ix1>, ) -> Result<ArrayBase<S, Ix1>>

Solves a system of linear equations A^H * x = b where A is self, b is the argument, and x is the successful result.

Panics

Panics if the length of b is not the equal to the number of rows of A.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A, S> Solve<A> for ArrayBase<S, Ix2>

where A: Scalar + Lapack, S: Data<Elem = A>,

fn solve_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Ix1>, ) -> Result<&'a mut ArrayBase<Sb, Ix1>>

where Sb: DataMut<Elem = A>,

fn solve_t_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Ix1>, ) -> Result<&'a mut ArrayBase<Sb, Ix1>>

where Sb: DataMut<Elem = A>,

fn solve_h_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Ix1>, ) -> Result<&'a mut ArrayBase<Sb, Ix1>>

where Sb: DataMut<Elem = A>,

Implementors

impl<A, S> Solve<A> for LUFactorized<S>

where A: Scalar + Lapack, S: Data<Elem = A> + RawDataClone,