Panduan Lengkap Fibonacci ZigZag untuk MetaTrader 5

Sebelum kita mulai, kita butuh beberapa hal:

• 1 grafik ZigZag
• 2 buffer data untuk harga tertinggi dan terendah
• Parameter input
• Serangkaian variabel sistem yang akan direset setiap kali indikator dihitung ulang

Array upWaves akan menyimpan harga tertinggi, sedangkan array dwWaves akan menyimpan harga terendah.

Variabel sistem yang perlu kita ketahui meliputi tipe gelombang terakhir, di mana gelombang tersebut dimulai, di mana gelombang tersebut berakhir, serta jarak dalam bar dari awal hingga akhir.

//--- melacak zigzag
int wave_type=0;
//--- harga dari gelombang (harga awal)
double wave_start_price=0.0;
//--- harga ke dari gelombang (harga akhir)
double wave_end_price=0.0;
//--- jarak dalam bar dari harga awal
int wave_start_distance=0;
//--- jarak dalam bar dari harga akhir
int wave_end_distance=0;
//--- pelacakan harga tertinggi
double high_mem=0.0;
int distance_from_high=0;
//--- pelacakan harga terendah
double low_mem=0.0;
int distance_from_low=0;
//--- rolling atr
double rollingAtr=0.0;
int rollingAtrs=0;

Kita juga perlu membuat fungsi reset 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;
}

Standar saja, kita mengisi array dengan nol dan mereset variabel sistem.

Di bagian oninit, kita akan menyiapkan buffer, plot, dan memanggil reset untuk pertama kali:

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

Kita mulai dengan menghitung rolling atr. Sampai kita mengumpulkan lebih banyak bar daripada periode atr, kita tidak akan melakukan hal lain.

Bagian yang mengelola rolling atr adalah sebagai berikut:

• jika kita belum mengumpulkan lebih dari periode, terus tambahkan range dari bar yang ditemukan ke dalam penjumlahan
• setelah mencapai periode, kita melakukan pembagian pertama (rata-rata)
• setelah itu, kita mengurangi satu bagian dari rolling atr, yaitu atr/periode, dan kemudian menambahkan bagian baru yang merupakan range bar/periode

Kita tempatkan bagian terakhir terlebih dahulu karena ini akan terjadi lebih sering dan kita tidak perlu mengakses dua pernyataan if.

//--- mengelola atr
rollingAtrs++;
if(rollingAtrs>rollingAtrPeriod){
    double new_portion=((high[i]-low[i])/_Point)/((double)rollingAtrPeriod);
    //--- kita menghapus bagian lama dan menambahkan bagian baru
    rollingAtr=(rollingAtr)-(rollingAtr/((double)rollingAtrPeriod))+new_portion;
} else if(rollingAtrs<=rollingAtrPeriod){
    rollingAtr+=(high[i]-low[i])/_Point;
    if(rollingAtrs==rollingAtrPeriod){
        rollingAtr/=((double)rollingAtrs);
        //--- mulai memori untuk highs dan lows dan sistem
        high_mem=high[i];
        low_mem=low[i];
        distance_from_high=0;
        distance_from_low=0;
    }
}

Bagus, sekarang ada masalah lain. Dasar dari zigzag ini adalah retracement.

Tapi untuk retracement terjadi, harus ada setidaknya satu gelombang.

Namun gelombang pertama akan retrace apa? xD

Oleh karena itu, kita akan melakukan hal berikut:

• secepatnya atr terisi (atr terkumpul = periode), kita akan mengambil harga tertinggi dan terendah dalam variabel sistem kita
• siapa pun yang berhasil membentuk gelombang dengan ukuran valid dalam satuan atr, dan membentuk harga tinggi baru (gelombang naik) atau harga rendah baru (gelombang turun) akan menang

Dengan cara ini kita tidak memiliki retracement sebagai gelombang awal, tetapi kita harus memulai urutan entah bagaimana.

Catatan: Kita juga bisa memilih untuk menggunakan pendekatan fraktal klasik hanya untuk gelombang pertama dan kemudian melanjutkan dengan retracement.

//--- jika kita belum memiliki tipe gelombang
else {
    //--- jika kita melanggar harga tinggi dan bukan harga rendah
    if(high[i]>high_mem && low[i]>=low_mem){
        double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
        //--- jika ukuran gelombang baru valid
        if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
            //--- mulai gelombang naik baru
            wave_type=1;
            //--- harga awal adalah low mem
            wave_start_price=low_mem;
            wave_start_distance=distance_from_low;
            //--- harga akhir adalah harga tinggi baru
            wave_end_price=high[i];
            wave_end_distance=0;
            //--- gambar gelombang
            dwWaves[i-wave_start_distance]=low_mem;
            upWaves[i]=high[i];
            //--- ubah harga tinggi
            high_mem=high[i];
            distance_from_high=0;
            //--- ubah harga rendah
            low_mem=low[i];
            distance_from_low=0;
        }
    } 
    //--- jika kita melanggar harga rendah dan bukan harga tinggi
    else if(low[i]=minSizeInAtrUnits){
            //--- mulai gelombang turun baru
            wave_type=-1;
            //--- harga awal adalah high mem
            wave_start_price=high_mem;
            wave_start_distance=distance_from_high;
            //--- harga akhir adalah harga rendah baru
            wave_end_price=low[i];
            wave_end_distance=0;
            //--- gambar gelombang
            upWaves[i-wave_start_distance]=high_mem;
            dwWaves[i]=low[i];
            //--- ubah harga tinggi
            high_mem=high[i];
            distance_from_high=0;
            //--- ubah harga rendah
            low_mem=low[i];
            distance_from_low=0;
        }
    }
    //--- jika kita melanggar keduanya
    else if(low[i]high_mem){
        //--- ubah mereka
        high_mem=high[i];
        low_mem=low[i];
        distance_from_high=0;
        distance_from_low=0;
    }
}

Bagus. Sekarang bagian terakhir.

Jika kita memiliki gelombang naik:

• jika harga tinggi baru dibuat, pindahkan zigzag dari posisi tinggi sebelumnya ke posisi tinggi baru yang bisa kita lakukan karena kita mempertahankan jarak bar. Juga perbarui harga rendah dan jarak dari harga rendah. Kita melakukan ini agar bisa menangkap harga terendah sejak puncak dan memeriksa apakah cukup retrace untuk memulai gelombang rendah baru.
• jika harga rendah baru dibuat, atau, harga rendah baru disetel, kita menghitung jarak dari puncak ke rendah dan membaginya dengan ukuran gelombang. Juga kalikan dengan 100 agar sesuai dengan skala parameter input. Jadi jika ukuran gelombang adalah 100 poin dan retracement adalah 24 poin, kita mendapatkan 24/100 = 0.24, lalu x 100 = 24%. Jika ukuran gelombang baru yang 'seharusnya' retrace gelombang sebelumnya juga valid terhadap satuan atr, kita mulai gelombang turun baru, mengatur harga tinggi dan rendah lokal yang baru, serta mengatur jarak bar.

Berikut adalah kode yang relevan untuk di atas:

//--- jika kita memiliki gelombang naik
if(wave_type==1){
    //--- jika gelombang melebar ke atas
    if(high[i]>wave_end_price){
        //--- hapus harga akhir sebelumnya dari posisi array-nya (0.0=kosong)
        upWaves[i-wave_end_distance]=0.0;
        //--- tempatkan di posisi baru
        upWaves[i]=high[i];
        wave_end_price=high[i];
        wave_end_distance=0;
        //--- ubah harga tinggi
        high_mem=high[i];
        distance_from_high=0;
        //--- ubah harga rendah
        low_mem=low[i];
        distance_from_low=0;
    }
    //--- periksa 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 ukuran gelombang baru valid
            if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
                //--- jika retracement signifikan, mulai gelombang turun
                if(retraced>=retracement){
                    //--- mulai gelombang turun baru
                    wave_type=-1;
                    //--- harga awal adalah high mem
                    wave_start_price=high[i-distance_from_high];
                    wave_start_distance=distance_from_high;
                    //--- harga akhir adalah harga rendah baru
                    wave_end_price=low[i];
                    wave_end_distance=0;
                    //--- gambar gelombang
                    upWaves[i-wave_start_distance]=high_mem;
                    dwWaves[i]=low[i];
                    //--- ubah harga tinggi
                    high_mem=high[i];
                    distance_from_high=0;
                    //--- ubah harga rendah
                    low_mem=low[i];
                    distance_from_low=0;
                }
            }
        }
    }
}

Kita melakukan sebaliknya ketika kita memiliki gelombang turun.

Dan kita selesai, zigzag retracement kita sudah siap.

Berikut adalah zigzag dengan 23.6% retracement dan 0.0 ukuran minimum gelombang dalam satuan atr

Dan berikut adalah zigzag yang sama dengan 3 ukuran minimum gelombang dalam satuan atr