tableau statique ? - page 2

Nouveau commentaire
 
Ok, au moins j'étais presque sur la bonne voie mais comme je ne connaissais pas EMPTY_VALUE et comment l'utiliser, je pensais essayer de boucler en arrière pour détecter le changement de valeur puisque la valeur de résistance et de support reste la même jusqu'aux indicateurs précédents.

Quoi qu'il en soit, merci, je vais devoir me documenter davantage sur le sujet, je m'en approche mais c'est encore un peu flou :)

Il semble que je mette trop de temps à apprendre les choses. Je pense que je dois lire plus de codes d'autres personnes et essayer de les comprendre pour avoir de meilleures idées de conception.

Merci pour la réponse.
 
RaptorUK:
Il y a 2 tampons (tableaux) qui contiennent les valeurs de prix des fractales ... val1 & val2. Si vous voulez trouver les valeurs fractales précédentes, il vous suffit de boucler, en incrémentant une valeur de décalage, et de vérifier les valeurs de la mémoire tampon jusqu'à ce que vous trouviez celles qui ne sont pas EMPTY_VALUE ( https://docs.mql4.com/customind/SetIndexEmptyValue ).
Ok, je pense juste à voix haute ici :

Donc je peux reboucler v1[i] et v2[i] avec un code 1++,

Je ne comprends pas pourquoi val1>0 n'est pas toujours supérieur à 0 sauf pour High[0] ?

Et pourquoi val1 ne marque que la fractale haute et pas toutes les hautes[i] AHHH je pense que je comprends parce que l'instruction if lui dit de ne faire que les hautes[i].

Alors ok, laissez-moi réfléchir encore un peu.

val1 est la fractale, mais v1[i] est seulement le haut de la fractale ok je pense que j'ai résolu cette partie.

Donc je pourrais boucler v1[i] 1++ d'une manière ou d'une autre (je dois travailler cette partie) jusqu'au point précédent avant le EMPTY_VALUE et ce serait la fractale High[i] précédente.

Est-ce que je me rapproche ?
 
Agent86:
Ok, je réfléchis à voix haute là :

val1 est la fractale, mais v1[i] ne sont que les hauts de la fractale ok je pense que j'ai compris cette partie.

Donc je pourrais boucler v1[i] 1++ d'une manière ou d'une autre (je dois travailler cette partie) jusqu'au point précédent avant le EMPTY_VALUE et ce serait la fractale High[i] précédente.

Est-ce que je me rapproche ?
Correct. . . :-)
 
RaptorUK:
Correct . . . :-)
Ouf ! J'étais inquiet.

Merci
 
Je me suis trompé, je peux mettre 0 pour EMPTY_VALUE et il imprime 0 continuellement, donc ce n'est pas correct, enfin peut-être que c'est correct mais pas l'effet que je souhaite.

Quoi qu'il en soit :

//+------------------------------------------------------------------+
//|                                                  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);
  }    

//+------------------------------------------------------------------+
Je pensais que la boucle for m'aurait ramené à un seul signal et aurait imprimé le niveau du signal pour moi, mais je n'obtiens rien ou 0.

Après quelques jours de réflexion et d'essais, j'ai essayé d'apporter ces modifications à la version de l'indicateur en ajoutant un troisième tampon et en essayant de signaler le prix sur les graphiques, mais cela n'a pas marché non plus.


Eh bien, attendez, je retire ce que j'ai dit, la version courte de l'EA n'a pas le tampon EMPTY_VALUE, donc cela ne va probablement pas fonctionner de toute façon, et donc l'idée était de tester l'EA pour que je puisse voir les fonctions d'impression pour voir les résultats, mais la version de l'indicateur, je devrais attendre, donc je dois revenir sur ce point.

Quoi qu'il en soit, voici la version de l'indicateur, mais je ne me sens pas confiant car je ne sais pas exactement si je dois essayer de boucler à l'intérieur de l'instruction while ou créer une nouvelle boucle et recréer également val1 = .....

//+------------------------------------------------------------------+
//|                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);
  }
//+------------------------------------------------------------------+
J'ai abandonné l'idée de créer un troisième tampon / signal pour le moment et je veux juste voir si je peux imprimer le résultat du signal précédent.

EMPTY_VALUE la façon dont j'ai mis le code initialise l'indicateur, mais c'est tout, rien n'est imprimé.
 

Pouvez-vous m'expliquer comment fonctionne cette boucle for ?

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

 
RaptorUK:

Pouvez-vous m'expliquer comment fonctionne cette boucle for ?

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

Je suppose que je pensais que puisque l'instruction while et v1[i] stockent les plus hauts et que i -- compte à rebours à partir des barres les plus hautes, alors je devrais simplement compter à nouveau vers le haut pendant que v1[i] == EMPTY_VALUE.

Je pensais que cela incrémenterait i++ d'un niveau jusqu'au plus haut précédent, mais en fait, je pense que cela irait au-delà jusqu'au prochain EMPTY_VALUE.

Donc j'ai besoin de faire ça dans le sens inverse v1[i] = High[i] ; i++

Alors cela ne devrait-il pas m'amener au sommet précédent, mais je ne suis pas sûr de savoir comment l'initialiser correctement.

Je vais continuer à travailler dessus.
 
Je suis en train de le changer en un if( Je veux juste voir quelque chose s'imprimer à ce stade pour que je puisse au moins voir ce que l'indicateur fait.

Tout ce que j'obtiens, ce sont des 0, donc il n'y a en fait AUCUNE valeur lorsque = Print (v1[i]) ;
Ce qui est étrange car comment l'indicateur peut-il fonctionner à ce stade ?

Oh bien, je vais continuer.
 
Agent86:
Je suis en train de le changer en un if( Je veux juste voir n'importe quoi s'imprimer à ce stade pour que je puisse au moins voir ce que fait l'indicateur.

Tout ce que j'obtiens, ce sont des 0, donc il n'y a en fait AUCUNE valeur lorsque = Print (v1[i]) ;
Ce qui est étrange car comment l'indicateur peut-il fonctionner à ce stade ?

Oh bien, je vais continuer.


Peut-être que vous ne voyez que les valeurs de v1[0] ? print i en même temps ....

Print ("v1[", i, "]= ", v1[i]);
  
2011.09.17 11:56:15     2011.01.03 09:24  Agent86_5min EURUSD,M5: v1[-1]= 0
hmm intéressant
Je n'ai pas tout affiché mais toutes les lignes se lisent de la même façon = 0

Je pensais que je devrais toujours voir une valeur réelle pour v1[0] ?

comment peut-il être toujours 0 alors que l'indicateur doit être if(>0) ?

Je suis peut-être en train d'entrer dans un autre domaine que je ne connais pas.

J'ai pensé que je pourrais être en mesure d'imprimer afin d'essayer de comprendre ce qui se passe et pourquoi toutes mes tentatives échouent ; et afin que je puisse incrémenter i++ d'une certaine manière pour obtenir la prochaine fractale et ensuite trouver comment utiliser cette information pour quelque chose.


Je peux imprimer High[i] ou v1[i] et c'est toujours 0

Impression de High[0] ou High[1] également 0

Bien que je comprenne ce que vous avez posté et l'impression de la valeur i qui semble être bloquée à cause de la boucle i-- qui l'amène toujours à 0, mais même ainsi il devrait toujours imprimer une valeur pour i, du moins je le pensais.

Et je comprends pourquoi il imprime [-1] parce que i=Bars. Je comprends, mais =0 ?




123456
Nouveau commentaire