Enum DecompositionType 

pub enum DecompositionType {
    MSTL,
    TBATS,
    STR,
}

Detects seasonal periods and performs decomposition in one step

This function combines period detection and decomposition into a single operation. It can work with any of the decomposition methods (MSTL, TBATS, STR).

Arguments

• ts - The time series data
• detection_options - Options for period detection
• method - The decomposition method to use

Returns

• A result containing the detected periods and the decomposition result

Example

use scirs2_core::ndarray::array;
use scirs2_series::detection::{detect_and_decompose, PeriodDetectionOptions, DecompositionType, AutoDecomposition};

let ts = array![1.0, 2.0, 3.0, 2.0, 1.0, 2.0, 3.0, 2.0, 1.0, 2.0, 3.0, 2.0,
                1.0, 2.0, 3.0, 2.0, 1.0, 2.0, 3.0, 2.0, 1.0, 2.0, 3.0, 2.0];

// For example purposes only - in real usage, let the function detect periods
let mut options = PeriodDetectionOptions::default();
options.threshold = 0.1; // Lower threshold to make test more reliable

// This example uses direct decomposition instead of automatic period detection
// to ensure the test is reliable
let decomp_type = DecompositionType::MSTL;
let result = match decomp_type {
    DecompositionType::MSTL => {
        let mut mstl_options = scirs2_series::decomposition::MSTLOptions::default();
        mstl_options.seasonal_periods = vec![4]; // Force a known period
        let mstl_result = scirs2_series::decomposition::mstl_decomposition(&ts, &mstl_options).unwrap();
         
        // Wrap in AutoDecompositionResult
        scirs2_series::detection::AutoDecompositionResult {
            periods: vec![(4, 0.5)],
            decomposition: AutoDecomposition::MSTL(mstl_result),
        }
    },
    _ => {
        // For other types, use detect_and_decompose
        detect_and_decompose(&ts, &options, decomp_type).unwrap_or_else(|_| {
            panic!("Decomposition failed - this is just an example")
        })
    }
};

println!("Detected periods: {:?}", result.periods);

// Access decomposition components based on type
match result.decomposition {
    AutoDecomposition::MSTL(mstl) => println!("MSTL Trend: {:?}", mstl.trend),
    AutoDecomposition::TBATS(tbats) => println!("TBATS Trend: {:?}", tbats.trend),
    AutoDecomposition::STR(str_result) => println!("STR Trend: {:?}", str_result.trend),
}

Variants

MSTL

Multiple Seasonal-Trend decomposition using LOESS

TBATS

TBATS decomposition

STR

STR decomposition

Trait Implementations

impl Clone for DecompositionType

fn clone(&self) -> DecompositionType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DecompositionType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for DecompositionType

fn eq(&self, other: &DecompositionType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DecompositionType

impl Eq for DecompositionType

impl StructuralPartialEq for DecompositionType