4.6 Cara menerapkan strategi dalam bahasa C++

Penulis:Kebaikan, Dibuat: 2019-05-06 13:00:27, Diperbarui:

Ringkasan

Dalam artikel sebelumnya, kami menjelaskan premis implementasi strategi trading dari pengenalan bahasa C++, tata bahasa dasar, dan struktur strategi.

Strategi Pengantar

Salah satu indikator yang paling umum digunakan dalam analisis teknis, KDJ, diakui oleh sebagian besar pedagang di seluruh dunia. Nama lengkap KDJ adalah Random indicator, yang merupakan indikator analisis teknis yang sangat baru dan praktis yang digunakan di pasar berjangka komoditas.

KDJ didasarkan pada teori statistik, nilai acak (RSV) dihitung dengan rasio dari harga tertinggi, terendah dan penutupan garis 9 K terbaru. kemudian menghitung nilai K, nilai D dan nilai J sesuai dengan moving average, dan menggambar grafik untuk menilai tren harga.

Dengan menggabungkan keuntungan dari konsep momentum, indikator kekuatan dan moving average, kita mengukur tingkat variasi harga saham dari pergerakan kisaran normal. Ketika nilai K lebih besar dari nilai D, itu menunjukkan bahwa harga saham saat ini dalam tren kenaikan. Oleh karena itu, ketika garis K melintasi garis D dari bawah ke atas, inilah saatnya untuk membeli saham. Sebaliknya, ketika nilai K kurang dari nilai D, itu menunjukkan bahwa pasar saham saat ini dalam tren penurunan. Oleh karena itu, ketika garis K melintasi garis D dari atas ke bawah, inilah saatnya untuk menjual saham.

Metode perhitungan indikator KDJ

Perhitungan indikator KDJ rumit. Pertama, nilai acak (RSV) dihitung, dan kemudian nilai K, nilai D, dan nilai J dihitung. Metode perhitungannya adalah sebagai berikut:

RSV = (harga penutupan - harga terendah periode N) / (N siklus harga tertinggi - N siklus harga terendah) * 100
Nilai K = rata-rata N siklus RSV
D nilai = rata-rata dari N siklus K
J nilai = 3 * K nilai -2 * D nilai

void main(){ // the program starts from this main function
    while (true){ // enter the loop
        auto ct = exchange.SetContractType(symblo); //set the contract type
        auto r = exchange.GetRecords(); // get the K line array
        auto arr = TA.KDJ(r, 9, 3, 3); // calculate the KDJ indicator 
        auto k = arr[0]arr[0].size() - 2]; // get the previous k line KDJ indicator K value
        auto d = arr[1]arr[1].size() - 2]; // get the previous k line KDJ indicator D value
        auto j = arr[2]arr[2].size() - 2]; // get the previous k line KDJ indicator J value
    }
}

Logika Strategi

Ada banyak cara untuk menggunakan KDJ, yang dapat digunakan sendiri atau dalam kombinasi dengan indikator lain. Artikel ini kita akan menggunakannya dengan cara yang paling sederhana, yaitu: Jika nilai K lebih besar dari nilai D, kita percaya bahwa daya beli menguat, gelombang pasar naik telah terbentuk, dan sinyal posisi panjang pembukaan dihasilkan; jika nilai K kurang dari nilai D, kita percaya bahwa daya jual menguat, dan gelombang tren menurun telah terbentuk, sinyal posisi pendek pembukaan dihasilkan.

Jika nilai D berubah dari atas ke bawah setelah posisi dibuka, kita percaya bahwa daya beli melemah, atau daya jual menguat, dan sinyal posisi panjang penutupan dihasilkan; jika posisi pendek dibuka, nilai D berubah dari bawah ke atas, kita percaya bahwa kekuatan daya jual melemah, atau bahwa daya beli menguat, dan sinyal posisi pendek ditutup dihasilkan.

Kondisi perdagangan

Posisi panjang terbuka: Jika tidak ada posisi, dan nilai K lebih besar dari nilai D
Posisi pendek: Jika tidak ada posisi, dan nilai K kurang dari nilai D
Penutupan posisi panjang: Jika ada posisi panjang yang dipegang dan nilai D kurang dari nilai D dari garis K yang menembus
Penutupan Posisi Pendek: Jika ada posisi pendek yang dipegang dan nilai D lebih besar dari nilai D dari garis K tembus

Pelaksanaan Kode Strategi

Langkah pertama dalam menerapkan strategi dengan kode adalah terlebih dahulu mempertimbangkan data apa yang kita butuhkan? melalui API mana untuk mendapatkan? setelah kita mendapatkan data, bagaimana menghitung logika perdagangan? selanjutnya, cara mana untuk menempatkan pesanan? akhirnya, mari kita menerapkannya langkah demi langkah:

Langkah 1: menggunakan arsitektur strategi dan perpustakaan kelas perdagangan

Seperti yang ditunjukkan di bawah ini, arsitektur terdiri dari dua fungsi: satu adalah fungsi utama, program dimulai dari fungsi utama, dan fungsinya adalah untuk menangani inti dari logika strategi. hal-hal seperti: menilai apakah koneksi dengan pertukaran ok, menyaring informasi log yang tidak perlu, interval waktu eksekusi kontrol dari inti logika strategi; dan yang lainnya adalah fungsi onTick, dalam fungsi ini, terutama adalah logika strategi, yang terdiri dari: Dapatkan data mentah, hitung data, tempat pesanan, dan banyak lagi.

bool onTick(){  // onTick function
    // strategy logic
}

void main(){ // program starts from here
    while (true){  // enter the loop
        if (exchange.IO("status") == 0) // if the connection with the exchange if not stable.
            sleep(1000); // pause for 1 second
            continue; // skip this loop, enter the next loop
        }
        if(!onTick()){ // if the connection with the exchange is stable, enter this if loop, start executing the onTick function
            sleep(1000); // pause for 1 second
        }
    }
}

Kode di atas adalah kerangka strategi C ++ yang dibuat oleh alat platform FMZ Quant. Ini adalah format pengkodean tetap, semua logika perdagangan dimulai dari baris 2, dan tidak ada perubahan yang dibuat di tempat lain. Selain itu, jika Anda seorang veteran, Anda dapat menambahkan atau memodifikasi fitur sesuai kebutuhan Anda.

Anda dapat menganggap perpustakaan kelas perdagangan sebagai modul fungsional. Keuntungan menggunakan perpustakaan kelas perdagangan adalah memungkinkan Anda untuk fokus pada menulis logika strategi. Misalnya, ketika kita menggunakan perpustakaan kelas perdagangan, untuk membuka atau menutup posisi, kita dapat langsung menggunakan antarmuka API di perpustakaan kelas perdagangan; tetapi jika kita tidak menggunakan perpustakaan kelas perdagangan, kita perlu mendapatkan harga pasar saat membuka posisi. Perlu mempertimbangkan masalah pesanan yang tidak dieksekusi dan masalah pesanan penarikan, dan sebagainya.

Langkah 2: Dapatkan semua jenis data

Data mentah yang berbeda adalah bagian penting dari logika perdagangan. Jenis data apa yang kita butuhkan? Dari logika perdagangan strategi kita, pertama kita perlu mendapatkan data garis K. Dengan data garis K asli, kita dapat menghitung indikator KDJ, dan akhirnya membandingkan hubungan antara nilai K dan nilai D untuk menentukan apakah akan menempatkan pesanan. Jadi mari kita dapatkan data ini.

Dapatkan data K-line

Pertama, kita perlu mendapatkan array K-line, karena array K-line akan digunakan untuk menghitung indikator KDJ. sebagai berikut:

double position = 0; // position status parameter, the default is 0 

bool onTick(string symbol){ // onTick function, all strategy logic are in this function
    auto ct = exchange.SetContractType(symbol); // set the contract type and trading variety
    if(ct == false){ // if the setting contract type and trading variety is not successful 
        return false; // return false
    }
    auto r = exchange.GetRecords(); // get the k-line array
    if(!r.Valid || r.size() < 10){ // if getting the k-line array or the number of k-line is less than 10
        return false; // return false
    }
}

void main(){ // program starts from here
    while (true){  // enter the loop
        if (exchange.IO("status") == 0) // if the connection with the exchange if not stable.
            sleep(1000); // pause for 1 second
            continue; // skip this loop, enter the next loop
        }
        if(!onTick("this_week")){ // if the connection with the exchange is stable, enter this if loop, start executing the onTick function
            sleep(1000); // pause for 1 second
        }
    }
}

Seperti yang ditunjukkan di atas:

Baris 1 : Mendefinisikan variabel yang digunakan untuk menerima status posisi.

Baris 3 sampai 12: Fungsi onTick didefinisikan, dan fungsi ini membawa dengan parameter. parameter ini adalah untuk lulus dalam variasi perdagangan, dalam hal ini, menggunakan mingguan k-line.

Baris 14 sampai 24: Mendefinisikan fungsi utama yang menangani logika non-strategi. Satu-satunya hal yang dapat diubah adalah kode kontrak this_week pada baris 20, yang tidak perlu dimodifikasi di tempat lain, karena ini adalah format tetap.

Mari kita fokus pada fungsi onTick dan melihat bagaimana ia mendapatkan data K-line:

Baris 4 sampai 7 : tetapkan jenis kontrak dan varietas perdagangan, jika jenis kontrak dan varietas perdagangan tidak berhasil, kembalikan false

Garis 8: Dapatkan array K-line, yang merupakan format tetap.

Garis 9 sampai 11: Menyaring panjang garis K, karena parameter yang kita gunakan untuk menghitung indikator KDJ adalah 9. Ketika jumlah garis K kurang dari 9, tidak mungkin untuk menghitung indikator KDJ. Jadi di sini kita ingin menyaring panjang garis K. Jika garis K kurang dari 10, kembalikan false langsung dan terus menunggu garis K berikutnya.

Dapatkan indikator KDJ, nilai K dan nilai D

Selanjutnya, kita perlu menghitung nilai K dan D dari indikator KDJ. Pertama-tama kita perlu mendapatkan array indikator KDJ, dan mendapatkan nilai K dan nilai D dari array ini. Pada platform FMZ Quant, mendapatkan array KDJ sangat sederhana, cukup hubungi API KDJ, kesulitan adalah untuk mendapatkan nilai nilai K dan D, karena array KDJ adalah array dua dimensi.

Array dua dimensi sebenarnya mudah dipahami, yang merupakan array array, urutan yang diperoleh adalah: pertama mendapatkan array yang ditentukan dalam array, dan kemudian mendapatkan elemen yang ditentukan dari array yang ditentukan, seperti yang ditunjukkan di bawah ini:

#include <iostream>
using namespace std;

int main(){
    int hour [3][2] = {{100, 50}, {66, 88}, {10, 90}};
    cout << hours[0][0]; // get the hours array first elements of first element, the result is 100
    cout << hours[0][1]; // get the hours array first elements of second element, the result is 50
    cout << hours[1][0]; // get the hours array second elements of first element, the result is 66
    return(0);
}

Seperti yang ditunjukkan di bawah ini, baris ke-12 secara langsung menggunakan API dari FMZ Quant untuk mendapatkan array indikator KDJ, yang merupakan array dua dimensi: arr = [[K value, K value, K value...], [D value, D value, D value...], [J value, J value, J value...]]

Garis 13 adalah untuk mendapatkan nilai k dari garis K sebelumnya, nilai K adalah arr[0], kemudian mendapatkan elemen penultimate dari arr[0], arr[0].size() dapat digunakan untuk memperoleh panjang array dari arr[0], arr[0].size() - 2 adalah elemen terakhir kedua dari array, letakkan bersama adalah: auto k = arr [0] [arr [0].size () - 2 ]; baris 14 dan 15 adalah perhitungan yang sama.

double position = 0; // position status parameter, the default is 0 

bool onTick(string symbol){ // onTick function, all strategy logic are in this function
    auto ct = exchange.SetContractType(symbol); // set the contract type and trading variety
    if(ct == false){ // if the setting contract type and trading variety is not successful 
        return false; // return false
    }
    auto r = exchange.GetRecords(); // get the k-line array
    if(!r.Valid || r.size() < 10){ // if getting the k-line array or the number of k-line is less than 10
        return false; // return false
    }
    auto arr = TA.KDJ(r, 9, 3, 3); // calculate the KDJ indicator 
    auto k = arr[0][arr[0].size() - 2]; // get the K value of the previous K line 
    auto d = arr[1][arr[1].size() - 2]; // get the D value of the previous K line
    auto dPre = arr[1][arr[1].size() - 3]; // get the D value of the second last of the K line
}

void main(){ // program starts from here
    while (true){  // enter the loop
        if (exchange.IO("status") == 0) // if the connection with the exchange if not stable.
            sleep(1000); // pause for 1 second
            continue; // skip this loop, enter the next loop
        }
        if(!onTick("this_week")){ // if the connection with the exchange is stable, enter this if loop, start executing the onTick function
            sleep(1000); // pause for 1 second
        }
    }
}

Langkah 3: Membuat Pemesanan

Dengan data di atas, kita dapat menulis logika trading dan bagian penempatan order sekarang. juga sangat sederhana, yang paling umum digunakan adalah pernyataan if, yang dapat dijelaskan sebagai: jika kondisi 1 dan kondisi 2 benar, tempatkan order; jika kondisi 3 atau kondisi 4 benar, tempatkan order. seperti yang ditunjukkan di bawah ini:

double position = 0; // position status parameter, the default is 0 

bool onTick(string symbol){ // onTick function, all strategy logic are in this function
    auto ct = exchange.SetContractType(symbol); // set the contract type and trading variety
    if(ct == false){ // if the setting contract type and trading variety is not successful 
        return false; // return false
    }
    auto r = exchange.GetRecords(); // get the k-line array
    if(!r.Valid || r.size() < 10){ // if getting the k-line array or the number of k-line is less than 10
        return false; // return false
    }
    auto arr = TA.KDJ(r, 9, 3, 3); // calculate the KDJ indicator 
    auto k = arr[0][arr[0].size() - 2]; // get the K value of the previous K line 
    auto d = arr[1][arr[1].size() - 2]; // get the D value of the previous K line
    auto dPre = arr[1][arr[1].size() - 3]; // get the D value of the second last of the K line
    string action; // define a string variable action
    // if currently holding long position, and the previous K line's D value is less than the second last k line's D value, close all position
    // if currently holding short position, and the previous K line's D value is greater than the second last k line's D value, close all position
    if((d < dPre && position > 0) || (d > dPre && position <0)){
        action = "cover";
    }else if (k > d && position <= 0){ // if the previous K line's K value is greater than the previous K line's D value, and there are no long positions
        action = "buy"; // set the variable action to "buy"
    }else if (k < d && position >= 0){ // if the previous K line's K value is less than the previous K line's D value, and there are no short positions
        action = "sell"; // set the variable action to "sell"
    }
    if (action.size() > 0){ // if there are placing order instruction
        position = ext::Trade(action, symbol, 1); // calling the C++ trading class library, placing orders according the direction of variable "action". and also renew the position status. 
    }
    return true; // return true
    } 
}

void main(){ // program starts from here
    while (true){  // enter the loop
        if (exchange.IO("status") == 0) // if the connection with the exchange if not stable.
            sleep(1000); // pause for 1 second
            continue; // skip this loop, enter the next loop
        }
        if(!onTick("this_week")){ // if the connection with the exchange is stable, enter this if loop, start executing the onTick function
            sleep(1000); // pause for 1 second
        }
    }
}

Dalam kode di atas, baris 19 sampai 28 adalah logika trading dan kode untuk menempatkan order. Namun, sebelum ini, kita perlu mendefinisikan variabel string "action" pada baris 16, yang digunakan untuk membantu menentukan tindakan order.

Garis 19 sampai baris 21 adalah: jika saat ini memegang posisi panjang, dan nilai K garis sebelumnya s D kurang dari nilai D garis terakhir kedua k, tutup semua posisi, jika saat ini memegang posisi pendek, dan nilai K garis sebelumnya s D lebih besar dari nilai D garis terakhir kedua k, tutup semua posisi. dan ubah variabel action menjadi cover.

Baris 21 sampai baris 25 adalah: kondisi untuk membuka posisi panjang dan pendek.

Baris 26 sampai baris 28 menjalankan logika pemesanan. Pertama, menurut panjang variabel string action, dinilai apakah ada instruksi untuk menempatkan pesanan. Jika ada, kode akan masuk ke baris 27, dan kemudian memanggil perpustakaan kelas perdagangan FMZ Quant, melakukan fungsi pemesanan.

Ada dua tempat yang perlu dicatat:

Cobalah untuk (tetapi tidak harus) menulis logika strategi saat kondisi K-line saat ini ditetapkan, kemudian menempatkan order pada k-line berikutnya. atau kondisi k-line sebelumnya ditetapkan, menempatkan order pada k-line saat ini, dengan cara ini, hasil dari backtest dan kinerja pasar nyata tidak jauh berbeda.
Secara umum, logika posisi penutupan harus ditulis di depan logika posisi pembukaan. Tujuan dari ini adalah untuk mencoba membuat logika strategi memenuhi harapan Anda. Misalnya, jika logika strategi hanya memenuhi situasi di mana ia perlu melakukan arah yang berlawanan dari perdagangan setelah hanya menutup posisi, aturan situasi semacam ini adalah untuk menutup posisi pertama dan kemudian membuka posisi baru. Jika kita menulis logika posisi penutupan di depan logika posisi pembukaan, itu akan sempurna memenuhi aturan ini.

Untuk meringkas

Di atas kita belajar bagaimana menganalisis indikator teknis KDJ dan mengubahnya menjadi strategi perdagangan kuantitatif yang lengkap. Termasuk: pengenalan strategi, metode perhitungan indikator KDJ, logika strategi, kondisi perdagangan, implementasi kode strategi, dll. Melalui kasus strategi ini, kita tidak hanya mengenal metode pemrograman C ++ di platform FMZ Quant, tetapi juga berbagai strategi dapat disesuaikan sesuai dengan kasus di bagian ini.

Untuk mencapai strategi perdagangan kuantitatif adalah dengan meringkas pengalaman atau sistem perdagangan subjektif kita sendiri, dan kemudian mendapatkan data mentah yang diperlukan secara terpisah, dan menghitung data yang diperlukan untuk logika strategi, dan akhirnya memanggil API pemesanan pesanan untuk mewujudkan perdagangan.

Pemberitahuan bagian berikutnya

Sejauh ini, tutorial menulis strategi dalam seri ini telah berakhir, saya percaya bahwa jika Anda mengikuti tutorial langkah demi langkah yang membawa Anda ke sini, Anda akan mendapatkan banyak. Bagaimanapun, dari perspektif kursus dasar perdagangan kuantitatif, Jalan Panjang telah berjalan lebih dari setengah. Dalam bab terakhir, kami akan mengajarkan Anda cara menggunakan alat perdagangan backtesting FMZ Quant, dan cara menghindari lubang dalam backtesting dan membuat persiapan akhir untuk perdagangan pasar nyata. Meskipun ini adalah bagian kecil dari konten, ini adalah langkah besar dalam memasuki dunia perdagangan kuantitatif!

Latihan setelah sekolah

Cobalah untuk menerapkan algoritma indikator KDJ menggunakan bahasa C ++ pada platform FMZ Quant.
Cobalah untuk menggunakan pengetahuan dalam bagian ini untuk membuat strategi indikator CCI.

Lebih banyak

2019 FMZ - Semua hak dilindungi