不完整代码，原文看这里。

struct FinancialData {
    double open;
    double close;
    double high;
    double low;
};
void OnTick()
  {


// 计算TR1 新ATR
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 N=20/M=3/M2=10这些参数需要根据不同的品种进行调优
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) {  // j=100-20+1; j<100;j++ 只是计算20 Bar的tr1均值
                ma_tr1 += tr1[j]; //ATR累加
            }
            ma_tr1 /= N;
            up[i] = hl_avg + ma_tr1 * M; //上轨
            dn[i] = hl_avg - ma_tr1 * M; //下轨  M=3.0倍
        } else { //20 bar以内不形成轨道线
            up[i] = hl_avg;
            dn[i] = hl_avg;
        }
    }
    return make_pair(up, dn);
}
//结论：如果当前Bar的ATR幅度很大，比如最近20 Bar持续低迷，那么预测的上下轨作用不大。
//但可考虑作为突破信号用，即判断趋势行情

// 计算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) {  //M2=10
            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;
}
   
  }