Struct rust_blas::math::bandmat::BandMat

pub struct BandMat<T> { /* private fields */ }

Banded Matrix A banded matrix is a matrix where only the diagonal, a number of super-diagonals and a number of sub-diagonals are non-zero. https://en.wikipedia.org/wiki/Band_matrix

Implementations

impl<T> BandMat<T>

pub fn new(n: usize, m: usize, sub: u32, sup: u32) -> BandMat<T>

pub fn rows(&self) -> usize

pub fn cols(&self) -> usize

pub unsafe fn set_rows(&mut self, n: usize)

Set Rows Manually

Safety

No guarantees are made about rows x columns being equivalent to data length after this operation

pub unsafe fn set_cols(&mut self, n: usize)

Set Columns Manually

Safety

No guarantees are made about rows x columns being equivalent to data length after this operation

pub unsafe fn set_sub_diagonals(&mut self, n: u32)

pub unsafe fn set_sup_diagonals(&mut self, n: u32)

pub unsafe fn push(&mut self, val: T)

impl<T: Copy> BandMat<T>

pub fn from_matrix( mat: Mat<T>, sub_diagonals: u32, sup_diagonals: u32 ) -> BandMat<T>

Converts a Mat into a BandMat.

The idea is to compress the the band matrix by compressing it to a form that is as legible as possible but without many of the extraneous zeros. You can read more about the process here: Wikipedia and Official BLAS Docs, but the best demonstration is probably by example.

Say you have a matrix:

let m =
[
  0.5, 2.0, 0.0, 0.0,
  1.0, 0.5, 2.0, 0.0,
  0.0, 1.0, 0.5, 2.0,
  0.0, 0.0, 1.0, 0.5,
];

This method will transform it into:

let x = 0.0;
let m =
[
  x,   0.5, 2.0,
  1.0, 0.5, 2.0,
  1.0, 0.5, 2.0,
  1.0, 0.5,   x,
];

The x’s represent the values that will not be read by the blas operation, and therefore can remain unchanged. Notice that the dimensions of the new matrix are (rows, LDA), where LDA = <sub diagonals> + <sup diagonals> + 1. This matrix will be stored in the original memory of the matrix that is consumed by this method.

For details about how the conversion actually happens, consult the code comments.

Panics

Panics if the size of the vector representing the input matrix is too small, that is rows * LDA > rows * cols. In this case there is not enough space to perform a safe conversion to the Band Storage format.

impl<T: Copy + Default> BandMat<T>

pub fn to_matrix(bandmat: Self) -> Mat<T>

Converts a BandMat back into a Mat.

This method creates a Mat instance by reversing the steps from the from_matrix method. It will also fill in all the values that are “zero” to the default value of T.

For more information about the implementation, please consult the code comments.

Panics

Panics if the values of rows * cols doesn’t correspond to the length of the data vector.

impl<T: Clone> BandMat<T>

pub fn fill(value: T, n: usize, m: usize) -> BandMat<T>

Trait Implementations

impl<T> BandMatrix<T> for BandMat<T>

fn sub_diagonals(&self) -> u32

fn sup_diagonals(&self) -> u32

fn as_matrix(&self) -> &dyn Matrix<T>

impl<T: Debug> Debug for BandMat<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for BandMat<T>

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

Formats the value using the given formatter.

impl<'a, T> From<&'a dyn BandMatrix<T>> for BandMat<T>

where T: Copy,

fn from(a: &dyn BandMatrix<T>) -> BandMat<T>

Converts to this type from the input type.

impl<T> Index<usize> for BandMat<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: usize) -> &[T]

Performs the indexing (container[index]) operation.

impl<T> Matrix<T> for BandMat<T>

fn lead_dim(&self) -> u32

The leading dimension of the matrix. Defaults to cols for RowMajor order and ‘rows’ for ColMajor order.

fn rows(&self) -> u32

Returns the number of rows.

fn cols(&self) -> u32

Returns the number of columns.

fn as_ptr(&self) -> *const T

An unsafe pointer to a contiguous block of memory.

fn as_mut_ptr(&mut self) -> *mut T

An unsafe pointer to a contiguous block of memory.

fn order(&self) -> Order

The order of the matrix. Defaults to RowMajor.

impl<T: PartialEq> PartialEq for BandMat<T>

fn eq(&self, other: &BandMat<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> StructuralPartialEq for BandMat<T>