Enum MtxData

pub enum MtxData<T: Num, const NDIM: usize = 2> {
    Dense([usize; NDIM], Vec<T>, SymInfo),
    Sparse([usize; NDIM], Vec<[usize; NDIM]>, Vec<T>, SymInfo),
}

The main enum of this crate, corresponding to the 2 kind of usage of mtx files. Both contains a first line with dimensions. Dense is a list of numbers. Sparse is a list of coordinates and values.

Variants

Dense([usize; NDIM], Vec<T>, SymInfo)

Sparse([usize; NDIM], Vec<[usize; NDIM]>, Vec<T>, SymInfo)

Implementations

impl<T: Num, const NDIM: usize> MtxData<T, NDIM>

pub fn from_file<P>(path: P) -> Result<Self, MtxError>

where P: AsRef<Path>,

Build a MtxData from a matrix market (usually .mtx) file.

Example

use matrix_market_rs::{MtxData, SymInfo, MtxError};
use std::fs::File;
use std::io::Write;

fn main() -> Result<(), MtxError> {
    let mtx_content = r#"
    %%MatrixMarket matrix coordinate integer symmetric
    2 2 2
    1 1 3
    2 2 4
    "#;
    
    let mut f = File::create("sparse2x2.mtx")?;
    f.write_all(mtx_content.trim().as_bytes());
    let shape = [2,2];
    let indices = vec![[0,0], [1,1]];
    let nonzeros = vec![3,4];
    let sym = SymInfo::Symmetric;
    
    let sparse:MtxData<i32> = MtxData::from_file("sparse2x2.mtx")?;
    assert_eq!(sparse, MtxData::Sparse(shape, indices, nonzeros, sym));
    Ok(())
}

Errors

It could fail for many reasons but for example:

• File doesn’t match the matrix market format.
• an IO error (file not found etc.)

Trait Implementations

impl<T: Clone + Num, const NDIM: usize> Clone for MtxData<T, NDIM>

fn clone(&self) -> MtxData<T, NDIM>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Num, const NDIM: usize> Debug for MtxData<T, NDIM>

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

Formats the value using the given formatter.

impl<T: PartialEq + Num, const NDIM: usize> PartialEq for MtxData<T, NDIM>

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

Tests for self and other values to be equal, and is used by ==.

const 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: Eq + Num, const NDIM: usize> Eq for MtxData<T, NDIM>

impl<T: Num, const NDIM: usize> StructuralPartialEq for MtxData<T, NDIM>