Struct Lapack 

pub struct Lapack { /* private fields */ }

LAPACK backend.

Implements the decomposition and solver traits from mdarray_linalg by delegating to LAPACK routines.

Implementations

impl Lapack

pub fn new() -> Self

Creates a new Lapack backend.

Trait Implementations

impl Clone for Lapack

fn clone(&self) -> Lapack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Lapack

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Lapack

fn default() -> Lapack

Returns the “default value” for a type.

impl<T, D0: Dim, D1: Dim> Eig<T, D0, D1> for Lapack

where T: ComplexFloat + Default + LapackScalar + NeedsRwork<Elem = T>, Complex<T::Real>: ComplexFloat + Default + LapackScalar + NeedsRwork<Elem = Complex<T::Real>>, i8: Into<T::Real>, T::Real: Into<T>,

fn eig<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EigDecomp<Self::SpectralScalar, D0, D1>, EigError>

where T: ComplexFloat,

Compute eigenvalues and right eigenvectors with new allocated matrices

fn eig_full<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EigDecomp<Self::SpectralScalar, D0, D1>, EigError>

Compute eigenvalues and both left/right eigenvectors with new allocated matrices

fn eig_values<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<Array<Self::SpectralScalar, (D0,)>, EigError>

Compute only eigenvalues with new allocated vectors

fn eigh<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<EighDecomp<T, Self::RealScalar, D0, D1>, EigError>

Compute eigenvalues and eigenvectors of a self-adjoint matrix

fn schur<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<SchurDecomp<T, D0, D1>, SchurError>

Compute Schur decomposition with new allocated matrices

fn schur_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, t: &mut Slice<T, (D0, D1), Dense>, z: &mut Slice<T, (D0, D1), Dense>, ) -> Result<(), SchurError>

Compute Schur decomposition overwriting existing matrices

fn schur_complex<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<SchurDecomp<Self::SpectralScalar, D0, D1>, SchurError>

Compute Schur (complex) decomposition with new allocated matrices

fn schur_complex_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, t: &mut Slice<Self::SpectralScalar, (D0, D1), Dense>, z: &mut Slice<Self::SpectralScalar, (D0, D1), Dense>, ) -> Result<(), SchurError>

Compute Schur (complex) decomposition overwriting existing matrices

type SpectralScalar = Complex<<T as ComplexFloat>::Real>

Spectral scalar type used for general eigenvalues/eigenvectors and complex Schur decompositions.

type RealScalar = <T as ComplexFloat>::Real

Real scalar type used for self-adjoint eigenvalues.

impl<T, D0: Dim, D1: Dim> LU<T, D0, D1> for Lapack

where T: ComplexFloat + Default + LapackScalar + Workspace, T::Real: Into<T>,

fn cholesky<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<Array<T, (D0, D1)>, InvError>

Computes the Cholesky decomposition, returning a lower-triangular matrix

fn cholesky_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<(), InvError>

Computes the Cholesky decomposition in-place, overwriting the input matrix

fn lu_write<L: Layout, Ll: Layout, Lu: Layout, Lp: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, l: &mut Slice<T, (D0, D0), Ll>, u: &mut Slice<T, (D0, D1), Lu>, p: &mut Slice<T, (D0, D0), Lp>, )

Computes LU decomposition overwriting existing matrices

fn lu<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> (Array<T, (D0, D0)>, Array<T, (D0, D1)>, Array<T, (D0, D0)>)

Computes LU decomposition with new allocated matrices: L, U, P (permutation matrix)

fn inv_write<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<(), InvError>

Computes inverse overwriting the input matrix

fn inv<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> Result<Array<T, (D0, D1)>, InvError>

Computes inverse with new allocated matrix

fn det<L: Layout>(&self, a: &mut Slice<T, (D0, D1), L>) -> T

Computes the determinant of a square matrix. Panics if the matrix is non-square.

impl<T, D0: Dim, D1: Dim> QR<T, D0, D1> for Lapack

where T: ComplexFloat + Default + LapackScalar + NeedsRwork, T::Real: Into<T>,

fn qr_write<D2: Dim, L: Layout, Lq: Layout, Lr: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, q: &mut Slice<T, (D0, D2), Lq>, r: &mut Slice<T, (D2, D1), Lr>, )

Compute QR decomposition overwriting existing matrices

fn qr<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> (Array<T, (D0, usize)>, Array<T, (usize, D1)>)

Compute QR decomposition with new allocated matrices

impl<T, D> SVD<T, D> for Lapack

where T: ComplexFloat + Default + LapackScalar + NeedsRwork, T::Real: Into<T>, D: Dim,

type SingularValue = T

Scalar type used for singular values.

fn svd<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<SVDDecomp<T, Self::SingularValue, D>, SVDError>

Compute full SVD with new allocated matrices

fn svd_thin<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<SVDDecomp<T, Self::SingularValue, D>, SVDError>

Compute thin SVD with new allocated matrices

fn svd_s<L: Layout>( &self, a: &mut Slice<T, (D, D), L>, ) -> Result<Array<Self::SingularValue, (D,)>, SVDError>

Compute only singular values with new allocated matrix

fn svd_write<L: Layout, Ls: Layout, Lu: Layout, Lvt: Layout>( &self, a: &mut Slice<T, (D, D), L>, s: &mut Slice<Self::SingularValue, (D,), Ls>, u: &mut Slice<T, (D, D), Lu>, vt: &mut Slice<T, (D, D), Lvt>, ) -> Result<(), SVDError>

Compute SVD, overwriting existing matrices

fn svd_write_s<L: Layout, Ls: Layout>( &self, a: &mut Slice<T, (D, D), L>, s: &mut Slice<Self::SingularValue, (D,), Ls>, ) -> Result<(), SVDError>

Compute only singular values, overwriting existing matrix

impl<T, D: Dim> Solve<T, D> for Lapack

where T: ComplexFloat + Default + LapackScalar, T::Real: Into<T>,

fn solve_write<R: Dim, La: Layout, Lb: Layout>( &self, a: &mut Slice<T, (D, D), La>, b: &mut Slice<T, (D, R), Lb>, ) -> Result<(), SolveError>

Solves linear system AX = B, overwriting B with the solution X.

fn solve<R: Dim, La: Layout, Lb: Layout>( &self, a: &mut Slice<T, (D, D), La>, b: &Slice<T, (D, R), Lb>, ) -> Result<Array<T, (D, R)>, SolveError>

Solves linear system AX = B with a newly allocated solution matrix.