Ce que rapportent les fonctions Lowest et Highest - page 4

 
Je vais essayer d'expérimenter avec le code donné par le composteur sur la première page. Peut-être que quelque chose va marcher.
 
nen:
Correct, il est calculé. Le numéro de cellule est trouvé. De cette cellule (série temporelle) est prise la valeur du maximum ou du minimum de la barre. On considère que le maximum a été trouvé sur cette barre. Cette valeur est ensuite placée dans le tampon de l'indicateur avec le numéro trouvé. Le maximum de l'indicateur doit correspondre au maximum de la barre. Dans mon code, le maximum est également pris dans le tableau (timeseries) avec le même numéro trouvé et comparé à la valeur de val. On vérifie si on fait bien les choses : on met le numéro val dans le tampon avec ce numéro. Elle doit également être égale au maximum de la barre. La comparaison de chiffres pris au même endroit est tout à fait correcte.

Il me semble que la comparaison ...==val, est dangereuse car c'est le numéro de la cellule qui peut changer de tick à tick. Surtout sur les petites échelles de temps où il y a beaucoup de bas et de hauts très proches les uns des autres. Cependant, nous devrions y réfléchir, peut-être que nous parlons de moments différents.
 
nen, voulez-vous tester ce zigzag ? En fait, il s'agit d'une demande à tous ceux qui ont l'expérience de l'utilisation des zigzags et qui savent ce qu'ils attendent d'un zigzag. Peut-être pouvez-vous faire quelque chose d'utile avec ce prototype ?
//+------------------------------------------------------------------+
//|                                                      CZigZag.mq4 |
//|                                         Copyright © 2006, Candid |
//|                                                   likh@yandex.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Candid"
#property link      "likh@yandex.ru"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Blue

//---- indicator parameters
extern int ExtDepth=12;
extern int ExtDeviation=5;
//extern int ExtBackstep=3;

int    shift;
double res;
int i;
int fBar;
double CurMax,CurMin;
int CurMaxPos,CurMinPos;
int CurMaxBar,CurMinBar;
double hPoint;
double mhPoint;
double EDev;
int MaxDist,MinDist;
bool FirstRun;
bool AfterMax,AfterMin;

//---- indicator buffers
double ZigZag[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init() {
//---- indicators
   SetIndexStyle(0,DRAW_SECTION);
//---- indicator buffers mapping
   SetIndexBuffer(0,ZigZag);
   SetIndexEmptyValue(0,0.0);
//---- indicator short name
   IndicatorShortName("CZigZag("+ExtDepth+","+ExtDeviation+")");
   
   FirstRun = true;
//----
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit() {
//----
   
//----
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start() {
  int counted_bars=IndicatorCounted();
  
  if (FirstRun) {
    hPoint = 0.5*Point;
    mhPoint = -hPoint;
//    EDev = ExtDeviation*Point;
    EDev = (ExtDeviation+0.5)*Point;
    AfterMax = true;
    AfterMin = true;
    fBar = Bars-1;
    CurMax = High[fBar];
    CurMaxBar = 1;
    CurMin = Low[fBar];
    CurMinBar = 1;
    MaxDist = 0;
    MinDist = 0;
    FirstRun = false;
  }
//----
  fBar = Bars-counted_bars-1;
  if (fBar > Bars-2) fBar = Bars-2;
  for(shift=fBar; shift>=0; shift--) {
    if (AfterMax) {
//      res = Low[shift]-CurMin-hPoint;
      res = Low[shift]-CurMin;
//      if (res < 0) {
      if (res < mhPoint) {
        ZigZag[Bars-CurMinBar] = 0;
        CurMin = Low[shift];
        CurMinBar = Bars-shift; 
        ZigZag[Bars-CurMinBar] = CurMin;
      } else {  //  if (res < 0)
//        if (res > 0 ) {
        if (res > hPoint ) {
          MaxDist = Bars-CurMaxBar-shift+1;
          MinDist = Bars-CurMinBar-shift+1;
          if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev) {
            AfterMax = false;
            AfterMin = true;
            CurMaxBar = CurMinBar+1;
            CurMaxPos = Bars-CurMaxBar;
            CurMax = High[CurMaxPos];
            for (i=CurMaxPos-1;i>=shift;i--) {
              if (High[i] > CurMax+hPoint) {
                CurMaxBar = Bars-i;
                CurMax = High[i];
              }
            }  //  for (i=CurMaxPos-1;i>=shift;i--)
            ZigZag[Bars-CurMaxBar] = CurMax;
          }  //  if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev)
        }  //  if (res > 0 )
      }  // else if (res < 0)
    }  //  if (AfterMax) 
    if (AfterMin) {
//      res = CurMax-High[shift]-hPoint;
      res = CurMax-High[shift];
//      if (res < 0) {
      if (res < mhPoint) {
        ZigZag[Bars-CurMaxBar] = 0;
        CurMax = High[shift];
        CurMaxBar = Bars-shift; 
        ZigZag[Bars-CurMaxBar] = CurMax;
      } else {  //  if (res < 0)
//        if (res > 0 ) {
        if (res > hPoint ) {
          MaxDist = Bars-CurMaxBar-shift+1;
          MinDist = Bars-CurMinBar-shift+1;
          if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev) {
            AfterMin = false;
            AfterMax = true;
            CurMinBar = CurMaxBar+1;
            CurMinPos = Bars-CurMinBar;
            CurMin = Low[CurMinPos];
            for (i=CurMinPos-1;i>=shift;i--) {
              if (Low[i] < CurMin-hPoint) {
                CurMinBar = Bars-i;
                CurMin = Low[i];
              }
            }  //  for (i=CurMinPos-1;i>=shift;i--)
            ZigZag[Bars-CurMinBar] = CurMin;
          }  //  if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev)
        }  //  if (res > 0 )
      }  // else if (res < 0)
    }  //  if (AfterMin) 
  }  //  for(shift=fBar; shift>=0; shift--)
//----
  return(0);
}
//+------------------------------------------------------------------+


Veuillez noter que, bien que les noms des paramètres soient conservés, ils fonctionnent différemment.


 
Ici aussi, jetez un coup d'œil à mon ZigZag, cela pourrait vous aider à trouver le fond du problème. ....

//+------------------------------------------------------------------+
//|                                                        DT_ZZ.mq4 |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, klot."
#property link      "klot@mail.ru"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Aqua
#property indicator_color2 Blue
#property indicator_color3 Red
//---- indicator parameters
extern int ExtDepth=12;
//---- indicator buffers
double zzL[];
double zzH[];
double zz[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
 //  IndicatorBuffers(3);
//---- drawing settings
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexStyle(0,DRAW_SECTION);
   SetIndexArrow(2,159);
   SetIndexArrow(1,159);
//---- indicator buffers mapping
   SetIndexBuffer(0,zz);
   SetIndexBuffer(1,zzH);
   SetIndexBuffer(2,zzL);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexEmptyValue(2,0.0);
     
//---- indicator short name
   IndicatorShortName("DT_ZZ("+ExtDepth+")");
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int    i,shift,pos,lasthighpos,lastlowpos,curhighpos,curlowpos;
   double curlow,curhigh,lasthigh,lastlow;
   double min, max;
   ArrayInitialize(zz,0.0);
   ArrayInitialize(zzL,0.0);
   ArrayInitialize(zzH,0.0);
   
   lasthighpos=Bars; lastlowpos=Bars;
   lastlow=Low[Bars];lasthigh=High[Bars];
  for(shift=Bars-ExtDepth; shift>=0; shift--)
    {
      curlowpos=Lowest(NULL,0,MODE_LOW,ExtDepth,shift);
      curlow=Low[curlowpos];
      curhighpos=Highest(NULL,0,MODE_HIGH,ExtDepth,shift);
      curhigh=High[curhighpos];
      //------------------------------------------------
      if( curlow>=lastlow ) { lastlow=curlow; }
      else
         { 
            //идем вниз
            if( lasthighpos>curlowpos  ) 
            { 
            zzL[curlowpos]=curlow;
              ///*
              min=100000; pos=lasthighpos;
               for(i=lasthighpos; i>=curlowpos; i--)
                  { 
                    if (zzL[i]==0.0) continue;
                    if (zzL[i]<min) { min=zzL[i]; pos=i; }
                    zz[i]=0.0;
                  } 
               zz[pos]=min;
               //*/
            } 
          lastlowpos=curlowpos;
          lastlow=curlow; 
         }
      //--- high
      if( curhigh<=lasthigh )  { lasthigh=curhigh;}
      else
         {  
            // идем вверх
            if( lastlowpos>curhighpos ) 
            {  
            zzH[curhighpos]=curhigh;
           ///*
               max=-100000; pos=lastlowpos;
               for(i=lastlowpos; i>=curhighpos; i--)
                  { 
                    if (zzH[i]==0.0) continue;
                    if (zzH[i]>max) { max=zzH[i]; pos=i; }
                    zz[i]=0.0;
                  } 
               zz[pos]=max;
           //*/     
            }  
         lasthighpos=curhighpos;
         lasthigh=curhigh;    
         }       
    //----------------------------------------------------------------------
    }
 return(0);
}
//+------------------------------------------------------------------+



 
nen Voulez-vous tester ce zigzag ? En fait, il s'agit d'une demande adressée à toute personne ayant une expérience des zigzags et sachant ce qu'elle attend d'un zigzag. Peut-être pouvez-vous faire quelque chose d'utile avec ce prototype ?
Veuillez noter que bien que les noms des paramètres soient les mêmes, ils fonctionnent différemment.


Candidat. Je vais y jeter un coup d'œil. La première fois que je l'ai installé, j'ai fait l'observation suivante.
Il y a plusieurs barres consécutives avec les mêmes sommets. Votre variante du zigzag dessine la rupture (en haut) sur la dernière barre. C'est-à-dire la barre la plus proche de zéro. Idéalement, la rupture doit être tracée sur la première barre, qui est la plus éloignée de la barre zéro. Le premier sommet qui apparaît est significatif. C'est la même chose avec mtnemums. Je peux citer plusieurs sources (de la littérature), lorsque cela est requis.
 
klot , merci. En suivant l'idée de votre DT-ZigZag, j'ai maintenant fait mon indicateur pour travailler avec des données à haute résolution. Mais je n'ai laissé que l'idée. J'ai créé mon propre algorithme. Hier, j'ai fait quelques corrections supplémentaires en zigzag. Maintenant, je l'ai téléchargé pour un test collectif. Je vais certainement essayer votre variante. Voici la description de l'indicateur qui a causé tout ce désordre : http://onix-trade.net/forum/index.php?showtopic=373. Veuillez noter que le mode DT-ZigZag utilise le zigzag externe qui est inclus avec l'indicateur. Et ce zigzag externe échoue parfois sur le premier rayon. Une nouvelle version du zigzag externe est en cours de test.
 
klot Merci. J'ai utilisé l'idée de votre DT-ZigZag et maintenant j'ai fait mon indicateur pour travailler avec des données à haute résolution. Mais je n'ai laissé que l'idée. J'ai créé mon propre algorithme. Hier, j'ai fait quelques corrections supplémentaires en zigzag. Maintenant, je l'ai téléchargé pour un test collectif. Je vais certainement essayer votre variante. Voici la description de l'indicateur qui a causé tout ce désordre : http://onix-trade.net/forum/index.php?showtopic=373. Veuillez noter que le mode DT-ZigZag utilise le zigzag externe qui est inclus avec l'indicateur. Et ce zigzag externe échoue parfois sur le premier rayon. Une nouvelle version du zigzag externe est en cours de test.

Oui, j'ai remarqué :) juste une idée :) . J'utilise maintenant mon ZZ un peu partout (code dans le post ci-dessus) Il fonctionne de manière plus stable avec d'autres données TF.
 
nen:
Lors de la première installation, le constat suivant s'est immédiatement imposé.
Il y a plusieurs barres consécutives avec les mêmes sommets. Votre option zigzag dessine une rupture (en haut) sur la dernière barre.
Aha, donc j'ai choisi la mauvaise "option". Je vais maintenant modifier le code dans le post source. Les signes de changements sont les lignes commentées de la mauvaise "option".
 
Candid, c'est bon maintenant.
Klot, option intéressante.

Si vos variantes de zigzag donnent des résultats intéressants, puis-je les appliquer dans mon développement ?
 
Si vos variantes de zig-zag donnent des résultats intéressants, pouvez-vous les appliquer dans votre conception ?
Oui, bien sûr. Si le résultat du test est positif, j'essaierai même de l'ajouter à la base de code.