nalgebra-sparse 0.11.0

Sparse matrix computation based on nalgebra.
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

//! Serial sparse matrix arithmetic routines.
//!
//! All routines are single-threaded.
//!
//! Some operations have the `prealloc` suffix. This means that they expect that the sparsity
//! pattern of the output matrix has already been pre-allocated: that is, the pattern of the result
//! of the operation fits entirely in the output pattern. In the future, there will also be
//! some operations which will be able to dynamically adapt the output pattern to fit the
//! result, but these have yet to be implemented.

macro_rules! assert_compatible_spmm_dims {
    ($c:expr, $a:expr, $b:expr) => {{
        use crate::ops::Op::{NoOp, Transpose};
        match (&$a, &$b) {
            (&NoOp(ref a), &NoOp(ref b)) => {
                assert_eq!($c.nrows(), a.nrows(), "C.nrows() != A.nrows()");
                assert_eq!($c.ncols(), b.ncols(), "C.ncols() != B.ncols()");
                assert_eq!(a.ncols(), b.nrows(), "A.ncols() != B.nrows()");
            }
            (&Transpose(ref a), &NoOp(ref b)) => {
                assert_eq!($c.nrows(), a.ncols(), "C.nrows() != A.ncols()");
                assert_eq!($c.ncols(), b.ncols(), "C.ncols() != B.ncols()");
                assert_eq!(a.nrows(), b.nrows(), "A.nrows() != B.nrows()");
            }
            (&NoOp(ref a), &Transpose(ref b)) => {
                assert_eq!($c.nrows(), a.nrows(), "C.nrows() != A.nrows()");
                assert_eq!($c.ncols(), b.nrows(), "C.ncols() != B.nrows()");
                assert_eq!(a.ncols(), b.ncols(), "A.ncols() != B.ncols()");
            }
            (&Transpose(ref a), &Transpose(ref b)) => {
                assert_eq!($c.nrows(), a.ncols(), "C.nrows() != A.ncols()");
                assert_eq!($c.ncols(), b.nrows(), "C.ncols() != B.nrows()");
                assert_eq!(a.nrows(), b.ncols(), "A.nrows() != B.ncols()");
            }
        }
    }};
}

macro_rules! assert_compatible_spadd_dims {
    ($c:expr, $a:expr) => {
        use crate::ops::Op;
        match $a {
            Op::NoOp(a) => {
                assert_eq!($c.nrows(), a.nrows(), "C.nrows() != A.nrows()");
                assert_eq!($c.ncols(), a.ncols(), "C.ncols() != A.ncols()");
            }
            Op::Transpose(a) => {
                assert_eq!($c.nrows(), a.ncols(), "C.nrows() != A.ncols()");
                assert_eq!($c.ncols(), a.nrows(), "C.ncols() != A.nrows()");
            }
        }
    };
}

mod cs;
mod csc;
mod csr;
mod pattern;

pub use csc::*;
pub use csr::*;
pub use pattern::*;
use std::fmt;
use std::fmt::Formatter;

/// A description of the error that occurred during an arithmetic operation.
#[derive(Clone, Debug)]
pub struct OperationError {
    error_kind: OperationErrorKind,
    message: String,
}

/// The different kinds of operation errors that may occur.
#[non_exhaustive]
#[derive(Copy, Clone, Debug)]
pub enum OperationErrorKind {
    /// Indicates that one or more sparsity patterns involved in the operation violate the
    /// expectations of the routine.
    ///
    /// For example, this could indicate that the sparsity pattern of the output is not able to
    /// contain the result of the operation.
    InvalidPattern,

    /// Indicates that a matrix is singular when it is expected to be invertible.
    Singular,
}

impl OperationError {
    fn from_kind_and_message(error_type: OperationErrorKind, message: String) -> Self {
        Self {
            error_kind: error_type,
            message,
        }
    }

    /// The operation error kind.
    #[must_use]
    pub fn kind(&self) -> &OperationErrorKind {
        &self.error_kind
    }

    /// The underlying error message.
    #[must_use]
    pub fn message(&self) -> &str {
        self.message.as_str()
    }
}

impl fmt::Display for OperationError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Sparse matrix operation error: ")?;
        match self.kind() {
            OperationErrorKind::InvalidPattern => {
                write!(f, "InvalidPattern")?;
            }
            OperationErrorKind::Singular => {
                write!(f, "Singular")?;
            }
        }
        write!(f, " Message: {}", self.message)
    }
}

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