resopt 0.3.0

Declarative constrained residual optimization in Rust
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

use std::fmt;

/// Public error type for the crate.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
    InvalidMatrixShape { expected: usize, got: usize },
    DimensionMismatch { message: String },
    InvalidParameter { message: String },
    MissingField { field: &'static str },
    SolverFailure { message: String },
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidMatrixShape { expected, got } => {
                write!(
                    f,
                    "invalid matrix shape: expected {} coefficients, got {}",
                    expected, got
                )
            }
            Self::DimensionMismatch { message } => {
                write!(f, "dimension mismatch: {}", message)
            }
            Self::InvalidParameter { message } => {
                write!(f, "invalid parameter: {}", message)
            }
            Self::MissingField { field } => {
                write!(f, "missing required field: {}", field)
            }
            Self::SolverFailure { message } => {
                write!(f, "solver failure: {}", message)
            }
        }
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn display_invalid_matrix_shape() {
        let e = Error::InvalidMatrixShape {
            expected: 6,
            got: 4,
        };
        let msg = format!("{}", e);
        assert!(msg.contains("6") && msg.contains("4"));
    }

    #[test]
    fn display_dimension_mismatch() {
        let e = Error::DimensionMismatch {
            message: "test dim".into(),
        };
        assert!(format!("{}", e).contains("test dim"));
    }

    #[test]
    fn display_invalid_parameter() {
        let e = Error::InvalidParameter {
            message: "bad param".into(),
        };
        assert!(format!("{}", e).contains("bad param"));
    }

    #[test]
    fn display_missing_field() {
        let e = Error::MissingField { field: "loss" };
        assert!(format!("{}", e).contains("loss"));
    }

    #[test]
    fn display_solver_failure() {
        let e = Error::SolverFailure {
            message: "boom".into(),
        };
        assert!(format!("{}", e).contains("boom"));
    }

    #[test]
    fn is_std_error() {
        let e: Box<dyn std::error::Error> = Box::new(Error::SolverFailure {
            message: "test".into(),
        });
        assert!(format!("{}", e).contains("test"));
    }
}