une stratégie commerciale basée sur la théorie des vagues d'Elliott - page 46

 
Je ne pense pas que ce genre de futilités de programmation mérite d'être discuté dans ce fil de discussion.


Merci... J'ai trouvé le chapitre correspondant dans le livre. Au fait, si quelqu'un trouve un jour un bogue dans mon code, quel que soit son degré d'ancienneté, je vous serais reconnaissant de m'en faire part... au cas où je l'aurais manqué. :-)

PS : Je vais essayer de poser moins de questions. :-)
 
Dans le code que j'ai maintenant, la variance est calculée sans appeler une fonction spéciale pour gagner du temps de calcul, et le contrôle <br / translate="no"> if(size-2!=0) disper=disper/(size-2) ;
En général, je pense que de telles bagatelles de programmation ne méritent pas d'être discutées dans ce fil.


Oui, ils le sont.
Parce que je ne comprends pas la nécessité de vérifier if(size-2!=0) - ceci en est une.
Et bien que je me souvienne vaguement avoir utilisé des estimations d'échantillonnage et que je n'argumente pas fortement contre disper=disper/(taille-2) (au lieu de disper=disper/(taille)) Je suis sûr qu'il n'y a aucun intérêt à affiner la forumule (c'est-à-dire qu'il n'y a pas de différence entre les deux dans ce cas) - ça fait deux.
 
... Je suis sûr qu'il est inutile d'affiner la forumule (c'est-à-dire qu'il n'y a pas de différence entre elles dans ce cas) - ça fait deux.


Je ne suis pas mathématicien, mais il me semble qu'avec une taille tendant vers l'infini, la variance tendra vers 0... Ainsi, si vous estimez un échantillon de 400 barres, que vous en soustrayez 1 ou 2, ou que vous ne soustrayez rien du tout, le résultat final n'en sera pas affecté... Néanmoins, la formule est une formule, et si mon oncle a écrit "N-2" dans un livre intelligent, alors personnellement je suis enclin à suivre son conseil... :-)
 
Comme je ne comprends pas la nécessité de vérifier si(taille-2!=0) - c'en est une. <br/ translate="no">Et bien que je me souvienne vaguement avoir utilisé des estimations d'échantillonnage et que je n'argumenterai pas fortement contre disper=disper/(size-2) (au lieu de disper=disper/(size)). Je suis sûr qu'il n'y a aucun intérêt à affiner la forumule (c'est-à-dire qu'il n'y a pas de différence entre les deux dans ce cas) - ça fait deux.

En principe, cette condition est bien sûr totalement inutile.
Je l'ai fait en écrivant le code à l'origine - j'ai enlevé la vérification avant la division, car 0 ne peut pas être parce que l'échantillon est évidemment plus grand. Mais au fur et à mesure du développement du code, des erreurs de division par zéro ont commencé à se produire de temps en temps. Comme il n'y a pas de débogueur dans MT4, il a été difficile de trouver où ce zéro s'est produit. Et jusqu'à ce que j'implémente la condition de vérifier la division par zéro dans toutes les divisions, je n'ai pas réussi à comprendre exactement dans quelle division le zéro était trouvé ! À l'avenir, bien sûr, vous pourrez supprimer cette vérification supplémentaire. Bien que je doute que cela donne un gain de temps de calcul, car le temps de base est consacré au calcul lui-même, mais pas à des vérifications superflues de la stabilité du code.

Il n'y a pas de différence fondamentale dans ces formules pour notre problème et il est peu probable que le bénéfice final soit affecté de manière notable. Mais pourquoi ne pas tout faire en conformité totale avec la façon dont cela devrait être selon les mathématiques ? Dans le système Vladislava, nous essayons simplement de nous éloigner de la subjectivité et d'obtenir l 'évaluation la plus objective de la situation actuelle du marché sur la base de méthodes mathématiques.
 
Je ne suis pas un grand mathématicien, mais il me semble qu'avec une taille tendant vers l'infini, la variance tendra vers 0...

Vous avez raison ! Mais seulement dans la première partie de votre déclaration ;o))))
 
<br/ translate="no">Vladislav, envisagez-vous de corriger le code de l'indicateur Murray à la lumière de nouvelles informations ? Nous attendons la nouvelle version ;o) !


Donc, maintenant, vous pouvez clairement voir la différence - si vous définissez le premier paramètre à true, vous obtiendrez des octaves selon l'ancien algorithme, c'est-à-dire en utilisant les fonctions intégrées pour rechercher les extrema.
Si vous le réglez sur false (paramètre par défaut), vous obtiendrez, IMHO, ce dont vous avez besoin. La différence est la suivante. Les extrêmes sont définis pour la définition de l'échantillon - le maximum le plus haut et le minimum le plus bas dans une zone donnée. Cela garantit que nous avons une probabilité minimale de capturer une partie de la surtendance. Elle est ensuite comparée à la valeur la plus haute/la plus basse des dernières mesures - c'est-à-dire d'un seul côté de la fourchette donnée - si nous sommes dans une tendance, nous pouvons facilement franchir les niveaux fixés et nous devrons reconstruire les octaves à temps.
//+------------------------------------------------------------------+
//|                                                   MMLevls_VG.mq4 |
//|                       Copyright © 2006, Vladislav Goshkov (VG).  |
//|                                           4vg@mail.ru            |
//|                                       Many thanks to Tim Kruzel  |
//+------------------------------------------------------------------+
#property copyright "Vladislav Goshkov (VG)."
#property link      "4vg@mail.ru"

#property indicator_chart_window

// ============================================================================================
// * Линии 8/8 и 0/8 (Окончательное сопротивление).
// * Эти линии самые сильные и оказывают сильнейшие сопротивления и поддержку.
// ============================================================================================
//* Линия 7/8  (Слабая, место для остановки и разворота). Weak, Stall and Reverse
//* Эта линия слаба. Если цена зашла слишком далеко и слишком быстро и если она остановилась около этой линии, 
//* значит она развернется быстро вниз. Если цена не остановилась около этой линии, она продолжит движение вверх к 8/8.
// ============================================================================================
//* Линия 1/8  (Слабая, место для остановки и разворота). Weak, Stall and Reverse
//* Эта линия слаба. Если цена зашла слишком далеко и слишком быстро и если она остановилась около этой линии, 
//* значит она развернется быстро вверх. Если цена не остановилась около этой линии, она продолжит движение вниз к 0/8.
// ============================================================================================
//* Линии 6/8 и 2/8 (Вращение, разворот). Pivot, Reverse
//* Эти две линии уступают в своей силе только 4/8 в своей способности полностью развернуть ценовое движение.
// ============================================================================================
//* Линия 5/8 (Верх торгового диапазона). Top of Trading Range
//* Цены всех рынков тратят 40% времени, на движение между 5/8 и 3/8 линиями. 
//* Если цена двигается около линии 5/8 и остается около нее в течении 10-12 дней, рынок сказал что следует 
//* продавать в этой «премиальной зоне», что и делают некоторые люди, но если цена сохраняет тенденцию оставаться 
//* выше 5/8, то она и останется выше нее. Если, однако, цена падает ниже 5/8, то она скорее всего продолжит 
//* падать далее до следующего уровня сопротивления.
// ============================================================================================
//* Линия 3/8 (Дно торгового диапазона). Bottom of Trading Range
//* Если цены ниже этой лини и двигаются вверх, то цене будет сложно пробить этот уровень. 
//* Если пробивают вверх эту линию и остаются выше нее в течении 10-12 дней, значит цены останутся выше этой линии 
//* и потратят 40% времени двигаясь между этой линией и 5/8 линией.
// ============================================================================================
//* Линия 4/8 (Главная линия сопротивления/поддержки). Major Support/Resistance
//* Эта линия обеспечивает наибольшее сопротивление/поддержку. Этот уровень является лучшим для новой покупки или продажи. 
//* Если цена находится выше 4/8, то это сильный уровень поддержки. Если цена находится ниже 4/8, то это прекрасный уровень 
//* сопротивления.
// ============================================================================================
extern bool OldVersion = false;
extern int P = 90;
extern int MMPeriod = 1440;
extern int StepBack = 0;

extern color  mml_clr_m_2_8 = White;       // [-2]/8
extern color  mml_clr_m_1_8 = White;       // [-1]/8
extern color  mml_clr_0_8   = Aqua;        //  [0]/8
extern color  mml_clr_1_8   = Yellow;      //  [1]/8
extern color  mml_clr_2_8   = Red;         //  [2]/8
extern color  mml_clr_3_8   = Green;       //  [3]/8
extern color  mml_clr_4_8   = Blue;        //  [4]/8
extern color  mml_clr_5_8   = Green;       //  [5]/8
extern color  mml_clr_6_8   = Red;         //  [6]/8
extern color  mml_clr_7_8   = Yellow;      //  [7]/8
extern color  mml_clr_8_8   = Aqua;        //  [8]/8
extern color  mml_clr_p_1_8 = White;       // [+1]/8
extern color  mml_clr_p_2_8 = White;       // [+2]/8

extern int    mml_wdth_m_2_8 = 2;        // [-2]/8
extern int    mml_wdth_m_1_8 = 1;        // [-1]/8
extern int    mml_wdth_0_8   = 2;        //  [0]/8
extern int    mml_wdth_1_8   = 1;        //  [1]/8
extern int    mml_wdth_2_8   = 1;        //  [2]/8
extern int    mml_wdth_3_8   = 1;        //  [3]/8
extern int    mml_wdth_4_8   = 2;        //  [4]/8
extern int    mml_wdth_5_8   = 1;        //  [5]/8
extern int    mml_wdth_6_8   = 1;        //  [6]/8
extern int    mml_wdth_7_8   = 1;        //  [7]/8
extern int    mml_wdth_8_8   = 2;        //  [8]/8
extern int    mml_wdth_p_1_8 = 1;        // [+1]/8
extern int    mml_wdth_p_2_8 = 2;        // [+2]/8

extern color  MarkColor   = Blue;
extern int    MarkNumber  = 217;


double  dmml = 0,
        dvtl = 0,
        sum  = 0,
        v1 = 0,
        v2 = 0,
        mn = 0,
        mx = 0,
        x1 = 0,
        x2 = 0,
        x3 = 0,
        x4 = 0,
        x5 = 0,
        x6 = 0,
        y1 = 0,
        y2 = 0,
        y3 = 0,
        y4 = 0,
        y5 = 0,
        y6 = 0,
        octave = 0,
        fractal = 0,
        range   = 0,
        finalH  = 0,
        finalL  = 0,
        mml[13];

string  ln_txt[13],        
        buff_str = "";
        
int     
        bn_Lo   = -1,
        bn_Hi   = -1,
        extr_bn_Lo  = -1,
        extr_bn_Hi  = -1,
        OctLinesCnt = 13,
        mml_thk = 8,
        mml_clr[13],
        mml_wdth[13],
        mml_shft = 35,
        nT = 0,
        nB = 0,
        nP = 0,
        nDigits = 0,
        i = 0;
int NewPeriod=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init() {
//---- indicators
   if(MMPeriod>0)
      NewPeriod   = P*MathCeil(MMPeriod/Period());
   else NewPeriod = P;
   
   ln_txt[0]  = "[-2/8]P";// "extremely overshoot [-2/8]";// [-2/8]
   ln_txt[1]  = "[-1/8]P";// "overshoot [-1/8]";// [-1/8]
   ln_txt[2]  = "[0/8]P";// "Ultimate Support - extremely oversold [0/8]";// [0/8]
   ln_txt[3]  = "[1/8]P";// "Weak, Stall and Reverse - [1/8]";// [1/8]
   ln_txt[4]  = "[2/8]P";// "Pivot, Reverse - major [2/8]";// [2/8]
   ln_txt[5]  = "[3/8]P";// "Bottom of Trading Range - [3/8], if 10-12 bars then 40% Time. BUY Premium Zone";//[3/8]
   ln_txt[6]  = "[4/8]P";// "Major Support/Resistance Pivotal Point [4/8]- Best New BUY or SELL level";// [4/8]
   ln_txt[7]  = "[5/8]P";// "Top of Trading Range - [5/8], if 10-12 bars then 40% Time. SELL Premium Zone";//[5/8]
   ln_txt[8]  = "[6/8]P";// "Pivot, Reverse - major [6/8]";// [6/8]
   ln_txt[9]  = "[7/8]P";// "Weak, Stall and Reverse - [7/8]";// [7/8]
   ln_txt[10] = "[8/8]P";// "Ultimate Resistance - extremely overbought [8/8]";// [8/8]
   ln_txt[11] = "[+1/8]P";// "overshoot [+1/8]";// [+1/8]
   ln_txt[12] = "[+2/8]P";// "extremely overshoot [+2/8]";// [+2/8]

   //mml_shft = 3;
   mml_thk  = 3;

   // Начальная установка цветов уровней октав и толщины линий
   mml_clr[0]  = mml_clr_m_2_8;   mml_wdth[0] = mml_wdth_m_2_8; // [-2]/8
   mml_clr[1]  = mml_clr_m_1_8;   mml_wdth[1] = mml_wdth_m_1_8; // [-1]/8
   mml_clr[2]  = mml_clr_0_8;     mml_wdth[2] = mml_wdth_0_8;   //  [0]/8
   mml_clr[3]  = mml_clr_1_8;     mml_wdth[3] = mml_wdth_1_8;   //  [1]/8
   mml_clr[4]  = mml_clr_2_8;     mml_wdth[4] = mml_wdth_2_8;   //  [2]/8
   mml_clr[5]  = mml_clr_3_8;     mml_wdth[5] = mml_wdth_3_8;   //  [3]/8
   mml_clr[6]  = mml_clr_4_8;     mml_wdth[6] = mml_wdth_4_8;   //  [4]/8
   mml_clr[7]  = mml_clr_5_8;     mml_wdth[7] = mml_wdth_5_8;   //  [5]/8
   mml_clr[8]  = mml_clr_6_8;     mml_wdth[8] = mml_wdth_6_8;   //  [6]/8
   mml_clr[9]  = mml_clr_7_8;     mml_wdth[9] = mml_wdth_7_8;   //  [7]/8
   mml_clr[10] = mml_clr_8_8;     mml_wdth[10]= mml_wdth_8_8;   //  [8]/8
   mml_clr[11] = mml_clr_p_1_8;   mml_wdth[11]= mml_wdth_p_1_8; // [+1]/8
   mml_clr[12] = mml_clr_p_2_8;   mml_wdth[12]= mml_wdth_p_2_8; // [+2]/8
   
   
//----
   return(0);
  }

//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit() {
//---- TODO: add your code here
Comment(" ");   
for(i=0;i<OctLinesCnt;i++) {
    buff_str = "mml"+i;
    ObjectDelete(buff_str);
    buff_str = "mml_txt"+i;
    ObjectDelete(buff_str);
    }
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+

//=========================================================================
int FindeExtrHi_bn(int n_bg, int n_nd ){

int    ext_bn = -1;
double ext_Hi = -10000000000000000000.0;
int    k = 0;
int    stop_bn = -1;
int    start_bn = -1;
int    cur_bn = n_bg;
    //Print(" FindeExtrHi_bn : n_bg = ", n_bg," n_nd = ", n_nd);
    if(n_bg<n_nd){
       start_bn = n_bg+1;
       stop_bn  = n_nd; 
       //Print(" FindeExtrHi_bn (n_bg<n_nd): start_bn = ", start_bn," stop_bn = ", stop_bn);
       for(int j=start_bn;j<stop_bn;j++){
          if( (High[j]>High[j+1])&&(High[j]>High[j-1])&&(High[j]>ext_Hi) ){
             ext_bn = j;
	          ext_Hi = High[j];
	          }
	       }//for(int j=start_bn;j<stop_bn;j++){
       }//if(n_bg<n_nd){


    if(n_bg>n_nd){
       start_bn = n_bg;
       stop_bn  = n_nd+1; 
       //Print(" FindeExtrHi_bn (n_bg>n_nd): start_bn = ", start_bn," stop_bn = ", stop_bn);
       for( j=start_bn;j>stop_bn;j--){
          if( (High[j]>High[j+1])&&(High[j]>High[j-1])&&(High[j]>ext_Hi) ){
             ext_bn = j;
	          ext_Hi = High[j];
	          }
          }//for(int j=start_bn;j>stop_bn;j--){
       }//if(n_bg>n_nd){
   
   //Print(" FindeExtrHi_bn:=> ext_bn = ",ext_bn);
   return(ext_bn);
   }

//=========================================================================
int FindeExtrLo_bn(int n_bg, int n_nd ){

int    ext_bn = -1;
double ext_Lo = 10000000000000000000.0;
int    stop_bn = -1;
int    start_bn = -1;
int    cur_bn = n_bg;


    //Print(" FindeExtrLo_bn : n_bg = ", n_bg," n_nd = ", n_nd);

    if(n_bg<n_nd){
       start_bn = n_bg+1;
       stop_bn  = n_nd; 
       //Print(" FindeExtrLo_bn (n_bg<n_nd): start_bn = ", start_bn," stop_bn = ", stop_bn);
       for(int j=start_bn;j<stop_bn;j++){
          if( (Low[j]<Low[j+1])&&(Low[j]<Low[j-1])&&(Low[j]<ext_Lo) ){
             ext_bn = j;
	          ext_Lo = Low[j];
	          }
	       }//for(int j=start_bn;j<stop_bn;j++){
       }//if(n_bg<n_nd){


    if(n_bg>n_nd){
       start_bn = n_bg;
       stop_bn  = n_nd+1; 
       //Print(" FindeExtrLo_bn (n_bg>n_nd): start_bn = ", start_bn," stop_bn = ", stop_bn);
       for( j=start_bn;j>stop_bn;j--){
          if( (Low[j]<Low[j+1])&&(Low[j]<Low[j-1])&&(Low[j]<ext_Lo) ){
             ext_bn = j;
	          ext_Lo = Low[j];
	          }
          }//for(int j=start_bn;j>stop_bn;j--){
       }//if(n_bg>n_nd){
   //Print(" FindeExtrLo_bn:=> ext_bn = ",ext_bn);
   return(ext_bn);
   }

int start() {
//---- TODO: add your code here

if( (nT!=Time[0])||(nP!=Period())||(nB!=Bars) ) {
   
  //price
  //Print("MMLevls : NewPeriod = ",NewPeriod);
   if(OldVersion){
      bn_Lo = Lowest(NULL,0,MODE_LOW,NewPeriod,StepBack);
      bn_Hi = Highest(NULL,0,MODE_HIGH,NewPeriod,StepBack);
   } else {//  if(OldVersion){
      extr_bn_Lo = FindeExtrLo_bn(NewPeriod+StepBack,StepBack);
      extr_bn_Hi = FindeExtrHi_bn(NewPeriod+StepBack,StepBack);
      //Print("MMLevls : NewPeriod = ",NewPeriod," extr_bn_Lo = ",extr_bn_Lo ," extr_bn_Hi = ",extr_bn_Hi);
      //Print("MMLevls : NewPeriod = ",NewPeriod," High[extr_bn_Lo] = ",High[extr_bn_Lo] ," extr_bn_Hi = ",extr_bn_Hi);
      if(extr_bn_Lo>=0){
         bn_Lo = extr_bn_Lo;
         for(int k=0;k<1;k++){
            if(Low[k]<Low[extr_bn_Lo]) {
               bn_Lo = k;
               break;
               }
            }
         } else bn_Lo = Lowest(NULL,0,MODE_LOW,NewPeriod,StepBack);
      if(extr_bn_Hi>=0){
         bn_Hi = extr_bn_Hi;
         for(k=0;k<1;k++){
            if(High[k]>High[extr_bn_Hi]) {//ошибка была здесь
               bn_Lo = k;
               break;
               } 
            }
         } else  bn_Hi = Highest(NULL,0,MODE_HIGH,NewPeriod,StepBack);
      // Пусть будет на всякий случай :).
      if(High[bn_Hi]<Low[bn_Lo]){
         //Print("MM ??? HiLo :High[",bn_Hi,"] = ",High[bn_Hi]," Low",bn_Lo,"] = ",Low[bn_Lo]);
         bn_Lo = Lowest(NULL,0,MODE_LOW,NewPeriod,StepBack);
         bn_Hi = Highest(NULL,0,MODE_HIGH,NewPeriod,StepBack);
         }

      }//} else {//  if(OldVersion){

   v1 = Low[bn_Lo];
   v2 = High[bn_Hi];

//determine fractal.....
   if( v2<=250000 && v2>25000 )
   fractal=100000;
   else
     if( v2<=25000 && v2>2500 )
     fractal=10000;
     else
       if( v2<=2500 && v2>250 )
       fractal=1000;
       else
         if( v2<=250 && v2>25 )
         fractal=100;
         else
           if( v2<=25 && v2>12.5 )
           fractal=12.5;
           else
             if( v2<=12.5 && v2>6.25)
             fractal=12.5;
             else
               if( v2<=6.25 && v2>3.125 )
               fractal=6.25;
               else
                 if( v2<=3.125 && v2>1.5625 )
                 fractal=3.125;
                 else
                   if( v2<=1.5625 && v2>0.390625 )
                   fractal=1.5625;
                   else
                     if( v2<=0.390625 && v2>0)
                     fractal=0.1953125;
      
   range=(v2-v1);
   //Print(" v2 = ",v2," v1 = ",v1," range = ",range );
   sum=MathFloor(MathLog(fractal/range)/MathLog(2));
   octave=fractal*(MathPow(0.5,sum));
   mn=MathFloor(v1/octave)*octave;
   if( (mn+octave)>v2 )
   mx=mn+octave; 
   else
     mx=mn+(2*octave);


// calculating xx
//x2
    if( (v1>=(3*(mx-mn)/16+mn)) && (v2<=(9*(mx-mn)/16+mn)) )
    x2=mn+(mx-mn)/2; 
    else x2=0;
//x1
    if( (v1>=(mn-(mx-mn)/8))&& (v2<=(5*(mx-mn)/8+mn)) && (x2==0) )
    x1=mn+(mx-mn)/2; 
    else x1=0;

//x4
    if( (v1>=(mn+7*(mx-mn)/16))&& (v2<=(13*(mx-mn)/16+mn)) )
    x4=mn+3*(mx-mn)/4; 
    else x4=0;

//x5
    if( (v1>=(mn+3*(mx-mn)/8))&& (v2<=(9*(mx-mn)/8+mn))&& (x4==0) )
    x5=mx; 
    else  x5=0;

//x3
    if( (v1>=(mn+(mx-mn)/8))&& (v2<=(7*(mx-mn)/8+mn))&& (x1==0) && (x2==0) && (x4==0) && (x5==0) )
    x3=mn+3*(mx-mn)/4; 
    else x3=0;

//x6
    if( (x1+x2+x3+x4+x5) ==0 )
    x6=mx; 
    else x6=0;

     finalH = x1+x2+x3+x4+x5+x6;
// calculating yy
//y1
    if( x1>0 )
    y1=mn; 
    else y1=0;

//y2
    if( x2>0 )
    y2=mn+(mx-mn)/4; 
    else y2=0;

//y3
    if( x3>0 )
    y3=mn+(mx-mn)/4; 
    else y3=0;

//y4
    if( x4>0 )
    y4=mn+(mx-mn)/2; 
    else y4=0;

//y5
    if( x5>0 )
    y5=mn+(mx-mn)/2; 
    else y5=0;

//y6
    if( (finalH>0) && ((y1+y2+y3+y4+y5)==0) )
    y6=mn; 
    else y6=0;

    finalL = y1+y2+y3+y4+y5+y6;

    for( i=0; i<OctLinesCnt; i++) {
         mml[i] = 0;
         }
         
   dmml = (finalH-finalL)/8;
   //Print("MMLevls : NewPeriod = ",NewPeriod," dmml = ",dmml," finalL = ",finalL);
   mml[0] =(finalL-dmml*2); //-2/8
   for( i=1; i<OctLinesCnt; i++) {
        mml[i] = mml[i-1] + dmml;
        }
   for( i=0; i<OctLinesCnt; i++ ){
        buff_str = "mml"+i;
        if(ObjectFind(buff_str) == -1) {
           ObjectCreate(buff_str, OBJ_HLINE, 0, Time[0], mml[i]);
           ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
           ObjectSet(buff_str, OBJPROP_COLOR, mml_clr[i]);
           ObjectSet(buff_str, OBJPROP_WIDTH, mml_wdth[i]);
           ObjectMove(buff_str, 0, Time[0],  mml[i]);
           }
        else {
           ObjectMove(buff_str, 0, Time[0],  mml[i]);
           }
             
        buff_str = "mml_txt"+i;
        if(ObjectFind(buff_str) == -1) {
           ObjectCreate(buff_str, OBJ_TEXT, 0, Time[mml_shft], mml_shft);
           ObjectSetText(buff_str, ln_txt[i], 8, "Arial", mml_clr[i]);
           ObjectMove(buff_str, 0, Time[mml_shft],  mml[i]);
           }
        else {
           ObjectMove(buff_str, 0, Time[mml_shft],  mml[i]);
           }
        } // for( i=1; i<=OctLinesCnt; i++ ){

   string buff_str = "LR_LatestCulcBar";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_ARROW,0, Time[StepBack], Low[StepBack]-2*Point );
      ObjectSet(buff_str, OBJPROP_ARROWCODE, MarkNumber);
      ObjectSet(buff_str, OBJPROP_COLOR, MarkColor);
      }
   else {
      ObjectMove(buff_str, 0, Time[StepBack], Low[StepBack]-2*Point );
      }

   nT = Time[0];
   nB = Bars;
   nP = Period();
   }//if( (nT!=Time[0])||(nP!=Period())||(nB!=Bars) ) {
 
//---- End Of Program
  return(0);
  }
//+------------------------------------------------------------------+ 




Bonne chance et bonnes tendances.
HZZ il y a eu une erreur - j'ai réécrit le code - maintenant la différence n'est pas si visible :).

 
Так как я не понимаю необходимость проверки if(size-2!=0) - это раз.
И хотя я смутно вспоминаю использование оценок по выборке и не буду сильно спорить против disper=disper/(size-2) (вместо disper=disper/(size)) , уверен, что нет смысла затачивать форумулу(то есть, разницы между ними нет в данном случае) - это два.

En principe, bien sûr, cette condition est totalement inutile.
Lorsque j'ai écrit le code, c'est ce que j'ai fait à l'origine - j'ai supprimé la vérification avant la division, parce que 0 ne peut pas être parce que l'échantillon est évidemment plus grand. Mais au fur et à mesure du développement du code, des erreurs de division par zéro ont commencé à se produire de temps en temps. En même temps, comme il n'y a pas de débogueur dans MT4, il était difficile de trouver où ce zéro s'était produit. Et jusqu'à ce que je vérifie la condition de vérification de la division par zéro dans toutes les divisions, je n'ai pas compris exactement dans quelle division le zéro était trouvé ! À l'avenir, bien sûr, vous pourrez supprimer cette vérification supplémentaire. Bien que je doute que cela donne un gain de temps de calcul, car le temps de base est consacré au calcul lui-même, mais pas à des vérifications superflues de la stabilité du code.

Il n'y a pas de différence fondamentale dans ces formules pour notre problème et il est peu probable que le bénéfice final soit affecté de manière notable. Mais pourquoi ne pas tout faire en conformité totale avec la façon dont cela devrait être selon les mathématiques ? Dans le système Vladislava, nous essayons simplement de nous affranchir de la subjectivité et d'obtenir l'évaluation la plus objective possible de la situation actuelle du marché, sur la base de méthodes mathématiques.


En fait, il n'y a pas de différence du tout, car l'erreur est négligeable, mais chacun peut, bien sûr, compter à sa manière.

 
Et donc - maintenant, vous pouvez clairement voir la différence - le premier paramètre défini dans fals - vous obtenez des octaves selon l'ancien algorithme, c'est-à-dire en utilisant les fonctions intégrées pour trouver les extrema. <br / translate="no">si vous le définissez dans trull (il est par défaut), vous obtiendrez IMHO - c'est ce dont vous avez besoin.

En effet, nous pouvons maintenant voir la différence dans la performance de l'indicateur.
Merci beaucoup pour cette amélioration ! Maintenant, la phrase "tous les niveaux sont normalisés à l'échelle quotidienne" a probablement reçu sa pleine application dans l'indicateur finalisé.
 
Vladislav,
veuillez voir à quel point cette situation est correcte ? USDCAD H4, décalage 40.
https://c.mql5.com/mql4/forum/2006/06/new_indicator.zip
Vous pouvez voir comment le prix est passé à une figure et demie en dessous de la ligne d'indicateur la plus basse. Ça ne devrait pas être comme ça ?
 
Vladislav,<br / translate="no"> voir si cette situation est correcte ? USDCAD H4, décalage 40.
https://c.mql5.com/mql4/forum/2006/06/new_indicator.zip
Vous pouvez voir que le prix s'est déplacé d'un chiffre et demi en dessous de la ligne d'indicateur la plus basse. Ça ne devrait pas être comme ça ?


Non, ça ne devrait pas. Désolé - il y a eu une erreur - le résultat d'une faute de frappe - lors de la comparaison avec le bord droit de la plage. Je l'ai corrigé. Maintenant, les différences ne sont plus aussi visibles :). Là, au lieu du numéro de barre de l'extrême haut pour le haut, on a pris le numéro de barre de l'extrême bas. Je l'ai découvert lorsque j'ai commencé à parcourir l'histoire en détail.
Je vais réarranger les codes.

Bonne chance et bonnes tendances.

ZS raccroché.
Raison: