numra-optim 0.1.2

Optimization for Numra: BFGS, L-BFGS, L-BFGS-B, Levenberg-Marquardt, Nelder-Mead, CMA-ES, SQP, LP/MILP, augmented Lagrangian, NSGA-II.
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
135

//! Error types for optimization algorithms.
//!
//! Author: Moussa Leblouba
//! Date: 8 February 2026
//! Modified: 2 May 2026

use numra_core::NumraError;
use thiserror::Error;

/// Errors that can occur during optimization.
#[derive(Debug, Error)]
pub enum OptimError {
    #[error("line search failed at iteration {iteration}: {reason}")]
    LineSearchFailed { iteration: usize, reason: String },
    #[error("not a descent direction (dg = {directional_derivative:.2e})")]
    NotDescentDirection { directional_derivative: f64 },
    #[error("invalid function value: {value}")]
    InvalidFunctionValue { value: f64 },
    #[error("singular matrix in solver")]
    SingularMatrix,
    #[error("dimension mismatch: expected {expected}, got {actual}")]
    DimensionMismatch { expected: usize, actual: usize },
    #[error("no objective function specified")]
    NoObjective,
    #[error("no initial point specified")]
    NoInitialPoint,
    #[error("infeasible: constraint violation = {violation:.2e}")]
    Infeasible { violation: f64 },
    #[error("problem is unbounded")]
    Unbounded,
    #[error("linear program is infeasible")]
    LPInfeasible,
    #[error("QP Hessian is not positive semi-definite")]
    QPNotPositiveSemiDefinite,
    #[error("mixed-integer linear program is infeasible")]
    MILPInfeasible,
    #[error("{0}")]
    Other(String),
}

impl From<String> for OptimError {
    fn from(s: String) -> Self {
        OptimError::Other(s)
    }
}

impl From<&str> for OptimError {
    fn from(s: &str) -> Self {
        OptimError::Other(s.to_string())
    }
}

impl From<numra_nonlinear::LineSearchError> for OptimError {
    fn from(e: numra_nonlinear::LineSearchError) -> Self {
        OptimError::Other(e.to_string())
    }
}

impl From<numra_nonlinear::LinalgError> for OptimError {
    fn from(e: numra_nonlinear::LinalgError) -> Self {
        match e {
            numra_nonlinear::LinalgError::Singular { .. }
            | numra_nonlinear::LinalgError::NotSquare { .. }
            | numra_nonlinear::LinalgError::NotPositiveDefinite => OptimError::SingularMatrix,
            numra_nonlinear::LinalgError::DimensionMismatch { expected, actual } => {
                OptimError::DimensionMismatch {
                    expected: expected.0,
                    actual: actual.0,
                }
            }
            _ => OptimError::Other(e.to_string()),
        }
    }
}

impl From<OptimError> for NumraError {
    fn from(e: OptimError) -> Self {
        NumraError::Optim(e.to_string())
    }
}

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

    #[test]
    fn test_display_formatting() {
        let e = OptimError::LineSearchFailed {
            iteration: 5,
            reason: "step too small".into(),
        };
        assert_eq!(
            e.to_string(),
            "line search failed at iteration 5: step too small"
        );

        let e = OptimError::NotDescentDirection {
            directional_derivative: 1.5,
        };
        assert!(e.to_string().contains("1.50e0"));

        let e = OptimError::SingularMatrix;
        assert_eq!(e.to_string(), "singular matrix in solver");

        let e = OptimError::DimensionMismatch {
            expected: 3,
            actual: 5,
        };
        assert_eq!(e.to_string(), "dimension mismatch: expected 3, got 5");
    }

    #[test]
    fn test_lp_qp_error_variants() {
        let e = OptimError::Unbounded;
        assert_eq!(e.to_string(), "problem is unbounded");

        let e = OptimError::LPInfeasible;
        assert_eq!(e.to_string(), "linear program is infeasible");

        let e = OptimError::QPNotPositiveSemiDefinite;
        assert_eq!(e.to_string(), "QP Hessian is not positive semi-definite");

        let e = OptimError::MILPInfeasible;
        assert_eq!(e.to_string(), "mixed-integer linear program is infeasible");
    }

    #[test]
    fn test_from_string() {
        let e: OptimError = "some error".into();
        assert_eq!(e.to_string(), "some error");

        let e: OptimError = String::from("another error").into();
        assert_eq!(e.to_string(), "another error");
    }
}