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

 
Candidato, vou tentar descrever a instabilidade da operação .

Uma opção. Existem outros.
Temos o primeiro raio. Por simplicidade - vindo da barra zero. A barra zero tem um máximo e um mínimo. O preço se move dentro da barra sem alterar seus extremos. Como os extremos não estão mudando, o primeiro raio deve ficar parado e não se mover. Mas não. Os primeiros palermas dos raios. Muda sua posição. Esta é apenas uma descrição da manifestação externa de instabilidade. Se o algoritmo funcionar de forma estável e os parâmetros de mercado (máximo e mínimo da última barra), dos quais depende a operação em ziguezague, não mudarem, o primeiro raio não deve vacilar. Tenho lutado com este problema por conta própria. Mas as notadas peculiaridades das funções de busca me forçaram a ir ao fórum.
========================
Quando movemos a janela (shift,shift+ExtDepth) enquanto calculamos o indicador, a aparência de um novo extremo pode estar relacionada a um novo preço ou ao antigo extremo ter deixado a janela. - Seria melhor especificá-lo explicitamente. Para deixar isso claro. Na descrição do idioma. De modo a não explorar as possibilidades ocultas da língua.

Para este fim, a linha if(highpos!=shift) val=0,0; . Como isto é feito no código padrão, eu não entendo. A julgar pelo fato de que os extremas pendurados desaparecem na minha variante, ou não é feito corretamente ou não é feito de todo. - Minha solução para esta questão é diferente: se (Alto[shift]=val) ZigZagBuffer[shift]=val; e se (Baixo[shift]=val) ZigZagBuffer[shift]=val;
Mas no sentido é a mesma coisa. Mas isso não resolve todos os problemas. É a maneira como combatemos a conseqüência e não a causa. Tentou combater a conseqüência da mesma forma. Mas, no primeiro raio, não funciona. O problema é que o algoritmo de ziguezague, digamos assim, não disseca. Deixe-me explicar isto. O cálculo é realizado ao longo de toda a história. E se corrigirmos alguma parte dela, o processamento permanece incompleto perto da barra zero, por assim dizer. Não consigo encontrar as palavras certas. Portanto, esta incompletude próxima à barra zero traz à tona o problema de identificar corretamente os extremos.

Tentei ajustar os parâmetros da janela (shift,shift+ExtDepth) não há muito tempo. Eu também estava experimentando a janela no outro dia. Mas até agora sem resultado.
 
A questão é que o algoritmo zig-zag, digamos assim, não disseca. Deixe-me explicar isto. O cálculo é realizado ao longo de toda a história. E se corrigirmos alguma parte dela, o processamento ainda permanece incompleto perto da barra zero, por assim dizer. Não consigo encontrar as palavras certas. Portanto, esta incompletude próxima à barra zero traz à tona o problema de identificar corretamente os extremos. <br/ translate="no">.


Este problema é conhecido e é corrigido teoricamente (tenho o algoritmo na minha cabeça há muito tempo). De qualquer forma, se nenhuma outra solução aparecer, eu otimizarei o algoritmo Zigzag. É feito da seguinte forma:
1) a primeira execução é feita ao longo de toda a história como no algoritmo atual
2) em cada tick a partir da barra zero no fundo da história, dois extremos do Ziguezague são procurados, o último extremo é morto à força.
3) do último (agora o último) segue novamente o procedimento padrão de cálculo Zigzag.
4) se a extremidade atual (a cauda do ZigZag) pode teoricamente ser um extremo (temos o mais alto do último Baixo ou vice-versa), ele também se torna um extremo.
5) com um novo tique de novo a partir do ponto 2)
 
nen:
Mas isso não aconteceu. Os primeiros torcedores de feixe. Ela muda sua posição.

Eu ainda não vi isto. Deixa uma extremidade da viga fixa? E qual deles. Se estiver na barra de zero, talvez se deva olhar mais de perto as condições em que as variáveis do tipo duplo são comparadas?

Quando movemos a janela enquanto calculamos o indicador (shift,shift+ExtDepth), a aparência de um novo extremo pode estar relacionada tanto ao novo preço quanto ao antigo extremo que deixou a janela. - Seria melhor especificá-lo explicitamente. Para deixar isso claro. Na descrição do idioma.

Isto me parece mais uma referência ao algoritmo do que à linguagem. Portanto, um lembrete de que as funções que estamos discutindo estão na verdade procurando o valor máximo (mínimo) do preço no intervalo, ao invés do extremo, seria apropriado em um livro ou em alguns comentários.
Para fazer isso na minha inserção a linha if(highpos!=shift) val=0,0; . Como isto é feito no código padrão, eu não entendo. A julgar pelo fato de que os extremas pendurados desaparecem na minha variante, ou não é feito corretamente ou não é feito de todo. - Minha solução para esta questão é diferente: se (Alto[shift]=val) ZigZagBuffer[shift]=val; e se (Baixo[shift]=val) ZigZagBuffer[shift]=val;
Eu gosto mais da minha versão :). Funciona com números inteiros. Em tal comparação de duplas (como Low[shift]==val) podem aparecer apenas batidas.
 
Rosh, eu tenho a mesma opção. Na minha cabeça. Há alguns pontos vagos que me impedem de percebê-lo. Vamos colocar as coisas desta maneira. O ponto 4) está um pouco fora do algoritmo. Já é outro algoritmo. E quando a seção processada no item 4) estiver disponível para o histórico, seu processamento com o algoritmo a partir do item 1) pode levar ao desenho de outros extremos. Ou seja, o tempo real e a história serão diferentes. Isto, em minha opinião, não é aceitável.
 
Rosh Eu tenho a mesma opção. Na minha cabeça. Há alguns pontos vagos que me impedem de percebê-lo. Vamos colocar as coisas desta maneira. O ponto 4) está um pouco fora do algoritmo. Este é um algoritmo diferente. E quando a seção processada no item 4) estiver disponível para o histórico, seu processamento com o algoritmo a partir do item 1) pode levar ao desenho de outros extremos. Ou seja, o tempo real e a história serão diferentes. Isto, em minha opinião, não é aceitável.


ponto 4) no próximo tick é processado com um arquivo até o ponto 2)
 
Дело в том, что алгоритм зигзага, скажем так, не расчленяется. Поясню это. Просчет проводится по всей истории. И если мы в какой-то части исправим ошибки, то в районе нулевого бара процесс обработки остается, скажем так, незавершенным. Затрудняюсь подобрать правильные слова. Так вот эта незавершенность в районе нулевого бара и вытаскивает на свет проблему правильного поиска экстремумов.


Este problema é conhecido e teoricamente corrigido (há muito tempo existe um algoritmo em mente).
Existe uma descrição verbal do que o ziguezague deve fazer? Algo como uma especificação técnica.
 
Eu ainda não vi isto. Deixa uma extremidade da viga presa? E qual deles. Se estiver em barra zero, então talvez se deva olhar mais de perto as condições em que as variáveis de tipo duplo são comparadas?
A questão é que estou testando o indicador que utiliza o ziguezague em condições muito rigorosas. Em minutos e com parâmetros 2-1-1. Qual é o propósito de tais testes? Este tipo de teste revela todas as falhas ocultas muito rapidamente. Além disso, há um desejo de que o indicador funcione em todos os prazos, sem exceção. O mercado é uma coisa fractal. Há muitas pessoas que negociam em minutos. Por que devemos privá-los da oportunidade de trabalhar com a ferramenta familiar em pequenos períodos de tempo?

Eu gosto mais da minha versão). Funciona com números inteiros. Ao realizar tal comparação de duplas (do tipo Low[shift]==val) pode causar batimentos.
Até agora, não encontrei nenhuma dificuldade em trabalhar com o dobro. Estes números são armazenados na memória inalterados. Mas minha comparação toma valores de uma única célula de memória. Se haverá um problema neste lugar, é uma questão de hardware (isto é, computador). Algo tem que ser feito com o hardware.

Parece-me que isto não se refere à linguagem, mas ao algoritmo. Assim, um lembrete de que as funções que estamos discutindo estão na verdade procurando o valor máximo (mínimo) do preço no intervalo, ao invés de um extremo, seria apropriado para um livro ou alguns comentários.

Eu acabei de chamá-lo de extremo. Na verdade, é o máximo e o mínimo do intervalo escolhido. É uma pronúncia longa. Mas o significado é o mesmo.
 
Existe uma descrição verbal do que o ziguezague deve fazer? Algo como um termo de referência?
Durante muito tempo, houve no CodeBase.mql4.com. Mas essa descrição é muito difícil de entender. E contraditórias. Durante o verão, acho que Slava afinou o código do ziguezague. Apenas parte da descrição anterior foi deixada no site depois disso.
 
nen:
Trabalhar com o dobro não causou nenhuma dificuldade até agora. Estes números são armazenados na memória inalterados. E minha comparação toma valores de um único local de memória. Se ocorre um problema aqui, é uma questão de hardware - o computador. Algo tem que ser feito com o hardware.
Bem, eu sou guiado pelo código no ramo. E calcula sempre a val. É mais seguro não usar === quando se compara o dou
 
Bem, eu estou baseado no código do ramo. E calcula sempre a val. Isso mesmo, é verdade. É encontrado o número de uma célula. A partir desta célula (série temporal), é tomado o valor da barra máxima ou mínima. Considera-se que o máximo foi encontrado nesta barra. Este valor é então colocado no buffer indicador com o número encontrado. O máximo do indicador deve corresponder ao máximo na barra. Em meu código, o máximo também é tirado da matriz (série de tempos) com o mesmo número encontrado e comparado com o valor de val. É verificado para ver se estamos fazendo a coisa certa: colocamos no buffer com este número o valor de val. Também deve ser igual ao máximo da barra. A comparação de números tirados do mesmo lugar é bastante correta.