une stratégie commerciale basée sur la théorie des vagues d'Elliott - page 10
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Et je ne vais pas partager la SOLUTION FAITE, mais la méthodologie - s'il vous plaît, pas de problème.
Bonne chance et bonnes tendances.
En général, c'est clair. Tout est comme dans la thèse. Il y a tout, sauf ce simple schéma, sans lequel rien ne fonctionnera ;o) ! Et le schéma n'est connu que de ceux qui l'ont inventé, et tout le reste sans lui n'est que du papier, qui est tellement autour. Mais attention, je ne fais qu'énoncer un fait, sans autre signification. Chacun doit de toute façon utiliser son propre vélo. C'est le FOREX après tout !)
Et voici une autre question. Tout cela est mis en œuvre sur quoi ? Sur MT4 ?
C'est-à-dire que MT4 possède l'indicateur Murray que vous avez mentionné. C'est clair.
Mais qu'utilisez-vous pour calculer les chaînes et Hearst ? Utilisez-vous également MT4 ? Vous avez mentionné une fois la taille du code de 0.5M. Qu'est-ce que vous entendez par là ? Le poids du texte d'un programme de calcul sur mql4 ? Si c'est le cas, franchement, j'ai du mal à imaginer un tel volume. Car, selon mon estimation prudente, le texte d'un tel programme devrait compter environ 10000 lignes. Une simple stratégie de bruit blanc que j'utilise ne prend que 1000 lignes, même si je lance simplement 6 threads de trading en parallèle qui utilisent des informations provenant de différents horizons temporels et qu'il est plus facile (plus pratique pour des modifications ultérieures) de laisser des morceaux de ce code dans sa forme actuelle que de les transformer en 400-500 lignes en utilisant des tableaux (bien que de tels plans soient également possibles à l'avenir). En d'autres termes, l'exécution d'un fil par une période de temps prendra 400 à 500 lignes. J'utilise un conseiller expert entièrement fonctionnel qui n'a pas besoin d'être surveillé. Bien sûr, je ne refuse pas son amélioration ultérieure, mais jusqu'à présent, j'ai déjà optimisé tout ce qui pouvait l'être dans le testeur. Mais il y a un certain intérêt pour vos méthodes et j'essaierai d'y appliquer quelque chose, si je réussis bien sûr.
PS : Et le fait que j'utilise non pas un fil de trade avec un grand lot, mais plusieurs fils parallèles sur des timeframes différents avec des petits lots s'explique uniquement par le fait que dans ce type de trade apparaît quelque chose comme un effet de filtration du drawdown maximum. En d'autres termes, si vous avez plusieurs processus aléatoires (dynamique de l'équilibre d'un fil), alors lorsque vous additionnez les soldes dans un compte, le drawdown maximal sera égal à la somme des drawdowns de chaque fil divisée par la racine carrée du nombre de fils, et non à la somme des drawdowns de chacun ! Ainsi, j'essaie de diminuer le drawdown maximal total. C'est-à-dire que si vous avez 6 fils, chacun avec un drawdown de 50USD sur un historique de 1,5 an, logiquement le drawdown total des 6 fils devrait être de 300USD, mais en pratique, ce montant devrait être divisé par la racine carrée de 6 = 2,45. C'est à peu près ce que montre le testeur. Le testeur montre que vous devez diviser par environ 2,2. Ce qui, je pense, correspond bien à mon idée de réduire le drawdown maximum.
Bonne chance et bonnes tendances.
Je ne suis pas d'accord avec vous. Ce fil de discussion n'est devenu intéressant que lorsque vous avez décidé de partager vos expériences et vos idées.
En tant que physicien, je comprends tout du champ, de la potentialité, etc. Tout est clair aussi en ce qui concerne l'optimisation - c'est un problème non trivial et intéressant. Quant aux statistiques mathématiques, je n'ai pu saisir ce dont il s'agit que de manière générale, hélas. Mais le sujet est intéressant. Surtout en ce qui concerne l'estimation a priori des niveaux de signification et la possibilité d'une prédiction non aléatoire.
Mon approche (jusqu'à présent) s'est concentrée sur la définition de périodes de marché à tendance. Je n'ai pas utilisé l'index Hearst sous la forme indiquée dans l'article ci-dessus, ni d'aucune autre manière. Cependant, j'essaie moi aussi de m'appuyer sur une mesure de la fractalité du marché qui dispose de mon propre algorithme de calcul. L'idée que les périodes de contre-tendance peuvent être utilisées tout aussi bien que les périodes de tendance m'a complètement surpris. Parfois, il est même difficile de voir ce qui se cache en dessous. :-)
C'est donc avec plaisir que je poursuivrai le dialogue, si ce n'est pas sur ce forum, mais par l'intermédiaire de votre adresse électronique indiquée dans l'indicateur des niveaux de Murray, ou sur l'araignée en privé.
En tout cas, je voudrais dire que votre travail m'a impressionné ! Pour la première fois, j'ai vu le travail non pas de la "pensée figurative" d'un amateur (dont je fais partie), mais des mathématiques dans les mains d'un mathématicien.
J'ai particulièrement aimé celui-ci :
Faire converger les résultats sur différents flux de données et sans utiliser de lissage signifie que votre méthodologie s'est adaptée à la nature du processus !
Pas de problème .
Faire converger les résultats sur différents flux de données et sans utiliser de lissage signifie que votre méthodologie s'est adaptée à la nature du processus !
Je le dirais un peu plus modestement - cela signifie que les méthodes matstatiques fonctionnent - il suffit de les appliquer correctement, et que de nombreuses méthodes TA sont encore justifiées. (c'est-à-dire qu'il existe des zones de mouvement prédéterminées sur le marché). Les méthodes qualitatives telles que Elliott ou Gann, bien que, comme je l'ai écrit - je n'aime pas beaucoup Elliott en raison du manque d'estimations quantitatives.
En tout cas, bonne chance et bonnes tendances.
Recherchez "Encyclopedia of Trading Strategies" de McCormick et "Statistics for Traders" de Bulashev - très utiles dans un sens appliqué - la logique des méthodes est montrée.
Essayez la transformation DCT avec le noyau de diffraction - elle lisse très bien, sans aucun décalage. IMHO, il fonctionne mieux que le LCF traditionnel. Vous trouverez ci-dessous quelques morceaux de code en C++. La façon de l'utiliser, je pense, est claire d'après les commentaires.
//*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Прямое дискретное косинус-преобразование (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; } //Et voici la méthode d'application :
// //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Сглаживание методом 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); } //Essayez, par exemple, les paramètres Eye = 2,5, Alfa = 0,5. Il est important de se rappeler que la combinaison (Eye !=0, Alfa == 0) n'est pas autorisée. L'EPS est utilisé pour éviter les incertitudes comme 0/0. Je prends EPS = 1.0E-09.
Le tableau lissé doit être normalisé à la plage de variation des prix sur nn_tot barres :
// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Нормировка результов вычислений на заданный диапазон значений |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: 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); } //Les variables v_max et v_min doivent être obtenues plus tôt, lors de la formation du tableau des prix pour le traitement.
Je comprends votre désir de vous passer des grands mots et votre attitude à l'égard des méthodes de la matstatique.
Cependant, j'ai une opinion différente.
Le marché est un processus non stationnaire et chaotique. Et les matstatiques traitent principalement des processus stationnaires. Le passage à la limite est l'une des principales méthodes pour prouver les affirmations. Et quel est l'état limite du marché ? Le mouvement brownien est un phénomène dans un système fermé, alors que le marché est un système essentiellement ouvert. D'autre part, le marché est un processus d'auto-organisation, il existe donc des lois de cette auto-organisation.
De mon point de vue, votre succès n'est pas dû à l'application des méthodes matstatiques,
mais aux LIMITATIONS des méthodes matstatiques de la part de la partie constructive de votre stratégie.
Ce sont ces limites qui ont permis de saisir quelque chose d'important, sans laisser la méthode (c'est-à-dire l'outil) le dissoudre dans les détails de l'application.
Merci pour les livres, je vais certainement y jeter un œil.
Votre surnom sur l'araignée est-il le même ?
Sur l'araignée, c'est VG .
Bonne chance et bonne chance avec les trnds.
Ces trois sources signifient-elles que vous les utilisez en conjonction avec MT4 (cela y ressemble) ? Et qu'en serait-il s'il n'y avait pas d'environnement C à compiler ?
Ces trois sources signifient-elles que vous les utilisez en conjonction avec MT4 (cela y ressemble) ? Et qu'en serait-il s'il n'y avait pas d'environnement C à compiler ?
Vous pourriez l'essayer dans MT. À l'origine, ils étaient programmés en MQL pour le débogage, puis ils ont été déplacés avec des changements minimes vers le C. Et la version la plus ancienne était en assembleur.