@363045841yyt/klinechart-core 0.7.3

package/src/engine/indicators/__tests__/dema.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest'
+import { calcDEMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { DEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcDEMAData — Double Exponential Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcDEMAData(empty, 20)).toEqual([])
+        })
+
+        it('single bar produces a single defined value (EMA seed = first close)', () => {
+            const out = calcDEMAData(singleBar, 20)
+            expect(out).toHaveLength(1)
+            expect(out[0]).toBeCloseTo(100, 9)
+        })
+
+        it('period = 0 or negative returns all undefined', () => {
+            const zero = calcDEMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+            const neg = calcDEMAData(pureUptrend, -1)
+            for (const v of neg) expect(v).toBeUndefined()
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → DEMA(20) = 100 throughout (zero lag at steady state)', () => {
+            assertSeriesClose(calcDEMAData(constantPrice, 20), DEMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcDEMAData(fx, 20), 'DEMA series')
+            }
+        })
+
+        it('on linear input close=100+t, DEMA converges toward close[t] (zero-lag property)', () => {
+            // 30-bar fixture isn't enough for full convergence with period=20,
+            // but DEMA should be closer to close[t] than EMA would be.
+            // Just verify monotonic increase tracking the uptrend.
+            const out = calcDEMAData(pureUptrend, 20)
+            const tail = out.slice(20).filter((v): v is number => v !== undefined)
+            for (let i = 1; i < tail.length; i++) {
+                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
+            }
+        })
+
+        it('extensional consistency (no leak from later bars into earlier values)', () => {
+            const full = calcDEMAData(pureUptrend, 20)
+            for (let n = 5; n < pureUptrend.length; n++) {
+                const partial = calcDEMAData(pureUptrend.slice(0, n), 20)
+                for (let i = 0; i < n; i++) {
+                    if (full[i] !== undefined && partial[i] !== undefined) {
+                        expect(partial[i]).toBeCloseTo(full[i]!, 9)
+                    }
+                }
+            }
+        })
+    })
+})

package/src/engine/indicators/__tests__/donchian.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import { calcDonchianData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcDonchianData', () => {
+    it('empty returns empty', () => {
+        expect(calcDonchianData(empty, 20)).toEqual([])
+    })
+
+    it('shorter than period returns all undefined', () => {
+        const out = calcDonchianData(constantPrice.slice(0, 5), 20)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcDonchianData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice (H=L=100) all bands collapse to 100', () => {
+        const out = calcDonchianData(constantPrice, 20)
+        const valid = out.filter((p) => p !== undefined)
+        expect(valid.length).toBeGreaterThan(0)
+        for (const p of valid) {
+            expect(p!.upper).toBe(100)
+            expect(p!.middle).toBe(100)
+            expect(p!.lower).toBe(100)
+        }
+    })
+
+    it('upper >= middle >= lower invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const out = calcDonchianData(fx, 20)
+            for (const p of out) {
+                if (!p) continue
+                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
+                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
+                expect(p.middle).toBeCloseTo((p.upper + p.lower) / 2, 9)
+            }
+        }
+    })
+
+    it('on pureUptrend, upper at index t equals high[t] (newest is always the maximum)', () => {
+        const out = calcDonchianData(pureUptrend, 20)
+        for (let t = 19; t < out.length; t++) {
+            expect(out[t]!.upper).toBe(pureUptrend[t]!.high)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcDonchianData(pureUptrend, 20)
+        for (let n = 20; n < pureUptrend.length; n++) {
+            const partial = calcDonchianData(pureUptrend.slice(0, n), 20)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    expect(p.upper).toBe(f.upper)
+                    expect(p.lower).toBe(f.lower)
+                }
+            }
+        }
+    })
+})

package/src/engine/indicators/__tests__/hma.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest'
+import { calcHMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { HMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcHMAData — Hull Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcHMAData(empty, 9)).toEqual([])
+        })
+
+        it('single bar with period 9 returns [undefined]', () => {
+            expect(calcHMAData(singleBar, 9)).toEqual([undefined])
+        })
+
+        it('period = 0 returns all undefined', () => {
+            const zero = calcHMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+        })
+
+        it('period = 1 returns close[t] (WMA of WMA of single value is itself)', () => {
+            const out = calcHMAData(pureUptrend, 1)
+            for (let i = 0; i < out.length; i++) {
+                expect(out[i]).toBeCloseTo(pureUptrend[i]!.close, 9)
+            }
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → HMA(9) = 100 after warm-up', () => {
+            assertSeriesClose(calcHMAData(constantPrice, 9), HMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite (or undefined in warm-up)', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcHMAData(fx, 9), 'HMA series')
+            }
+        })
+
+        it('HMA(9) on pureUptrend tracks linear motion with very low lag', () => {
+            const out = calcHMAData(pureUptrend, 9)
+            const tail = out.slice(11).filter((v): v is number => v !== undefined)
+            for (let i = 1; i < tail.length; i++) {
+                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
+            }
+        })
+
+        it('extensional consistency', () => {
+            const full = calcHMAData(pureUptrend, 9)
+            for (let n = 12; n < pureUptrend.length; n++) {
+                const partial = calcHMAData(pureUptrend.slice(0, n), 9)
+                for (let i = 0; i < n; i++) {
+                    if (full[i] !== undefined && partial[i] !== undefined) {
+                        expect(partial[i]).toBeCloseTo(full[i]!, 9)
+                    }
+                }
+            }
+        })
+    })
+})

package/src/engine/indicators/__tests__/ichimoku.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from 'vitest'
+import { calcIchimokuData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+} from './__fixtures__/synthetic'
+
+describe('calcIchimokuData', () => {
+    it('empty returns empty', () => {
+        expect(calcIchimokuData(empty, 9, 26, 52, 26)).toEqual([])
+    })
+
+    it('on constantPrice (H=L=100) all lines collapse to 100', () => {
+        // Only constantPrice (30 bars) is shorter than spanBPeriod=52, so use small periods for this test
+        const out = calcIchimokuData(constantPrice, 5, 10, 15, 5)
+        // Test data is 30 bars, so spanA/B/chikou exist within the window
+        const valid = out.filter((p): p is NonNullable<typeof p> => p !== undefined)
+        expect(valid.length).toBe(constantPrice.length)
+        // After warm-up, tenkan and kijun should both be 100
+        for (let t = 15; t < out.length - 5; t++) {
+            const p = out[t]!
+            if (p.tenkan !== undefined) expect(p.tenkan).toBe(100)
+            if (p.kijun !== undefined) expect(p.kijun).toBe(100)
+            if (p.spanA !== undefined) expect(p.spanA).toBe(100)
+            if (p.spanB !== undefined) expect(p.spanB).toBe(100)
+            if (p.chikou !== undefined) expect(p.chikou).toBe(100)
+        }
+    })
+
+    it('uptrend: spanA > spanB once cloud is established (bullish cloud)', () => {
+        const out = calcIchimokuData(pureUptrend, 5, 10, 15, 5)
+        let bullishCount = 0
+        let bearishCount = 0
+        for (const p of out) {
+            if (p && p.spanA !== undefined && p.spanB !== undefined) {
+                if (p.spanA > p.spanB) bullishCount++
+                else if (p.spanA < p.spanB) bearishCount++
+            }
+        }
+        expect(bullishCount).toBeGreaterThan(bearishCount)
+    })
+
+    it('downtrend: spanA < spanB once cloud is established (bearish cloud)', () => {
+        const out = calcIchimokuData(pureDowntrend, 5, 10, 15, 5)
+        let bullishCount = 0
+        let bearishCount = 0
+        for (const p of out) {
+            if (p && p.spanA !== undefined && p.spanB !== undefined) {
+                if (p.spanA > p.spanB) bullishCount++
+                else if (p.spanA < p.spanB) bearishCount++
+            }
+        }
+        expect(bearishCount).toBeGreaterThan(bullishCount)
+    })
+
+    it('chikou at bar t equals close[t+displacement] when in range, undefined otherwise', () => {
+        const displacement = 5
+        const out = calcIchimokuData(pureUptrend, 5, 10, 15, displacement)
+        for (let t = 0; t < pureUptrend.length; t++) {
+            const p = out[t]!
+            if (t + displacement < pureUptrend.length) {
+                expect(p.chikou).toBe(pureUptrend[t + displacement]!.close)
+            } else {
+                expect(p.chikou).toBeUndefined()
+            }
+        }
+    })
+
+    it('tenkan/kijun midline equals (max(high) + min(low)) / 2 over the period', () => {
+        const period = 9
+        const out = calcIchimokuData(pureUptrend, period, 26, 52, 26)
+        for (let t = period - 1; t < pureUptrend.length; t++) {
+            let hi = -Infinity
+            let lo = Infinity
+            for (let k = 0; k < period; k++) {
+                const bar = pureUptrend[t - k]!
+                if (bar.high > hi) hi = bar.high
+                if (bar.low < lo) lo = bar.low
+            }
+            expect(out[t]!.tenkan).toBeCloseTo((hi + lo) / 2, 9)
+        }
+    })
+
+    it('extensional consistency on sideways fixture', () => {
+        const full = calcIchimokuData(sideways, 5, 10, 15, 5)
+        for (let n = 16; n < sideways.length; n++) {
+            const partial = calcIchimokuData(sideways.slice(0, n), 5, 10, 15, 5)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    if (f.tenkan !== undefined && p.tenkan !== undefined) {
+                        expect(p.tenkan).toBeCloseTo(f.tenkan, 9)
+                    }
+                    if (f.kijun !== undefined && p.kijun !== undefined) {
+                        expect(p.kijun).toBeCloseTo(f.kijun, 9)
+                    }
+                }
+            }
+        }
+    })
+})

package/src/engine/indicators/__tests__/kama.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest'
+import { calcKAMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { KAMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcKAMAData — Kaufman Adaptive Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcKAMAData(empty, 10, 2, 30)).toEqual([])
+        })
+
+        it('single bar returns [undefined]', () => {
+            expect(calcKAMAData(singleBar, 10, 2, 30)).toEqual([undefined])
+        })
+
+        it('n <= period returns all undefined', () => {
+            const tiny = constantPrice.slice(0, 10)
+            const out = calcKAMAData(tiny, 10, 2, 30)
+            for (const v of out) expect(v).toBeUndefined()
+        })
+
+        it('period = 0 or negative returns all undefined', () => {
+            expect(calcKAMAData(pureUptrend, 0, 2, 30)).toEqual(
+                Array.from({ length: pureUptrend.length }, () => undefined),
+            )
+            expect(calcKAMAData(pureUptrend, -1, 2, 30)).toEqual(
+                Array.from({ length: pureUptrend.length }, () => undefined),
+            )
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → KAMA stays at 100 once seeded', () => {
+            assertSeriesClose(calcKAMAData(constantPrice, 10, 2, 30), KAMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcKAMAData(fx, 10, 2, 30), 'KAMA series')
+            }
+        })
+
+        it('on pureUptrend ER ≈ 1 → KAMA tracks close[t] closely', () => {
+            // Linear uptrend has direction = period and volSum = period (all changes = 1),
+            // so ER = 1 every step → SC = fastSC² = (2/3)² = 4/9 ≈ 0.444
+            const out = calcKAMAData(pureUptrend, 10, 2, 30)
+            // Tail values should be close to close[t]; difference monotonically shrinks
+            const tail = out.slice(15)
+            for (let i = 1; i < tail.length; i++) {
+                if (tail[i] === undefined || tail[i - 1] === undefined) continue
+                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
+            }
+        })
+
+        it('extensional consistency', () => {
+            const full = calcKAMAData(pureUptrend, 10, 2, 30)
+            for (let n = 12; n < pureUptrend.length; n++) {
+                const partial = calcKAMAData(pureUptrend.slice(0, n), 10, 2, 30)
+                for (let i = 0; i < n; i++) {
+                    if (full[i] !== undefined && partial[i] !== undefined) {
+                        expect(partial[i]).toBeCloseTo(full[i]!, 9)
+                    }
+                }
+            }
+        })
+    })
+})

package/src/engine/indicators/__tests__/keltner.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest'
+import { calcKeltnerData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcKeltnerData', () => {
+    it('empty returns empty', () => {
+        expect(calcKeltnerData(empty, 20, 10, 2)).toEqual([])
+    })
+
+    it('on constantPrice all bands collapse to 100 (ATR=0 → no band width)', () => {
+        const out = calcKeltnerData(constantPrice, 20, 10, 2)
+        const valid = out.filter((p) => p !== undefined)
+        expect(valid.length).toBeGreaterThan(0)
+        for (const p of valid) {
+            expect(p!.middle).toBeCloseTo(100, 9)
+            expect(p!.upper).toBeCloseTo(100, 9)
+            expect(p!.lower).toBeCloseTo(100, 9)
+        }
+    })
+
+    it('upper >= middle >= lower invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const out = calcKeltnerData(fx, 20, 10, 2)
+            for (const p of out) {
+                if (!p) continue
+                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
+                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
+            }
+        }
+    })
+
+    it('larger multiplier widens the band', () => {
+        const narrow = calcKeltnerData(spikeAtBar19, 20, 10, 1)
+        const wide = calcKeltnerData(spikeAtBar19, 20, 10, 4)
+        for (let i = 15; i < narrow.length; i++) {
+            const n = narrow[i]
+            const w = wide[i]
+            if (n && w) {
+                expect(w.upper - w.lower).toBeGreaterThanOrEqual(n.upper - n.lower)
+            }
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcKeltnerData(pureUptrend, 20, 10, 2)
+        for (let n = 15; n < pureUptrend.length; n++) {
+            const partial = calcKeltnerData(pureUptrend.slice(0, n), 20, 10, 2)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    expect(p.middle).toBeCloseTo(f.middle, 9)
+                    expect(p.upper).toBeCloseTo(f.upper, 9)
+                    expect(p.lower).toBeCloseTo(f.lower, 9)
+                }
+            }
+        }
+    })
+})

package/src/engine/indicators/__tests__/pivot-fib.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest'
+import { calcPivotData, calcFibData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcPivotData', () => {
+    it('empty returns empty', () => {
+        expect(calcPivotData(empty)).toEqual([])
+    })
+
+    it('first bar has no pivot (needs prior bar)', () => {
+        expect(calcPivotData(pureUptrend)[0]).toBeUndefined()
+    })
+
+    it('PP = (prevH + prevL + prevC) / 3', () => {
+        const out = calcPivotData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            const prev = pureUptrend[t - 1]!
+            expect(out[t]!.pp).toBeCloseTo((prev.high + prev.low + prev.close) / 3, 9)
+        }
+    })
+
+    it('R1 > PP > S1 invariant (price-action symmetry)', () => {
+        const out = calcPivotData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            const p = out[t]!
+            expect(p.r1).toBeGreaterThan(p.pp)
+            expect(p.pp).toBeGreaterThan(p.s1)
+        }
+    })
+
+    it('R3 > R2 > R1 > PP > S1 > S2 > S3 chain', () => {
+        const out = calcPivotData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            const p = out[t]!
+            expect(p.r3).toBeGreaterThanOrEqual(p.r2)
+            expect(p.r2).toBeGreaterThanOrEqual(p.r1)
+            expect(p.r1).toBeGreaterThanOrEqual(p.pp)
+            expect(p.pp).toBeGreaterThanOrEqual(p.s1)
+            expect(p.s1).toBeGreaterThanOrEqual(p.s2)
+            expect(p.s2).toBeGreaterThanOrEqual(p.s3)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcPivotData(pureUptrend)
+        for (let n = 3; n < pureUptrend.length; n++) {
+            const partial = calcPivotData(pureUptrend.slice(0, n))
+            for (let i = 0; i < n; i++) {
+                if (full[i] && partial[i]) {
+                    expect(partial[i]!.pp).toBeCloseTo(full[i]!.pp, 9)
+                }
+            }
+        }
+    })
+})
+
+describe('calcFibData', () => {
+    it('empty returns empty', () => {
+        expect(calcFibData(empty, 20)).toEqual([])
+    })
+
+    it('shorter than period returns all undefined', () => {
+        const out = calcFibData(pureUptrend.slice(0, 10), 20)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on pureUptrend direction = up, levels descend from high to low', () => {
+        const out = calcFibData(pureUptrend, 10)
+        for (let t = 9; t < out.length; t++) {
+            const p = out[t]!
+            expect(p.direction).toBe('up')
+            expect(p.high).toBeGreaterThan(p.low)
+            expect(p.level236).toBeLessThan(p.high)
+            expect(p.level236).toBeGreaterThan(p.level382)
+            expect(p.level382).toBeGreaterThan(p.level500)
+            expect(p.level500).toBeGreaterThan(p.level618)
+            expect(p.level618).toBeGreaterThan(p.level786)
+            expect(p.level786).toBeGreaterThan(p.low)
+        }
+    })
+
+    it('on pureDowntrend direction = down, levels ascend from low to high', () => {
+        const out = calcFibData(pureDowntrend, 10)
+        for (let t = 9; t < out.length; t++) {
+            const p = out[t]!
+            expect(p.direction).toBe('down')
+            expect(p.level236).toBeGreaterThan(p.low)
+            expect(p.level236).toBeLessThan(p.level382)
+            expect(p.level382).toBeLessThan(p.level500)
+        }
+    })
+
+    it('50% level equals (high + low) / 2', () => {
+        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+            const out = calcFibData(fx, 10)
+            for (const p of out) {
+                if (p) {
+                    expect(p.level500).toBeCloseTo((p.high + p.low) / 2, 9)
+                }
+            }
+        }
+    })
+})

package/src/engine/indicators/__tests__/roc.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest'
+import { calcROCData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+} from './__fixtures__/synthetic'
+
+describe('calcROCData', () => {
+    it('empty returns empty', () => {
+        expect(calcROCData(empty, 12)).toEqual([])
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcROCData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice ROC = 0 after warm-up', () => {
+        const out = calcROCData(constantPrice, 12)
+        for (let t = 12; t < out.length; t++) {
+            expect(out[t]).toBe(0)
+        }
+    })
+
+    it('on pureUptrend ROC > 0 throughout post-warmup', () => {
+        const out = calcROCData(pureUptrend, 12)
+        for (let t = 12; t < out.length; t++) {
+            expect(out[t]).toBeGreaterThan(0)
+        }
+    })
+
+    it('on pureDowntrend ROC < 0 throughout post-warmup', () => {
+        const out = calcROCData(pureDowntrend, 12)
+        for (let t = 12; t < out.length; t++) {
+            expect(out[t]).toBeLessThan(0)
+        }
+    })
+
+    it('mathematical exactness: ROC(t) = (close[t]-close[t-p])/close[t-p]*100', () => {
+        const period = 12
+        const out = calcROCData(pureUptrend, period)
+        for (let t = period; t < out.length; t++) {
+            const expected = (pureUptrend[t]!.close - pureUptrend[t - period]!.close) / pureUptrend[t - period]!.close * 100
+            expect(out[t]!).toBeCloseTo(expected, 12)
+        }
+    })
+
+    it('warm-up region is [0, period)', () => {
+        const out = calcROCData(sideways, 12)
+        for (let i = 0; i < 12; i++) expect(out[i]).toBeUndefined()
+        for (let i = 12; i < out.length; i++) expect(out[i]).toBeDefined()
+    })
+
+    it('extensional consistency', () => {
+        const full = calcROCData(pureUptrend, 12)
+        for (let n = 15; n < pureUptrend.length; n++) {
+            const partial = calcROCData(pureUptrend.slice(0, n), 12)
+            for (let i = 0; i < n; i++) {
+                if (full[i] !== undefined && partial[i] !== undefined) {
+                    expect(partial[i]).toBeCloseTo(full[i]!, 12)
+                }
+            }
+        }
+    })
+})