指标和价格图表线到目前为止都是直线。。但这只是一个抽象, 与实际价格走势无关。因此, 我们来研究能用来定义价格和指标方向并检测背离的方法。那么我们将在实践中看看背离分类系统。

一般来说, 我们首先需要识别图表上的价格或是顶部和底部, 然后比较它们的价值。看涨背离 (买入信号) 由底部检测: 如果一个底部高于前一个底部, 然后指标指向上升, 反之亦然。看跌背离则检测顶部 (卖出信号)。    

在图表上有三种检测极值点的方法。

1. 利用柱线。
2. 利用自最后一个高/低价位的阈值超越。
3. 最大/最小值要高于/低于指标中线。 

利用柱线检测顶部/底部。我们利用一定数量的顶部/底部柱线。例如, 如果参数为 2, 则顶部柱线上的指标值应该超过左、右侧的两根柱线。有鉴于此, 底部的值应该低于相邻柱线的值 (图例. 6)。

图例. 6。用两根柱线定义顶部和底部。左向顶部定义。有箭头标记的柱线, 它成为已知的
由对勾标记示出的顶部。右向底部定义

左向和右向的顶部/底部所需的柱线数量可能有所不同: 例如, 左向 5 和右向 2 (图例. 7)。

图例. 7。顶部由左边的五根柱线和右边的两根柱线定义 

利用阈值定义顶部/底部。当指标上升, 系统跟踪其最大值。在没有新极值的柱线上, 当前值与前一个固定的顶部/底部相比较。如果差值超过外部参数设定的阀值, 则假设指标已改变了方向, 而该根已到达最大值/最小值的柱线可看作顶部/底部 (图例. 8)。

图例. 8。利用阈值定义顶部和底部。阀值 显示 在左上角。
直至柱线 2, 柱线上升, 最大值固定在柱线 2, 而在柱线 5, 数值
已降至阀值, 此即意味着指标改变了其方向。在柱线 6, 指标
再次超越阀值并改变方向。

利用柱线定义是最方便的, 因为它不依赖于指标。与之对比, 阈值则要取决于指标类型。例如, 对于振荡范围 0-100 的 RSI, 阀值可为 5。对于 Momentum, 阀值为 0.1-1, 因为指标在 100 附近略微波动。此外, 这些波动的大小取决于时间帧。这些进一步使阈值的使用复杂化。

最大值/最小值要高于/低于指标中线。此方法比其它方法使用频率更低。它也取决于所应用的指标, 因为并非所有指标的平均值都为 0 (例如, RSI 的平均值为 50)。但其主要缺点是过于滞后 (图例. 9)。 

图例. 9。利用中线穿越定义顶部和底部。只有中线在柱线 2 上穿越之后
我们才会确认顶部 1。在柱线 4 穿越后
我们才会确认底部 3

背离分类系统

您可以在网上找到很多有关背离的文章。它们以各种方法描述了不同的术语, 以及将背离和趋合系统化的原则。您可以找到简单, 经典, 隐藏和扩展背离。有些人, 以及作者本人将其分成 A, B 和 C 类。我们不会在本文中分析主要来源。代之, 我们来通览一些已辨识的类型。

经典背离. 这种类型已经在上面描述过并在图例. 5 中示出。

隐藏背离. 隐藏背离与经典的不同之处在于价格变动和指标变动的方向。换言之, 隐含背离与趋合相似。

扩展背离. 到目前为止, 我们只讨论了价格和指标的上升、下降运动。如果我们加上横向运动, 则选项数量增加。尽管我们可以通过组合三个价格走向和三个指标走向来获得多种选择, 但仅提出了一个版本的扩展背离:

• 横向价格走势, 指标向下移动 — 延伸看跌背离 (卖出信号)
• 横向价格走势, 指标上升移动 — 延伸看涨背离 (买入信号)。

• 横向价格走势, 指标向下移动 — 看跌 (卖出信号)。
• 横向价格走势, 指标上升移动 — 看涨 (买入信号)。

• 价格上升, 指标顶部处于一个等级 — 看跌 (卖出信号)。
• 价格下降, 指标底部处于一个等级 — 看涨 (买入信号)。

我们可以看到, B 和 С 类是扩展背离的方法。B 类完全重复上述定义。

在浏览有关背离的材料时, 我得出的主要结论是缺乏清晰的术语, 有的版本可能覆盖不完整。因此, 我们将分析各种价格和指标走向组合的选项, 并对其进行系统化。

价格和指标走向的完整系统化

首先, 我们定义两个可能的价格和指标走向。

1. 两个运动方向: 上升和下降。 
2. 三个运动方向: 上升, 下降, 横向。

第一种情况只提供四种可能的组合。以卖出信号为例, 我们来看看。

1. 价升, 指标升。 
2. 价升, 指标降 (背离)。
3. 价降, 指标升 (趋合)。
4. 价降, 指标降。  

1. 价升, 指标升。
2. 价升, 指标横。
3. 价升, 指标降 (背离)。
4. 价横, 指标升。
5. 价横, 指标横。
6. 价横, 指标降。
7. 价降, 指标升 (趋合)。
8. 价降, 指标横。
9. 价降, 指标降。

所有这些组合都显示在图例. 11 中。

图例. 11。在三个可用方向的情况下, 价格和指标变动的所有可能组合 

如果您创建一款可以选择任意已研究选项的指标, 之后选择您认为是正确的背离, 趋合, 隐藏或扩展背离。换言之, 我们得到一款通用的指标, 即便对于不认同系统化和本文中所做定义的那些人也是有用的。

在这种情况下, 更正确的说法是走势而非方向。在图例. 12 中显示了有三个顶部的走势类型。

这些结构的两个数组将用于存储关于所有顶部和底部的数据。它们将成为基类的成员。

用于定义极值的类位于 UniDiver/CUniDiverExtremums.mqh 文件中, 基类名称为 CDiverBase。现在, 我们来研究只有基本方法的类结构。其余的将在必要时添加。

class CDiverBase{
   protected: 
      
      SExtremum m_upper[];
      SExtremum m_lower[];

      void AddExtremum( SExtremum & a[],
                        int & cnt,
                        double iv,
                        double pv,
                        int mb,
                        int sb,
                        datetime et);
   
      void CheckDiver(  int i,
                        int ucnt,
                        int lcnt,
                        const datetime & time[],
                        const double &high[],
                        const double &low[],                     
                        double & buy[],
                        double & sell[],
                        double & osc[]
      );

   public:
      virtual void Calculate( const int rates_total,
                              const int prev_calculated,
                              const datetime &time[],
                              const double &high[],
                              const double &low[],
                              double & osc[],
                              double & buy[],     
                              double & sell[]
      );
}; 

Calculate() 虚方法允许您选择极限值定义选项。AddExtremum() 和 CheckDiver() 方法位于 ‘protected’ 部分 — 它们会从派生类的 Calculate() 方法中调用。AddExtremum() 方法收集有关顶部和底部的数据到 m_upper[] 和 m_lower[] 数组。CheckDiver() 方法检查是否满足背离条件并设置指示箭头。下面我们更详细地研究所有这些方法, 但是现在让我们熟悉派生类的其它定义极值的方法。

利用柱线定义极值。利用柱线定义极限值的类:

class CDiverBars:public CDiverBase{
   private:   
   
      SPseudoBuffers1 Cur;
      SPseudoBuffers1 Pre;  
           
      int m_left,m_right,m_start,m_period;   
   
   public:
         
      void CDiverBars(int Left,int Right);
   
      void Calculate( const int rates_total,
                      const int prev_calculated,
                      const datetime &time[],
                      const double &high[],
                      const double &low[],
                      double & osc[],
                      double & buy[],
                      double & sell[]
      );
}; 

用于定义极值的参数 (LeftBars 和 RightBars 外部变量) 传递给类构造函数, 如果需要, 它们的值将会被验证和修改, 并计算其它参数:

void CDiverBars(int Left,int Right){
   m_left=Left;
   m_right=Right;   
   if(m_left<1)m_left=m_right;   // Left 参数未设置
   if(m_right<1)m_right=m_left;  // Right 参数未设置
   if(m_left<1 && m_right<1){    // 两个参数均未设置
      m_left=2;
      m_right=2;
   }
   m_start=m_left+m_right;       // 平移间隔起始点
   m_period=m_start+1;           // 间隔柱线数
}

首先验证参数值。如果其中某些非正数 (未设置), 则会分配第二个参数的值。如果是单个参数未设置, 则会为它们分配默认值 (2)。此后计算用于搜索极值 (m_start) 的初始柱线缩进和极值柱线总数 (m_period)。

Calculate() 方法与标准的 OnCalculate() 函数相同, 但它只接收所需的价格数组, 而非全部: time[], high[], low[] 和 osc[] 指标缓冲区 (振荡器数据), buy[] 和 sell[] (箭头)。如同以往, 已计算的柱线范围在 OnCalculte() 函数中定义。指标极值 (ArrayMaximum() 和 ArrayMinimum() 函数) 在标准指标循环之后定义。在检测到极点后, 调用 AddExtremum() 方法将数据添加到 m_upper[ ]或 m_lower[] 数组中。最后, 调用 CheckDiver() 方法来分析含有极值的数组数据。如果检测到背离, 则放置箭头。

void Calculate( const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &high[],
                const double &low[],
                double & osc[],
                double & buy[],
                double & sell[]
){

   int start; // 初始索引变量
   
   if(prev_calculated==0){ // 完全指标计算
      start=m_period; // 定义初始计算柱线 
      m_LastTime=0;   // 为了定义新柱线而重置变量 
      Cur.Reset();    // 重置辅助结构
      Pre.Reset();    // 重置辅助结构
   }
   else{ // 仅当新柱线计算
      start=prev_calculated-1; // 计算柱线索引, 从而恢复计算
   }

   for(int i=start;i<rates_total;i++){ // 指标主要循环
      
      if(time[i]>m_LastTime){ // 新柱线
         m_LastTime=time[i];
         Pre=Cur;
      }
      else{ // 重计算相同柱线
         Cur=Pre;
      }
      
      // 计算最高/最低搜索参数 
      int sb=i-m_start; // 柱线索引, 间隔从此处开始
      int mb=i-m_right; // 最高/最低柱线的索引  
      
      if(ArrayMaximum(osc,sb,m_period)==mb){ // 这是顶部
         // 将顶部加入数组
         this.AddExtremum(m_upper,Cur.UpperCnt,osc[mb],high[mb],mb,i,time[mb]);
      }
      if(ArrayMinimum(osc,sb,m_period)==mb){ // 这是底部
         // 将底部加入数组
         this.AddExtremum(m_lower,Cur.LowerCnt,osc[mb],low[mb],mb,i,time[mb]);
      }
      
      // 检查背离
      this.CheckDiver(i,Cur.UpperCnt,Cur.LowerCnt,time,high,low,buy,sell,osc);
   } 
}

我们来详细研究这段代码。在指标循环的开始:

if(time[i]>m_LastTime){ // 新柱线
   m_LastTime=time[i];
   Pre=Cur;
}
else{ // 重计算相同柱线
   Cur=Pre;
}

m_LastTime 变量已在基类中声明。如果 time[i] 柱线的时间超过变量, 则为首次计算柱线。将柱线时间分配给 m_LastTime 变量, 而将 Cur 变量值分配给 Pre 变量。相反, 当重新计算相同的柱线时, 将 Pre 变量分配给 Cur。在 这篇文章 中详细讨论了使用 Cur 和 Pre 变量。 Pre 和 Cur 变量是 UniDiverDefines 文件中描述的SPseudoBuffers1 类型:

struct SPseudoBuffers1{
   int UpperCnt;
   int LowerCnt;
   void Reset(){
      UpperCnt=0;
      LowerCnt=0;  
   }   
};

结构包含两个字段:

• UpperCount — 使用的 m_upper[] 数组元素数量;
• LowerCount — 使用的 m_lower[] 数组元素数量;

为了快速重置所有结构字段, 创建了 Reset() 方法。

在使用了 Cur 和 Pre 变量后, 计算搜索极值的柱线索引:

// 计算搜索最高/最低值的参数 
int sb=i-m_start; // 柱线索引, 间隔从此处开始
int mb=i-m_right; // 顶部/底部的柱线索引 

将搜索最高/最低开始的柱线索引分配给 “sb” 变量。将最高/最低值的柱线索引分配给 ‘mb’ 变量。

使用 ArrayMaximum() 和 ArrayMinimum() 函数定义顶部或底部:

if(ArrayMaximum(osc,sb,m_period)==mb){ // 这是顶部
   // 加入到数组
   this.AddExtremum(m_upper,Cur.UpperCnt,osc[mb],high[mb],mb,i,time[mb]);
}
if(ArrayMinimum(osc,sb,m_period)==mb){ // 这是底部
   // 加入到数组
   this.AddExtremum(m_lower,Cur.LowerCnt,osc[mb],low[mb],mb,i,time[mb]);
}

如果 ArrayMaximum() 或 ArrayMinimum() 函数返回 ‘mb’, 这意味着指定数量的柱线位于顶部/底部的左侧和右侧。反过来, 这表明所需的顶部/底部已经形成。调用 AddExtremum() 方法, 并将数据添加到 m_upper[] 或 m_lower[] 数组中。

我们来看一下简单的 AddExtremum() 方法:

void AddExtremum( SExtremum & a[], // 数据将要加入的数组
                  int & cnt,       // 已占用的数组元素数量
                  double iv,       // 指标值
                  double pv,       // 价格 
                  int mb,          // 极值所在柱线的索引
                  int sb,          // 确认极值的柱线索引
                  datetime et      // 极值所在柱线的时间
){
   if(cnt>=ArraySize(a)){ // 数组已填充
      // 增加数组尺寸
      ArrayResize(a,ArraySize(a)+1024);
   }
   // 加入新数据
   a[cnt].IndicatorValue=iv; // 指标值
   a[cnt].PriceValue=pv;     // 价格值
   a[cnt].ExtremumBar=mb;    // 极值所在柱线的索引
   a[cnt].SignalBar=sb;      // 确认极值的柱线索引 
   a[cnt].ExtremumTime=et;   // 极值柱线的时间
   cnt++;                    // 增加已占用的数组元素数量
}

要添加新数据的 a[] 数组, 通过参数传递给方法。可以是 m_upper[] 或 m_lower[] 数组。通过 ‘cnt’ 变量传递 a[] 数组被占用元素的数量。可以是 Cur.UpperCnt 或 Cur.LowerCnt 变量。数组 a[] 和 ‘cnt’ 变量由引用传递, 因为它们要在方法中被更改。 

iv — 基于极值的指标值, pv — 基于极值的价格, mb — 极值所在柱线的价格, sb — 信号柱线 (即确认极值到达的柱线), et — 极值所在柱线的时间。

在 AddExtremum() 方法的开始处检查数组大小。如果它已满, 可增加其大小, 直到 1024 个元素。数据添加之后 ‘cnt’ 变量递增。

稍后我们将查看 CheckDiver() 方法。

利用阈值定义极值。

利用阈值定义的类不同于利用柱线定义的类, 主要在于 Cur 和 Pre 变量类型: 这是 UniDiverDefines.mqh 文件中描述的 SPseudoBuffers2 类型:

struct SPseudoBuffers2{
   int UpperCnt;
   int LowerCnt;
   double MinMaxVal;
   int MinMaxBar;   
   int Trend;
   void Reset(){
      UpperCnt=0;
      LowerCnt=0;  
      MinMaxVal=0;
      MinMaxBar=0;
      Trend=1;
   }   
};

SPseudoBuffers2 结构就像 SPseudoBuffers1 一样有相同的字段, 加上少量额外字段:

• MinMaxVal — 指标最大或最小值的变量
• MinMaxBar — 发现指标最大或最小值的柱线索引变量
• Trend — 指标走向变量。值 1 表示指标向上移动并跟踪其最大值。在 -1 的情况下, 跟踪最小值。

阈值的外部参数 — MinMaxThreshold 变量 — 传递到类的构造函数。它的值被保存在 “私有” 部分中声明的 m_threshold 变量当中。 

该类的 Calculate() 方法在极值定义方法中有所不同:

switch(Cur.Trend){ // 指标当前方向
   case 1: // 上升
      if(osc[i]>Cur.MinMaxVal){ // 新的最大值
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;
      }
      if(osc[i]<Cur.MinMaxVal-m_threshold){ // 超过阀值
         // 加入到数组
         this.AddExtremum(m_upper,Cur.UpperCnt,Cur.MinMaxVal,high[Cur.MinMaxBar],Cur.MinMaxBar,i,time[Cur.MinMaxBar]);
         Cur.Trend=-1;          // 改变跟踪方向 
         Cur.MinMaxVal=osc[i];  // 初始化最小值
         Cur.MinMaxBar=i;       // 初始化最小值的柱线       
      }
   break;
   case -1: // 下降
      if(osc[i]<Cur.MinMaxVal){ // 新的最小值
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;
      }
      if(osc[i]>Cur.MinMaxVal+m_threshold){ // 超过阀值
         // 将底部加入数组
         this.AddExtremum(m_lower,Cur.LowerCnt,Cur.MinMaxVal,low[Cur.MinMaxBar],Cur.MinMaxBar,i,time[Cur.MinMaxBar]);
         Cur.Trend=1;           // 改变跟踪方向 
         Cur.MinMaxVal=osc[i];  // 初始化最大值
         Cur.MinMaxBar=i;       // 初始化最大值的柱线 
      }         
   break;
}

如果 Cur.Trend 变量为 1, 则将振荡器值与 Curve.MiniMaxValue 值进行比较。如果新的振荡器值超过变量的值, 则更新变量值。将检测到新的最高值所在柱线索引被分配给 Cur.MinMaxBar 变量。还要确保振荡器值自最后已知的最大值尚未减去 m_threshold 值。如果已经减掉, 振荡器就改变了方向。调用 AddExtremum() 方法, 将新的极值上的数据保存在数组中, Cur.Trend 值被替换为相反的值, 而新的最小值的初始参数在 Cur.MinMaxVal 和 Cur.MinMaxBar 变量中设置。由于 Cur.Trend 变量的值已更改, 因此另一个 “case” 部分 — 跟踪最小振荡器值以及上穿阈值 — 从现在开始执行。

利用相对于振荡器中点的位置来定义极值。所应用的振荡器的类型被传递给类构造器。根据该类型, 定义振荡器中间值:

void CDiverMiddle(EOscUniType type){
   if(type==OscUni_Momentum){
      m_level=100.0;
   }
   else if(type==OscUni_RSI || type==OscUni_Stochastic){
      m_level=50.0;
   }
   else if(type==OscUni_WPR){
      m_level=-50.0;
   }
   else{
      m_level=0.0;
   }
}

对于 Momentum, 值为 100, 对于 RSI 和 Stochastic, 是 50, 对于 WPR, 是 -50, 对于其它振荡器, 是 0。

确定极值的方法在许多方面与阈值法相似:

switch(Cur.Trend){
   case 1:
      if(osc[i]>Cur.MinMaxVal){
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;
      }
      if(osc[i]<m_level){
         this.AddExtremum(m_upper,Cur.UpperCnt,Cur.MinMaxVal,high[Cur.MinMaxBar],Cur.MinMaxBar,i,time[Cur.MinMaxBar]);
         Cur.Trend=-1;
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;               
      }
   break;
   case -1:
      if(osc[i]<Cur.MinMaxVal){
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;
      }
      if(osc[i]>m_level){
         this.AddExtremum(m_lower,Cur.LowerCnt,Cur.MinMaxVal,low[Cur.MinMaxBar],Cur.MinMaxBar,i,time[Cur.MinMaxBar]);
         Cur.Trend=1;
         Cur.MinMaxVal=osc[i];
         Cur.MinMaxBar=i;
      }         
   break;
}

唯一的区别是比较振荡器的中值来完成方向改变: osc[i]<m_level 或 osc[i]>m_level。

设置背离类型的方法。在外部参数里加入用来选择所辨识的背离类型的变量:

input int                  Number            =  3;

默认参数值为 3。根据图例, 11, 这意味着经典的背离。图例. 11 中显示了价格和指标走势的 9 种组合。我们加入另一个选项 — “not checked”。现在, 我们有 10 个组合。因此, 使用通常的十进制数, 我们可以描述任意数量 (包括三重背离) 的不同走势的任何组合。事实证明, 一位数字对应于简单的背离 (两个顶部/底部), 两位数字是三重数量, 依此类推。例如, 13 的数量对应于图例. 14 所示的组合。

图例. 14。指标与价格走势的组合
当 Number = 13 时卖出 

用于检查背离条件的类。创建基类和用于检查背离条件的派生类。Number 参数值将在指标启动时进行分析。最重要的属性是它的长度, 因为它影响到指向类的指针的数组大小。然后, 根据条件类型为每个数组元素生成相应的对象。    

class CDiverConditionsBase{
   protected:
      double m_pt;
      double m_it;
   public:
   void SetParameters(double pt,double it){
      m_pt=pt;
      m_it=it;
   }
   virtual bool CheckBuy(double i1,double p1,double i2,double p2){
      return(false);
   }
   virtual bool CheckSell(double i1,double p1,double i2,double p2){
      return(false);
   }
};

input double               IndLevel          =  0;
input int                  PriceLevel        =  0;

class CDiverConditions1:public CDiverConditionsBase{
   private:
   public:
   bool CheckBuy(double i1,double p1,double i2,double p2){
      return((p1>p2+m_pt) && (i1>i2+m_it));
   }
   bool CheckSell(double i1,double p1,double i2,double p2){
      return((p1<p2-m_pt) && (i1<i2-m_it));
   }
};

CDiverConditionsBase * m_conditions[];
int m_ccnt;  

void SetConditions(int num,      // 背离数量
                   double pt,    // PriceLevel 参数
                   double it){   // IndLevel 参数
   if(num<1)num=1; // 背离数量不应小于 1
   ArrayResize(m_conditions,10); // 最大可能的条件数量
   m_ccnt=0; // 条件数量的实际计数值
   while(num>0){
      int cn=num%10; // 新极值对之间的差值变化
      m_conditions[m_ccnt]=CreateConditions(cn); // 创建一个对象
      m_conditions[m_ccnt].SetParameters(pt,it); // 设置条件验证参数
      num=num/10; // 移到下一个条件
      m_ccnt++; // 条件数量计数
   }
   // 根据实际的条件数量调整数组大小 
   ArrayResize(m_conditions,m_ccnt);    
}

if(num<1)num=1; // 背离数量不应小于 1

CDiverConditionsBase * CreateConditions(int i){
   switch(i){
      case 0:
         return(new CDiverConditions0());      
      break;
      case 1:
         return(new CDiverConditions1());      
      break;
      case 2:
         return(new CDiverConditions2());      
      break;
      case 3:
         return(new CDiverConditions3());      
      break;
      case 4:
         return(new CDiverConditions4());      
      break;
      case 5:
         return(new CDiverConditions5());      
      break;      
      case 6:
         return(new CDiverConditions6());      
      break;
      case 7:
         return(new CDiverConditions7());      
      break;
      case 8:
         return(new CDiverConditions8());      
      break;
      case 9:
         return(new CDiverConditions9());
      break;
   }
   return(new CDiverConditions0()); 
}

void CheckDiver(  int i,                    // 计算柱线索引
                  int ucnt,                 // m_upper 数组中的顶部数量
                  int lcnt,                 // m_lower 数组中的顶部数量
                  const datetime & time[],  // 柱线时间数组
                  const double &high[],     // 最高柱线的数组
                  const double &low[],      // 最低柱线的数组            
                  double & buy[],           // 指标的上升箭头缓冲区 
                  double & sell[],          // 指标的下降箭头缓冲区
                  double & osc[]            // 指标的振荡器数值缓冲区
){

   // 清除箭头缓冲区
   buy[i]=EMPTY_VALUE;
   sell[i]=EMPTY_VALUE;
   
   // 删除图形对象
   this.DelObjects(time[i]);
   
   // 对于顶部 (卖出信号)
   if(ucnt>m_ccnt){ // 顶部数量足够
      if(m_upper[ucnt-1].SignalBar==i){ // 已计算柱线上检测到一个顶部

         bool check=true; // 假设背离已经发生
         
         for(int j=0;j<m_ccnt;j++){ // 所有顶部
            // 验证新的一对顶部符合条件
            bool result=m_conditions[j].CheckSell( m_upper[ucnt-1-j].IndicatorValue,
                                                   m_upper[ucnt-1-j].PriceValue,
                                                   m_upper[ucnt-1-j-1].IndicatorValue,
                                                   m_upper[ucnt-1-j-1].PriceValue
                                                );
            if(!result){ // 不满足条件 
               check=false; // 没有背离
               break; 
            } 
                                
         }
         if(check){ // 背离已经发生
            // 设置指标箭头缓冲区
            sell[i]=osc[i];
            // 绘制价格图表的附加曲线 和/或 箭头
            this.DrawSellObjects(time[i],high[i],ucnt);
         }
      }
   }
   
   // 对于底部 (买入信号)
   if(lcnt>m_ccnt){
      if(m_lower[lcnt-1].SignalBar==i){
         bool check=true;
         for(int j=0;j<m_ccnt;j++){
            bool result=m_conditions[j].CheckBuy(  m_lower[lcnt-1-j].IndicatorValue,
                                                   m_lower[lcnt-1-j].PriceValue,
                                                   m_lower[lcnt-2-j].IndicatorValue,
                                                   m_lower[lcnt-2-j].PriceValue
                                                );
            if(!result){
               check=false;
               break;
            }                                          
         }
         if(check){
            buy[i]=osc[i];
            this.DrawBuyObjects(time[i],low[i],lcnt);
         }
      }
   }    
}

// 清除箭头缓冲区
buy[i]=EMPTY_VALUE;
sell[i]=EMPTY_VALUE;

// 删除图形对象
this.DelObjects(time[i]);

// 对于顶部 (卖出信号)
if(ucnt>m_ccnt){ // 有足够数量的顶部 

}

if(m_upper[ucnt-1].SignalBar==i){ // 在已计算柱线上检测到的顶部

}

bool check=true; // 假设背离发生

for(int j=0;j<m_ccnt;j++){ // 遍历所有顶部对
   // 在下一对顶部检查符合条件
   bool result=m_conditions[j].CheckSell( m_upper[ucnt-1-j].IndicatorValue,
                                          m_upper[ucnt-1-j].PriceValue,
                                          m_upper[ucnt-1-j-1].IndicatorValue,
                                          m_upper[ucnt-1-j-1].PriceValue
                                        );
   if(!result){ // 不满足条件 
      check=false; // 没有背离
      break; 
   } 
}

if(check){ // 背离发生
   // 放置指标缓冲区箭头
   sell[i]=osc[i];
   // 在价格图表上绘制辅助线和/或箭头
   this.DrawSellObjects(time[i],high[i],ucnt);
}

input bool                 ArrowsOnChart     =  true;
input bool                 DrawLines         =  true;
input color                ColBuy            =  clrAqua;
input color                ColSell           =  clrDeepPink;

bool m_arrows;  // 对应于 ArrowsOnChart 变量
bool m_lines;   // 对应于 DrawLines 变量
color m_cbuy;   // 对应于 ColBuy 变量
color m_csell;  // 对应于 ColSell 变量 

void SetDrawParmeters(bool arrows,bool lines,color cbuy,color csell){
   m_arrows=arrows;
   m_lines=lines;
   m_cbuy=cbuy;
   m_csell=csell;
}

void DelObjects(datetime bartime){ // 已启用绘制线条
   if(m_lines){
      // 形成共同的前缀
      string pref=MQLInfoString(MQL_PROGRAM_NAME)+"_"+IntegerToString((long)bartime)+"_";
      for(int j=0;j<m_ccnt;j++){ // 依据背离条件数量
         ObjectDelete(0,pref+"bp_"+IntegerToString(j)); // 买入信号的情况下, 价格图上的线条
         ObjectDelete(0,pref+"bi_"+IntegerToString(j)); // 买入信号的情况下, 指标图形上的线条
         ObjectDelete(0,pref+"sp_"+IntegerToString(j)); // 卖出信号的情况下, 价格图上的线条
         ObjectDelete(0,pref+"si_"+IntegerToString(j)); // 卖出信号的情况下, 指标图形上的线条
      }            
   }
   if(m_arrows){ // 启用价格图表上的箭头
      // 
      ObjectDelete(0,MQLInfoString(MQL_PROGRAM_NAME)+"_"+IntegerToString((long)bartime)+"_ba");
      // 
      ObjectDelete(0,MQLInfoString(MQL_PROGRAM_NAME)+"_"+IntegerToString((long)bartime)+"_sa");
   }
}

void DrawSellObjects(datetime bartime,double arprice,int ucnt){
   if(m_lines){ // 启用显示线条
      
      // 形成共同的前缀
      string pref=MQLInfoString(MQL_PROGRAM_NAME)+"_"+IntegerToString((long)bartime)+"_";
      
      for(int j=0;j<m_ccnt;j++){  // 依据所有背离条件
                  
         // 价格图表上的线条
         fObjTrend(  pref+"sp_"+IntegerToString(j),
                     m_upper[ucnt-1-j].ExtremumTime,
                     m_upper[ucnt-1-j].PriceValue,
                     m_upper[ucnt-2-j].ExtremumTime,
                     m_upper[ucnt-2-j].PriceValue,
                     m_csell);
                     
         // 指标图形上的线条
         fObjTrend(  pref+"si_"+IntegerToString(j),
                     m_upper[ucnt-1-j].ExtremumTime,
                     m_upper[ucnt-1-j].IndicatorValue,
                     m_upper[ucnt-2-j].ExtremumTime,
                     m_upper[ucnt-2-j].IndicatorValue,
                     m_csell,
                     ChartWindowFind(0,MQLInfoString(MQL_PROGRAM_NAME)));  
      }
   }
      
   if(m_arrows){ // 已启用价格图表上的箭头
      fObjArrow(MQLInfoString(MQL_PROGRAM_NAME)+"_"+IntegerToString((long)bartime)+"_sa",
               bartime,
               arprice,
               234,
               m_csell,
               ANCHOR_LOWER); 
   }            
} 

switch(ExtremumType){
   case ExtrBars:
      diver=new CDiverBars(LeftBars,RightBars);
   break;
   case ExtrThreshold:
      diver=new CDiverThreshold(MinMaxThreshold);
   break;      
   case ExtrMiddle:
      diver=new CDiverMiddle(Type);
   break;      
}

input bool                 Auto5Digits       =  true;

int pl=PriceLevel;   
if(Auto5Digits && (Digits()==5 || Digits()==3)){
   pl*=10;
}  

diver.SetConditions(Number,Point()*pl,IndLevel);
diver.SetDrawParmeters(ArrowsOnChart,DrawLines,ColBuy,ColSell);

diver.Calculate(  rates_total,
                  prev_calculated,
                  time,
                  high,
                  low,
                  buf_osc,
                  buf_buy,
                  buf_sell);

if(ArrowsOnChart || DrawLines){
   ChartRedraw();
}

void ~CDiverBase(){
   for(int i=0;i<ArraySize(m_conditions);i++){ // 所有条件
      if(CheckPointer(m_conditions[i])==POINTER_DYNAMIC){
         delete(m_conditions[i]); // 删除对象
      }      
   }  
   // 删除图形对象
   ObjectsDeleteAll(0,MQLInfoString(MQL_PROGRAM_NAME));
   ChartRedraw();          
}