O que as funções mais baixas e mais altas retornam - página 5

 
Candid Estou bem agora.
Klot, opção interessante.

Se suas variantes em ziguezague mostram resultados interessantes, posso aplicá-las em meu desenvolvimento?

É claro que você pode, estou acompanhando o desenvolvimento com interesse e gosto muito de seu trabalho.
 
Obrigado.
 
2 nen:
Mais sobre as "opções". Agora uma das condições para comutação extrema: a corrente baixa é maior que a corrente baixa por mais do que os pontos de ExtDeviação (semelhante para alta). O código permite implementar outras opções com bastante facilidade, se necessário.
Bem, seguindo o klot, gostaria de acrescentar que meu interesse atual no ziguezague é causado unicamente por meu interesse em seu projeto.
 
Corrigi novamente o código fonte - ontem descobri que a primeira regra de barra significativa às vezes não é respeitada em minutos. Para verificar, eu só tinha uma hora e meia de tempo online, mas parece que era uma questão de comparar o dobro com zero.
 
Outro bug: os extremos só podem ser trocados no final de um bar, caso contrário há uma diferença entre o tempo real e a história. Não é difícil de consertar. Eu ainda não corrigi o código fonte no ramo - deixe a nova versão rodar em minutos.
 
Candidato, fez uma versão 45 do indicador ZUP: http://onix-trade.net/forum/index.php?s=&showtopic=118&view=findpost&p=117997
Incluído seu ziguezague como ziguezague externo. Assim que uma versão de trabalho estável aparecer, eu a mudarei.
 
Até agora não vejo nenhum problema, aqui está a versão corrigida do código:
//+------------------------------------------------------------------+
//|                                                      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 respeito das peculiaridades dos diferentes ziguezagues. A principal característica deste ziguezague é que tudo é feito em uma única passagem, a revisitação dos dados históricos é feita somente quando um extremo é fixado, e somente para dados após esse extremo. Ou seja, deve ser bastante rápido. As particularidades do desenho dependerão, naturalmente, dos critérios de fixação extrema, mas várias opções podem ser facilmente implementadas aqui. Por exemplo, já fiz a troca de variantes por porcentagem de um movimento anterior, por partida de Alto do mínimo (respectivamente Baixo do máximo) e ligando a troca para o tamanho médio da barra.

 
Aqui está outro problema com o indicador: encontrei uma dobra em meu ziguezague (cursor cruzado na figura). O tempo da dobra corresponde a quando o terminal foi desligado, o preço corresponde a quando foi ligado novamente.


Para esclarecer minhas suspeitas, inseri a impressão no código:
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]);


O terminal foi então fechado e reiniciado alguns minutos mais tarde. E aqui está um fragmento do tronco:

2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=0, Bars=38233, Tempo[turno]=2006.10.31 22:51, Alto[turno]=1.2763, Baixo[turno]=1.2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=0, Bars=38233, Tempo[turno]=2006.10,31 22:51, Alta[turno]=1,2763, Baixa[turno]=1,2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=0, Bars=38233, Tempo[turno]=2006.10.31 22:51, Alta[turno]=1.2763, Baixo[turno]=1,2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=1, Bars=38233, Tempo[turno]=2006.10.31 22:50, Alto[turno]=1,2763, Baixo[turno]=1,2762 2006.10.3131 23:58:26 CZZ2 EURUSD,M1: turno=2, Bars=38233, Tempo[turno]=2006.10.31 22:49, Alto[turno]=1.2763, Baixo[turno]=1.2763 2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=3, Bars=38233, Tempo[turno]=2006.10,31 22:47, Alta[turno]=1,2763, Baixa[turno]=1,2762 2006.10.31 23:58:26 CZZ2 EURUSD,M1: turno=4, Barras=38233, Tempo[turno]=2006.10.31 22:45, Alta[turno]=1.2763, Baixo[turno]=1,2762 2006.10.31 23:58:25 CZZ2 EURUSD,M1: turno=0, Bars=38230, Tempo[turno]=2006.10.31 22:51, Alto[turno]=1,2763, Baixo[turno]=1,2763 2006.10.31 23:58:25 CZZ2 EURUSD,M1: turno=1, Bars=38230, Tempo[turno]=2006.10.31 22:45, Alto[turno]=1.2762, Baixo[turno]=1.2762 2006.10.31 23:58:23 CZZ2 EURUSD,M1: turno=0, Bars=38229, Tempo[turno]=2006.10,31 22:45, Alta[turno]=1,2762, Baixa[turno]=1,2762 2006.10.31 23:58:22 CZZ2 EURUSD,M1: turno=0, Bars=38229, Tempo[turno]=2006.10.31 22:45, Alta[turno]=1,2762, Baixa[turno]=1,2762


Você pode ver que às 23:58:23 a história ainda não estava bombeada, e às 23:58:25 a última 1 barra estava bombeada. E somente em 2006.10.31 23:58:26 todas as barras intermediárias foram bombeadas.
Pergunta para os desenvolvedores: esta é a seqüência normal de paginação? E se sim, qual é o objetivo disso? Claramente, é desejável ter o valor do preço atual mais cedo. Mas a existência planejada de um buraco na história por algum tempo significa essencialmente uma falha garantida de indicadores para este tempo. Não é mais seguro para o usuário adiar o cálculo dos indicadores até que o histórico seja completamente trocado? Ou pelo menos reinicializá-los após a troca completa?

 
A "reinicialização" foi um erro, seria essencialmente um desbravador de pistas :)
 
Estou familiarizado com este tipo de paginação da história. Fiz uma verificação das cinco primeiras quebras em ziguezague E um recálculo do indicador ZUP.