加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

Zigzag之字形指标

(2015-03-30 11:01:15)
标签：

股票

低点

高点

拐点

指标

杂谈

Zigzag指标是连接一系列价格点的趋势线。最小价格的参数改变需要在定单中从新的"Zig" 或 "Zag" 线中确定百分比。这个指标可以消除价格点的改变，分析的价值少于给出的价值。因此，Zigzag指标只反映明显的变化。其主要用途是来标识过去价格中的相对高低点，并以这些点之间的连线来表示这段价格变动的趋势。多数情况下，我们使用之字形很容易感知到价格点，最重要的是它能够显示其转换和改变。在它的帮助下，你同样可以揭示Elliot波动和多样的情形。



Zigzag指标算法

1. Zigzag的3个参数

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

extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;

说明：
ExtDepth：用于设置高低点是相对与过去多少个Bars(价格图形中的一个柱子)而言。Mt4中默认是12。
ExtDeviation：用于设置重新计算高低点时，与前一高低点的相对点差。默认值是5， 也就是说如果
A)当前高点>上个高点 5 ,或者
B)当前低点<上个低点 – 5的情况下，则会对之前计算过的ExtBacksteps个Bars值的高低点进行重新计算。
ExtBackstep：用于设置回退计算的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源码里面的注释特别稀罕，估计是感觉实现比较简单，所以一概略去——恩，极坏的编程习惯。
下面简要说明一下，中文部分都是追加的解释：


  1. // ——————————————————————
  2. //|                                                       Zigzag.mq4 |
  3. //|                 Copyright ?2005-2007, MetaQuotes Software Corp. |
  4. //|                                       http://www.metaquotes.net/ |
  5. // ——————————————————————
  6. #property copyright “Copyright ?2007, MetaQuotes Software Corp.”
  7. #property link      “http://www.metaquotes.net/”

  9. //Mt4特有的指标属性设置
  10. #property indicator_chart_window      //主窗口进行指标显示
  11. #property indicator_buffers 1            //指标运用到数值的个数
  12. #property indicator_color1 Red       //指标显示颜色
  13. //—- indicator parameters
  14. //Zigzag的三个参数
  15. extern int ExtDepth=12;
  16. extern int ExtDeviation=5;
  17. extern int ExtBackstep=3;

  19. //—- indicator buffers
  20. //指标的数值存储变量
  21. double ZigzagBuffer[];        //拐点
  22. double HighMapBuffer[];      //高点的临时变量数组
  23. double LowMapBuffer[];    //低点的临时变量数组

  25. int level=3; // recounting’s depth  //最近已知的三个拐点
  26. bool downloadhistory=false; //是否第一次计算
  27. // ——————————————————————
  28. //| Custom indicator initialization function                         |
  29. // ——————————————————————

  31. //Init函数是Mt4指标第一次载入之后运行的初期化函数
  32. int init()
  33.   {
  34.    IndicatorBuffers(3); //对于缓冲储存器分配记忆应用自定义指标计算，用F1可以看到该函数的帮助和解释
  35. //—- drawing settings
  36.    SetIndexStyle(0,DRAW_SECTION);     //划线的风格
  37. //—- indicator buffers mapping
  38.    SetIndexBuffer(0,ZigzagBuffer);
  39.    SetIndexBuffer(1,HighMapBuffer);
  40.    SetIndexBuffer(2,LowMapBuffer);
  41.    SetIndexEmptyValue(0,0.0);
  42.    
  43. //—- indicator short name
  44.    IndicatorShortName(”ZigZag(” ExtDepth ”,” ExtDeviation ”,” ExtBackstep ”)”);        //设置指标的简称。
  45. //—- initialization done
  46.    return(0);
  47.   }
  48. // ——————————————————————
  49. //|                                                                  |
  50. // ——————————————————————

  52. //start函数是Mt4的主函数，当每次价格变动之后都会触发该函数的执行
  53. int start()
  54.   {
  55. //变量定义

  57.   //i：临时变量；
  58.   //counted_bars ：用于标识已经计算过的Bar数
  59.    int i, counted_bars = IndicatorCounted();

  61.    //limit：算法中所谓的开始计算位置;
  62.   //counterZ：临时变量
  63.   //whatlookfor：用于标识当前计算的是高点或者低点
  64.    int limit,counterZ,whatlookfor;      

  66.   //以下都是临时变量，具体设值时解释
  67.    int shift,back,lasthighpos,lastlowpos;
  68.    double val,res;
  69.    double curlow,curhigh,lasthigh,lastlow;

  71.    if (counted_bars==0 && downloadhistory) // history was downloaded
  72.      {   //指标载入时counted_bars为0，而downloadhistory为false，将在下一次价格变化时进行
  73.       ArrayInitialize(ZigzagBuffer,0.0);
  74.       ArrayInitialize(HighMapBuffer,0.0);
  75.       ArrayInitialize(LowMapBuffer,0.0);
  76.      }
  77.    if (counted_bars==0)
  78.      { //初期化，第一次运行时limit为除去ExtDepth个图形最初的部分。（算法1.1）
  79.       limit=Bars-ExtDepth;
  80.       downloadhistory=true;
  81.      }
  82.    if (counted_bars>0)
  83.      {//如果之前已经计算过，找到最近已知的三个拐点（高点或低点），将计算位置设置为倒数第三个拐点。（算法1.2）
  84.       while (counterZ<100)
  85.         {
  86.          res=ZigzagBuffer;
  87.          if (res!=0) counterZ ;
  88.          i ;
  89.         }
  90.       i–;           //在上面while中最后一次找到的时候进行 1，所以要-1才能得到真正第三个拐点处。
  91.       limit=i;  //计算位置赋值
  92.       if (LowMapBuffer!=0)
  93.         {//如果倒数第三个拐点是低点
  94.          curlow=LowMapBuffer;
  95.          //目标在于寻找高点
  96.          whatlookfor=1;
  97.         }
  98.       else
  99.         {
  100.          curhigh=HighMapBuffer;
  101.          whatlookfor=-1;
  102.         }
  103.       for (i=limit-1;i>=0;i–)
  104.         {//清空第三个拐点后的数值，准备重新计算最后的拐点
  105.          ZigzagBuffer=0.0;
  106.          LowMapBuffer=0.0;
  107.          HighMapBuffer=0.0;
  108.         }
  109.      }


  112. //算法Step2部分：计算高低点
  113.    for(shift=limit; shift>=0; shift–)
  114.      {
  115.       //2.1计算ExtDepth区间内的低点
  116.       val=Low[iLowest(NULL,0,MODE_LOW,ExtDepth,shift)];
  117.       if(val==lastlow) val=0.0;
  118.       else
  119.         {//如果该低点是当前低点，
  120.          lastlow=val;
  121.          if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;        //是否比上个低点还低ExtDeviation，不是的话则不进行回归处理
  122.          else
  123.            {//找到一个新的低点
  124.             for(back=1; back<=ExtBackstep; back )
  125.               {//回退ExtBackstep个Bar，把比当前低点高的纪录值给清空
  126.                res=LowMapBuffer[shift back];
  127.                if((res!=0)&&(res>val)) LowMapBuffer[shift back]=0.0;
  128.               }
  129.            }
  130.         }
  131.       //将新的低点进行记录
  132.       if (Low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;

  134.       //— high
  135.       val=High[iHighest(NULL,0,MODE_HIGH,ExtDepth,shift)];
  136.       if(val==lasthigh) val=0.0;
  137.       else
  138.         {
  139.          lasthigh=val;
  140.          if((val-High[shift])>(ExtDeviation*Point)) val=0.0;
  141.          else
  142.            {
  143.             for(back=1; back<=ExtBackstep; back )
  144.               {
  145.                res=HighMapBuffer[shift back];
  146.                if((res!=0)&&(res
  147.               }
  148.            }
  149.         }
  150.       if (High[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
  151.      }

  153.    // final cutting
  154.    if (whatlookfor==0)
  155.      {
  156.       lastlow=0;
  157.       lasthigh=0;
  158.      }
  159.    else
  160.      {
  161.       lastlow=curlow;
  162.       lasthigh=curhigh;
  163.      }

  165. //算法step3.定义指标的高低点
  166.    for (shift=limit;shift>=0;shift–)
  167.      {
  168.       res=0.0;
  169.       switch(whatlookfor)
  170.         {
  171.          //初期化的情况下，尝试找第一个高点或者是地点
  172.          case 0: // look for peak or lawn
  173.             if (lastlow==0 && lasthigh==0)
  174.               {//lastlow，lasthigh之前已经初始化，再次判断以保证正确性？
  175.                if (HighMapBuffer[shift]!=0)
  176.                  {//发现高点
  177.                   lasthigh=High[shift];
  178.                   lasthighpos=shift;
  179.                   whatlookfor=-1;        //下个寻找目标是低点
  180.                   ZigzagBuffer[shift]=lasthigh;
  181.                   res=1;
  182.                  }
  183.                if (LowMapBuffer[shift]!=0)
  184.                  {//发现低点
  185.                   lastlow=Low[shift];
  186.                   lastlowpos=shift;
  187.                   whatlookfor=1;       //下个寻找目标是高点
  188.                   ZigzagBuffer[shift]=lastlow;
  189.                   res=1;
  190.                  }
  191.               }
  192.              break;
  193.          case 1: // look for peak      //寻找高点
  194.             if (LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]
  195.               {//如果在上个低点和下个高点间发现新的低点，则把上个低点抹去，将新发现的低点作为最后一个低点
  196.                ZigzagBuffer[lastlowpos]=0.0;
  197.                lastlowpos=shift;
  198.                lastlow=LowMapBuffer[shift];
  199.                ZigzagBuffer[shift]=lastlow;
  200.                res=1;
  201.               }
  202.             if (HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
  203.               {//发现目标高点
  204.                lasthigh=HighMapBuffer[shift];
  205.                lasthighpos=shift;
  206.                ZigzagBuffer[shift]=lasthigh;
  207.                whatlookfor=-1;        //下一个目标将是寻找低点
  208.                res=1;
  209.               }
  210.             break;            
  211.          case -1: // look for lawn          //寻找低点
  212.             if (HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
  213.               {
  214.                ZigzagBuffer[lasthighpos]=0.0;
  215.                lasthighpos=shift;
  216.                lasthigh=HighMapBuffer[shift];
  217.                ZigzagBuffer[shift]=lasthigh;
  218.               }
  219.             if (LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
  220.               {
  221.                lastlow=LowMapBuffer[shift];
  222.                lastlowpos=shift;
  223.                ZigzagBuffer[shift]=lastlow;
  224.                whatlookfor=1;
  225.               }
  226.             break;            
  227.          default: return;
  228.         }
  229.      }

  231.    return(0);
  232.   }
  233. // ——————————————————————

复制代码

4.总结

以上就是对Zigzag算法和实现的分析。希望能够对大家编写指标和EA有所帮助。
原文来自：股票自动机-AI Invest博客

喜欢

0

阅读┊ 收藏 ┊ 喜欢▼ ┊打印┊举报/Report
  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有