# 请各位朋友帮看看如何实现这样的指标

71
2010.09.19 06:12

//----------------

//---------------

1、此指标是替换ZIGZAG里的高低点的算法，但代入我求出的高低值并不能实现我的目标。

/

2、由于本人水平有限，弄了几天也发现不了问题所在，请各位朋友看看在那里需要修改。

/

3、最后未出现新的均线交叉前的线也没想到好算法，也请各位朋友出出主意。

/

/

```//+------------------------------------------------------------------+
//|                                                     indi_ls2.mq4 |
//|                                                                  |
//|                                                                  |
//+------------------------------------------------------------------+

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Blue       //指标显示颜色
#property indicator_width1 3
//---- indicator parameters
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
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(3);
//---- 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);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
{
int i, counted_bars = IndicatorCounted();
int limit,counterZ,whatlookfor;
int shift,back,lasthighpos,lastlowpos;
double val,res;
double curlow,curhigh,lasthigh,lastlow;

{
ArrayInitialize(ZigzagBuffer,0.0);
ArrayInitialize(HighMapBuffer,0.0);
ArrayInitialize(LowMapBuffer,0.0);
}
if (counted_bars==0)
{
limit=Bars-ExtDepth;
}
if (counted_bars>0)
{
while (counterZ<level && i<100)
{
res=ZigzagBuffer[i];
if (res!=0) counterZ++;
i++;
}
i--;
limit=i;
if (LowMapBuffer[i]!=0)
{
curlow=LowMapBuffer[i];
whatlookfor=1;
}
else
{
curhigh=HighMapBuffer[i];
whatlookfor=-1;
}
for (i=limit-1;i>=0;i--)
{
ZigzagBuffer[i]=0.0;
LowMapBuffer[i]=0.0;
HighMapBuffer[i]=0.0;
}
}

for(shift=limit; shift>=0; shift--)
{
val=Low[Lp(shift)];        //替换原[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;
else
{
for(back=1; back<=ExtBackstep; back++)
{
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[Hp(shift)];       //替换原[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;
}
for (shift=limit;shift>=0;shift--)
{
res=0.0;
switch(whatlookfor)
{
case 0: // look for peak or lawn
if (lastlow==0 && lasthigh==0)
{
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);
}
//+------------------------------------------------------------------+
int Hp(int i)
{
double MaS_curr, MaS_prev, MaB_curr, MaB_prev;
int j,k;
MaS_curr=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,i);
MaS_prev=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,i+1);
MaB_curr=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,i);
MaB_prev=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,i+1);
if(MaB_curr<=MaS_curr && MaB_prev>MaS_prev)
{
j=i+1;
while(j<500)
{
MaS_curr=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,j);
MaS_prev=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,j+1);
MaB_curr=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,j);
MaB_prev=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,j+1);
//Comment(i," ",DoubleToStr(Signal_curr,4),"\n");
if(MaB_curr>=MaS_curr && MaB_prev<MaS_prev)
{
double HH[0];
ArrayResize(HH,j-i);
for(k=0;k<j-i;k++)
HH[k]=High[k];
int Hpoint=ArrayMaximum(HH,j-i,1);         //高点位置

break;
}
j++;
}
}
return(Hpoint);
}
//+------------------------------------------------------------------+
int Lp(int i)
{
double MaS_curr, MaS_prev, MaB_curr, MaB_prev;
int j,k;
MaS_curr=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,i);
MaS_prev=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,i+1);
MaB_curr=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,i);
MaB_prev=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,i+1);
if(MaB_curr>=MaS_curr && MaB_prev<MaS_prev)
{
j=i+1;
while(j<500)
{
MaS_curr=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,j);
MaS_prev=iMA(NULL,0,21,0,MODE_SMA,PRICE_CLOSE,j+1);
MaB_curr=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,j);
MaB_prev=iMA(NULL,0,55,0,MODE_SMA,PRICE_CLOSE,j+1);

if(MaB_curr<=MaS_curr && MaB_prev>MaS_prev)
{
double LL[0];
ArrayResize(LL,j-i);
for(k=0;k<j-i;k++)
LL[k]=Low[k];

int Lpoint=ArrayMinimum(LL,j-i,1);         //低点位置

break;
}
j++;
}
}
return(Lpoint);
}

```

indi_ls2.mq4 9 kb