Wavelet transforms.
AI & ML features.

use ferro_wave::{Signal, Daubechies, DaubechiesType};
use ferro_wave::analysis::denoising::{denoise_modwt,
             DenoiseConfig, ThresholdMethod, ThresholdRule};

let signal = Signal::from_slice(&tick_returns);
let wavelet = Daubechies::new(DaubechiesType::Db4);

let config = DenoiseConfig {
    method: ThresholdMethod::Soft,
    rule:   ThresholdRule::Universal,
    levels: 4,
    ..DenoiseConfig::default()
};

let clean = denoise_modwt(&signal, &wavelet, config)?;
// clean.len() == signal.len()  — no padding artefacts
// Jumps preserved; gaussian micro-noise attenuated

use ferro_wave::{Signal, Haar, BoundaryMode, dwt};
use ferro_wave::analysis::denoising::{estimate_noise_mad,
             compute_threshold, ThresholdRule};

let signal = Signal::from_slice(&prices);
let coeffs = dwt(&signal, &Haar::new(), BoundaryMode::Periodic)?;

// MAD-robust noise on finest detail
let sigma     = estimate_noise_mad(&coeffs.detail);
let threshold = compute_threshold(
    &coeffs.detail, sigma, ThresholdRule::Universal,
    signal.len());   // universal uses N, not detail.len()

let jumps: Vec<usize> = coeffs.detail.iter()
    .enumerate()
    .filter(|(_, &d)| d.abs() > threshold)
    .map(|(i, _)| i * 2)   // Haar stride
    .collect();

use ferro_wave::{Daubechies, DaubechiesType};
use ferro_wave::analysis::multifractal::{
             estimate_hurst_exponent, HurstResult, MultifractalConfig};

let wavelet = Daubechies::new(DaubechiesType::Db4);
let config  = MultifractalConfig::for_hurst_only();

let h: HurstResult = estimate_hurst_exponent(
    &log_returns, &wavelet, Some(config))?;

if h.saturated {
    // integrated input (prices, log-prices) — not a regime signal
    skip_regime_switch();
} else {
    match h.hurst_exponent {
        x if x < 0.45 => switch_to_mean_revert(),
        x if x > 0.55 => switch_to_trend_follow(),
        _ => keep_neutral(),
    }
}

// h.confidence_interval — half-width at config.confidence_level
// h.r_squared           — log-log fit quality

use ferro_wave::Signal;
use ferro_wave::transform::{emd, EMDConfig, IMF};

let signal = Signal::new(log_returns.to_vec());
let config = EMDConfig::default()
    .with_max_imfs(6)
    .with_max_sifting_iterations(50);

let result = emd(&signal, &config)?;

for (i, imf) in result.imfs.iter().enumerate() {
    // imf.data — same length as signal
    // imf is band-limited around one local freq
}
// result.residual — monotonic trend
// result.orthogonality_index() — Huang 1998 Eq. 5.5
// result.mode_mixing_index() — per-IMF spectral overlap

// Drop in CEEMDAN, MEMD, VMD, EWT, or SST for
// the same IMF contract over a different decomposer.