MetaTrader5
Fibonacci ZigZag Indicator voor MetaTrader 5: Een Stapsgewijze Handleiding
De Setup Voor het instellen van de Fibonacci ZigZag indicator heb je het volgende nodig: 1 ZigZag plot 2 databuffers voor de hoogste en laagste punten Invoervariabelen Een set systeemvariabelen die resetten wanneer de indicator opnieuw berekend wordt Hier is een voorbeeld van de code: #property indicator_buffers 2
#property indicator_plots 1
input double retracement=23.6;// retracement percentage
input double minSizeInAtrUnits=0.0;// minimale golfgrootte in ATR eenheden
input int rollingAtrPeriod=14;// rolling ATR periode
input color Color=clrDodgerBlue;// golf kleur
input int Width=3;// golf breedte
input ENUM_LINE_STYLE Style=STYLE_SOLID;// golf stijl De upWaves array zal de hoogste punten opslaan en de dwWaves array zal de laagste punten opslaan. Systeemvariabelen: We moeten weten wat het laatste golftype is, waar het begon, waar het eindigde, en de afstand in bars van het begin naar het eind. We hebben ook lokale hoogtes en laagtes nodig, evenals de afstanden in bars vanaf elk punt. //--- bijhouden van de zigzag
//--- het type golf dat we hebben [0] geen [1] omhoog [2] omlaag
int wave_type=0;
//--- de beginprijs van de golf (startprijs)
double wave_start_price=0.0;
//--- de eindprijs van de golf (eindprijs)
double wave_end_price=0.0;
//--- de afstand in bars vanaf de beginprijs
int wave_start_distance=0;
//--- de afstand in bars vanaf de eindprijs
int wave_end_distance=0;
//--- tracking van de hoge prijs
double high_mem=0.0;
int distance_from_high=0;
//--- tracking van de lage prijs
double low_mem=0.0;
int distance_from_low=0;
//--- rolling ATR
double rollingAtr=0.0;
int rollingAtrs=0; We creëren vervolgens een functie voor het resetten van het systeem: void resetSystem(){
ArrayFill(upWaves,0,ArraySize(upWaves),0.0);
ArrayFill(dwWaves,0,ArraySize(dwWaves),0.0);
wave_type=0;
wake_start_price=0.0;
wake_end_price=0.0;
wake_start_distance=0;
wake_end_distance=0;
high_mem=0.0;
low_mem=0.0;
distance_from_high=0;
distance_from_low=0;
rollingAtr=0.0;
rollingAtrs=0;
} Standaard dingen: vul de arrays met nullen en reset de systeemvariabelen. Bij de initialisatie stellen we de buffers in, de plots, en roepen we de resetfunctie voor de eerste keer aan: SetIndexBuffer(0,upWaves,INDICATOR_DATA);
SetIndexBuffer(1,dwWaves,INDICATOR_DATA);
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_ZIGZAG);
PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Color);
PlotIndexSetInteger(0,PLOT_LINE_WIDTH,Width);
PlotIndexSetInteger(0,PLOT_LINE_STYLE,Style);
resetSystem(); Laten we nu de berekeningen bekijken. Het eerste wat we moeten doen is de rolling ATR beheren. Totdat we meer bars hebben verzameld dan de ATR-periode, doen we verder niets. De sectie die het rolling ATR beheert is als volgt: Als we niet meer dan de periode hebben verzameld, blijven we het bereik van de gevonden bars optellen tot een som Wanneer we de periode bereiken, voeren we de eerste deling (gemiddelde) uit Daarna knippen we een deel van de rolling ATR af, wat ATR/periode is, en voegen we een nieuw deel toe, wat het bereik van de bar/periode is We plaatsen het laatste deel eerst omdat dat vaker zal gebeuren en we niet twee if-statements hoeven te benaderen. //--- beheer de ATR
rollingAtrs++;
if(rollingAtrs>rollingAtrPeriod){
double new_portion=((high[i]-low[i])/_Point)/((double)rollingAtrPeriod);
//--- we verwijderen een oud deel en voegen een nieuw deel toe
rollingAtr=(rollingAtr)-(rollingAtr/((double)rollingAtrPeriod))+new_portion;
}
else if(rollingAtrs<=rollingAtrPeriod){
rollingAtr+=(high[i]-low[i])/_Point;
if(rollingAtrs==rollingAtrPeriod){
rollingAtr/=((double)rollingAtrs);
//--- start het geheugen voor hoogtes en laagtes en het systeem
high_mem=high[i];
low_mem=low[i];
distance_from_high=0;
distance_from_low=0;
}
} Geweldig! Nu hebben we nog een probleem. De basis van deze ZigZag is een retracement. Maar voor een retracement moet er tenminste één golf zijn. Maar wat zal de eerste golf retraceren? Daarom doen we het volgende: Zodra de ATR zich heeft gevuld (ATR verzameld = periode), pakken we de hoogste en laagste waarde in onze systeemvariabelen Welke kant een golf vormt die een geldige grootte heeft in ATR-eenheden en een nieuwe hoge (upwave) of een nieuwe lage (downwave) vormt, wint Op deze manier hebben we geen retracement als de initiële golf, maar we moeten de sequentie op de een of andere manier starten. We zouden ook kunnen kiezen voor een klassieke fractalbenadering voor alleen de eerste golf en dan doorgaan met retracements. //--- als we nog geen golftype hebben
else{
//--- als we de hoge breken en niet de lage
if(high[i]>high_mem&&low[i]>=low_mem){
double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
//--- als de nieuwe golfgrootte geldig is
if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
//--- start een nieuwe upwave
wave_type=1;
//--- startprijs is de lage mem
wave_start_price=low_mem;
wave_start_distance=distance_from_low;
//--- eindprijs is de nieuwe hoge
wave_end_price=high[i];
wave_end_distance=0;
//--- teken de golf
dwWaves[i-wave_start_distance]=low_mem;
upWaves[i]=high[i];
//--- wijzig de hoge
high_mem=high[i];
distance_from_high=0;
//--- wijzig de lage
low_mem=low[i];
distance_from_low=0;
}
}
//--- als we de lage breken en niet de hoge
else if(low[i]<low_mem&&high[i]<=high_mem){
double new_wave_size_in_atr_units=((high_mem-low[i])/_Point)/rollingAtr;
//--- als de nieuwe golfgrootte geldig is
if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
//--- start een nieuwe downwave
wave_type=-1;
//--- startprijs is de hoge mem
wave_start_price=high_mem;
wave_start_distance=distance_from_high;
//--- eindprijs is de nieuwe lage
wave_end_price=low[i];
wave_end_distance=0;
//--- teken de golf
upWaves[i-wave_start_distance]=high_mem;
dwWaves[i]=low[i];
//--- wijzig de hoge
high_mem=high[i];
distance_from_high=0;
//--- wijzig de lage
low_mem=low[i];
distance_from_low=0;
}
}
//--- als we beide breken
else if(low[i]<low_mem&&high[i]>high_mem){
//--- wijzig ze
high_mem=high[i];
low_mem=low[i];
distance_from_high=0;
distance_from_low=0;
}
} Geweldig! Nu de laatste stap. Als we een upwave hebben: als er een nieuwe hoge wordt gemaakt, verplaats de zigzag van de vorige hoge positie naar de nieuwe hoge positie, wat we kunnen doen omdat we de bar-afstanden behouden. Werk ook de lage en de afstand van de lage bij. Dit doen we zodat we de laagste laag kunnen vangen sinds de piek en controleren of deze genoeg retracete om een nieuwe lage te starten. Als er een nieuwe lage wordt gemaakt, of een nieuwe lage wordt ingesteld, berekenen we de afstand van de piek naar de lage en delen deze door de golfgrootte. Vermenigvuldig ook met 100 om overeen te komen met de invoervariabele schaal. Dus als de golfgrootte 100 punten is en de retracement 24 punten is, krijgen we 24/100 = 0,24, en dan x 100 = 24%. Als de grootte van de nieuwe "zou zijn" golf die de vorige retraceert ook geldig is tegen de ATR-eenheden, starten we een nieuwe downwave, stellen we de nieuwe lokale hoogtes en laagtes in, en stellen we de bar-afstanden in. Hier is de relevante code voor het bovenstaande: //--- als we een upwave hebben
if(wave_type==1){
//--- als de golf omhoog uitbreidt
if(high[i]>wave_end_price){
//--- verwijder de vorige eindprijs van zijn arraypositie (0.0=leeg)
upWaves[i-wave_end_distance]=0.0;
upWaves[i]=high[i];
wave_end_price=high[i];
wave_end_distance=0;
//--- wijzig de hoge
high_mem=high[i];
distance_from_high=0;
//--- wijzig de lage
low_mem=low[i];
distance_from_low=0;
}
//--- controleer op retracement
if(low[i]<low_mem||distance_from_low==0){
low_mem=low[i];
distance_from_low=0;
double size_of_wave=(wave_end_price-wave_start_price)/_Point;
double size_of_retracement=(wave_end_price-low_mem)/_Point;
if(size_of_wave>0.0){
double retraced=(size_of_retracement/size_of_wave)*100.0;
double new_wave_size_in_atr_units=((wave_end_price-low_mem)/_Point)/rollingAtr;
//--- als de nieuwe golfgrootte geldig is
if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
//--- als de retracement significant is, start een downwave
wave_type=-1;
wave_start_price=high[i-distance_from_high];
wave_start_distance=distance_from_high;
wave_end_price=low[i];
wave_end_distance=0;
upWaves[i-wave_start_distance]=high_mem;
dwWaves[i]=low[i];
high_mem=high[i];
distance_from_high=0;
low_mem=low[i];
distance_from_low=0;
}
}
}
} We doen het tegenovergestelde wanneer we een downwave hebben. En we zijn klaar, onze retracement ZigZag is gereed. Hier is de ZigZag met 23.6% retracement en 0.0 minimale golfgrootte in ATR eenheden En hier is dezelfde ZigZag met 3 minimale golfgrootte in ATR eenheden
2025.03.03
