动量指标

用于趋势和强度分析的振荡器和基于动量的指标。

RSI - 相对强弱指数

通过比较平均涨幅和平均跌幅来衡量动量。

公式

\[RS = \frac{AvgGain}{AvgLoss}\]

\[RSI = 100 - \frac{100}{1 + RS}\]

初始平均值使用简单均值。后续值使用 Wilder 平滑： $$AvgGain_t = \frac{AvgGain_{t-1} \times (period-1) + gain_t}{period}$$

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(1)
范围	0-100

API 用法

Python

from techkit import RSI

rsi = RSI(period=14)
    result = rsi.update(price)
values = rsi.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
rsi_values = ta.RSI(prices, timeperiod=14)

Node.js

const tk = require('techkit');
const rsi = tk.rsi(14);
const result = rsi.update(price);
const values = tk.RSI(prices, 14);

C++

techkit::RSI rsi(14);
auto result = rsi.update(price);

C

tk_indicator rsi = tk_rsi_new(14);
tk_result r = tk_update(rsi, price);
tk_free(rsi);

交易用法

水平	解释
> 70	超买 - 可能反转下跌
< 30	超卖 - 可能反转上涨
50	中性 / 趋势确认

背离：价格创新高但 RSI 没有 = 看跌背离
失败摆动：RSI 突破之前的摆动 = 趋势变化信号

MACD - 移动平均收敛背离

趋势跟踪动量指标，显示两个 EMA 之间的关系。

公式

\[MACD = EMA(close, fast) - EMA(close, slow)\]

\[Signal = EMA(MACD, signal)\]

\[Histogram = MACD - Signal\]

参数

参数	类型	默认值	范围	描述
fast_period	int	12	2-100000	快线 EMA 周期
slow_period	int	26	2-100000	慢线 EMA 周期
signal_period	int	9	1-100000	信号线 EMA 周期

特性

属性	值
输入	收盘价
输出	3 个值 (macd, signal, histogram)
回看	slow_period - 1 + signal_period - 1
内存	O(1)

API 用法

Python

from techkit import MACD

macd = MACD(fast=12, slow=26, signal=9)
result = macd.update(price)
if result.valid:
    print(f"MACD: {result.macd}, Signal: {result.signal}, Hist: {result.histogram}")

# Batch - returns tuple
macd_line, signal_line, histogram = macd.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
macd, signal, hist = ta.MACD(prices, fastperiod=12, slowperiod=26, signalperiod=9)

Node.js

const tk = require('techkit');
const macd = tk.macd(12, 26, 9);
const result = macd.update(price);
// result.macd, result.signal, result.histogram

const [macdLine, signalLine, hist] = tk.MACD(prices, 12, 26, 9);

C++

techkit::MACD macd(12, 26, 9);
auto result = macd.update_macd(price);
// result.macd, result.signal, result.histogram

C

tk_indicator macd = tk_macd_new(12, 26, 9);
tk_macd_result r = tk_macd_update(macd, price);
// r.macd, r.signal, r.histogram
tk_free(macd);

交易用法

信号	解释
MACD 上穿信号线	看涨
MACD 下穿信号线	看跌
柱状图增加	动量增强
柱状图减少	动量减弱
MACD 穿越零轴	趋势变化

背离：价格与 MACD 背离 = 可能反转
柱状图：预示 MACD/信号线交叉

STOCH - 随机振荡器

将收盘价与一段时间内的价格范围进行比较。

公式

\[\%K_{raw} = \frac{close - lowest(low, k\_period)}{highest(high, k\_period) - lowest(low, k\_period)} \times 100\]

\[\%K_{slow} = SMA(\%K_{raw}, k\_slow)\]

\[\%D = SMA(\%K_{slow}, d\_period)\]

参数

参数	类型	默认值	描述
k_period	int	14	%K 回看周期
k_slow	int	3	%K 平滑周期
k_matype	int	0	%K 均线类型
d_period	int	3	%D 平滑周期
d_matype	int	0	%D 均线类型

特性

属性	值
输入	OHLCV
输出	2 个值 (slowk, slowd)
回看	k_period - 1 + k_slow - 1 + d_period - 1
范围	0-100

API 用法

Python

from techkit import STOCH

stoch = STOCH(k_period=14, k_slow=3, d_period=3)
result = stoch.update_ohlcv(open, high, low, close, volume)
    if result.valid:
    print(f"%K: {result.k}, %D: {result.d}")

slowk, slowd = stoch.calculate(high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
slowk, slowd = ta.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowd_period=3)

Node.js

const { STOCH } = require('techkit');

const stoch = new STOCH({ kPeriod: 14, kSlowPeriod: 3, dPeriod: 3 });
const result = stoch.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`%K: ${result.k}, %D: ${result.d}`);
}

const { k, d } = stoch.calculate(openArr, highArr, lowArr, closeArr, volumeArr);

C++

#include <techkit/techkit.hpp>

techkit::STOCH stoch(14, 3, 3);
auto result = stoch.update_ohlcv(open, high, low, close, volume);
if (result.valid) {
    std::cout << "%K: " << result.k << ", %D: " << result.d << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator stoch = tk_stoch_new(14, 3, 3);
tk_ohlcv bar = {open, high, low, close, volume};
tk_stoch_result r = tk_stoch_update(stoch, &bar);
if (r.valid) {
    printf("%%K: %f, %%D: %f\n", r.slowk, r.slowd);
}
tk_free(stoch);

交易用法

水平	解释
> 80	超买
< 20	超卖
%K 上穿 %D	看涨信号
%K 下穿 %D	看跌信号

ADX - 平均趋向指数

使用方向性运动来衡量趋势强度，无论方向如何。

公式

\[\begin{split}+DM = \begin{cases} high - prev\_high & \text{if } (high - prev\_high) > (prev\_low - low) \text{ and } (high - prev\_high) > 0 \\ 0 & \text{otherwise} \end{cases}\end{split}\]

\[\begin{split}-DM = \begin{cases} prev\_low - low & \text{if } (prev\_low - low) > (high - prev\_high) \text{ and } (prev\_low - low) > 0 \\ 0 & \text{otherwise} \end{cases}\end{split}\]

\[TR = \max(high - low, |high - prev\_close|, |low - prev\_close|)\]

\[+DI = 100 \times \frac{Wilder\_smooth(+DM)}{Wilder\_smooth(TR)}\]

\[-DI = 100 \times \frac{Wilder\_smooth(-DM)}{Wilder\_smooth(TR)}\]

\[DX = 100 \times \frac{|+DI - -DI|}{+DI + -DI}\]

\[ADX = Wilder\_smooth(DX)\]

Wilder 平滑：

第一个平滑值 = sum - sum/period + current
后续：smoothed = smoothed - smoothed/period + current

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	平滑回看周期

特性

属性	值
输入	OHLCV
输出	3 个值 (plus_di, minus_di, adx)
回看	2 × period - 1
内存	O(1)
范围	0-100

API 用法

Python

from techkit import ADX

adx = ADX(period=14)
result = adx.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"+DI: {result.plus_di}, -DI: {result.minus_di}, ADX: {result.adx}")

# TA-Lib compatible
from techkit import talib_compat as ta
adx_values = ta.ADX(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const adx = tk.adx(14);
const result = adx.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`+DI: ${result.plus_di}, -DI: ${result.minus_di}, ADX: ${result.adx}`);
}

const adxValues = tk.ADX(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::ADX adx(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_adx_result result = adx.update(bar);
if (result.valid) {
    std::cout << "+DI: " << result.plus_di 
              << ", -DI: " << result.minus_di 
              << ", ADX: " << result.adx << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator adx = tk_adx_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_adx_result r = tk_adx_update(adx, &bar);
if (r.valid) {
    printf("+DI: %f, -DI: %f, ADX: %f\n", r.plus_di, r.minus_di, r.adx);
}
tk_free(adx);

交易用法

水平	解释
ADX > 25	强趋势 - 适合趋势跟踪策略
ADX < 20	弱/无趋势 - 避免趋势跟踪策略
ADX 20-25	过渡区 - 趋势可能正在形成

方向性指标：

+DI > -DI：上升趋势 - 看涨动量
-DI > +DI：下降趋势 - 看跌动量
+DI 上穿 -DI：看涨信号
-DI 上穿 +DI：看跌信号

综合分析：

高 ADX (>25) + +DI > -DI = 强上升趋势
高 ADX (>25) + -DI > +DI = 强下降趋势
低 ADX (<20) = 区间震荡市场，使用振荡器代替

其他动量指标

[继续完整参考所有 30 个动量指标...]

指标	函数	描述
MOM	`MOM(period)`	动量 (close - close[n])
ROC	`ROC(period)`	变化率 %
CCI	`CCI(period)`	商品通道指数
WILLR	`WILLR(period)`	威廉指标 %R
APO	`APO(fast, slow)`	绝对价格振荡器
PPO	`PPO(fast, slow)`	百分比价格振荡器
CMO	`CMO(period)`	钱德动量振荡器
TRIX	`TRIX(period)`	三重 EMA 变化率
ULTOSC	`ULTOSC(p1, p2, p3)`	终极振荡器
AROON	`AROON(period)`	阿隆指标上/下
AROONOSC	`AROONOSC(period)`	阿隆振荡器

MOM - 动量

N 个周期内的简单价格变化。

公式

\[MOM = price_t - price_{t-period}\]

参数

参数	类型	默认值	范围	描述
period	int	10	1-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(period)

API 用法

Python

from techkit import MOM

mom = MOM(period=10)
result = mom.update(price)
values = mom.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
mom_values = ta.MOM(prices, timeperiod=10)

Node.js

const tk = require('techkit');
const mom = tk.mom(10);
const result = mom.update(price);
const values = tk.MOM(prices, 10);

C++

techkit::MOM mom(10);
auto result = mom.update(price);

C

tk_indicator mom = tk_mom_new(10);
tk_result r = tk_update(mom, price);
tk_free(mom);

交易用法

正值：价格上涨
负值：价格下跌
零轴穿越：趋势变化
背离：价格与动量背离信号反转

ROC - 变化率

N 个周期内的百分比变化。

公式

\[ROC = \frac{price_t - price_{t-period}}{price_{t-period}} \times 100\]

参数

参数	类型	默认值	范围	描述
period	int	10	1-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(period)

API 用法

Python

from techkit import ROC

roc = ROC(period=10)
result = roc.update(price)
values = roc.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
roc_values = ta.ROC(prices, timeperiod=10)

Node.js

const tk = require('techkit');
const roc = tk.roc(10);
const result = roc.update(price);
const values = tk.ROC(prices, 10);

C++

techkit::ROC roc(10);
auto result = roc.update(price);

C

tk_indicator roc = tk_roc_new(10);
tk_result r = tk_update(roc, price);
tk_free(roc);

交易用法

超买/超卖：极值暗示反转
零轴：穿越表示动量转换

ROCP - 变化率百分比

与 ROC 相同，但返回小数（不乘以 100）。

公式

\[ROCP = \frac{price_t - price_{t-period}}{price_{t-period}}\]

参数

参数	类型	默认值	范围	描述
period	int	10	1-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(period)

API 用法

Python

from techkit import ROCP

rocp = ROCP(period=10)
result = rocp.update(price)
values = rocp.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
rocp_values = ta.ROCP(prices, timeperiod=10)

Node.js

const tk = require('techkit');
const rocp = tk.rocp(10);
const result = rocp.update(price);
const values = tk.ROCP(prices, 10);

C++

techkit::ROCP rocp(10);
auto result = rocp.update(price);

C

tk_indicator rocp = tk_rocp_new(10);
tk_result r = tk_update(rocp, price);
tk_free(rocp);

交易用法

正值：价格上涨
负值：价格下跌
零：无变化

ROCR - 变化率比率

N 个周期内的价格比率。

公式

\[ROCR = \frac{price_t}{price_{t-period}}\]

参数

参数	类型	默认值	范围	描述
period	int	10	1-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(period)

API 用法

Python

from techkit import ROCR

rocr = ROCR(period=10)
result = rocr.update(price)
values = rocr.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
rocr_values = ta.ROCR(prices, timeperiod=10)

Node.js

const tk = require('techkit');
const rocr = tk.rocr(10);
const result = rocr.update(price);
const values = tk.ROCR(prices, 10);

C++

techkit::ROCR rocr(10);
auto result = rocr.update(price);

C

tk_indicator rocr = tk_rocr_new(10);
tk_result r = tk_update(rocr, price);
tk_free(rocr);

交易用法

> 1：价格上涨
< 1：价格下跌
= 1：无变化

ROCR100 - 变化率比率 × 100

公式

\[ROCR100 = \frac{price_t}{price_{t-period}} \times 100\]

参数

参数	类型	默认值	范围	描述
period	int	10	1-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(period)

API 用法

Python

from techkit import ROCR100

rocr100 = ROCR100(period=10)
result = rocr100.update(price)
values = rocr100.calculate(prices)

# TA-Lib compatible
from techkit import talib_compat as ta
rocr100_values = ta.ROCR100(prices, timeperiod=10)

Node.js

const tk = require('techkit');
const rocr100 = tk.rocr100(10);
const result = rocr100.update(price);
const values = tk.ROCR100(prices, 10);

C++

techkit::ROCR100 rocr100(10);
auto result = rocr100.update(price);

C

tk_indicator rocr100 = tk_rocr100_new(10);
tk_result r = tk_update(rocr100, price);
tk_free(rocr100);

交易用法

> 100：价格上涨
< 100：价格下跌
= 100：无变化

MACDEXT - MACD 扩展

MACD，所有组件均可配置均线类型。

参数

参数	类型	默认值	描述
fast_period	int	12	快线均线周期
fast_matype	int	0	快线均线类型 (0=SMA, 1=EMA...)
slow_period	int	26	慢线均线周期
slow_matype	int	0	慢线均线类型
signal_period	int	9	信号线均线周期
signal_matype	int	0	信号线均线类型

均线类型值

值	类型
0	SMA
1	EMA
2	WMA
3	DEMA
4	TEMA
5	TRIMA
6	KAMA
7	MAMA
8	T3

MACDFIX - MACD 固定 12/26

MACD，固定 12/26 周期，仅信号周期可配置。

参数

参数	类型	默认值	描述
signal_period	int	9	信号线周期

快线和慢线周期固定为 12 和 26。

STOCHF - 快速随机

快速随机，无 %K 平滑。

公式

\[Fast\%K = \frac{close - lowest(low, k\_period)}{highest(high, k\_period) - lowest(low, k\_period)} \times 100\]

\[Fast\%D = SMA(Fast\%K, d\_period)\]

参数

参数	类型	默认值	描述
k_period	int	5	%K 回看周期
d_period	int	3	%D 平滑周期
d_matype	int	0	%D 均线类型

特性

属性	值
输入	OHLCV
输出	2 个值 (fastk, fastd)
回看	k_period - 1 + d_period - 1
范围	0-100

API 用法

Python

from techkit import STOCHF

stochf = STOCHF(k_period=5, d_period=3)
result = stochf.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Fast %K: {result.k}, Fast %D: {result.d}")

fastk, fastd = stochf.calculate(high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
fastk, fastd = ta.STOCHF(high, low, close, fastk_period=5, fastd_period=3)

Node.js

const { STOCHF } = require('techkit');

const stochf = new STOCHF(5, 3);
const result = stochf.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Fast %K: ${result.k}, Fast %D: ${result.d}`);
}

const { k, d } = stochf.calculate(openArr, highArr, lowArr, closeArr, volumeArr);

C++

#include <techkit/techkit.hpp>

techkit::STOCHF stochf(5, 3);
auto result = stochf.update_ohlcv(open, high, low, close, volume);
if (result.valid) {
    std::cout << "Fast %K: " << result.k << ", Fast %D: " << result.d << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator stochf = tk_stochf_new(5, 3);
tk_ohlcv bar = {open, high, low, close, volume};
tk_stochf_result r = tk_stochf_update(stochf, &bar);
if (r.valid) {
    printf("Fast %%K: %f, Fast %%D: %f\n", r.fastk, r.fastd);
}
tk_free(stochf);

交易用法

类似于 STOCH，但由于缺少 %K 平滑而更敏感。信号更快但更容易产生假信号。

STOCHRSI - 随机 RSI

将随机公式应用于 RSI 值而不是价格。

公式

\[RSI\_values = RSI(close, rsi\_period)\]

\[StochRSI = STOCH(RSI\_values, stoch\_period)\]

参数

参数	类型	默认值	描述
rsi_period	int	14	RSI 周期
stoch_period	int	14	随机周期
k_period	int	3	%K 平滑
d_period	int	3	%D 平滑

特性

属性	值
输入	收盘价
输出	2 个值 (fastk, fastd)
回看	rsi_period + stoch_period - 1 + k_period - 1 + d_period - 1
范围	0-100

API 用法

Python

from techkit import STOCHRSI

stochrsi = STOCHRSI(rsi_period=14, stoch_period=14, k_smooth=3, d_period=3)
result = stochrsi.update(close)
if result.valid:
    print(f"StochRSI %K: {result.k}, %D: {result.d}")

k, d = stochrsi.calculate(close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
fastk, fastd = ta.STOCHRSI(close, timeperiod=14, fastk_period=14, fastd_period=3, fastd_matype=0)

Node.js

const { STOCHRSI } = require('techkit');

const stochrsi = new STOCHRSI(14, 14, 3, 3);
const result = stochrsi.update(close);
if (result.valid) {
    console.log(`StochRSI %K: ${result.k}, %D: ${result.d}`);
}

const { k, d } = stochrsi.calculate(closeArr);

C++

#include <techkit/techkit.hpp>

techkit::STOCHRSI stochrsi(14, 14, 3, 3);
auto result = stochrsi.update(close);
if (result.valid) {
    std::cout << "StochRSI %K: " << result.k << ", %D: " << result.d << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator stochrsi = tk_stochrsi_new(14, 14, 3, 3);
tk_stochrsi_result r = tk_stochrsi_update(stochrsi, close);
if (r.valid) {
    printf("StochRSI %%K: %f, %%D: %f\n", r.fastk, r.fastd);
}
tk_free(stochrsi);

交易用法

比标准 RSI 或随机指标单独使用更敏感。结合动量（RSI）和超买/超卖水平（随机）。

水平	解释
> 80	超买
< 20	超卖
%K 上穿 %D	看涨信号
%K 下穿 %D	看跌信号

ADXR - 平均趋向指数评级

ADX 的平滑版本，将当前 ADX 与 N 个周期前的 ADX 进行平均。

公式

\[ADXR = \frac{ADX_{today} + ADX_{period\_ago}}{2}\]

其中 ADX 的计算方式与 ADX 指标相同。

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	ADX 计算和评级的回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	3 × period - 1
内存	O(period)
范围	0-100

API 用法

Python

from techkit import ADXR

adxr = ADXR(period=14)
result = adxr.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"ADXR: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
adxr_values = ta.ADXR(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const adxr = tk.adxr(14);
const result = adxr.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`ADXR: ${result.value}`);
}

const adxrValues = tk.ADXR(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::ADXR adxr(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = adxr.update(bar);
if (result.valid) {
    std::cout << "ADXR: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator adxr = tk_adxr_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(adxr, &bar);
if (r.valid) {
    printf("ADXR: %f\n", r.value);
}
tk_free(adxr);

交易用法

ADXR 提供了比单独使用 ADX 更平滑、波动更小的趋势强度衡量。

水平	解释
> 25	强趋势确认
< 20	弱趋势确认
ADXR 上升	趋势增强
ADXR 下降	趋势减弱

比 ADX 更不敏感：过滤噪音
更适合确认：用于确认趋势强度
与 ADX 一起使用：用于趋势强度分析

DX - 方向性运动指数

未经 ADX 平滑的原始方向性运动指数。衡量 +DI 和 -DI 之间的差异。

公式

\[DX = 100 \times \frac{|+DI - -DI|}{+DI + -DI}\]

其中 +DI 和 -DI 的计算方式与 ADX 相同。

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	DI 计算的回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period
内存	O(1)
范围	0-100

API 用法

Python

from techkit import DX

dx = DX(period=14)
result = dx.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"DX: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
dx_values = ta.DX(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const dx = tk.dx(14);
const result = dx.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`DX: ${result.value}`);
}

const dxValues = tk.DX(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::DX dx(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = dx.update(bar);
if (result.valid) {
    std::cout << "DX: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator dx = tk_dx_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(dx, &bar);
if (r.valid) {
    printf("DX: %f\n", r.value);
}
tk_free(dx);

交易用法

DX 是平滑为 ADX 之前的原始方向性运动指数。比 ADX 波动更大。

较高值：强方向性运动（向上或向下）
较低值：弱方向性运动，区间震荡市场
大多数交易应用使用 ADX 代替（ADX 是平滑后的 DX）

PLUS_DI - 正向方向性指标

衡量相对于真实区间的向上方向性运动强度。

公式

\[+DI = 100 \times \frac{Wilder\_smooth(+DM)}{Wilder\_smooth(TR)}\]

其中 +DM 和 TR 的计算方式与 ADX 相同。

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	平滑回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period
内存	O(1)
范围	0-100

API 用法

Python

from techkit import PLUS_DI

plus_di = PLUS_DI(period=14)
result = plus_di.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"+DI: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
plus_di_values = ta.PLUS_DI(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const plusDi = tk.plusDi(14);
const result = plusDi.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`+DI: ${result.value}`);
}

const plusDiValues = tk.PLUS_DI(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::PLUS_DI plus_di(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = plus_di.update(bar);
if (result.valid) {
    std::cout << "+DI: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator plus_di = tk_plus_di_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(plus_di, &bar);
if (r.valid) {
    printf("+DI: %f\n", r.value);
}
tk_free(plus_di);

交易用法

+DI 衡量向上价格运动强度。

条件	解释
+DI > -DI	上升趋势 - 看涨动量
+DI 上穿 -DI	看涨信号 - 趋势转为向上
+DI 上升	向上动量增强
+DI 下降	向上动量减弱

与 -DI 一起使用：确定趋势方向
与 ADX 一起使用：确认趋势强度
较高值：表示更强的向上运动

MINUS_DI - 负向方向性指标

衡量相对于真实区间的向下方向性运动强度。

公式

\[-DI = 100 \times \frac{Wilder\_smooth(-DM)}{Wilder\_smooth(TR)}\]

其中 -DM 和 TR 的计算方式与 ADX 相同。

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	平滑回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period
内存	O(1)
范围	0-100

API 用法

Python

from techkit import MINUS_DI

minus_di = MINUS_DI(period=14)
result = minus_di.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"-DI: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
minus_di_values = ta.MINUS_DI(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const minusDi = tk.minusDi(14);
const result = minusDi.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`-DI: ${result.value}`);
}

const minusDiValues = tk.MINUS_DI(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::MINUS_DI minus_di(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = minus_di.update(bar);
if (result.valid) {
    std::cout << "-DI: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator minus_di = tk_minus_di_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(minus_di, &bar);
if (r.valid) {
    printf("-DI: %f\n", r.value);
}
tk_free(minus_di);

交易用法

-DI 衡量向下价格运动强度。

条件	解释
-DI > +DI	下降趋势 - 看跌动量
-DI 上穿 +DI	看跌信号 - 趋势转为向下
-DI 上升	向下动量增强
-DI 下降	向下动量减弱

与 +DI 一起使用：确定趋势方向
与 ADX 一起使用：确认趋势强度
较高值：表示更强的向下运动

PLUS_DM - 正向方向性运动

原始向上方向性运动，使用 Wilder 方法平滑。

公式

\[+DM = \begin{cases} high - prev\_high & \text{if } (high - prev\_high) > (prev\_low - low) \text{ and } (high - prev\_high) > 0 \ 0 & \text{otherwise} \end{cases}\]

使用 Wilder 平滑：

第一个平滑值 = 第一个周期值的总和
后续：smoothed = smoothed - smoothed/period + current

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	平滑回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period - 1
内存	O(1)
范围	0 到正无穷

API 用法

Python

from techkit import PLUS_DM

plus_dm = PLUS_DM(period=14)
result = plus_dm.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"+DM: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
plus_dm_values = ta.PLUS_DM(high, low, timeperiod=14)

Node.js

const tk = require('techkit');
const plusDm = tk.plusDm(14);
const result = plusDm.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`+DM: ${result.value}`);
}

const plusDmValues = tk.PLUS_DM(highArr, lowArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::PLUS_DM plus_dm(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = plus_dm.update(bar);
if (result.valid) {
    std::cout << "+DM: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator plus_dm = tk_plus_dm_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(plus_dm, &bar);
if (r.valid) {
    printf("+DM: %f\n", r.value);
}
tk_free(plus_dm);

交易用法

+DM 衡量标准化之前的原始向上价格运动。

较高值：强向上价格运动
较低值：弱或无向上运动
大多数应用使用 +DI 代替（+DI 通过真实区间标准化）
ADX 系统的组成部分 - 很少单独使用

MINUS_DM - 负向方向性运动

原始向下方向性运动，使用 Wilder 方法平滑。

公式

\[\begin{split}-DM = \begin{cases} prev\_low - low & \text{if } (prev\_low - low) > (high - prev\_high) \text{ and } (prev\_low - low) > 0 \\ 0 & \text{otherwise} \end{cases}\end{split}\]

使用 Wilder 平滑：

第一个平滑值 = 第一个周期值的总和
后续：smoothed = smoothed - smoothed/period + current

参数

参数	类型	默认值	范围	描述
period	int	14	1-100000	平滑回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period - 1
内存	O(1)
范围	0 到正无穷

API 用法

Python

from techkit import MINUS_DM

minus_dm = MINUS_DM(period=14)
result = minus_dm.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"-DM: {result.value}")

# TA-Lib compatible
from techkit import talib_compat as ta
minus_dm_values = ta.MINUS_DM(high, low, timeperiod=14)

Node.js

const tk = require('techkit');
const minusDm = tk.minusDm(14);
const result = minusDm.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`-DM: ${result.value}`);
}

const minusDmValues = tk.MINUS_DM(highArr, lowArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::MINUS_DM minus_dm(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = minus_dm.update(bar);
if (result.valid) {
    std::cout << "-DM: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator minus_dm = tk_minus_dm_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(minus_dm, &bar);
if (r.valid) {
    printf("-DM: %f\n", r.value);
}
tk_free(minus_dm);

交易用法

-DM 衡量标准化之前的原始向下价格运动。

较高值：强向下价格运动
较低值：弱或无向下运动
大多数应用使用 -DI 代替（-DI 通过真实区间标准化）
ADX 系统的组成部分 - 很少单独使用

CCI - 商品通道指数

使用典型价格衡量价格与其统计均值的偏差。

公式

\[TP = \frac{High + Low + Close}{3}\]

\[SMA_{TP} = \frac{1}{period} \sum_{i=0}^{period-1} TP_{t-i}\]

\[MeanDeviation = \frac{1}{period} \sum_{i=0}^{period-1} |TP_{t-i} - SMA_{TP}|\]

\[CCI = \frac{TP - SMA_{TP}}{0.015 \times MeanDeviation}\]

参数

参数	类型	默认值	范围	描述
period	int	20	2-100000	回看周期

特性

属性	值
输入	OHLCV（使用典型价格）
输出	单个值
回看	period - 1
内存	O(period)
范围	通常 -100 到 +100，但无界

API 用法

Python

from techkit import CCI

cci = CCI(period=20)
result = cci.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"CCI: {result.value}")

values = cci.calculate(high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
cci_values = ta.CCI(high, low, close, timeperiod=20)

Node.js

const tk = require('techkit');
const cci = tk.cci(20);
const result = cci.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`CCI: ${result.value}`);
}

const cciValues = tk.CCI(highArr, lowArr, closeArr, 20);

C++

#include <techkit/techkit.hpp>

techkit::CCI cci(20);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = cci.update(bar);
if (result.valid) {
    std::cout << "CCI: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator cci = tk_cci_new(20);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(cci, &bar);
if (r.valid) {
    printf("CCI: %f\n", r.value);
}
tk_free(cci);

交易用法

水平	解释
> +100	超买 - 价格显著高于均值
< -100	超卖 - 价格显著低于均值
0	价格处于统计均值

突破：CCI > +100 或 < -100 表示强动量
反转：从极值水平返回可能信号反转
趋势确认：CCI 保持在零轴上方/下方确认趋势方向

CMO - 钱德动量振荡器

类似于 RSI 的动量振荡器，但范围从 -100 到 +100。

公式

\[Gain = \max(close - prev\_close, 0)\]

\[Loss = \max(prev\_close - close, 0)\]

初始周期：使用涨幅和跌幅的 SMA $$AvgGain = \frac{1}{period} \sum_{i=1}^{period} Gain_i$$AvgLoss = \frac{1}{period} \sum_{i=1}^{period} Loss_i$$

预热后：使用 Wilder 平滑（与 RSI 相同） $$AvgGain_t = \frac{AvgGain_{t-1} \times (period-1) + Gain_t}{period}$$AvgLoss_t = \frac{AvgLoss_{t-1} \times (period-1) + Loss_t}{period}$$

\[CMO = 100 \times \frac{AvgGain - AvgLoss}{AvgGain + AvgLoss}\]

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	收盘价
输出	单个值
回看	period
内存	O(1)
范围	-100 到 +100

API 用法

Python

from techkit import CMO

cmo = CMO(period=14)
result = cmo.update(close)
if result.valid:
    print(f"CMO: {result.value}")

values = cmo.calculate(close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
cmo_values = ta.CMO(close, timeperiod=14)

Node.js

const tk = require('techkit');
const cmo = tk.cmo(14);
const result = cmo.update(close);
if (result.valid) {
    console.log(`CMO: ${result.value}`);
}

const cmoValues = tk.CMO(closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::CMO cmo(14);
tk_result result = cmo.update(close);
if (result.valid) {
    std::cout << "CMO: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator cmo = tk_cmo_new(14);
tk_result r = tk_update(cmo, close);
if (r.valid) {
    printf("CMO: %f\n", r.value);
}
tk_free(cmo);

交易用法

水平	解释
> +50	强向上动量
< -50	强向下动量
0	中性动量

相对于 RSI 的优势：CMO 可以显示负动量（低于 0）
超买/超卖：> +50 或 < -50 表示极端条件
零轴穿越：动量转换信号
背离：价格与 CMO 背离信号可能反转

MFI - 资金流量指数

将交易量纳入动量计算的成交量加权 RSI。

公式

\[TP = \frac{High + Low + Close}{3}\]

\[RawMoneyFlow = TP \times Volume\]

\[PositiveMoneyFlow = \sum_{i=0}^{period-1} RawMF_i \text{ where } TP_i > TP_{i-1}\]

\[NegativeMoneyFlow = \sum_{i=0}^{period-1} RawMF_i \text{ where } TP_i < TP_{i-1}\]

\[MoneyFlowRatio = \frac{PositiveMoneyFlow}{NegativeMoneyFlow}\]

\[MFI = 100 - \frac{100}{1 + MoneyFlowRatio}\]

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period
内存	O(period)
范围	0-100

API 用法

Python

from techkit import MFI

mfi = MFI(period=14)
result = mfi.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"MFI: {result.value}")

values = mfi.calculate(high_arr, low_arr, close_arr, volume_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
mfi_values = ta.MFI(high, low, close, volume, timeperiod=14)

Node.js

const tk = require('techkit');
const mfi = tk.mfi(14);
const result = mfi.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`MFI: ${result.value}`);
}

const mfiValues = tk.MFI(highArr, lowArr, closeArr, volumeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::MFI mfi(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = mfi.update(bar);
if (result.valid) {
    std::cout << "MFI: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator mfi = tk_mfi_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(mfi, &bar);
if (r.valid) {
    printf("MFI: %f\n", r.value);
}
tk_free(mfi);

交易用法

水平	解释
> 80	超买 - 高买压
< 20	超卖 - 高卖压
50	中性

成交量确认：MFI 使用成交量，使其比 RSI 更可靠
背离：价格创新高但 MFI 没有 = 看跌背离（派发）
价格创新低但 MFI 没有 = 看涨背离（吸筹）
与 RSI 一起使用：MFI 用成交量数据确认 RSI 信号

WILLR - 威廉指标 %R

类似于随机指标的动量振荡器，但反转（范围 -100 到 0）。

公式

\[HighestHigh = \max(high, period)\]

\[LowestLow = \min(low, period)\]

\[WILLR = -100 \times \frac{HighestHigh - Close}{HighestHigh - LowestLow}\]

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period - 1
内存	O(period)
范围	-100 到 0

API 用法

Python

from techkit import WILLR

willr = WILLR(period=14)
result = willr.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Williams %R: {result.value}")

values = willr.calculate(high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
willr_values = ta.WILLR(high, low, close, timeperiod=14)

Node.js

const tk = require('techkit');
const willr = tk.willr(14);
const result = willr.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Williams %R: ${result.value}`);
}

const willrValues = tk.WILLR(highArr, lowArr, closeArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::WILLR willr(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = willr.update(bar);
if (result.valid) {
    std::cout << "Williams %R: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator willr = tk_willr_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(willr, &bar);
if (r.valid) {
    printf("Williams %%R: %f\n", r.value);
}
tk_free(willr);

交易用法

水平	解释
> -20	超买 - 收盘价接近最高价
< -80	超卖 - 收盘价接近最低价
-50	中性

反转随机指标：WILLR = -100 × (1 - 随机指标 %K)
超买/超卖：更极端的值表示更强的信号
背离：价格与 WILLR 背离信号可能反转
与随机指标一起使用：确认随机振荡器的信号

APO - 绝对价格振荡器

衡量两个指数移动平均线之间的绝对差值。

公式

\[APO = EMA(close, fast\_period) - EMA(close, slow\_period)\]

参数

参数	类型	默认值	范围	描述
fast_period	int	12	2-100000	快线 EMA 周期
slow_period	int	26	2-100000	慢线 EMA 周期

特性

属性	值
输入	收盘价
输出	单个值
回看	slow_period - 1
内存	O(1)

API 用法

Python

from techkit import APO

apo = APO(fast=12, slow=26)
result = apo.update(close)
if result.valid:
    print(f"APO: {result.value}")

values = apo.calculate(close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
apo_values = ta.APO(close, fastperiod=12, slowperiod=26)

Node.js

const tk = require('techkit');
const apo = tk.apo(12, 26);
const result = apo.update(close);
if (result.valid) {
    console.log(`APO: ${result.value}`);
}

const apoValues = tk.APO(closeArr, 12, 26);

C++

#include <techkit/techkit.hpp>

techkit::APO apo(12, 26);
tk_result result = apo.update(close);
if (result.valid) {
    std::cout << "APO: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator apo = tk_apo_new(12, 26);
tk_result r = tk_update(apo, close);
if (r.valid) {
    printf("APO: %f\n", r.value);
}
tk_free(apo);

交易用法

信号	解释
APO > 0	快线 EMA 高于慢线 EMA - 看涨
APO < 0	快线 EMA 低于慢线 EMA - 看跌
APO 上穿 0	看涨交叉
APO 下穿 0	看跌交叉
APO 增加	动量增强
APO 减少	动量减弱

类似于 MACD：APO 是没有信号平滑的 MACD 线
绝对值：用于比较不同价格水平
零轴穿越：趋势变化信号

PPO - 百分比价格振荡器

衡量两个指数移动平均线之间的百分比差值。

公式

\[PPO = 100 \times \frac{EMA(close, fast\_period) - EMA(close, slow\_period)}{EMA(close, slow\_period)}\]

参数

参数	类型	默认值	范围	描述
fast_period	int	12	2-100000	快线 EMA 周期
slow_period	int	26	2-100000	慢线 EMA 周期

特性

属性	值
输入	收盘价
输出	单个值
回看	slow_period - 1
内存	O(1)

API 用法

Python

from techkit import PPO

ppo = PPO(fast=12, slow=26)
result = ppo.update(close)
if result.valid:
    print(f"PPO: {result.value}")

values = ppo.calculate(close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
ppo_values = ta.PPO(close, fastperiod=12, slowperiod=26)

Node.js

const tk = require('techkit');
const ppo = tk.ppo(12, 26);
const result = ppo.update(close);
if (result.valid) {
    console.log(`PPO: ${result.value}`);
}

const ppoValues = tk.PPO(closeArr, 12, 26);

C++

#include <techkit/techkit.hpp>

techkit::PPO ppo(12, 26);
tk_result result = ppo.update(close);
if (result.valid) {
    std::cout << "PPO: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator ppo = tk_ppo_new(12, 26);
tk_result r = tk_update(ppo, close);
if (r.valid) {
    printf("PPO: %f\n", r.value);
}
tk_free(ppo);

交易用法

信号	解释
PPO > 0	快线 EMA 高于慢线 EMA - 看涨
PPO < 0	快线 EMA 低于慢线 EMA - 看跌
PPO 上穿 0	看涨交叉
PPO 下穿 0	看跌交叉

相对于 APO 的优势：百分比格式允许跨不同证券比较
标准化：相同的百分比值意味着相同的相对动量，无论价格水平如何
用于投资组合分析：比较不同股票的动量

TRIX - 三重平滑 EMA 变化率

显示三重指数平滑移动平均的百分比变化率的动量振荡器。

公式

\[EMA1 = EMA(close, period)\]

\[EMA2 = EMA(EMA1, period)\]

\[EMA3 = EMA(EMA2, period)\]

\[TRIX = 100 \times \frac{EMA3_t - EMA3_{t-1}}{EMA3_{t-1}}\]

参数

参数	类型	默认值	范围	描述
period	int	30	2-100000	所有三个平滑阶段的 EMA 周期

特性

属性	值
输入	收盘价
输出	单个值
回看	3 × (period - 1) + 1
内存	O(1)

API 用法

Python

from techkit import TRIX

trix = TRIX(period=30)
result = trix.update(close)
if result.valid:
    print(f"TRIX: {result.value}")

values = trix.calculate(close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
trix_values = ta.TRIX(close, timeperiod=30)

Node.js

const tk = require('techkit');
const trix = tk.trix(30);
const result = trix.update(close);
if (result.valid) {
    console.log(`TRIX: ${result.value}`);
}

const trixValues = tk.TRIX(closeArr, 30);

C++

#include <techkit/techkit.hpp>

techkit::TRIX trix(30);
tk_result result = trix.update(close);
if (result.valid) {
    std::cout << "TRIX: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator trix = tk_trix_new(30);
tk_result r = tk_update(trix, close);
if (r.valid) {
    printf("TRIX: %f\n", r.value);
}
tk_free(trix);

交易用法

信号	解释
TRIX > 0	向上动量
TRIX < 0	向下动量
TRIX 上穿 0	看涨信号
TRIX 下穿 0	看跌信号

平滑指标：三重平滑有效过滤噪音
动量测量：显示变化率，而非绝对水平
背离：价格与 TRIX 背离信号可能反转
长回看：默认周期 30 使其对短期波动不太敏感

ULTOSC - 终极振荡器

结合三个不同时间框架的买压来识别超买/超卖条件。

公式

\[BP = Close - \min(Low, PrevClose)\]

\[TR = \max(High, PrevClose) - \min(Low, PrevClose)\]

\[Avg1 = \frac{\sum_{i=0}^{period1-1} BP_{t-i}}{\sum_{i=0}^{period1-1} TR_{t-i}}\]

\[Avg2 = \frac{\sum_{i=0}^{period2-1} BP_{t-i}}{\sum_{i=0}^{period2-1} TR_{t-i}}\]

\[Avg3 = \frac{\sum_{i=0}^{period3-1} BP_{t-i}}{\sum_{i=0}^{period3-1} TR_{t-i}}\]

\[ULTOSC = 100 \times \frac{4 \times Avg1 + 2 \times Avg2 + Avg3}{7}\]

参数

参数	类型	默认值	范围	描述
period1	int	7	1-100000	短期周期
period2	int	14	1-100000	中期周期
period3	int	28	1-100000	长期周期

注意：必须满足 period1 < period2 < period3

特性

属性	值
输入	OHLCV
输出	单个值
回看	period3
内存	O(period3)
范围	0-100

API 用法

Python

from techkit import ULTOSC

ultosc = ULTOSC(period1=7, period2=14, period3=28)
result = ultosc.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Ultimate Oscillator: {result.value}")

values = ultosc.calculate(high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
ultosc_values = ta.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28)

Node.js

const tk = require('techkit');
const ultosc = tk.ultosc(7, 14, 28);
const result = ultosc.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Ultimate Oscillator: ${result.value}`);
}

const ultoscValues = tk.ULTOSC(highArr, lowArr, closeArr, 7, 14, 28);

C++

#include <techkit/techkit.hpp>

techkit::ULTOSC ultosc(7, 14, 28);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = ultosc.update(bar);
if (result.valid) {
    std::cout << "Ultimate Oscillator: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator ultosc = tk_ultosc_new(7, 14, 28);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(ultosc, &bar);
if (r.valid) {
    printf("Ultimate Oscillator: %f\n", r.value);
}
tk_free(ultosc);

交易用法

水平	解释
> 70	超买 - 可能反转下跌
< 30	超卖 - 可能反转上涨
50	中性

多时间框架：结合短期、中期和长期动量
加权平均：短期（4×）比长期（1×）权重更大
更少假信号：多时间框架方法减少震荡
背离：价格与 ULTOSC 背离信号可能反转

AROON - 阿隆指标

衡量周期内最高价和最低价出现后经过的时间。

公式

\[AroonUp = 100 \times \frac{period - bars\_since\_highest\_high}{period}\]

\[AroonDown = 100 \times \frac{period - bars\_since\_lowest\_low}{period}\]

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	OHLCV
输出	2 个值 (aroon_up, aroon_down)
回看	period
内存	O(period)
范围	两个输出均为 0-100

API 用法

Python

from techkit import AROON

aroon = AROON(period=14)
result = aroon.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Aroon Up: {result.up}, Aroon Down: {result.down}")

up, down = aroon.calculate(high_arr, low_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
up, down = ta.AROON(high, low, timeperiod=14)

Node.js

const tk = require('techkit');
const aroon = tk.aroon(14);
const result = aroon.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Aroon Up: ${result.up}, Aroon Down: ${result.down}`);
}

const { up, down } = tk.AROON(highArr, lowArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::AROON aroon(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_aroon_result result = aroon.update(bar);
if (result.valid) {
    std::cout << "Aroon Up: " << result.up 
              << ", Aroon Down: " << result.down << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator aroon = tk_aroon_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_aroon_result r = tk_aroon_update(aroon, &bar);
if (r.valid) {
    printf("Aroon Up: %f, Aroon Down: %f\n", r.up, r.down);
}
tk_free(aroon);

交易用法

条件	解释
Aroon Up > 70	强上升趋势 - 近期创新高
Aroon Down > 70	强下降趋势 - 近期创新低
Aroon Up 上穿 Aroon Down	看涨信号
Aroon Down 上穿 Aroon Up	看跌信号
两者 < 50	整理/区间震荡市场

趋势强度：高 Aroon 值表示强趋势
趋势变化：交叉信号潜在趋势反转
基于时间：衡量自极值以来的时间，而非价格水平
与 AROONOSC 一起使用：振荡器版本简化分析

AROONOSC - 阿隆振荡器

从 Aroon Up 和 Aroon Down 导出的单值振荡器。

公式

\[AROONOSC = AroonUp - AroonDown\]

其中 Aroon Up 和 Aroon Down 的计算方式与 AROON 指标相同。

参数

参数	类型	默认值	范围	描述
period	int	14	2-100000	回看周期

特性

属性	值
输入	OHLCV
输出	单个值
回看	period
内存	O(period)
范围	-100 到 +100

API 用法

Python

from techkit import AROONOSC

aroonosc = AROONOSC(period=14)
result = aroonosc.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Aroon Oscillator: {result.value}")

values = aroonosc.calculate(high_arr, low_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
aroonosc_values = ta.AROONOSC(high, low, timeperiod=14)

Node.js

const tk = require('techkit');
const aroonosc = tk.aroonosc(14);
const result = aroonosc.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Aroon Oscillator: ${result.value}`);
}

const aroonoscValues = tk.AROONOSC(highArr, lowArr, 14);

C++

#include <techkit/techkit.hpp>

techkit::AROONOSC aroonosc(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = aroonosc.update(bar);
if (result.valid) {
    std::cout << "Aroon Oscillator: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator aroonosc = tk_aroonosc_new(14);
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(aroonosc, &bar);
if (r.valid) {
    printf("Aroon Oscillator: %f\n", r.value);
}
tk_free(aroonosc);

交易用法

水平	解释
> 0	Aroon Up > Aroon Down - 看涨
< 0	Aroon Down > Aroon Up - 看跌
> +50	强上升趋势
< -50	强下降趋势
穿越零轴	趋势变化信号

简化的 Aroon：单值而非两个值
零轴穿越：信号趋势变化
极值：> +50 或 < -50 表示强趋势
与 AROON 一起使用：以更简单的格式提供相同信息

BOP - 多空平衡

衡量开盘价和收盘价相对于交易区间的关系。

公式

\[BOP = \frac{Close - Open}{High - Low}\]

如果 High == Low（无区间），BOP = 0。

参数

参数	类型	默认值	范围	描述
None	-	-	-	无状态指标（无参数）

特性

属性	值
输入	OHLCV
输出	单个值
回看	0（始终有效）
内存	O(1)
范围	通常 -1 到 +1

API 用法

Python

from techkit import BOP

bop = BOP()
result = bop.update_ohlcv(open, high, low, close, volume)
if result.valid:
    print(f"Balance of Power: {result.value}")

values = bop.calculate(open_arr, high_arr, low_arr, close_arr)

# TA-Lib compatible
from techkit import talib_compat as ta
bop_values = ta.BOP(open, high, low, close)

Node.js

const tk = require('techkit');
const bop = tk.bop();
const result = bop.updateOHLCV({ open, high, low, close, volume });
if (result.valid) {
    console.log(`Balance of Power: ${result.value}`);
}

const bopValues = tk.BOP(openArr, highArr, lowArr, closeArr);

C++

#include <techkit/techkit.hpp>

techkit::BOP bop;
tk_ohlcv bar = {open, high, low, close, volume};
tk_result result = bop.update(bar);
if (result.valid) {
    std::cout << "Balance of Power: " << result.value << std::endl;
}

C

#include <techkit/techkit_c.h>

tk_indicator bop = tk_bop_new();
tk_ohlcv bar = {open, high, low, close, volume};
tk_result r = tk_update_ohlcv(bop, &bar);
if (r.valid) {
    printf("Balance of Power: %f\n", r.value);
}
tk_free(bop);

交易用法

水平	解释
> 0	收盘 > 开盘 - 看涨（买方控制）
< 0	收盘 < 开盘 - 看跌（卖方控制）
= +1	收盘 = 最高价，开盘 = 最低价 - 最大看涨
= -1	收盘 = 最低价，开盘 = 最高价 - 最大看跌
= 0	收盘 = 开盘或最高价 = 最低价 - 中性

日内动量：显示谁控制了 K 线（买方 vs 卖方）
无需预热：从第一根 K 线起始终有效（无状态）
区间标准化：值通过 K 线区间标准化
与其他指标一起使用：确认其他振荡器的动量