@363045841yyt/klinechart-core 0.8.11-alpha.0 → 0.8.12

package/src/indicators/__tests__/oscillators.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Oscillator completion pack tests (B-10).
+ *
+ * Mixed input signatures across the 6:
+ *   - close-only: StochRSI, DPO, STC
+ *   - HL bars   : AO, Fisher Transform
+ *   - OHLC bars : UO
+ */
+
+import { describe, it, expect } from 'vitest'
+import { computeStochRSI } from '../stochRSI'
+import { computeAwesomeOscillator } from '../awesomeOscillator'
+import { computeUltimateOscillator } from '../ultimateOscillator'
+import { computeDPO } from '../dpo'
+import { computeFisherTransform } from '../fisherTransform'
+import { computeSchaffTrendCycle } from '../schaffTrendCycle'
+
+function ramp(n: number, start = 1, step = 1): number[] {
+    return Array.from({ length: n }, (_, i) => start + step * i)
+}
+
+function constantClose(n: number, v: number): number[] {
+    return Array.from({ length: n }, () => v)
+}
+
+function hlBars(n: number, mid = 100, spread = 1): Array<{ high: number; low: number }> {
+    return Array.from({ length: n }, (_, i) => ({
+        high: mid + i * 0.1 + spread / 2,
+        low: mid + i * 0.1 - spread / 2,
+    }))
+}
+
+function ohlcRamp(n: number, start = 100, step = 0.5): Array<{ high: number; low: number; close: number }> {
+    return Array.from({ length: n }, (_, i) => {
+        const c = start + step * i
+        return { high: c + 0.5, low: c - 0.5, close: c }
+    })
+}
+
+describe('computeStochRSI', () => {
+    it('output length === input length and produces values in 0..100', () => {
+        const { k, d } = computeStochRSI(ramp(60), {
+            rsiPeriod: 14,
+            stochPeriod: 14,
+        })
+        expect(k.length).toBe(60)
+        expect(d.length).toBe(60)
+        for (let i = 30; i < 60; i++) {
+            const v = k[i]
+            if (!Number.isNaN(v as number)) {
+                expect(v).toBeGreaterThanOrEqual(0)
+                expect(v).toBeLessThanOrEqual(100)
+            }
+        }
+    })
+
+    it('throws on invalid period args', () => {
+        expect(() => computeStochRSI(ramp(20), { rsiPeriod: 1, stochPeriod: 10 })).toThrow()
+        expect(() => computeStochRSI(ramp(20), { rsiPeriod: 14, stochPeriod: 1 })).toThrow()
+    })
+})
+
+describe('computeAwesomeOscillator', () => {
+    it('output length === input length, leading NaN until slow window primed', () => {
+        const r = computeAwesomeOscillator(hlBars(60), { fast: 5, slow: 34 })
+        expect(r.length).toBe(60)
+        for (let i = 0; i < 33; i++) expect(Number.isNaN(r[i] as number)).toBe(true)
+        expect(Number.isNaN(r[33] as number)).toBe(false)
+    })
+
+    it('on a steady linear trend, AO is positive once primed (fast > slow)', () => {
+        const r = computeAwesomeOscillator(hlBars(60, 100, 1), { fast: 5, slow: 34 })
+        for (let i = 34; i < 60; i++) expect(r[i]).toBeGreaterThan(0)
+    })
+
+    it('rejects fast >= slow', () => {
+        expect(() => computeAwesomeOscillator(hlBars(60), { fast: 10, slow: 10 })).toThrow()
+    })
+})
+
+describe('computeUltimateOscillator', () => {
+    it('output length === input length and 0..100 once primed', () => {
+        const r = computeUltimateOscillator(ohlcRamp(80), { p1: 7, p2: 14, p3: 28 })
+        expect(r.length).toBe(80)
+        for (let i = 30; i < 80; i++) {
+            const v = r[i] as number
+            expect(v).toBeGreaterThanOrEqual(0)
+            expect(v).toBeLessThanOrEqual(100)
+        }
+    })
+
+    it('rejects non-positive periods', () => {
+        expect(() => computeUltimateOscillator(ohlcRamp(50), { p1: 0 })).toThrow()
+    })
+})
+
+describe('computeDPO', () => {
+    it('output length === input length and constant input → ~0 once primed', () => {
+        const r = computeDPO(constantClose(40, 50), { period: 10 })
+        expect(r.length).toBe(40)
+        for (let i = 14; i < 40; i++) expect(r[i]!).toBeCloseTo(0, 9)
+    })
+
+    it('rejects period < 2', () => {
+        expect(() => computeDPO(ramp(20), { period: 1 })).toThrow()
+    })
+})
+
+describe('computeFisherTransform', () => {
+    it('output length === input length; values primed after period', () => {
+        const r = computeFisherTransform(hlBars(50), { period: 10 })
+        expect(r.fisher.length).toBe(50)
+        expect(r.trigger.length).toBe(50)
+        for (let i = 0; i < 9; i++) expect(Number.isNaN(r.fisher[i] as number)).toBe(true)
+        expect(Number.isNaN(r.fisher[10] as number)).toBe(false)
+    })
+
+    it('trigger == fisher shifted one bar', () => {
+        const r = computeFisherTransform(hlBars(50), { period: 10 })
+        for (let i = 12; i < 49; i++) {
+            // trigger[i] is set to previous fisher value before the new fisher is committed.
+            // We can confirm via the relationship inside the producer loop.
+            const t = r.trigger[i + 1]
+            const f = r.fisher[i]
+            if (!Number.isNaN(t as number) && !Number.isNaN(f as number)) {
+                expect(t).toBeCloseTo(f as number, 12)
+            }
+        }
+    })
+})
+
+describe('computeSchaffTrendCycle', () => {
+    it('output length === input length and values in [0, 100]', () => {
+        const r = computeSchaffTrendCycle(ramp(100), { fast: 23, slow: 50, cycle: 10, factor: 0.5 })
+        expect(r.length).toBe(100)
+        for (let i = 70; i < 100; i++) {
+            const v = r[i] as number
+            if (!Number.isNaN(v)) {
+                expect(v).toBeGreaterThanOrEqual(0)
+                expect(v).toBeLessThanOrEqual(100)
+            }
+        }
+    })
+
+    it('rejects bad args', () => {
+        expect(() => computeSchaffTrendCycle(ramp(30), { fast: 50, slow: 23 })).toThrow()
+        expect(() => computeSchaffTrendCycle(ramp(30), { cycle: 1 })).toThrow()
+        expect(() => computeSchaffTrendCycle(ramp(30), { factor: 0 })).toThrow()
+    })
+})

package/src/indicators/alma.ts

@@ -0,0 +1,61 @@
+import { KLineChartError } from '../errors'
+/**
+ * ALMA — Arnaud Legoux Moving Average.
+ *
+ * Public reference: Legoux & Beneduce, "ALMA Indicator Description" (2009).
+ *
+ * Weighted MA where weights are a Gaussian centred at `offset * (period-1)`
+ * (default 0.85 = near the right edge), spread parameter `sigma` (default 6).
+ *
+ *   m       = offset * (period - 1)
+ *   s       = period / sigma
+ *   w[k]    = exp(-(k - m)^2 / (2 * s^2))   for k in 0..period-1
+ *   alma[i] = sum(w[k] * price[i - k]) / sum(w[k])
+ *
+ * `offset` near 1 follows price tightly (short lag); near 0 smooths heavily.
+ * `sigma` controls the bell width — lower = sharper centre.
+ *
+ * Output length === input length. Indices < period - 1 are NaN.
+ */
+
+export interface AlmaOptions {
+    period: number
+    /** Default 0.85 — fractional position of the Gaussian centre, in [0, 1]. */
+    offset?: number
+    /** Default 6 — bell width parameter. Must be > 0. */
+    sigma?: number
+}
+
+export function computeALMA(prices: ReadonlyArray<number>, opts: AlmaOptions): Float64Array {
+    const { period } = opts
+    const offset = opts.offset ?? 0.85
+    const sigma = opts.sigma ?? 6
+    if (period < 1 || !Number.isFinite(period)) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: period must be >= 1')
+    if (sigma <= 0 || !Number.isFinite(sigma)) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: sigma must be > 0')
+    if (offset < 0 || offset > 1) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: offset must be in [0, 1]')
+
+    const out = new Float64Array(prices.length)
+    const m = offset * (period - 1)
+    const s = period / sigma
+    const denom = 2 * s * s
+    const weights = new Float64Array(period)
+    let wsum = 0
+    for (let k = 0; k < period; k++) {
+        const w = Math.exp(-((k - m) * (k - m)) / denom)
+        weights[k] = w
+        wsum += w
+    }
+
+    for (let i = 0; i < prices.length; i++) {
+        if (i < period - 1) {
+            out[i] = Number.NaN
+            continue
+        }
+        let acc = 0
+        for (let k = 0; k < period; k++) {
+            acc += (weights[k] as number) * (prices[i - k] as number)
+        }
+        out[i] = acc / wsum
+    }
+    return out
+}

package/src/indicators/awesomeOscillator.ts

@@ -0,0 +1,54 @@
+import { KLineChartError } from '../errors'
+/**
+ * Awesome Oscillator — Bill Williams.
+ *
+ *   median[i] = (high[i] + low[i]) / 2
+ *   AO[i]     = SMA(median, fast) - SMA(median, slow)
+ *
+ * Defaults: fast=5, slow=34.
+ *
+ * Output: `Float64Array` of length === input. NaN leading.
+ */
+
+export interface AwesomeOscillatorOptions {
+    fast?: number
+    slow?: number
+}
+
+export function computeAwesomeOscillator(
+    bars: ReadonlyArray<{ high: number; low: number }>,
+    opts: AwesomeOscillatorOptions = {},
+): Float64Array {
+    const fast = opts.fast ?? 5
+    const slow = opts.slow ?? 34
+    if (fast < 1 || slow < 1 || fast >= slow) {
+        throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeAwesomeOscillator: require 1 <= fast < slow')
+    }
+    const n = bars.length
+    const med = new Float64Array(n)
+    for (let i = 0; i < n; i++) {
+        const b = bars[i] as { high: number; low: number }
+        med[i] = (b.high + b.low) / 2
+    }
+    const sf = simpleSMA(med, fast)
+    const ss = simpleSMA(med, slow)
+    const out = new Float64Array(n)
+    for (let i = 0; i < n; i++) {
+        const a = sf[i] as number
+        const b = ss[i] as number
+        out[i] = Number.isNaN(a) || Number.isNaN(b) ? Number.NaN : a - b
+    }
+    return out
+}
+
+function simpleSMA(input: Float64Array, period: number): Float64Array {
+    const n = input.length
+    const out = new Float64Array(n)
+    let acc = 0
+    for (let i = 0; i < n; i++) {
+        acc += input[i] as number
+        if (i >= period) acc -= input[i - period] as number
+        out[i] = i < period - 1 ? Number.NaN : acc / period
+    }
+    return out
+}

package/src/indicators/dpo.ts

@@ -0,0 +1,37 @@
+import { KLineChartError } from '../errors'
+/**
+ * DPO — Detrended Price Oscillator.
+ *
+ *   shift = floor(period / 2) + 1
+ *   sma   = SMA(close, period)
+ *   DPO[i] = close[i - shift] - sma[i]
+ *
+ * The shift makes DPO a centred oscillator: the trend (SMA) is removed
+ * at a centred lag so the result is a cleaner cycle indicator.
+ *
+ * Output: `Float64Array` length === input. NaN until index >= period + shift.
+ */
+
+export interface DpoOptions {
+    period: number
+}
+
+export function computeDPO(prices: ReadonlyArray<number>, opts: DpoOptions): Float64Array {
+    const { period } = opts
+    if (period < 2 || !Number.isFinite(period)) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeDPO: period must be >= 2')
+    const n = prices.length
+    const out = new Float64Array(n)
+    out.fill(Number.NaN)
+    const shift = Math.floor(period / 2) + 1
+
+    let acc = 0
+    for (let i = 0; i < n; i++) {
+        acc += prices[i] as number
+        if (i >= period) acc -= prices[i - period] as number
+        if (i < period - 1) continue
+        const sma = acc / period
+        const back = i - shift
+        if (back >= 0) out[i] = (prices[back] as number) - sma
+    }
+    return out
+}

package/src/indicators/fisherTransform.ts

@@ -0,0 +1,63 @@
+import { KLineChartError } from '../errors'
+/**
+ * Fisher Transform — John Ehlers (2002).
+ *
+ * Maps price into a near-Gaussian distribution to make turning points sharper:
+ *
+ *   med[i]   = (high[i] + low[i]) / 2
+ *   hi[i]    = max(med, period)
+ *   lo[i]    = min(med, period)
+ *   raw[i]   = 0.5 * 2 * ((med - lo) / (hi - lo) - 0.5)            (in [-1, 1))
+ *   v[i]     = clip(0.33 * raw + 0.67 * v[i-1], -0.999, 0.999)
+ *   fish[i]  = 0.5 * ln((1 + v) / (1 - v)) + 0.5 * fish[i-1]
+ *
+ * Output: `{ fisher, trigger }` parallel arrays. `trigger` is `fisher`
+ * shifted one bar (a common companion plot).
+ */
+
+export interface FisherTransformOptions {
+    period: number
+}
+
+export function computeFisherTransform(
+    bars: ReadonlyArray<{ high: number; low: number }>,
+    opts: FisherTransformOptions,
+): { fisher: Float64Array; trigger: Float64Array } {
+    const { period } = opts
+    if (period < 2 || !Number.isFinite(period)) {
+        throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeFisherTransform: period must be >= 2')
+    }
+    const n = bars.length
+    const fisher = new Float64Array(n)
+    const trigger = new Float64Array(n)
+    fisher.fill(Number.NaN)
+    trigger.fill(Number.NaN)
+
+    let v = 0
+    let f = 0
+
+    for (let i = 0; i < n; i++) {
+        if (i < period - 1) continue
+        let hi = -Infinity
+        let lo = Infinity
+        for (let j = i - period + 1; j <= i; j++) {
+            const b = bars[j] as { high: number; low: number }
+            const med = (b.high + b.low) / 2
+            if (med > hi) hi = med
+            if (med < lo) lo = med
+        }
+        const b = bars[i] as { high: number; low: number }
+        const medCur = (b.high + b.low) / 2
+        const denom = hi - lo
+        const norm = denom === 0 ? 0 : (medCur - lo) / denom // [0, 1]
+        const raw = 2 * (norm - 0.5)                          // [-1, 1]
+        v = 0.33 * raw + 0.67 * v
+        if (v > 0.999) v = 0.999
+        if (v < -0.999) v = -0.999
+        const fNew = 0.5 * Math.log((1 + v) / (1 - v)) + 0.5 * f
+        trigger[i] = f // previous fisher serves as trigger
+        f = fNew
+        fisher[i] = f
+    }
+    return { fisher, trigger }
+}

package/src/indicators/frama.ts

@@ -0,0 +1,87 @@
+import { KLineChartError } from '../errors'
+/**
+ * FRAMA — Fractal Adaptive Moving Average (John Ehlers, 2005).
+ *
+ * Estimates the fractal dimension D of price over the last `period` bars
+ * (split into two halves) and uses it to adapt an EMA smoothing constant:
+ *
+ *   N1 = (max(H_first_half) - min(H_first_half)) / (period/2)
+ *   N2 = (max(H_second_half) - min(H_second_half)) / (period/2)
+ *   N3 = (max(H_full) - min(H_full)) / period
+ *   D  = (log(N1 + N2) - log(N3)) / log(2)
+ *   alpha = exp(-4.6 * (D - 1))
+ *   FRAMA = alpha * price + (1 - alpha) * FRAMA_prev
+ *
+ * Output length === input length. Indices < period are NaN.
+ *
+ * Note: Ehlers's original uses H (high) and L (low) separately for each
+ * range. With close-only input we use price extrema as a faithful
+ * close-input approximation — documented divergence vs the H/L variant.
+ */
+
+export interface FramaOptions {
+    /** Must be EVEN and >= 4. Default 16. */
+    period: number
+}
+
+function rangeMaxMin(arr: ReadonlyArray<number>, start: number, end: number): {
+    max: number
+    min: number
+} {
+    let max = -Infinity
+    let min = Infinity
+    for (let i = start; i < end; i++) {
+        const v = arr[i] as number
+        if (v > max) max = v
+        if (v < min) min = v
+    }
+    return { max, min }
+}
+
+export function computeFRAMA(prices: ReadonlyArray<number>, opts: FramaOptions): Float64Array {
+    const { period } = opts
+    if (period < 4 || period % 2 !== 0 || !Number.isFinite(period)) {
+        throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeFRAMA: period must be even and >= 4')
+    }
+
+    const n = prices.length
+    const out = new Float64Array(n)
+    const half = period >> 1
+    let prev = Number.NaN
+
+    for (let i = 0; i < n; i++) {
+        if (i < period - 1) {
+            out[i] = Number.NaN
+            continue
+        }
+        const fullStart = i - period + 1
+        const midStart = i - half + 1
+        const r1 = rangeMaxMin(prices, fullStart, fullStart + half)
+        const r2 = rangeMaxMin(prices, midStart, midStart + half)
+        const rF = rangeMaxMin(prices, fullStart, fullStart + period)
+        const N1 = (r1.max - r1.min) / half
+        const N2 = (r2.max - r2.min) / half
+        const N3 = (rF.max - rF.min) / period
+
+        let alpha: number
+        if (N1 <= 0 || N2 <= 0 || N3 <= 0) {
+            // Degenerate flat window — fall back to a simple EMA constant.
+            alpha = 2 / (period + 1)
+        } else {
+            const D = (Math.log(N1 + N2) - Math.log(N3)) / Math.LN2
+            alpha = Math.exp(-4.6 * (D - 1))
+            // Numerical safety: clamp to [0.01, 1].
+            if (!(alpha > 0)) alpha = 0.01
+            if (alpha > 1) alpha = 1
+        }
+
+        const cur = prices[i] as number
+        if (Number.isNaN(prev)) {
+            prev = cur
+        } else {
+            prev = alpha * cur + (1 - alpha) * prev
+        }
+        out[i] = prev
+    }
+    return out
+}

package/src/indicators/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @klinechart-quant/core/indicators — headless indicator math.
+ *
+ * Pure functions over price arrays. No DOM, no signals, no controllers —
+ * these are the building blocks consumers compose into UI flows or feed
+ * to the legacy scheduler in `src/core/indicators/`.
+ *
+ * Convention: each indicator's output is a `Float64Array` of the same length
+ * as the input, with NaN for indices where the indicator hasn't primed yet.
+ * This makes alignment with bar arrays trivial in render code.
+ */
+
+// MA family completion pack (tick 7 b-9)
+export { computeALMA, type AlmaOptions } from './alma'
+export { computeT3, type T3Options } from './t3'
+export { computeZLEMA, type ZlemaOptions } from './zlema'
+export { computeLSMA, type LsmaOptions } from './lsma'
+export { computeVIDYA, type VidyaOptions } from './vidya'
+export { computeFRAMA, type FramaOptions } from './frama'
+
+// Oscillator completion pack (tick 8 b-10)
+export { computeStochRSI, type StochRsiOptions } from './stochRSI'
+export {
+    computeAwesomeOscillator,
+    type AwesomeOscillatorOptions,
+} from './awesomeOscillator'
+export {
+    computeUltimateOscillator,
+    type UltimateOscillatorOptions,
+} from './ultimateOscillator'
+export { computeDPO, type DpoOptions } from './dpo'
+export {
+    computeFisherTransform,
+    type FisherTransformOptions,
+} from './fisherTransform'
+export {
+    computeSchaffTrendCycle,
+    type SchaffTrendCycleOptions,
+} from './schaffTrendCycle'

package/src/indicators/lsma.ts

@@ -0,0 +1,58 @@
+import { KLineChartError } from '../errors'
+/**
+ * LSMA — Least-Squares (Linear Regression) Moving Average.
+ *
+ * At each index i (with at least `period` samples available), fit a
+ * line `y = a + b * x` over the last `period` prices via least squares,
+ * and emit the value of that line at the right endpoint (`y[period-1]`).
+ *
+ * Closed-form (mean-centred):
+ *   x̄ = (period - 1) / 2          (since x = 0..period-1)
+ *   ȳ = mean(prices over window)
+ *   b = sum((x - x̄) * (y - ȳ)) / sum((x - x̄)^2)
+ *   a = ȳ - b * x̄
+ *   lsma[i] = a + b * (period - 1)
+ *
+ * Output length === input length. Indices < period - 1 are NaN.
+ */
+
+export interface LsmaOptions {
+    period: number
+}
+
+export function computeLSMA(prices: ReadonlyArray<number>, opts: LsmaOptions): Float64Array {
+    const { period } = opts
+    if (period < 2 || !Number.isFinite(period)) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeLSMA: period must be >= 2')
+
+    const out = new Float64Array(prices.length)
+    const xbar = (period - 1) / 2
+    // sum((x - x̄)^2) for x = 0..period-1 is a constant; precompute.
+    let xxSum = 0
+    for (let k = 0; k < period; k++) {
+        const d = k - xbar
+        xxSum += d * d
+    }
+
+    for (let i = 0; i < prices.length; i++) {
+        if (i < period - 1) {
+            out[i] = Number.NaN
+            continue
+        }
+        // Window covers indices i - period + 1 .. i, mapped to x = 0..period-1.
+        let ysum = 0
+        for (let k = 0; k < period; k++) {
+            ysum += prices[i - period + 1 + k] as number
+        }
+        const ybar = ysum / period
+        let xy = 0
+        for (let k = 0; k < period; k++) {
+            const xd = k - xbar
+            const yd = (prices[i - period + 1 + k] as number) - ybar
+            xy += xd * yd
+        }
+        const b = xy / xxSum
+        const a = ybar - b * xbar
+        out[i] = a + b * (period - 1)
+    }
+    return out
+}

package/src/indicators/schaffTrendCycle.ts

@@ -0,0 +1,92 @@
+import { KLineChartError } from '../errors'
+/**
+ * STC — Schaff Trend Cycle (Doug Schaff, 2008).
+ *
+ * Doubly-stochastic MACD-cycle hybrid:
+ *
+ *   macd      = EMA(close, fast) - EMA(close, slow)
+ *   k1        = stoch(macd, cycle)         (raw, 0..100)
+ *   d1        = EMA(k1, factor)            (smoothing)
+ *   k2        = stoch(d1, cycle)
+ *   STC       = EMA(k2, factor)
+ *
+ * Defaults: fast=23, slow=50, cycle=10, factor=0.5 (smoothing constant,
+ * applied as `d = factor*new + (1-factor)*d_prev`).
+ *
+ * Output: `Float64Array` length === input. NaN until index >= slow + 2*cycle.
+ */
+
+export interface SchaffTrendCycleOptions {
+    fast?: number
+    slow?: number
+    cycle?: number
+    factor?: number
+}
+
+export function computeSchaffTrendCycle(
+    prices: ReadonlyArray<number>,
+    opts: SchaffTrendCycleOptions = {},
+): Float64Array {
+    const fast = opts.fast ?? 23
+    const slow = opts.slow ?? 50
+    const cycle = opts.cycle ?? 10
+    const factor = opts.factor ?? 0.5
+    if (fast < 2 || slow <= fast) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'STC: require 2 <= fast < slow')
+    if (cycle < 2) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'STC: cycle must be >= 2')
+    if (!(factor > 0 && factor <= 1)) throw new KLineChartError('INDICATOR_INVALID_PARAM', 'STC: factor must be in (0, 1]')
+
+    const n = prices.length
+    const macd = new Float64Array(n)
+    const kFast = 2 / (fast + 1)
+    const kSlow = 2 / (slow + 1)
+    let emaF = Number.NaN
+    let emaS = Number.NaN
+    for (let i = 0; i < n; i++) {
+        const p = prices[i] as number
+        emaF = Number.isNaN(emaF) ? p : kFast * p + (1 - kFast) * emaF
+        emaS = Number.isNaN(emaS) ? p : kSlow * p + (1 - kSlow) * emaS
+        macd[i] = emaF - emaS
+    }
+
+    const k1 = stochOver(macd, cycle)
+    const d1 = smoothFactor(k1, factor)
+    const k2 = stochOver(d1, cycle)
+    const stc = smoothFactor(k2, factor)
+    return stc
+}
+
+function stochOver(input: Float64Array, period: number): Float64Array {
+    const n = input.length
+    const out = new Float64Array(n)
+    out.fill(Number.NaN)
+    for (let i = period - 1; i < n; i++) {
+        let lo = Infinity
+        let hi = -Infinity
+        let any = false
+        for (let j = i - period + 1; j <= i; j++) {
+            const v = input[j] as number
+            if (Number.isNaN(v)) continue
+            any = true
+            if (v < lo) lo = v
+            if (v > hi) hi = v
+        }
+        if (!any) continue
+        const denom = hi - lo
+        out[i] = denom === 0 ? 50 : (100 * ((input[i] as number) - lo)) / denom
+    }
+    return out
+}
+
+function smoothFactor(input: Float64Array, factor: number): Float64Array {
+    const n = input.length
+    const out = new Float64Array(n)
+    out.fill(Number.NaN)
+    let prev = Number.NaN
+    for (let i = 0; i < n; i++) {
+        const v = input[i] as number
+        if (Number.isNaN(v)) continue
+        prev = Number.isNaN(prev) ? v : factor * v + (1 - factor) * prev
+        out[i] = prev
+    }
+    return out
+}