Pastori ZigZags

C'era un thread come questo qui una volta https://www.mql5.com/ru/forum/105771

и

https://www.mql5.com/ru/forum/105771

sono tutti sulla volatilità H. Qualcun altro è interessato a questo?

Диссертация Пастухова https://smart-lab.ru/tag/%D0%BF%D0%B0%D1%81%D1%82%D1%83%D1%85%D0%BE%D0%B2/

La domanda si riferisce alla pagina 81. Le formule sono leggermente fuori posto, dove le parentesi, Kagi(H) è circa 2, Kagi2(H) è circa 5, Renko(H) è circa 2 e Renko2(H) è circa 6. La costruzione di Kagi è più sensibile di Renko, e qui tutto equivale a un 2, e poi qualche dubbio.

Lasciatemi ricordare un po' il caso senza mercato di arbitraggio che abbiamo quando costruiamo lo zigzag Kagi e Renko H-volatilità =2, flat<2, trend>2. Questo è lo stesso che nel caso dell'indice Hurst.

Apprezzo certamente la ricerca della conoscenza, ma ho solo due domande

1) che diavolo è questa cosa?

2) a cosa serve?

Bene, bisogna capire che l'umile casalinga si riferisce ai mariti colti, e non ai pazzi come te).

C'è anche una pubblicazione simile qui https://www.argolab.net/izuchaem-zigzagi.html

Questa è in realtà la stessa cosa, solo che la formula è leggermente modificata e viene introdotto il concetto di overshoot. Il principio è lo stesso.

Tutti gli zigzag sono utilizzati per valore di soglia, così come nella tesi di Pastukhov.

Nel caso degli zigzag Renko, che sono meno sensibili di Kagi, la distribuzione di probabilità dell'occorrenza dei segmenti H è in potenza di due, cioè

1H-50%, 2H-25%, 3H-12,5%, ecc. Quindi si ottiene la non arbitrarietà, cioè in media su SB abbiamo 2 segmenti Su BP a campione piuttosto grande si ottengono le stesse cifre, cioè abbiamo un po' più di 2 o un po' meno di 2.

Sono interessato alla distribuzione Kagi zigzag, qualcuno può consigliare, perché non c'è 2.

Esempio di costruzione di uno zigzag Kagi

https://www.mql5.com/ru/code/1027

e questo è uno zigzag Renko,if(High[i]>zzH[last] add + profondità ,

      } else //direction<0
      {
         if(Low[i]<zzL[last] добавить -depth

//+------------------------------------------------------------------+
//|                                                       FastZZ.mq4 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yurich"
#property link      "https://login.mql5.com/ru/users/Yurich"
//---
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Red
#property indicator_color2 Red
#property indicator_color3 Gold
#property indicator_color4 DodgerBlue

#property indicator_width3 3
#property indicator_width4 3

//--- input parameters
extern int  Depth    = 300;
extern bool AllPoint = true;
//---
double zzH[], zzL[];
double depth;
int last, direction, pbars;
datetime lastbar;

double ArrUp[];
double ArrDn[];
//+------------------------------------------------------------------+
int init()
{
//---- indicators
   SetIndexBuffer(0,zzH);
   SetIndexBuffer(1,zzL);
   SetIndexBuffer(2,ArrUp);
   SetIndexBuffer(3,ArrDn);
   
   SetIndexStyle(0,DRAW_ZIGZAG);
   SetIndexStyle(1,DRAW_ZIGZAG);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexStyle(3,DRAW_ARROW);
   
   SetIndexArrow(2,159);
   SetIndexArrow(3,159);
   
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   IndicatorDigits(Digits);
//----
   depth=Depth*Point;
   direction=1;
   last=0;
   pbars=0;
   lastbar=0;
   return(0);
}
//+------------------------------------------------------------------+
int start()
{
   int limit=Bars-IndicatorCounted()-1;
   if(lastbar!=Time[0])
   {
      lastbar=Time[0];
      last++;
   }
   if(MathAbs(Bars-pbars)>1) { last=Bars-1; limit=last;}
   pbars=Bars;
   //---
   for(int i=limit; i>0; i--)
   {
      bool set=false;
      zzL[i]=0;
      zzH[i]=0;
      ArrUp[i]=EMPTY_VALUE;
      ArrDn[i]=EMPTY_VALUE;
      //---
      if(direction>0)
      {
         if(High[i]>zzH[last]+depth)
         {
            zzH[last]=0;
            zzH[i]=High[i];
            if(AllPoint) ArrUp[i]=High[i];
            
            if(Low[i]<High[last]-depth)
            {
               if(Open[i]<Close[i])
                {
                  zzH[last]=High[last]; 
                  ArrUp[i]=High[i];
                }else direction=-1;
               zzL[i]=Low[i];
               ArrDn[i]=Low[i];
            }
            last=i;
            set=true;
         }
         if(Low[i]<zzH[last]-depth && (!set || Open[i]>Close[i]))
         {
            zzL[i]=Low[i];
            ArrDn[i]=Low[i];
            
            if(High[i]>zzL[i]+depth && Open[i]<Close[i])
             {
               zzH[i]=High[i];
               ArrUp[i]=High[i]; 
             }else direction=-1;
            last=i;
         }
      } else //direction<0
      {
         if(Low[i]<zzL[last]-depth)
         {
            zzL[last]=0;
            zzL[i]=Low[i];
            if(AllPoint) ArrDn[i]=Low[i];
            
            if(High[i]>Low[last]+depth)
            {
               if(Open[i]>Close[i])
                {
                  zzL[last]=Low[last]; 
                  ArrDn[i]=Low[i];
                }else direction=1;
               zzH[i]=High[i];
               ArrUp[i]=High[i];
            }
            last=i;
            set=true;
         }
         if(High[i]>zzL[last]+depth && (!set || Open[i]<Close[i]))
         {
            zzH[i]=High[i];
            ArrUp[i]=High[i];
            
            if(Low[i]<zzH[i]-depth && Open[i]>Close[i])
             {
               zzL[i]=Low[i]; 
               ArrDn[i]=Low[i];
             }else direction=1;
            last=i;
         }
      }
   }
//----
   zzH[0]=0;
   zzL[0]=0;
//----
   return(0);
}
//+------------------------------------------------------------------+

Questo è "Guai di Wit" nel più alto grado di purificazione. Un'epurazione della connessione con la realtà.