Enum MatrixMarketErrorKind

#[non_exhaustive]
pub enum MatrixMarketErrorKind {
    ParsingError,
    InvalidHeader,
    EntryMismatch,
    TypeMismatch,
    ZeroError,
    SparseFormatError(SparseFormatErrorKind),
    DiagonalError,
    IOError(ErrorKind),
    NotLowerTriangle,
    NonSquare,
}

Errors produced by functions that expect well-formed matrix market format data.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ParsingError

Parsing failure.

Indicates that the parser failed, for example due to an unexpected string.

Examples

let str = r#"
%%MatrixMarket invalid invalid invalid invalid
1 1 1
1 1 5
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(), MatrixMarketErrorKind::ParsingError);

InvalidHeader

Indicates that the matrix market header is invalid.

Examples

let str = r#"
%%MatrixMarket matrix coordinate real hermitian
% a real matrix can't be hermitian
1 1 1
1 1 5
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::InvalidHeader);

EntryMismatch

Indicates that the number of data entries in the matrix market file does not match the header.

Examples

let str = r#"
%%matrixmarket matrix coordinate real general
% it has one more data entry than specified.
3 3 1
2 2 2
2 3 2
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::EntryMismatch);

TypeMismatch

Indicates that the scalar type requested is not compatible with the scalar type stored in the matrix market file.

Examples

let str = r#"
%%matrixmarket matrix coordinate real general
% it should be loaded with load_coo_from_matrix_market_str::<f64>(str) (or f32)
3 3 2
2 2 2.22
2 3 2.22
"#;
let matrix_result = load_coo_from_matrix_market_str::<i32>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::TypeMismatch);

ZeroError

Indicates that zero has been used as an index in the data.

Note: The matrix market format uses 1-based indexing.

Examples

let str = r#"
%%matrixmarket matrix coordinate real general
1 1 1
0 0 10
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::ZeroError);

SparseFormatError(SparseFormatErrorKind)

Indicates SparseFormatError while creating the sparse matrix.

Examples

let str = r#"
%%matrixmarket matrix coordinate real general
1 1 1
4 2 10
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),
    MatrixMarketErrorKind::SparseFormatError(SparseFormatErrorKind::IndexOutOfBounds));

DiagonalError

Indicates that a wrong diagonal element has been provided to the matrix.

Examples

let str = r#"
%%matrixmarket matrix coordinate real skew-symmetric
% skew-symmetric matrix can't have element on diagonal
5 5 2
1 1 10
2 1 5
"#;
let matrix_result = load_coo_from_matrix_market_str::<f64>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::DiagonalError);

let str = r#"
%%matrixmarket matrix coordinate complex hermitian
% hermitian matrix diagonal element must be a real number
5 5 2
1 1 10 2
2 1 5 2
"#;
let matrix_result = load_coo_from_matrix_market_str::<Complex<f64>>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::DiagonalError);

Here the skew matrix shouldn’t have an element on the diagonal.

IOError(ErrorKind)

Indicates an IO error while reading the data from file.

Examples

let matrix_result = load_coo_from_matrix_market_file::<f64,_>("matrix.mtx");
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::IOError(std::io::ErrorKind::NotFound));

NotLowerTriangle

Indicates that a (skew-)symmetric (or hermitian) matrix is not a lower triangular matrix.

Examples

let str = r#"
%%matrixmarket matrix coordinate integer symmetric
5 5 2
1 1 10
2 3 5
"#;
let matrix_result = load_coo_from_matrix_market_str::<i32>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::NotLowerTriangle);

NonSquare

Indicates that a (skew-)symmetric (or hermitian) matrix is not a square matrix.

Examples

let str = r#"
%%matrixmarket matrix coordinate integer symmetric
5 4 2
1 1 10
3 2 5
"#;
let matrix_result = load_coo_from_matrix_market_str::<i32>(str);
assert_eq!(matrix_result.is_err(), true);
assert_eq!(matrix_result.unwrap_err().kind(),MatrixMarketErrorKind::NonSquare);

Trait Implementations

impl Clone for MatrixMarketErrorKind

fn clone(&self) -> MatrixMarketErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MatrixMarketErrorKind

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

Formats the value using the given formatter.

impl PartialEq for MatrixMarketErrorKind

fn eq(&self, other: &MatrixMarketErrorKind) -> 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 Copy for MatrixMarketErrorKind

impl StructuralPartialEq for MatrixMarketErrorKind