Pastori ZigZags

[Violetta Novak]

Cara Assemblea! Per favore, non giudicate severamente, siate un po' indulgenti, è soprattutto un severo carrozzone di studiosi e io sono una modesta casalinga con alcune domande sulla tesi di Pastukhov. Si prega di rispondere a coloro che sono interessati a zigzagare.

[Violetta Novak]

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?

[Violetta Novak]

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

[Violetta Novak]

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.

[Mikhail Bilan]

охохохоох((( что это такое ?(

[Mickey Moose]

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

1) che diavolo è questa cosa?

2) a cosa serve?

[khorosh]

Михаил Билан:
hohohohohoho(((( cosa è questo?

Mickey Moose:

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).

[Violetta Novak]

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.

[Violetta Novak]

Davvero, grazie mille per aver risposto, vorrei sentire qualche parola sull'argomento

[Violetta Novak]

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

[Alexey Volchanskiy]

Михаил Билан:
hohohohohoho(((( cos'è quello?

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