SciRS2 Series

[]

Production-ready time series analysis module for the SciRS2 scientific computing library (v0.1.0-rc.2). Following the SciRS2 POLICY, this Release Candidate 2 provides comprehensive, tested, and optimized tools for analyzing, decomposing, and forecasting time series data with feature parity to leading Python libraries, zero-warning code quality, and ecosystem consistency through scirs2-core abstractions.

Features

Core Capabilities:

Advanced Decomposition: STL, TBATS, SSA, STR, Multi-seasonal decomposition, Robust variants
State-of-the-Art Forecasting: ARIMA/SARIMA, Auto-ARIMA, Exponential Smoothing (ETS), Holt-Winters
Comprehensive Analysis: Autocorrelation, partial autocorrelation, cross-correlation functions
Change Point & Anomaly Detection: PELT, CUSUM, Bayesian online detection, multiple anomaly methods
Feature Engineering: 60+ statistical, frequency, and complexity features with automated selection
Transformations: Box-Cox, differencing, normalization, stationarity tests
State-Space Models: Kalman filtering, structural time series, dynamic linear models
Causality Analysis: Granger causality, transfer entropy, causal impact analysis
Dimensionality Reduction: PCA, functional PCA, symbolic approximation
Clustering & Classification: Time series clustering, DTW-based methods, shapelet discovery

Production Features:

Zero-warning Codebase: All clippy warnings resolved, production-ready code quality
Comprehensive Testing: 137 unit tests, 43 doc tests, 100% core functionality coverage
Performance Optimized: SIMD acceleration, parallel processing, memory-efficient algorithms
Rust Ecosystem Integration: Full ndarray support, compatible with scientific Rust ecosystem

Installation

Release Candidate 2 - Production Ready

Add the following to your Cargo.toml:

[dependencies]
scirs2-series = "0.1.0-rc.2"

Recommended for Production: Enable performance optimizations:

[dependencies]
scirs2-series = { version = "0.1.0-rc.2", features = ["parallel", "simd"] }
scirs2-core = { version = "0.1.0-rc.2", features = ["parallel", "simd"] }

Available Features:

parallel: Multi-threaded processing for large datasets
simd: SIMD acceleration for numerical operations
caching: Advanced caching for repeated computations

Usage

Basic usage examples:

use scirs2_series::{utils, decomposition, forecasting, features};
use scirs2_core::error::CoreResult;
use ndarray::array;

// Create a simple time series
fn time_series_example() -> CoreResult<()> {
    // Sample time series data
    let data = array![10.0, 11.0, 12.0, 11.5, 11.0, 10.5, 11.2, 12.5, 13.0, 12.7, 
                      12.0, 11.8, 12.2, 13.5, 14.0, 13.5, 13.0, 12.5, 13.0, 14.5];
    
    // Autocorrelation
    let acf = utils::autocorrelation(&data, 5)?;
    println!("Autocorrelation: {:?}", acf);
    
    // Partial autocorrelation
    let pacf = utils::partial_autocorrelation(&data, 5)?;
    println!("Partial autocorrelation: {:?}", pacf);
    
    // Decompose time series
    let decomposition = decomposition::seasonal_decompose(&data, 4, None, None)?;
    
    println!("Trend: {:?}", decomposition.trend);
    println!("Seasonal: {:?}", decomposition.seasonal);
    println!("Residual: {:?}", decomposition.resid);
    
    // Extract features
    let mean = features::mean(&data)?;
    let std_dev = features::standard_deviation(&data)?;
    let min = features::minimum(&data)?;
    let max = features::maximum(&data)?;
    
    println!("Time series features:");
    println!("Mean: {}", mean);
    println!("Standard deviation: {}", std_dev);
    println!("Min: {}", min);
    println!("Max: {}", max);
    
    // Forecast future values (simple moving average)
    let forecast = forecasting::moving_average_forecast(&data, 3, 5)?;
    println!("Forecast (next 5 points): {:?}", forecast);
    
    Ok(())
}

Components

Time Series Utilities

Functions for time series analysis:

use scirs2_series::utils::{
    autocorrelation,        // Calculate autocorrelation function
    partial_autocorrelation, // Calculate partial autocorrelation function
    cross_correlation,      // Calculate cross-correlation between two series
    lag_plot,               // Create lag plot data
    seasonal_plot,          // Create seasonal plot data
    difference,             // Difference a time series
    seasonal_difference,    // Apply seasonal differencing
    inverse_difference,     // Invert differencing
    lag_series,             // Create lagged versions of a time series
};

Decomposition

Methods for time series decomposition:

use scirs2_series::decomposition::{
    seasonal_decompose,     // Seasonal decomposition (additive or multiplicative)
    stl_decompose,          // STL decomposition (Seasonal-Trend decomposition using LOESS)
    hp_filter,              // Hodrick-Prescott filter
};

Forecasting

Time series forecasting methods:

use scirs2_series::forecasting::{
    moving_average_forecast, // Moving average forecast
    exponential_smoothing,  // Simple exponential smoothing
    double_exponential_smoothing, // Double exponential smoothing (Holt's method)
    triple_exponential_smoothing, // Triple exponential smoothing (Holt-Winters method)
    arima_forecast,         // ARIMA forecast
    sarima_forecast,        // Seasonal ARIMA forecast
};

Feature Extraction

Functions for extracting features from time series:

use scirs2_series::features::{
    // Basic Statistics
    mean,                   // Calculate mean
    standard_deviation,     // Calculate standard deviation
    minimum,                // Find minimum value
    maximum,                // Find maximum value
    
    // Trend Features
    trend_strength,         // Calculate trend strength
    seasonality_strength,   // Calculate seasonality strength
    
    // Complexity Measures
    entropy,                // Calculate entropy
    approximate_entropy,    // Calculate approximate entropy
    sample_entropy,         // Calculate sample entropy
    
    // Spectral Features
    spectral_entropy,       // Calculate spectral entropy
    dominant_frequency,     // Find dominant frequency
    
    // Other Features
    turning_points,         // Count turning points
    crossing_points,        // Count crossing points
    autocorrelation_features, // Extract autocorrelation features
};

Advanced Features

STL Decomposition

Seasonal-Trend decomposition using LOESS (STL):

use scirs2_series::decomposition::stl_decompose;
use ndarray::Array1;

// Sample time series
let data = Array1::from_vec(vec![/* time series data */]);

// STL decomposition parameters
let period = 12; // For monthly data
let robust = true;
let seasonal_degree = 1;
let seasonal_jump = 1;
let seasonal_window = 13;
let trend_degree = 1;
let trend_jump = 1;
let trend_window = 21;
let inner_iter = 2;
let outer_iter = 1;

// Perform STL decomposition
let decomposition = stl_decompose(&data, period, robust, 
                                 seasonal_degree, seasonal_jump, seasonal_window,
                                 trend_degree, trend_jump, trend_window,
                                 inner_iter, outer_iter).unwrap();

println!("Trend component: {:?}", decomposition.trend);
println!("Seasonal component: {:?}", decomposition.seasonal);
println!("Residual component: {:?}", decomposition.resid);

ARIMA Forecasting

Autoregressive Integrated Moving Average (ARIMA) model:

use scirs2_series::forecasting::arima_forecast;
use ndarray::Array1;

// Sample time series
let data = Array1::from_vec(vec![/* time series data */]);

// ARIMA parameters
let p = 1; // AR order
let d = 1; // Differencing order
let q = 1; // MA order

// Forecast horizon
let steps = 10;

// Perform ARIMA forecast
let (forecast, conf_intervals) = arima_forecast(&data, p, d, q, steps, 0.95).unwrap();

println!("ARIMA({},{},{}) forecast: {:?}", p, d, q, forecast);
println!("95% confidence intervals: {:?}", conf_intervals);

Contributing

See the CONTRIBUTING.md file for contribution guidelines.

License

This project is dual-licensed under:

You can choose to use either license. See the LICENSE file for details.

scirs2-series 0.1.0-rc.2