Indikator Frage - Seite 7

Neuer Kommentar
 
Es geht um den Geltungsbereich und den zuletzt gesetzten Wert. Alle diese Variablen haben mindestens den Geltungsbereich der Funktion, in der sie sich befinden. Wenn sie global deklariert sind, haben sie einen Geltungsbereich außerhalb der Funktion. Wenn sich der Wert einer Variablen innerhalb einer Schleife dreimal ändert, können Sie den zweiten Wert, auf den sie gesetzt wurde, nicht von außerhalb der Schleife abrufen, da die Variable zu dem Zeitpunkt, an dem der Code außerhalb der Schleife ausgeführt wird, auf ihren dritten Wert gesetzt ist.
 
Wenn ich so etwas verwende

Und sagen wir, ich deklariere val1 mit shift 3
und dann ist die Schleife natürlich shift i

Wenn ich mich auf val1 außerhalb der Schleife beziehe, spreche ich dann von val1 global oder val1 in der Schleife?

Ich schätze, ich frage mich, ob ich ein separates globales Fraktal für meine if-Anweisungen wie val3 und val4 oder so etwas hinzufügen sollte

Ich komme hier irgendwie nicht weiter, aber es scheint so, als ob das ABCD-Schema zumindest ein wenig Fortschritte macht

Wie auch immer, hier ist der Code, irgendwelche Ideen? 

//+------------------------------------------------------------------+
//|                                                  Agent86_5min.mq4 |
//|                                                    Unfinished POS |
//|                      my attempt at an ABCD scheme and fib retrace | 
//+------------------------------------------------------------------+
#property copyright "Unfinished POS by Agent86"


//---- input parameters
extern double    TakeProfit=20.0;
extern double    Lots=0.1;
extern double    StopLoss=10.0;
extern int MagicNumber=123486;

double val1;
double val2;


//++++ These are adjusted for 5 digit brokers.

int     pips2points;    // slippage  3 pips    3=points    30=points
double  pips2dbl;       // Stoploss 15 pips    0.0015      0.00150
int     Digits.pips;    // DoubleToStr(dbl/pips2dbl, Digits.pips)

    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
   if (Digits == 5 || Digits == 3)
   {    // Adjust for five (5) digit brokers.
      pips2dbl    = Point*10; pips2points = 10;   Digits.pips = 1;
   } 
   else 
    {    
      pips2dbl    = Point;    pips2points =  1;   Digits.pips = 0; 
    }
    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
     
   
    
//---- 

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
   
    
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   
        
   int i=0;                
   val1=iFractals(NULL, 0, MODE_UPPER,3);
   val2=iFractals(NULL, 0, MODE_LOWER,3); 
  


for(i=0; val1==0 || val2==0; i++)
     {
     if(iFractals(NULL, 0, MODE_UPPER,i) > 0 && val1 == 0) 
     val1 = iFractals(NULL, 0, MODE_UPPER, i);
     if(iFractals(NULL, 0, MODE_LOWER, i) > 0 && val2 == 0)
     val2 = iFractals(NULL, 0, MODE_LOWER, i);
     double A = val2;
     if(A !=0) 
     Print (A, " A loop down");
     double a = val1;
     if(a !=0)
     Print (a, " a loop up");
      
     //Print (" Last UPPER Fractal at ", val1, " Last LOWER Fractal at ", val2);
         
     }   
                            
      if(val1 > 0)
         {
         //Print (val1, " val1");
         //Print(TimeToStr(Time[3],TIME_DATE|TIME_MINUTES), " = val1 time");      
         //datetime b = Time[3];
         ////Print (A, " A if");
         double Z=(val1-A)/2; //my attempt at a .50 retrace in pips but can be any fib level
         double C=A+Z; //using the calc above to get the retrace value at .50
         //Print (C, " C");
         if(Bid<=C && Bid > A) //C will be somewhere in between here
         Print (Low[0], " Low [0] ", C, " = C");
         // some other signal here to trade at retrace
         }        
         
         

      if(val2 < 0)
         {
         //Print (val2, " val2");
         //Print(TimeToStr(Time[3],TIME_DATE|TIME_MINUTES), " = val2 time");
         //datetime c = Time[3];
         //Print(a, " a");
         double z=(a-val2)/2; //my attempt at a .50 retrace in pips but can be any fib level
         double c=a+z; //using the calc above to get the retrace value at .50
         //Print (c, " c");
         if(Bid<=c && c < a) //c will be somewhere in between here
         Print (Low[0], " Low [0] ", c, " = c");
         //some other signal here to trade at retrace
         }
         
                   
                
   return(0);
  }    

//+------------------------------------------------------------------+


Das A wäre also der vorherige Tiefpunkt und val1 sollte die aktuelle Verschiebung 3 sein, und dasselbe mit a und val2

Ich muss noch einmal testen, um sicher zu sein, dass A und a sich auf die richtigen Werte beziehen, denn ich habe die !=0-Anweisungen hinzugefügt, damit die leeren Werte nicht gedruckt werden.
Auf den ersten Blick scheint es in Ordnung zu sein, aber ich muss das noch einmal bestätigen

Um es noch einmal zu sagen:
Bezieht sich val1 in meiner if(-Anweisung) auf die richtige Bedingung, oder brauche ich ein völlig anderes iFractal, um mich auf Shift 3 zu beziehen
Ich kann nicht wirklich sagen, ob es richtig funktioniert oder nicht, es scheint zu funktionieren, aber irgendetwas scheint nicht zu stimmen, und ich kann nicht genau sagen, was es ist.

Bitte um Rat

Danke

Obwohl dies wirklich kein Indikator-Thema mehr ist, sollte ich dies in ein neues Thema verschieben?

 
Agent86:
Wenn ich etwas wie dieses verwende

Und sagen wir mal, ich deklariere val1 mit shift 3
und dann ist die Schleife natürlich shift i

Wenn ich val1 außerhalb der Schleife referenziere, spreche ich dann von val1 global oder val1 in der Schleife?

Ich schätze, ich frage mich, ob ich ein separates globales Fraktal für meine if-Anweisungen wie val3 und val4 oder so etwas hinzufügen sollte.

val1 und val2 werden mit globalem Geltungsbereich deklariert, i wird lokal in start() deklariert.

val1 und val2 haben innerhalb oder außerhalb der Schleife den letzten Wert, der ihnen zugewiesen wurde ... das geschieht vor der Schleife und dann können die Werte innerhalb der Schleife geändert werden ... sobald die Schleife verlassen wird, sind die Werte, was sie sind und bleiben so, bis start() das nächste Mal aufgerufen wird, dann werden sie zurückgesetzt und dann möglicherweise in der Schleife geändert ... usw. usw.

 
RaptorUK:

val1 und val2 werden mit globalem Geltungsbereich deklariert, i wird lokal in start() deklariert.

val1 und val2 haben innerhalb oder außerhalb der Schleife den letzten Wert, der ihnen zugewiesen wurde ... das geschieht vor der Schleife und dann können die Werte innerhalb der Schleife geändert werden ... sobald die Schleife verlassen wird, sind die Werte, was sie sind und bleiben so, bis start() das nächste Mal aufgerufen wird, dann werden sie zurückgesetzt und dann möglicherweise in der Schleife geändert ... usw. usw.

Hmmm, also Entscheidungen Entscheidungen.

Ich könnte versuchen, nach den Werten zu gehen, während ich in der Schleife bin, und einfach val1 und val2 =iFractal,,,3 neu deklarieren. Um die Dinge zurückzusetzen, aber erst nachdem ich A=val2 und a=val1 deklariert habe, damit ich einen Wert für diese Werte habe, der hoffentlich mein vorheriges Fraktal ist, wenn ich das richtig verstanden habe.

Oder ich könnte val 1 und val2 außerhalb der Schleife neu deklarieren, aber ich möchte nicht den Wert für A oder a verlieren, also muss ich es einfach zu den richtigen Zeiten ausarbeiten, denke ich.

Es könnte auch sein, dass ich das alles falsch angehe, aber das ist egal. Irgendwo muss man ja anfangen, also habe ich mir das für den Moment ausgesucht; und ich kann es anpassen, wenn ich mehr Erfahrung habe.

Vielen Dank für die Hilfe
 
Diese sind also irgendwie irrelevant?

val1=iFractals(NULL, 0, MODE_UPPER,3);
val2=iFractals(NULL, 0, MODE_LOWER,3);

Ich schätze, ich sollte diese wahrscheinlich in val3 und val4 ändern, um das aktuelle iFractal für den Handel zu verwenden und nur auf (A) und (a) zu verweisen, um auf mein vorheriges Fraktal zu verweisen.


Ich werde weiter daran arbeiten.

Danke

 
Ok

Nachdem ich ein paar Tage darüber nachgedacht und versucht habe, die Logik durchzuarbeiten, denke ich, dass ich jetzt einen besser funktionierenden Code habe, obwohl er nicht perfekt ist, aber er macht Fortschritte

//+------------------------------------------------------------------+
//|                                                  Agent86_5min.mq4 |
//|                                              Unfinished POS slate |
//|                                           See progress notes below |
//+------------------------------------------------------------------+
#property copyright "Unfinished POS slate by Agent86"


//---- input parameters
extern double    TakeProfit=20.0;
extern double    Lots=0.1;
extern double    StopLoss=10.0;
extern int MagicNumber=123486;

double val1;
double val2;
bool traded = false;

//++++ These are adjusted for 5 digit brokers.

int     pips2points;    // slippage  3 pips    3=points    30=points
double  pips2dbl;       // Stoploss 15 pips    0.0015      0.00150
int     Digits.pips;    // DoubleToStr(dbl/pips2dbl, Digits.pips)

    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
   if (Digits == 5 || Digits == 3)
   {    // Adjust for five (5) digit brokers.
      pips2dbl    = Point*10; pips2points = 10;   Digits.pips = 1;
   } 
   else 
    {    
      pips2dbl    = Point;    pips2points =  1;   Digits.pips = 0; 
    }
    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
     
   
    
//---- 

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
    
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   
        
   int i=0;
   int ticket,total,result;
   total = OrdersTotal();                 
   val1=iFractals(NULL, 0, MODE_UPPER,3);
   val2=iFractals(NULL, 0, MODE_LOWER,3); 


     
     if(val1 > 0 && traded == false)
      { 
      // in the absence of an && indicator above I get continous print statements
      // with indicator added && indicator above, then it prints A and B once as it should ???
      // I need to work this out so it won't print all the time aka trade all the time
      // A and B first values seems to initialize the whole block
      // just a reminder that they time stamps coordinate after this FYI
      // now work on C retrace and possibly signals
      // add options for user to select some candle patterns
      // add options to select indicators
      // add bells and whistles to make things fun
      // alerts,sounds,maybe poppup video animation or something
      
      double B = val1;
      Print(B, " B high");
         if(val2==0)
            {
            for (i=0; val2==0; i++)
               {
               val2=iFractals(NULL, 0, MODE_LOWER, i);
               double A = val2;
                  if(A!=0)
                     {
                     Print(A, " A low");
                     }
               }
             }  
      traded=true;
      }
     
     if(val2 > 0 && traded == true)
      {
      B = val2;
      Print(B, " B low");
         if(val1==0)
            {
            for (i=0; val1==0; i++)
               {
               val1=iFractals(NULL, 0, MODE_UPPER, i);
               A = val1;
                  if(A!=0)
                     {
                     Print(A, " A high");
                     }
               }
             }  
      traded=false;
      }
     
                    
                
   return(0);
  }    

//+------------------------------------------------------------------+


      

Ich habe also meine A- und B-Werte und während eine Indikatoranweisung in den anfänglichen if(Anweisungen && Indikatoren) platziert wird, werden die Werte einmal gedruckt, z. B. MACD schneller > langsamer oder einige solche Indikatoranweisungen.

Ich erhalte also nur A und B, wie ich es gerne hätte.

Ich bin mir nicht sicher, warum die Werte mehrfach gedruckt werden, wenn die Indikatoroptionen aus den if(Anweisungen) entfernt werden.

Wie auch immer, ich bin immer ein wenig näher mit diesem ABCD Art von Schema, das auf andere Indikatoren zu nicht nur Fraktale etc. für zukünftige Referenz verwendet werden kann

Bitte beraten

Danke

 

Dies könnte Ihnen helfen. Es ist ein Indikator für den Zugriff auf die letzten Fraktale und die Verschiebung, mit dem du dein ABCD ausrechnen kannst.

iCustom(Symbol(),0,"Fractal Store",0,"",0,0)

Das ergibt die oberen Fraktale. Ändern Sie "" in "L" für untere Fraktale.

iCustom(Symbol(),0,"Fractal Store",1,"",0,0)

Damit erhalten Sie das Fraktal vor dem letzten Fraktal.

Dateien:
fractalfstore.mq4  3 kb
 
heelflip43:

Dies könnte Ihnen helfen. Es ist ein Indikator für den Zugriff auf die letzten Fraktale und die Verschiebung, mit dem du dein ABCD ausrechnen kannst.

Das ergibt die oberen Fraktale. Ändern Sie "" in "L" für untere Fraktale.

Damit erhalten Sie das Fraktal vor dem letzten Fraktal.

Jep, ich sehe das

vor meinem letzten Code in diesem Thread hatte ich einige verschiedene (for) Anweisungen mit etwas Hilfe ausgearbeitet und es war auch ein Indikator, den ich in der Lage war, zu zeichnen, was ich in den Puffer wollte, jedoch brachte mich zu einem anderen Problem der Versuch, die Werte zu extrahieren und nur diese Werte einmal zu drucken, verwendet oder referenziert werden.

Da diese verschiedenen for-Anweisungen bei mir Probleme verursachen und diese dem von Ihnen geposteten Code ähneln.
Ich war nie in der Lage, die Werte zu erhalten, ohne ständig den Wert jedes Mal zu drucken, wenn er wahr wird, was ständig der Fall ist.
Ich habe einige dieser Probleme gelöst, aber ich habe nie wirklich gelernt, wie man aufhört, sobald eine Bedingung erfüllt ist.

Ich sehe in Ihrem Code eine Sache, die helfen könnte, ist die statische datetime Block und ich habe nur einmal verwendet, bevor auf die Bedingung nur dann, wenn ein neuer Balken und neue Bar Zeit kommt in beziehen.
Dieser Teil könnte hilfreich sein, mit dem, was ich bin arbeiten. Und obwohl mein aktueller Code das aktuelle Fraktal und das vorherige Fraktal erzeugt, funktioniert es derzeit

Das einzige Problem, das ich meistens habe, ist, dass, sobald die Bedingung wahr ist, es die Anweisung kontinuierlich ausdruckt, was in Ordnung sein könnte, aber das bedeutet, dass es wahrscheinlich auch einen Handel kontinuierlich platzieren wird, sobald ich zu diesem Punkt komme.

Vielleicht brauche ich mehr Erfahrung in der Verwendung von iCustom Indikatoren und dies könnte eine Menge meiner Probleme lösen, aber ich bin noch nicht so weit in meinem Lernen.

Ich werde mir den Code und die EMPTY_VALUE-Teile noch einmal genauer ansehen. Jetzt, wo ich sehe, dass das verwendet wird, kann ich auch daraus lernen. Es wurde schon früher vorgeschlagen, aber ich habe nie verstanden, wie man es verwendet.

Ich werde weiter daran arbeiten.
Vielen Dank für die Hilfe
 
Ein letzter Gedanke, den ich bemerkte, dass, wenn ich hinzufügen, sagen wir MACD zu den if(val1 > 0 && schneller > langsamer && gehandelt == false)

Dann funktioniert es und gibt nur genau das, was ich will, die A niedrig, B hoch, dann und / oder B niedrig und A hoch

drucken ist.

Aber wenn ich die schneller > langsamer und schneller < langsamer auf diese beiden if-Anweisungen herausnehme, dann bemerke ich, dass es NIE das A-Hoch druckt und auch kontinuierlich die anderen druckt, die ich verwirrt bin


Ich werde weiter daran arbeiten, ich bin mir sicher, dass ich die Anweisung nur einmal ohne andere Indikatoranweisungen im EA ausdrucken muss, damit ich weiß, dass die Indikatoren die ABCD-Teile des Codes nicht beeinträchtigen

Zurück zum Zeichenbrett


 

Ich glaube, Ihr Problem liegt darin, dass Sie val1 und val2 nicht zurückgesetzt haben. Sobald Sie also den Höchst- und den letzten Tiefstwert gefunden haben, müssen Sie sie zurücksetzen:

double B = val1;
      Print(B, " B high");
         if(val2==0)
            {
            for (i=0; val2==0; i++)
               {
               //Print("i "+i);
               val2=iFractals(NULL, 0, MODE_LOWER, i);
               double A = val2;
                  if(A!=0)
                     {
                     Print(A, " A low");
                     }
               }
             }  
      traded=true;
      }
     
   val1=iFractals(NULL, 0, MODE_UPPER,3);
   val2=iFractals(NULL, 0, MODE_LOWER,3); 

     if(val2 > 0 && traded == true)
      {
      B = val2;
      Print(B, " B low");
         if(val1==0)
            {
            for (i=0; val1==0; i++)
               {
               val1=iFractals(NULL, 0, MODE_UPPER, i);
               A = val1;
                  if(A!=0)
                     {
                     Print(A, " A high");
                     }
               }
             }  
      traded=false;
      }
Hoffentlich hilft das.
12345678
Neuer Kommentar