a trading strategy based on Elliott Wave Theory - page 64

 
<br/ translate="no"> I totally agree with Rosh. Inflow is best associated with the delta, and Close[] with the volume accumulated in the reservoir. However, it seems to me that since Close[] is the cumulative total from the delta, the two series are very closely related. Therefore, the Hurst coefficients for them must somehow correlate. But you should hardly rely on my opinion. All I am saying is based only on my general understanding. When I work with my hands, I will be able to form a more informed opinion.


And I am gradually leaning towards that view. Something remains to be clarified, namely. Suppose, reasoning by analogy, Close[] is the water level in a reservoir. We have no way to measure the exact inflow (rainfall, numerous rivers, etc.), but will estimate the inflow, by the level.

When the water level increases, everything is clear - the inflow will be a positive difference. But if we started the observation in a dry summer and as a consequence - negative values of the change in the level. After all, a decrease in the level does not mean that there was no inflow, just that more has flowed out than inflow. The average inflow should be equal to the volume released from the reservoir each year. Again some cyclicality comes up.

I want to clarify what is the correct methodologically to take as inflow for my case:
- Only the difference
- Only the difference modulo
- Only the positive difference

Intuitively, I understand that the main thing is to correctly determine the inflow.

I also doubt that there is a correlation between Close[] and Close[i]-Close[i+1]. I once tried to find it using DSP methods (as a test, I was debugging functions to determine correlation and autocorrelation of signals at the time), the calculation result - not related in any way. This, in general, can be seen with the naked eye, if you look at the shape of the signal. But these are DSP methods, it may not be logical to use them in this case.

Also, one cannot reconstruct the original series by Close[i]-Close[i+1] alone - the necessary information is just lost, and the Hearst calculation is performed, in fact, by a different series from the original one.
 
<br / translate="no"> I would like to clarify what is the correct methodologically to take as an inflow for my case:
-Difference only
- modulo difference
- only positive difference

Intuitively, I understand that the main thing is to correctly determine the inflow.

I also doubt that there is a correlation between Close[] and Close[i]-Close[i+1].
...
Also, one cannot reconstruct the original series by Close[i]-Close[i+1] alone - the necessary information is just lost, and the Hearst calculation is performed, in fact, by a different series from the original one.


I would only take the difference. Also, if you've got a good reason, don't say you can't use it :)

http://forex.kbpauk.ru/showflat.php/Cat/0/Number/120077/an/0/page/0#Post120077
 
<br/ translate="no"> Indeed, I use completely different approaches. Although spectral analysis of random series is, I think, a very interesting direction. However, too complicated for me. And too far from my specialty, to take it now.


And I am not a professional "digitizer". Three months ago I've come across an article praising the use of DSP in trading. I found it interesting, and decided to make a basic set of digital filters. Well, it was done. Went to a bookstore, chose two thickest books and bought them. After reading the first 200 pages of the first book I encountered, I closed it and, muttering swear words, went to pick up the dusty two-volume book of mathematics.

I was interested not to buy a ready-made product (I have enough money for that), but to make my own, assuming that the study of this area - new ideas will appear. And so it happened. Within 3 months, without any distractions I got what I wanted - DSP-based indicators and a lot of ideas.

But perfection knows no boundaries....) :о))) I want to ask professionals (it's faster or I'll get it myself, but later) to define some specifications of existing filters and write really adaptive filter.

From what is offered - no one has them, I mean no adaptive filters.

PS: And I'll get to spectra soon :o))))
 
<br / translate="no"> ...
I would only take the difference.
...


I'm thinking the same thing. It's a lot of right data, well ... almost right.
 
And I'm not a professional "digitizer"<br/ translate="no"> ......
- DSP based indicators and a bunch of ideas.
......
From what's on offer - no one has them, I mean no adaptive filters.
PS: And I'll get to spectra soon :o))))

Here I am, I believe in DSP and "not a professional "digitizer""
I use this:
"Package for technical analysis by digital filtering methods
Developed thanks to Keny (Oleg, Krasnoyarsk, unclekenny@yandex.ru) and
Goodman (Zyabrev Ilya, Moscow, info@goodman.ru)
Help in testing - Tsygankov Andrey gypsy@mail.ru, Elizarov Oleg TOPpoint@yandex.ru
Distributed for free according to "AS-IS" principles.
Please inform the author about all remarks and errors."
and there is one unrealized idea how to optimize filters on the fly:
There is nothing new. This has been done manually hundreds of times, but how to automate it? -
I'm talking about FATL SATL (FATL-SATL, FATL SATL CD ...) and adjusting their parameters
manually using spectrum analyzer (included in the package).
A library is needed that performs spectrum analysis, giving output periods of
maximum signal density (time series). Analysing this data
for different fragments of time series you may try to guess periods, phases, weighted coefficients (amplitudes) of harmonic components (how? I don't know yet)
The more harmonic components may be determined the more probable it is to forecast development of series. That's all.
Yeshe. If the forecast differs a lot from reality, we can suppose the reaction
of the market to strong news. Now that is all.

Not a programmer and not a mathematician. :)
This branch is clearly beyond my skills. I've been chewing on it for a week now. :(
 
Vladislav, I have a question about the Murray indicator. I have noticed it a long time ago when I use your indicator in my Expert Advisor (the latest version) that sometimes there are days when the new version of the indicator does not show levels correctly, while the old version has no such drawback. To avoid such failures at such moments I simply use the latest correctly calculated levels. Earlier I used to put it down to some imperfection of the MT4 tester, but now the situation happened that I have long observed in my Expert Advisor during tests on history (i.e., the tester was not mistaken in indicating the possibility of such a situation!) Please see the screenshots at https://c.mql5.com/mql4/forum/2006/06/Murrey_new_and_old.zip
Two screenshots made with only one difference in calculation version setting (OldVersion: true and false)
You can see that the old version shows habitual levels, while the new one shows a failure with the same parameters - "sticky" Murray levels. Can you comment on this situation? Are "adhered" Murray levels in the new version of the indicator just a technical failure or do they have a deeper meaning? For example, no Murray levels can exist today because of the strongest movement and we should just wait until they are correctly calculated for example on Monday and then we can make decisions about market entry? And today, for example, if you did not manage to enter yesterday, it would be better to stay out of the market? I would like to hear your opinion on this issue.

PS: But now with the new bar the new version has started to display the same Murray levels as the old one. Probably it is some technical error of the new version of calculation of the Murray levels.

PPS: A couple more bars came and levels in the new version are stuck together again.
 
Technical analysis package for digital filtering methods

where can i see it?
google is silent
 
Vladislav I have a question about the Murray indicator.
...............................................
PS: But now with the arrival of the new bar and the new version began to show the same Murray levels as the old one. Probably it is some technical mistake of the new version of Murray's levels calculation.

PPS: A couple more bars came and levels in the new version are stuck together again.


Strange - I'll keep an eye on it - of course it shouldn't be like that. Need to look at the initialisation of the arrays I'll check.
I actually don't have it, but I don't use it as a separate indicator - I just built the code into the Expert Advisor.

HH I found one more place where there was a typo. You were right - the error is technical. Here is the corrected code :

i//+------------------------------------------------------------------+
//|                                                   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;
int CurPeriod=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init() {
//---- indicators
   CurPeriod=Period();
   if(MMPeriod>CurPeriod)
      NewPeriod   = P*MathCeil(MMPeriod/CurPeriod);
   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) ) {
   CurPeriod=Period();
   if(MMPeriod>CurPeriod)
      NewPeriod   = P*MathCeil(MMPeriod/CurPeriod);
   else NewPeriod = P;
   
  //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);
      if(extr_bn_Lo>=0){
         bn_Lo = extr_bn_Lo;
         //Print("MMLevls : 1 bn_Lo = ",bn_Lo);
         for(int k=0;k<1;k++){
            if(Low[k]<Low[extr_bn_Lo]) {
               bn_Lo = k;
               break;
               }
            }
         //Print("MMLevls : 2 bn_Lo = ",bn_Lo);
         } 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_Hi = 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){

   //Print("MMLevls : Low[",bn_Lo,"] = ",Low[bn_Lo]," High[",bn_Hi,"] = ",High[bn_Hi]);
 
   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);
  }
//+------------------------------------------------------------------+ 



Good luck and happy trends.



 
ZS Found another place where there was a typo. You were right - it was a technical error. Here is the corrected code :

Really fixing one more error eliminated the problem, as only the original version of adding code at the beginning of start() did not solve the problem and I was about to send you quotes and screenshots to reproduce the problem on your computer. But now it is not needed because you have completely solved the problem judging by my observation of the latest corrected code. I will move the new corrected code to my Expert Advisor.

Thank you very much for the prompt solution of the problem!!!
 
Demax, Digital Method Generator - http://fx.qrz.ru/
There is also a paid one from Finware. haven't tried it