Struct Tridiagonal 

pub struct Tridiagonal<A>
where
    A: Scalar,
{
    pub l: MatrixLayout,
    pub dl: Vec<A>,
    pub d: Vec<A>,
    pub du: Vec<A>,
}

Represents a tridiagonal matrix as 3 one-dimensional vectors.

[d0, u1,  0,   ...,       0,
 l1, d1, u2,            ...,
  0, l2, d2,
 ...           ...,  u{n-1},
  0,  ...,  l{n-1},  d{n-1},]

Fields

l: MatrixLayout

layout of raw matrix

dl: Vec<A>

(n-1) sub-diagonal elements of matrix.

d: Vec<A>

(n) diagonal elements of matrix.

du: Vec<A>

(n-1) super-diagonal elements of matrix.

Trait Implementations

impl<A> Clone for Tridiagonal<A>

where A: Clone + Scalar,

fn clone(&self) -> Tridiagonal<A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A> DeterminantTridiagonal<A> for Tridiagonal<A>

where A: Scalar,

fn det_tridiagonal(&self) -> Result<A, LinalgError>

Computes the determinant of the matrix. Unlike .det() of Determinant trait, this method doesn’t returns the natural logarithm of the determinant but the determinant itself.

impl<A> FactorizeTridiagonal<A> for Tridiagonal<A>

where A: Scalar + Lapack,

fn factorize_tridiagonal( &self, ) -> Result<LUFactorizedTridiagonal<A>, LinalgError>

Computes the LU factorization A = P*L*U, where P is a permutation matrix.

impl<A> FactorizeTridiagonalInto<A> for Tridiagonal<A>

where A: Scalar + Lapack,

fn factorize_tridiagonal_into( self, ) -> Result<LUFactorizedTridiagonal<A>, LinalgError>

Computes the LU factorization A = P*L*U, where P is a permutation matrix.

impl<A> Index<[i32; 2]> for Tridiagonal<A>

where A: Scalar,

type Output = A

The returned type after indexing.

fn index(&self, _: [i32; 2]) -> &A

Performs the indexing (container[index]) operation.

impl<A> Index<(i32, i32)> for Tridiagonal<A>

where A: Scalar,

type Output = A

The returned type after indexing.

fn index(&self, _: (i32, i32)) -> &A

Performs the indexing (container[index]) operation.

impl<A> IndexMut<[i32; 2]> for Tridiagonal<A>

where A: Scalar,

fn index_mut(&mut self, _: [i32; 2]) -> &mut A

Performs the mutable indexing (container[index]) operation.

impl<A> IndexMut<(i32, i32)> for Tridiagonal<A>

where A: Scalar,

fn index_mut(&mut self, _: (i32, i32)) -> &mut A

Performs the mutable indexing (container[index]) operation.

impl<A> OperationNorm for Tridiagonal<A>

where A: Scalar + Lapack,

type Output = <A as Scalar>::Real

the value of norm

fn opnorm( &self, t: NormType, ) -> Result<<Tridiagonal<A> as OperationNorm>::Output, LinalgError>

fn opnorm_one(&self) -> Result<Self::Output, LinalgError>

the one norm of a matrix (maximum column sum)

fn opnorm_inf(&self) -> Result<Self::Output, LinalgError>

the infinity norm of a matrix (maximum row sum)

fn opnorm_fro(&self) -> Result<Self::Output, LinalgError>

the Frobenius norm of a matrix (square root of sum of squares)

impl<A> PartialEq for Tridiagonal<A>

where A: PartialEq + Scalar,

fn eq(&self, other: &Tridiagonal<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A> SolveTridiagonal<A, Dim<[usize; 1]>> for Tridiagonal<A>

where A: Scalar + Lapack,

fn solve_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 1]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

fn solve_t_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_t_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 1]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

fn solve_h_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_h_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 1]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 1]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

impl<A> SolveTridiagonal<A, Dim<[usize; 2]>> for Tridiagonal<A>

where A: Scalar + Lapack,

fn solve_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

fn solve_t_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_t_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

fn solve_h_tridiagonal<Sb>( &self, b: &ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>, LinalgError>

where Sb: Data<Elem = A>,

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

fn solve_h_tridiagonal_into<Sb>( &self, b: ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

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

impl<A> SolveTridiagonalInplace<A, Dim<[usize; 2]>> for Tridiagonal<A>

where A: Scalar + Lapack,

fn solve_tridiagonal_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<&'a mut ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

Solves a system of linear equations A * x = b tridiagonal matrix A, where A is self, b is the argument, and x is the successful result. The value of x is also assigned to the argument.

fn solve_t_tridiagonal_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<&'a mut ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

Solves a system of linear equations A^T * x = b tridiagonal matrix A, where A is self, b is the argument, and x is the successful result. The value of x is also assigned to the argument.

fn solve_h_tridiagonal_inplace<'a, Sb>( &self, rhs: &'a mut ArrayBase<Sb, Dim<[usize; 2]>>, ) -> Result<&'a mut ArrayBase<Sb, Dim<[usize; 2]>>, LinalgError>

where Sb: DataMut<Elem = A>,

Solves a system of linear equations A^H * x = b tridiagonal matrix A, where A is self, b is the argument, and x is the successful result. The value of x is also assigned to the argument.

impl<A> Eq for Tridiagonal<A>

where A: Eq + Scalar,

impl<A> StructuralPartialEq for Tridiagonal<A>

where A: Scalar,