sprs 0.11.0

A sparse matrix library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Error type for sprs

#[derive(PartialEq, Debug, Copy, Clone)]
pub enum StructureError {
    Unsorted(&'static str),
    SizeMismatch(&'static str),
    OutOfRange(&'static str),
}

#[derive(PartialEq, Debug, Copy, Clone)]
#[non_exhaustive]
pub enum StructureErrorKind {
    Unsorted,
    SizeMismatch,
    OutOfRange,
}

impl StructureError {
    pub fn kind(&self) -> StructureErrorKind {
        match self {
            StructureError::Unsorted(_) => StructureErrorKind::Unsorted,
            StructureError::SizeMismatch(_) => StructureErrorKind::SizeMismatch,
            StructureError::OutOfRange(_) => StructureErrorKind::OutOfRange,
        }
    }

    fn kind_str(&self) -> &str {
        match self {
            StructureError::Unsorted(_) => "unsorted",
            StructureError::SizeMismatch(_) => "size mismatch",
            StructureError::OutOfRange(_) => "out of range",
        }
    }

    fn msg(&self) -> &str {
        match self {
            StructureError::Unsorted(s)
            | StructureError::SizeMismatch(s)
            | StructureError::OutOfRange(s) => s,
        }
    }
}

impl std::fmt::Display for StructureError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "Structure Error ({}): {}", self.kind_str(), self.msg())
    }
}

impl std::error::Error for StructureError {}

#[derive(PartialEq, Debug, Copy, Clone)]
pub struct ShapeMismatchInfo {
    pub expected: (usize, usize),
    pub received: (usize, usize),
}

#[derive(PartialEq, Debug, Copy, Clone)]
pub struct SingularMatrixInfo {
    pub index: usize,
    pub reason: &'static str,
}

#[derive(PartialEq, Debug, Clone)]
#[non_exhaustive]
pub enum LinalgError {
    ShapeMismatch(ShapeMismatchInfo),
    NonSquareMatrix,
    SingularMatrix(SingularMatrixInfo),
    ThirdPartyError(isize, &'static str),
}

impl std::fmt::Display for LinalgError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            LinalgError::ShapeMismatch(shapes) => {
                write!(
                    f,
                    "Shape mismatch: expected ({}, {}), got ({}, {})",
                    shapes.expected.0,
                    shapes.expected.1,
                    shapes.received.0,
                    shapes.received.1,
                )
            }
            LinalgError::NonSquareMatrix => write!(f, "Non square matrix"),
            LinalgError::SingularMatrix(info) => {
                write!(
                    f,
                    "Singular matrix at index {} ({})",
                    info.index, info.reason,
                )
            }
            LinalgError::ThirdPartyError(code, msg) => {
                write!(f, "Third party error: {} (code {})", msg, code,)
            }
        }
    }
}

impl std::error::Error for LinalgError {}

/// Convenience wrapper around more precise error types. Not returned by
/// functions in this crate, but can be easily obtained from any error
/// returned in this crate using `Into` and `From`.
#[derive(PartialEq, Debug, Clone)]
#[non_exhaustive]
pub enum SprsError {
    Structure(StructureError),
    Linalg(LinalgError),
}

impl From<StructureError> for SprsError {
    fn from(e: StructureError) -> Self {
        Self::Structure(e)
    }
}

impl From<LinalgError> for SprsError {
    fn from(e: LinalgError) -> Self {
        Self::Linalg(e)
    }
}

impl std::fmt::Display for SprsError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::Structure(e) => write!(f, "Structure error: {}", e),
            Self::Linalg(e) => write!(f, "Linalg error: {}", e),
        }
    }
}

impl std::error::Error for SprsError {}