una strategia di trading basata sulla teoria dell'onda di Elliott - pagina 10
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
E non ho intenzione di condividere la SOLUZIONE FATTA, ma la metodologia - per favore, nessun problema.
Buona fortuna e buone tendenze.
In generale è chiaro. Tutto è come nella tesi. C'è tutto, tranne quel semplice schema, senza il quale non funziona nulla ;o)! E lo schema è noto solo a chi lo ha inventato, e tutto il resto senza di esso è solo carta, che è tanto in giro. Attenzione però, sto solo affermando un fatto, senza altri significati. Ognuno deve comunque andare in bicicletta. È FOREX dopo tutto!)
Ed ecco un'altra domanda. Tutto questo è implementato su cosa? Su MT4?
Cioè, MT4 ha l'indicatore Murray che hai menzionato. È chiaro.
Ma cosa usate per calcolare i canali e Hearst? Usate anche voi MT4? Una volta avete menzionato la dimensione del codice di 0,5M. Cosa vuoi dire con questo? Il peso del testo di un programma di calcolo su mql4? Se è così, francamente non riesco a immaginare un tale volume. Perché, secondo la mia stima prudente, il testo di un tale programma dovrebbe essere di circa 10000 linee. Una semplice strategia di rumore bianco che uso prende solo 1000 linee, anche se semplicemente lancio 6 thread di trading in parallelo che usano informazioni da diversi timeframe ed è più facile (più conveniente per ulteriori modifiche) lasciare pezzi di tale codice nella sua forma attuale che trasformarli in 400-500 linee usando gli array (sebbene tali piani siano anche possibili in futuro). Cioè, l'esecuzione di un thread per un periodo di tempo richiederà 400-500 linee. Sto usando un Expert Advisor completamente funzionale che non ha bisogno di essere monitorato. Naturalmente non rifiuto il suo ulteriore miglioramento, ma finora ho già ottimizzato tutto ciò che poteva essere ottimizzato in esso nel tester. Ma c'è un certo interesse nei vostri metodi e cercherò di applicare qualcosa, se ci riesco, naturalmente.
PS: E il fatto che io non uso un solo filo di commercio con un grande lotto, ma diversi fili paralleli su diversi timeframe con piccoli lotti si spiega solo con il fatto che in questo tipo di commercio appare qualcosa come un effetto di filtraggio di massimo drawdown. Cioè, se avete diversi processi casuali (dinamiche di equilibrio di un thread), allora quando si sommano i saldi in un conto, il drawdown massimo sarà uguale alla somma dei drawdown di ogni thread diviso la radice quadrata del numero di thread, non la somma dei drawdown di ciascuno! Quindi, cerco di diminuire il drawdown massimo totale. Cioè, se hai 6 fili, ognuno con un drawdown di 50USD su 1,5 anni di storia, logicamente il drawdown totale di 6 fili dovrebbe essere 300USD, ma in pratica, questo importo dovrebbe essere diviso per la radice quadrata di 6 = 2,45. Questo è più o meno quello che mostra il tester. Il tester mostra che si dovrebbe dividere per circa 2,2. Il che penso sia in accordo con la mia idea di ridurre il drawdown massimo.
Buona fortuna e buone tendenze.
Mi permetto di non essere d'accordo con lei. Questo thread è diventato interessante solo quando avete deciso di condividere le vostre esperienze e idee.
Come fisico, capisco tutto del campo, delle potenzialità, ecc. Tutto è chiaro anche con l'ottimizzazione - è un problema non banale e interessante. Per quanto riguarda la statistica matematica, ho potuto solo capire di cosa si tratta in termini generali, ahimè. Ma l'argomento è interessante. Soprattutto in parte della stima a priori dei livelli di significatività e della possibilità di predizione non casuale.
Il mio approccio (finora) si è concentrato sulla definizione dei periodi di mercato di tendenza. Non ho usato l'indice Hearst nella forma indicata nell'articolo sopra, né in nessun altro modo. Tuttavia, anch'io cerco di basarmi su una misura della frattalità del mercato che ha un mio algoritmo di calcolo. L'idea che i periodi di controtendenza possano essere usati altrettanto bene dei periodi di tendenza mi ha sorpreso completamente. A volte è difficile vedere anche quello che c'è sotto. :-)
Quindi continuerei volentieri il dialogo, se non su questo forum, allora tramite la tua email data nell'indicatore dei livelli Murray, o sullo spider in privato.
Comunque vorrei dire: il tuo lavoro mi ha impressionato! Per la prima volta ho visto l'opera non del "pensiero figurativo" di un dilettante (di cui faccio parte), ma della matematica nelle mani di un matematico.
Questo mi è piaciuto particolarmente:
La convergenza dei risultati su diversi flussi di dati e senza usare lo smoothing significa che la tua metodologia ha raggiunto la natura del processo!
Nessun problema.
La convergenza dei risultati su diversi flussi di dati e senza usare lo smoothing significa che la tua metodologia ha raggiunto la natura del processo!
Lo metterei un po' più modestamente - significa che i metodi matstatistici funzionano - hanno solo bisogno di essere applicati correttamente, e che ancora molti metodi TA hanno una giustificazione. (cioè ci sono aree di movimento predeterminate nel mercato). I metodi qualitativi come Elliott o Gann, anche se, come ho scritto - non mi piace molto Elliott a causa della mancanza di stime quantitative.
Comunque, buona fortuna e buone tendenze.
Cercate "Encyclopedia of Trading Strategies" di McCormick e "Statistics for Traders" di Bulashev - molto utile in senso applicato - viene mostrata la logica dei metodi.
Provate la trasformazione DCT con kernel di diffrazione - leviga molto bene, non ha alcun ritardo. IMHO, funziona meglio del LCF tradizionale. Qui sotto ci sono alcuni pezzi di codice in C++. Il modo di usarlo, penso, è chiaro dai commenti.
//*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Прямое дискретное косинус-преобразование (DCT) x[] --> y[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // входной массив Входные локальные переменные: int n_bars // полное число баров для DCT-преобразования Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // массив гармоник */ void DCT(int n_bars, double x [], double y []) { int k; // счетчик строк матрицы коэффициентов int n; // счетчик столбцов матрицы коэффициентов double sum; // накопитель double PIN2 = PI / (n_bars * 2.0); double wgt_zero = 1.0 / sqrt(n_bars); // вес при 0-м коэффициенте double wgt_nzero = sqrt(2.0) * wgt_zero; // вес при всех остальных //---- // dct-преобразование for (k = 0; k < n_bars; k++) { // цикл по k sum = 0.0; // обнуляем накопитель for (n = 0; n < n_bars; n++) { sum += x[n] * cos(PIN2 * (2.0 * n + 1.0) * k); } // цикл по n if (k != 0) { y[k] = wgt_nzero * sum; } else { y[k] = wgt_zero * sum; } } // цикл по k //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Обратное дискретное косинус-преобразование (IDCT) y[] --> x[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double y[] // массив гармоник Входные локальные переменные: int n_bars // полное число баров для DCT-преобразования Выходные локальные переменные: нет Выходные глобальные переменные: double x[] // выходной массив */ void IDCT(int n_bars, double x [], double y []) { int k; // счетчик строк матрицы коэффициентов int n; // счетчик столбцов матрицы коэффициентов double sum; // накопитель double PIN2 = PI / (n_bars * 2.0); double wgt_zero = 1.0 / sqrt(n_bars); // вес при 0-м коэффициенте double wgt_nzero = sqrt(2.0) * wgt_zero; // вес при всех остальных //---- // idct-преобразование for (n = 0; n < n_bars; n++) { // цикл по n sum = 0.0; // обнуляем накопитель for (k = 0; k < n_bars; k++) { // цикл по k if (k != 0) { sum += wgt_nzero * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); } else { sum += wgt_zero * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); } } // цикл по k x[n] = sum; } // цикл по n //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Вычисление левой части уравнения y[] --> y[] (диффракционное ядро) |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double y[] // массив гармоник Входные локальные переменные: int n_bars // полное число баров для расчета double eye // размер "окна" double alfa // параметр регуляризации Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // массив значений левой части уравнения */ void GetDiffrLeftSide(int n_bars, double eye, double alfa, double y []) { double kern; // double omega; // double domega; // double omega2; // 1 + omega^2 double delta = 2.0 * PI / (n_bars - 1); int i; //---- for (i = 0; i < n_bars; i++) { omega = i * delta; domega = omega * eye; omega2 = 1.0 + omega * omega; // 1. + omega^2 kern = (sin(domega) + EPS) / (domega + EPS); // sin(arg)/arg y[i] = (kern * y[i]) / (kern * kern + alfa * omega2); } //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Линейное сглаживание массива x[] по 5 точкам; результат - y[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // входной массив - аргумент; Входные локальные переменные: int n_beg // номер начального бара int n_end // номер конечного бара Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // выходной массив - ответ; */ void GetSmooth5(int n_beg, int n_end, double x [], double y []) { int i; //---- y[n_beg] = (3.0 * x[n_beg] + 2.0 * x[n_beg+1] + x[n_beg+2] - x[n_beg+4]) / 5.0; y[n_beg+1] = (4.0 * x[n_beg] + 3.0 * x[n_beg+1] + 2.0 * x[n_beg+2] + x[n_beg+3]) / 10.0; for (i = n_beg + 2; i < n_end - 2; i++) { y[i] = (x[i-2] + x[i-1] + x[i] + x[i+1] + x[i+2]) / 5.0; } y[n_end-2] = (x[n_end-4] + 2.0 * x[n_end-3] + 3.0 * x[n_end-2] + 4.0 * x[n_end-1]) / 10.0; y[n_end-1] = (3.0 * x[n_end-1] + 2.0 * x[n_end-2] + x[n_end-3] - x[n_end-5]) / 5.0; //---- return; } //E questo è il metodo di applicazione:
// //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Сглаживание методом DCT-преобразования (без запаздывания) |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // несглаженный массив значений аргумента (цена); Входные локальные переменные: int n_bars // полное число баров для преобразования double eye // размер "окна" double alfa // параметр регуляризации Выходные локальные переменные: int nn_tot // число сглаженных баров Выходные глобальные переменные: double x[] // ответ - сглаженный массив значений аргумента; */ MT4_EXPFUNC int __stdcall GetDiffrDCTS (int nn_tot, double eye, double alfa, double x []) { int err_code = 0; // код ошибки int i; // счетчик // // ########################### Error Definitions ########################### // *** Ошибка: если превышено максимальное число баров, выход *** if (nn_tot > NN_MAX) { err_code = -1; return(err_code); } // *** Ошибка: для преобразования задано слишком мало баров, выход *** if (nn_tot < NN_MIN) { err_code = -2; return(err_code); } // *** Ошибка: параметр alfa = 0 при eye <> 0, выход *** if ((alfa == 0.0) && (eye != 0.0)) { err_code = -3; return(err_code); } // *** Ошибка: параметр eye_size < 0, выход *** if (eye < 0.0) { err_code = -4; return(err_code); } // *** Ошибка: параметр eye_alfa < 0, выход *** if (alfa < 0.0) { err_code = -5; return(err_code); } // ######################################################################### // //---- // DCT (nn_tot, x, y); // x[] --> y[] GetDiffrLeftSide (nn_tot, eye, alfa, y); // y[] --> y[] IDCT (nn_tot, x, y); // y[] --> x[] GetSmooth5 (0, nn_tot, x, y); // x[] --> y[] for (i = 0; i < nn_tot; i++) { x[i] = y[i]; } // y[] --> x[] // //---- err_code = nn_tot; return(err_code); } //Provate, per esempio, i parametri Eye = 2,5, Alfa = 0,5. È importante ricordare che la combinazione (Eye !=0, Alfa == 0) non è ammessa. L'EPS è usato per evitare incertezze come 0/0. Prendo EPS = 1.0E-09.
L'array lisciato deve essere normalizzato all'intervallo di variazione del prezzo su nn_tot barre:
// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Нормировка результов вычислений на заданный диапазон значений |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // неномированный массив значений аргумента; Входные локальные переменные: int n_beg // номер начального бара int n_end // номер конечного бара double v_max // максимальное значение диапазона для нормировки; double v_min // минимальное значение диапазона для нормировки; Выходные локальные переменные: нет Выходные глобальные переменные: double x[] // ответ - нормированный массив значений аргумента; */ MT4_EXPFUNC int __stdcall NormRange(int n_beg, int n_end, double v_max, double v_min, double x []) { int err_code = 0; // возвращаемый код ошибки double x_max; // максимальное значение в нормируемом массиве double x_min; // минимальное значение в нормируемом массиве double x_curr; // текущее ненормированное значение double x_norm; // текущее нормированное значение double coef_1; // 1-й нормировочный коэффициент double coef_2; // 2-й нормировочный коэффициент double diff_x; // разность x_max - x_min int n_bars; // n_end - n_beg int i; // счетчик // n_bars = n_end - n_beg; // ########################### Error Definitions ########################### // *** Ошибка: если перепутаны местами начальный и конечный бары, выход *** if (n_bars < 0) { err_code = -6; return(err_code); } // *** Ошибка: если превышено максимальное число баров, выход *** if ((n_bars > 0) && (n_bars > NN_MAX)) { err_code = -1; return(err_code); } // *** Ошибка: для преобразования задано слишком мало баров, выход *** if ((n_bars > 0) && (n_bars < NN_MIN)) { err_code = -2; return(err_code); } // ######################################################################### // //---- // находим максимумы и минимумы в массиве результата x_min = 999999999.0; x_max = -999999999.0; for (i = n_beg; i < n_end; i++) { x_curr = x[i]; if (x_curr >= x_max) { x_max = x_curr; } if (x_curr <= x_min) { x_min = x_curr; } } diff_x = x_max - x_min; // // ########################### Error Definitions ########################### // *** Ошибка: diff_x = 0 *** if (diff_x == 0.0) { err_code = -7; return(err_code); } // ######################################################################### // // находим коэффициенты пересчета coef_1 = (v_min * x_max - v_max * x_min) / diff_x; coef_2 = (v_max - v_min) / diff_x; // нормируем результат на заданный диапазон for (i = n_beg; i < n_end; i++) { x_curr = x[i]; x_norm = coef_1 + x_curr * coef_2; x[i] = x_norm; } //---- return(err_code); } //Le variabili v_max e v_min devono essere ottenute prima, quando si forma la matrice dei prezzi per l'elaborazione.
capisco il tuo desiderio di fare a meno dei paroloni e il tuo atteggiamento verso i metodi della matstatistica.
Tuttavia, io ho un'opinione diversa.
Il mercato è un processo non stazionario e caotico. E la matstatistica si occupa principalmente di processi stazionari. La transizione al limite è uno dei principali metodi di dimostrazione delle affermazioni. E qual è lo stato limite del mercato? Il moto browniano è un fenomeno in un sistema chiuso, mentre il mercato è un sistema sostanzialmente aperto. D'altra parte, il mercato è un processo di auto-organizzazione, quindi ci sono leggi di questa auto-organizzazione.
Dal mio punto di vista, il vostro successo non è dovuto all'applicazione di metodi matstatistici,
ma alle LIMITAZIONI sui metodi matstatistici da parte della parte costruttiva della vostra strategia.
Queste limitazioni sono ciò che ha aiutato a cogliere qualcosa di importante, senza lasciare che il metodo (cioè lo strumento) lo dissolva nei dettagli dell'applicazione.
Grazie per i libri, darò sicuramente un'occhiata.
Il tuo nickname sullo spider è lo stesso?
Sul ragno è VG .
Buona fortuna e in bocca al lupo per i trnd.
Queste tre fonti significano che le stai usando insieme a MT4 (sembra di sì). E come sarebbe se non ci fosse un ambiente C da compilare?
Queste tre fonti significano che le stai usando insieme a MT4 (sembra di sì). E come sarebbe se non ci fosse un ambiente C da compilare?
Si potrebbe provare in MT. Originariamente erano programmati in MQL per il debug, e poi sono stati spostati con modifiche minime in C. E la versione più vecchia era in assembler.