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

//! Define Errors

use ndarray::{Ixs, ShapeError};
use std::error;
use std::fmt;

pub type Result<T> = ::std::result::Result<T, LinalgError>;

/// Master Error type of this crate
#[derive(Debug)]
pub enum LinalgError {
    /// Matrix is not square
    NotSquare { rows: i32, cols: i32 },
    /// LAPACK subroutine returns non-zero code
    Lapack { return_code: i32 },
    /// Strides of the array is not supported
    InvalidStride { s0: Ixs, s1: Ixs },
    /// Memory is not aligned continously
    MemoryNotCont,
    /// Obj cannot be made from a (rows, cols) matrix
    NotStandardShape {
        obj: &'static str,
        rows: i32,
        cols: i32,
    },
    /// Strides of the array is not supported
    Shape(ShapeError),
}

impl fmt::Display for LinalgError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            LinalgError::NotSquare { rows, cols } => {
                write!(f, "Not square: rows({}) != cols({})", rows, cols)
            }
            LinalgError::Lapack { return_code } => {
                write!(f, "LAPACK: return_code = {}", return_code)
            }
            LinalgError::InvalidStride { s0, s1 } => {
                write!(f, "invalid stride: s0={}, s1={}", s0, s1)
            }
            LinalgError::MemoryNotCont => write!(f, "Memory is not contiguous"),
            LinalgError::NotStandardShape { obj, rows, cols } => write!(
                f,
                "{} cannot be made from a ({}, {}) matrix",
                obj, rows, cols
            ),
            LinalgError::Shape(err) => write!(f, "Shape Error: {}", err),
        }
    }
}

impl error::Error for LinalgError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            LinalgError::Shape(err) => Some(err),
            _ => None,
        }
    }
}

impl From<ShapeError> for LinalgError {
    fn from(error: ShapeError) -> LinalgError {
        LinalgError::Shape(error)
    }
}