变体 2. 两条线: 快速和慢速。快速线高于慢速线 — 上行趋势, 快速低于慢速 — 下行趋势。需要两套相同的标准参数。 

参数: 

1. int ama_period1 — AMA 周期; 
2. int fast_ma_period1 — 快速均线周期;
3. int slow_ma_period1 — 慢速均线周期; 
4. int ama_shift1 — 指标的水平位移; 
5. ENUM_APPLIED_PRICE  applied_price1 — 价格类型;
6. int ama_period2 — AMA 周期; 
7. int fast_ma_period2 — 快速均线周期;
8. int slow_ma_period2 — 慢速均线周期; 
9. int ama_shift2 — 指标的水平位移; 
10. ENUM_APPLIED_PRICE  applied_price2 — 价格类型。

变体 2. 两条线: 快速和慢速。

参数: 

1. int ma_period1 — 均化周期;
2. ENUM_APPLIED_PRICE  applied_price1 — 价格类型;
3. int ma_shift1 — 指标的水平位移; 
4. int ma_period2 — 均化周期;
5. ENUM_APPLIED_PRICE  applied_price2 — 价格类型;
6. int ma_shift2 — 指标的水平位移。

变体 2. 两条线: 快速和慢速。

1. int ma_period1 — 均化周期; 
2. int ma_shift1 — 指标的水平位移; 
3. ENUM_APPLIED_PRICE  applied_price1 — 价格类型;
4. int ma_period2 — 均化周期; 
5. int ma_shift2 — 指标的水平位移; 
6. ENUM_APPLIED_PRICE  applied_price2 — 价格类型。

参数: 

1. int tenkan_sen — Tenkan-sen 线周期; 
2. int kijun_sen — Kijun-sen 线周期; 
3. int senkou_span_b — Senkou Span B 周期。  

1. int ma_period — 均化周期; 
2. int ma_shift — 指标的水平位移; 
3. ENUM_MA_METHOD ma_method — 平滑类型; 
4. ENUM_APPLIED_PRICE applied_price — 价格类型;
5. int shift2 — 相对于所检查坡度点的位移。

变体 2. 两条线: 快速和慢速。

参数: 

1. int ma_period1 — 均化周期; 
2. int ma_shift1 — 指标的水平位移; 
3. ENUM_MA_METHOD ma_method1 — 平滑类型; 
4. ENUM_APPLIED_PRICE applied_price1 — 价格类型;
5. int ma_period2 — 均化周期; 
6. int ma_shift2 — 指标的水平位移; 
7. ENUM_MA_METHOD ma_method2 — 平滑类型; 
8. ENUM_APPLIED_PRICE applied_price2 — 价格类型。

变体 2. 主线和信号线。

参数:

1. int ma_period — 均化周期。.  

1. int ma_period — 均化周期; 
2. int ma_shift — 指标的水平位移; 
3. ENUM_APPLIED_PRICE applied_price — 价格类型;
4. int shift2 — 相对于所检查坡度点的位移。

变体 2. 两条线: 快速和慢速。

参数: 

1. int ma_period1 — 均化周期; 
2. int ma_shift1 — 指标的水平位移; 
3. ENUM_APPLIED_PRICE applied_price1 — 价格类型;
4. int ma_period2 — 均化周期; 
5. int ma_shift2 — 指标的水平位移; 
6. ENUM_APPLIED_PRICE applied_price2 — 价格类型。

1. int ma_period — 均化周期; 
2. int ma_shift — 指标的水平位移; 
3. ENUM_APPLIED_PRICE applied_price — 价格类型;
4. int shift2 — 相对于所检查坡度点的位移。

变体 2. 两条线: 快速和慢速。

参数: 

1. int ma_period1 — 均化周期; 
2. int ma_shift1 — 指标的水平位移; 
3. ENUM_APPLIED_PRICE applied_price1 — 价格类型;
4. int ma_period2 — 均化周期; 
5. int ma_shift2 — 指标的水平位移; 
6. ENUM_APPLIED_PRICE applied_price2 — 价格类型。

参数: 

1. int ma_period1 — 均化周期; 
2. int ma_shift1 — 指标的水平位移; 
3. ENUM_APPLIED_PRICE applied_price1 — 价格类型;
4. int ma_period2 — 均化周期; 
5. int ma_shift2 — 指标的水平位移; 
6. ENUM_APPLIED_PRICE applied_price2 — 价格类型。

我们已定义了指标及其应用变体。现在我们来编写一个所有类型的枚举。在 Includes 文件夹里, 我们创建 UniTrend 文件夹, 并创建内含枚举的 UniTrendDefines.mqh 文件: 

enum EType{
   Type_ADX_PDIMDI,          // ADX 指标 PDI 和 MDI 线的位置
   Type_ADX_Level,           // 相对于级别的 ADX 线位置
   Type_ADXW_PDIMDI,         // ADX Wilder 指标 PDI 和 MDI 线的位置
   Type_ADXW_Level,          // 相对于 ADX Wilder 级别的 ADX 线位置
   Type_Alligator,           // 鳄鱼
   Type_AMA_Dir,             // АМА  的方向
   Type_AMA_2MA,             // 两个 АМА
   Type_ATR_Level,           // ATR
   Type_BuBe_Level,          // 牛/熊动力及级别
   Type_BuBe_Dir,            // 牛/熊动力的方向
   Type_Bands,               // 布林带
   Type_CCI_Level,           // CCI 和级别
   Type_Chaikin_Level,       // Chaikin 振荡器和级别
   Type_DEMA_Dir,            // DEMA 的方向
   Type_DEMA_2MA,            // 两个 DEMA
   Type_DeMarker_Level,      // DeMarker 和级别
   Type_Envelopes,           // 包络
   Type_Force_Level,         // 强推振荡器和级别
   Type_Fractals,            // 分形
   Type_FrAMA_Dir,           // FrAMA 的方向
   Type_FrAMA_2MA,           // 两个 FrAMA
   Type_Ichimoku_TK,         // Ichimoku: Tenkan 和 Kijun
   Type_Ichimoku_SASB,       // Ichimoku: 云图
   Type_Momentum_Level,      // 动量和级别
   Type_MFI_Level,           // MFI 和级别
   Type_MA_Dir,              // MA 的方向
   Type_MA_2MA,              // 两个 MA
   Type_OsMA_Dir,            // OsMA 的方向
   Type_OsMA_Level,          // OsMA 和级别
   Type_MACD_Dir,            // MACD 的方向
   Type_MACD_Level,          // MACD 和级别
   Type_SAR,                 // SAR
   Type_RSI_Level,           // RSI 和级别
   Type_RVI_Level,           // RVI 和级别
   Type_RVI_MS,              // RVI 的主线和信号线
   Type_STD_Level,           // 标准偏差和级别
   Type_Sto_Dir,             // 随机振荡器的方向
   Type_Sto_Level,           // 随机振荡器和级别
   Type_Sto_MS,              // 随机振荡器的主线和信号线
   Type_TEMA_Dir,            // TEMA 的方向
   Type_TEMA_2MA,            // 两个 TEMA
   Type_TriX_Dir,            // TriX 的方向
   Type_TriX_2MA,            // 两个 TriX
   Type_VIDyA_Dir,           // VIDyA 的方向
   Type_VIDyA_2MA,           // 两个 VIDyA
   Type_Volumes              // 交易量
            };

外部参数

通过分析上述指标说明, 我们可以确定所需的外部参数集。所有需要的参数及其类型在表 1 里给出。我们基本上会在变量里使用前缀 “f_” (其意为快速)。对于带有快速和慢移动均值的变体, 我们将在第二组参数里使用前缀 “s_” (其意为慢速)。

表 1. 外部参数和它们的类型  

除了在指标描述里指定的参数, 在表格底部还提供了少量额外参数: 

• mult — 参数的倍数取决于报价中的小数位数。诸如 MACD 和 OsMA 等一些指标的数值与价格挂钩, 因此将它们设为点数更为便捷。参数值需要根据报价中的小数位数进行调整。
• level_digits — level 参数中的小数位数。在图形界面中, 使用 CSpinBox 控件 (带有 “+” 和 “-” 按钮的输入字段) 设置级别值, 因此, 它可以很轻松地为不同的指标设置不同的最小变化 (当按 “+” 或 “-” 时的变化量)。
• sar_step_digits — SAR 指标 step 参数的小数位数。
• sar_maximum_digits — SAR 指标 maximum 参数的小数位数。

#define ADX_LEVEL_DIGITS         0 // 用于 ADX 指标
#define ADXW_LEVEL_DIGITS        0 // 用于 ADX Wilder 指标
#define ATR_LEVEL_DIGITS         1 // 用于 ATR 指标
#define BUBE_LEVELS_DIGITS       1 // 用于牛/熊动力指标
#define CCI_LEVEL_DIGITS         0 // 用于 CCI 指标
#define CHAIKIN_LEVEL_DIGITS     0 // 用于 Chaikin 指标
#define DEMARKER_LEVEL_DIGITS    2 // 用于 Demarker 指标 
#define FORCE_LEVEL_DIGITS       3 // 用于强推指标
#define MOMENTUM_LEVEL_DIGITS    2 // 用于动量指标
#define MFI_LEVEL_DIGITS         0 // 用于 MFI 指标
#define OSMA_LEVBEL_DIGITS       2 // 用于 OsMA 指标
#define MACD_LEVEL_DIGITS        2 // 用于 MACD 指标
#define RSI_LEVEL_DIGITS         0 // 用于 RSI 指标
#define RVI_LEVEL_DIGITS         2 // 用于 RVI 指标
#define STD_LEVEL_DIGITS         1 // 用于 STD 指标
#define STO_LEVEL_DIGITS         0 // 用于随机振荡器指标
#define BANDS_LEVEL_DIGITS       1 // 用于布林带
#define ENVELOPES_LEVEL_DIGITS   2 // 用于包络指标
#define SAR_STEP_DIGITS          3 // 用于 SAR 指标 (step 参数)
      #define SAR_MAXIMUM_DIGITS       2 // 用于 SAR 指标 (maximum 参数)

我们来根据表 1 创建以下结构:

struct SExtParams{
   int                 f_period1;
   int                 f_shift1;
   int                 f_period2;
   int                 f_shift2;
   int                 f_period3;
   int                 f_shift3;
   long                f_method;
   long                f_price;
   long                f_volume;
   long                f_sto_price;
   double              f_level;
   int                 f_dot2shift;
   double              f_step;  
   double              f_maximum;  
   int                 s_period1;
   int                 s_shift1;
   int                 s_period2;
   int                 s_shift2;
   int                 s_period3;
   int                 s_shift3;
   long                s_method;
   long                s_price;
   int                 mult;
   int                 level_digits;
   int                 sar_step_digits;
   int                 sar_maximum_digits;      
            };

将参数组合到一个结构中可令我们将它们与其余的代码隔离开来。若是可用的选项不够, 我们需要通过添加新的趋势检测类型来修改指标, 这会非常便利。此外, 这大大简化了函数和类方法的参数传递。

由于本文中生成的指标将趋势显示为一排字符 (对于所有指标都是相同的), 我们可以轻松地向指标中添加函数来通知趋势开始。有人可能会对通知一个完全形成的趋势 (示意在一根完整的柱线上) 感兴趣, 而有人想第一时间抓住新趋势出现 (在新出现的柱线上)。所以, 我们将编写用于选择通知类型的枚举:

enum EAlerts{
   Alerts_off=0, // 禁用通知
   Alerts_Bar0=1, // 新出现柱线上通知
   Alerts_Bar1=2 // 完整柱线上通知
            };  

创建一款指标

在文章 “带有图形界面的通用振荡器” 和 “带有图形界面的通用通道” 中详细讨论了如何创建通用指标的类。我们来研究为它们创建与本文有关的具体功能。

所有上述判断趋势的方法分为两类: 一个或两个指标。在第一组中, 加载指标后, 我们需要检查一个句柄, 而第二组我们要检查其中两个。这意味着基类将有两个子类用不同的方法来检查句柄。反过来, 这些子类还会有自己的子类, 并在其中判断趋势。

基类:

class CUniTrend{
   protected:
  
      int m_handle1;
      int m_handle2;
      
      string m_name;
      string m_help;
      
      int m_ci;
      
      double m_b1[1];
      double m_b2[1];      
      double m_b3[1];    
      double m_b4[1];
            
      int m_shift;
      int m_shift1;    
      int m_shift2;
      int m_shift3;
      
      int m_dot2shift;
      
      double m_level;      
      
   public:
  
      void CUniTrend(){
         m_handle1=INVALID_HANDLE;
         m_handle2=INVALID_HANDLE;
      }
      
      void ~CUniTrend(){
         if(m_handle1!=INVALID_HANDLE){
            IndicatorRelease(m_handle1);
         }
         if(m_handle2!=INVALID_HANDLE){
            IndicatorRelease(m_handle2);
         }        
      }
  
      virtual int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & upBuffer[],
                     double & dnBuffer[]
      ){
         return(rates_total);
      }
      
      virtual bool Calculated(){
         return(false);
      }
      
      virtual bool CheckHandles(){
         return(true);
      }      
      
      string Name(){
         return(m_name);
      }    
      string Help(){
         return(m_help);
      }
            };

保护部分包含各种辅助变量的声明, 这在子类中是有用的。指标句柄的变量在构造函数中初始化, 在析构函数中释放句柄。其余的方法是虚构的。

含有一个指标的子类变体:

class CUniTrend1:public CUniTrend{
   public:
      bool Calculated(){
         if(BarsCalculated(m_handle1)>0){
            return(true);
         }  
         else{
            return(false);
         }    
      }
      
      bool CheckHandles(){
         return(m_handle1!=INVALID_HANDLE);
      }
            };

该类有两个实际的方法: CheckHandle() — 它可以检查指标是否可以加载, Calculated() — 可以确定指标是否计算完整, 以及趋势缓冲区的显示内容是否已更新。

含有两个指标的子类变体:

class CUniTrend2:public CUniTrend{
   public:
      bool Calculated(){
         if(BarsCalculated(m_handle1)>0 && BarsCalculated(m_handle2)>0){
            return(true);
         }  
         else{
            return(false);
         }    
      }      
      
      bool CheckHandles(){
         return(m_handle1!=INVALID_HANDLE && m_handle2!=INVALID_HANDLE);
      }
            };

含有不同趋势识别变体的类都将是 CUniTrend1 或 CUniTrend2 的子类。研究下面的子类:

class CUniTrend_ADX_PDIMDI:public CUniTrend1{
   private:  
   public:
  
      void CUniTrend_ADX_PDIMDI( bool use_default,
                                 bool keep_previous,
                                 SExtParams & par){
        
         // 设置省缺参数
        
         if(use_default){
            if(keep_previous){
               if(par.f_period1==PARAMETER_EMPTY)par.f_period1=14;
            }
            else{
               par.f_period1=14;
            }      
         }          
         // 加载指标
         m_handle1=iADX(Symbol(),Period(),par.f_period1);
         // 形成指标名和参数提示
         m_name=StringFormat( "iADX_PDIMDI(%i)",
                              par.f_period1
                            );
  
         m_help=StringFormat( "adx_period - f_period1(%i)",
                              par.f_period1
                            );
      }
      
      int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & upBuffer[],
                     double & dnBuffer[]
      ){
         int start;
        
         if(prev_calculated==0){
            start=1;
         }
         else{
            start=prev_calculated-1;
         }
      
         for(int i=start;i<rates_total;i++){
        
            upBuffer[i]=EMPTY_VALUE;        
            dnBuffer[i]=EMPTY_VALUE;
        
            m_ci=rates_total-i-1;
            
            if(CopyBuffer(m_handle1,PLUSDI_LINE,m_ci,1,m_b1)==-1){
               return(0);
            }
            
            if(CopyBuffer(m_handle1,MINUSDI_LINE,m_ci,1,m_b2)==-1){
               return(0);
            }
            
            if(m_b1[0]>m_b2[0]){
               upBuffer[i]=1;
            }
            else if(m_b1[0]<m_b2[0]){
               dnBuffer[i]=-1;            
            }
            
         }      
      
         return(rates_total);
      }
            };

类的构造函数中的主要重点已被注释, Calculate() 方法是指标标准 OnCalculate() 函数的模拟。函数代码与指标代码类似。

在本文附件中, 文件中的所有指标类都位于 Include/UniTrend/UniTrendIndicators.mqh 中。

现在, 所有的类我们都已准备就绪, 我们可以创建一个简单的指标来判断趋势, 就像我们在有关通用振荡器和通用通道的文章中所做的那样。在附件里的 Indicators/iUniTrend.mq5 文件中提供了一个不带图形界面的现成指标。

创建图形界面

图形界面的所有类位于文件 UniTrendForm.mqh 和 UniTrendControl.mqh 中。表单类在 UniTrendForm.mqh 文件里提供, 而 UniTrendControl.mqh 文件包含用于输入指标参数的通用控件类。无须详细讨论表单类的创建, 因为它已在有关通用振荡器和通用通道的文章中研究过了。在文章 “自定义图形控件。第 3 部分: 表单” 里也有详尽研究。我们来研究创造一个通用的控件。

通用控件的基础是 CUniTrendControl 基础类。该类的公有部分仅包含虚构方法, 保护部分包含一些用于下拉列表的辅助方法: 用于使用变体填充列表的方法, 以及用于设置列表中所选项目的方法。此处是带注释的基类代码:

class CUniTrendControl{
   protected:
      
      /* 用于计算最小值变化的函数
         通过 level 参数的小数位数
      */
      double SolveChange(int d){
         return(NormalizeDouble(1.0/pow(10,d),d));  
      }
      
      // 用 ENUM_MA_METHOD 变体填充列表
      void AddVariantsMethod(CComBox & cb){
         for(int i=0;i<ArraySize(e_method);i++){
            cb.AddItem(EnumToString((ENUM_MA_METHOD)e_method[i]));
         }
      }
      
      // 用 ENUM_APPLIED_PRICE 变体填充列表
      void AddVariantsPrice(CComBox & cb){
         for(int i=0;i<ArraySize(e_price);i++){
            cb.AddItem(EnumToString((ENUM_APPLIED_PRICE)e_price[i]));
         }
      }      
      
      // 用 ENUM_APPLIED_VOLUME 变体填充列表
      void AddVariantsVolume(CComBox & cb){
         for(int i=0;i<ArraySize(e_volume);i++){
            cb.AddItem(EnumToString((ENUM_APPLIED_VOLUME)e_volume[i]));
         }
      }  
      
      // 用 ENUM_STO_PRICE 变体填充列表     
      void AddVariantsStoPrice(CComBox & cb){
         for(int i=0;i<ArraySize(e_sto_price);i++){
            cb.AddItem(EnumToString((ENUM_STO_PRICE)e_sto_price[i]));
         }
      }      
      
      // 获取 ENUM_MA_METHOD 的索引值  
      int MethodIndex(long val){
         for(int i=ArraySize(e_method)-1;i>=0;i--){
            if(e_method[i]==val){
               return(i);
            }
         }
         return(-1);
      }
      
      // 获取 ENUM_APPLIED_PRICE 的索引值
      int PriceIndex(long val){
         for(int i=ArraySize(e_price)-1;i>=0;i--){
            if(e_price[i]==val){
               return(i);
            }
         }
         return(-1);
      }  
      
      // 获取 ENUM_APPLIED_VOLUME 的索引值   
      int VolumeIndex(long val){
         for(int i=ArraySize(e_volume)-1;i>=0;i--){
            if(e_volume[i]==val){
               return(i);
            }
         }
         return(-1);
      }  
      
      // 获取 ENUM_STO_PRICE 的索引值     
      int StoPriceIndex(long val){
         for(int i=ArraySize(e_sto_price)-1;i>=0;i--){
            if(e_sto_price[i]==val){
               return(i);
            }
         }
         return(-1);
      }      
      
   public:
      
      // 控件初始化
      virtual void Init(SExtParams & par){}
      
      // 设置数值
      virtual void SetValues(SExtParams & par){}      
      
      // 获取数值
      virtual void GetValues(SExtParams & par){}
      
      // 显示控件
      virtual void Show(int x,int y){}      
      
      // 隐藏控件
      virtual void Hide(){}      
      
      // 用于计算表单高度的控件数量
      virtual int ControlsCount(){
         return(0);
      }
      
      // 事件处理
      virtual int Event(int id,long lparam,double dparam,string sparam){
         return(0);
      }
      
};
    

我们来研究基于 ADX 和级别 (两个控件) 进行趋势检测的子类:

class CUniTrendControl_ADX_Level: public CUniTrendControl{
   private:
  
      // 简单控件的指针
      CSpinInputBox m_f_period1;
      CSpinInputBox m_f_level;
  
   public:
  
      // 控件初始化
      void Init(SExtParams & par){
         m_f_period1.Init("f_period1",SPIN_BOX_WIDTH,1," adx_period");
         m_f_period1.SetMinValue(1);
         m_f_period1.SetReadOnly(false);
         m_f_level.Init("f_level",COMBO_BOX_WIDTH,this.SolveChange(par.level_digits)," level");
         m_f_level.SetMinValue(0);
         m_f_level.SetReadOnly(false);
      }
  
      // 设置数值
      void SetValues(SExtParams & par){        
         m_f_period1.SetValue(par.f_period1);
         m_f_level.SetValue(par.f_level);
      }
  
      // 获取数值
      void GetValues(SExtParams & par){
         par.f_period1=(int)m_f_period1.Value();
         par.f_level=m_f_level.Value();
      }    
  
      // 显示控件
      void Show(int x,int y){
         m_f_period1.Show(x,y);
         y+=20;
         m_f_level.Show(x,y);
      }      
  
      // 隐藏控件
      void Hide(){
         m_f_period1.Hide();
         m_f_level.Hide();
      }
  
      // 用于计算表单高度的控件数量
      int ControlsCount(){
         return(2);
      }
  
      // 执行控件事件
      int Event(int id,long lparam,double dparam,string sparam){
         int e1=m_f_period1.Event(id,lparam,dparam,sparam);
         int e2=m_f_level.Event(id,lparam,dparam,sparam);
         if(e1!=0 || e2!=0){
            return(1);
         }
         return(0);
      }
};
    

传递一个 SExtParam 类型的变量到方法 SetValues() 和 GetValues(), 在每个子类中仅使用结构的必需字段。我们需要设置级别控件的最小变化值; 这可以在控件初始化期间完成, 因此带有参数的结构也传递给 Init() 方法。一般来说, 子类的创建对应于文章 “自定义图形控件。第 1 部分: 创建一个简单控件” 中描述的控件创建的所有原则, 期望在此仅创建必要的方法, 而非全部。 

图形界面与指标的结合

指标创建阶段与创建通用趋势/通道指标的相应阶段非常类似。我们来研究一下不同之处。

早先, 当指标以省缺值 ​​(UseDefault=true) 操作时, 所有参数初始化为 -1。现在这个选项不合时宜了, 因为某些指标的 level 参数可以是负数。因此, 采用在 UniTrendDefines.mqh 文件中声明的 PARAMETER_EMPTY 常量值来执行变量的初始化。常数的值为 INT_MAX (此值极大超过了实际值的限制)。

另一个小小区别是 OnTimer() 函数。调用 Calculated() 方法来检查指标是否已计算, 因为对于趋势的一些变体, 我们仅需检查一个指标, 而对于其它指标, 我们要检查两个指标。这只能在指标类的内部才知晓。

结果就是, 我们得到了另一款通用且十分方便的指标 (图例. 10)。

图例. 10. 带有图形界面的通用趋势指标

注意: 除了显示在表单内的列表中所选变体的名称之外, 所使用的指标类型也显示在指标子窗口的左上角。除了类型之外, 还显示所有参数的值 (括号中)。如果指定了级别点数值, 则写入用于计算实际级别值的表达式 (图例. 11)。

 
图例. 11. 显示指定参数的点数

现成的指标已在下面的附件中提供, 文件名为 Indicators/iUniTrendGUI.mq5。  

结论