File size: 7,957 Bytes
61ca2b1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
/**

 * 技术指标计算工具

 */

export interface PriceData {
  date: string
  open: number
  high: number
  low: number
  close: number
  volume?: number
}

export interface ATRResult {
  date: string
  tr: number
  atr: number
  trPct: number | null
}

/**

 * 将分钟线数据转换为日线数据

 * @param minuteData 分钟线数据数组

 * @returns 转换后的日线数据数组

 */
export function convertMinuteToDaily(minuteData: PriceData[]): PriceData[] {
  if (!minuteData || minuteData.length === 0) {
    return []
  }

  // 按日期分组
  const dailyGroups: Record<string, PriceData[]> = {}
  
  minuteData.forEach(item => {
    // 提取日期部分(去掉时间)
    const dateOnly = item.date.split(' ')[0] || item.date
    
    if (!dailyGroups[dateOnly]) {
      dailyGroups[dateOnly] = []
    }
    
    dailyGroups[dateOnly].push(item)
  })

  // 将分组数据转换为日线数据
  const dailyData: PriceData[] = []
  
  Object.keys(dailyGroups).sort().forEach(date => {
    const dayData = dailyGroups[date]
    
    // 计算日线的OHLCV
    const open = dayData[0].open // 当天第一根K线的开盘价
    const close = dayData[dayData.length - 1].close // 当天最后一根K线的收盘价
    const high = Math.max(...dayData.map(d => d.high)) // 当天最高价
    const low = Math.min(...dayData.map(d => d.low)) // 当天最低价
    const volume = dayData.reduce((sum, d) => sum + (d.volume || 0), 0) // 当天总成交量
    
    dailyData.push({
      date,
      open,
      high,
      low,
      close,
      volume
    })
  })

  return dailyData
}

/**

 * 计算真实波幅(True Range)

 * TR = max(H - L, |H - Cp|, |L - Cp|)

 * H: 当日最高价

 * L: 当日最低价

 * Cp: 前一日收盘价

 * 振幅百分比 = (TR ÷ Cp) × 100%

 */
function calculateTR(

  high: number,

  low: number,

  prevClose: number

): number {
  const hl = high - low
  const hc = Math.abs(high - prevClose)
  const lc = Math.abs(low - prevClose)
  return Math.max(hl, hc, lc)
}

/**

 * 计算 ATR(平均真实波幅)

 * @param priceData 价格数据数组,需要按时间顺序排列

 * @param period ATR 周期,默认 14

 * @returns ATR 结果数组

 */
export function calculateATR(

  priceData: PriceData[],

  period: number = 14

): ATRResult[] {
  if (!priceData || priceData.length < 2) {
    return []
  }

  const results: ATRResult[] = []
  let trSum = 0
  let atr = 0

  for (let i = 0; i < priceData.length; i++) {
    const current = priceData[i]
    let tr = 0;
    let trPct: number | null = null;

    if (i === 0) {
      // 对于第一条数据,TR 就是最高价减去最低价
      tr = current.high - current.low;
    } else {
      const prevClose = priceData[i - 1].close;
      tr = calculateTR(current.high, current.low, prevClose);
      if (Number.isFinite(prevClose) && prevClose !== 0) {
        trPct = (tr / prevClose) * 100
      }
    }

    if (i < period - 1) {
      // 前 period-1 天,累加 TR
      trSum += tr
      results.push({
        date: current.date,
        tr: tr,
        atr: 0, // 未达到周期,ATR 为 0
        trPct: trPct
      })
    } else if (i === period - 1) {
      // 第 period 天,计算初始 ATR
      trSum += tr
      atr = trSum / period
      results.push({
        date: current.date,
        tr: tr,
        atr: atr,
        trPct: trPct
      })
    } else {
      // 第 period+1 天及以后,使用平滑公式
      // 新 ATR = (前一日 ATR × (n-1) + 当日 TR) / n
      atr = (atr * (period - 1) + tr) / period
      results.push({
        date: current.date,
        tr: tr,
        atr: atr,
        trPct: trPct
      })
    }
  }

  return results
}

/**

 * 获取最新的 ATR 值

 * @param priceData 价格数据数组

 * @param period ATR 周期

 * @returns 最新的 ATR 值,如果数据不足返回 0

 */
export function getLatestATR(

  priceData: PriceData[],

  period: number = 14

): number {
  const results = calculateATR(priceData, period)
  if (results.length === 0) return 0
  return results[results.length - 1].atr
}

/**

 * 获取 ATR 统计信息

 */
export interface ATRStats {
  latest: number
  highest: number
  lowest: number
  average: number
  validCount: number
}

export function getATRStats(

  priceData: PriceData[],

  period: number = 14,

  window?: number,

  trimPercent?: number

): ATRStats {
  const results = calculateATR(priceData, period)
  
  // 过滤出有效的 ATR 值(非 0)
  const rawValidATRs = results
    .filter(r => r.atr > 0)
    .map(r => r.atr)

  const w = Number(window)
  const validATRs = Number.isFinite(w) && w > 0
    ? rawValidATRs.slice(-Math.min(rawValidATRs.length, Math.floor(w)))
    : rawValidATRs

  if (validATRs.length === 0) {
    return {
      latest: 0,
      highest: 0,
      lowest: 0,
      average: 0,
      validCount: 0
    }
  }

  const trim = Number(trimPercent)
  const sortedATRs = [...validATRs].sort((a, b) => a - b)
  const rawTrimCount = Number.isFinite(trim) && trim > 0 ? Math.floor((sortedATRs.length * trim) / 100) : 0
  const safeTrimCount = Math.min(rawTrimCount, Math.floor((sortedATRs.length - 1) / 2))
  const trimmedATRs = safeTrimCount > 0
    ? sortedATRs.slice(safeTrimCount, sortedATRs.length - safeTrimCount)
    : sortedATRs
  const average = trimmedATRs.reduce((a, b) => a + b, 0) / trimmedATRs.length

  return {
    latest: validATRs[validATRs.length - 1],
    highest: Math.max(...validATRs),
    lowest: Math.min(...validATRs),
    average,
    validCount: validATRs.length
  }
}

/**

 * 计算移动平均线 (MA)

 * @param priceData 价格数据数组

 * @param period 周期

 * @returns 包含日期和MA值的数组

 */
export function calculateMA(priceData: PriceData[], period: number): { date: string, ma: number }[] {
  if (priceData.length < period) {
    return [];
  }

  const maData: { date: string, ma: number }[] = [];
  let sum = 0;

  // 初始化第一个窗口的 sum
  for (let i = 0; i < period; i++) {
    sum += priceData[i].close;
  }

  maData.push({
    date: priceData[period - 1].date,
    ma: sum / period,
  });

  // 滑动窗口计算后续的MA
  for (let i = period; i < priceData.length; i++) {
    sum = sum - priceData[i - period].close + priceData[i].close;
    maData.push({
      date: priceData[i].date,
      ma: sum / period,
    });
  }

  return maData;
}

/**

 * 获取最新的MA值

 * @param priceData 价格数据

 * @param period 周期

 * @returns 最新的MA值

 */
export function getLatestMA(priceData: PriceData[], period: number): number | null {
  const maResult = calculateMA(priceData, period);
  if (maResult.length > 0) {
    return maResult[maResult.length - 1].ma;
  }
  return null;
}

/**

 * 计算MA的统计信息

 * @param priceData 价格数据

 * @param period 周期

 * @param window 统计窗口(最近window个MA值)。不传则统计全量MA值

 * @returns MA统计信息

 */
export function getMAStats(priceData: PriceData[], period: number, window?: number): ATRStats | null {
  const maResult = calculateMA(priceData, period);
  if (maResult.length === 0) {
    return null;
  }

  const rawValues = maResult.map(item => item.ma);
  const w = Number(window)
  const maValues = Number.isFinite(w) && w > 0
    ? rawValues.slice(-Math.min(rawValues.length, Math.floor(w)))
    : rawValues
  const latest = maValues[maValues.length - 1];
  const highest = Math.max(...maValues);
  const lowest = Math.min(...maValues);
  const average = maValues.reduce((acc, val) => acc + val, 0) / maValues.length;
  const validCount = maValues.length;

  return { latest, highest, lowest, average, validCount };
}