124 lines
3.4 KiB
Rust
124 lines
3.4 KiB
Rust
//! Error types for the time series forecast demo
|
|
|
|
use thiserror::Error;
|
|
|
|
/// Result type for forecaster operations
|
|
pub type Result<T> = std::result::Result<T, ForecastError>;
|
|
|
|
/// Errors that can occur during time series forecasting
|
|
#[derive(Debug, Error)]
|
|
pub enum ForecastError {
|
|
/// Model not initialized
|
|
#[error("Forecaster not initialized. Fit a model first.")]
|
|
NotInitialized,
|
|
|
|
/// Invalid data
|
|
#[error("Invalid data: {0}")]
|
|
InvalidData(String),
|
|
|
|
/// Model fitting error
|
|
#[error("Model fitting failed: {0}")]
|
|
FittingError(String),
|
|
|
|
/// Forecast generation error
|
|
#[error("Forecast generation failed: {0}")]
|
|
ForecastError(String),
|
|
|
|
/// Time series library error
|
|
#[error("Time series error: {0}")]
|
|
TimeSeriesError(String),
|
|
|
|
/// Tensor operation error
|
|
#[error("Tensor error: {0}")]
|
|
TensorError(String),
|
|
|
|
/// Configuration error
|
|
#[error("Invalid configuration: {0}")]
|
|
ConfigError(String),
|
|
|
|
/// Sample data error
|
|
#[error("Sample data error: {0}")]
|
|
SampleDataError(String),
|
|
}
|
|
|
|
impl From<rtx_timeseries::TimeSeriesError> for ForecastError {
|
|
fn from(e: rtx_timeseries::TimeSeriesError) -> Self {
|
|
Self::TimeSeriesError(e.to_string())
|
|
}
|
|
}
|
|
|
|
impl From<rtx_tensor::error::TensorError> for ForecastError {
|
|
fn from(e: rtx_tensor::error::TensorError) -> Self {
|
|
Self::TensorError(e.to_string())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_not_initialized_error() {
|
|
let err = ForecastError::NotInitialized;
|
|
assert!(err.to_string().contains("not initialized"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_data_error() {
|
|
let err = ForecastError::InvalidData("empty data".to_string());
|
|
assert!(err.to_string().contains("empty data"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_fitting_error() {
|
|
let err = ForecastError::FittingError("convergence failed".to_string());
|
|
assert!(err.to_string().contains("convergence failed"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_forecast_error() {
|
|
let err = ForecastError::ForecastError("horizon too large".to_string());
|
|
assert!(err.to_string().contains("horizon too large"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_time_series_error() {
|
|
let err = ForecastError::TimeSeriesError("invalid parameters".to_string());
|
|
assert!(err.to_string().contains("invalid parameters"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_tensor_error() {
|
|
let err = ForecastError::TensorError("shape mismatch".to_string());
|
|
assert!(err.to_string().contains("shape mismatch"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_config_error() {
|
|
let err = ForecastError::ConfigError("invalid model type".to_string());
|
|
assert!(err.to_string().contains("invalid model type"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_sample_data_error() {
|
|
let err = ForecastError::SampleDataError("distribution failed".to_string());
|
|
assert!(err.to_string().contains("distribution failed"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_error_debug_format() {
|
|
let err = ForecastError::NotInitialized;
|
|
let debug_str = format!("{:?}", err);
|
|
assert!(debug_str.contains("NotInitialized"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_result_type() {
|
|
let ok_result: Result<i32> = Ok(42);
|
|
assert!(ok_result.is_ok());
|
|
|
|
let err_result: Result<i32> = Err(ForecastError::NotInitialized);
|
|
assert!(err_result.is_err());
|
|
}
|
|
}
|