anofox-forecast 0.15.8

Time series forecasting 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
135
136
137
138
139
140
141

//! Error types for the anofox-forecast library.

use thiserror::Error;

/// Result type alias for forecast operations.
pub type Result<T> = std::result::Result<T, ForecastError>;

/// Errors that can occur during forecasting operations.
#[derive(Error, Debug, Clone, PartialEq)]
pub enum ForecastError {
    /// Input data is empty.
    #[error("empty input data")]
    EmptyData,

    /// Insufficient data points for the operation.
    #[error("insufficient data: need at least {needed}, got {got}{}", .hint.as_deref().map(|h| format!(" ({})", h)).unwrap_or_default())]
    InsufficientData {
        needed: usize,
        got: usize,
        hint: Option<String>,
    },

    /// Invalid parameter value.
    #[error("invalid parameter: {0}")]
    InvalidParameter(String),

    /// Dimension mismatch between data structures.
    #[error("dimension mismatch: expected {expected}, got {got}")]
    DimensionMismatch { expected: usize, got: usize },

    /// Timestamp-related error.
    #[error("timestamp error: {0}")]
    TimestampError(String),

    /// Model has not been fitted yet.
    #[error("{}", match model { Some(m) => format!("Model '{}' must be fitted before prediction", m), None => "model must be fitted before prediction".to_string() })]
    FitRequired { model: Option<String> },

    /// A sub-model within an ensemble or composite model failed.
    #[error("sub-model '{model_name}' failed: {source}")]
    SubModelError {
        model_name: String,
        source: Box<ForecastError>,
    },

    /// Missing values detected when not allowed.
    #[error("missing values detected in data")]
    MissingValues,

    /// Frequency inference failed.
    #[error("could not infer frequency: {0}")]
    FrequencyInference(String),

    /// Index out of bounds.
    #[error("index out of bounds: {index} (size: {size})")]
    IndexOutOfBounds { index: usize, size: usize },

    /// Computation error (e.g., numerical issues).
    #[error("computation error: {0}")]
    ComputationError(String),

    /// Convergence failure during optimization or model fitting.
    #[error("convergence failure: {0}")]
    ConvergenceFailure(String),

    /// Linear algebra failure (e.g., singular matrix, failed decomposition).
    #[error("singular matrix: {0}")]
    SingularMatrix(String),

    /// Serialization or persistence error.
    #[error("serialization error: {0}")]
    SerializationError(String),
}

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

    #[test]
    fn error_messages_are_descriptive() {
        let err = ForecastError::EmptyData;
        assert_eq!(err.to_string(), "empty input data");

        let err = ForecastError::InsufficientData {
            needed: 10,
            got: 5,
            hint: None,
        };
        assert_eq!(
            err.to_string(),
            "insufficient data: need at least 10, got 5"
        );

        let err = ForecastError::InsufficientData {
            needed: 10,
            got: 5,
            hint: Some("test hint".into()),
        };
        assert_eq!(
            err.to_string(),
            "insufficient data: need at least 10, got 5 (test hint)"
        );

        let err = ForecastError::InvalidParameter("window must be positive".to_string());
        assert_eq!(
            err.to_string(),
            "invalid parameter: window must be positive"
        );

        let err = ForecastError::DimensionMismatch {
            expected: 3,
            got: 2,
        };
        assert_eq!(err.to_string(), "dimension mismatch: expected 3, got 2");

        let err = ForecastError::FitRequired { model: None };
        assert_eq!(err.to_string(), "model must be fitted before prediction");

        let err = ForecastError::FitRequired {
            model: Some("TestModel".to_string()),
        };
        assert_eq!(
            err.to_string(),
            "Model 'TestModel' must be fitted before prediction"
        );

        let inner = ForecastError::EmptyData;
        let err = ForecastError::SubModelError {
            model_name: "SES".to_string(),
            source: Box::new(inner),
        };
        assert_eq!(err.to_string(), "sub-model 'SES' failed: empty input data");
    }

    #[test]
    fn errors_are_clonable_and_comparable() {
        let err1 = ForecastError::EmptyData;
        let err2 = err1.clone();
        assert_eq!(err1, err2);
    }
}