Zigzag指标及源码解释

一般的MT4中 Custom Indicator 中都有 ZigZag 这个指标.

在理解Zigzag指标的算法之前，我们可以思考这么一个问题：给我们下面的这副图，我们怎么能够把这些1、2、3等数字代表的高低点给选择出来？



Zigzag指标算法

如官方所述：Zigzag指标是连接一系列价格点的趋势线。所以Zigzag主要用途是来标识过去价格中的相对高低点，并以这些点之间的连线来表示这段价格变动的趋势。

1.Zigzag的3个参数

Zigzag在识别高低点的过程中，主要设置了以下三个参数：Depth, Deviation 以及Backstep。程序中的表示：



extern int Depth=12;

extern int Deviation=5;

extern int Backstep=3;

说明：

Depth：用于设置高低点是相对与过去多少个Bars（价格图形中的一个柱子）而言。Mt4中默认是12。

Deviation：用于设置重新计算高低点时，与前一高低点的相对点差。默认值是5， 也就是说如果

A）当前高点>上个高点 5 ,或者

B）当前低点<上个低点 – 5的情况下，则会对之前计算过的ExtBacksteps个Bars值的高低点进行重新计算。

Backstep：用于设置回退计算的Bars的个数。

2.Zigzag算法

1对计算位置进行初期化

1.1判断是否是第一次进行高低点计算，如果是，则设定计算位置为除去ExtDepth个图形最初的部分。

1.2如果之前已经计算过，找到最近已知的三个拐点（高点或低点），将计算位置设置为倒数第三个拐点之后，重新计算最后的拐点。

2.从步骤1已经设置好的计算位置开始，将对用于存储高低点的变量进行初始化，准备计算高低点

2.1计算ExtDepth区间内的低点，如果该低点是当前低点，则进行2.1.1的计算，并将其记录成一个低点。

2.1.1如果当前低点比上一个低点值小于相对点差（ExtDeviation）；并且之前ExtBackstep个Bars的记录的中，高于当前低点的值清空。

2.2高点的计算如同2.1以及分支处理2.1.1。

3.从步骤1已经设置好的计算位置开始，定义指标高点和低点

3.1如果开始位置为高点，则接下来寻找低点，在找到低点之后，将下一个寻找目标定义为高点

3.2如果开始位置为低点，则与3.1反之。

以上可能比较难以理解，我们这边举个例子说明：

假设上次计算的结果如下：倒数第14个Bar出现了一个高点（3.1），倒数第4个是低点（1.5），

倒数第1个是新的高点（2.1）——因为距离倒数第14已经大于ExtDepth（14-1>12）。

Bar-14　　　Bar-4　　Bar-1 　　Bar-Current

高（3.1）　　低（1.5）　　高（2.1） 　　 X

对于Bar-Current，即当前的价格X，

CaseI.

如果 X >=2.1 ExtDeviation，则根据Zigzag的定义，这将是一个新的高点。假设这里X=2.3，那么我们绘制指标的时候应该成为：

Bar-14 　　　Bar-4　　Bar-Current

高（3.1）  　　低（1.5）　　高（2.3）     

CaseII.

如果 1.5 – ExtDeviation< X<2.1 ExtDeviation，则我们继续等待价格的变化，所绘制的指标也不会变化。

CaseIII.

如果 1.5 – ExtDeviation>= X，则这是一个新的低点。假设这里X=1.3，则我们绘制指标的时候应该成为：

Bar-14　　　Bar-Current

高（3.1）  　　低（1.3）

这个时候，之前的Bar-4因为在我们定义的ExtBackstep之内（1-4），所以他的最低值会被清空，

根据算法第三步的定义，我们会一直寻找低点直到发现Bar-Current，这时候已经遍历过Bar-1，所以Bar-1定义的高点也不再成为拐点。

这也就是所谓的重绘部分，也因此诟病为“未来函数”——因为所看见的当前最后的高低点可能在下个时间段里面被抹去。

3.Zigzag源码解释：

Mt4的Zigzag源码里面的注释特别稀罕，估计是感觉实现比较简单，所以一概略去——恩，极坏的编程习惯。

下面简要说明一下，中文部分都是追加的解释：

// ——————————————————————

//|                                                       Zigzag.mq4 |

//|                 Copyright ?2005-2007, MetaQuotes Software Corp. |

//|                                       http://www.metaquotes.net/ |

// ——————————————————————

#property copyright “Copyright ?2007, MetaQuotes Software Corp.”

#property link      “http://www.metaquotes.net/”

//Mt4特有的指标属性设置

#property indicator_chart_window      //主窗口进行指标显示

#property indicator_buffers 1            //指标运用到数值的个数

#property indicator_color1 Red       //指标显示颜色

//—- indicator parameters

//Zigzag的三个参数

extern int ExtDepth=12;

extern int ExtDeviation=5;

extern int ExtBackstep=3;

//—- indicator buffers

//指标的数值存储变量

double ZigzagBuffer[];        //拐点

double HighMapBuffer[];      //高点的临时变量数组

double LowMapBuffer[];    //低点的临时变量数组

int level=3; // recounting’s depth  //最近已知的三个拐点

bool downloadhistory=false; //是否第一次计算

// ——————————————————————

//| Custom indicator initialization function                         |

// ——————————————————————

//Init函数是Mt4指标第一次载入之后运行的初期化函数

int init（）

  {

   IndicatorBuffers（3）; //对于缓冲储存器分配记忆应用自定义指标计算，用F1可以看到该函数的帮助和解释

//—- drawing settings

   SetIndexStyle（0,DRAW_SECTION）;     //划线的风格

//—- indicator buffers mapping

   SetIndexBuffer（0,ZigzagBuffer）;

   SetIndexBuffer（1,HighMapBuffer）;

   SetIndexBuffer（2,LowMapBuffer）;

   SetIndexEmptyValue（0,0.0）;

     

//—- indicator short name

   IndicatorShortName（”ZigZag（” ExtDepth ”,” ExtDeviation ”,” ExtBackstep ”）”）;        //设置指标的简称。

//—- initialization done

   return（0）;

  }

// ——————————————————————

//|                                                                  |

// ——————————————————————

//start函数是Mt4的主函数，当每次价格变动之后都会触发该函数的执行

int start（）

  {

//变量定义

  //i：临时变量；

  //counted_bars ：用于标识已经计算过的Bar数

   int i, counted_bars = IndicatorCounted（）;  

   //limit：算法中所谓的开始计算位置;

  //counterZ：临时变量

  //whatlookfor：用于标识当前计算的是高点或者低点

   int limit,counterZ,whatlookfor;        

  //以下都是临时变量，具体设值时解释

   int shift,back,lasthighpos,lastlowpos;

   double val,res;

   double curlow,curhigh,lasthigh,lastlow;

   if （counted_bars==0 && downloadhistory） // history was downloaded

     {   //指标载入时counted_bars为0，而downloadhistory为false，将在下一次价格变化时进行

      ArrayInitialize（ZigzagBuffer,0.0）;

      ArrayInitialize（HighMapBuffer,0.0）;

      ArrayInitialize（LowMapBuffer,0.0）;

     }

   if （counted_bars==0）

     { //初期化，第一次运行时limit为除去ExtDepth个图形最初的部分。（算法1.1）

      limit=Bars-ExtDepth;

      downloadhistory=true;

     }

   if （counted_bars>0）

     {//如果之前已经计算过，找到最近已知的三个拐点（高点或低点），将计算位置设置为倒数第三个拐点。（算法1.2）

      while （counterZ<level && i<100）

        {

         res=ZigzagBuffer;

         if （res!=0） counterZ ;

         i ;

        }

      i–;           //在上面while中最后一次找到的时候进行 1，所以要-1才能得到真正第三个拐点处。

      limit=i;  //计算位置赋值

      if （LowMapBuffer!=0）

        {//如果倒数第三个拐点是低点

         curlow=LowMapBuffer;

         //目标在于寻找高点

         whatlookfor=1;

        }

      else

        {

         curhigh=HighMapBuffer;

         whatlookfor=-1;

        }

      for （i=limit-1;i>=0;i–）  

        {//清空第三个拐点后的数值，准备重新计算最后的拐点

         ZigzagBuffer=0.0;  

         LowMapBuffer=0.0;

         HighMapBuffer=0.0;

        }

     }

//算法Step2部分：计算高低点

   for（shift=limit; shift>=0; shift–）

     {

      //2.1计算ExtDepth区间内的低点

      val=Low[iLowest（NULL,0,MODE_LOW,ExtDepth,shift）];

      if（val==lastlow） val=0.0;

      else

        {//如果该低点是当前低点，

         lastlow=val;

         if（（Low[shift]-val）>（ExtDeviation*Point）） val=0.0;        //是否比上个低点还低ExtDeviation，不是的话则不进行回归处理

         else

           {//找到一个新的低点

            for（back=1; back<=ExtBackstep; back ）

              {//回退ExtBackstep个Bar，把比当前低点高的纪录值给清空

               res=LowMapBuffer[shift back];

               if（（res!=0）&&（res>val）） LowMapBuffer[shift back]=0.0;

              }

           }

        }

      //将新的低点进行记录

      if （Low[shift]==val） LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;

      //— high

      val=High[iHighest（NULL,0,MODE_HIGH,ExtDepth,shift）];

      if（val==lasthigh） val=0.0;

      else

        {

         lasthigh=val;

         if（（val-High[shift]）>（ExtDeviation*Point）） val=0.0;

         else

           {

            for（back=1; back<=ExtBackstep; back ）

              {

               res=HighMapBuffer[shift back];

               if（（res!=0）&&（res<val）） HighMapBuffer[shift back]=0.0;

              }

           }

        }

      if （High[shift]==val） HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;

     }

   // final cutting

   if （whatlookfor==0）

     {

      lastlow=0;

      lasthigh=0;  

     }

   else

     {

      lastlow=curlow;

      lasthigh=curhigh;

     }

//算法step3.定义指标的高低点

   for （shift=limit;shift>=0;shift–）

     {

      res=0.0;

      switch（whatlookfor）

        {

         //初期化的情况下，尝试找第一个高点或者是地点

         case 0: // look for peak or lawn

            if （lastlow==0 && lasthigh==0）

              {//lastlow，lasthigh之前已经初始化，再次判断以保证正确性？

               if （HighMapBuffer[shift]!=0）

                 {//发现高点

                  lasthigh=High[shift];

                  lasthighpos=shift;

                  whatlookfor=-1;        //下个寻找目标是低点

                  ZigzagBuffer[shift]=lasthigh;

                  res=1;

                 }

               if （LowMapBuffer[shift]!=0）

                 {//发现低点

                  lastlow=Low[shift];

                  lastlowpos=shift;

                  whatlookfor=1;       //下个寻找目标是高点

                  ZigzagBuffer[shift]=lastlow;

                  res=1;

                 }

              }

             break;  

         case 1: // look for peak      //寻找高点

            if （LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0）

              {//如果在上个低点和下个高点间发现新的低点，则把上个低点抹去，将新发现的低点作为最后一个低点

               ZigzagBuffer[lastlowpos]=0.0;

               lastlowpos=shift;

               lastlow=LowMapBuffer[shift];

               ZigzagBuffer[shift]=lastlow;

               res=1;

              }

            if （HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0）

              {//发现目标高点

               lasthigh=HighMapBuffer[shift];

               lasthighpos=shift;

               ZigzagBuffer[shift]=lasthigh;

               whatlookfor=-1;        //下一个目标将是寻找低点

               res=1;

              }   

            break;               

         case -1: // look for lawn          //寻找低点

            if （HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0）

              {

               ZigzagBuffer[lasthighpos]=0.0;

               lasthighpos=shift;

               lasthigh=HighMapBuffer[shift];

               ZigzagBuffer[shift]=lasthigh;

              }

            if （LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0）

              {

               lastlow=LowMapBuffer[shift];

               lastlowpos=shift;

               ZigzagBuffer[shift]=lastlow;

               whatlookfor=1;

              }   

            break;               

         default: return;

        }

     }

   return（0）;

  }

// ——————————————————————

4.总结

以上就是对Zigzag算法和实现的分析。希望能够对大家编写指标和EA有所帮助。