Fibonacci ZigZag - Indikator Berguna untuk MetaTrader 5

Persediaan

Kita perlukan:

1 plot zigzag
2 buffer data untuk tahap tinggi dan rendah
parameter input
set pembolehubah sistem yang akan diset semula setiap kali indikator dikira semula

#property indicator_buffers 2
#property indicator_plots 1
input double retracement=23.6; //jumlah retracement
input double minSizeInAtrUnits=0.0; //saiz minimum gelombang dalam unit atr
input int rollingAtrPeriod=14; //tempoh atr bergulir
input color Color=clrDodgerBlue; //warna gelombang
input int Width=3; //lebar gelombang
input ENUM_LINE_STYLE Style=STYLE_SOLID; //gaya gelombang
//+------------------------------------------------------------------+

Array upWaves akan menyimpan tahap tinggi dan array dwWaves akan menyimpan tahap rendah.

Pembolehubah sistem:

Kita perlu tahu jenis gelombang terakhir, di mana ia bermula, di mana ia berakhir, serta jarak dalam bar dari permulaan hingga akhir.

Kemudian kita perlukan pembolehubah tinggi dan rendah tempatan serta jarak dalam bar dari setiap titik.

//--- menjejaki zigzag
int wave_type=0; //--- jenis gelombang [0] tiada [1] atas [2] bawah
//--- harga dari gelombang (harga permulaan)
double wave_start_price=0.0;
//--- harga ke gelombang (harga akhir)
double wave_end_price=0.0;
//--- jarak dalam bar dari harga permulaan
int wave_start_distance=0;
//--- jarak dalam bar dari harga akhir
int wave_end_distance=0;
//--- menjejaki harga tinggi
double high_mem=0.0;
int distance_from_high=0;
//--- menjejaki harga rendah
double low_mem=0.0;
int distance_from_low=0;
//--- rolling atr
double rollingAtr=0.0;
int rollingAtrs=0;

Akhir sekali, unit atr bergulir dan berapa banyak yang telah dikira.

Kita kemudian buat fungsi untuk menetapkan semula sistem:

void resetSystem(){
ArrayFill(upWaves,0,ArraySize(upWaves),0.0);
ArrayFill(dwWaves,0,ArraySize(dwWaves),0.0);
wave_type=0;
wave_start_price=0.0;
wave_end_price=0.0;
wave_start_distance=0;
wave_end_distance=0;
high_mem=0.0;
low_mem=0.0;
distance_from_high=0;
distance_from_low=0;
rollingAtr=0.0;
rollingAtrs=0;
}

Ini adalah rutin biasa, isi array dengan nol dan set semula pembolehubah sistem.

Ketika inisialisasi, kita sediakan buffer, plot, dan panggil reset untuk kali pertama:

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();

Jadi, mari kita teruskan kepada pengiraan.

Perkara pertama yang perlu kita urus ialah rolling atr.

Sehingga kita telah mengumpul lebih banyak bar daripada tempoh atr, kita tidak akan lakukan apa-apa lagi.

Bahagian yang mengurus rolling atr adalah seperti berikut:

jika kita belum mengumpulkan lebih daripada tempoh, teruskan menambah julat bar yang dijumpai ke dalam jumlah
sebaik sahaja kita mencapai tempoh, kita lakukan pembahagian pertama (purata)
selepas itu, kita potong satu bahagian dari rolling atr, iaitu atr/tempoh, dan kemudian tambah satu bahagian baharu yang merupakan julat bar/tempoh

Kita letakkan bahagian terakhir dahulu kerana ia akan berlaku lebih kerap dan kita tidak perlu mengakses 2 pernyataan jika.

//--- urus atr
rollingAtrs++;
if(rollingAtrs>rollingAtrPeriod){
 double new_portion=((high[i]-low[i])/_Point)/((double)rollingAtrPeriod);
//--- kita mengeluarkan bahagian lama dan menambah bahagian baharu
 rollingAtr=(rollingAtr)-(rollingAtr/((double)rollingAtrPeriod))+new_portion;
}
else if(rollingAtrs<=rollingAtrPeriod){
 rollingAtr+=(high[i]-low[i])/_Point;
 if(rollingAtrs==rollingAtrPeriod){
 rollingAtr/=((double)rollingAtrs);
//--- mula menyimpan untuk tinggi dan rendah serta sistem
 high_mem=high[i];
 low_mem=low[i];
 distance_from_high=0;
 distance_from_low=0;
}
}

Sangat baik, sekarang, ada satu isu lain.

Asas zigzag ini adalah retracement.

Namun untuk retracement berlaku, mesti ada sekurang-kurangnya satu gelombang.

Apa yang akan retrace gelombang pertama? xD

Oleh sebab itu, kita akan melakukan perkara berikut:

sebaik sahaja atr dipenuhi (atr dikumpul = tempoh), kita akan ambil tahap tinggi dan rendah dalam pembolehubah sistem kita
sebarang sisi yang berjaya membentuk gelombang dengan saiz yang sah dalam unit atr dan membentuk tahap tinggi baharu (gelombang atas) atau tahap rendah baharu (gelombang bawah) akan menang

Dengan cara ini, kita tidak mempunyai retracement sebagai gelombang awal, tetapi kita perlu memulakan urutan dengan cara tertentu.

Perlu diingat kita juga boleh memilih pendekatan fraktal klasik di sini untuk gelombang pertama sahaja dan kemudian teruskan dengan retracement.

Inilah yang kita lakukan selagi kita tidak mempunyai gelombang:

//--- jika kita belum mempunyai jenis gelombang
else{
//--- jika kita memecahkan tahap tinggi dan bukan tahap rendah
 if(high[i]>high_mem&&low[i]>=low_mem){
 double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
//--- jika saiz gelombang baharu adalah sah
 if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
//--- mula gelombang atas baharu
 wave_type=1;
//--- harga permulaan adalah low mem
 wave_start_price=low_mem;
 wave_start_distance=distance_from_low;
//--- harga akhir adalah tahap tinggi baharu
 wave_end_price=high[i];
 wave_end_distance=0;
//--- lukis gelombang
 dwWaves[i-wave_start_distance]=low_mem;
 upWaves[i]=high[i];
//--- tukar tahap tinggi
 high_mem=high[i];
 distance_from_high=0;
//--- tukar tahap rendah
 low_mem=low[i];
 distance_from_low=0;
}
}
//--- jika kita memecahkan tahap rendah dan bukan tahap tinggi
else if(low[i]=minSizeInAtrUnits){
//--- mula gelombang bawah baharu
 wave_type=-1;
//--- harga permulaan adalah high mem
 wave_start_price=high_mem;
 wave_start_distance=distance_from_high;
//--- harga akhir adalah tahap rendah baharu
 wave_end_price=low[i];
 wave_end_distance=0;
//--- lukis gelombang
 upWaves[i-wave_start_distance]=high_mem;
 dwWaves[i]=low[i];
//--- tukar tahap tinggi
 high_mem=high[i];
 distance_from_high=0;
//--- tukar tahap rendah
 low_mem=low[i];
 distance_from_low=0;
}
}
//--- jika kita memecahkan kedua-duanya
else if(low[i]high_mem){
//--- tukar mereka
 high_mem=high[i];
 low_mem=low[i];
 distance_from_high=0;
 distance_from_low=0;
}
}

Bagus. Sekarang, bahagian terakhir.

Jika kita mempunyai gelombang atas:

jika tahap tinggi baharu dibuat, pindahkan zigzag dari posisi tahap tinggi sebelumnya ke posisi tahap tinggi baharu yang kita boleh lakukan kerana kita mengekalkan jarak bar. Juga kemas kini tahap rendah dan jarak dari tahap rendah. Kita lakukan ini untuk menangkap tahap rendah terendah sejak puncak dan semak jika ia retraces cukup untuk memulakan gelombang rendah baharu.
jika tahap rendah baharu dibuat, atau, tahap rendah baharu ditetapkan, kita mengira jarak dari puncak ke rendah dan membahagikannya dengan saiz gelombang. Dan juga mengalikan dengan 100 untuk memadankan skala parameter input. Jadi jika saiz gelombang adalah 100 mata dan retracement adalah 24 mata, kita mendapat 24/100 0.24, kemudian x 100 24%. Jika saiz "gelombang" baharu yang "sepatutnya" retrace gelombang sebelumnya juga sah berbanding unit atr, kita mulakan gelombang bawah baharu, tetapkan tahap tinggi dan rendah tempatan, tetapkan jarak bar.

Inilah kod yang berkaitan untuk di atas:

//--- jika kita mempunyai gelombang atas
if(wave_type==1){
//--- jika gelombang berkembang ke atas
 if(high[i]>wave_end_price){
//--- keluarkan harga akhir sebelumnya dari kedudukan arraynya (0.0=kosong)
 upWaves[i-wave_end_distance]=0.0;
//--- letakkan pada posisi baharu
 upWaves[i]=high[i];
 wave_end_price=high[i];
 wave_end_distance=0;
//--- tukar tahap tinggi
 high_mem=high[i];
 distance_from_high=0;
//--- tukar tahap rendah
 low_mem=low[i];
 distance_from_low=0;
}
//--- semak untuk retracement
 if(low[i]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;
//--- jika saiz gelombang baharu adalah sah
 if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
//--- jika retracement signifikan, mula gelombang bawah
 if(retraced>=retracement){
//--- mula gelombang bawah baharu
 wave_type=-1;
//--- harga permulaan adalah high mem
 wave_start_price=high[i-distance_from_high];
 wave_start_distance=distance_from_high;
//--- harga akhir adalah tahap rendah baharu
 wave_end_price=low[i];
 wave_end_distance=0;
//--- lukis gelombang
 upWaves[i-wave_start_distance]=high_mem;
 dwWaves[i]=low[i];
//--- tukar tahap tinggi
 high_mem=high[i];
 distance_from_high=0;
//--- tukar tahap rendah
 low_mem=low[i];
 distance_from_low=0;
}
}
}
}
}

Kita lakukan sebaliknya apabila kita mempunyai gelombang bawah.

Dan kita sudah selesai, zigzag retracement kita sudah siap.

Inilah zigzag dengan 23.6% retracement dan 0.0 saiz minimum gelombang dalam unit atr

Dan inilah zigzag yang sama dengan 3 saiz minimum gelombang dalam unit atr

Fibonacci ZigZag - Indikator Berguna untuk MetaTrader 5

Persediaan

Siaran berkaitan