unit tests for indicators

BusinessDuck · BusinessDuck · commit e04b0f36b13a · 2026-04-28T15:18:18.000+02:00
diff --git a/src/elder-ray.ts b/src/elder-ray.ts
@@ -30,8 +30,8 @@ export class ElderRay {
         const bull = high - ema;
         const bear = low - ema;
         this.nextValue = (high: number, low: number, close: number) => {
-            const ema = this.ema.nextValue(close);
-            return { bull, bear };
+            const e = this.ema.nextValue(close);
+            return { bull: high - e, bear: low - e };
         };
         return { bull, bear };
     }
diff --git a/tests/cmo/cmo.spec.ts b/tests/cmo/cmo.spec.ts
@@ -0,0 +1,28 @@
+import { CMO } from '../../src/cmo';
+
+describe('CMO', () => {
+    it('matches hand calculation for period 2', () => {
+        const cmo = new CMO(2);
+        expect(cmo.nextValue(100)).toBeUndefined();
+        expect(cmo.nextValue(102)).toBeUndefined();
+        const v = cmo.nextValue(101);
+        // diffs: +2, -1 -> gains 2, losses 1 -> 100 * (2-1) / 3
+        expect(v).toBeCloseTo(100 / 3, 5);
+    });
+
+    it('returns 0 when gains and losses cancel in denominator edge', () => {
+        const cmo = new CMO(1);
+        cmo.nextValue(10);
+        const v = cmo.nextValue(10);
+        expect(v).toBe(0);
+    });
+
+    it('momentValue matches a fresh instance with the same history', () => {
+        const seq = [10, 11, 12, 11, 10];
+        const a = new CMO(3);
+        for (const x of seq) a.nextValue(x);
+        const b = new CMO(3);
+        for (const x of seq) b.nextValue(x);
+        expect(b.momentValue(11)).toBeCloseTo(a.momentValue(11) as number, 10);
+    });
+});
diff --git a/tests/dc/dc.spec.ts b/tests/dc/dc.spec.ts
@@ -1,7 +1,7 @@
 import { DC } from '../../src/dc';
 import { dcValues, ohlc } from './excel-data';
 
-describe.only('Donchian Channels', () => {
+describe('Donchian Channels', () => {
     it('Excel Validate', () => {
         const dc = new DC(21);
         const EPSILON = 0.001;
diff --git a/tests/dmi/dmi.spec.ts b/tests/dmi/dmi.spec.ts
@@ -0,0 +1,41 @@
+import { DMI } from '../../src/dmi';
+
+describe('DMI', () => {
+    it('is undefined on first bar', () => {
+        const d = new DMI(14, false);
+        expect(d.nextValue(10, 8, 9)).toBeUndefined();
+    });
+
+    it('returns plusDI and minusDI as finite numbers when ready', () => {
+        const d = new DMI(3, false);
+        const highs = [10, 11, 12, 11, 10, 9, 10, 11, 12, 11, 10, 9, 10, 11, 12, 11, 10, 9, 10];
+        const lows = [8, 9, 10, 9, 8, 7, 8, 9, 10, 9, 8, 7, 8, 9, 10, 9, 8, 7, 8];
+        const closes = [9, 10, 11, 10, 9, 8, 9, 10, 11, 10, 9, 8, 9, 10, 11, 10, 9, 8, 9];
+        let last: { plusDI: number; minusDI: number } | undefined;
+        for (let i = 0; i < highs.length; i++) {
+            const v = d.nextValue(highs[i], lows[i], closes[i]) as
+                | { plusDI: number; minusDI: number }
+                | undefined;
+            if (v) last = v;
+        }
+        expect(last).toBeDefined();
+        expect(Number.isFinite(last!.plusDI)).toBe(true);
+        expect(Number.isFinite(last!.minusDI)).toBe(true);
+    });
+
+    it('with ADX includes adx in result', () => {
+        const d = new DMI(4, true);
+        const h = [10, 12, 11, 10, 12, 11, 10, 12, 11, 10, 12];
+        const l = [8, 9, 8, 7, 9, 8, 7, 9, 8, 7, 9];
+        const c = [9, 11, 9, 8, 11, 9, 8, 11, 9, 8, 11];
+        let last: { adx: number; plusDI: number; minusDI: number } | undefined;
+        for (let i = 0; i < h.length; i++) {
+            const v = d.nextValue(h[i], l[i], c[i]) as
+                | { adx: number; plusDI: number; minusDI: number }
+                | undefined;
+            if (v && v.adx !== undefined) last = v;
+        }
+        expect(last).toBeDefined();
+        expect(Number.isFinite(last!.adx)).toBe(true);
+    });
+});
diff --git a/tests/dpo/dpo.spec.ts b/tests/dpo/dpo.spec.ts
@@ -0,0 +1,25 @@
+import { DPO } from '../../src/dpo';
+
+describe('DPO', () => {
+    it('returns undefined until period + shift bars', () => {
+        const dpo = new DPO(4);
+        const shift = Math.floor(4 / 2 + 1);
+        for (let i = 0; i < 4 + shift - 1; i++) {
+            expect(dpo.nextValue(100 + i)).toBeUndefined();
+        }
+        const v = dpo.nextValue(100 + 4 + shift - 1);
+        expect(v).toBeDefined();
+        expect(typeof v).toBe('number');
+    });
+
+    it('momentValue is stable with nextValue series', () => {
+        const dpo = new DPO(5);
+        const prices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        for (const p of prices) dpo.nextValue(p);
+        const m = dpo.momentValue(11);
+        const dpo2 = new DPO(5);
+        for (let i = 0; i < prices.length; i++) dpo2.nextValue(prices[i]);
+        const without = dpo2.momentValue(11);
+        expect(m).toBeCloseTo(without as number, 10);
+    });
+});
diff --git a/tests/elder-ray/elder-ray.spec.ts b/tests/elder-ray/elder-ray.spec.ts
@@ -0,0 +1,25 @@
+import { ElderRay } from '../../src/elder-ray';
+
+describe('ElderRay', () => {
+    it('bull and bear recompute on each nextValue after warmup', () => {
+        const er = new ElderRay(3);
+        er.nextValue(95, 90, 100);
+        er.nextValue(100, 95, 100);
+        const a = er.nextValue(105, 100, 102) as { bull: number; bear: number };
+        const b = er.nextValue(110, 100, 104) as { bull: number; bear: number };
+        expect(b.bull).toBeGreaterThan(a.bull);
+    });
+
+    it('momentValue on a new bar matches nextValue when EMA is already warmed', () => {
+        const period = 4;
+        const er = new ElderRay(period);
+        for (let i = 0; i < period - 1; i++) {
+            er.nextValue(10 + i, 9 + i, 9.5 + i);
+        }
+        er.nextValue(20, 8, 12);
+        const m = er.momentValue(22, 7, 13) as { bull: number; bear: number };
+        const v = er.nextValue(22, 7, 13) as { bull: number; bear: number };
+        expect(v.bull).toBeCloseTo(m.bull, 5);
+        expect(v.bear).toBeCloseTo(m.bear, 5);
+    });
+});
diff --git a/tests/envelopes/envelopes.spec.ts b/tests/envelopes/envelopes.spec.ts
@@ -0,0 +1,40 @@
+import { Envelopes } from '../../src/envelopes';
+import { SMA as SMA2 } from 'technicalindicators';
+import { closes } from '../macd/excel-data';
+
+describe('Envelopes', () => {
+    it('produces symmetric bands around SMA', () => {
+        const e = new Envelopes(3, 10);
+        e.nextValue(10);
+        e.nextValue(10);
+        const v = e.nextValue(10) as { lower: number; middle: number; upper: number };
+        expect(v.middle).toBe(10);
+        expect(v.upper).toBe(11);
+        expect(v.lower).toBe(9);
+    });
+
+    it('momentValue uses the same middle as SMA.momentValue', () => {
+        const e = new Envelopes(4, 2);
+        e.nextValue(1);
+        e.nextValue(2);
+        e.nextValue(3);
+        e.nextValue(4);
+        const m = e.momentValue(5) as { lower: number; middle: number; upper: number };
+        expect(m.middle * 0.02).toBeCloseTo((m.upper - m.middle), 8);
+        expect(m.middle * 0.02).toBeCloseTo((m.middle - m.lower), 8);
+    });
+
+    it('Cross sdk: middle band matches technicalindicators SMA', () => {
+        const period = 20;
+        const pct = 2.5;
+        const env = new Envelopes(period, pct);
+        const refSma = new SMA2({ period, values: [] });
+        closes.forEach((c) => {
+            const e = env.nextValue(c) as { lower: number; middle: number; upper: number } | undefined;
+            const m = refSma.nextValue(c);
+            if (e && m !== undefined) {
+                expect(e.middle).toBeCloseTo(m, 8);
+            }
+        });
+    });
+});
diff --git a/tests/force-index/force-index.spec.ts b/tests/force-index/force-index.spec.ts
@@ -0,0 +1,23 @@
+import { ForceIndex } from '../../src/force-index';
+
+describe('ForceIndex', () => {
+    it('is undefined on the first close', () => {
+        const f = new ForceIndex();
+        expect(f.nextValue(100, 1000)).toBeUndefined();
+    });
+
+    it('equals (close - prevClose) * volume', () => {
+        const f = new ForceIndex();
+        f.nextValue(100, 1000);
+        expect(f.nextValue(102, 500)).toBe(2 * 500);
+        expect(f.nextValue(99, 200)).toBe(-3 * 200);
+    });
+
+    it('momentValue matches the formula without advancing state', () => {
+        const f = new ForceIndex();
+        f.nextValue(10, 100);
+        f.nextValue(12, 200);
+        const m = f.momentValue(11, 300);
+        expect(m).toBe((11 - 12) * 300);
+    });
+});
diff --git a/tests/fractal/fractal.spec.ts b/tests/fractal/fractal.spec.ts
@@ -0,0 +1,27 @@
+import { Fractal } from '../../src/fractal';
+
+describe('Fractal', () => {
+    it('detects a swing high (fractal up)', () => {
+        const f = new Fractal(2, 2);
+        const highs = [1, 1, 10, 1, 1];
+        const lows = [0, 0, 0, 0, 0];
+        let up: number | undefined;
+        for (let i = 0; i < highs.length; i++) {
+            const r = f.nextValue(highs[i], lows[i]);
+            if (r && r.up !== undefined) up = r.up;
+        }
+        expect(up).toBe(10);
+    });
+
+    it('with full window, momentValue returns a defined structure', () => {
+        const f = new Fractal(1, 1);
+        f.nextValue(1, 5);
+        f.nextValue(3, 3);
+        f.nextValue(2, 2);
+        f.nextValue(1, 1);
+        const m = f.momentValue(1, 1) as { up?: number; down?: number };
+        expect(m).toBeDefined();
+        expect('up' in m).toBe(true);
+        expect('down' in m).toBe(true);
+    });
+});
diff --git a/tests/ichimoku/ichimoku.spec.ts b/tests/ichimoku/ichimoku.spec.ts
@@ -0,0 +1,25 @@
+import { Ichimoku } from '../../src/ichimoku';
+
+describe('Ichimoku', () => {
+    it('returns flat lines on constant range with short periods', () => {
+        const ichi = new Ichimoku(2, 2, 2, 1);
+        const h = 100;
+        const l = 100;
+        const c = 100;
+        ichi.nextValue(h, l, c);
+        const v = ichi.nextValue(h, l, c);
+        expect(v).toBeDefined();
+        expect(v!.tenkan).toBe(100);
+        expect(v!.kijun).toBe(100);
+        expect(v!.senkouA).toBe(100);
+        expect(v!.senkouB).toBe(100);
+    });
+
+    it('tenkan reflects max/min over conversion period', () => {
+        const ichi = new Ichimoku(2, 2, 2, 1);
+        ichi.nextValue(8, 6, 7);
+        const v = ichi.nextValue(12, 10, 11) as { tenkan: number; kijun: number };
+        // max(8,12)=12, min(6,10)=6 -> (12+6)/2 = 9
+        expect(v.tenkan).toBe(9);
+    });
+});
diff --git a/tests/keltner/keltner.spec.ts b/tests/keltner/keltner.spec.ts
@@ -0,0 +1,72 @@
+import { KeltnerChannel } from '../../src/keltner';
+import { KeltnerChannels } from 'technicalindicators';
+import { closes } from '../macd/excel-data';
+import { ohlc } from '../cci/excel-data';
+import { EMA } from '../../src/ema';
+import { ATR } from '../../src/atr';
+
+describe('KeltnerChannel', () => {
+    it('bands are symmetric around EMA for a fixed multiplier', () => {
+        const k = new KeltnerChannel(3, 2);
+        for (let i = 0; i < 10; i++) {
+            k.nextValue(10, 8, 9);
+        }
+        const v = k.nextValue(10, 8, 9) as { lower: number; middle: number; upper: number };
+        expect(Number.isFinite(v.upper)).toBe(true);
+        expect(v.upper - v.middle).toBeCloseTo(v.middle - v.lower, 5);
+    });
+
+    it('matches EMA plus/minus 2*ATR from standalone indicators', () => {
+        const period = 5;
+        const m = 2;
+        const kc = new KeltnerChannel(period, m);
+        const ema = new EMA(period);
+        const atr = new ATR(period);
+        for (const c of closes) {
+            const o = c + 0.1;
+            const h = c + 0.5;
+            const l = c - 0.5;
+            kc.nextValue(h, l, c);
+            ema.nextValue(c);
+            atr.nextValue(h, l, c);
+        }
+        const last = closes[closes.length - 1];
+        const h2 = last + 0.5;
+        const l2 = last - 0.5;
+        const ku = kc.momentValue(h2, l2, last) as { lower: number; middle: number; upper: number };
+        const mid = ema.momentValue(last);
+        const a = atr.momentValue(h2, l2) as number;
+        expect(ku.middle).toBeCloseTo(mid, 5);
+        expect(ku.upper).toBeCloseTo(mid + m * a, 5);
+        expect(ku.lower).toBeCloseTo(mid - m * a, 5);
+    });
+
+    it('Cross sdk: matches technicalindicators KeltnerChannels (EMA middle, WEMA ATR)', () => {
+        const period = 20;
+        const mult = 2;
+        const kc = new KeltnerChannel(period, mult);
+        const ref = new KeltnerChannels({
+            maPeriod: period,
+            atrPeriod: period,
+            useSMA: false,
+            multiplier: mult,
+            high: [],
+            low: [],
+            close: []
+        });
+        const eps = 0.01;
+        ohlc.forEach((bar) => {
+            const a = kc.nextValue(bar.h, bar.l, bar.c) as
+                | { lower: number; middle: number; upper: number }
+                | undefined;
+            const b = ref.nextValue({ high: bar.h, low: bar.l, close: bar.c } as any) as
+                | { lower: number; middle: number; upper: number }
+                | undefined;
+            if (a && b) {
+                expect(Math.abs(a.middle - b.middle)).toBeLessThan(eps);
+                expect(Math.abs(a.upper - b.upper)).toBeLessThan(eps);
+                expect(Math.abs(a.lower - b.lower)).toBeLessThan(eps);
+            }
+        });
+    });
+});
diff --git a/tests/tema/tema.spec.ts b/tests/tema/tema.spec.ts
@@ -0,0 +1,28 @@
+import { TEMA } from '../../src/tema';
+import { EMA } from '../../src/ema';
+
+describe('TEMA', () => {
+    it('momentValue matches 3*e1 - 3*e2 + e3 for the same EMA state', () => {
+        const period = 5;
+        const e1 = new EMA(period);
+        const e2 = new EMA(period);
+        const e3 = new EMA(period);
+        const tema = new TEMA(period);
+        const prices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21];
+        for (const x of prices) {
+            tema.nextValue(x);
+            const a = e1.nextValue(x);
+            if (a !== undefined) {
+                const b = e2.nextValue(a);
+                if (b !== undefined) e3.nextValue(b);
+            }
+        }
+        const probe = 22;
+        const m1 = e1.momentValue(probe) as number;
+        const m2 = e2.momentValue(m1) as number;
+        const m3 = e3.momentValue(m2) as number;
+        const expected = 3 * m1 - 3 * m2 + m3;
+        const actual = tema.momentValue(probe) as number;
+        expect(actual).toBeCloseTo(expected, 4);
+    });
+});
diff --git a/tests/trix/trix.spec.ts b/tests/trix/trix.spec.ts
@@ -0,0 +1,17 @@
+import { TRIX } from '../../src/trix';
+import { TRIX as TRIX2 } from 'technicalindicators';
+import { closes } from '../macd/excel-data';
+
+describe('TRIX', () => {
+    it('Cross sdk: matches technicalindicators TRIX when both produce a value', () => {
+        const t1 = new TRIX(15);
+        const t2 = new TRIX2({ period: 15, values: [] });
+        for (const c of closes) {
+            const a = t1.nextValue(c);
+            const b = t2.nextValue(c);
+            if (a !== undefined && b !== undefined) {
+                expect(a).toBeCloseTo(b, 4);
+            }
+        }
+    });
+});
diff --git a/tests/ultimate-oscillator/ultimate-oscillator.spec.ts b/tests/ultimate-oscillator/ultimate-oscillator.spec.ts
diff --git a/tests/volume-oscillator/volume-oscillator.spec.ts b/tests/volume-oscillator/volume-oscillator.spec.ts
