Struct BandedMatrix 

pub struct BandedMatrix<A>
where
    A: Float + NumAssign + Zero + Sum + One + ScalarOperand + Send + Sync + Debug,
{ /* private fields */ }

Banded matrix representation

A banded matrix has non-zero elements only within a band around the main diagonal. The band is defined by the number of lower diagonals and upper diagonals.

Examples

use scirs2_core::ndarray::{array, Array2};
use scirs2_linalg::specialized::BandedMatrix;
use scirs2_linalg::SpecializedMatrix;

// Create a 5x5 banded matrix with lower bandwidth 1 and upper bandwidth 2
// This means we have the main diagonal, 1 subdiagonal, and 2 superdiagonals
let mut data = Array2::zeros((4, 5)); // 4 diagonals (1+1+2), 5 columns

// Set the values for each diagonal
// Lower diagonal (the 1 subdiagonal)
data[[0, 0]] = 1.0;
data[[0, 1]] = 2.0;
data[[0, 2]] = 3.0;
data[[0, 3]] = 4.0;

// Main diagonal
data[[1, 0]] = 5.0;
data[[1, 1]] = 6.0;
data[[1, 2]] = 7.0;
data[[1, 3]] = 8.0;
data[[1, 4]] = 9.0;

// First superdiagonal
data[[2, 0]] = 10.0;
data[[2, 1]] = 11.0;
data[[2, 2]] = 12.0;
data[[2, 3]] = 13.0;

// Second superdiagonal
data[[3, 0]] = 14.0;
data[[3, 1]] = 15.0;
data[[3, 2]] = 16.0;

let band = BandedMatrix::new(data.view(), 1, 2, 5, 5).unwrap();

// The matrix is equivalent to:
// [[ 5.0, 10.0, 14.0,  0.0,  0.0 ],
//  [ 1.0,  6.0, 11.0, 15.0,  0.0 ],
//  [ 0.0,  2.0,  7.0, 12.0, 16.0 ],
//  [ 0.0,  0.0,  3.0,  8.0, 13.0 ],
//  [ 0.0,  0.0,  0.0,  4.0,  9.0 ]]

// Get elements
assert_eq!(band.get(0, 0).unwrap(), 5.0);
assert_eq!(band.get(0, 1).unwrap(), 10.0);
assert_eq!(band.get(0, 2).unwrap(), 14.0);
assert_eq!(band.get(1, 0).unwrap(), 1.0);
assert_eq!(band.get(0, 3).unwrap(), 0.0); // Outside the band

// Matrix-vector multiplication
let x = array![1.0, 2.0, 3.0, 4.0, 5.0];
let y = band.matvec(&x.view()).unwrap();

Implementations

impl<A> BandedMatrix<A>

where A: Float + NumAssign + Zero + Sum + One + ScalarOperand + Send + Sync + Debug,

pub fn new( data: ArrayView2<'_, A>, lower_bandwidth: usize, upper_bandwidth: usize, nrows: usize, ncols: usize, ) -> LinalgResult<Self>

Create a new banded matrix from band storage

Arguments

• data - Band storage with diagonals as rows, ordered from lowest to highest
• lower_bandwidth - Number of lower diagonals
• upper_bandwidth - Number of upper diagonals
• nrows - Number of rows in the full matrix
• ncols - Number of columns in the full matrix

Returns

• BandedMatrix if the data has valid dimensions
• LinalgError if dimensions are incompatible

pub fn frommatrix( a: &ArrayView2<'_, A>, lower_bandwidth: usize, upper_bandwidth: usize, ) -> LinalgResult<Self>

Create a new banded matrix from a general matrix, extracting the band

Arguments

• a - Input matrix
• lower_bandwidth - Number of lower diagonals to extract
• upper_bandwidth - Number of upper diagonals to extract

Returns

• BandedMatrix representation of the input matrix

pub fn bandwidth(&self) -> usize

Get the bandwidth of the matrix (sum of lower and upper bandwidth plus one)

pub fn lower_bandwidth(&self) -> usize

Get the lower bandwidth of the matrix

pub fn upper_bandwidth(&self) -> usize

Get the upper bandwidth of the matrix

pub fn solve(&self, b: &ArrayView1<'_, A>) -> LinalgResult<Array1<A>>

Solve a banded system of equations Ax = b

This implementation uses a modified LU decomposition for banded matrices.

Arguments

• b - Right-hand side vector

Returns

• Solution vector x
• LinalgError if the matrix is singular or dimensions are incompatible

Trait Implementations

impl<A> Clone for BandedMatrix<A>

where A: Float + NumAssign + Zero + Sum + One + ScalarOperand + Send + Sync + Debug + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for BandedMatrix<A>

where A: Float + NumAssign + Zero + Sum + One + ScalarOperand + Send + Sync + Debug + Debug,

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

Formats the value using the given formatter.

impl<A> SpecializedMatrix<A> for BandedMatrix<A>

where A: Float + NumAssign + Zero + Sum + One + ScalarOperand + Send + Sync + Debug,

fn nrows(&self) -> usize

Return the number of rows in the matrix

fn ncols(&self) -> usize

Return the number of columns in the matrix

fn get(&self, i: usize, j: usize) -> LinalgResult<A>

Get the element at position (i, j)

fn matvec(&self, x: &ArrayView1<'_, A>) -> LinalgResult<Array1<A>>

Perform matrix-vector multiplication: A * x

fn matvec_transpose(&self, x: &ArrayView1<'_, A>) -> LinalgResult<Array1<A>>

Perform transposed matrix-vector multiplication: A^T * x

fn to_dense(&self) -> LinalgResult<Array2<A>>

Convert to a dense matrix representation

fn to_operator(&self) -> LinalgResult<LinearOperator<A>>

where Self: Sync + 'static + Sized,

Convert to a matrix-free operator