anofox-forecast

Time series forecasting library for Rust.

Provides 35+ forecasting models, 76+ statistical features, seasonality decomposition, changepoint detection, anomaly detection, and time series clustering. Rust port of anofox-time (C++).

Features

• Forecasting Models (35+)

  • ARIMA and AutoARIMA with automatic order selection
  • Exponential Smoothing: Simple (SES), Holt's Linear, Holt-Winters
  • ETS (Error-Trend-Seasonal) state-space framework with AutoETS
  • Baseline methods: Naive, Seasonal Naive, Random Walk with Drift, Simple Moving Average
  • Theta method for forecasting
  • Intermittent demand models: Croston, ADIDA, TSB
  • Ensemble methods with multiple combination strategies

• Time Series Feature Extraction (76+ features)

  • Basic statistics (mean, variance, quantiles, energy, etc.)
  • Distribution features (skewness, kurtosis, symmetry)
  • Autocorrelation and partial autocorrelation
  • Entropy features (approximate, sample, permutation, binned, Fourier)
  • Complexity measures (C3, CID, Lempel-Ziv)
  • Trend analysis and stationarity tests (ADF, KPSS)

• Seasonality & Decomposition

  • STL (Seasonal-Trend decomposition using LOESS)
  • MSTL (Multiple Seasonal-Trend decomposition) for complex seasonality

• Periodicity Detection

  • ACF-based period detection
  • FFT-based spectral analysis
  • Autoperiod (hybrid FFT+ACF, Vlachos et al. 2005)
  • CFD-Autoperiod (noise-resistant with clustering)
  • SAZED ensemble (parameter-free, combines multiple methods)

• Changepoint Detection

  • PELT algorithm with O(n) average complexity
  • Multiple cost functions: L1, L2, Normal, Poisson

• Anomaly Detection

  • Statistical methods (IQR, z-score)
  • Automatic threshold selection
  • Seasonality-aware detection

• Time Series Clustering

  • Dynamic Time Warping (DTW) distance
  • K-Means clustering with multiple distance metrics
  • Elbow method for optimal cluster selection

• Data Transformations

  • Scaling: standardization, min-max, robust scaling
  • Box-Cox transformation with automatic lambda selection
  • Window functions: rolling mean, std, min, max, median
  • Exponential weighted moving averages

• Model Evaluation & Validation

  • Accuracy metrics: MAE, MSE, RMSE, MAPE, and more
  • Time series cross-validation
  • Residual testing and diagnostics

Installation

Add this to your Cargo.toml:

[dependencies]
anofox-forecast = "0.1"

Quick Start

Creating a Time Series

use anofox_forecast::prelude::*;
use chrono::{TimeZone, Utc};

// Create timestamps
let timestamps: Vec<_> = (0..100)
    .map(|i| Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap() + chrono::Duration::days(i))
    .collect();

// Create values
let values: Vec<f64> = (0..100).map(|i| (i as f64 * 0.1).sin() + 10.0).collect();

// Build the time series
let ts = TimeSeries::builder()
    .timestamps(timestamps)
    .values(values)
    .build()?;

ARIMA Forecasting

use anofox_forecast::prelude::*;
use anofox_forecast::models::arima::Arima;

// Create and fit an ARIMA(1,1,1) model
let mut model = Arima::new(1, 1, 1)?;
model.fit(&ts)?;

// Generate forecasts with 95% confidence intervals
let forecast = model.predict_with_intervals(12, 0.95)?;

println!("Point forecasts: {:?}", forecast.values());
println!("Lower bounds: {:?}", forecast.lower());
println!("Upper bounds: {:?}", forecast.upper());

Holt-Winters Forecasting

use anofox_forecast::models::exponential::HoltWinters;

// Create Holt-Winters with additive seasonality (period = 12)
let mut model = HoltWinters::additive(12)?;
model.fit(&ts)?;

let forecast = model.predict(24)?;

Feature Extraction

use anofox_forecast::features::{mean, variance, skewness, approximate_entropy};

let values = ts.values();

let m = mean(values);
let v = variance(values);
let s = skewness(values);
let ae = approximate_entropy(values, 2, 0.2)?;

println!("Mean: {}, Variance: {}, Skewness: {}, ApEn: {}", m, v, s, ae);

STL Decomposition

use anofox_forecast::seasonality::Stl;

// Decompose with seasonal period of 12
let stl = Stl::new(12)?;
let decomposition = stl.decompose(&ts)?;

println!("Trend: {:?}", decomposition.trend());
println!("Seasonal: {:?}", decomposition.seasonal());
println!("Remainder: {:?}", decomposition.remainder());

Changepoint Detection

use anofox_forecast::changepoint::{Pelt, CostFunction};

let pelt = Pelt::new(CostFunction::L2, 10.0)?;
let changepoints = pelt.detect(&ts)?;

println!("Changepoints at indices: {:?}", changepoints);

Periodicity Detection

use anofox_forecast::detection::{
    detect_period, detect_period_ensemble, Autoperiod, PeriodicityDetector,
};

// Quick detection with default settings
let result = detect_period(&values);
println!("Detected period: {:?}", result.primary_period);

// Ensemble method (combines ACF, FFT, and other detectors)
let result = detect_period_ensemble(&values);
println!("Period: {:?}, Confidence: {:.2}", result.primary_period, result.confidence());

// Custom detector with specific parameters
let detector = Autoperiod::new(2, 365, 3.0, 0.2);
let result = detector.detect(&values);
for p in &result.periods {
    println!("Period: {}, Score: {:.4}, Source: {:?}", p.period, p.score, p.source);
}

API Reference

Core Types

Forecasting Models

Feature Categories

Dependencies

• chrono - Date and time handling
• faer - Linear algebra operations
• statrs - Statistical distributions and functions
• thiserror - Error handling
• rand - Random number generation
• rustfft - Fast Fourier Transform for periodicity detection

License

MIT License - see LICENSE for details.