statisches Array ? - Seite 2

Neuer Kommentar
 
Ok, zumindest war ich fast auf dem richtigen Weg, aber da ich nicht wusste, über EMPTY_VALUE und wie man es verwendet, dachte ich an versuchen, zurück zu schleifen, um die Änderung im Wert zu erkennen, da der Widerstand und die Unterstützung Wert gleich bleibt, bis die vorherigen Indikatoren.

Wie auch immer, danke, ich habe zu lesen, bis einige mehr auf diese, ich bin immer näher, aber es ist immer noch ein wenig neblig :)

Es scheint, dass ich zu lange brauche, um Dinge zu lernen. Ich glaube, ich muss mehr von den Codes anderer Leute lesen und versuchen, sie zu verstehen, um bessere Designideen zu bekommen.

Vielen Dank für die Antwort.
 
RaptorUK:
Es gibt 2 Puffer (Arrays), die die Preiswerte der Fraktale enthalten ... val1 & val2. Wenn Sie frühere Fraktalwerte finden möchten, führen Sie einfach eine Schleife durch, in der Sie einen Verschiebungswert erhöhen, und prüfen die Pufferwerte, bis Sie solche finden, die nicht EMPTY_VALUE sind ( https://docs.mql4.com/customind/SetIndexEmptyValue )
Ok, ich denke hier nur laut nach:

Ich kann also v1[i] und v2[i] mit etwas 1++ Code zurückschleifen,

Ich verstehe nicht, ist val1>0 nicht immer größer als 0, außer bei High[0]?

Und warum markiert val1 nur das hohe Fraktal und nicht alle High[i] 's AHHH Ich glaube, ich verstehe, weil die if-Anweisung ihm sagt, dass er nur die High[i]'s machen soll

Also gut, lass mich noch ein bisschen nachdenken.

val1 ist das Fraktal, aber v1[i] sind nur die Highs des Fraktals ok ich denke ich habe diesen Teil verstanden.

Dann könnte ich v1[i] 1++ irgendwie in einer Schleife zum vorherigen Punkt vor dem EMPTY_VALUE bringen und das wäre dann das vorherige High[i]-Fraktal.

Komme ich der Sache näher?
 
Agent86:
Ok, ich habe hier nur laut gedacht:

val1 ist die Fraktale, aber v1[i] sind nur die Höchstwerte der Fraktale, ok ich denke, ich habe diesen Teil herausgefunden.

Dann könnte ich v1[i] 1++ irgendwie in einer Schleife (diesen Teil muss ich noch ausarbeiten) zum vorherigen Punkt vor dem EMPTY_VALUE zurückführen und dies wäre das vorherige High[i]-Fraktal.

Komme ich der Sache näher?
Richtig ... :-)
 
RaptorUK:
Richtig ... :-)
Puh! Ich war besorgt

Danke
 
Ich habe etwas falsch, ich kann 0 in für EMPTY_VALUE und es druckt 0 kontinuierlich, so dass das nicht richtig ist, vielleicht ist das richtig, aber nicht meine gewünschte Wirkung.

Wie auch immer:

//+------------------------------------------------------------------+
//|                                                  Agent86_5min.mq4 |
//|                                                    Unfinished POS |
//|                                    
//+------------------------------------------------------------------+
#property copyright "Unfinished POS by Agent86"


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

double v1[];
double v2[];
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()
  {
  
  
   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 i=Bars;         
   
   while(i>=0)
     {
      val1=iFractals(NULL, 0, MODE_UPPER,i);
      if (val1 > 0) v1[i]=High[i];
      else          v1[i]=v1[i+1];

      val2=iFractals(NULL, 0, MODE_LOWER,i);
      if (val2 > 0) v2[i]=Low[i];
      else          v2[i]=v2[i+1];
      
      i--;
     }
   
    for(val1=High[i]; v1[i] == EMPTY_VALUE ;i++)
      {
      Print (v1[i]);
      } 
  
//----
            
                       
            

           

//---- 

 
                    
        

                
   return(0);
  }    

//+------------------------------------------------------------------+
Ich dachte, die for-Schleife würde mir nur ein Signal zurückgeben und den Signalpegel für mich ausgeben, aber ich bekomme nichts oder 0

Nachdem ich ein paar Tage darüber nachgedacht und viele Dinge ausprobiert habe, habe ich versucht, diese Änderungen an der Indikatorversion vorzunehmen, indem ich einen dritten Puffer hinzugefügt habe und versucht habe, das Signal mit dem Preis auf den Charts auszugeben, aber auch das hat nicht funktioniert.


Nun, warten Sie, ich nehme dies zurück die kurze Version EA Ich habe nicht die EMPTY_VALUE Puffer, so dass wahrscheinlich nicht gehen, um irgendwie zu arbeiten, und so die Idee war, die EA zu testen, so dass ich die Druckfunktionen, um die Ergebnisse zu sehen, aber der Indikator-Version, die ich hätte zu warten, so dass ich wieder auf, dass, wie es sich herausstellt, zu posten haben.

Jedenfalls hier ist der Indikator-Version, aber ich fühle mich nicht sicher über diese, weil ich nicht genau sicher, ob ich versuchen sollte, innerhalb der while-Anweisung Schleife oder erstellen Sie eine neue Schleife und neu erstellen val1 = .... wieder auch.

//+------------------------------------------------------------------+
//|                Support and Resistance                            |
//|                Copyright © 2004/5     Barry Stander              |
//|                http://www.4Africa.net/4meta/                     |
//+------------------------------------------------------------------+

#property copyright "Support and Resistance             Barry_Stander_4@yahoo.com"
#property link      "http://www.4Africa.net/4meta/"
#property indicator_chart_window
#property indicator_buffers 2
#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(2);

   SetIndexArrow(0, 159);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");
   SetIndexEmptyValue(0,0.0);

   SetIndexArrow(1, 159);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");
   SetIndexEmptyValue(1,0.0);
   
   SetIndexArrow(2, 225);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A");
   SetIndexEmptyValue(2,0.0); 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   
   
   int i=Bars;
//----
   while(i>=0)
     {
      val1=iFractals(NULL, 0, MODE_UPPER,i);
      if (val1 > 0) v1[i]=High[i];
      else          v1[i]=v1[i+1];

      val2=iFractals(NULL, 0, MODE_LOWER,i);
      if (val2 > 0) v2[i]=Low[i];
      else          v2[i]=v2[i+1];
      
      i--;      
       
      }
      
     
     for(val1=High[i]; v1[i] == 0 ;i++)  // or v1[i] == EMPTY_VALUE
      {
      Print (v1[i]);
      }
       
     
     
     
//----
   return(0);
  }
//+------------------------------------------------------------------+
Ich habe den Versuch aufgegeben, den 3. Puffer / das Signal für jetzt zu erstellen und möchte nur sehen, ob ich das Ergebnis des vorherigen Signals drucken kann

EMPTY_VALUE die Art, wie ich in den Code setzen initialisiert den Indikator, aber das ist alles nichts drucken
 

Können Sie erklären, wie diese for-Schleife funktioniert?

for(val1=High[i]; v1[i] == 0 ;i++)

 
RaptorUK:

Können Sie erklären, wie diese for-Schleife funktioniert?

for(val1=High[i]; v1[i] == 0 ;i++)

Ich schätze, dass ich dachte, da die while-Anweisung und v1[i] die Höchstwerte speichert und i - vom höchsten Wert des Balkens abwärts zählt, würde ich einfach wieder nach oben zählen, während v1[i] == EMPTY_VALUE

Ich dachte, dies würde i++ um 1 Level bis zum vorherigen Höchststand erhöhen, nun, eigentlich würde es darüber hinaus bis zum nächsten EMPTY_VALUE gehen

Ich muss das also andersherum machen v1[i] = High[i]; i++

Dann sollte dies nicht nehmen mich auf die vorherige High, aber ich bin nicht sicher, wie man es richtig zu initialisieren.

Ich werde weiter daran arbeiten.
 
Ich ändere es in ein if( Ich möchte nur sehen, alles drucken an dieser Stelle, so kann ich zumindest sehen, was der Indikator tut.

Alles, was ich bekomme, ist 0's so gibt es eigentlich KEINE Werte, wenn = Print (v1[i]);
Was seltsam ist, denn wie kann der Indikator zu diesem Zeitpunkt überhaupt funktionieren?

Nun gut, ich werde weiter daran arbeiten.
 
Agent86:
Ich ändere es in ein if( Ich möchte nur sehen, dass irgendetwas an diesem Punkt gedruckt wird, damit ich zumindest sehen kann, was der Indikator tut.

Alles, was ich bekomme, ist 0's, so gibt es eigentlich KEINE Werte, wenn = Print (v1[i]);
Was seltsam ist, denn wie kann der Indikator zu diesem Zeitpunkt überhaupt funktionieren?

Nun gut, ich werde weiter daran arbeiten.


Vielleicht sehen Sie nur Werte für v1[0] ? print i zur gleichen Zeit.

Print ("v1[", i, "]= ", v1[i]);
  
2011.09.17 11:56:15     2011.01.03 09:24  Agent86_5min EURUSD,M5: v1[-1]= 0
hmm interessant
Ich habe nicht alles gepostet, aber alle Zeilen lauten gleich = 0

Ich dachte, ich sollte noch einen aktuellen Wert für v1[0] sehen ?

wie kann es immer 0 sein, wenn der Indikator if(>0) sein muss ?

Möglicherweise gerate ich in ein weiteres Gebiet, in dem ich nicht bewandert bin.

Ich dachte, ich könnte ausdrucken, damit ich versuche zu verstehen, was und warum alle meine Versuche fehlschlagen; und damit ich i++ irgendwie inkrementieren kann, um zum nächsten Fraktal zu gelangen und dann irgendwie herauszufinden, wie ich diese Information für etwas verwenden kann.


Ich kann High[i] oder v1[i] drucken und es ist immer 0

Drucken von High[0] oder High[1] auch 0

Obwohl ich verstehe, was Sie gepostet haben und das Drucken des i-Wertes, der wegen der i-- Schleife, die ihn immer auf 0 bringt, stecken zu bleiben scheint, aber selbst dann sollte es immer noch einen Wert für i drucken, so dachte ich zumindest.

Und ich verstehe, warum [-1] gedruckt wird, weil i=Bars. Ich verstehe das, aber =0 ?




123456
Neuer Kommentar