Indikator Frage - Seite 3

Neuer Kommentar
 
Agent86:
.

Jedenfalls habe ich versucht, die hohen Fraktale nur zu bilden, wenn eine andere Bedingung eintritt, wie iMACD Kreuze, oder EMA Kreuze oder einige andere Indikatoren Kreuze.
So dass die Fraktale nur auf dem Indikator angezeigt werden, wenn alle Bedingungen erfüllt sind.


Ich war nicht sicher, was Sie genau zu tun versuchen, aber versuchen Sie dies, beachten Sie die externen Eingänge.

#property indicator_chart_window      extern bool condition1 = true;
#property indicator_buffers 3         extern bool condition2 = true;
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1), //MODE_MAIN
            slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1); //MODE_SIGNAL
           
            
   int bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     if(condition1)
       {
        val1=iFractals(NULL, 0, MODE_UPPER,i);
        if (val1 > 0) v1[i]=High[i];       
       }   
     if(condition2)
       {      
        val2=iFractals(NULL, 0, MODE_LOWER,i);
        if (val2 > 0) v2[i]=Low[i];
       }
     }    
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
WHRoeder:
Wie sind Sie genau zu diesem Schluss gekommen und worin besteht der funktionale Unterschied?

Ich bin zu dieser Schlussfolgerung gekommen, weil ich wahrscheinlich von der OOP-Perspektive ausgegangen bin. Ja, das gilt nicht für den Fall von MQL4, wenn ich mich recht erinnere. Obwohl es eine gute Praxis sein kann?



 

Oder vielleicht so etwas wie das?

Sie sollten wirklich IndicatorCounted() verwenden, denn wenn Sie es so machen, zeichnet Ihr Indikator all diese Objekte bei jedem neuen Tick neu, anstatt sie alle nur einmal zu zeichnen und neue hinzuzufügen, wenn neue Balken gebildet werden 

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster=0;
   double   slower=0;         
   int      bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i); //MODE_MAIN
     slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,i); //MODE_SIGNAL
     val1=iFractals(NULL, 0, MODE_UPPER,i);
     val2=iFractals(NULL, 0, MODE_LOWER,i);
     
     if(faster > 0)
      {
       if (val1 > 0) v1[i]=High[i];
      }
      
     if(faster < 0)
      {
       if (val2 > 0) v2[i]=Low[i];
      }        
    }   
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
diostar:
Ich bin zu diesem Schluss gekommen, weil ich wahrscheinlich aus der OOP-Perspektive geschaut habe. Ja, das gilt nicht für den Fall von MQL4, wenn ich mich recht erinnere. Obwohl es eine gute Praxis sein kann?

Es ist immer eine gute Praxis, den Umfang zu begrenzen. Es ist immer eine gute Praxis, Variablen/Objekte dort zu definieren, wo sie verwendet werden, und sie an diesem Punkt zu initialisieren.

Die Definition eines Objekts außerhalb der Schleife führt zu einer Standardkonstruktion plus N Zuweisungen. Die Definition innerhalb der Schleife führt zu N Konstruktionen mit Wert - normalerweise schneller.

Sorgen Sie sich nie um Optimierungen, bis Sie beweisen können, dass die Änderung einen Unterschied macht.

 
WHRoeder:

Es ist immer eine gute Praxis, den Anwendungsbereich zu begrenzen. Es ist immer eine gute Praxis, Variablen/Objekte dort zu definieren, wo sie verwendet werden, und sie an diesem Punkt zu initialisieren.

Die Definition eines Objekts außerhalb der Schleife führt zu einer Standardkonstruktion plus N Zuweisungen. Die Definition innerhalb der Schleife führt zu N Konstruktionen mit Wert - normalerweise schneller.

Machen Sie sich keine Gedanken über Optimierungen, solange Sie nicht beweisen können, dass die Änderung einen Unterschied macht.

Dies sollte auch für seinen Iterator gelten. for (int i=0; ...
 
diostar:
Dies sollte auch für seinen Iterator gelten. for (int i=0;...
Ich stimme zu, aber ich habe diesen Code nicht geschrieben.
 
Ok, ich scheine jetzt einige Varianten eines funktionierenden Codes zu haben, danke.

Allerdings bin ich etwas verwirrt, warum die Deklaration der Variablen (schnellere und langsamere) außerhalb der Schleife nicht gut ist, während sie innerhalb der Schleife in Ordnung ist

Und trotzdem funktioniert der int i = Bars außerhalb der Schleife oder innerhalb der Schleife?


Jedenfalls ist es gut zu sehen, dass einige meiner Ideen, an denen ich gearbeitet habe, bereits in diesem Thread gepostet wurden. Das sind gute Nachrichten und bedeutet, dass ich dem Ziel, eines Tages selbst etwas zu programmieren, ein Stück näher komme. Ein kleiner Fortschritt ist also besser als gar keiner. Danke

So, jetzt kann ich daran arbeiten, einige der Indikatorzeiten zu vergleichen, ich werde versuchen, das jetzt herauszufinden.

Zum Beispiel:
Vergleiche v1[i] mit v2[i] Aktuell gebildete Indikatorzeiten && / || if(v1[i] time is > v2[i] time) und andere Vergleiche wie diese.

Vielen Dank für die vielen Tipps, das war eine große Hilfe.
 
WHRoeder:

Es ist immer eine gute Praxis, den Anwendungsbereich zu begrenzen. Es ist immer eine gute Praxis, Variablen/Objekte dort zu definieren, wo sie verwendet werden, und sie an diesem Punkt zu initialisieren.

Die Definition eines Objekts außerhalb der Schleife führt zu einer Standardkonstruktion plus N Zuweisungen. Die Definition innerhalb der Schleife führt zu N Konstruktionen mit Wert - normalerweise schneller.

Machen Sie sich keine Gedanken über Optimierungen, solange Sie nicht beweisen können, dass die Änderung einen Unterschied macht.

Ich nehme an, dies gilt für alle, und nicht nur Indikatoren / benutzerdefinierte Indikatoren?
 
Agent86:
Ok, ich scheine jetzt einige Varianten eines funktionierenden Codes zu haben, danke.

Allerdings bin ich etwas verwirrt, warum die Deklaration der Variablen (schneller und langsamer) außerhalb der Schleife nicht gut ist, während sie innerhalb der Schleife in Ordnung ist

Und dennoch funktioniert der int i = Bars außerhalb der Schleife oder innerhalb der Schleife?


Wenn Sie einen Indikator erstellen, wenden Sie Ihren Code auf jeden einzelnen Balken im Diagramm an. Das bedeutet, dass Sie den Wert des Macd-Indikators so abrufen müssen, wie er für jeden dieser historischen Balken war.

In Ihrem ursprünglichen Code haben Sie das getan:

double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1),
Der letzte Parameter 1 ist der Wert des Macd, wie er in Balken 1 des Charts war, dem Balken vor dem aktuellen Balken, der als Balken 0 indexiert ist

Offensichtlich wollen Sie nicht diesen einen Wert des macd in Ihrem bedingten Operator für den gesamten historischen Chart verwenden.

Sie müssen den macd auf denselben Balkenindex wie jeden einzelnen Balken indexieren, so dass Sie zum Beispiel bei Balken 500 Folgendes benötigen

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,500)

Der letzte Parameter muss sich ändern, damit er mit der Bar-Nummer übereinstimmt, auf die Ihr Indikator seine Algorithmen anwendet.

Aus diesem Grund benötigen Sie ihn innerhalb der Schleife, so dass Sie den Schleifenzyklus-Iterator ( i ) für den letzten Parameter verwenden können, damit Sie Ihren Macd-Wert so erhalten, wie er für jeden Balken des historischen Charts war.

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i),

Ich hoffe, das hilft, die Dinge ein wenig zu klären.

 
WHRoeder:
Versuchen Sie diese Änderung
Warum for(int i = Bars-1 ?

Und warum ist dies besser als for(int i = Bars ??

Bitte um Ratschläge, danke

12345678
Neuer Kommentar