人工智能AI学量化：SuperTrend超级趋势创新通道指标

石丰布衣 2025-03-18 发布于广东

展开全文

各位老铁，今天给大家说说一个很深度的主图指标——多维度波动率通道。这可不是普通的指标，它在传统指标的基础上进行了深度创新改良，先来说说它的几个核心部分。

一、SuperTrend超级趋势创新通道简介

（一）改良版ATR机制

传统ATR（平均真实波幅）大家都熟悉吧，但这个改良版的ATR可就有深度了。它采用了 MAX[(H-L), |REF(C,1)-H|, |REF(C,1)-L|] 的计算方式。

简单来说，就是把当天的最高价和最低价的差值、昨天收盘价和今天最高价的差值的绝对值、昨天收盘价和今天最低价的差值的绝对值，这三者中最大的那个作为当天的TR值。这么一来，它对极端波动的捕捉能力就大大增强了，比传统ATR灵敏多了，能更快地感知市场的大幅波动。

（二）动态通道

这个指标的动态通道也很有讲究。它以中轨（H+L）/2为中心，然后在这个基础上叠加 MA(TR1,N)*M 来构造非对称带宽。这就打破了传统布林带那种静态标准差逻辑的局限，让通道能够根据市场的波动情况动态调整，更好地适应市场的变化。

（三）自适应趋势线（SUPERTREN）

这个趋势线可不是简单的均线，它通过递归条件判断（LIJIN3/Z1/Z2）来动态切换趋势方向，还能结合历史信号回溯（BARSLAST）精确捕捉趋势延续或反转的临界点。这就相当于给趋势线装上了“眼睛”和“大脑”，让它能够敏锐地感知市场的趋势变化。

（四）双状态阈值分离

LIJINZ1（绿线）和LIJINZ2（红线）是这个指标的两个重要参考线，它们可以很好地区分多空，避免了传统指标那种滞后性的问题。绿线代表多头信号，红线代表空头信号，通过这两条线，我们可以更清晰地判断市场的多空力量对比。

（五）复合加权均线系统

LIJINW这个加权均线也很有特点，它采用20周期线性衰减权重，公式是（20A + 19REF(A,1) + ... + REF(A,20))/210。这种加权方式赋予了近期价格更高的权重，同时削弱了早期的噪声，让均线更能反映市场的近期走势。而D线则是LIJINW的10周期平滑，和LIJINW一起形成了一个带状区间（DRAWBAND），通过这个带状区间，我们可以监测动量的收敛和发散情况。

二、趋势判断逻辑

这个指标的趋势判断逻辑也很强大，主要有以下几个方面。

（一）波动突破驱动

当价格突破UP通道时，就会触发潜在的多头信号；而当下穿DN通道时，则会强化空头信号。这就相当于给市场设了一个“警戒线”，一旦价格突破这个警戒线，就可能预示着趋势的改变。

（二）SUPERTREN切换

通过D6与YX6周期数的对比（BY/SL交叉），可以判断趋势是延续还是反转。这就像是给趋势线装了一个“开关”，能够及时地切换趋势的方向。

（三）递归信号验证

Z2信号要求价格在Z1周期内连续突破LIJIN3或其滞后值（REF(LIJIN3,2)），这样可以避免假突破的情况。同时，在趋势周期内取极值构建支撑/阻力，形成自适应轨道，这样就能更好地把握趋势的支撑和阻力位。

通达信SuperTrend超级趋势通道指标

DRAWGBK(C>0,RGB(0,0,20),RGB(00,0,0),0,0,1);N:=20;M:=3;TR1:=MAX(MAX((HIGH-LOW),ABS(REF(CLOSE,1)-HIGH)),ABS(REF(CLOSE,1)-LOW));UP:=(H+L)/2+MA(TR1,N)*M;DN:=(H+L)/2-MA(TR1,N)*M;LIJIN:=REF(UP,BARSLAST(UP<=REF(UP,1)));LIJIN2:=LLV(UP,N*1.5);LIJIN3:=IF(LIJIN2<>REF(LIJIN2,1)&&LIJIN<REF(LIJIN,1),LIJIN,IF(LIJIN=LIJIN2,LIJIN,LIJIN2));Z1:=BARSLAST(CROSS(0.5,UP=LIJIN3))+1;Z2:=CROSS(COUNT((CROSS(C,LIJIN3)||CROSS(C,REF(LIJIN3,2)))&&UP>LIJIN3,Z1),0.5);YX6:=BARSLAST(Z2);D6:=BARSLAST(CROSS(HHV(DN,YX6+1),C));BY:=CROSS(D6,YX6);SL:=CROSS(YX6,D6);SUPERTREN:=IF(D6>YX6,HHV(DN,BARSLAST(BY)+1),LLV(UP,BARSLAST(SL)+1));LIJINZ1:IF(D6<=YX6,SUPERTREN,DRAWNULL),COLORGREEN,LINETHICK2;LIJINZ2:IF(D6>YX6,SUPERTREN,DRAWNULL),COLORRED,LINETHICK2;M2:=10;A:=(3*C+L+O+H)/6;

LIJINW:(20*A+19*REF(A,1)+18*REF(A,2)+17*REF(A,3)+16*REF(A,4)+15*REF(A,5)+14*REF(A,6)+13*REF(A,7)+12*REF(A,8)+11*REF(A,9)+10*REF(A,10)+9*REF(A,11)+8*REF(A,12)+7*REF(A,13)+6*REF(A,14)+5*REF(A,15)+4*REF(A,16)+3*REF(A,17)+2*REF(A,18)+REF(A,20))/210,COLORWHITE;

D:MA(LIJINW,M2),COLORYELLOW;DRAWBAND(D,RGB(0,224,224),LIJINW,RGB(255,96,96));DRAWKLINE(H,O,L,C);LIJIN18:=((SMA(MAX((CLOSE-REF(CLOSE,1)),0),6,1)/SMA(ABS((CLOSE-REF(CLOSE,1))),6,1))*100);DRAWTEXT(CROSS(80,LIJIN18),(HIGH),'★短跑'),COLORFFDDEE;DRAWTEXT(CROSS(LIJIN18,20),(LOW),'★机会'),COLORRED;STICKLINE(C<LIJINW,C,O,3,0),COLORBLUE;STICKLINE(C<LIJINW,H,L,0,0),COLORBLUE;STICKLINE(C>=LIJINW,C,O,3,0),COLORYELLOW;STICKLINE(C>=LIJINW,H,L,0,0),COLORYELLOW;STICKLINE(C>=LIJINW&&C>O,C,O,3,0),COLORRED;

四、总结指标评价

这个指标可以说是融合了波动率自适应、递归条件验证、动量加权三重逻辑的高阶趋势跟踪系统。它对趋势启动和终结的捕捉效率显著高于传统Supertrend，非常适合中长线持仓策略。不过，它也有一些局限性。比如参数敏感性比较高，N=20/M=3/M2=10这些参数需要根据不同的品种进行调优。而且在低波动震荡市中，它可能会比较频繁地切换信号。不过，瑕不掩瑜，这个指标的创新点也很突出。它将BARSLAST与CROSS函数嵌套，构建了离散事件驱动型状态机，替代了传统连续型指标计算，这在技术上是一个很大的突破。

总之，这个多维度波动率通道指标是一个很强大的工具，但大家在使用的时候也要结合自己的实际情况，配合成交量或宏观因子过滤，这样才能更好地发挥它的作用，提升胜率。

SuperTrend超级趋势通道指标C++开源代码

#include <iostream>
#include <vector>
#include <cmath>

usingnamespacestd;

struct FinancialData {
    double open;
    double close;
    double high;
    double low;
};

// 计算TR1
vector<double> calculateTR1(const vector<FinancialData>& data) {
    int n = data.size();
    vector<double> tr1(n, 0.0);
    for (int i = 1; i < n; ++i) {
        double high_low = data[i].high - data[i].low;
        double abs_close_high = abs(data[i-1].close - data[i].high);
        double abs_close_low = abs(data[i-1].close - data[i].low);
        tr1[i] = max(max(high_low, abs_close_high), abs_close_low);
    }
    return tr1;
}

// 计算UP和DN
pair<vector<double>, vector<double>> calculateUPDN(const vector<FinancialData>& data, int N, int M) {
    int n = data.size();
    vector<double> up(n, 0.0);
    vector<double> dn(n, 0.0);
    vector<double> tr1 = calculateTR1(data);
    
    for (int i = 0; i < n; ++i) {
        double hl_avg = (data[i].high + data[i].low) / 2.0;
        if (i >= N) {
            double ma_tr1 = 0.0;
            for (int j = i - N + 1; j <= i; ++j) {
                ma_tr1 += tr1[j];
            }
            ma_tr1 /= N;
            up[i] = hl_avg + ma_tr1 * M;
            dn[i] = hl_avg - ma_tr1 * M;
        } else {
            up[i] = hl_avg;
            dn[i] = hl_avg;
        }
    }
    return make_pair(up, dn);
}

// 计算LIJIN3
double calculateLIJIN3(const vector<double>& up) {
    int n = up.size();
    double lijin3 = up[0];
    for (int i = 1; i < n; ++i) {
        if (up[i] != up[i-1] && up[i] < up[i-1]) {
            lijin3 = up[i];
        } elseif (up[i] == up[i-1]) {
            lijin3 = up[i];
        } else {
            lijin3 = up[i-1];
        }
    }
    return lijin3;
}

// 计算Z1和Z2
pair<int, int> calculateZ1Z2(const vector<double>& up, const vector<double>& dn, int N) {
    int n = up.size();
    int z1 = 0;
    int z2 = 0;
    
    // 计算Z1
    for (int i = 0; i < n; ++i) {
        if (i > 0 && up[i] > up[i-1]) {
            z1 = i + 1;
            break;
        }
    }
    
    // 计算Z2
    for (int i = 0; i < n; ++i) {
        if (i > 0 && (up[i] > calculateLIJIN3(up) || dn[i] > calculateLIJIN3(up))) {
            z2 = i + 1;
            break;
        }
    }
    
    return make_pair(z1, z2);
}

// 计算SUPERTREN
vector<double> calculateSUPERTREN(const vector<double>& up, const vector<double>& dn, int N) {
    int n = up.size();
    vector<double> supertren(n, 0.0);
    int last_by = -1;
    int last_sl = -1;
    
    for (int i = 0; i < n; ++i) {
        if (i > 0) {
            if (dn[i] > up[i]) {
                if (last_by == -1) {
                    last_by = i;
                }
                supertren[i] = dn[i];
            } else {
                if (last_sl == -1) {
                    last_sl = i;
                }
                supertren[i] = up[i];
            }
        } else {
            supertren[i] = (up[i] + dn[i]) / 2.0;
        }
    }
    return supertren;
}

// 计算LIJINW
vector<double> calculateLIJINW(const vector<FinancialData>& data, int M2) {
    int n = data.size();
    vector<double> lijinw(n, 0.0);
    
    for (int i = 0; i < n; ++i) {
        double a = (3 * data[i].close + data[i].low + data[i].open + data[i].high) / 6.0;
        double weighted_sum = 0.0;
        for (int j = 0; j < 20; ++j) {
            if (i - j >= 0) {
                weighted_sum += (20 - j) * a;
            }
        }
        lijinw[i] = weighted_sum / 210.0;
    }
    
    // 计算D
    vector<double> d(n, 0.0);
    for (int i = 0; i < n; ++i) {
        if (i >= M2) {
            double sum = 0.0;
            for (int j = i - M2 + 1; j <= i; ++j) {
                sum += lijinw[j];
            }
            d[i] = sum / M2;
        } else {
            d[i] = lijinw[i];
        }
    }
    
    return d;
}