feat(family-10): add 16 Ehlers / Cycle (DSP) indicators (#49)

Implements Family 10 (Ehlers / Cycle) end-to-end across Rust core, Python / Node / WASM bindings, fuzz, tests, benches and docs. This is an entirely new family covering John Ehlers' digital-signal- processing school of cycle analytics — a strong differentiator versus TA-Lib and pandas-ta, which ship only fragments. Indicators: - MAMA (Mesa Adaptive MA) — multi-output { mama, fama } - FAMA (Following Adaptive MA) — scalar wrapper around MAMA's slow line - Fisher Transform — Gaussian-normalising price transform - Inverse Fisher Transform — bounded oscillator (tanh-based) - SuperSmoother — 2-pole Butterworth lowpass - Roofing Filter — high-pass + SuperSmoother bandpass - Decycler — price minus 2-pole high-pass (lag-free trend) - Decycler Oscillator — fast / slow Decycler difference (MACD-like) - Hilbert Dominant Cycle — phase-derived period estimator [6, 50] - Sine Wave Indicator — sin(phase) with 45° lead companion - Adaptive Cycle Indicator — half-period driver for adaptive oscillators - Center of Gravity Oscillator — weighted-mass momentum - Cybernetic Cycle Component — EasyLanguage classic - Empirical Mode Decomposition — bandpass + envelope mean - Ehlers Stochastic — Stochastic on Roofing Filter input, [-1, +1] - Instantaneous Trendline — Ehlers 2-pole lag-free trend Indicator count rises 71 -> 87 across nine families (was eight). All sixteen pass batch == streaming equivalence, expose the standard Indicator surface (update / batch / reset / is_ready / warmup_period / name), are fuzz-tested, benchmarked against the checked-in BTCUSDT 1-minute dataset and reach across all four bindings. Wiki deep-dive drafts for every indicator + Sidebar / Overview / Home / Warmup updates are staged under indicator-ideas/families/ wiki/family-10-ehlers-cycle/ in the main repo (ghost-ignored) for the maintainer to publish to the wiki repo manually.
2026-05-25 22:14:27 +02:00
parent 4f9ed34884
commit 7a18a26daf
34 changed files with 4947 additions and 46 deletions
@@ -75,6 +75,22 @@ const scalarFactories = {
  LaguerreRSI: () => new wickra.LaguerreRSI(0.5),
  ConnorsRSI: () => new wickra.ConnorsRSI(3, 2, 100),
  RVIVolatility: () => new wickra.RVIVolatility(10),
+  // Family 10 — Ehlers / Cycle
+  SuperSmoother: () => new wickra.SuperSmoother(10),
+  FisherTransform: () => new wickra.FisherTransform(10),
+  InverseFisherTransform: () => new wickra.InverseFisherTransform(1.0),
+  Decycler: () => new wickra.Decycler(20),
+  DecyclerOscillator: () => new wickra.DecyclerOscillator(10, 30),
+  RoofingFilter: () => new wickra.RoofingFilter(10, 48),
+  CenterOfGravity: () => new wickra.CenterOfGravity(10),
+  CyberneticCycle: () => new wickra.CyberneticCycle(10),
+  InstantaneousTrendline: () => new wickra.InstantaneousTrendline(20),
+  EhlersStochastic: () => new wickra.EhlersStochastic(20),
+  EmpiricalModeDecomposition: () => new wickra.EmpiricalModeDecomposition(20, 0.5),
+  HilbertDominantCycle: () => new wickra.HilbertDominantCycle(),
+  AdaptiveCycle: () => new wickra.AdaptiveCycle(),
+  SineWave: () => new wickra.SineWave(),
+  FAMA: () => new wickra.FAMA(0.5, 0.05),
 };

 for (const [name, make] of Object.entries(scalarFactories)) {
@@ -213,6 +229,8 @@ const multi = {
  TDLines: { make: () => new wickra.TDLines(4, 9), fields: ['resistance', 'support'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
  TDRangeProjection: { make: () => new wickra.TDRangeProjection(), fields: ['high', 'low'], step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
  TDRiskLevel: { make: () => new wickra.TDRiskLevel(4, 9), fields: ['buyRisk', 'sellRisk'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  // Family 10: Ehlers / Cycle (multi-output)
+  MAMA: { make: () => new wickra.MAMA(0.5, 0.05), fields: ['mama', 'fama'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
 };

 for (const [name, d] of Object.entries(multi)) {
@@ -310,7 +310,7 @@ if (!nativeBinding) {
  throw new Error(`Failed to load native binding`)
 }

-const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, MACD, BollingerBands, ATR, Stochastic, OBV, ADX, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, KAMA, RVI, PGO, KST, SMI, LaguerreRSI, ConnorsRSI, Inertia, ALMA, McGinleyDynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA, APO, AwesomeOscillatorHistogram, CFO, ZeroLagMACD, ElderImpulse, STC, T3, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, EaseOfMovement, KVO, VolumeOscillator, NVI, PVI, WilliamsAD, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, Vortex, RWI, WaveTrend, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, RVIVolatility, ParkinsonVolatility, GarmanKlassVolatility, RogersSatchellVolatility, YangZhangVolatility, MaEnvelope, AccelerationBands, StarcBands, AtrBands, HurstChannel, LinRegChannel, StandardErrorBands, DoubleBollinger, TtmSqueeze, FractalChaosBands, VwapStdDevBands, ClassicPivots, FibonacciPivots, Camarilla, WoodiePivots, DemarkPivots, WilliamsFractals, ZigZag, TDSetup, TDSequential, TDDeMarker, TDREI, TDPressure, TDCombo, TDCountdown, TDLines, TDRangeProjection, TDDifferential, TDOpen, TDRiskLevel } = nativeBinding
+const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, MACD, BollingerBands, ATR, Stochastic, OBV, ADX, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, KAMA, RVI, PGO, KST, SMI, LaguerreRSI, ConnorsRSI, Inertia, ALMA, McGinleyDynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA, APO, AwesomeOscillatorHistogram, CFO, ZeroLagMACD, ElderImpulse, STC, T3, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, EaseOfMovement, KVO, VolumeOscillator, NVI, PVI, WilliamsAD, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, Vortex, RWI, WaveTrend, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, RVIVolatility, ParkinsonVolatility, GarmanKlassVolatility, RogersSatchellVolatility, YangZhangVolatility, MaEnvelope, AccelerationBands, StarcBands, AtrBands, HurstChannel, LinRegChannel, StandardErrorBands, DoubleBollinger, TtmSqueeze, FractalChaosBands, VwapStdDevBands, ClassicPivots, FibonacciPivots, Camarilla, WoodiePivots, DemarkPivots, WilliamsFractals, ZigZag, TDSetup, TDSequential, TDDeMarker, TDREI, TDPressure, TDCombo, TDCountdown, TDLines, TDRangeProjection, TDDifferential, TDOpen, TDRiskLevel, SuperSmoother, FisherTransform, InverseFisherTransform, Decycler, DecyclerOscillator, RoofingFilter, CenterOfGravity, CyberneticCycle, InstantaneousTrendline, EhlersStochastic, EmpiricalModeDecomposition, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA } = nativeBinding

 module.exports.version = version
 module.exports.SMA = SMA
@@ -461,3 +461,19 @@ module.exports.TDRangeProjection = TDRangeProjection
 module.exports.TDDifferential = TDDifferential
 module.exports.TDOpen = TDOpen
 module.exports.TDRiskLevel = TDRiskLevel
+module.exports.SuperSmoother = SuperSmoother
+module.exports.FisherTransform = FisherTransform
+module.exports.InverseFisherTransform = InverseFisherTransform
+module.exports.Decycler = Decycler
+module.exports.DecyclerOscillator = DecyclerOscillator
+module.exports.RoofingFilter = RoofingFilter
+module.exports.CenterOfGravity = CenterOfGravity
+module.exports.CyberneticCycle = CyberneticCycle
+module.exports.InstantaneousTrendline = InstantaneousTrendline
+module.exports.EhlersStochastic = EhlersStochastic
+module.exports.EmpiricalModeDecomposition = EmpiricalModeDecomposition
+module.exports.HilbertDominantCycle = HilbertDominantCycle
+module.exports.AdaptiveCycle = AdaptiveCycle
+module.exports.SineWave = SineWave
+module.exports.MAMA = MAMA
+module.exports.FAMA = FAMA
@@ -119,6 +119,23 @@ node_scalar_indicator!(ZScoreNode, "ZScore", wc::ZScore);
 node_scalar_indicator!(McGinleyDynamicNode, "McGinleyDynamic", wc::McGinleyDynamic);
 node_scalar_indicator!(FramaNode, "FRAMA", wc::Frama);

+// Family 10 — Ehlers / Cycle: single-period scalars.
+node_scalar_indicator!(SuperSmootherNode, "SuperSmoother", wc::SuperSmoother);
+node_scalar_indicator!(FisherTransformNode, "FisherTransform", wc::FisherTransform);
+node_scalar_indicator!(DecyclerNode, "Decycler", wc::Decycler);
+node_scalar_indicator!(CenterOfGravityNode, "CenterOfGravity", wc::CenterOfGravity);
+node_scalar_indicator!(CyberneticCycleNode, "CyberneticCycle", wc::CyberneticCycle);
+node_scalar_indicator!(
+    InstantaneousTrendlineNode,
+    "InstantaneousTrendline",
+    wc::InstantaneousTrendline
+);
+node_scalar_indicator!(
+    EhlersStochasticNode,
+    "EhlersStochastic",
+    wc::EhlersStochastic
+);
+
 // RviVolatility (Relative Volatility Index, Donald Dorsey). Disambiguated
 // from `RVI` = Relative Vigor Index in Family 02. Takes a single `period`
 // parameter and additionally rejects `period == 1` (a 1-bar standard
@@ -7389,3 +7406,343 @@ impl TdRiskLevelNode {
        self.inner.warmup_period() as u32
    }
 }
+
+// ============================== Family 10 — Ehlers / Cycle ==============================
+
+#[napi(js_name = "InverseFisherTransform")]
+pub struct InverseFisherTransformNode {
+    inner: wc::InverseFisherTransform,
+}
+
+#[napi]
+impl InverseFisherTransformNode {
+    #[napi(constructor)]
+    pub fn new(scale: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::InverseFisherTransform::new(scale).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "DecyclerOscillator")]
+pub struct DecyclerOscillatorNode {
+    inner: wc::DecyclerOscillator,
+}
+
+#[napi]
+impl DecyclerOscillatorNode {
+    #[napi(constructor)]
+    pub fn new(fast: u32, slow: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::DecyclerOscillator::new(fast as usize, slow as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "RoofingFilter")]
+pub struct RoofingFilterNode {
+    inner: wc::RoofingFilter,
+}
+
+#[napi]
+impl RoofingFilterNode {
+    #[napi(constructor)]
+    pub fn new(lp_period: u32, hp_period: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::RoofingFilter::new(lp_period as usize, hp_period as usize)
+                .map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "EmpiricalModeDecomposition")]
+pub struct EmpiricalModeDecompositionNode {
+    inner: wc::EmpiricalModeDecomposition,
+}
+
+#[napi]
+impl EmpiricalModeDecompositionNode {
+    #[napi(constructor)]
+    pub fn new(period: u32, fraction: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::EmpiricalModeDecomposition::new(period as usize, fraction)
+                .map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "HilbertDominantCycle")]
+pub struct HilbertDominantCycleNode {
+    inner: wc::HilbertDominantCycle,
+}
+
+#[napi]
+impl HilbertDominantCycleNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::HilbertDominantCycle::new(),
+        }
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "AdaptiveCycle")]
+pub struct AdaptiveCycleNode {
+    inner: wc::AdaptiveCycle,
+}
+
+#[napi]
+impl AdaptiveCycleNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::AdaptiveCycle::new(),
+        }
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "SineWave")]
+pub struct SineWaveNode {
+    inner: wc::SineWave,
+}
+
+#[napi]
+impl SineWaveNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::SineWave::new(),
+        }
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn lead(&self) -> f64 {
+        self.inner.lead()
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(object)]
+pub struct MamaValue {
+    pub mama: f64,
+    pub fama: f64,
+}
+
+#[napi(js_name = "MAMA")]
+pub struct MamaNode {
+    inner: wc::Mama,
+}
+
+#[napi]
+impl MamaNode {
+    #[napi(constructor)]
+    pub fn new(fast_limit: f64, slow_limit: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::Mama::new(fast_limit, slow_limit).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<MamaValue> {
+        self.inner.update(value).map(|o| MamaValue {
+            mama: o.mama,
+            fama: o.fama,
+        })
+    }
+    /// Returns a flat array of length `2 * n`: `[mama0, fama0, mama1, fama1, ...]`.
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        let mut out = vec![f64::NAN; prices.len() * 2];
+        for (i, p) in prices.iter().enumerate() {
+            if let Some(o) = self.inner.update(*p) {
+                out[i * 2] = o.mama;
+                out[i * 2 + 1] = o.fama;
+            }
+        }
+        out
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(js_name = "FAMA")]
+pub struct FamaNode {
+    inner: wc::Fama,
+}
+
+#[napi]
+impl FamaNode {
+    #[napi(constructor)]
+    pub fn new(fast_limit: f64, slow_limit: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::Fama::new(fast_limit, slow_limit).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    #[napi]
+    pub fn batch(&mut self, prices: Vec<f64>) -> Vec<f64> {
+        flatten(self.inner.batch(&prices))
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
@@ -149,6 +149,23 @@ from ._wickra import (
    LinRegSlope,
    ZScore,
    LinRegAngle,
+    # Ehlers / Cycle
+    SuperSmoother,
+    FisherTransform,
+    InverseFisherTransform,
+    Decycler,
+    DecyclerOscillator,
+    RoofingFilter,
+    CenterOfGravity,
+    CyberneticCycle,
+    InstantaneousTrendline,
+    EhlersStochastic,
+    EmpiricalModeDecomposition,
+    HilbertDominantCycle,
+    AdaptiveCycle,
+    SineWave,
+    MAMA,
+    FAMA,
    # Bands & Channels
    MaEnvelope,
    AccelerationBands,
@@ -310,6 +327,23 @@ __all__ = [
    "LinRegSlope",
    "ZScore",
    "LinRegAngle",
+    # Ehlers / Cycle
+    "SuperSmoother",
+    "FisherTransform",
+    "InverseFisherTransform",
+    "Decycler",
+    "DecyclerOscillator",
+    "RoofingFilter",
+    "CenterOfGravity",
+    "CyberneticCycle",
+    "InstantaneousTrendline",
+    "EhlersStochastic",
+    "EmpiricalModeDecomposition",
+    "HilbertDominantCycle",
+    "AdaptiveCycle",
+    "SineWave",
+    "MAMA",
+    "FAMA",
    # Bands & Channels
    "MaEnvelope",
    "AccelerationBands",
@@ -9417,6 +9417,513 @@ impl PyTdRiskLevel {
    }
 }

+// ============================== Ehlers / Cycle (Family 10) ==============================
+
+macro_rules! py_scalar_one_period {
+    ($wrapper:ident, $py_name:literal, $rust_ty:ty) => {
+        #[pyclass(name = $py_name, module = "wickra._wickra", skip_from_py_object)]
+        #[derive(Clone)]
+        struct $wrapper {
+            inner: $rust_ty,
+        }
+
+        #[pymethods]
+        impl $wrapper {
+            #[new]
+            fn new(period: usize) -> PyResult<Self> {
+                Ok(Self {
+                    inner: <$rust_ty>::new(period).map_err(map_err)?,
+                })
+            }
+            fn update(&mut self, value: f64) -> Option<f64> {
+                self.inner.update(value)
+            }
+            fn batch<'py>(
+                &mut self,
+                py: Python<'py>,
+                prices: PyReadonlyArray1<'py, f64>,
+            ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+                let slice = prices
+                    .as_slice()
+                    .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+                Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+            }
+            #[getter]
+            fn period(&self) -> usize {
+                self.inner.period()
+            }
+            #[getter]
+            fn value(&self) -> Option<f64> {
+                self.inner.value()
+            }
+            fn reset(&mut self) {
+                self.inner.reset();
+            }
+            fn is_ready(&self) -> bool {
+                self.inner.is_ready()
+            }
+            fn warmup_period(&self) -> usize {
+                self.inner.warmup_period()
+            }
+            fn __repr__(&self) -> String {
+                format!("{}(period={})", $py_name, self.inner.period())
+            }
+        }
+    };
+}
+
+py_scalar_one_period!(PySuperSmoother, "SuperSmoother", wc::SuperSmoother);
+py_scalar_one_period!(PyFisherTransform, "FisherTransform", wc::FisherTransform);
+py_scalar_one_period!(PyDecycler, "Decycler", wc::Decycler);
+py_scalar_one_period!(PyCenterOfGravity, "CenterOfGravity", wc::CenterOfGravity);
+py_scalar_one_period!(PyCyberneticCycle, "CyberneticCycle", wc::CyberneticCycle);
+py_scalar_one_period!(
+    PyInstantaneousTrendline,
+    "InstantaneousTrendline",
+    wc::InstantaneousTrendline
+);
+py_scalar_one_period!(PyEhlersStochastic, "EhlersStochastic", wc::EhlersStochastic);
+
+// --- InverseFisherTransform: single f64 `scale` param ---
+
+#[pyclass(
+    name = "InverseFisherTransform",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyInverseFisherTransform {
+    inner: wc::InverseFisherTransform,
+}
+
+#[pymethods]
+impl PyInverseFisherTransform {
+    #[new]
+    #[pyo3(signature = (scale=1.0))]
+    fn new(scale: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::InverseFisherTransform::new(scale).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn scale(&self) -> f64 {
+        self.inner.scale()
+    }
+    #[getter]
+    fn value(&self) -> Option<f64> {
+        self.inner.value()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        format!("InverseFisherTransform(scale={})", self.inner.scale())
+    }
+}
+
+// --- DecyclerOscillator: two-period ---
+
+#[pyclass(
+    name = "DecyclerOscillator",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyDecyclerOscillator {
+    inner: wc::DecyclerOscillator,
+}
+
+#[pymethods]
+impl PyDecyclerOscillator {
+    #[new]
+    fn new(fast: usize, slow: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::DecyclerOscillator::new(fast, slow).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn periods(&self) -> (usize, usize) {
+        self.inner.periods()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (f, s) = self.inner.periods();
+        format!("DecyclerOscillator(fast={f}, slow={s})")
+    }
+}
+
+// --- RoofingFilter: two-period (lp, hp) ---
+
+#[pyclass(name = "RoofingFilter", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyRoofingFilter {
+    inner: wc::RoofingFilter,
+}
+
+#[pymethods]
+impl PyRoofingFilter {
+    #[new]
+    #[pyo3(signature = (lp_period=10, hp_period=48))]
+    fn new(lp_period: usize, hp_period: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::RoofingFilter::new(lp_period, hp_period).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn periods(&self) -> (usize, usize) {
+        self.inner.periods()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (lp, hp) = self.inner.periods();
+        format!("RoofingFilter(lp_period={lp}, hp_period={hp})")
+    }
+}
+
+// --- EmpiricalModeDecomposition: period + fraction ---
+
+#[pyclass(
+    name = "EmpiricalModeDecomposition",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyEmd {
+    inner: wc::EmpiricalModeDecomposition,
+}
+
+#[pymethods]
+impl PyEmd {
+    #[new]
+    #[pyo3(signature = (period=20, fraction=0.5))]
+    fn new(period: usize, fraction: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::EmpiricalModeDecomposition::new(period, fraction).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn period(&self) -> usize {
+        self.inner.period()
+    }
+    #[getter]
+    fn fraction(&self) -> f64 {
+        self.inner.fraction()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        format!(
+            "EmpiricalModeDecomposition(period={}, fraction={})",
+            self.inner.period(),
+            self.inner.fraction()
+        )
+    }
+}
+
+// --- HilbertDominantCycle / SineWave / AdaptiveCycle: parameterless ---
+
+macro_rules! py_no_params_scalar {
+    ($wrapper:ident, $py_name:literal, $rust_ty:ty) => {
+        #[pyclass(name = $py_name, module = "wickra._wickra", skip_from_py_object)]
+        #[derive(Clone)]
+        struct $wrapper {
+            inner: $rust_ty,
+        }
+
+        #[pymethods]
+        impl $wrapper {
+            #[new]
+            fn new() -> Self {
+                Self {
+                    inner: <$rust_ty>::new(),
+                }
+            }
+            fn update(&mut self, value: f64) -> Option<f64> {
+                self.inner.update(value)
+            }
+            fn batch<'py>(
+                &mut self,
+                py: Python<'py>,
+                prices: PyReadonlyArray1<'py, f64>,
+            ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+                let slice = prices
+                    .as_slice()
+                    .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+                Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+            }
+            #[getter]
+            fn value(&self) -> Option<f64> {
+                self.inner.value()
+            }
+            fn reset(&mut self) {
+                self.inner.reset();
+            }
+            fn is_ready(&self) -> bool {
+                self.inner.is_ready()
+            }
+            fn warmup_period(&self) -> usize {
+                self.inner.warmup_period()
+            }
+            fn __repr__(&self) -> String {
+                format!("{}()", $py_name)
+            }
+        }
+    };
+}
+
+py_no_params_scalar!(
+    PyHilbertDominantCycle,
+    "HilbertDominantCycle",
+    wc::HilbertDominantCycle
+);
+py_no_params_scalar!(PyAdaptiveCycle, "AdaptiveCycle", wc::AdaptiveCycle);
+
+// SineWave needs a `lead` accessor in addition to scalar value, but otherwise
+// matches the parameterless surface.
+#[pyclass(name = "SineWave", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PySineWave {
+    inner: wc::SineWave,
+}
+
+#[pymethods]
+impl PySineWave {
+    #[new]
+    fn new() -> Self {
+        Self {
+            inner: wc::SineWave::new(),
+        }
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn value(&self) -> Option<f64> {
+        self.inner.value()
+    }
+    #[getter]
+    fn lead(&self) -> f64 {
+        self.inner.lead()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        "SineWave()".to_string()
+    }
+}
+
+// --- MAMA: multi-output (mama, fama), shape (n, 2) ---
+
+#[pyclass(name = "MAMA", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyMama {
+    inner: wc::Mama,
+}
+
+#[pymethods]
+impl PyMama {
+    #[new]
+    #[pyo3(signature = (fast_limit=0.5, slow_limit=0.05))]
+    fn new(fast_limit: f64, slow_limit: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::Mama::new(fast_limit, slow_limit).map_err(map_err)?,
+        })
+    }
+    /// Returns `(mama, fama)` or `None` during warmup.
+    fn update(&mut self, value: f64) -> Option<(f64, f64)> {
+        self.inner.update(value).map(|o| (o.mama, o.fama))
+    }
+    /// Batch returns shape `(n, 2)` columns `[mama, fama]`. Warmup rows NaN.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let n = slice.len();
+        let mut out = vec![f64::NAN; n * 2];
+        for (i, p) in slice.iter().enumerate() {
+            if let Some(o) = self.inner.update(*p) {
+                out[i * 2] = o.mama;
+                out[i * 2 + 1] = o.fama;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    #[getter]
+    fn limits(&self) -> (f64, f64) {
+        self.inner.limits()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (f, s) = self.inner.limits();
+        format!("MAMA(fast_limit={f}, slow_limit={s})")
+    }
+}
+
+// --- FAMA: scalar wrapper exposing only the fama line ---
+
+#[pyclass(name = "FAMA", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyFama {
+    inner: wc::Fama,
+}
+
+#[pymethods]
+impl PyFama {
+    #[new]
+    #[pyo3(signature = (fast_limit=0.5, slow_limit=0.05))]
+    fn new(fast_limit: f64, slow_limit: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::Fama::new(fast_limit, slow_limit).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        prices: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let slice = prices
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        Ok(flatten(self.inner.batch(slice)).into_pyarray(py))
+    }
+    #[getter]
+    fn limits(&self) -> (f64, f64) {
+        self.inner.limits()
+    }
+    #[getter]
+    fn value(&self) -> Option<f64> {
+        self.inner.value()
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (f, s) = self.inner.limits();
+        format!("FAMA(fast_limit={f}, slow_limit={s})")
+    }
+}
+
 // ============================== Module ==============================

 #[pymodule]
@@ -9572,5 +10079,22 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<PyTdDifferential>()?;
    m.add_class::<PyTdOpen>()?;
    m.add_class::<PyTdRiskLevel>()?;
+    // Family 10 — Ehlers / Cycle
+    m.add_class::<PySuperSmoother>()?;
+    m.add_class::<PyFisherTransform>()?;
+    m.add_class::<PyInverseFisherTransform>()?;
+    m.add_class::<PyDecycler>()?;
+    m.add_class::<PyDecyclerOscillator>()?;
+    m.add_class::<PyRoofingFilter>()?;
+    m.add_class::<PyCenterOfGravity>()?;
+    m.add_class::<PyCyberneticCycle>()?;
+    m.add_class::<PyInstantaneousTrendline>()?;
+    m.add_class::<PyEhlersStochastic>()?;
+    m.add_class::<PyEmd>()?;
+    m.add_class::<PyHilbertDominantCycle>()?;
+    m.add_class::<PyAdaptiveCycle>()?;
+    m.add_class::<PySineWave>()?;
+    m.add_class::<PyMama>()?;
+    m.add_class::<PyFama>()?;
    Ok(())
 }
@@ -39,3 +39,20 @@ def test_roc_and_trix_have_default_periods():
    # ROC/TRIX gained constructor defaults matching the TA-Lib convention.
    assert ta.ROC().period == 10
    assert ta.TRIX() is not None
+
+
+def test_family_10_ehlers_rejects_invalid_parameters():
+    with pytest.raises(ValueError):
+        ta.SuperSmoother(0)
+    with pytest.raises(ValueError):
+        ta.FisherTransform(0)
+    with pytest.raises(ValueError):
+        ta.InverseFisherTransform(0.0)
+    with pytest.raises(ValueError):
+        ta.DecyclerOscillator(30, 10)
+    with pytest.raises(ValueError):
+        ta.RoofingFilter(48, 10)
+    with pytest.raises(ValueError):
+        ta.MAMA(0.05, 0.5)
+    with pytest.raises(ValueError):
+        ta.EmpiricalModeDecomposition(20, 0.0)
@@ -332,6 +332,36 @@ def test_obv_cumulative_known_sequence():
    np.testing.assert_allclose(out, [0.0, 20.0, -10.0, -10.0, 0.0])


+# --- Family 10 — Ehlers / Cycle reference values ---
+
+
+def test_inverse_fisher_saturates_for_large_input():
+    # tanh(10) ~ 0.99999996; very close to +1 without exceeding.
+    v = ta.InverseFisherTransform(1.0).batch(np.array([10.0]))[0]
+    assert v < 1.0
+    assert v > 0.999
+
+
+def test_super_smoother_constant_input_is_constant():
+    out = ta.SuperSmoother(20).batch(np.full(200, 50.0))
+    # Steady-state gain is 1, so a flat input stays flat.
+    np.testing.assert_allclose(out[-50:], 50.0, atol=1e-9)
+
+
+def test_decycler_oscillator_flat_series_is_zero():
+    out = ta.DecyclerOscillator(10, 30).batch(np.full(80, 42.0))
+    ready = out[~np.isnan(out)]
+    np.testing.assert_allclose(ready, 0.0, atol=1e-9)
+
+
+def test_mama_constant_series_both_lines_converge_to_price():
+    out = ta.MAMA().batch(np.full(200, 100.0))
+    last = out[-1]
+    # MAMA and FAMA both track price closely on a flat series.
+    assert abs(last[0] - 100.0) < 1.0
+    assert abs(last[1] - 100.0) < 1.0
+
+
 # --- DeMark family ---------------------------------------------------------


@@ -86,3 +86,20 @@ def test_candle_tuple_input_supported():
    atr.update((10.0, 11.0, 9.0, 10.5, 1.0, 0))
    v = atr.update((10.5, 12.0, 10.0, 11.0, 1.0, 1))
    assert v is not None
+
+
+def test_ehlers_indicators_lifecycle():
+    # Spot-check a few Family-10 entries beyond what test_new_indicators covers.
+    series = np.linspace(1.0, 200.0, 200) + np.sin(np.arange(200) * 0.3) * 5.0
+    for ind in [
+        ta.SuperSmoother(10),
+        ta.FisherTransform(10),
+        ta.MAMA(),
+        ta.HilbertDominantCycle(),
+        ta.SineWave(),
+    ]:
+        assert not ind.is_ready()
+        ind.batch(series)
+        assert ind.is_ready()
+        ind.reset()
+        assert not ind.is_ready()
@@ -79,6 +79,22 @@ SCALAR = [
    (ta.LaguerreRSI, (0.5,)),
    (ta.ConnorsRSI, (3, 2, 100)),
    (ta.RVIVolatility, (10,)),
+    # Family 10 — Ehlers / Cycle scalar indicators
+    (ta.SuperSmoother, (10,)),
+    (ta.FisherTransform, (10,)),
+    (ta.InverseFisherTransform, (1.0,)),
+    (ta.Decycler, (20,)),
+    (ta.DecyclerOscillator, (10, 30)),
+    (ta.RoofingFilter, (10, 48)),
+    (ta.CenterOfGravity, (10,)),
+    (ta.CyberneticCycle, (10,)),
+    (ta.InstantaneousTrendline, (20,)),
+    (ta.EhlersStochastic, (20,)),
+    (ta.EmpiricalModeDecomposition, (20, 0.5)),
+    (ta.HilbertDominantCycle, ()),
+    (ta.AdaptiveCycle, ()),
+    (ta.SineWave, ()),
+    (ta.FAMA, (0.5, 0.05)),
 ]


@@ -434,6 +450,10 @@ MULTI_SCALAR_INPUT = {
        lambda: ta.KST(10, 15, 20, 30, 10, 10, 10, 15, 9),
        lambda ind, c: ind.batch(c),
    ),
+    "MAMA": (
+        lambda: ta.MAMA(0.5, 0.05),
+        lambda ind, c: ind.batch(c),
+    ),
 }


@@ -888,6 +908,54 @@ def test_z_score_reference():
    assert out[1] == pytest.approx(1.0)


+# --- Family 10 — Ehlers / Cycle ---
+
+
+def test_mama_batch_shape_and_streaming_equivalence(sine_prices):
+    batch = ta.MAMA().batch(sine_prices)
+    assert batch.shape == (sine_prices.size, 2)
+
+    streamer = ta.MAMA()
+    rows = []
+    for p in sine_prices:
+        v = streamer.update(float(p))
+        rows.append([math.nan, math.nan] if v is None else list(v))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _eq_nan(batch, streamed)
+
+
+def test_inverse_fisher_transform_zero_input_yields_zero():
+    out = ta.InverseFisherTransform(1.0).batch(np.array([0.0, 0.0, 0.0]))
+    np.testing.assert_allclose(out, [0.0, 0.0, 0.0], atol=1e-12)
+
+
+def test_fisher_transform_flat_series_is_zero():
+    # Zero range -> the normaliser yields 0, and tanh(0) chain stays at 0.
+    out = ta.FisherTransform(5).batch(np.full(20, 42.0))
+    ready = out[~np.isnan(out)]
+    assert np.all(np.abs(ready) < 1e-6)
+
+
+def test_decycler_flat_series_passes_through():
+    # High-pass of a flat input is zero, so the decycler equals the input.
+    out = ta.Decycler(20).batch(np.full(30, 100.0))
+    ready = out[~np.isnan(out)]
+    np.testing.assert_allclose(ready, 100.0, atol=1e-9)
+
+
+def test_center_of_gravity_flat_series_is_zero():
+    out = ta.CenterOfGravity(5).batch(np.full(20, 7.0))
+    ready = out[~np.isnan(out)]
+    np.testing.assert_allclose(ready, 0.0, atol=1e-12)
+
+
+def test_super_smoother_first_two_outputs_equal_inputs():
+    out = ta.SuperSmoother(10).batch(np.array([100.0, 101.0, 102.0]))
+    # The 2-pole filter is seeded with raw values for the first two bars.
+    assert out[0] == pytest.approx(100.0)
+    assert out[1] == pytest.approx(101.0)
+
+
 def test_td_setup_pure_uptrend_reaches_minus_9():
    # Every close is strictly greater than four bars ago -> sell-setup -9.
    h = np.arange(2.0, 22.0)
@@ -55,3 +55,13 @@ def test_obv_batch_shape(ohlc_series):
    volume = np.ones_like(close)
    out = ta.OBV().batch(close, volume)
    assert out.shape == close.shape
+
+
+def test_ehlers_super_smoother_batch_shape(sine_prices):
+    out = ta.SuperSmoother(10).batch(sine_prices)
+    assert out.shape == sine_prices.shape
+
+
+def test_mama_batch_shape(sine_prices):
+    out = ta.MAMA().batch(sine_prices)
+    assert out.shape == (sine_prices.size, 2)
@@ -117,6 +117,30 @@ def test_obv_streaming_matches_batch(ohlc_series):
    assert _equal_with_nan(batch, streamed)


+def test_mama_streaming_matches_batch(sine_prices):
+    batch = ta.MAMA().batch(sine_prices)
+    streamer = ta.MAMA()
+    rows = []
+    for p in sine_prices:
+        v = streamer.update(float(p))
+        if v is None:
+            rows.append([math.nan, math.nan])
+        else:
+            rows.append(list(v))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_super_smoother_streaming_matches_batch(sine_prices):
+    batch = ta.SuperSmoother(10).batch(sine_prices)
+    streamer = ta.SuperSmoother(10)
+    streamed = np.array(
+        [math.nan if (v := streamer.update(float(p))) is None else float(v) for p in sine_prices],
+        dtype=np.float64,
+    )
+    assert _equal_with_nan(batch, streamed)
+
+
 def test_rolling_vwap_streaming_matches_batch(ohlc_series):
    # RollingVWAP(20) on the shared OHLC series. Provides finite-memory VWAP
    # parity coverage now that the indicator is exposed across all bindings.
@@ -448,6 +448,20 @@ impl WasmParkinsonVolatility {
    }
 }

+// Family 10 — Ehlers / Cycle scalars
+wasm_scalar_indicator!(WasmSuperSmoother, "SuperSmoother", wc::SuperSmoother, period: usize);
+wasm_scalar_indicator!(WasmFisherTransform, "FisherTransform", wc::FisherTransform, period: usize);
+wasm_scalar_indicator!(WasmInverseFisherTransform, "InverseFisherTransform", wc::InverseFisherTransform, scale: f64);
+wasm_scalar_indicator!(WasmDecycler, "Decycler", wc::Decycler, period: usize);
+wasm_scalar_indicator!(WasmDecyclerOscillator, "DecyclerOscillator", wc::DecyclerOscillator, fast: usize, slow: usize);
+wasm_scalar_indicator!(WasmRoofingFilter, "RoofingFilter", wc::RoofingFilter, lp_period: usize, hp_period: usize);
+wasm_scalar_indicator!(WasmCenterOfGravity, "CenterOfGravity", wc::CenterOfGravity, period: usize);
+wasm_scalar_indicator!(WasmCyberneticCycle, "CyberneticCycle", wc::CyberneticCycle, period: usize);
+wasm_scalar_indicator!(WasmInstantaneousTrendline, "InstantaneousTrendline", wc::InstantaneousTrendline, period: usize);
+wasm_scalar_indicator!(WasmEhlersStochastic, "EhlersStochastic", wc::EhlersStochastic, period: usize);
+wasm_scalar_indicator!(WasmEmpiricalModeDecomposition, "EmpiricalModeDecomposition", wc::EmpiricalModeDecomposition, period: usize, fraction: f64);
+wasm_scalar_indicator!(WasmFama, "FAMA", wc::Fama, fast_limit: f64, slow_limit: f64);
+
 // ---------- KAMA (three params) ----------

 #[wasm_bindgen(js_name = KAMA)]
@@ -3486,6 +3500,159 @@ impl WasmAroon {
    }
 }

+// ============================== Family 10: parameterless / multi-output ==============================
+
+#[wasm_bindgen(js_name = HilbertDominantCycle)]
+pub struct WasmHilbertDominantCycle {
+    inner: wc::HilbertDominantCycle,
+}
+
+#[wasm_bindgen(js_class = HilbertDominantCycle)]
+impl WasmHilbertDominantCycle {
+    #[wasm_bindgen(constructor)]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> WasmHilbertDominantCycle {
+        Self {
+            inner: wc::HilbertDominantCycle::new(),
+        }
+    }
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    pub fn batch(&mut self, prices: &[f64]) -> Float64Array {
+        Float64Array::from(flatten(self.inner.batch(prices)).as_slice())
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+#[wasm_bindgen(js_name = AdaptiveCycle)]
+pub struct WasmAdaptiveCycle {
+    inner: wc::AdaptiveCycle,
+}
+
+#[wasm_bindgen(js_class = AdaptiveCycle)]
+impl WasmAdaptiveCycle {
+    #[wasm_bindgen(constructor)]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> WasmAdaptiveCycle {
+        Self {
+            inner: wc::AdaptiveCycle::new(),
+        }
+    }
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    pub fn batch(&mut self, prices: &[f64]) -> Float64Array {
+        Float64Array::from(flatten(self.inner.batch(prices)).as_slice())
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+#[wasm_bindgen(js_name = SineWave)]
+pub struct WasmSineWave {
+    inner: wc::SineWave,
+}
+
+#[wasm_bindgen(js_class = SineWave)]
+impl WasmSineWave {
+    #[wasm_bindgen(constructor)]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> WasmSineWave {
+        Self {
+            inner: wc::SineWave::new(),
+        }
+    }
+    pub fn update(&mut self, value: f64) -> Option<f64> {
+        self.inner.update(value)
+    }
+    pub fn batch(&mut self, prices: &[f64]) -> Float64Array {
+        Float64Array::from(flatten(self.inner.batch(prices)).as_slice())
+    }
+    pub fn lead(&self) -> f64 {
+        self.inner.lead()
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+#[wasm_bindgen(js_name = MAMA)]
+pub struct WasmMama {
+    inner: wc::Mama,
+}
+
+#[wasm_bindgen(js_class = MAMA)]
+impl WasmMama {
+    #[wasm_bindgen(constructor)]
+    pub fn new(fast_limit: f64, slow_limit: f64) -> Result<WasmMama, JsError> {
+        Ok(Self {
+            inner: wc::Mama::new(fast_limit, slow_limit).map_err(map_err)?,
+        })
+    }
+    pub fn update(&mut self, value: f64) -> JsValue {
+        match self.inner.update(value) {
+            Some(o) => {
+                let obj = Object::new();
+                Reflect::set(&obj, &"mama".into(), &o.mama.into()).ok();
+                Reflect::set(&obj, &"fama".into(), &o.fama.into()).ok();
+                obj.into()
+            }
+            None => JsValue::NULL,
+        }
+    }
+    /// Returns a flat `Float64Array` of length `2 * n`: `[mama0, fama0, mama1, fama1, ...]`.
+    pub fn batch(&mut self, prices: &[f64]) -> Float64Array {
+        let n = prices.len();
+        let mut out = vec![f64::NAN; n * 2];
+        for (i, p) in prices.iter().enumerate() {
+            if let Some(o) = self.inner.update(*p) {
+                out[i * 2] = o.mama;
+                out[i * 2 + 1] = o.fama;
+            }
+        }
+        Float64Array::from(out.as_slice())
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
 // ============================== Family 05: Bands & Channels ==============================

 // Every indicator below is multi-output (2-5 bands), so they bypass the
@@ -5335,6 +5502,7 @@ impl WasmTdRiskLevel {
        self.inner.warmup_period()
    }
 }
+
 #[cfg(test)]
 mod tests {
    use super::*;