Struct NalgebraMat 

pub struct NalgebraMat<T: Scalar> { /* private fields */ }

Trait Implementations

impl<T: Scalar> Add<&NalgebraMat<T>> for NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the + operator.

fn add(self, rhs: &NalgebraMat<T>) -> Self::Output

Performs the + operation.

impl<T: Scalar> Add<&NalgebraMat<T>> for NalgebraMatRef<'_, T>

type Output = NalgebraMat<T>

The resulting type after applying the + operator.

fn add(self, rhs: &NalgebraMat<T>) -> Self::Output

Performs the + operation.

impl<T: Scalar> Add<&NalgebraMatRef<'_, T>> for NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the + operator.

fn add(self, rhs: &NalgebraMatRef<'_, T>) -> Self::Output

Performs the + operation.

impl<T: Scalar> AddAssign<&NalgebraMat<T>> for NalgebraMat<T>

fn add_assign(&mut self, rhs: &NalgebraMat<T>)

Performs the += operation.

impl<T: Scalar> AddAssign<&NalgebraMatRef<'_, T>> for NalgebraMat<T>

fn add_assign(&mut self, rhs: &NalgebraMatRef<'_, T>)

Performs the += operation.

impl<T: Clone + Scalar> Clone for NalgebraMat<T>

fn clone(&self) -> NalgebraMat<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Scalar> Debug for NalgebraMat<T>

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

Formats the value using the given formatter.

impl<T: Scalar> DefaultSolver for NalgebraMat<T>

type LS = LU<T>

fn default_solver() -> Self::LS

impl<T: Scalar> DenseMatrix for NalgebraMat<T>

type View<'a> = NalgebraMatRef<'a, T>

A view of the dense matrix type

type ViewMut<'a> = NalgebraMatMut<'a, T>

A mutable view of the dense matrix type

fn gemm(&mut self, alpha: Self::T, a: &Self, b: &Self, beta: Self::T)

Perform a matrix-matrix multiplication self = alpha * a * b + beta * self, where alpha and beta are scalars, and a and b are matrices

fn resize_cols(&mut self, ncols: IndexType)

Resize the number of columns in the matrix. Existing data is preserved, new elements are uninitialized

fn get_index(&self, i: IndexType, j: IndexType) -> Self::T

Get the value at a given index

fn from_vec( nrows: IndexType, ncols: IndexType, data: Vec<Self::T>, ctx: Self::C, ) -> Self

creates a new matrix from a vector of values, which are assumed to be in column-major order

fn column_mut(&mut self, i: IndexType) -> <Self::V as Vector>::ViewMut<'_>

Get a mutable vector view of the column i

fn columns_mut(&mut self, start: IndexType, end: IndexType) -> Self::ViewMut<'_>

Get a mutable matrix view of the columns starting at start and ending at end

fn set_index(&mut self, i: IndexType, j: IndexType, value: Self::T)

Set the value at a given index

fn column(&self, i: IndexType) -> <Self::V as Vector>::View<'_>

Get a vector view of the column i

fn columns(&self, start: IndexType, end: IndexType) -> Self::View<'_>

Get a matrix view of the columns starting at start and ending at end

fn column_axpy(&mut self, alpha: Self::T, j: IndexType, i: IndexType)

Performs an axpy operation on two columns of the matrix M[:, i] = alpha * M[:, j] + M[:, i]

fn mat_mul(&self, b: &Self) -> Self

mat_mat_mul using gemm, allocating a new matrix

impl<T: Scalar> Index<(usize, usize)> for NalgebraMat<T>

type Output = T

The returned type after indexing.

fn index(&self, index: (IndexType, IndexType)) -> &T

Performs the indexing (container[index]) operation.

impl<T: Scalar> IndexMut<(usize, usize)> for NalgebraMat<T>

fn index_mut(&mut self, index: (IndexType, IndexType)) -> &mut T

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

impl<T: Scalar> LinearSolver<NalgebraMat<T>> for LU<T>

fn solve_in_place(&self, state: &mut NalgebraVec<T>) -> Result<(), DiffsolError>

fn set_linearisation<C: NonLinearOpJacobian<T = T, V = NalgebraVec<T>, M = NalgebraMat<T>>>( &mut self, op: &C, x: &NalgebraVec<T>, t: T, )

fn set_problem<C: NonLinearOpJacobian<T = T, V = NalgebraVec<T>, M = NalgebraMat<T>, C = NalgebraContext>>( &mut self, op: &C, )

Set the problem to be solved, any previous problem is discarded. Any internal state of the solver is reset. This function will normally set the sparsity pattern of the matrix to be solved.

fn solve(&self, b: &M::V) -> Result<M::V, DiffsolError>

Solve the problem Ax = b and return the solution x. panics if Self::set_linearisation has not been called previously

impl<T: Scalar> Matrix for NalgebraMat<T>

type Sparsity = Dense<NalgebraMat<T>>

type SparsityRef<'a> = DenseRef<'a, NalgebraMat<T>>

fn sparsity(&self) -> Option<Self::SparsityRef<'_>>

Return sparsity information (None if the matrix is dense)

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

fn set_data_with_indices( &mut self, dst_indices: &<Self::V as Vector>::Index, src_indices: &<Self::V as Vector>::Index, data: &Self::V, )

assign the values in the data vector to the matrix at the indices in dst_indices from the indices in src_indices dst_index can be obtained using the get_index method on the Sparsity type - for dense matrices, the dst_index is the data index in column-major order - for sparse matrices, the dst_index is the index into the data array

fn gather(&mut self, other: &Self, indices: &<Self::V as Vector>::Index)

gather the values in the matrix other at the indices in indices to the matrix self for sparse matrices: the index idx_i in indices is an index into the data array for other, and is copied to the index idx_i in the data array for self for dense matrices: the index idx_i in indices is the data index in column-major order for other, and is copied to the index idx_i in the data array for self (again in column-major order)

fn partition_indices_by_zero_diagonal( &self, ) -> (<Self::V as Vector>::Index, <Self::V as Vector>::Index)

fn add_column_to_vector(&self, j: IndexType, v: &mut Self::V)

fn triplet_iter(&self) -> impl Iterator<Item = (IndexType, IndexType, Self::T)>

fn try_from_triplets( nrows: IndexType, ncols: IndexType, triplets: Vec<(IndexType, IndexType, T)>, ctx: Self::C, ) -> Result<Self, DiffsolError>

Create a new matrix from a vector of triplets (i, j, value) where i and j are the row and column indices of the value

fn zeros(nrows: IndexType, ncols: IndexType, ctx: Self::C) -> Self

Create a new matrix of shape nrows x ncols filled with zeros

fn from_diagonal(v: &Self::V) -> Self

Create a new diagonal matrix from a Vector holding the diagonal elements

fn gemv(&self, alpha: Self::T, x: &Self::V, beta: Self::T, y: &mut Self::V)

Perform a matrix-vector multiplication y = alpha * self * x + beta * y.

fn copy_from(&mut self, other: &Self)

Copy the contents of other into self

fn set_column(&mut self, j: IndexType, v: &Self::V)

sets the values of column j to be equal to the values in v For sparse matrices, only the existing non-zero elements are updated

fn scale_add_and_assign(&mut self, x: &Self, beta: Self::T, y: &Self)

Perform the assignment self = x + beta * y where x and y are matrices and beta is a scalar Panics if the sparsity of self, x, and y do not match (i.e. sparsity of self must be the union of the sparsity of x and y)

fn new_from_sparsity( nrows: IndexType, ncols: IndexType, _sparsity: Option<Self::Sparsity>, ctx: Self::C, ) -> Self

Create a new matrix from a sparsity pattern, the non-zero elements are not initialized

fn is_sparse() -> bool

fn split( &self, algebraic_indices: &<Self::V as Vector>::Index, ) -> [(Self, <Self::V as Vector>::Index); 4]

Split the matrix into four submatrices, based on the indices in algebraic_indices

fn combine( ul: &Self, ur: &Self, ll: &Self, lr: &Self, algebraic_indices: &<Self::V as Vector>::Index, ) -> Self

impl<T: Scalar> MatrixCommon for NalgebraMat<T>

type T = T

type V = NalgebraVec<T>

type C = NalgebraContext

type Inner = Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>

fn nrows(&self) -> IndexType

fn ncols(&self) -> IndexType

fn inner(&self) -> &Self::Inner

impl<'a, T: Scalar> Mul<Scale<T>> for &NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation.

impl<'a, T: Scalar> Mul<Scale<T>> for NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation.

impl<T: PartialEq + Scalar> PartialEq for NalgebraMat<T>

fn eq(&self, other: &NalgebraMat<T>) -> 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<T: Scalar> Sub<&NalgebraMat<T>> for NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &NalgebraMat<T>) -> Self::Output

Performs the - operation.

impl<T: Scalar> Sub<&NalgebraMat<T>> for NalgebraMatRef<'_, T>

type Output = NalgebraMat<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &NalgebraMat<T>) -> Self::Output

Performs the - operation.

impl<T: Scalar> Sub<&NalgebraMatRef<'_, T>> for NalgebraMat<T>

type Output = NalgebraMat<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &NalgebraMatRef<'_, T>) -> Self::Output

Performs the - operation.

impl<T: Scalar> SubAssign<&NalgebraMat<T>> for NalgebraMat<T>

fn sub_assign(&mut self, rhs: &NalgebraMat<T>)

Performs the -= operation.

impl<T: Scalar> SubAssign<&NalgebraMatRef<'_, T>> for NalgebraMat<T>

fn sub_assign(&mut self, rhs: &NalgebraMatRef<'_, T>)

Performs the -= operation.

impl<T: Scalar> StructuralPartialEq for NalgebraMat<T>