@363045841yyt/klinechart-core 0.7.3

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest'
+import { calcTEMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { TEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcTEMAData — Triple Exponential Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcTEMAData(empty, 20)).toEqual([])
+        })
+
+        it('single bar produces a single defined value', () => {
+            const out = calcTEMAData(singleBar, 20)
+            expect(out).toHaveLength(1)
+            expect(out[0]).toBeCloseTo(100, 9)
+        })
+
+        it('period = 0 returns all undefined', () => {
+            const zero = calcTEMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → TEMA(20) = 100 throughout', () => {
+            assertSeriesClose(calcTEMAData(constantPrice, 20), TEMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcTEMAData(fx, 20), 'TEMA series')
+            }
+        })
+
+        it('tracks uptrend monotonically once warmed', () => {
+            const out = calcTEMAData(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', () => {
+            const full = calcTEMAData(pureUptrend, 20)
+            for (let n = 5; n < pureUptrend.length; n++) {
+                const partial = calcTEMAData(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__/trix.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import { calcTRIXData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+} from './__fixtures__/synthetic'
+
+describe('calcTRIXData', () => {
+    it('empty returns empty result', () => {
+        const out = calcTRIXData(empty, 15, 9)
+        expect(out.series).toEqual([])
+        expect(out.signalSeries).toEqual([])
+    })
+
+    it('period <= 0 returns empty series', () => {
+        const out = calcTRIXData(pureUptrend, 0, 9)
+        for (const v of out.series) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice TRIX = 0 (constant EMA3 → no change)', () => {
+        const out = calcTRIXData(constantPrice, 15, 9)
+        for (let t = 1; t < out.series.length; t++) {
+            if (out.series[t] !== undefined) expect(out.series[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('on pureUptrend TRIX > 0 once warmed', () => {
+        const out = calcTRIXData(pureUptrend, 5, 3)
+        const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
+        expect(tail.length).toBeGreaterThan(0)
+        for (const v of tail) {
+            expect(v).toBeGreaterThan(0)
+        }
+    })
+
+    it('on pureDowntrend TRIX < 0 once warmed', () => {
+        const out = calcTRIXData(pureDowntrend, 5, 3)
+        const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
+        for (const v of tail) {
+            expect(v).toBeLessThan(0)
+        }
+    })
+
+    it('signal series is a smoothing of TRIX (less volatile)', () => {
+        const out = calcTRIXData(sideways, 5, 3)
+        // Both should have defined tails; signal range should not exceed series range
+        const series = out.series.filter((v): v is number => v !== undefined)
+        const signal = out.signalSeries.filter((v): v is number => v !== undefined)
+        if (series.length >= 5 && signal.length >= 5) {
+            const seriesRange = Math.max(...series) - Math.min(...series)
+            const signalRange = Math.max(...signal) - Math.min(...signal)
+            expect(signalRange).toBeLessThanOrEqual(seriesRange + 1e-9)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcTRIXData(pureUptrend, 5, 3)
+        for (let n = 10; n < pureUptrend.length; n++) {
+            const partial = calcTRIXData(pureUptrend.slice(0, n), 5, 3)
+            for (let i = 0; i < n; i++) {
+                if (full.series[i] !== undefined && partial.series[i] !== undefined) {
+                    expect(partial.series[i]).toBeCloseTo(full.series[i]!, 9)
+                }
+            }
+        }
+    })
+})

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

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest'
+import { calcHVData, calcParkinsonData, calcChaikinVolData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcHVData — Historical Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcHVData(empty, 20, 252)).toEqual([])
+    })
+
+    it('period <= 0 or annualization <= 0 returns all undefined', () => {
+        const out1 = calcHVData(pureUptrend, 0, 252)
+        for (const v of out1) expect(v).toBeUndefined()
+        const out2 = calcHVData(pureUptrend, 20, 0)
+        for (const v of out2) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice HV = 0 (no return variance)', () => {
+        const out = calcHVData(constantPrice, 10, 252)
+        for (let t = 10; t < out.length; t++) {
+            expect(out[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('on pureUptrend HV > 0 once warm-up complete', () => {
+        const out = calcHVData(pureUptrend, 10, 252)
+        for (let t = 10; t < out.length; t++) {
+            expect(out[t]).toBeGreaterThanOrEqual(0)
+        }
+    })
+
+    it('HV ≥ 0 always', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcHVData(fx, 10, 252)) {
+                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
+            }
+        }
+    })
+
+    it('higher annualization → higher HV value (sqrt scaling)', () => {
+        const low = calcHVData(spikeAtBar19, 10, 100)
+        const high = calcHVData(spikeAtBar19, 10, 400)
+        for (let t = 10; t < low.length; t++) {
+            if (low[t] !== undefined && high[t] !== undefined) {
+                expect(high[t]).toBeCloseTo(low[t]! * 2, 9) // sqrt(400)/sqrt(100) = 2
+            }
+        }
+    })
+})
+
+describe('calcParkinsonData — Parkinson Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcParkinsonData(empty, 20, 252)).toEqual([])
+    })
+
+    it('on constantPrice (H=L) Parkinson = 0', () => {
+        const out = calcParkinsonData(constantPrice, 10, 252)
+        for (let t = 9; t < out.length; t++) {
+            expect(out[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('Parkinson ≥ 0 always', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcParkinsonData(fx, 10, 252)) {
+                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
+            }
+        }
+    })
+
+    it('on spike fixture Parkinson responds to the spike bar', () => {
+        const out = calcParkinsonData(spikeAtBar19, 5, 252)
+        const preSpike = out[18]
+        const atSpike = out[19]
+        if (preSpike !== undefined && atSpike !== undefined) {
+            expect(atSpike).toBeGreaterThanOrEqual(preSpike)
+        }
+    })
+})
+
+describe('calcChaikinVolData — Chaikin Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcChaikinVolData(empty, 10, 10)).toEqual([])
+    })
+
+    it('on constantPrice ChaikinVol stays at 0 (EMA(H-L) constant)', () => {
+        const out = calcChaikinVolData(constantPrice, 10, 10)
+        for (let t = 10; t < out.length; t++) {
+            if (out[t] !== undefined) expect(out[t]).toBeCloseTo(0, 6)
+        }
+    })
+
+    it('values finite or undefined', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcChaikinVolData(fx, 10, 10)) {
+                if (v !== undefined) expect(Number.isFinite(v)).toBe(true)
+            }
+        }
+    })
+
+    it('extensional consistency on spike fixture', () => {
+        const full = calcChaikinVolData(spikeAtBar19, 5, 5)
+        for (let n = 12; n < spikeAtBar19.length; n++) {
+            const partial = calcChaikinVolData(spikeAtBar19.slice(0, n), 5, 5)
+            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__/volume.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest'
+import { calcVMAData, calcOBVData, calcPVTData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcVMAData', () => {
+    it('empty returns empty', () => {
+        expect(calcVMAData(empty, 5)).toEqual([])
+    })
+
+    it('shorter than period returns all undefined', () => {
+        const out = calcVMAData(pureUptrend.slice(0, 3), 5)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcVMAData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice (volume=1000) VMA = 1000 after warm-up', () => {
+        const out = calcVMAData(constantPrice, 5)
+        for (let t = 4; t < out.length; t++) {
+            expect(out[t]).toBe(1000)
+        }
+    })
+
+    it('mathematical exactness: VMA = mean of last `period` volumes', () => {
+        const period = 5
+        const out = calcVMAData(pureUptrend, period)
+        for (let t = period - 1; t < out.length; t++) {
+            let sum = 0
+            for (let k = 0; k < period; k++) sum += pureUptrend[t - k]!.volume ?? 0
+            expect(out[t]!).toBeCloseTo(sum / period, 9)
+        }
+    })
+})
+
+describe('calcOBVData', () => {
+    it('empty returns empty', () => {
+        expect(calcOBVData(empty)).toEqual([])
+    })
+
+    it('starts at 0', () => {
+        const out = calcOBVData(pureUptrend)
+        expect(out[0]).toBe(0)
+    })
+
+    it('on pureUptrend OBV monotonically increases (every Δclose > 0 → +volume)', () => {
+        const out = calcOBVData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('on pureDowntrend OBV monotonically decreases', () => {
+        const out = calcOBVData(pureDowntrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeLessThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('on constantPrice (no Δclose) OBV stays at 0', () => {
+        const out = calcOBVData(constantPrice)
+        for (const v of out) expect(v).toBe(0)
+    })
+
+    it('extensional consistency on spike fixture', () => {
+        const full = calcOBVData(spikeAtBar19)
+        for (let n = 5; n < spikeAtBar19.length; n++) {
+            const partial = calcOBVData(spikeAtBar19.slice(0, n))
+            for (let i = 0; i < n; i++) {
+                expect(partial[i]).toBe(full[i])
+            }
+        }
+    })
+})
+
+describe('calcPVTData', () => {
+    it('empty returns empty', () => {
+        expect(calcPVTData(empty)).toEqual([])
+    })
+
+    it('starts at 0', () => {
+        expect(calcPVTData(pureUptrend)[0]).toBe(0)
+    })
+
+    it('on constantPrice PVT stays at 0', () => {
+        const out = calcPVTData(constantPrice)
+        for (const v of out) expect(v).toBe(0)
+    })
+
+    it('on pureUptrend PVT monotonically increases', () => {
+        const out = calcPVTData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcPVTData(sideways)
+        for (let n = 5; n < sideways.length; n++) {
+            const partial = calcPVTData(sideways.slice(0, n))
+            for (let i = 0; i < n; i++) {
+                expect(partial[i]).toBeCloseTo(full[i]!, 9)
+            }
+        }
+    })
+})

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

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest'
+import { calcVolumeProfileData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcVolumeProfileData', () => {
+    it('empty returns empty profile', () => {
+        const result = calcVolumeProfileData(empty, 24, 0, 0.7)
+        expect(result.bins).toEqual([])
+        expect(result.totalVolume).toBe(0)
+    })
+
+    it('bins <= 0 returns empty', () => {
+        const result = calcVolumeProfileData(pureUptrend, 0, 0, 0.7)
+        expect(result.bins).toEqual([])
+    })
+
+    it('on constantPrice (H=L=100): degenerate range → empty bins (no meaningful distribution)', () => {
+        const result = calcVolumeProfileData(constantPrice, 10, 0, 0.7)
+        // When priceMax === priceMin, the binning has no range; the function returns empty bins
+        expect(result.bins).toEqual([])
+        expect(result.totalVolume).toBe(0)
+    })
+
+    it('on pureUptrend: total volume = sum of bar volumes', () => {
+        const result = calcVolumeProfileData(pureUptrend, 24, 0, 0.7)
+        let expectedTotal = 0
+        for (const bar of pureUptrend) expectedTotal += bar.volume ?? 0
+        expect(result.totalVolume).toBeCloseTo(expectedTotal, 6)
+    })
+
+    it('POC is within [val, vah] (value area contains POC)', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
+            if (result.bins.length === 0) continue
+            expect(result.poc).toBeGreaterThanOrEqual(result.val)
+            expect(result.poc).toBeLessThanOrEqual(result.vah)
+        }
+    })
+
+    it('VAH >= VAL invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
+            expect(result.vah).toBeGreaterThanOrEqual(result.val)
+        }
+    })
+
+    it('value area sums to >= valueAreaPercent of total volume', () => {
+        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        const vaVolume = result.bins
+            .filter((b) => b.priceLow >= result.val - 1e-9 && b.priceHigh <= result.vah + 1e-9)
+            .reduce((a, b) => a + b.volume, 0)
+        expect(vaVolume).toBeGreaterThanOrEqual(result.totalVolume * 0.7 - 1e-6)
+    })
+
+    it('bins cover [priceMin, priceMax] contiguously', () => {
+        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        for (let i = 1; i < result.bins.length; i++) {
+            expect(result.bins[i]!.priceLow).toBeCloseTo(result.bins[i - 1]!.priceHigh, 9)
+        }
+    })
+
+    it('lookback limits the data window', () => {
+        const full = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        const last10 = calcVolumeProfileData(pureUptrend, 20, 10, 0.7)
+        // Lookback should use less data → lower total volume
+        expect(last10.totalVolume).toBeLessThan(full.totalVolume)
+    })
+})

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

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest'
+import { calcVWAPData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcVWAPData', () => {
+    it('empty returns empty', () => {
+        expect(calcVWAPData(empty, 0)).toEqual([])
+    })
+
+    it('on constantPrice (TP=100, volume=1000) VWAP = 100 throughout', () => {
+        const out = calcVWAPData(constantPrice, 0)
+        for (const v of out) expect(v).toBeCloseTo(100, 9)
+    })
+
+    it('VWAP between min low and max high of cumulative window', () => {
+        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+            const out = calcVWAPData(fx, 0)
+            for (let t = 0; t < out.length; t++) {
+                const v = out[t]
+                if (v === undefined) continue
+                let cumLo = Infinity
+                let cumHi = -Infinity
+                for (let i = 0; i <= t; i++) {
+                    if (fx[i]!.low < cumLo) cumLo = fx[i]!.low
+                    if (fx[i]!.high > cumHi) cumHi = fx[i]!.high
+                }
+                expect(v).toBeGreaterThanOrEqual(cumLo - 1e-9)
+                expect(v).toBeLessThanOrEqual(cumHi + 1e-9)
+            }
+        }
+    })
+
+    it('on pureUptrend VWAP monotonically increases (each new TP > running average)', () => {
+        const out = calcVWAPData(pureUptrend, 0)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeGreaterThan(out[t - 1]!)
+        }
+    })
+
+    it('session reset triggers when gap exceeds threshold', () => {
+        // Construct data with a big timestamp gap to trigger reset
+        const HOUR_MS = 3_600_000
+        const data = pureUptrend.map((bar, i) => ({
+            ...bar,
+            timestamp: bar.timestamp + (i >= 15 ? 24 * HOUR_MS : 0), // 15-bar gap day-jump
+        }))
+        const noReset = calcVWAPData(data, 0)
+        const withReset = calcVWAPData(data, 12 * HOUR_MS)
+        // After reset, VWAP at bar 15+ should be different from no-reset version
+        expect(withReset[15]).not.toBeCloseTo(noReset[15]!, 6)
+    })
+
+    it('extensional consistency', () => {
+        const full = calcVWAPData(pureUptrend, 0)
+        for (let n = 5; n < pureUptrend.length; n++) {
+            const partial = calcVWAPData(pureUptrend.slice(0, n), 0)
+            for (let i = 0; i < n; i++) {
+                expect(partial[i]).toBeCloseTo(full[i]!, 9)
+            }
+        }
+    })
+})

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

@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'vitest'
+import { calcWMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    shortSequence,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { WMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+    assertWarmupThenDefined,
+} from './_propertyAssertions'
+
+describe('calcWMAData — Linear-weighted moving average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcWMAData(empty, 9)).toEqual([])
+        })
+
+        it('single bar with period 9 returns [undefined]', () => {
+            expect(calcWMAData(singleBar, 9)).toEqual([undefined])
+        })
+
+        it('shorter than period returns all undefined', () => {
+            const out = calcWMAData(shortSequence, 9)
+            expect(out).toHaveLength(shortSequence.length)
+            for (const v of out) expect(v).toBeUndefined()
+        })
+
+        it('period = 0 or negative returns all undefined', () => {
+            const zero = calcWMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+            const neg = calcWMAData(pureUptrend, -3)
+            for (const v of neg) expect(v).toBeUndefined()
+        })
+
+        it('period = 1 reproduces close[t] exactly', () => {
+            const out = calcWMAData(pureUptrend, 1)
+            for (let i = 0; i < out.length; i++) {
+                expect(out[i]).toBeCloseTo(pureUptrend[i]!.close, 12)
+            }
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → WMA(9) equals 100 after warm-up', () => {
+            assertSeriesClose(calcWMAData(constantPrice, 9), WMA_GOLDEN.constantPrice!.series)
+        })
+
+        it('pureUptrend → WMA(9) matches closed-form derivation', () => {
+            assertSeriesClose(calcWMAData(pureUptrend, 9), WMA_GOLDEN.pureUptrend!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('warm-up region exactly [0, period-1)', () => {
+            assertWarmupThenDefined(calcWMAData(pureUptrend, 9), 8, 'WMA(9) pureUptrend')
+        })
+
+        it('all values finite (or undefined in warm-up)', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcWMAData(fx, 9), 'WMA series')
+            }
+        })
+
+        it('downtrend WMA mirrors uptrend WMA around the center value', () => {
+            // pureUptrend close = 100+i, pureDowntrend close = 200-i
+            // sum of corresponding closes = 300 for all i → WMA up + WMA down = 300
+            const up = calcWMAData(pureUptrend, 9)
+            const dn = calcWMAData(pureDowntrend, 9)
+            for (let i = 0; i < up.length; i++) {
+                if (up[i] === undefined) {
+                    expect(dn[i]).toBeUndefined()
+                } else {
+                    expect(up[i]! + dn[i]!).toBeCloseTo(300, 9)
+                }
+            }
+        })
+
+        it('WMA lag on linear input equals (period-1)/3', () => {
+            // For close = 100+t, WMA(period)(t) = (100+t) - (period-1)/3 at steady state
+            const period = 9
+            const out = calcWMAData(pureUptrend, period)
+            const lag = (period - 1) / 3
+            for (let t = period - 1; t < out.length; t++) {
+                const expected = 100 + t - lag
+                expect(out[t]!).toBeCloseTo(expected, 9)
+            }
+        })
+    })
+
+    describe('extensional consistency', () => {
+        it('extending data preserves earlier WMA values', () => {
+            for (let n = 9; n < pureUptrend.length; n++) {
+                const prefix = calcWMAData(pureUptrend.slice(0, n), 9)
+                const extended = calcWMAData(pureUptrend.slice(0, n + 1), 9)
+                for (let i = 0; i < prefix.length; i++) {
+                    if (prefix[i] === undefined) {
+                        expect(extended[i]).toBeUndefined()
+                    } else {
+                        expect(extended[i]).toBeCloseTo(prefix[i]!, 12)
+                    }
+                }
+            }
+        })
+    })
+})