@363045841yyt/klinechart-core 0.8.8 → 0.8.9

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

@@ -0,0 +1,365 @@
+import type { KLineData } from '../../../types/price'
+import { _computeEMASeries } from './_shared'
+import { calcATRData } from './volatility'
+
+export interface BOLLPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcBOLLData(
+    data: KLineData[],
+    period: number,
+    multiplier: number
+): BOLLPoint[] {
+    const result: BOLLPoint[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    let sum = 0
+    const window: number[] = []
+
+    for (let i = 0; i < period; i++) {
+        const item = data[i]
+        if (!item) return result
+        const close = item.close
+        window.push(close)
+        sum += close
+    }
+
+    for (let i = period - 1; i < data.length; i++) {
+        const item = data[i]
+        if (!item) continue
+
+        if (i >= period) {
+            const oldVal = window.shift()
+            if (oldVal !== undefined) sum -= oldVal
+            const close = item.close
+            window.push(close)
+            sum += close
+        }
+
+        const ma = sum / period
+
+        let variance = 0
+        for (let j = 0; j < period; j++) {
+            const wVal = window[j]
+            if (wVal !== undefined) {
+                variance += Math.pow(wVal - ma, 2)
+            }
+        }
+        const stdDev = Math.sqrt(variance / period)
+
+        result[i] = {
+            upper: ma + multiplier * stdDev,
+            middle: ma,
+            lower: ma - multiplier * stdDev,
+        }
+    }
+
+    return result
+}
+
+export interface ENEPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcENEData(
+    data: KLineData[],
+    period: number,
+    deviation: number
+): ENEPoint[] {
+    const result: ENEPoint[] = 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
+    }
+
+    const firstMA = sum / period
+    const firstDeviation = deviation / 100
+    result[period - 1] = {
+        upper: firstMA * (1 + firstDeviation),
+        middle: firstMA,
+        lower: firstMA * (1 - firstDeviation),
+    }
+
+    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
+        const ma = sum / period
+        const dev = deviation / 100
+
+        result[i] = {
+            upper: ma * (1 + dev),
+            middle: ma,
+            lower: ma * (1 - dev),
+        }
+    }
+
+    return result
+}
+
+export interface SARPoint {
+    value: number
+    trend: 'up' | 'down'
+}
+
+export function calcSARData(
+    data: KLineData[],
+    step: number,
+    maxStep: number,
+): (SARPoint | undefined)[] {
+    const n = data.length
+    const result: (SARPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n < 2 || step <= 0 || maxStep <= 0) return result
+
+    let trend: 'up' | 'down' = data[1]!.close >= data[0]!.close ? 'up' : 'down'
+    let sar = trend === 'up' ? data[0]!.low : data[0]!.high
+    let ep = trend === 'up' ? data[0]!.high : data[0]!.low
+    let af = step
+
+    result[0] = { value: sar, trend }
+
+    for (let t = 1; t < n; t++) {
+        const bar = data[t]!
+        sar = sar + af * (ep - sar)
+
+        if (trend === 'up') {
+            const cap1 = data[t - 1]!.low
+            const cap2 = t >= 2 ? data[t - 2]!.low : cap1
+            sar = Math.min(sar, cap1, cap2)
+        } else {
+            const cap1 = data[t - 1]!.high
+            const cap2 = t >= 2 ? data[t - 2]!.high : cap1
+            sar = Math.max(sar, cap1, cap2)
+        }
+
+        if (trend === 'up' && bar.low < sar) {
+            trend = 'down'
+            sar = ep
+            ep = bar.low
+            af = step
+        } else if (trend === 'down' && bar.high > sar) {
+            trend = 'up'
+            sar = ep
+            ep = bar.high
+            af = step
+        } else {
+            if (trend === 'up' && bar.high > ep) {
+                ep = bar.high
+                af = Math.min(af + step, maxStep)
+            } else if (trend === 'down' && bar.low < ep) {
+                ep = bar.low
+                af = Math.min(af + step, maxStep)
+            }
+        }
+
+        result[t] = { value: sar, trend }
+    }
+
+    return result
+}
+
+export interface SuperTrendPoint {
+    value: number
+    trend: 'up' | 'down'
+}
+
+export function calcSuperTrendData(
+    data: KLineData[],
+    atrPeriod: number,
+    multiplier: number,
+): (SuperTrendPoint | undefined)[] {
+    const n = data.length
+    const result: (SuperTrendPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || atrPeriod <= 0 || multiplier <= 0) return result
+
+    const atr = calcATRData(data, atrPeriod)
+
+    let trend: 'up' | 'down' = 'up'
+    let prevUpper = Infinity
+    let prevLower = -Infinity
+
+    for (let t = 0; t < n; t++) {
+        const bar = data[t]!
+        const a = atr[t]
+        if (a === undefined) continue
+
+        const hl2 = (bar.high + bar.low) / 2
+        const upperBasic = hl2 + multiplier * a
+        const lowerBasic = hl2 - multiplier * a
+
+        const prevClose = t > 0 ? data[t - 1]!.close : bar.close
+        const upper = (upperBasic < prevUpper || prevClose > prevUpper) ? upperBasic : prevUpper
+        const lower = (lowerBasic > prevLower || prevClose < prevLower) ? lowerBasic : prevLower
+
+        if (trend === 'up' && bar.close < lower) {
+            trend = 'down'
+        } else if (trend === 'down' && bar.close > upper) {
+            trend = 'up'
+        }
+
+        result[t] = { value: trend === 'up' ? lower : upper, trend }
+
+        prevUpper = upper
+        prevLower = lower
+    }
+
+    return result
+}
+
+export interface KeltnerPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcKeltnerData(
+    data: KLineData[],
+    emaPeriod: number,
+    atrPeriod: number,
+    multiplier: number,
+): (KeltnerPoint | undefined)[] {
+    const n = data.length
+    const result: (KeltnerPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || emaPeriod <= 0 || atrPeriod <= 0) return result
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const ema = _computeEMASeries(closes, emaPeriod)
+    const atr = calcATRData(data, atrPeriod)
+
+    for (let t = 0; t < n; t++) {
+        const m = ema[t]
+        const a = atr[t]
+        if (m === undefined || a === undefined) continue
+        result[t] = {
+            upper: m + multiplier * a,
+            middle: m,
+            lower: m - multiplier * a,
+        }
+    }
+    return result
+}
+
+export interface DonchianPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcDonchianData(
+    data: KLineData[],
+    period: number,
+): (DonchianPoint | undefined)[] {
+    const n = data.length
+    const result: (DonchianPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+
+    for (let t = period - 1; t < n; t++) {
+        let hi = -Infinity
+        let lo = Infinity
+        for (let k = 0; k < period; k++) {
+            const bar = data[t - k]!
+            if (bar.high > hi) hi = bar.high
+            if (bar.low < lo) lo = bar.low
+        }
+        result[t] = { upper: hi, middle: (hi + lo) / 2, lower: lo }
+    }
+    return result
+}
+
+export interface IchimokuPoint {
+    tenkan?: number
+    kijun?: number
+    spanA?: number
+    spanB?: number
+    chikou?: number
+}
+
+function _rollingMidline(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n < period || period <= 0) return result
+    for (let t = period - 1; t < n; t++) {
+        let hi = -Infinity
+        let lo = Infinity
+        for (let k = 0; k < period; k++) {
+            const bar = data[t - k]!
+            if (bar.high > hi) hi = bar.high
+            if (bar.low < lo) lo = bar.low
+        }
+        result[t] = (hi + lo) / 2
+    }
+    return result
+}
+
+export function calcIchimokuData(
+    data: KLineData[],
+    tenkanPeriod: number,
+    kijunPeriod: number,
+    spanBPeriod: number,
+    displacement: number,
+): (IchimokuPoint | undefined)[] {
+    const n = data.length
+    const totalLen = n + displacement
+    const result: (IchimokuPoint | undefined)[] = new Array(totalLen).fill(undefined)
+    if (n === 0 || tenkanPeriod <= 0 || kijunPeriod <= 0 || spanBPeriod <= 0) {
+        return result.slice(0, n)
+    }
+
+    const tenkan = _rollingMidline(data, tenkanPeriod)
+    const kijun = _rollingMidline(data, kijunPeriod)
+    const spanBSource = _rollingMidline(data, spanBPeriod)
+
+    for (let t = 0; t < n; t++) {
+        const point: IchimokuPoint = {}
+        if (tenkan[t] !== undefined) point.tenkan = tenkan[t]
+        if (kijun[t] !== undefined) point.kijun = kijun[t]
+
+        const src = t - displacement
+        if (src >= 0) {
+            if (tenkan[src] !== undefined && kijun[src] !== undefined) {
+                point.spanA = (tenkan[src]! + kijun[src]!) / 2
+            }
+            if (spanBSource[src] !== undefined) {
+                point.spanB = spanBSource[src]
+            }
+        }
+
+        const future = t + displacement
+        if (future < n) point.chikou = data[future]!.close
+
+        result[t] = point
+    }
+
+    for (let f = 0; f < displacement; f++) {
+        const t = n + f
+        const src = t - displacement
+        const point: IchimokuPoint = {}
+        if (src >= 0 && src < n) {
+            if (tenkan[src] !== undefined && kijun[src] !== undefined) {
+                point.spanA = (tenkan[src]! + kijun[src]!) / 2
+            }
+            if (spanBSource[src] !== undefined) {
+                point.spanB = spanBSource[src]
+            }
+        }
+        result[t] = point
+    }
+
+    return result
+}

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

@@ -0,0 +1,37 @@
+export type { MAFlags } from './movingAverages'
+export { DEFAULT_MA_PERIODS, calcMAData } from './movingAverages'
+export type { EXPMAPoint } from './movingAverages'
+export { calcEXPMAData, calcWMAData, calcDEMAData, calcTEMAData, calcHMAData, calcKAMAData } from './movingAverages'
+
+export type { BOLLPoint } from './bands'
+export { calcBOLLData } from './bands'
+export type { ENEPoint } from './bands'
+export { calcENEData } from './bands'
+export type { SARPoint } from './bands'
+export { calcSARData } from './bands'
+export type { SuperTrendPoint } from './bands'
+export { calcSuperTrendData } from './bands'
+export type { KeltnerPoint } from './bands'
+export { calcKeltnerData } from './bands'
+export type { DonchianPoint } from './bands'
+export { calcDonchianData } from './bands'
+export type { IchimokuPoint } from './bands'
+export { calcIchimokuData } from './bands'
+
+export { calcRSIData, calcCCIData } from './oscillators'
+export type { STOCHPoint } from './oscillators'
+export { calcSTOCHData, calcMOMData, calcWMSRData } from './oscillators'
+export type { KSTPoint, MACDPoint } from './oscillators'
+export { calcKSTData, calcFASTKData, calcMACDData } from './oscillators'
+export { calcROCData } from './oscillators'
+export type { TRIXResult } from './oscillators'
+export { calcTRIXData } from './oscillators'
+
+export { calcATRData, calcHVData, calcParkinsonData, calcChaikinVolData } from './volatility'
+
+export { calcVMAData, calcOBVData, calcPVTData, calcVWAPData, calcCMFData, calcMFIData } from './volume'
+export type { VolumeProfileBin, VolumeProfileResult } from './volume'
+export { calcVolumeProfileData } from './volume'
+
+export type { PivotPoint, FibPoint, SwingPoint, StructureEventKind, StructureEvent, StructureSnapshot, ZoneKind, Zone } from './patterns'
+export { calcPivotData, calcFibData, calcStructureData, calcZonesData } from './patterns'

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
+}