目录

旗形形态的基本特性，就如同它的名字所关联的，是一种明显的垂直方向价格变化(“旗杆”)伴着随后的水平方向的价格盘整所构成的水平旗形(图 1).

图 1. 旗形

在技术分析相关的书籍和网站中，旗形形态经常与三角旗形形态做横向比较，与旗形不同，三角旗形是三角形形状 (图 2), 这也是为什么在一些技术分析资源中，旗形形态与三角形态一起分析。

图 2. 三角旗形

可能看起来三角旗形和三角形只是相同形态的不同名称，在一些技术分析书籍中，例如 Tomas Bulkowski 的“图表形态百科全书”中, 这两种形态是分别独立描述的。而且书中还描述了楔形形态，它和水平绘制的三角形是类似的，它的狭窄部分在左边，而在右方价格变化的范围更大。

图 3. 楔形

除了楔形形态，还有扩张三角形，以及各种长方形形态都类似于旗形。所以，应该有明确的规则来区分三角旗形和三角形，区分楔形和扩张三角形，以及区分旗形和水平形态。这个问题将会在文章中首先做探讨，然后，我们将创建指标来搜索所有这些形态。 

三角旗形和三角形的差别

让我们探讨一下三角旗形和三角形的区别，以及其他上述形状类似的形态的区别:

• 长方形形态和旗形;
• 三角形和三角旗形;
• 扩张三角形和楔形.

长方形形态，三角形和扩张三角形都属于一类，而旗形、三角旗形和楔形属于另一类，

第一类的模式都是由价格反转点构成的(图4)，所以可以使用之字转向(ZigZag)指标来搜索它们。

图 4. 形态: a — 水平形态, b — 三角形, c — 扩张三角形.  
形态显示价格有上涨的期待(用于买入).

第二类的模式是由填充它们区域的柱构成的，当然，在图表上很难看到明显形成这样的图形，但是重点是有一个柱被邻近的柱大幅覆盖，而形成了形态。 

图 5. 形态: a — 旗形, b — 三角形, c — 楔形.
形态显示了价格可能会上涨 (用于买入).

现在我们已经确定了类别和它们的基本差别，让我们单独探讨每个形态。 

水平形态

让我们从第一类的形态开始讨论，确定这样形态的简便方法是使用之字转向指标，这类形态的第一个是水平形态, 它对应着第二种类的旗形形态。然而，在大多数技术分析相关资料中，水平形态也被称为旗形形态。

为了形成水平形态，价格应当有明显的垂直方向变化，然后再在相同的价格水平上形成至少双顶和双底。价格也可能形成三顶和三底(图 6), 或者更多。所以，指标的一个参数就是确定构成形态的顶部和底部的数量。

图 6. 水平形态: a — 由两个顶部/底部构成，b — 由三个顶部/底部构成.
形态显示出价格可能上涨 (适合买入) 

在形态中并不要求顶部和底部的边缘是水平的，它们必须是平行的，所以指标将有一个或者多个参数来选择形态的倾斜方向: 水平方向，向上倾斜，向下倾斜 (图 7).

图 7. a — 水平方向形态, b — 向下倾斜的形态, c — 向上倾斜的形态. 
形态显示价格可能上涨 (适合买入)

当然，这样向上或者向下倾斜的形态不能称为水平形态，但是它们在原则上与水平形态很接近，

当价格突破了顶部构成的水平时，形态就结束了。

 
图 8. 形态结束并建立一个
买入仓位: a — 对于水平形态,
b — 对于向下倾斜的形态 

向上倾斜形态进场的时刻将不考虑顶部的倾斜，而会使用最后一个顶部的水平价格 (图 9).

图 9. 确定向上倾斜形态的入场点 (买入)

在向下倾斜形态中也可以使用水平级别的简单变化，所以指标还将有个变量用于选择级别的类型而不论形态的类型。

水平形态的目标是由形态形成之前垂直方向价格变化的大小来决定的，价格的距离应当等于它形成之前的价格的距离(图10)。

图 10. 确定目标。L1 是在进入形态之前价格的距离，
它应当等于退出形态的距离L2。 

因为形态的上下边界是平行的，我们可以使用一个简单方法来确定目标: 我们可以根据价格和第一个形态顶部的距离来使用相同的距离设置最近的底部(图 11)。

图 11. 确定目标的简单方法。价格距离构成第一个顶部之间的距离L1
等于最后一个底部和目标的距离L2

收敛三角形

其余的条件与水平形态类似: 三角形的水平位置或者向上/向下倾斜，在突破了由最近两个顶部或者底部水平级别的阻力位时进场，目标水平的计算也类似。

扩张三角形

上面的收敛三角形原则可以应用于扩张三角形，唯一的区别是构成形态的之字转向片段在增大(图 13)。

 图 13. 扩张三角形. 片段 3-4 必须大于
片段 1-2, 而片段 5-6 必须大于 3-4 

根据这三种形态如此的类似，我们可以为搜索它们创建一个通用指标。  

用于搜索水平形态和三角形的通用指标

为了创建指标，我们将使用 iUniZigZagSW 指标，它来自通用的之字转向指标这篇文章。还需要以下另外的文件: CSorceData.mqh, CZZDirection.mqh 和 CZZDraw.mqh。这些文件以及iUniZigZagSW.mq5 文件可以从通用之字转向指标文章的附件中下载。下载文档，再解压并把 MQL5 文件夹复制到终端数据文件夹中，在复制之后， ZigZag 文件夹将会出现在 MQL5/Indicators 中，包含了几个文件 (包括 iUniZigZagSW.mq5), 还有另一个 ZigZag 文件夹，CSorceData.mqh, CZZDirection.mqh 和 CZZDraw.mqh 文件将出现在 MQL5/Includes 文件夹中。在复制文件之后，重新启动终端来编译指标或者在 MetaEditor 中逐个编译它们。在终端的图表中运行 iUniZigZagSW 指标已确保它能正常工作。

在沃尔夫波形文章中，在创建指标的中间步骤中保存了iWolfeWaves_Step_1.mq5 文件，它实现了使用 iCustom() 函数访问 iUniZigZagSW.mq5 指标，另外，在它内部还有一个数组保存了所有之字转向的顶部和底部。下载‘沃尔夫波形’文章的附件, 把它解压缩, 复制iWolfeWaves_Step_1.mq5 到 MQL5/Indicators, 把它重命名为 “iHorizontalFormation” 并在 MetaEditor 中打开它，所有使用指标来侦测水平形态的工作都将在这个文件中进行。可能需要在这个文件中修改 iUniZigZagSW 指标的路径，为了检查这一点，要编译指标并尝试在图表上运行它。如果出现了 “载入指标出错” 的消息窗口， 就要在 OnInit() 中找到对 iCustom() 的调用, 并且把指标名称从”iUniZigZagSW”改为”ZigZags//iUniZigZagSW”。在这样修改之后，再次编译指标，并确保它可以在图表上正确运行。在这个阶段，指标不会画出任何东西。

在这里讨论的整个搜索形态的过程可以分为几个独立任务:

1. 确定在形成形态之前的价格变化的数值，
2. 确定形态的形状，
3. 确定形态的斜度，
4. 形态生成结束: 在形态形成之后或者等到突破某一水平。
5. 确定目标。

每个任务(除了第一个)都将提供集中方案选项，这将有助于我们创建一个通用指标来识别所有这三种形态。我们将能够在指标参数窗口中使用枚举的下拉列表在选项中作切换， 

选择形状(形态类型)的枚举:

enum EPatternType{
   PatternTapered,
   PatternRectangular,
   PatternExpanding
};

属性窗口中对应的变量:

input EPatternType         Pattern        =  PatternRectangular;

这个参数可以用来选择形态的形状: PatternTapered — 收敛三角形, PatternRectangular – 长方形, PatternExpanding – 扩张三角形.

用于选择形态倾斜方向的枚举:

enum EInclineType{
   InclineAlong,
   InclineHorizontally,
   InclineAgainst
};

属性窗口中对应的变量:

input EInclineType         Incline        =  InclineHorizontally; 

这个参数可以选择形态的倾斜方向: InclineAlong — 在期望的方向上继续延伸 (对于买入就是上涨，对于卖出就是下跌), InclineHorizontally — 没有倾斜, InclineAgainst — 于期望的方向上相反。

用于选择形态结束方法的枚举:

enum EEndType{
   Immediately,
   OneLastVertex,
   TwoLastVertices
};

属性窗口中对应的变量:

input EEndType             CompletionType =  Immediately;

可以使用以下的选项: 在形态完成后立即, OneLastVertex — 在突破了形态最近的顶部水平后, TwoLastVertices — 在突破了形态中由两个顶部构成的水平之后.

用于选择目标计算选项的枚举:

enum ETargetType{
   FromVertexToVertex,
   OneVertex,
   TwoVertices
};

属性窗口中对应的变量:

input ETargetType          Target         =  OneVertex;

可以使用以下的选项: FromVertexToVertex (图 11), OneVertex (图 10), TwoVertices, 使用形态中的两个初始底部 (参见图 14).

图 14. 三顶的形态。目标确定选项是 TwoVertices,
形态完成方法是 OneLastVertex.

当形态完成方法设为 Immediately 的时候, Target 参数就是无效的，因为只能使用 FromVertexToVertex 。对于另外两种形态完成选项 (OneLastVertex 和 TwoLastVertices), 所有三种 CompletionType 选项的不同组合都是可能的。请注意下面的特性: 如果选择了 OneVertex 或者 TwoVertices 选项来确定目标, 一个或者两个第一底部(图14中的点2, 或者点2和点4)来用于确定目标, 而突破水平是根据最近一个或者两个顶部来确定的 (图14中的点5或者点3和点5). 如果使用了双顶的形态，将使用点3或者点1和点3。

为了解决任务1, 我们需要一个参数来确定形态之前价格变化的大小:

input double               K1             =  1.5;

片段1-2的高度(参见图14)用作形态的基础(它的参考大小), 而所有对大小的检查都是相对它的。K1 参数确定了片段0-1的高度应该比片段1-2高多少倍。

为了确定形态的形状，我们使用 K2 参数:

input double               K2             =  0.25;

参数值越小，形态的高度在它的长度中就越稳定。对于三角形形态 (扩张和收敛), 有一个增加参数用来搜索最明显的三角形。

为了确定形态的倾斜方向，我们使用 K3 参数:

input double               K3             =  0.25;

参数值越小，就意味着指标将搜索水平位置的形态，要搜索倾斜的形态，就应该在K2参数中指定较大的数值，它可以找到明显倾斜的形态。

最后，还有一个主要的参数:

input int                  N              =  2;

N 参数确定了形态定点的数量。 

结果，我们就有了以下的外部参数集 (还有 ZigZag 的参数):

input EPatternType         Pattern        =  PatternRectangular;
input EInclineType         Incline        =  InclineHorizontally;     
input double               K1             =  1.5;
input double               K2             =  0.25;
input double               K3             =  0.25;
input int                  N              =  2;
input EEndType             CompletionType =  Immediately;
input ETargetType          Target         =  OneVertex;

使用 N 参数，我们计算在确定形态时需要多少个之字转向点。首先，我们声明一个全局变量:

int RequiredCount;

在 OnInit() 函数中，我们计算它的值:

RequiredCount=N*2+2;

2*N 是构成形态的顶点的数量 (N 个顶部和 N 个底部). 另外一个顶点确定了之前价格的变化，而额外的一个点是新的之字转向片段(没有在计算中使用)的最后一个点。

更多的操作将在 OnTick() 函数中进行，新的代码将会加在住指标循环的最后。如果之字转向点的数量足够并且只有在它方向改变时，才将检查形态形成的条件，价格和水平将在每个之字转向变化时作检查:

if(CurCount>=RequiredCount){
   if(CurDir!=PreDir){      
      // 检查条件

   }
   // 检查价格和水平级别

} 

首先，我们计算基础数值，也就是片段 1-2 的高度(参见图14)，这个值将在检查所有形态形成条件的时候使用。然后，检查任务1的条件，也就是之前的价格变化

int li=CurCount-RequiredCount;                                            // 初始形态点在 PeackTrough 数组中的索引
double base=MathAbs(PeackTrough[li+1].Val-PeackTrough[li+2].Val);        // 基础数值
double l1=MathAbs(PeackTrough[li+1].Val-PeackTrough[li].Val);             // 片段 1-2 的高度
   if(l1>=base*K1){                                                       // 检查之前价格变化的大小
        // 其它的检查

   }

进一步的检查将依赖于之字转向的最后片段是指向上涨还是下跌。

if(CurDir==1){              // 最后的之字转向片段指向上涨
   // 检查上涨方向的条件  
             
}
else if(CurDir==-1){        // 最后的之字转向片段指向下跌
   // 检查下跌方向的条件

}

让我们讨论上涨方向条件的检查:

if(CheckForm(li,base) && CheckInclineForBuy(li,base)){      // 检查形态和方向
   if(CompletionType==Immediately){ 
      // 画出指标箭头
      UpArrowBuffer[i]=low[i];
      // 画出目标点
      UpDotBuffer[i]=PeackTrough[CurCount-1].Val+l1;
   }
   else{
      // 设置突破水平参数
      SetLevelParameters(1);
      // 设置目标参数
      SetTarget(1,li);
   }
} 

形态形成条件是使用两个函数作检查的: CheckForm() 来检查形态的形状，而 CheckInclineForBuy() 来检查倾斜度。如果成功检查了形状和倾斜，那么就根据形态完成的类型，在图表上画出箭头或者目标点，或者突破水平的参数。

CheckForm() 函数。形态中第一个点在 PeackTrough 数组中的索引基础数值 ‘base’ 会传给函数，这里是函数的代码:

bool CheckForm(int li,double base){               
   switch(Pattern){
      case PatternTapered: 
         // 收敛
         return(CheckFormTapered(li,base));
      break;               
      case PatternRectangular: 
         // 长方形
         return(CheckFormRectangular(li,base));
      break;
      case PatternExpanding: 
         // 扩张
         return(CheckFormExpanding(li,base));
      break;
   }
   return(true);
}

在函数中，会根据 Pattern 参数的值调用适当的函数: 对于收敛三角形调用 CheckFormTapered(), 对于长方形形态调用 CheckFormRectangular(), 对于扩张三角形调用 CheckFormExpanding()。

CheckFormTapered() 函数:

bool CheckFormTapered(int li,double base){
   // 从1开始循环，不检查第一个片段,
   // 但是所有随后的片段都会相对它做检查 
   for(int i=1;i<N;i++){ 
      // 计算形态中下一个顶部点的索引
      int j=li+1+i*2;
      // 下一个片段的数值 
      double lv=MathAbs(PeackTrough[j].Val-PeackTrough[j+1].Val);
      // 前一个片段的数值
      double lp=MathAbs(PeackTrough[j-2].Val-PeackTrough[j-1].Val);
      // 前一个片段应该更大，否则
      // 函数返回 false   
      if(!(lp-lv>K2*base)){
         return(false);
      }
   } 
   return(true);
}

在函数中，构成形态的之字转向片段在一个循环中做检查，而每个后面的片段必须小于前一个。

CheckFormExpanding() 函数类似，只有一点区别:

if(!(lv-lp>K2*base)){
   return(false);
}

为了达成这个条件，每个后面的片段必须比前一个片段要大。

CheckFormRectangular() 函数:

bool CheckFormRectangular(int li,double base){   
   // 在除了第一个片段之外的所有片段做循环      
   for(int i=1;i<N;i++){
      // 计算下一个顶部的索引 
      int j=li+1+i*2; 
      // 计算下一个片段的大小
      double lv=MathAbs(PeackTrough[j].Val-PeackTrough[j+1].Val);
      // 片段应该和基础数值相差不大 
      if(MathAbs(lv-base)>K2*base){
         return(false); 
      }
   }
   return(true);
}

在这个函数中，每个片段都和基础数值作比较，如果差别很大，函数就返回 false。

如果形状检查成功，就检查它的倾斜度。CheckInclineForBuy() 函数:

bool CheckInclineForBuy(int li,double base){                 
   switch(Incline){
      case InclineAlong:
         // 在价格移动方向上的倾斜
         return(CheckInclineUp(li,base));
      break;
      case InclineHorizontally:
         // 没有倾斜
         return(CheckInclineHorizontally(li,base));
      break;                     
      case InclineAgainst:
         // 倾斜方向与价格移动方向相反
         return(CheckInclineDn(li,base));
      break;
   } 
   return(true);
}  

用于卖出的倾斜检查函数只有两行不同:

bool CheckInclineForSell(int li,double base){                 
   switch(Incline){
      case InclineAlong:
         // 在价格移动方向上的倾斜
         return(CheckInclineDn(li,base));
      break;
      case InclineHorizontally:
         // 没有倾斜
         return(CheckInclineHorizontally(li,base));
      break;                     
      case InclineAgainst:
         // 倾斜方向与价格移动方向相反
         return(CheckInclineUp(li,base));
      break;
   } 
   return(true);
} 

如果 Incline 等于 InclineAlong (与移动方向相同), 买入就调用 CheckInclineUp() 而卖出则调用 CheckInclineDn()。如果 Incline = InclineAgainst 就相反。

CheckInclineUp(), 该函数用于检查形态的向上倾斜:

bool CheckInclineUp(int li,double base){   
   // 在除了第一个片段之外的所有片段做循环      
   for(int v=1;v<N;v++){
      // 计算下一个顶部的索引
      int vi=li+1+v*2;
      // 计算下一个之字转向片段的中部
      double mc=(PeackTrough[vi].Val+PeackTrough[vi+1].Val)/2;
      // 计算前一个之字转向片段的中部
      double mp=(PeackTrough[vi-2].Val+PeackTrough[vi-1].Val)/2;
      // 下一个片段应该比前一个更高
      if(!(mc>mp+base*K3)){
         return(false);
      }
   }
   return(true);
} 

所有的之字转向片段都在函数中作检查: 计算每个片段的中部，并且与前一个片段的中部作比较，每个片段应该高于它前一个片段 base*K3 的数值。

CheckInclineDn() 函数有一点差别:

if(!(mc<mp-base*K3)){
   return(false);
}

为了满足这个条件，每个后续片段必须比前一个要小。

CheckInclineHorizontally() 函数:

bool CheckInclineHorizontally(int li,double base){ 
   // 基础片段的中点
   double mb=(PeackTrough[li+1].Val+PeackTrough[li+2].Val)/2;        
   for(int v=1;v<N;v++){
      // 下一个顶部的索引
      int vi=li+1+v*2;
      // 下一个片段的中点
      double mc=(PeackTrough[vi].Val+PeackTrough[vi+1].Val)/2;
      // 下一个片段的中点 
      // 和基础片段的中点不能偏移太多
      if(MathAbs(mc-mb)>base*K3){
         return(false);
      }
   }                  
   return(true);
}

如果检查形状和倾斜成功，就执行以下的代码部分:

if(CompletionType==Immediately){                    // 立即入场
   UpArrowBuffer[i]=low[i];
   UpDotBuffer[i]=PeackTrough[CurCount-1].Val+l1;
}
else{                                               // 等待水平的突破
   SetLevelParameters(1);
   SetTarget(1,li);
}

如果形态结束设为 Immediately, 指标就画出箭头并设置目标点，在其它情况下就使用 SetLevelParameters() 函数来设置突破水平，而使用 SetTarget() 函数来设置目标。

SetLevelParameters() 函数:

void SetLevelParameters(int dir){
   CurLevel.dir=dir;   
   switch(CompletionType){
      case OneLastVertex:                            // 根据一个点
          CurLevel.v=PeackTrough[CurCount-3].Val;
      break;
      case TwoLastVertices:                          // 根据两个点
         CurLevel.x1=PeackTrough[CurCount-5].Bar;
         CurLevel.y1=PeackTrough[CurCount-5].Val;
         CurLevel.x2=PeackTrough[CurCount-3].Bar;
         CurLevel.y2=PeackTrough[CurCount-3].Val;
      break;
   }
} 

在 SetLevelParameters() 函数中，SLevelParameters 结构用于保存水平参数:

struct SLevelParameters{
   int x1;
   double y1;
   int x2;
   double y2;       // 从 x1 到 y2 - 倾斜水平参数
   double v;        // 水平级别的数值
   int dir;         // 方向
   double target;   // 目标
   // 用于计算倾斜水平数值的方法
   double y3(int x3){
      if(CompletionType==TwoLastVertices){
            return(y1+(x3-x1)*(y2-y1)/(x2-x1));
      }
      else{
         return(v);
      }
   }
   // 用于初始化或者重置参数的方法
   void Init(){
      x1=0;
      y1=0;
      x2=0;
      y2=0;
      v=0;
      dir=0;   
   }
};

该结构包含了线形参数的栏位: x1, y1, x2, y2; 栏位 ‘v’ 用于水平级别数值; ‘d’ 是形态的方向; ‘target’ 是目标。目标可以设为价格水平 (当使用 FromVertexToVertex 时) 或者是突破水平的数值 (当使用 OneVertex 或者 TwoVertices 时)。y3() 方法用于计算倾斜水平的数值，Init() 方法用于初始化或者重置数值，

如果所有的形态生成条件都满足，就调用 SetLevelParameter() 函数。根据所选水平的类型 (水平或者倾斜)，倾斜水平参数(栏位 x1, y1, x2, y2) 或者一个水平级别数值 ‘v’ 会在这个函数中设置。在 y3() 方法中, 水平数值是使用 x1, y1, x2, y2 栏位或者返回的 ‘v’ 栏位数值计算的。

在指标中声明了两个 SLevelParameters 类型的变量:

SLevelParameters CurLevel;
SLevelParameters PreLevel;

这对变量的使用和变量 CurCount-PreCount 以及 CurDir-PreDir 类似, 变量的数值在指标初始计算时会重置 (代码部分位于 OnTick() 函数的开头):

int start;

if(prev_calculated==0){           // 第一次计算全部柱
   start=1;      
   CurCount=0;
   PreCount=0;
   CurDir=0;
   PreDir=0;  
   CurLevel.Init();    
   CurLevel.Init();
   LastTime=0;
}
else{                           // 计算新柱和生成的柱
   start=prev_calculated-1;
}

在每个柱的计算中，这些变量的数值会有变化(代码位于指标循环的开始):

if(time[i]>LastTime){
   // 新柱的第一次计算
   LastTime=time[i];
   PreCount=CurCount;
   PreDir=CurDir;
   PreLevel=CurLevel;
}
else{
   // 重新计算柱
   CurCount=PreCount;
   CurDir=PreDir;
   CurLevel=PreLevel;
}

目标参数是通过 SetTarget() 函数调用的:

void SetTarget(int dir,int li){
   switch(Target){
      case FromVertexToVertex:
         //  '从顶点到顶点'的版本
         if(dir==1){
            CurLevel.target=PeackTrough[CurCount-1].Val+(PeackTrough[li+1].Val-PeackTrough[li].Val);
         }
         else if(dir==-1){
            CurLevel.target=PeackTrough[CurCount-1].Val-(PeackTrough[li].Val-PeackTrough[li+1].Val);
         }
      break;
      case OneVertex:
         // 使用一个顶点
         CurLevel.target=MathAbs(PeackTrough[li].Val-PeackTrough[li+2].Val);
      break;
      case TwoVertices:
         // 使用两个顶点
         SetTwoVerticesTarget(dir,li);
      break;
   }
}

为 FromVertexToVertex 要计算一个价格值。对于 OneVertex, 价格变化的数值是从突破水平到目标，赋值到 ‘target’ 栏位。在 SetTwoVerticesTarget() 函数中计算 SetTwoVerticesTarget :

void SetTwoVerticesTarget(int dir,int li){
   // 形态中初始线的坐标
   //  - 从底部到顶部  
   double x11=PeackTrough[li].Bar;
   double y11=PeackTrough[li].Val;
   double x12=PeackTrough[li+1].Bar;
   double y12=PeackTrough[li+1].Val;
   // 通过两个底部画线用于买入的坐标
   // 或者通过两个顶部画线用于卖出
   double x21=PeackTrough[li+2].Bar;
   double y21=PeackTrough[li+2].Val;
   double x22=PeackTrough[li+4].Bar;
   double y22=PeackTrough[li+4].Val;
   // 线的交叉点的数值
   double t=TwoLinesCrossY(x11,y11,x12,y12,x21,y21,x22,y22);
   // 根据方向设置目标数值
   if(dir==1){
      CurLevel.target=t-PeackTrough[li].Val;
   }
   else if(dir==-1){
      CurLevel.target=PeackTrough[li].Val-t;         
   }
}

对于 SetTwoVerticesTarget 版本, ‘target’ 栏位的赋值为从突破水平到目标的价格移动，与 OneVertex 类似。

让我们探讨价格和水平跟踪是如何进行的 (CompletionType 不等于 Immediately):

// 使用水平级别
if(CompletionType!=Immediately){
   // 之字转向有变化
   if(PeackTrough[CurCount-1].Bar==i){
      if(CurLevel.dir==1){                // 等待向上突破
         // 把水平数值赋予 cl 变量
         double cl=CurLevel.y3(i); 
         // 之字转向突破了水平级别
         if(PeackTrough[CurCount-1].Val>cl){
            // 设置向上箭头
            UpArrowBuffer[i]=low[i];
            // 设置目标点
            if(Target==FromVertexToVertex){
               // 'target' 栏位中的价格
               UpDotBuffer[i]=CurLevel.target;                        
            }
            else{
               // 与 'target' 栏位中水平的距离
               UpDotBuffer[i]=cl+CurLevel.target;
            }
            // 清零 'dir' 栏位以停止跟踪水平
            CurLevel.dir=0;
         }
      }
      else if(CurLevel.dir==-1){         // 等待向下突破
         // 把水平数值赋予 cl 变量
         double cl=CurLevel.y3(i);
         // 之字转向突破了水平级别
         if(PeackTrough[CurCount-1].Val<cl){
            // 设置向下箭头
            DnArrowBuffer[i]=low[i];
            // 设置目标点
            if(Target==FromVertexToVertex){
               // 'target' 栏位中的价格
               DnDotBuffer[i]=CurLevel.target;
            }
            else{                     
               // 与 'target' 栏位中水平的距离
               DnDotBuffer[i]=cl-CurLevel.target;
            }
            // 清零 'dir' 栏位以停止跟踪水平
            CurLevel.dir=0;
         }         
      }         
   }
} 

这个检查是在每次之字转向有变化的时候进行的，所有的之字转向峰值都保存在 PeackTrough 数组中，改变是由最新之字转向点对当前柱索引变化来确定的:

if(PeackTrough[CurCount-1].Bar==i){

当前的水平数值使用 y3() 方法来计算:

double cl=CurLevel.y3(i); 

要检查最新的之字转向片段是否突破了这一水平:

if(PeackTrough[CurCount-1].Val>cl){

如果水平被突破，指标就画出箭头并加上目标点，’target’ 栏位可能包含目标的价格数值，在这种情况下直接使用这个数值。它也可能包含和目标的距离，在这种情况下目标是根据当前价格水平数值来计算的: 

if(Target==FromVertexToVertex){
   UpDotBuffer[i]=CurLevel.target;                        
}
else{
   UpDotBuffer[i]=cl+CurLevel.target;
}

最后，’dir’ 栏位要重置来停止跟踪价格，直到下一个形态出现:

CurLevel.dir=0;

现在，指标的创建就结束了，一些它运行的片段显示在图15中。

图 15. iHorizontalFormation 指标的信号

指标中还加入了一个提醒的功能，可用的指标放在下面的附件中，文件名为 iHorizontalFormation。

用于搜索旗形，三角旗形和楔形的通用指标

input int                  ATRPeriod            =  50;
input double               K1                   =  3;

int h;

h=iATR(Symbol(),Period(),ATRPeriod);
if(h==INVALID_HANDLE){
   Alert("载入指标出错");
   return(INIT_FAILED);
}

double atr[1];
if(CopyBuffer(h,0,rates_total-i-1,1,atr)==-1){
   return(0);
}

if(high[i]-low[i]>atr[0]*K1){    // 长柱形
   if(close[i]>open[i]){         // 柱为上涨方向
      Cur.Whait=1;
      Cur.Count=0;
      Cur.Bar=i;
   }
   else if(close[i]<open[i]){    // 柱为下跌方向
      Cur.Whait=-1;   
      Cur.Count=0;
      Cur.Bar=i;
   }
}

struct SCurPre{
   int Whait;
   int Count;
   int Bar;
   void Init(){
      Whait=0;
      Count=0;
      Bar=0;
   }
};

static datetime LastTime=0;   
static SCurPre Cur;          
static SCurPre Pre;

int start=0;

if(prev_calculated==0){           // 第一次计算指标
   
   start=1;      
   
   Cur.Init();
   Pre.Init();             
     
   LastTime=0;      
}
else{                             // 计算新柱和正在生成的柱
   start=prev_calculated-1;
}

if(time[i]>LastTime){       // 第一次计算一个柱
   LastTime=time[i];
   Pre=Cur;              
}
else{                      // 重新计算一个柱
   Cur=Pre;
}  

if(Cur.Whait!=0){
   Cur.Count++;            // 计算柱数
   if(Cur.Count>=3){
      // 进一步检查

   }
}

Overlapping=MathMin(high[i],high[i-1])-MathMax(low[i],low[i-1]);

double PreSize=MathMax(high[i-1]-low[i-1],high[i]-low[i]);

if(!(Overlapping>=PreSize*MinOverlapping))

if(Cur.Count-2>=MinCount){
   // 进一步检查
}
Cur.Whait=0;

input double               MinOverlapping       =  0.4;
input int                  MinCount             =  5;

double AverSize,AverBias,AverSizeDif;
PatternParameters(high,low,i-1,Cur.Count-2,AverSize,AverBias,AverSizeDif);

void PatternParameters( const double & high[],
                        const double & low[],
                        int i,
                        int CurCnt,
                        double & AverSize,
                        double & AverBias,
                        double & AverSizeDif
){
            
   // 平均柱大小            
   AverSize=high[i-CurCnt]-low[i-CurCnt];
   // 平均柱偏移
   AverBias=0;
   // 两个邻近柱偏差的平均值
   AverSizeDif=0;
   
   for(int k=i-CurCnt+1;k<i;k++){      // 序列中除了第一个柱的所有柱
      // 平均大小
      AverSize+=high[k]-low[k];
      // 平均偏移
      double mc=(high[k]+low[k])/2;
      double mp=(high[k-1]+low[k-1])/2;
      AverBias+=(mc-mp);
      // 平均大小的偏差
      double sc=(high[k]-low[k]);
      double sp=(high[k-1]-low[k-1]);
      AverSizeDif+=(sc-sp);               
      
   }
   
   // 总数除以数量
   AverSize/=CurCnt;
   AverBias/=(CurCnt-1);
   AverSizeDif/=(CurCnt-1); 
} 

for(int k=i-CurCnt+1;k<i;k++)

AverSize+=high[k]-low[k];

double mc=(high[k]+low[k])/2;
double mp=(high[k-1]+low[k-1])/2;
AverBias+=(mc-mp);

double sc=(high[k]-low[k]);
double sp=(high[k-1]-low[k-1]);
AverSizeDif+=(sc-sp);    

AverSize/=CurCnt;
AverBias/=(CurCnt-1);
AverSizeDif/=(CurCnt-1); 

if(   FormTapered(AverSizeDif,AverSize) ||
      FormHorizontal(AverSizeDif,AverSize) ||
      FormExpanding(AverSizeDif,AverSize)
){ 
   // 检查方向
}

input bool                 FormTapered          =  true;
input double               FormTaperedK         =  0.05;
input bool                 FormRectangular      =  true;
input double               FormRectangularK     =  0.33;
input bool                 FormExpanding        =  true;
input double               FormExpandingK       =  0.05;

bool FormTapered(double AverDif, double AverSize){
   return(FormTapered && AverDif<-FormTaperedK*AverSize);
}

bool FormHorizontal(double AverDif, double AverSize){
   return(FormRectangular && MathAbs(AverDif)<FormRectangularK*AverSize);
}

bool FormExpanding(double AverDif, double AverSize){
   return(FormExpanding && AverDif>FormExpandingK*AverSize);
}

if(Cur.Whait==1){
   if(CheckInclineForBuy(AverBias/AverSize)){
      // 再检查上涨方向

   }
}
else if(Cur.Whait==-1){
   if(CheckInclineForSell(AverBias/AverSize)){   
      // 再检查下跌方向

   }
}

input bool                 InclineAlong         =  true;
input double               InclineAlongK        =  0.1;
input bool                 InclineHorizontal    =  true;
input double               InclineHorizontalK   =  0.1;
input bool                 InclineAgainst       =  true;
input double               InclineAgainstK      =  0.1;

bool CheckInclineForBuy(double Val){
   return(  (InclineAlong && Val>InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val<-InclineAgainstK)
   );
}   

bool CheckInclineForBuy(double Val){
   return(  (InclineAlong && Val>InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val<-InclineAgainstK)
   );
}   

bool CheckInclineForSell(double Val){
   return(  (InclineAlong && Val<-InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val>InclineAgainstK)
   );
}  

input bool                 EnterAlong           =  true;
input bool                 EnterAgainst         =  true;

if((EnterAlong && close[i]>open[i]) || (EnterAgainst && close[i]<open[i])){
   Label1Buffer[i]=low[i];
   Label3Buffer[i]=close[i]+(high[Cur.Bar]-low[Cur.Bar]);
}

if((EnterAlong && close[i]<open[i]) || (EnterAgainst && close[i]>open[i])){
   Label2Buffer[i]=high[i];                  
   Label4Buffer[i]=close[i]-(high[Cur.Bar]-low[Cur.Bar]);
}

input int                  ID             =  1;

string ShortName=MQLInfoString(MQL_PROGRAM_NAME)+"-"+IntegerToString(ID);
IndicatorSetString(INDICATOR_SHORTNAME,ShortName);

int ForTester=0;       // 一个用于此数值的变量
if(!(SrcSelect==Src_HighLow)){
   // 在已经完成的柱上工作
   ForTester+=10;
}   
if(!(SrcSelect==Src_HighLow || SrcSelect==Src_Close)){
   // 可以使用目标点
   ForTester+=1;
}     
UpArrowBuffer[0]=ForTester;  

string ShortName=MQLInfoString(MQL_PROGRAM_NAME)+"-"+IntegerToString(ID);
IndicatorSetString(INDICATOR_SHORTNAME,ShortName);

Label1Buffer[0]=11;

input int                  ID             =  1;
input double               StopLoss_K     =  1;
input bool                 FixedSLTP      =  false;
input int                  StopLoss       =  50;
input int                  TakeProfit     =  50;

string IndName;

IndName=MQLInfoString(MQL_PROGRAM_NAME);

struct SPos{
   int dir;
   double price;
   double sl;
   double tp;
   datetime time; 
};
SPos Pos[];
int PosCnt;

datetime LastPosTime;

int Closed;
datetime CloseTime;

string name;
static int last_handle=-1;
static int shift=0;
static int use_target=0;
int handle=-1;     
int start=2;  

int it=ChartIndicatorsTotal(0,0);

for(int i=0;i<it;i++){        // 图表上的全部指标
   // 取得下一个指标的名称
   name=ChartIndicatorName(0,0,i);
   // 搜索子字符串 "-"
   int p=StringFindRev(name,"-");
   if(p!=-1){
      // 找到了子字符串，检查标识符的值
      if(StringSubstr(name,p+1,StringLen(name)-p-1)==IntegerToString(ID)){
         // ID 对应，取得句柄
         handle=ChartIndicatorGet(0,0,name);
      }
   }
} 

if(handle!=last_handle){
   if(handle==-1){                    // 没有句柄
      // 设置源名称
      IndicatorSetString(INDICATOR_SHORTNAME,IndName);
      ChartRedraw(0);
      return(0);
   }
   // 检查测试指标的计算是否已经结束
   int bc=BarsCalculated(handle);
   if(bc<=0)return(0);                // 如果没有，函数就中断
   // 使用测试参数复制数据
   double sh[1];
   if(CopyBuffer(handle,0,rates_total-1,1,sh)==-1){
      // 如果复制失败，函数就中断直到
      // 下一个分时
      return(0);
   }
   // 展开独立的参数
   shift=((int)sh[0])/10;              // 已完成或是正在出现的柱
   use_target=((int)sh[0])%10;         // 是否使用目标点?
   last_handle=handle;                 // 保存句柄数值
   // 设置指标名称
   IndicatorSetString(INDICATOR_SHORTNAME,name);
   ChartRedraw(0);
}
else if(prev_calculated!=0){
   // 如果没有新的句柄，只计算新柱, 
   // 还有当前正在形成的柱
   start=prev_calculated-1;
}

if(start==2){
   PosCnt=0;
   BalanceBuffer[1]=0;
   EquityBuffer[1]=0;
   LastPosTime=0;
   Closed=0;
   CloseTime=0;      
}

for(int i=start;i<rates_total;i++){

   // 传入之前知道的余额和净值
   BalanceBuffer[i]=BalanceBuffer[i-1];
   EquityBuffer[i]=EquityBuffer[i-1];

   if(CloseTime!=time[i]){ 
      // 开始新柱的计算
      Closed=0; // 把利润变量清零
      CloseTime=time[i];          
   }

   // 取得测试指标的数据
   double buy[1],sell[1],buy_target[1],sell_target[1],enter[1];
   int ind=rates_total-i-1+shift;
   if(CopyBuffer(last_handle,0,ind,1,buy)==-1 || 
      CopyBuffer(last_handle,1,ind,1,sell)==-1 ||
      CopyBuffer(last_handle,2,ind,1,buy_target)==-1 || 
      CopyBuffer(last_handle,3,ind,1,sell_target)==-1        
   ){
      return(0);
   }
  
   if(shift==0){
      // 如果测试是在正在出现的柱上进行的，取得开盘价格 
      // 要从测试指标的额外缓冲区中取得       
      if(CopyBuffer(last_handle,4,ind,1,enter)==-1){
         return(0);
      } 
   }
   else{
      // 如果测试是在已经完成的柱上进行的，我们使用柱的
      // 开盘价格
      enter[0]=open[i];
   }

   // 买入箭头
   if(buy[0]!=EMPTY_VALUE){
      AddPos(1,enter[0],buy_target[0],spread[i],time[i],use_target);      
   }
   // 卖出箭头
   if(sell[0]!=EMPTY_VALUE){
      AddPos(-1,enter[0],sell_target[0],spread[i],time[i],use_target);       
   }

   // 检查是否需要平仓
   CheckClose(i,high,low,close,spread);

   // 余额线
   BalanceBuffer[i]+=Closed;
   
   // 净值线
   EquityBuffer[i]=BalanceBuffer[i]+SolveEquity(i,close,spread);

}

// 传入之前所知的余额和净值
BalanceBuffer[i]=BalanceBuffer[i-1];

在每个柱的第一次计算中，这个柱上的平仓利润变量要被清零:

if(CloseTime!=time[i]){ 
   Closed=0;
   CloseTime=time[i];          
}

复制测试指标的数据:

// 取得测试指标的数据
double buy[1],sell[1],buy_target[1],sell_target[1],enter[1];
int ind=rates_total-i-1+shift;
if(CopyBuffer(last_handle,0,ind,1,buy)==-1 || 
   CopyBuffer(last_handle,1,ind,1,sell)==-1 ||
   CopyBuffer(last_handle,2,ind,1,buy_target)==-1 || 
   CopyBuffer(last_handle,3,ind,1,sell_target)==-1        
){
   return(0);
}

箭头缓冲区的数据被复制到 ‘buy’ 和 ‘sell’ 数组中，目标点的数据复制到 ‘buy_target’ 和 ‘sell_target’。在复制之前，要考虑到 shift 偏移变量来计算柱的索引 ‘ind’，

根据 ‘shift’的值, 看是复制额外缓冲区或者柱的开盘价:

if(shift==0){
   // 如果测试是在正在出现的柱上进行的，取得开盘价格 
   // 要从测试指标的额外缓冲区中取得       
   if(CopyBuffer(last_handle,4,ind,1,enter)==-1){
      return(0);
   } 
}
else{
   // 如果测试是在已经完成的柱上进行的，我们使用柱的
   // 开盘价格
   enter[0]=open[i];
}

如果在计算的柱上找到了箭头，就通过调用 AddPos() 函数来建立仓位:

// 买入箭头
if(buy[0]!=EMPTY_VALUE){
   AddPos(1,enter[0],buy_target[0],spread[i],time[i],use_target);      
}
// 卖出箭头
if(sell[0]!=EMPTY_VALUE){
   AddPos(-1,enter[0],sell_target[0],spread[i],time[i],use_target);       
}

在 CheckClose() 函数中检查仓位是否需要关闭，如果仓位关闭，利润结果会保存到 Closed 变量中:

// 检查，是否需要平仓
CheckClose(i,high,low,close,spread);

Closed 变量中的利润要加到余额中:

// 余额线
BalanceBuffer[i]+=Closed;

净值是由余额和浮盈共同组成，通过 SolveEquity() 函数计算所得的:

EquityBuffer[i]=BalanceBuffer[i]+SolveEquity(i,close,spread);

让我们讨论下面的函数: AddPos(), CheckClose(), SolveEquity(). 以下是每个函数的代码，都带有详细描述。  

AddPos():

void AddPos(int dir, double price,double target,int spread,datetime time,bool use_target){

   if(time<=LastPosTime){
      // 带有 'time' 时间的仓位已经被加过了
      return;
   }
   
   // 数组中没有空闲空间
   if(PosCnt>=ArraySize(Pos)){
      // 数组大小增加32个元素块大小
      ArrayResize(Pos,ArraySize(Pos)+32);
   }
   
   // 保存仓位的方向
   Pos[PosCnt].dir=dir;
   // 仓位建立时间
   Pos[PosCnt].time=time;
   // 仓位的开盘价格
   if(dir==1){
      // 买入的价格
      Pos[PosCnt].price=price+Point()*spread;  
   }
   else{
      // 卖出的价格
      Pos[PosCnt].price=price;  
   }

   // 计算止损和获利
   if(use_target && !FixedSLTP){ 
      // 使用目标点来计算止损
      if(dir==1){
         Pos[PosCnt].tp=target;
         Pos[PosCnt].sl=NormalizeDouble(Pos[PosCnt].price-StopLoss_K*(Pos[PosCnt].tp-Pos[PosCnt].price),Digits());
      }
      else{
         Pos[PosCnt].tp=target+Point()*spread;
         Pos[PosCnt].sl=NormalizeDouble(Pos[PosCnt].price+StopLoss_K*(Pos[PosCnt].price-Pos[PosCnt].tp),Digits());
      }   
   }
   else{
      // 使用 StopLoss 和 TakeProfit 变量来止损
      if(dir==1){
         Pos[PosCnt].tp=Pos[PosCnt].price+Point()*TakeProfit;
         Pos[PosCnt].sl=Pos[PosCnt].price-Point()*StopLoss;
      }
      else{
         Pos[PosCnt].tp=Pos[PosCnt].price-Point()*TakeProfit;
         Pos[PosCnt].sl=Pos[PosCnt].price+Point()*StopLoss;
      }     
   }
   
   PosCnt++;
   
}  

CheckClose() 函数:

void CheckClose(int i,const double & high[],const double & low[],const double & close[],const int & spread[]){
   for(int j=PosCnt-1;j>=0;j--){                                       // 所有仓位
      bool closed=false;                                               // 'false' 值表示仓位依然开启  
      if(Pos[j].dir==1){                                               // 买入
         if(low[i]<=Pos[j].sl){                                        // 价格低于或者等于止损
            // 利润点数
            Closed+=(int)((Pos[j].sl-Pos[j].price)/Point());
            closed=true;                                               // 以j为索引的仓位已经平仓
         }
         else if(high[i]>=Pos[j].tp){                                  // 已经达到了获利
            // 利润点数
            Closed+=(int)((Pos[j].tp-Pos[j].price)/Point());    
            closed=true;                                               // 以j为索引的仓位已经平仓
         }
      }
      else{ // Selling
         if(high[i]+Point()*spread[i]>=Pos[j].sl){                     // 已经达到了止损
            // 利润点数
            Closed+=(int)((Pos[j].price-Pos[j].sl)/Point());
            closed=true;                                               // 以j为索引的仓位已经平仓
         }
         else if(low[i]+Point()*spread[i]<=Pos[j].tp){                 // 价格低于或者等于获利
            // 利润点数
            Closed+=(int)((Pos[j].price-Pos[j].tp)/Point());              
            closed=true;                                               // 以j为索引的仓位已经平仓
         }         
      }
      // 仓位已经关闭，它应当从数组中删除
      if(closed){ 
         int ccnt=PosCnt-j-1;
         if(ccnt>0){
            ArrayCopy(Pos,Pos,j,j+1,ccnt);
         }
         PosCnt--;
      }
   }
}

在 CheckClose() 函数中，所有仓位都保存在 Pos 数组中，检查它们的止损和获利，并与最高价和最低价做比较，如果仓位平仓，它的利润加到 Closed 变量中，随后仓位要从数组中删除。

SolveEquity():

int SolveEquity(int i,const double & close[],const int & spread[]){
   int rv=0;                                // 用于结果的变量
   for(int j=PosCnt-1;j>=0;j--){            // 所有仓位
      if(Pos[j].dir==1){                    // 买入
                                            // 利润
         rv+=(int)((close[i]-Pos[j].price)/Point());
      }
      else{                                // 卖出
         // 利润
         rv+=(int)((Pos[j].price+Point()*spread[i]-close[i])/Point());         
      }
   }
   return(rv);
}  

SolveEquity() 函数计算来自 Pos 数组的所有开启仓位的利润。

我们已经结束了 iTester 指标的分析，可用的 iTester 指标可以在附件中找到。图 17 显示了带有 iHorizontalFormation (箭头) 的图表，而 iTester 位于子窗口中，绿色线显示的是净值，而红色线显示余额。

图 17. iTester 指标 (位于子窗口中), 基于 iHorizontalFormation (图表上的箭头)

结论

在本文中描述的形态侦测方法解决了初始的任务，所以各种形状，例如旗形、三角旗形、三角形和楔形都可以在图表上清楚看到。探讨的方法不仅是可行的而且是绝对正确的。也可能有其他方法来识别相同的形态，例如，您可以使用线性回归，使用最高价和最低价进行独立的计算，然后检查斜率和这些线的聚合/分离。如果我们处理单个子任务，还会有更多的可用方法，可以用来解决侦测形态中的一般难点。尽管这样，在本文中讨论的在创建指标时的价格分析方法对于其他技术分析相关目标也是有所帮助的。 

附件

我们在文章中创建的所有指标都在下面的附件中，包括:

• iHorizontalFormation
• iFlag
• iTester