@363045841yyt/klinechart-core 0.8.7 → 0.8.9

package/src/engine/indicators/calculators/movingAverages.ts

@@ -0,0 +1,189 @@
+import type { KLineData } from '../../../types/price'
+import { _computeEMASeries, _computeWMAOnNumbers } from './_shared'
+
+export type MAFlags = {
+    ma5?: boolean
+    ma10?: boolean
+    ma20?: boolean
+    ma30?: boolean
+    ma60?: boolean
+}
+
+export const DEFAULT_MA_PERIODS = [5, 10, 20, 30, 60] as const
+
+export function calcMAData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    let sum = 0
+
+    for (let i = 0; i < period; i++) {
+        const item = data[i]
+        if (!item) return result
+        sum += item.close
+    }
+
+    result[period - 1] = sum / period
+
+    for (let i = period; i < data.length; i++) {
+        const prevItem = data[i - period]
+        const currItem = data[i]
+        if (!prevItem || !currItem) continue
+
+        sum = sum - prevItem.close + currItem.close
+        result[i] = sum / period
+    }
+
+    return result
+}
+
+export interface EXPMAPoint {
+    fast: number
+    slow: number
+}
+
+export function calcEXPMAData(
+    data: KLineData[],
+    fastPeriod: number,
+    slowPeriod: number
+): EXPMAPoint[] {
+    const result: EXPMAPoint[] = new Array(data.length)
+
+    if (data.length === 0) return result
+
+    const fastK = 2 / (fastPeriod + 1)
+    const slowK = 2 / (slowPeriod + 1)
+
+    const firstClose = data[0]!.close
+    let fastEMA = firstClose
+    let slowEMA = firstClose
+
+    result[0] = { fast: fastEMA, slow: slowEMA }
+
+    for (let i = 1; i < data.length; i++) {
+        const close = data[i]!.close
+        fastEMA = close * fastK + fastEMA * (1 - fastK)
+        slowEMA = close * slowK + slowEMA * (1 - slowK)
+        result[i] = { fast: fastEMA, slow: slowEMA }
+    }
+
+    return result
+}
+
+export function calcWMAData(data: KLineData[], period: number): (number | undefined)[] {
+    if (data.length === 0 || period <= 0) {
+        return new Array(data.length).fill(undefined)
+    }
+    const closes = new Array<number | undefined>(data.length)
+    for (let i = 0; i < data.length; i++) closes[i] = data[i]!.close
+    return _computeWMAOnNumbers(closes, period)
+}
+
+export function calcDEMAData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const ema1 = _computeEMASeries(closes, period)
+    const ema2 = _computeEMASeries(ema1, period)
+
+    for (let i = 0; i < n; i++) {
+        const e1 = ema1[i]
+        const e2 = ema2[i]
+        if (e1 === undefined || e2 === undefined) continue
+        result[i] = 2 * e1 - e2
+    }
+    return result
+}
+
+export function calcTEMAData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const ema1 = _computeEMASeries(closes, period)
+    const ema2 = _computeEMASeries(ema1, period)
+    const ema3 = _computeEMASeries(ema2, period)
+
+    for (let i = 0; i < n; i++) {
+        const e1 = ema1[i]
+        const e2 = ema2[i]
+        const e3 = ema3[i]
+        if (e1 === undefined || e2 === undefined || e3 === undefined) continue
+        result[i] = 3 * e1 - 3 * e2 + e3
+    }
+    return result
+}
+
+export function calcHMAData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const halfPeriod = Math.max(1, Math.floor(period / 2))
+    const sqrtPeriod = Math.max(1, Math.round(Math.sqrt(period)))
+
+    const wmaHalf = _computeWMAOnNumbers(closes, halfPeriod)
+    const wmaFull = _computeWMAOnNumbers(closes, period)
+
+    const raw: (number | undefined)[] = new Array(n).fill(undefined)
+    for (let i = 0; i < n; i++) {
+        const h = wmaHalf[i]
+        const f = wmaFull[i]
+        if (h === undefined || f === undefined) continue
+        raw[i] = 2 * h - f
+    }
+    return _computeWMAOnNumbers(raw, sqrtPeriod)
+}
+
+export function calcKAMAData(
+    data: KLineData[],
+    period: number,
+    fastPeriod: number,
+    slowPeriod: number,
+): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || fastPeriod <= 0 || slowPeriod <= 0 || n <= period) return result
+
+    const fastSC = 2 / (fastPeriod + 1)
+    const slowSC = 2 / (slowPeriod + 1)
+    const scRange = fastSC - slowSC
+
+    let volSum = 0
+    for (let i = 1; i <= period; i++) {
+        volSum += Math.abs(data[i]!.close - data[i - 1]!.close)
+    }
+
+    let kama = data[period - 1]!.close
+    result[period - 1] = kama
+
+    for (let t = period; t < n; t++) {
+        const close = data[t]!.close
+        const closeNPeriodsAgo = data[t - period]!.close
+        const direction = Math.abs(close - closeNPeriodsAgo)
+
+        const er = volSum > 0 ? direction / volSum : 0
+        const sc = (er * scRange + slowSC) ** 2
+
+        kama = kama + sc * (close - kama)
+        result[t] = kama
+
+        if (t < n - 1) {
+            volSum -= Math.abs(data[t - period + 1]!.close - data[t - period]!.close)
+            volSum += Math.abs(data[t + 1]!.close - data[t]!.close)
+        }
+    }
+
+    return result
+}

package/src/engine/indicators/calculators/oscillators.ts

@@ -0,0 +1,446 @@
+import type { KLineData } from '../../../types/price'
+import { _computeEMASeries } from './_shared'
+
+export function calcRSIData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period + 1) return result
+
+    const changes: number[] = []
+    for (let i = 1; i < data.length; i++) {
+        changes.push(data[i]!.close - data[i - 1]!.close)
+    }
+
+    let sumGain = 0
+    let sumLoss = 0
+
+    for (let i = 0; i < period; i++) {
+        const change = changes[i]
+        if (change !== undefined) {
+            if (change > 0) sumGain += change
+            else sumLoss += Math.abs(change)
+        }
+    }
+
+    let avgGain = sumGain / period
+    let avgLoss = sumLoss / period
+
+    if (avgLoss === 0) {
+        result[period] = 100
+    } else {
+        const rs = avgGain / avgLoss
+        result[period] = 100 - 100 / (1 + rs)
+    }
+
+    for (let i = period; i < changes.length; i++) {
+        const change = changes[i]
+        if (change === undefined) continue
+
+        if (change > 0) {
+            avgGain = (avgGain * (period - 1) + change) / period
+            avgLoss = (avgLoss * (period - 1)) / period
+        } else {
+            avgGain = (avgGain * (period - 1)) / period
+            avgLoss = (avgLoss * (period - 1) + Math.abs(change)) / period
+        }
+
+        if (avgLoss === 0) {
+            result[i + 1] = 100
+        } else {
+            const rs = avgGain / avgLoss
+            result[i + 1] = 100 - 100 / (1 + rs)
+        }
+    }
+
+    return result
+}
+
+export function calcCCIData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    const tpValues: number[] = []
+    for (const item of data) {
+        tpValues.push((item.high + item.low + item.close) / 3)
+    }
+
+    let sum = 0
+    for (let i = 0; i < period; i++) {
+        sum += tpValues[i]!
+    }
+
+    for (let i = period - 1; i < data.length; i++) {
+        if (i >= period) {
+            sum = sum - tpValues[i - period]! + tpValues[i]!
+        }
+        const sma = sum / period
+
+        let meanDeviation = 0
+        for (let j = 0; j < period; j++) {
+            meanDeviation += Math.abs(tpValues[i - j]! - sma)
+        }
+        meanDeviation /= period
+
+        if (meanDeviation === 0) {
+            result[i] = 0
+        } else {
+            result[i] = (tpValues[i]! - sma) / (0.015 * meanDeviation)
+        }
+    }
+
+    return result
+}
+
+export interface STOCHPoint {
+    k: number
+    d: number
+}
+
+export function calcSTOCHData(data: KLineData[], n: number, m: number): STOCHPoint[] {
+    const result: STOCHPoint[] = new Array(data.length)
+
+    if (data.length < n) return result
+
+    const kValues: (number | undefined)[] = new Array(data.length)
+
+    for (let i = n - 1; i < data.length; i++) {
+        let highest = -Infinity
+        let lowest = Infinity
+
+        for (let j = 0; j < n; j++) {
+            const item = data[i - j]
+            if (!item) continue
+            highest = Math.max(highest, item.high)
+            lowest = Math.min(lowest, item.low)
+        }
+
+        const close = data[i]!.close
+        if (highest === lowest) {
+            kValues[i] = 50
+        } else {
+            kValues[i] = ((close - lowest) / (highest - lowest)) * 100
+        }
+    }
+
+    for (let i = n - 1 + m - 1; i < data.length; i++) {
+        const k = kValues[i]
+        if (k === undefined) continue
+
+        let sum = 0
+        let validCount = 0
+        for (let j = 0; j < m; j++) {
+            const kv = kValues[i - j]
+            if (kv !== undefined) {
+                sum += kv
+                validCount++
+            }
+        }
+
+        if (validCount === m) {
+            result[i] = { k, d: sum / m }
+        }
+    }
+
+    return result
+}
+
+export function calcMOMData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period + 1) return result
+
+    for (let i = period; i < data.length; i++) {
+        const currentClose = data[i]?.close
+        const prevClose = data[i - period]?.close
+
+        if (currentClose !== undefined && prevClose !== undefined) {
+            result[i] = currentClose - prevClose
+        }
+    }
+
+    return result
+}
+
+export function calcWMSRData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    for (let i = period - 1; i < data.length; i++) {
+        let highest = -Infinity
+        let lowest = Infinity
+
+        for (let j = 0; j < period; j++) {
+            const item = data[i - j]
+            if (!item) continue
+            highest = Math.max(highest, item.high)
+            lowest = Math.min(lowest, item.low)
+        }
+
+        const close = data[i]!.close
+        if (highest === lowest) {
+            result[i] = -50
+        } else {
+            result[i] = ((highest - close) / (highest - lowest)) * -100
+        }
+    }
+
+    return result
+}
+
+export interface KSTPoint {
+    kst: number
+    signal: number
+}
+
+function calcROCInternal(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period + 1) return result
+
+    for (let i = period; i < data.length; i++) {
+        const currentClose = data[i]?.close
+        const prevClose = data[i - period]?.close
+
+        if (currentClose !== undefined && prevClose !== undefined && prevClose !== 0) {
+            result[i] = ((currentClose - prevClose) / prevClose) * 100
+        }
+    }
+
+    return result
+}
+
+function calcSMAInternal(data: (number | undefined)[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    let sum = 0
+    let count = 0
+
+    for (let i = 0; i < data.length; i++) {
+        const val = data[i]
+
+        if (val !== undefined) {
+            sum += val
+            count++
+
+            if (count > period) {
+                const oldVal = data[i - period]
+                if (oldVal !== undefined) {
+                    sum -= oldVal
+                    count--
+                }
+            }
+
+            if (count === period) {
+                result[i] = sum / period
+            }
+        }
+    }
+
+    return result
+}
+
+export function calcKSTData(
+    data: KLineData[],
+    roc1: number,
+    roc2: number,
+    roc3: number,
+    roc4: number,
+    signalPeriod: number
+): KSTPoint[] {
+    const result: KSTPoint[] = new Array(data.length)
+
+    const roc1Data = calcROCInternal(data, roc1)
+    const roc2Data = calcROCInternal(data, roc2)
+    const roc3Data = calcROCInternal(data, roc3)
+    const roc4Data = calcROCInternal(data, roc4)
+
+    const sma1 = calcSMAInternal(roc1Data, 10)
+    const sma2 = calcSMAInternal(roc2Data, 10)
+    const sma3 = calcSMAInternal(roc3Data, 10)
+    const sma4 = calcSMAInternal(roc4Data, 15)
+
+    const kstValues: (number | undefined)[] = new Array(data.length)
+
+    for (let i = 0; i < data.length; i++) {
+        const v1 = sma1[i]
+        const v2 = sma2[i]
+        const v3 = sma3[i]
+        const v4 = sma4[i]
+
+        if (v1 !== undefined && v2 !== undefined && v3 !== undefined && v4 !== undefined) {
+            kstValues[i] = v1 * 1 + v2 * 2 + v3 * 3 + v4 * 4
+        }
+    }
+
+    const signalData = calcSMAInternal(kstValues, signalPeriod)
+
+    for (let i = 0; i < data.length; i++) {
+        const kst = kstValues[i]
+        const signal = signalData[i]
+
+        if (kst !== undefined && signal !== undefined) {
+            result[i] = { kst, signal }
+        }
+    }
+
+    return result
+}
+
+export function calcFASTKData(data: KLineData[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    for (let i = period - 1; i < data.length; i++) {
+        let highest = -Infinity
+        let lowest = Infinity
+
+        for (let j = 0; j < period; j++) {
+            const item = data[i - j]
+            if (!item) continue
+            highest = Math.max(highest, item.high)
+            lowest = Math.min(lowest, item.low)
+        }
+
+        const close = data[i]!.close
+        if (highest === lowest) {
+            result[i] = 50
+        } else {
+            result[i] = ((close - lowest) / (highest - lowest)) * 100
+        }
+    }
+
+    return result
+}
+
+export interface MACDPoint {
+    dif: number
+    dea: number
+    macd: number
+}
+
+function calcEMA(data: KLineData[], period: number): number[] {
+    const result: number[] = new Array(data.length)
+    const k = 2 / (period + 1)
+
+    if (data.length === 0) return result
+
+    result[0] = data[0]!.close
+
+    for (let i = 1; i < data.length; i++) {
+        const item = data[i]
+        if (!item) continue
+        result[i] = item.close * k + result[i - 1]! * (1 - k)
+    }
+
+    return result
+}
+
+function calcEMAFromArray(values: (number | undefined)[], period: number): (number | undefined)[] {
+    const result: (number | undefined)[] = new Array(values.length)
+    const k = 2 / (period + 1)
+
+    const firstValid = values.findIndex(v => v !== undefined)
+    if (firstValid === -1) return result
+
+    result[firstValid] = values[firstValid]
+
+    for (let i = firstValid + 1; i < values.length; i++) {
+        const val = values[i]
+        const prev = result[i - 1]
+        if (val === undefined || prev === undefined) continue
+        result[i] = val * k + prev * (1 - k)
+    }
+
+    return result
+}
+
+export function calcMACDData(
+    data: KLineData[],
+    fastPeriod: number,
+    slowPeriod: number,
+    signalPeriod: number
+): MACDPoint[] {
+    const result: MACDPoint[] = new Array(data.length)
+
+    if (data.length < slowPeriod) return result
+
+    const emaFast = calcEMA(data, fastPeriod)
+    const emaSlow = calcEMA(data, slowPeriod)
+
+    const dif: (number | undefined)[] = new Array(data.length)
+    for (let i = 0; i < data.length; i++) {
+        const fast = emaFast[i]
+        const slow = emaSlow[i]
+        if (fast !== undefined && slow !== undefined) {
+            dif[i] = fast - slow
+        }
+    }
+
+    const dea = calcEMAFromArray(dif, signalPeriod)
+
+    for (let i = 0; i < data.length; i++) {
+        const d = dif[i]
+        const e = dea[i]
+        if (d !== undefined && e !== undefined) {
+            result[i] = {
+                dif: d,
+                dea: e,
+                macd: (d - e) * 2,
+            }
+        }
+    }
+
+    return result
+}
+
+export function calcROCData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+    for (let t = period; t < n; t++) {
+        const prev = data[t - period]!.close
+        if (prev === 0) continue
+        result[t] = (data[t]!.close - prev) / prev * 100
+    }
+    return result
+}
+
+export interface TRIXResult {
+    series: (number | undefined)[]
+    signalSeries: (number | undefined)[]
+}
+
+export function calcTRIXData(
+    data: KLineData[],
+    period: number,
+    signalPeriod: number,
+): TRIXResult {
+    const n = data.length
+    const series: (number | undefined)[] = new Array(n).fill(undefined)
+    const signalSeries: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return { series, signalSeries }
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const ema1 = _computeEMASeries(closes, period)
+    const ema2 = _computeEMASeries(ema1, period)
+    const ema3 = _computeEMASeries(ema2, period)
+
+    for (let t = 1; t < n; t++) {
+        const cur = ema3[t]
+        const prev = ema3[t - 1]
+        if (cur === undefined || prev === undefined || prev === 0) continue
+        series[t] = (cur - prev) / prev * 100
+    }
+
+    if (signalPeriod > 0) {
+        const smoothed = _computeEMASeries(series, signalPeriod)
+        for (let i = 0; i < n; i++) signalSeries[i] = smoothed[i]
+    }
+
+    return { series, signalSeries }
+}