eine Handelsstrategie auf der Grundlage der Elliott-Wellen-Theorie - Seite 10
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Und ich werde nicht die GESCHLOSSENE LÖSUNG mitteilen, sondern die Methodik - bitte, kein Problem.
Viel Glück und glückliche Trends.
Im Allgemeinen ist das klar. Alles ist wie in der Diplomarbeit. Es gibt alles, außer diesem einfachen Schema, ohne das nichts geht ;o)! Und der Schaltplan ist nur denen bekannt, die ihn erfunden haben, und alles andere ist nur Papier, das so viel herumliegt. Wohlgemerkt, ich gebe nur eine Tatsache an, ohne eine andere Bedeutung zu haben. Jeder muss sowieso mit seinem eigenen Fahrrad fahren. Es ist schließlich FOREX!)
Und hier noch eine Frage. Wofür wird das alles eingesetzt? Auf MT4?
Das heißt, MT4 hat den von Ihnen erwähnten Murray-Indikator. Das ist klar.
Aber womit berechnen Sie Kanäle und Hearst? Verwenden Sie auch MT4? Sie haben einmal die Codegröße von 0,5M erwähnt. Was meinen Sie damit? Das Gewicht des Textes eines Berechnungsprogramms auf mql4? Wenn ja, kann ich mir eine solche Menge, ehrlich gesagt, kaum vorstellen. Denn nach meiner vorsichtigen Schätzung müsste der Text eines solchen Programms etwa 10000 Zeilen umfassen. Eine einfache White-Noise-Strategie, die ich verwende, nimmt nur 1000 Zeilen in Anspruch, obwohl ich einfach 6 Handels-Threads parallel starte, die Informationen aus verschiedenen Zeitrahmen verwenden, und es ist einfacher (bequemer für weitere Änderungen), Teile eines solchen Codes in seiner jetzigen Form zu belassen, als sie in 400-500 Zeilen unter Verwendung von Arrays umzuwandeln (obwohl solche Pläne auch in Zukunft möglich sind). Das bedeutet, dass die Ausführung eines Threads durch einen Zeitrahmen 400-500 Zeilen in Anspruch nimmt. Ich verwende einen voll funktionsfähigen Expert Advisor, der nicht überwacht werden muss. Natürlich schließe ich eine weitere Verbesserung nicht aus, aber bis jetzt habe ich schon alles optimiert, was im Tester optimiert werden konnte. Aber es besteht ein gewisses Interesse an Ihren Methoden, und ich werde versuchen, etwas davon anzuwenden, wenn es mir gelingt, versteht sich.
PS: Und die Tatsache, dass ich nicht einen einzigen Handelsfaden mit einem großen Lot verwende, sondern mehrere parallele Fäden auf verschiedenen Zeitrahmen mit kleinen Lots, erklärt sich allein aus der Tatsache, dass bei dieser Art von Handel so etwas wie ein maximaler Drawdown-Filtereffekt auftritt. Das heißt, wenn Sie mehrere Zufallsprozesse haben (Gleichgewichtsdynamik eines Threads), dann wird bei der Summierung der Salden in einem Konto der maximale Drawdown gleich der Summe der Drawdowns jedes Threads geteilt durch die Quadratwurzel der Anzahl der Threads sein, nicht die Summe der Drawdowns jedes Threads! Daher versuche ich, den gesamten maximalen Drawdown zu verringern. Das heißt, wenn Sie 6 Threads haben, jeder mit einem Drawdown von 50USD auf 1,5 Jahre Historie, sollte der Gesamtdrawdown von 6 Threads logischerweise 300USD betragen, aber in der Praxis sollte dieser Betrag durch die Quadratwurzel von 6 = 2,45 geteilt werden. Das ist in etwa das, was das Prüfgerät anzeigt. Der Tester zeigt an, dass Sie durch etwa 2,2 dividieren sollten. Das deckt sich meiner Meinung nach gut mit meiner Idee, die maximale Inanspruchnahme zu reduzieren.
Viel Glück und gute Trends.
Da muss ich Ihnen widersprechen. Dieser Thread wurde erst interessant, als Sie sich entschlossen, Ihre Erfahrungen und Ideen mitzuteilen.
Als Physikerin verstehe ich alles über das Feld, die Potenzialität usw. Auch bei der Optimierung ist alles klar - sie ist ein nicht triviales und interessantes Problem. Was die mathematische Statistik betrifft, so konnte ich sie leider nur in allgemeiner Form begreifen. Aber das Thema ist interessant. Insbesondere in Bezug auf die a priori-Schätzung der Signifikanzniveaus und die Möglichkeit einer nicht zufälligen Vorhersage.
Mein Ansatz hat sich (bisher) auf die Definition von Trendmarktperioden konzentriert. Ich habe den Hearst-Index weder in der im obigen Artikel beschriebenen Form noch in irgendeiner anderen Form verwendet. Aber auch ich versuche, mich auf ein Maß für die Fraktalität des Marktes zu stützen, für das ich einen eigenen Berechnungsalgorithmus habe. Der Gedanke, dass Gegen-Trend-Perioden genauso gut genutzt werden können wie Trend-Perioden, hat mich völlig überrascht. Manchmal ist es schwer zu erkennen, was darunter liegt. :-)
Ich würde mich freuen, den Dialog fortzusetzen, wenn nicht in diesem Forum, dann über Ihre E-Mail in der Murray Ebenen Indikator gegeben, oder auf der Spinne in der privaten Nachricht.
Auf jeden Fall möchte ich sagen: Ihre Arbeit hat mich beeindruckt! Zum ersten Mal sah ich, dass es sich nicht um die Arbeit eines Amateurs handelte (zu dem ich mich selbst zähle), sondern um Mathematik in den Händen eines Mathematikers.
Dieser hat mir besonders gut gefallen:
Die Konvergenz der Ergebnisse bei verschiedenen Datenströmen und ohne Glättung bedeutet, dass Ihre Methodik die Natur des Prozesses erfasst hat!
Kein Problem.
Die Konvergenz der Ergebnisse bei verschiedenen Datenströmen und ohne Glättung bedeutet, dass Ihre Methodik die Natur des Prozesses erfasst hat!
Ich würde es etwas bescheidener ausdrücken - es bedeutet, dass die Methoden der Mathematik funktionieren - sie müssen nur richtig angewandt werden, und dass immer noch viele TA-Methoden ihre Berechtigung haben. (d.h. es gibt Bereiche, in denen der Markt eine bestimmte Bewegung aufweist). Die qualitativen Methoden wie Elliott oder Gann, obwohl ich - wie ich schon schrieb - Elliott wegen des Mangels an quantitativen Schätzungen nicht besonders mag.
Wie auch immer, viel Glück und gute Trends.
Suchen Sie nach McCormicks "Encyclopedia of Trading Strategies" und Bulashevs "Statistics for Traders" - sehr nützlich in einem angewandten Sinne - die Logik der Methoden wird aufgezeigt.
Versuchen Sie die DCT-Transformation mit Beugungskern - sie glättet sehr gut und verzögert überhaupt nicht. Meiner Meinung nach funktioniert es besser als das traditionelle LCF. Nachfolgend finden Sie einige Teile des C++-Codes. Die Art und Weise, wie sie zu verwenden ist, geht meines Erachtens aus den Kommentaren hervor.
//*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Прямое дискретное косинус-преобразование (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; } //Und das ist die Methode der Anwendung:
// //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Сглаживание методом 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); } //Versuchen Sie es zum Beispiel mit den Parametern Auge = 2,5, Alfa = 0,5. Es ist wichtig, daran zu denken, dass die Kombination (Auge !=0, Alfa == 0) nicht zulässig ist. Das EPS wird verwendet, um Unsicherheiten wie 0/0 zu vermeiden. Ich nehme EPS = 1,0E-09.
Das geglättete Array muss auf den Bereich der Preisänderung über nn_tot Bars normalisiert werden:
// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Нормировка результов вычислений на заданный диапазон значений |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: 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); } //Die Variablen v_max und v_min sollten vorher ermittelt werden, wenn das Preisfeld für die Verarbeitung gebildet wird.
Ich verstehe Ihren Wunsch, auf große Worte zu verzichten und Ihre Einstellung zu den Methoden der Mathematik.
Ich habe jedoch eine andere Meinung.
Der Markt ist ein nichtstationärer, chaotischer Prozess. Und die Mathematik beschäftigt sich hauptsächlich mit stationären Prozessen. Der Übergang zum Grenzwert ist eine der wichtigsten Methoden, um Aussagen zu beweisen. Und wie sieht es mit der Grenzlage des Marktes aus? Die Brownsche Bewegung ist ein Phänomen in einem geschlossenen System, während der Markt ein im Wesentlichen offenes System ist. Andererseits ist der Markt ein sich selbst organisierender Prozess, daher gibt es Gesetze für diese Selbstorganisation.
Meines Erachtens ist Ihr Erfolg nicht auf die Anwendung mathematischer Methoden zurückzuführen (
), sondern auf die EINSCHRÄNKUNGEN der mathematischen Methoden auf Seiten des konstruktiven Teils Ihrer Strategie.
Diese Einschränkungen haben dazu beigetragen, etwas Wichtiges zu erfassen, ohne dass die Methode (d. h. das Werkzeug) es in den Details der Anwendung auflöst.
Danke für die Bücher, die werde ich mir auf jeden Fall ansehen.
Ist Ihr Spitzname auf der Spinne derselbe?
Bei der Spinne ist es VG .
Viel Glück und viel Erfolg bei den Trnds.
Bedeuten diese drei Quellen, dass Sie sie in Verbindung mit MT4 verwenden (sieht so aus). Und wie würde es sich anfühlen, wenn es keine C-Umgebung zum Kompilieren gäbe?
Bedeuten diese drei Quellen, dass Sie sie in Verbindung mit MT4 verwenden (sieht so aus). Und wie würde es sich anfühlen, wenn es keine C-Umgebung zum Kompilieren gäbe?
Sie können es in MT versuchen. Ursprünglich wurden sie zum Debuggen in MQL programmiert, dann wurden sie mit minimalen Änderungen nach C verschoben, und die älteste Version war in Assembler.