Struct RectMatrix 

pub struct RectMatrix<T: MatElement, const R: usize, const C: usize> { /* private fields */ }

Implementations

impl<T: MatElement, const R: usize, const C: usize> RectMatrix<T, R, C>

pub fn mat_from_vec(data: [[T; C]; R]) -> RectMatrix<T, R, C>

Create a new vector from data.

pub fn value(&self, row: usize, col: usize) -> T

Returns the value.

pub fn set_value(&mut self, row: usize, col: usize, value: T)

Sets a value.

pub fn rows(&self) -> usize

Returns the number of rows.

pub fn row(&self, i: usize) -> RowVector<T, C>

Returns the i-th row.

pub fn row_to_vec(&self, i: usize) -> [T; C]

Returns the i-th row to an array.

pub fn col_to_vec(&self, j: usize) -> [T; R]

Returns the j-th column as an array.

pub fn cols(&self) -> usize

Returns the number of columns.

pub fn col(&self, j: usize) -> ColVector<T, R>

Returns the i-th column.

pub fn max_col(&self, j: usize) -> T

Returns the max value in column.

pub fn print(&self)

Prints the matrix.

pub fn rect<const R2: usize, const C2: usize>( &self, top: usize, left: usize, ) -> RectMatrix<T, R2, C2>

Crops the matrix.

pub fn size(&self) -> Size

Returns the size of the matrix.

pub fn transposed(&self) -> RectMatrix<T, C, R>

Transpose this matrix and returns a new transposed instance.

pub fn assign_col( &mut self, col: usize, v: ColVector<T, R>, ) -> &RectMatrix<T, R, C>

Assigns a column.

pub fn is_lower_triangular(&self) -> bool

Returns true iif the matrix is lower triangular.

pub fn is_upper_triangular(&self) -> bool

Returns true iif the matrix is upper triangular.

pub fn is_square(&self) -> bool

Returns true iif the matrix is square.

pub fn is_row(&self) -> bool

Returns true iif this is a row.

pub fn is_col(&self) -> bool

Returns true iif this a col.

pub fn zeros() -> Self

Creates a matrix filled with zeros.

pub fn reset(&mut self)

Reset all values to zero.

pub fn identity() -> Self

Creates an identity matrix.

impl<const R: usize, const C: usize> RectMatrix<f64, R, C>

pub fn round(&mut self, decimals: i32) -> &RectMatrix<f64, R, C>

Rounds all the values in the matrix.

impl<T: MatElement, const L: usize> RectMatrix<T, 1, L>

pub fn row_from_vec(data: &[T]) -> RowVector<T, L>

Builds a RowVector from a vector.

pub fn evenly_spaced(a: &f64, b: &f64) -> RowVector<f64, L>

Creates a evenly spaced sequence of numbers.

impl<T: MatElement, const L: usize> RectMatrix<T, L, 1>

pub fn col_from_vec(data: &[T]) -> ColVector<T, L>

Builds a ColVector from a vector.

Trait Implementations

impl<T: MatElement, const R: usize, const C: usize> Add for RectMatrix<T, R, C>

fn add(self, other: Self) -> Self

Adds another matrix.

type Output = RectMatrix<T, R, C>

The resulting type after applying the + operator.

impl<T: MatElement, const R: usize, const C: usize> AddAssign for RectMatrix<T, R, C>

fn add_assign(&mut self, rhs: RectMatrix<T, R, C>)

Performs the += operation.

impl<M: Copy + Default, F: MatElement + ApproxEq<Margin = M>, const R: usize, const C: usize> ApproxEq for RectMatrix<F, R, C>

type Margin = M

This type type defines a margin within which two values are to be considered approximately equal. It must implement Default so that approx_eq() can be called on unknown types.

fn approx_eq<T: Into<Self::Margin>>(self, other: Self, margin: T) -> bool

This method tests that the self and other values are equal within margin of each other.

fn approx_ne<M>(self, other: Self, margin: M) -> bool

where M: Into<Self::Margin>,

This method tests that the self and other values are not within margin of each other.

impl<T: MatElement, const R: usize, const C: usize> Clone for RectMatrix<T, R, C>

fn clone(&self) -> RectMatrix<T, R, C>

Clones this matrix.

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

Performs copy-assignment from source.

impl<T: Debug + MatElement, const R: usize, const C: usize> Debug for RectMatrix<T, R, C>

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

Formats the value using the given formatter.

impl<T: MatElement, const R1: usize, const C1: usize, const C2: usize> Mul<RectMatrix<T, C1, C2>> for RectMatrix<T, R1, C1>

fn mul(self, other: RectMatrix<T, C1, C2>) -> RectMatrix<T, R1, C2>

Multiplication by another matrix.

type Output = RectMatrix<T, R1, C2>

The resulting type after applying the * operator.

impl<T: MatElement, const R: usize, const C: usize> Mul<T> for RectMatrix<T, R, C>

fn mul(self, scalar: T) -> Self::Output

Multiplication by a scalar.

type Output = RectMatrix<T, R, C>

The resulting type after applying the * operator.

impl<T: MatElement, const R: usize, const C: usize> MulAssign<T> for RectMatrix<T, R, C>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: MatElement, const R: usize, const C: usize> PartialEq for RectMatrix<T, R, C>

fn eq(&self, other: &Self) -> 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: MatElement, const R: usize, const C: usize> Sub for RectMatrix<T, R, C>

fn sub(self, other: Self) -> Self::Output

Subtracts another matrix.

type Output = RectMatrix<T, R, C>

The resulting type after applying the - operator.

impl<T: MatElement, const R: usize, const C: usize> SubAssign for RectMatrix<T, R, C>

fn sub_assign(&mut self, rhs: RectMatrix<T, R, C>)

Performs the -= operation.

impl<T: Copy + MatElement, const R: usize, const C: usize> Copy for RectMatrix<T, R, C>

impl<T: Eq + MatElement, const R: usize, const C: usize> Eq for RectMatrix<T, R, C>