如何显示支撑/阻力位？

geek005

简介

文章涉及在 MetaTrader 4 程序中探明和指示支撑/阻力位。 基于简单的算法，方便又通用的指标 FindLevels 在符号图表创建水平支撑线。 参见下文：

本文同时探讨了一个有用的主题，即创建能够在一个工作空间显示不同时间范围结果的简单指标。 示例如下。

第一个指标显示了基于 30 分钟报价的支撑位（米黄色粗线）。 同一窗口内运行的第二个指标显示了 30 分钟位置上方基于 15 分钟时间范围的位置（紫色细短划线）。 详情请参阅“指标相互作用”部分。

理论综述

现在来描述检测支撑/阻力位的算法，它将在 FindLevels 指标中进一步实现。 支撑/阻力位是由于外力而无法产生交叉的价格值。 外力可能由心理指标、大型交易者的影响或者该区域内的巨量止损订单导致。 显然，比起其他的非支撑线，报价与该线交叉的频率低的多。 在很多交易书籍中可以发现这种事实的佐证。

为了利用这一现象，我们必须计算交叉每个价格的柱的数量。 这是前文中所描述计算的结果。

图像中的横轴是价格，纵轴是交叉价格的柱的数量。 如图所示，图表中有很多局部最小值。 局部最小值是属于非零区间的一个点，其自身是该区间的最小值。 现在必须根据某种特征选择局部最小值。

首先，要设置区域半径常量 MaxR。 如果局部最小值不是属于 MaxR 半径区域的最小值，则不符合我们的要求。 其次，设置 MaxCrossesLevel 参数。 如果函数的最大值和最小值之差小于 MaxR 区域的 MaxCrossesLevel，则不显示该局部最小值，因为它不够显著。 这是检测支撑/阻力位的机制。 遵循这个简单的算法，我们来编写指标。

辅助函数

如上所述，FindLevels 指标设计用于处理任何时间范围的报价。 时间范围由用户设置（TimePeriod 变量）。 出于代码简单性的考虑，设置两个不需要额外解释的简单函数：

1. double prLow(int i)
   
2.   {
   
3.     return (iLow(NULL,TimePeriod,i));
   
4.   }
   
5. 
   
6. double prHigh(int i)
   
7.   {
   
8.     return (iHigh(NULL,TimePeriod,i));
   
9.   }

复制代码

为了便于显示取决于时间范围的支撑位、宽度、颜色和指示模式，第三和第四个函数非常必要。

1. int Period2Int(int TmPeriod)
   
2.   {
   
3.     switch(TmPeriod)
   
4.       {
   
5.         case PERIOD_M1  : return(0);
   
6.         case PERIOD_M5  : return(1);
   
7.         case PERIOD_M15 : return(2);
   
8.         case PERIOD_M30 : return(3);
   
9.         case PERIOD_H1  : return(4);
   
10.         case PERIOD_H4  : return(5);
    
11.         case PERIOD_D1  : return(6);
    
12.         case PERIOD_W1  : return(7);
    
13.         case PERIOD_MN1 : return(8);
    
14.       }      
    
15.     return (0);
    
16.   }
    
17. 
    
18. string Period2AlpthabetString(int TmPeriod)
    
19.   {
    
20.     return(Alphabet[Period2Int(TmPeriod)]);
    
21.   }

复制代码

设置函数 Period2AlphabetString() 的意义描述见“指标互相作用” 一节，Period2Int() 函数的使用详见下节。

编写指标

从由用户设置的外部变量入手：

1. extern int MaxLimit = 1000;
   
2. extern int MaxCrossesLevel = 10;
   
3. extern double MaxR = 0.001;
   
4. extern int TimePeriod = 0;
   
5. extern color LineColor = White;
   
6. extern int LineWidth = 0;
   
7. extern int LineStyle = 0;

复制代码

• MaxLimit - 所使用的历史柱的数量；
  
• MaxCrossesLevel – 局部最大值和局部最小值的最小差异（关于详细描述请参阅“理论综述”一节；
  
• MaxR – 检出的最小值所在区域的半径；
  
• TimePeriod – 用于检测支撑位的时间范围； 默认为映射窗口的时间范围；
  
• LineColor – 显示的线条颜色；
  
• LineWidth – 线条宽度，默认为 0；
  
• LineStyle – 线型，默认为 0。
  
  

如果 LineColor、LineWidth 或 LineStyle 值由用户默认设置，则执行 Init 程序时我们会根据时间范围将其变更为其他选项。 这样不同时间范围的线条视图就不会一致，容易进行区分。

1. int init()
   
2.   {
   
3.     if(TimePeriod == 0)
   
4.         TimePeriod = Period();
   
5. 
   
6.     if(TimePeriod != 0 && LineWidth == 0)
   
7.         if(Period2Int(TimePeriod) - Period2Int(Period()) >= 0)
   
8.             LineWidth = Widths[Period2Int(TimePeriod) - Period2Int(Period())];
   
9.         else
   
10.           {
    
11.             LineWidth = 0;
    
12.             if(LineStyle == 0)
    
13.                 LineStyle = STYLE_DASH;
    
14.           }
    
15. 
    
16.     if(TimePeriod != 0 && LineColor == White)
    
17.         LineColor = Colors[Period2Int(TimePeriod)];
    
18. 
    
19.     return(0);
    
20.   }

复制代码

如果 TimePeriod 值为默认，我们在第一行进行设置。 然后确定线条宽度。 跟图表（映射窗口）时间范围相关的 TimePeriod 值越多，线条越宽。 如果 TimePeriod 小于图表时段，则线条宽度等于 0 且为短划线。 每个时间期间都有自己的颜色。

Colors[] 和 Width[] 数组定义方式如下：

1. color  Colors[] = {Red,Maroon, Sienna, OrangeRed, Purple,I ndigo,
   
2.                    DarkViolet, MediumBlue, DarkSlateGray};
   
3. int    Widths[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

复制代码

让我们定义剩余的变量：

1. int CrossBarsNum[];
   
2. bool CrossBarsMin[];
   
3. double d1Num = 0.0, d2Num = 0.0;
   
4. datetime TMaxI = 0;

复制代码

• CrossBarsNum[] 数组 – 为每个价格指示柱的数量的数组；
  
• CrossBarsMin[] – 跟设定价格线是否为局部最小值相对应的数组；
  
• d1Num 和 d2Num – 属于从 0 到 MaxLimit 柱区间的最低价格和最高价格；
  
• TMaxI – 指示最后处理柱的时间。
  
  

1. #define MaxLines 1000
   
2. string LineName[MaxLines];
   
3. int LineIndex = 0;

复制代码

• axLines - 创建线条的最大数量；
  
  
• LineName[] – 线条名称的数组；
  
  
• LineIndex – LineName[] 数组中空单元的索引。
  
  
  

现在继续讲解函数 start()：

1. int counted_bars = IndicatorCounted();
   
2. int limit = MathMin(Bars - counted_bars, MaxLimit);
   
3. 
   
4. double d1 = prLow(iLowest(NULL, TimePeriod, MODE_LOW, limit, 0));
   
5. double d2 = prHigh(iHighest(NULL, TimePeriod, MODE_HIGH, limit, 0));

复制代码

我们使用自上一次提取指标以来尚未变化的柱数计算限值变量。d1 和 d2 是从 0 到限值的区间上的最低和最高价格。

1. if(d1Num != d1 || d2Num != d2)
   
2.   {
   
3.     ArrayResize(CrossBarsNum, (d2 - d1)*10000);
   
4.     ArrayResize(CrossBarsMin, (d2 - d1)*10000);
   
5. 
   
6.     if(d1Num != d1 && d1Num != 0.0)
   
7.       {
   
8.         ArrayCopy(CrossBarsNum, CrossBarsNum, 0, (d1Num - d1)*10000);
   
9.         ArrayCopy(CrossBarsMin, CrossBarsMin, 0, (d1Num - d1)*10000);
   
10.       }
    
11. 
    
12.     d1Num = d1;
    
13.     d2Num = d2;
    
14.   }

复制代码

在指标运行时，CrossBarsNum[] 和 CrossBarsMin[] 数组覆盖的价格缺口可能改变。 每次发生时，必须增加数组内单元的数量，必要时将其移到右侧。 如果新变量 d1 和 d2 跟上次运行函数 start() 时得到的变量 d1Num 和 d2Num 不匹配，则通常会发生。

1. for(double d = d1; d <= d2; d += 0.0001)
   
2.   {
   
3.     int di = (d - d1)*10000;
   
4.     for(int i = 1; i < limit; i++)
   
5.         if(d > prLow(i) && d < prHigh(i))
   
6.             CrossBarsNum[di]++;
   
7.     if(Time[limit] != TMaxI&&TMaxI != 0)
   
8.         if(d > prLow(iBarShift(NULL, 0, TMaxI)) &&
   
9.            d < prHigh(iBarShift(NULL, 0, TMaxI)))
   
10.             CrossBarsNum[di]--;
    
11.   }
    
12. TMaxI = Time[limit] - 1;

复制代码

在确保数组符合必要的大小后，开始计算每个价格的新柱数，并在柱交叉价位时增大 CrossBarsNum[] 值。 由于不断出现新柱，旧柱将从 [0 : limit] 区间除去。 因此，必须检查这种柱，以在出现交叉时减小 CrossBarsNum[] 值。 然后我们将最后计算的柱的时间分配给 TmaxI 变量。

1. double l = MaxR*10000;
   
2. for(d = d1 + MaxR; d <= d2 - MaxR; d += 0.0001)
   
3.   {
   
4.     di = (d - d1)*10000;
   
5.     if(!CrossBarsMin[di] && CrossBarsNum[ArrayMaximum(CrossBarsNum, 2*l, di - l)] -
   
6.        CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)] > MaxCrossesLevel &&
   
7.        CrossBarsNum[di] == CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)] &&
   
8.        CrossBarsNum[di-1] != CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)])
   
9.       {
   
10.         CrossBarsMin[di] = true;
    
11.         LineName[LineIndex] = Period2AlpthabetString(TimePeriod) + TimePeriod + "_" + d;
    
12.         ObjectCreate(LineName[LineIndex], OBJ_HLINE, 0, 0, d);
    
13.         ObjectSet(LineName[LineIndex], OBJPROP_COLOR, LineColor);
    
14.         ObjectSet(LineName[LineIndex], OBJPROP_WIDTH, LineWidth);
    
15.         ObjectSet(LineName[LineIndex], OBJPROP_STYLE, LineStyle);
    
16.         LineIndex++;
    
17.       }
    
18.     if(CrossBarsMin[di] && CrossBarsNum[di] !=
    
19.        CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)])
    
20.       {
    
21.         CrossBarsMin[di] = false;
    
22.         ObjectDelete(Period2AlpthabetString(TimePeriod) + TimePeriod + "_" + d);
    
23.       }         
    
24.   }

复制代码

在 start() 程序最后，我们再次查看 CrossBarsMin[] 数组，以确定新的局部最小值并删除不再是局部最小值的旧值。 因为可能的局部最小值不止一个（在 CrossBarsMin[] 数组有多个匹配值，全部是局部最小值），我们只能提取其中之一。 我们将使用价格最低的局部最小值。

1. CrossBarsNum[di] == CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)] &&
   
2. CrossBarsNum[di-1]!= CrossBarsNum[ArrayMinimum(CrossBarsNum, 2*l, di - l)]

复制代码

创建一个新的图形对象——水平线，并不复杂 设置该线条的特征：宽度、线型和颜色（我们之前在 Init 过程已经对其进行设定）。 删除那些不再是支撑线的线条并不复杂。 只有一点没有阐述清楚：为什么以及出于什么目的而使用以对象命名的 Period2AlpthabetString(TimePeriod) 函数？ 下一段对该问题进行了描述，之前已多次提及。

指标互相作用

如本文开头所讲，FindLevels 指标设计用于指示在一个图表内多个时间范围的支撑线。 为了达到该目的，需要满足以下条件：

• 应能多次运行指标，且指标应具有时间期间内的输入数据；
  
  
• 线条应不同，要容易区分每个支撑位所属的时段；
  
  
• 所有线条都应该长期和短期跟踪。
  
  
  

第一点没有任何问题。 我们没有全局变量。 每个时段的图形对象都有不同的名称，因为对象名称中包含时段（例如，“f30_1.25600000”中的 30 是时段），所以在运行多个指标时不会有冲突。

第二点已成功实现，每个线条都根据时段有不同的颜色（LineColor=Colors[Period2Int(TimePeriod)]）。

现在只剩下第三点。 按理来讲，如果一条线为 5 分钟图表的支撑线，则也会是 30 分钟图表的支撑线。 如果这些线在价格上出现冲突，具有相同的宽度，则其中一条线就会变为不可见！ 这就是不同时间范围的线条宽度应不同的原因。 我们使较长时间范围的支撑线宽度大于较短时间范围的支撑线。 这很容易理解，因为属于长时段的线条更加显著。

必须设置线条显示的适当优先级。 较细的线条应最后显示并在粗线条之上，只有这样才能看清。 在 MetaTrader 4 程序中对象按字母顺序显示。 因此有必要使较长时段的线条名称按照字母顺序出现在较短时段的线条之前。 这就是我们创建根据时段设置拉丁字母顺序函数的缘故。

1. string Period2AlpthabetString(int TmPeriod)
   
2.   {
   
3.     return (Alphabet[Period2Int(TmPeriod)]);
   
4.   }

复制代码

Alphabet 是逆序拉丁字母的数组。 每个支撑位的全名如下： Period2AlpthabetString(TimePeriod)+TimePeriod+"_"+d。

总结

指标测试表明其行之有效。 因为可以显示不同时间范围的数据，所以容易使用。 测试期间显示，如果指标为每个 TimePeriod 显示 3-10 个支撑位，则更加方便。 为此，必须选择相应的输入条目 MaxR 和 MaxCrossesLevel。 测试过程中，MaxR 从较短时间范围的 0.0003 到较长时间范围的 0.002 不等。 MaxCrossesLevel 从 3 到 20 不等。 对指标进行配置，使其能够显示一定数量的最显著的支撑位，或许这样比较有用，但这样会使代码更加复杂。 我想那些喜欢我指标的人自己能够轻松做到。

完整代码如下：

1. //+------------------------------------------------------------------+
   
2. //|                                                ExportLevels2.mq4 |
   
3. //|                      Copyright ?2006, MetaQuotes Software Corp. |
   
4. //|                                        http://www.metaquotes.net |
   
5. //+------------------------------------------------------------------+
   
6. #property copyright "Copyright ?2006, MetaQuotes Software Corp."
   
7. #property link      "http://www.metaquotes.net"
   
8. 
   
9. #property indicator_chart_window
   
10. 
    
11. extern int MaxLimit = 1000;
    
12. extern int MaxCrossesLevel = 10;
    
13. extern double MaxR = 0.001;
    
14. extern color LineColor = White;
    
15. extern int LineWidth = 0;
    
16. extern int LineStyle = 0;
    
17. extern int TimePeriod = 0;
    
18. 
    
19. color  Colors[] = {Red,Maroon,Sienna,OrangeRed,Purple,Indigo,DarkViolet,MediumBlue,DarkSlateGray};
    
20. int    Widths[] = {1,2,3,4,5,6,7,8,9};
    
21. string Alphabet[] = {"i","h","g","f","e","d","c","b","a"};
    
22. 
    
23. int CrossBarsNum[];
    
24. bool CrossBarsMin[];
    
25. double d1Num =0.0, d2Num = 0.0;
    
26. 
    
27. datetime TMaxI = 0;
    
28. 
    
29. #define MaxLines 1000
    
30. string LineName[MaxLines];
    
31. int LineIndex = 0;
    
32. //+------------------------------------------------------------------+
    
33. //| Custom indicator initialization function                         |
    
34. //+------------------------------------------------------------------+
    
35. double prLow(int i)
    
36. {
    
37.   return (iLow(NULL,TimePeriod,i));
    
38. }
    
39. double prHigh(int i)
    
40. {
    
41.   return (iHigh(NULL,TimePeriod,i));
    
42. }
    
43. 
    
44. int Period2Int(int TmPeriod)
    
45. {
    
46.   switch (TmPeriod)
    
47.   {
    
48.     case PERIOD_M1  : return(0);
    
49.     case PERIOD_M5  : return(1);
    
50.     case PERIOD_M15 : return(2);
    
51.     case PERIOD_M30 : return(3);
    
52.     case PERIOD_H1  : return(4);
    
53.     case PERIOD_H4  : return(5);
    
54.     case PERIOD_D1  : return(6);
    
55.     case PERIOD_W1  : return(7);
    
56.     case PERIOD_MN1 : return(8);
    
57.   }      
    
58.   return (0);
    
59. }
    
60. 
    
61. string Period2AlpthabetString(int TmPeriod)
    
62. {
    
63.    return (Alphabet[Period2Int(TmPeriod)]);
    
64. }
    
65. 
    
66. int init()
    
67.   {
    
68. //---- indicators
    
69. //----
    
70.    if (TimePeriod==0)
    
71.      TimePeriod=Period();
    
72. 
    
73.    if (TimePeriod!=0&&LineWidth==0)
    
74.      if (Period2Int(TimePeriod)-Period2Int(Period())>=0)
    
75.        LineWidth=Widths[Period2Int(TimePeriod)-Period2Int(Period())];
    
76.      else
    
77.        {
    
78.          LineWidth=0;
    
79.          if (LineStyle==0)
    
80.            LineStyle=STYLE_DASH;
    
81.        }
    
82.    if (TimePeriod!=0&&LineColor==White)
    
83.      LineColor=Colors[Period2Int(TimePeriod)];
    
84.      
    
85.    return(0);
    
86.   }
    
87. //+------------------------------------------------------------------+
    
88. //| Custom indicator deinitialization function                       |
    
89. //+------------------------------------------------------------------+
    
90. int deinit()
    
91.   {
    
92. //----
    
93.    for (int i = 0; i<LineIndex;i++)
    
94.      ObjectDelete(LineName[i]);
    
95.    
    
96.          
    
97. //----
    
98.    return(0);
    
99.   }
    
100. //+------------------------------------------------------------------+
     
101. //| Custom indicator iteration function                              |
     
102. //+------------------------------------------------------------------+
     
103. int start()
     
104.   {
     
105.    int    counted_bars=IndicatorCounted();
     
106.    int    limit = MathMin(Bars - counted_bars,MaxLimit);
     
107.    
     
108.    double d1 = prLow(Lowest(NULL,TimePeriod,MODE_LOW,limit,0));
     
109.    double d2 = prHigh(Highest(NULL,TimePeriod,MODE_HIGH,limit,0));
     
110.    
     
111.    if (d1Num!=d1||d2Num!=d2)
     
112.      {
     
113.        ArrayResize(CrossBarsNum, (d2-d1)*10000);
     
114.        ArrayResize(CrossBarsMin, (d2-d1)*10000);
     
115.        if (d1Num!=d1&&d1Num!=0.0)
     
116.        {
     
117.          ArrayCopy(CrossBarsNum,CrossBarsNum, 0, (d1Num-d1)*10000);
     
118.          ArrayCopy(CrossBarsMin,CrossBarsMin, 0, (d1Num-d1)*10000);
     
119.        }
     
120.        d1Num=d1;
     
121.        d2Num=d2;
     
122.      }
     
123.      
     
124.    
     
125.    for (double d=d1;d<=d2;d+=0.0001)
     
126.      {
     
127.        int di = (d-d1)*10000;
     
128.        for (int i=1; i<limit;i++)
     
129.          if (d>prLow(i)&&d<prHigh(i))
     
130.            CrossBarsNum[di]++;
     
131.        if (Time[limit]!=TMaxI&&TMaxI!=0)
     
132.          if (d>prLow(iBarShift(NULL,0,TMaxI))&&d<prHigh(iBarShift(NULL,0,TMaxI)))
     
133.            CrossBarsNum[di]--;
     
134.      }
     
135.    TMaxI = Time[limit]-1;
     
136. 
     
137.    double l=MaxR*10000;
     
138.    for (d=d1+MaxR;d<=d2-MaxR;d+=0.0001)
     
139.      {
     
140.         di = (d-d1)*10000;
     
141.         if (!CrossBarsMin[di]&&//CrossBarsNum[di]<MaxCrossesLevel&&
     
142.              CrossBarsNum[ArrayMaximum(CrossBarsNum,2*l,di-l)]-CrossBarsNum[ArrayMinimum(CrossBarsNum,2*l,di-l)]>MaxCrossesLevel
     
143.                              &&CrossBarsNum[di]  ==CrossBarsNum[ArrayMinimum(CrossBarsNum,2*l,di-l)]
     
144.                              &&CrossBarsNum[di-1]!=CrossBarsNum[ArrayMinimum(CrossBarsNum,2*l,di-l)])
     
145.         {
     
146.           CrossBarsMin[di]=true;
     
147.           LineName[LineIndex]=Period2AlpthabetString(TimePeriod)+TimePeriod+"_"+d;
     
148.          
     
149.           ObjectCreate(LineName[LineIndex],OBJ_HLINE,0,0,d);
     
150.           ObjectSet(LineName[LineIndex],OBJPROP_COLOR,LineColor);
     
151.           ObjectSet(LineName[LineIndex],OBJPROP_WIDTH,LineWidth);
     
152.           ObjectSet(LineName[LineIndex],OBJPROP_STYLE,LineStyle);
     
153.           LineIndex++;
     
154.         }
     
155. 
     
156.         if (CrossBarsMin[di]&&CrossBarsNum[di]!=CrossBarsNum[ArrayMinimum(CrossBarsNum,2*l,di-l)])
     
157.         {
     
158.           CrossBarsMin[di]=false;
     
159.           ObjectDelete(Period2AlpthabetString(TimePeriod)+TimePeriod+"_"+d);
     
160.         }
     
161.          
     
162.      }
     
163.       
     
164.    return(0);
     
165.   }
     
166. //+------------------------------------------------------------------+

复制代码