汇合指数 Stoch+RSI+MACD - MetaTrader 5脚本

//+------------------------------------------------------------------+
//|                                        MultiConfluence_Index.mq5 |
//|                           Stoch+RSI+MACD 汇合指数    |
//+------------------------------------------------------------------+
＃财产版权 《多元融合指数》
＃财产版本  “1.00”
＃财产指标_单独_窗口
＃财产指标缓冲区 6
＃财产指标图  4

// 索引主线
＃财产指标标签1  《融合指数》
＃财产指标类型1  绘制线
＃财产指示器颜色1  clr道奇蓝
＃财产指示器宽度1  3

// 零线
＃财产指标标签2  《零线》
＃财产指标类型2  绘制线
＃财产指示器颜色2  灰灰
＃财产指示器宽度2  1
＃财产指标样式2  样式_点

// 区域看涨极端
＃财产指标标签3  “区域看涨”
＃财产指标类型3  绘制_填充
＃财产指标颜色3  clr深绿

// 极端看跌区域
＃财产指标标签4  “区域看跌”
＃财产指标类型4  绘制_填充
＃财产指示器颜色4  clr深红

//+------------------------------------------------------------------+
//|输入参数                                              |
//+------------------------------------------------------------------+
输入团体“=== 时间框架 ===”
输入 ENUM_TIMEFRAMESTF1 =PERIOD_CURRENT;  // 时间范围 1（快）
输入 ENUM_TIMEFRAMESTF2=PERIOD_H1;        // 时间范围 2（中）
输入 ENUM_TIMEFRAMESTF3 =PERIOD_H4;        // 时间范围 3（慢速）

输入团体“===参数===
输入 整数      Stoch_K        =14;      // 随机 K
输入 整数      Stoch_D        =3;      // 随机 D
输入 整数      Stoch_Slowing=3;      // 随机放缓
输入 整数      RSI_周期     =14;      // RSI 周期
输入 整数      MACD_快速      =12;      // MACD EMA 快速
输入 整数      MACD_Slow      =26;      // MACD EMA 缓慢
输入 整数      MACD_信号    =9;      // MACD 信号

//+------------------------------------------------------------------+
//|缓冲区                                                            |
//+------------------------------------------------------------------+
双倍的索引缓冲区[]；双倍的零缓冲区[]；双倍的BullishZoneTop[];双倍的BullishZoneBottom[];双倍的BearishZoneTop[];双倍的BearishZoneBottom[];// 指标句柄
整数句柄_stoch_tf1、句柄_stoch_tf2、句柄_stoch_tf3；整数句柄_rsi_tf1、句柄_rsi_tf2、句柄_rsi_tf3；整数句柄_macd_tf1、句柄_macd_tf2、句柄_macd_tf3；//+------------------------------------------------------------------+
//|初始化                                                     |
//+------------------------------------------------------------------+
整数 初始化时()
{
  // 缓冲区  设置索引缓冲区（0, 索引缓冲区,INDICATOR_DATA）；
  设置索引缓冲区（1, 零缓冲区,INDICATOR_DATA）；
  设置索引缓冲区（2, 看涨区域顶部,INDICATOR_DATA）；
  设置索引缓冲区（3, 看涨区域底部,INDICATOR_DATA）；
  设置索引缓冲区（4, 熊市顶部,INDICATOR_DATA）；
  设置索引缓冲区（5, 看跌区域底部,INDICATOR_DATA）；
   
  // 配置  数组集为系列（索引缓冲区，真的）；
  数组集为系列（零缓冲区，真的）；
  数组集为系列（看涨区域顶部，真的）；
  数组集为系列（看涨区域底部，真的）；
  数组集为系列（看跌区域顶部，真的）；
  数组集为系列（看跌区域底部，真的）；
   
  // 零线  数组初始化（零缓冲区，0.0）；
   
  // 填充区域的配置  绘图索引集整数（2,绘图_绘制_开始,0）；
  绘图索引集整数（3,绘图_绘制_开始,0）；
   
  // 创建句柄 - 随机   句柄_stoch_tf1 =随机指标（_象征, TF1, Stoch_K, Stoch_D, Stoch_Slowing,模式_SMA,STO_LOWHIGH）；
   句柄_stoch_tf2 =随机指标（_象征, TF2, Stoch_K, Stoch_D, Stoch_Slowing,模式_SMA,STO_LOWHIGH）；
   句柄_stoch_tf3 =随机指标（_象征, TF3, Stoch_K, Stoch_D, Stoch_Slowing,模式_SMA,STO_LOWHIGH）；
   
  // 创建句柄 - RSI   句柄_rsi_tf1 =RSI（_象征, TF1, RSI_周期,PRICE_CLOSE）；
   句柄_rsi_tf2 =RSI（_象征, TF2, RSI_周期,PRICE_CLOSE）；
   句柄_rsi_tf3 =RSI（_象征, TF3, RSI_周期,PRICE_CLOSE）；
   
  // 创建句柄 - MACD   句柄_macd_tf1 =平滑异同移动平均线（_象征, TF1, MACD_快, MACD_慢, MACD_信号,PRICE_CLOSE）；
   句柄_macd_tf2 =平滑异同移动平均线（_象征, TF2, MACD_快, MACD_慢, MACD_信号,PRICE_CLOSE）；
   句柄_macd_tf3 =平滑异同移动平均线（_象征, TF3, MACD_快, MACD_慢, MACD_信号,PRICE_CLOSE）；
   
  // 验证句柄  如果(handle_stoch_tf1 ==INVALID_HANDLE||句柄_stoch_tf2 ==INVALID_HANDLE||句柄_stoch_tf3 ==INVALID_HANDLE||
      句柄_rsi_tf1 ==INVALID_HANDLE||句柄_rsi_tf2 ==INVALID_HANDLE||句柄_rsi_tf3 ==INVALID_HANDLE||
      句柄_macd_tf1 ==INVALID_HANDLE||句柄_macd_tf2 ==INVALID_HANDLE||句柄_macd_tf3 ==INVALID_HANDLE）
   {
      打印（“错误：无法创建句柄”）；
      返回（初始化失败）；
   }
   
  // 名称和比例  指标集字符串（INDICATOR_SHORTNAME,《多元融合指数》）；
  指标集整数（INDICATOR_DIGITS,1）；
  指标集双（INDICATOR_MINIMUM, -100）；
  指标集双（INDICATOR_MAXIMUM,100）；
   
  // 级别  指标集整数（INDICATOR_LEVELS,3）；
  指标集双（INDICATOR_LEVELVALUE,0,0）；
  指标集双（INDICATOR_LEVELVALUE,1,50）；
  指标集双（INDICATOR_LEVELVALUE,2, -50）；
   
  指标集整数（INDICATOR_LEVELCOLOR,0,灰灰）；
  指标集整数（INDICATOR_LEVELCOLOR,1,清绿）；
  指标集整数（INDICATOR_LEVELCOLOR,2,红细胞）；
   
  指标集整数（INDICATOR_LEVELSTYLE,0,样式_实体）；
  指标集整数（INDICATOR_LEVELSTYLE,1,样式_点）；
  指标集整数（INDICATOR_LEVELSTYLE,2,样式_点）；
   
  打印（“多重汇合索引已初始化 - TF：”,枚举转字符串(TF1),“/”,枚举转字符串(TF2),“/”,枚举转字符串(TF3));
  返回（初始化成功）；
}//+------------------------------------------------------------------+
//|去初始化                                                 |
//+------------------------------------------------------------------+
空白 解初始化（常量 整数原因）
{
  如果（handle_stoch_tf1！=INVALID_HANDLE）指标释放(handle_stoch_tf1);
  如果（handle_stoch_tf2！=INVALID_HANDLE）指标释放(handle_stoch_tf2);
  如果（handle_stoch_tf3！=INVALID_HANDLE）指标释放(handle_stoch_tf3);
  如果（handle_rsi_tf1！=INVALID_HANDLE）指标释放(handle_rsi_tf1);
  如果（handle_rsi_tf2！=INVALID_HANDLE）指标释放(handle_rsi_tf2);
  如果（handle_rsi_tf3！=INVALID_HANDLE）指标释放(handle_rsi_tf3);
  如果（handle_macd_tf1！=INVALID_HANDLE）指标释放(handle_macd_tf1);
  如果(handle_macd_tf2 !=INVALID_HANDLE）指标释放(handle_macd_tf2);
  如果（handle_macd_tf3！=INVALID_HANDLE）指标释放(handle_macd_tf3);
   
  评论（””）；
}//+------------------------------------------------------------------+
//|主要计算                                                   |
//+------------------------------------------------------------------+
整数 计算时（常量 整数费率_总计，
                常量 整数先前计算的，
                常量 日期时间＆时间[]，
                常量 双倍的＆打开[]，
                常量 双倍的＆高的[]，
                常量 双倍的＆低的[]，
                常量 双倍的＆关闭[]，
                常量 长的&tick_volume[],
                常量 长的＆体积[]，
                常量 整数＆传播[]）
{
  如果（费率_总计 <100）
      返回（0）；
   
  整数限制= rates_total - prev_calculated；
  如果（限制==0) 极限 =1;
  如果（先前计算的==0) 限制 = rates_total -100;
   
  // 数据数组（作为匹配缓冲区索引的系列）  双倍的stoch_k1[]、stoch_d1[]、stoch_k2[]、stoch_d2[]、stoch_k3[]、stoch_d3[]；
  双倍的rsi1[]、rsi2[]、rsi3[]；
  双倍的macd_main1[]、macd_sig1[]、macd_main2[]、macd_sig2[]、macd_main3[]、macd_sig3[]；
   
  数组集为系列(stoch_k1,真的）；
  数组集为系列（stoch_d1，真的）；
  数组集为系列(stoch_k2,真的）；
  数组集为系列（stoch_d2，真的）；
  数组集为系列(stoch_k3,真的）；
  数组集为系列（stoch_d3，真的）；
  数组集为系列（rsi1，真的）；
  数组集为系列（rsi2，真的）；
  数组集为系列（rsi3，真的）；
  数组集为系列(macd_main1,真的）；
  数组集为系列(macd_sig1,真的）；
  数组集为系列(macd_main2,真的）；
  数组集为系列(macd_sig2,真的）；
  数组集为系列(macd_main3,真的）；
  数组集为系列(macd_sig3,真的）；
   
  // 复制数据 - 复制足够的柱  整数复制条数 = 限制 +50;
   
  整数复制=0;
   复制=复制缓冲区(handle_stoch_tf1,0,0、bars_to_copy、stoch_k1);
  如果（复制<=0）{打印（“错误：无法复制 stoch_k1，代码：”,获取最后一个错误());返回（先前计算）； }
   
  如果（复制缓冲区(handle_stoch_tf1,1,0, 复制条数, stoch_d1) <=0）{打印（“错误：无法复制 stoch_d1”）；返回（先前计算）； }
  如果（复制缓冲区(handle_stoch_tf2,0,0、bars_to_copy、stoch_k2) <=0）{打印（“错误：无法复制 stoch_k2”）；返回（先前计算）； }
  如果（复制缓冲区(handle_stoch_tf2,1,0, 复制条数, stoch_d2) <=0）{打印（“错误：无法复制stoch_d2”）；返回（先前计算）； }
  如果（复制缓冲区(handle_stoch_tf3,0,0、bars_to_copy、stoch_k3) <=0）{打印（“错误：无法复制 stoch_k3”）；返回（先前计算）； }
  如果（复制缓冲区(handle_stoch_tf3,1,0、bars_to_copy、stoch_d3) <=0）{打印（“错误：无法复制 stoch_d3”）；返回（先前计算）； }
   
  如果（复制缓冲区(handle_rsi_tf1,0,0, 复制条数, rsi1) <=0）{打印（“错误：复制 rsi1 失败”）；返回（先前计算）； }
  如果（复制缓冲区(handle_rsi_tf2,0,0, 复制条数, rsi2) <=0）{打印（“错误：复制 rsi2 失败”）；返回（先前计算）； }
  如果（复制缓冲区(handle_rsi_tf3,0,0, 复制条数, rsi3) <=0）{打印（“错误：复制 rsi3 失败”）；返回（先前计算）； }
   
  如果（复制缓冲区(handle_macd_tf1,0,0、bars_to_copy、macd_main1) <=0）{打印（“错误：无法复制 macd_main1”）；返回（先前计算）； }
  如果（复制缓冲区(handle_macd_tf1,1,0、bars_to_copy、macd_sig1) <=0）{打印（“错误：无法复制 macd_sig1”）；返回（先前计算）； }
  如果（复制缓冲区(handle_macd_tf2,0,0、bars_to_copy、macd_main2) <=0）{打印（“错误：无法复制 macd_main2”）；返回（先前计算）； }
  如果（复制缓冲区(handle_macd_tf2,1,0、bars_to_copy、macd_sig2) <=0）{打印（“错误：无法复制 macd_sig2”）；返回（先前计算）； }
  如果（复制缓冲区(handle_macd_tf3,0,0、bars_to_copy、macd_main3) <=0）{打印（“错误：无法复制 macd_main3”）；返回（先前计算）； }
  如果（复制缓冲区(handle_macd_tf3,1,0、bars_to_copy、macd_sig3) <=0）{打印（“错误：无法复制 macd_sig3”）；返回（先前计算）； }
   
  打印（“调试：已复制”, 复制,“酒吧，限制=”， 限制，“rates_total=”, rates_total);
   
  // 计算索引 - 现在 i=0 是最近的柱  整数计算=0;
  为了（整数我=0;我<限制；我++）
   {
      // 数组访问的安全检查      如果（我 >=数组大小(stoch_k1) ||我 >=数组大小(stoch_k2) ||我 >=数组大小(stoch_k3))
      {
        打印（“调试：跳过 i=”， 我，“-stoch 数组太小”）；
        继续;
      }
      如果（我 >=数组大小(rsi1) ||我 >=数组大小(rsi2) ||我 >=数组大小(RSI3))
      {
        打印（“调试：跳过 i=”， 我，“ - rsi 数组太小”）；
        继续;
      }
      如果（我 >=数组大小(macd_main1) ||我 >=数组大小(macd_main2) ||我 >=数组大小(macd_main3))
      {
        打印（“调试：跳过 i=”， 我，“ - MACD 数组太小”）；
        继续;
      }
      
      双倍的分数=0.0;
      
      //=== 随机 ===      // TF1      如果(stoch_k1[i] > stoch_d1[i])
         分数+=11.0;
      别的         分数-=11.0;
      
      // TF2      如果(stoch_k2[i] > stoch_d2[i])
         分数+=17.0;
      别的         分数-=17.0;
      
      // TF3      如果(stoch_k3[i] > stoch_d3[i])
         分数+=17.0;
      别的         分数-=17.0;
      
      //=== RSI ===      // TF1      如果(rsi1[i] >50）
         分数+=7.0;
      别的         分数-=7.0;
      
      // TF2      如果(rsi2[i] >50）
         分数+=11.0;
      别的         分数-=11.0;
      
      // TF3      如果(rsi3[i] >50）
         分数+=11.0;
      别的         分数-=11.0;
      
      //=== MACD ===      // TF1      如果(macd_main1[i] > macd_sig1[i])
         分数+=6.0;
      别的         分数-=6.0;
      
      // TF2      如果(macd_main2[i] > macd_sig2[i])
         分数+=10.0;
      别的         分数-=10.0;
      
      // TF3      如果(macd_main3[i] > macd_sig3[i])
         分数+=10.0;
      别的         分数-=10.0;
      
      // Stockage - i=0 是当前柱      IndexBuffer[i] = 分数；
      计算++；
      
      如果（我 <3）  // 调试 3 个首映栏      {
        打印（“调试：栏[”， 我，”]得分=“， 分数，“斯托赫1=”, stoch_k1[i],“ rsi1 =”, rsi1[i],“macd1=”, macd_main1[i]);
      }
      
      // 彩色区域      如果（分数>50）
      {
         看涨区域顶部[i] =100;
         BullishZoneBottom[i] =50;
      }
      别的      {
         看涨区域顶部[i] =空_VALUE;
         BullishZoneBottom[i] =空_VALUE;
      }
      
      如果（分数 < -50）
      {
         BearishZoneTop[i] = -50;
         BearishZoneBottom[i] = -100;
      }
      别的      {
         BearishZoneTop[i] =空_VALUE;
         BearishZoneBottom[i] =空_VALUE;
      }
   }
   
  打印（“调试：计算”, 计算出,“酒吧出来”， 限制）;
   
  // 第一次计算时的调试信息  如果（先前计算的==0）
   {
      细绳信息=字符串格式（“计算完成|当前索引：%.1f”, 索引缓冲区[0]);
      打印（信息）;
      评论（信息）;
   }
   
  返回（费率_总计）；
}//+------------------------------------------------------------------+

附件下载

📎 MTF_NN.mq5 (27.81 KB)

Source: MQL5 #66295