Experte auf der Grundlage der Elliott-Wellen-Theorie - Seite 12

Neuer Kommentar
 
Yurixx:
Ganzzahlig:
Yurixx:


Stellen Sie sich einen einfachen TS vor, der auf einem normalisierten Oszillator basiert: Bei den Höchstständen verkaufen wir, bei den Tiefstständen kaufen wir. Es genügt also, das Extremum zum richtigen Zeitpunkt zu erkennen, um erfolgreich zu handeln. Einfach, nicht wahr? Und auf jeden Fall genug. Können Sie es schnell machen (nicht sehr schnell)? Oder tun Sie es wenigstens einfach?


Kann und sehr und schnell.


Großartig! Dann werfen Sie einen RSI(14,Close)-Indikator auf EURUSD, M1 und lösen Sie das Problem der Identifizierung von RSI-Extremwerten ohne Verzögerung.

Die Amplitude der RSI-Änderung zwischen benachbarten Extremen sollte mindestens 25 betragen.


Formulieren Sie das Problem genau und vollständig. Wenn sie theoretisch lösbar ist, ist sie auch praktisch lösbar. Wenn das Problem richtig formuliert ist, können sie alle gelöst werden (und Sie können es selbst tun). Bei diesem Problem besteht das Kriterium zur Identifizierung eines Extremwerts darin, einen Wert um 25 Einheiten zurückzudrehen, d. h. die Identifizierung anhand eines solchen Kriteriums ohne Verzögerung kann theoretisch nicht gelöst werden. Wenn Sie ein Kriterium definieren - mehr als 25 auf der linken Seite und mehr als 5, aber weniger als 10 auf der rechten Seite - wird die Verzögerung geringer, aber die Zahl der Fehlsignale größer.

  
//+------------------------------------------------------------------+
//|                                                     toYurixx.mq4 |
//|                                                                * |
//|                                                                * |
//+------------------------------------------------------------------+
#property copyright "*"
#property link      "*"
 
#property indicator_separate_window
#property indicator_maximum 100
#property indicator_minimum 0
#property indicator_buffers 3
#property indicator_color1 Yellow
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Red
//---- input parameters
extern int       RightMore=5;
extern int       RightLess=10;
extern int       LeftMore=25;
 
 
//---- buffers
double rsi[];
double u[];
double l[];
 
 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,rsi);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexBuffer(1,u);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,l);
   SetIndexEmptyValue(2,0.0);
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    limit=Bars-IndicatorCounted();
      for(int i=0;i<limit;i++){
         rsi[i]=iRSI(NULL,0,14,0,i);
      }
      ArrayInitialize(u,EMPTY_VALUE);
      ArrayInitialize(l,EMPTY_VALUE);      
      for(i=Bars-1;i>=0;i--){
         double max=rsi[i];
         int maxb;
         for(int j=i;j<Bars;j++){
               if(rsi[j]>max){
                  max=rsi[j];
                  maxb=j;
               }
               if(max-rsi[i]>RightLess){
                  break;//не состоялся
               }
               if(max-rsi[j]>LeftMore){
                     if(max-rsi[i]>RightMore){//нашли
                        u[maxb]=rsi[maxb];
                     }
                  break;
               }
         }
         
         max=rsi[i];
         for(j=i;j<Bars;j++){
               if(rsi[j]<max){
                  max=rsi[j];
                  maxb=j;
               }
               if(rsi[i]-max>RightLess){
                  break;//не состоялся
               }
               if(rsi[j]-max>LeftMore){
                     if(rsi[i]-max>RightMore){//нашли
                        l[maxb]=rsi[maxb];
                     }
                  break;
               }
         }         
         
      }
      
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
 

Insgesamt 23.06.2007 01:45 - 23.06.2007 01:08 = 37 Minuten habe ich gebraucht, um das Problem zu lösen, aber ich hatte auch Kaffee für diese Zeit. Ich sollte auch das Kriterium der Anzahl der Balken links und rechts vom Extremwert einführen.

 
Integer:
Yurixx:


Großartig! Dann werfen wir den RSI(14,Close) Indikator auf EURUSD, M1 und lösen das Problem der Identifizierung ohne eine Verzögerung von RSI Extrema.

Die Amplitude der RSI-Änderung zwischen benachbarten Extrema muss mindestens 25 betragen.


Formulieren Sie das Problem genau und vollständig. Wenn sie theoretisch lösbar ist, ist sie auch praktisch lösbar. Wenn das Problem richtig formuliert ist, können sie alle gelöst werden (und Sie können es selbst tun). Bei diesem Problem ist das Kriterium für die Identifizierung eines Extremums ein Rollback von 25 Einheiten, d.h. die Identifizierung durch ein solches Kriterium ohne Verzögerung kann theoretisch nicht gelöst werden. Wenn Sie ein Kriterium definieren - mehr als 25 auf der linken Seite und mehr als 5, aber weniger als 10 auf der rechten Seite - wird die Verzögerung geringer, aber die Zahl der Fehlsignale größer.


Natürlich danke ich Ihnen für den Code, aber er ist, wie Sie selbst verstehen, nicht die Lösung und nicht das Problem.

Ich habe mich vielleicht zu kurz gefasst, aber es ist eigentlich eine ganz richtige Aussage. Sie kann länger sein. Erforderlich ist ein Verfahren zur Ermittlung eines lokalen Extremwerts, das in Echtzeit und nicht in der Vergangenheit funktioniert. Identifizierung bedeutet, dass nach Abschluss eines Balkens bestimmt wird, ob der entsprechende Punkt des Indikatorcharts ein Punkt eines lokalen Extremums ist. Ein lokales Extremum ist ein Extremum, bei dem sich der Indikatorwert sowohl nach rechts als auch nach links um mindestens 25,0 % ändert.

Soweit die bevorstehende Veränderung des Indikators rechts vom erwarteten Extrempunkt zum Zeitpunkt des Taktabschlusses nicht bekannt ist, handelt es sich um eine optimale Vorhersage des Indikatorverhaltens. Diese Vorhersage ist keine Extrapolation, da die Indikatorwerte rechts vom Extrempunkt nicht von Interesse sind. Die einzige Bedingung ist die Bedingung des Extremums, d.h. die Indikatorwerte werden sich um den konditionierten Wert verändern. Optimale Vorhersage wird im statistischen Sinne verstanden, d.h. die Vorhersage sollte eine ausreichend hohe Zuverlässigkeit haben.

Formal sieht das alles anders aus, aber ich habe nichts Neues für Sie gesagt. All dies ist bereits in den drei Worten "Identifizierung ohne Verzögerung" enthalten.

Ich möchte Ihre Aufmerksamkeit darauf lenken, dass ein elementares Skript für die Suche nach Extrema mit bestimmten Eigenschaften auf einer ko-gerahmten Geschichte prägnanter und einfacher hätte geschrieben werden können. Verschachtelte Schleifen sind ein teurer Overkill und werden bei großen Arrays zu einem Engpass. All dies kann in einem Durchgang erfolgen, d. h. für jeden neuen Balken kann nur ein neuer Wert berechnet werden, und zwar ganz ohne Schleifen. Und da Sie Ihr Skript als Indikator konzipiert haben, werden Sie bei jedem neuen Balken eine Schleife durch die gesamte Vorgeschichte ziehen - die Berechnungszeit erhöht sich um Balken*Balken/2 mal. Und wenn Sie die Schleife in der Schleife verwenden, macht es keinen Sinn, die Schleife über j ab j=i zu beginnen.

Ich bin Ihren Code nicht im Detail durchgegangen und habe ihn mir auch nicht im Diagramm angesehen, aber es scheint mir, dass er einen wesentlichen Fehler enthält - er ändert sein eigenes Ergebnis. Ist dieser Punkt beispielsweise ein Extremwert für ein bestimmtes i, so ist er möglicherweise kein Extremwert mehr, wenn er zu (i+1) oder weiter geht. Dies ist jedoch eine Folge der von Ihnen auferlegten Bedingung: mehr als 5, weniger als 10.

Für den größten Teil der Geschichte spielt das keine Rolle. Für den rechten Rand jedoch schon, und das ist sehr wichtig. Das von Ihrem Skript identifizierte Extremum auf der linken Seite des Nullbalkens kann beim nächsten Balken verschwinden, was nicht gut ist. :-))

 
Yurixx:


1. Ich danke Ihnen natürlich für den Code, aber das ist, wie Sie selbst wissen, nicht die Lösung und nicht das Problem.

Vielleicht habe ich mich zu kurz gefasst, aber es ist eigentlich eine richtige Aussage. Sie könnte länger sein. Erforderlich ist ein Verfahren zur Ermittlung eines lokalen Extremwerts, das in Echtzeit und nicht in der Vergangenheit arbeitet. Identifizierung bedeutet, dass nach Abschluss eines Balkens bestimmt wird, ob der entsprechende Punkt des Indikatorcharts ein Punkt eines lokalen Extremums ist. Ein lokales Extremum ist ein Extremum, bei dem sich der Indikatorwert sowohl nach rechts als auch nach links um mindestens 25,0 % ändert.

Soweit die bevorstehende Veränderung des Indikators rechts vom erwarteten Extrempunkt zum Zeitpunkt des Taktabschlusses nicht bekannt ist, handelt es sich um eine optimale Vorhersage des Indikatorverhaltens. Diese Vorhersage ist keine Extrapolation, da die Indikatorwerte rechts vom Extrempunkt nicht von Interesse sind. Die einzige Bedingung ist die Bedingung des Extremums, d.h. die Indikatorwerte werden sich um den konditionierten Wert verändern. Optimale Vorhersage wird im statistischen Sinne verstanden, d.h. die Vorhersage sollte eine ausreichend hohe Zuverlässigkeit haben.

Formal sieht das alles anders aus, aber ich habe nichts Neues für Sie gesagt. All dies ist bereits in den drei Worten "Identifizierung ohne Verzögerung" enthalten.

2) Ich möchte Sie darauf aufmerksam machen, dass ein elementares Skript zur Suche nach Extrema mit bestimmten Eigenschaften in einer gerahmten Geschichte knapper und einfacher hätte geschrieben werden können. Verschachtelte Schleifen sind ein teurer Overkill und werden bei großen Arrays zu einem Engpass. All dies kann in einem Durchgang erfolgen, d. h. für jeden neuen Balken kann nur ein neuer Wert berechnet werden, und zwar ganz ohne Schleifen. Und da Sie Ihr Skript als Indikator konzipiert haben, werden Sie bei jedem neuen Balken eine Schleife durch die gesamte Vorgeschichte ziehen - die Berechnungszeit erhöht sich um Balken*Balken/2 mal. Und wenn Sie eine Schleife in einer Schleife verwenden, macht es keinen Sinn, die Schleife über j ab j=i zu beginnen.

3. ich habe mich nicht eingehend mit Ihrem Code befasst und ihn nicht im Diagramm betrachtet, aber es scheint mir, dass er einen wesentlichen Fehler enthält - er ändert sein eigenes Ergebnis. Wenn der Punkt zum Beispiel für ein bestimmtes i ein Extrempunkt ist, kann es sein, dass er nicht mehr ein Extrempunkt ist, wenn er zu (i+1) oder weiter geht. Dies ist jedoch eine Folge der von Ihnen auferlegten Bedingung: mehr als 5, weniger als 10.

Für den größten Teil der Geschichte spielt das keine Rolle. Für den rechten Rand jedoch schon, und das ist sehr wichtig. Das von Ihrem Skript identifizierte Extremum auf der linken Seite des Nullbalkens kann beim nächsten Balken verschwinden, was nicht gut ist. :-))

1. Die Aufgabe bestand darin, Extrema zu erkennen, nicht darin, ihr Auftreten zu VERMEIDEN. Kurz gesagt, ein billiger Ponzi .... ...nicht vorhersagen konnte. ... Das ist dasselbe, als würde man sagen: Gib mir einen Gral, damit es überhaupt keine Elche gibt, und 1000%. Das ist genau das, worüber ich geschrieben habe - die Aufgabe muss zuerst eine einzige theoretische Lösung haben und dann wird sie in Code umgesetzt. Für die Vorhersage gibt es jedoch keine einwertige Lösung.

Unter Identifikation verstehen wir die Bestimmung, ob der entsprechende Punkt des Indikator-Charts ein Punkt eines lokalen Extremums nach dem Ende des Balkens ist - verwechseln Sie nicht Gottes Segen mit einem Ei - Identifikation und Vorhersage.

"Identifizierung ohne Verzögerung" - auch hier. Identifizierung ohne Verzögerung bedeutet Identifizierung im allerersten Moment, in dem die Situation eindeutig identifiziert wird.

2. Zeigen Sie es uns und wir werden es sehen.

Balken*Balken/2 mal - offensichtlich verstehen Sie nicht einmal, wie es funktioniert, oder Sie kennen die Bedeutung des Break-Operators nicht;

Es machtkeinen Sinn, die Schleife bei j ab dem Wert j=i zu beginnen - aber bei welchem Wert dann? Dies ist eine sehr interessante Frage für Sie!!!!

Ich habe mich nicht eingehend mit Ihrem Code befasst und ihn nicht grafisch betrachtet, aber mir scheint, dass er einen wesentlichen Fehler enthält - er ändert sein eigenes Ergebnis.

3. beachten Sie, dass er seine Werte nur in Abhängigkeit von der noch nicht gebildeten Nullleiste ändert. Und alle Indikatoren ändern ihren letzten Wert entsprechend dem Wert des Nullbalkens. Haben Sie schon einmal den Fractals-Indikator gesehen (eingebaut in MT (Hauptmenü - Indikatoren - Bill Williams - Fractals)) - Schauen Sie es sich an, es ist sehr interessant und faszinierend und könnte sogar eines Tages für Sie nützlich sein. Die Berechnung von Änderungen am Nullpunkt bei der Programmierung von Indikatoren ist zumindest eine Regel der guten Sitten, wenn nicht sogar eine unumstößliche Regel ihrer Programmierung. Der erste Balken ist in der Regel auf sehr unerfahrene, nicht sehr tief in das Wesen des Indikators beschränkt.

Ich habe nie gesagt, dass der Algorithmus perfekt ist, es gibt eine große Reserve für seine Beschleunigung, wir können die Berechnung eines Indikators nur auf einen neuen Balken beschränken. Ursprünglich bestand die Aufgabe jedoch nur darin, ein Extremum anhand des Kriteriums der Veränderung des Indikatorwerts um einen bestimmten Wert zu identifizieren, und sie wurde gelöst, wenn wir Ihre billigen Scherze mit der Ersetzung der Begriffe Identifikation und Vorhersage ignorieren.

 
Integer:

... billig ponce ....


Wie Sie wollen. :-)

Ganzzahlig:

Wenn man weiß, was man will, ist es sehr schnell erledigt.

Offensichtlich hat man "man weiß, was man will" durch "eine theoretische Lösung" ersetzt. Übrigens: Ihre Konzepte.

 
Es ist ein gutes Thema und es ist schade, dass es sich totgelaufen hat.
Professionellen Programmierern würde ich empfehlen, die DLL von Elliottician-Produkten zu verwenden. Sie schreiben ihre Kreationen in VisualBasic, aber die Bibliotheken haben eine Beschreibung von Wellen und Paterns mit den üblichen Begriffen von hoch, nah, etc. Außerdem enthalten die neuesten Versionen von RET ein Plugin für Forex. Und die DLL mit der Basis der Wellen der letzten 15 Jahre zu zerlegen ist sehr verlockend!
 
Bookkeeper:

Frage: Ist es möglich, die Strategie zu einem riskanten, aggressiven Pipsetting nicht auf die realen anzupassen,

aber nur auf Demo? Die Frage ist nicht einfach nur eine Frage. Es ist möglich, mit einem aufdringlichen Eintrag oder mit viel Mut.

Ich denke, das ist möglich, sehen Sie sich die Anwendung an.

Ich habe meine Einlage in einer Woche um 900 % erhöht.

Mit freundlichen Grüßen,

Alex Niroba.

Dateien:
statement.zip  9 kb
 
NYROBA >> :

Ich denke, es ist möglich, schauen Sie sich die App an.

Ich habe mein Depot in einer Woche um 900 % erhöht.

Herzliche Grüße,

Alex Niroba.

Ja... Aber das ist eine lange Geschichte.

;)

 
divenetz >>:
Хорошая тема, жаль выдохлась.
Для профпрограммистов я бы порекомендовал поковырять DLL от продуктов Elliottician. Они пишут свои творения на ВижуалВасике, но в библиотеках есть описание волн и патернов обычными понятиями high, close и пр. Тем более что последние версии RET содержат плагин для Forex. А разобрать DLL с базой волн за последние 15 лет - очень заманчиво!

RET ist Scheiße. Besser modern75.nls zum Disassemblieren aus ElWave (vor allem, da es sich um eine offene Datei handelt). RET ist fast dasselbe wie trivial winwaves32.

1...56789101112
Neuer Kommentar