Cosa restituiscono le funzioni Lowest e Highest - pagina 5

 
Candid Ora sto bene.
Klot, opzione interessante.

Se le vostre varianti di zigzag mostrano risultati interessanti, posso applicarle nel mio sviluppo?

Certo che puoi, sto seguendo lo sviluppo con interesse e mi piace molto il tuo lavoro.
 
Grazie.
 
2 nen:
Altro per quanto riguarda le "opzioni". Ora una delle condizioni per la commutazione dell'estremo: la corrente bassa è superiore alla corrente bassa per più di punti di ExtDeviation (simile per l'alto). Il codice permette di implementare altre opzioni abbastanza facilmente, se necessario.
Bene, seguendo klot vorrei aggiungere che il mio attuale interesse per lo zigzag è causato unicamente dal mio interesse per il tuo disegno.
 
Corretto di nuovo il codice sorgente - ieri ho scoperto che la regola della prima barra significativa a volte non è rispettata sui minuti. Per verificarlo, ho avuto solo un'ora e mezza di tempo online, ma sembra che si sia trattato di confrontare il doppio con lo zero.
 
Un altro bug: gli estremi possono essere commutati solo alla fine di una barra, altrimenti c'è una differenza tra il tempo reale e la storia. Non è difficile da riparare. Non ho ancora corretto il codice sorgente nel ramo - lasciate che la nuova versione venga eseguita a minuti.
 
Candido, fatto una versione 45 dell'indicatore ZUP: http://onix-trade.net/forum/index.php?s=&showtopic=118&view=findpost&p=117997
Incluso il tuo zigzag come uno zigzag esterno. Non appena apparirà una versione stabile e funzionante, la cambierò.
 
Finora non vedo alcun problema, ecco la versione corretta del codice:
//+------------------------------------------------------------------+
//|                                                      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 Navy

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

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

//---- 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("ZigZag("+ExtDepth+","+ExtDeviation+")");
   
   FirstRun = true;
//----
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit() {
//----
   
//----
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start() {
  int counted_bars=IndicatorCounted();
  int fBar;
  
  if (FirstRun) {
    hPoint = 0.5*Point;
    mhPoint = -hPoint;
    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;
    BarTime = 0;
    FirstRun = false;
  }


//----
  fBar = Bars-counted_bars-1;
  if (fBar > Bars-2) fBar = Bars-2;
  for(shift=fBar; shift>=0; shift--) {
    if (BarTime!=Time[shift]) {
      BarTime=Time[shift];
      if (res > hPoint ) {
        MaxDist = Bars-CurMaxBar-shift+1;
        MinDist = Bars-CurMinBar-shift+1;
        if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev) {
          if (AfterMax) {
            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;
          } else {  //  if (AfterMax)
            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;
          }  //  else if (AfterMax)    
        }  //  if ((MaxDist>ExtDepth && MinDist>ExtDepth) || res > EDev)
      }  //  if (res > hPoint )
    }  //  if (BarTime!=Time[0])
    if (AfterMax) {
      res = Low[shift]-CurMin;
      if (res < mhPoint) {
        ZigZag[Bars-CurMinBar] = 0;
        CurMin = Low[shift];
        CurMinBar = Bars-shift; 
        ZigZag[Bars-CurMinBar] = CurMin;
      }  //  if (res < mhPoint)
    }  //  if (AfterMax) 
    if (AfterMin) {
      res = CurMax-High[shift];
      if (res < mhPoint) {
        ZigZag[Bars-CurMaxBar] = 0;
        CurMax = High[shift];
        CurMaxBar = Bars-shift; 
        ZigZag[Bars-CurMaxBar] = CurMax;
      }  //  if (res < mhPoint)
    }  //  if (AfterMin) 
  }  //  for(shift=fBar; shift>=0; shift--)
//----
  return(0);
}
//+------------------------------------------------------------------+


A proposito delle peculiarità dei diversi zigzag. La caratteristica principale di questo zigzag è che tutto è fatto in un solo passaggio, la rivisitazione dei dati storici è fatta solo quando un estremo è fissato, e solo per i dati dopo quell'estremo. Cioè, deve essere abbastanza veloce. I particolari del disegno dipenderanno naturalmente dai criteri di fissaggio degli estremi, ma varie opzioni possono essere facilmente implementate qui. Per esempio, ho già fatto delle varianti di commutazione per percentuale di una mossa precedente, per allontanamento di High dal minimo (rispettivamente Low dal massimo) e legando la commutazione alla dimensione media della barra.

 
Ecco un altro problema con l'indicatore: ho trovato una piega nel mio zigzag (croce del cursore nella foto). Il tempo della piega corrisponde a quando il terminale è stato spento, il prezzo corrisponde a quando è stato riacceso.


Per chiarire i miei sospetti, ho inserito il Print nel codice:
if (shift<5) Print ("shift=",shift,", Bars=",Bars,", Time[shift]=",TimeToStr(Time[shift],TIME_DATE|TIME_MINUTES),", High[shift]=",High[shift],", Low[shift]=",Low[shift]);


Il terminale è stato poi chiuso e riavviato pochi minuti dopo. Ed ecco un frammento del log:

2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=0, Bars=38233, Time[shift]=2006.10.31 22:51, High[shift]=1.2763, Low[shift]=1.2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=0, Bars=38233, Time[shift]=2006.10.31 22:51, High[shift]=1.2763, Low[shift]=1.2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=0, Bars=38233, Time[shift]=2006.10.31 22:51, High[shift]=1.2763, Low[shift]=1,2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=1, Bars=38233, Time[shift]=2006.10.31 22:50, High[shift]=1,2763, Low[shift]=1,2762 2006.10.3131 23:58:26 CZZ2 EURUSD,M1: shift=2, Bars=38233, Time[shift]=2006.10.31 22:49, High[shift]=1.2763, Low[shift]=1.2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=3, Bars=38233, Time[shift]=2006.10.31 22:47, High[shift]=1.2763, Low[shift]=1.2762 2006.10.31 23:58:26 CZZ2 EURUSD,M1: shift=4, Bars=38233, Time[shift]=2006.10.31 22:45, High[shift]=1.2763, Low[shift]=1.2762 2006.10.31 23:58:25 CZZ2 EURUSD,M1: shift=0, Bars=38230, Time[shift]=2006.10.31 22:51, High[shift]=1.2763, Low[shift]=1.2763 2006.10.31 23:58:25 CZZ2 EURUSD,M1: shift=1, Bars=38230, Time[shift]=2006.10.31 22:45, High[shift]=1.2762, Low[shift]=1.2762 2006.10.31 23:58:23 CZZ2 EURUSD,M1: shift=0, Bars=38229, Time[shift]=2006.10.31 22:45, High[shift]=1.2762, Low[shift]=1.2762 2006.10.31 23:58:22 CZZ2 EURUSD,M1: shift=0, Bars=38229, Time[shift]=2006.10.31 22:45, High[shift]=1.2762, Low[shift]=1.2762


Potete vedere che alle 23:58:23 la storia non era ancora stata pompata, e alle 23:58:25 l'ultimo 1 bar era stato pompato. E solo nel 2006.10.31 23:58:26 tutte le barre intermedie erano pompate.
Domanda agli sviluppatori: è questa la normale sequenza di paginazione? E se è così, che senso ha? Chiaramente, è auspicabile avere il valore del prezzo corrente in anticipo. Ma l'esistenza programmata di un buco nella storia per qualche tempo significa essenzialmente un fallimento garantito degli indicatori per questo tempo. Non è più sicuro per l'utente rimandare il calcolo degli indicatori fino a quando la storia è completamente scambiata? O almeno reinizializzarli dopo lo scambio completo?

 
La cosa del "reinizializzare" è stato un errore, sarebbe essenzialmente un pioniere :)
 
Ho familiarità con questo tipo di impaginazione della storia. Ho fatto un controllo delle prime cinque rotture a zigzag E un ricalcolo dell'indicatore ZUP.