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.

bindings/python/tests/test_input_validation.py

@@ -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)

bindings/python/tests/test_known_values.py

@@ -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 ---------------------------------------------------------
 
 

bindings/python/tests/test_lifecycle.py

@@ -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()

bindings/python/tests/test_new_indicators.py

@@ -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)

bindings/python/tests/test_smoke.py

@@ -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)

bindings/python/tests/test_streaming_vs_batch.py

@@ -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.