Características úteis da KimIV - página 31

Novo comentário
 
ShestkoFF писал (а) >>
Bem, eu não o bloquearia, é claro. Eu teria passado o erro para cima e decidido o que fazer com ele.

Se você bloquear a EA neste ponto, pode haver uma posição em aberto deixada por esta EA, o que seria um desastre.

Agora você respondeu à sua própria pergunta sobre a longa pausa. É feito para esperar que o sinal abra uma posição ou estabeleça uma ordem.

Obrigado, Vasily, mais uma vez por ter me enganado com sucesso. Quase me apressei para consertar os códigos... E obrigado novamente por me trazer de volta ao meu caminho :-)

 
KimIV писал (а) >>

:-) Agora você respondeu sua própria pergunta sobre a longa pausa. É feito a fim de esperar que o sinal abra uma posição ou estabeleça uma ordem.

Obrigado, Vasily, mais uma vez, por me teres conseguido desencaminhar. Quase me apressei para consertar os códigos... E obrigado novamente por me trazer de volta ao meu caminho :-)

Para ser honesto, eu não entendo a lógica.
Por exemplo, fizemos um pedido de lote 0,000001. O servidor, é claro, nos esbofeteia por isso.
Em vez de mudar o lote (fora da função), fazemos uma pausa.
Como resultado desta interrupção, podemos perder o sinal para estabelecer uma ordem, mas devemos mudar o lote ao invés de esperar.
É por isso que eu não concordo com a pausa. Devemos simplesmente deixar esta função e passar o código de erro para cima e manuseá-lo lá.
Se seguirmos meu caminho, talvez não percamos um comércio lucrativo! E podemos até ter uma perda :)

PS: Eu o desviarei do caminho inverídico :)

 
Pensei que a função de cálculo de lote deveria ser chamada imediatamente (em vez de ir para o topo), indo para o topo somente após o excesso de erros no contador
 
Prival писал (а) >>
e eu pensei, você precisa chamar a função de cálculo de lote de uma vez (e não ir para o topo), indo para o topo somente após o transbordamento do contador de erros

Sim, claro que você precisa chamar esta função imediatamente, mas se ocorrer um erro!!!
Sair para o topo chamo uma situação em que você tem que sair da função SetOrder.
Vejo-o aproximadamente da seguinte forma


int ticket = SetOrder(.....);

se (bilhete > 0) {

// tudo ok

{} else {

// erro lógico correto

}


int SetOrder(....) // devolve ou um bilhete ou um número de erro apenas com um sinal negativo.
{

int ticket = OrderSend(....)

se (bilhete < 0) {

// corrigir erros de ordem definidos

}

}


Portanto, acho que precisamos distinguir entre erros lógicos e erros de configuração de ordem. Espero dar hoje um exemplo de uma implementação.
 
ShestkoFF писал (а) >>
Para ser honesto, eu não entendo a lógica.

Eu construí a função de cálculo do tamanho do lote de tal forma que ele dará um lote incorreto (zero) somente se não houver dinheiro suficiente. Em outros casos, o lote é normalizado e é conduzido dentro dos limites entre os tamanhos mínimo e máximo. Se não houver dinheiro suficiente, temos que esperar que alguma posição feche.

ShestkoFF escreveu (a) >>
Se você encomendou o lote 0,000001. Nosso servidor certamente nos deu uma bofetada no pulso.

Por que fizemos isso? Por que passamos deliberadamente o tamanho errado do lote? Como podemos justificar este comportamento?

ShestkoFF escreveu(a) >>.

Devemos simplesmente deixar esta função e passar o código de erro para cima e manuseá-lo lá.

O que isso nos trará? Será que teremos um lote de tamanho diferente? Por que não conseguimos logo o tamanho de lote certo? Dê razões. Vamos analisar...
 

Eu só acho que sua função é uma função de biblioteca, ou seja, universal, e portanto você deve dividir todos os erros em 2 categorias:

  • erros que devem ser processados dentro da função SetOrder (erros de conexão, solicitações...)
  • Erros que devem ser processados fora da função SetOrder (tamanho de lote errado, paradas erradas...)

Функцию расчёта размера лота я строю таким образом, что неверный лот (ноль) она выдаст только в случае не хватки денег. В остальных случаях лот нормализуется и загоняется в рамки между минимальным и максимальным размерами. Если денег не хватает, то надо ждать, когда закроется какая-нибудь позиция.

Esta é a lógica de seus especialistas, outras pessoas podem ter uma lógica diferente. É por isso que eu colocaria o erro com os lotes errados no
externo.

bloco de verificação de erros.

Essa é a minha visão deste caso :) Como escrevi acima, espero dar hoje um exemplo de implementação.

 

Minha versão da moda:



int ModeInt(int array[])
{
   int size = ArraySize(array);
   
   if (size == 0) 
   {
      Print("Invalid parameter in function ModeInt(int array[]). It should be at least one element.");
      return(0);
   }
   
   int buffer[];
   ArrayCopy(buffer, array); 
   ArraySort(buffer);
   
   int max = 0;
   int maxValue = 0;
   
   int startIndex = 0;
   int startValue = buffer[0];
   
   for (int i = 1; i < size; i++)
   {
      if (buffer[i] > startValue)
      {
         if (max < i - startIndex)
         {
            max = i - startIndex;
            maxValue = buffer[startIndex];
         }
         
         startIndex = i;
         startValue = buffer[i];
      }
   }
   
   if (max < size - startIndex)
   {
      max = size - startIndex;
      maxValue = buffer[startIndex];
   }
   
   return (maxValue);
}
 
double ModeDouble(double array[], double interval)
{
   int size = ArraySize(array);
   
   if (size == 0) 
   {
      Print("Invalid first parameter in function ModeDouble(double array[], double interval). It should be at least one element.");
      return(0);
   }
   
   if (interval <= 0) 
   {
      Print("Invalid second parameter in function ModeDouble(double array[], double interval). It should be > 0 .");
      return(0);
   }
   
   double buffer[];
   ArrayCopy(buffer, array); 
   ArraySort(buffer);
   
   int max = 0;
   double maxValue = 0;
   
   int startIndex = 0;
   double startValue = buffer[0];
   
   double sum = startValue;
   
   for (int i = 1; i < size; i++)
   {
      if (buffer[i] >= startValue + interval)
      {
         if (max < i - startIndex)
         {
            max = i - startIndex;
            maxValue = (sum)/max;
         }
         
         startIndex = i;
         startValue = buffer[i];
         sum = 0;
      }
      sum += buffer[i];
   }
   
   if (max < size - startIndex)
   {
      max = size - startIndex;
      maxValue = (sum)/max;
   }
 
   return (maxValue);
}
 
TheXpert писал (а) >>

Minha versão do mod:


Caro TheXpert, seu código parece muito compacto. O que, é claro, é uma vantagem gorda! >> Obrigado.

 
Como prometido, estou postando minha versão da função.
Em anexo, encontra-se um consultor especializado que utiliza a função. Eu usei o AI Expert Advisor como base.
Eu não tive tempo de verificar a função no tempo. Em outras palavras, acredito que o sinal deve ser verificado novamente após 8 minutos.
Acrescentou a geração de erros do servidor comercial que permitirá examinar a operação da função em detalhes e detectar erros.
int errTest[] = {0, 128, 0, 142, 0, 143, 0, 4, 132};
errTest - seqüência de erros gerados, nenhum erro 0. Esta é uma seqüência aleatória e não há nenhum senão para ser encontrado nela.


Estou esperando algumas críticas :)

Arquivos anexados:
setordertest.mq4  32 kb
 
ShestkoFF писал (а) >>
Como prometido, estou postando minha versão da função.
O arquivo anexo contém a EA onde esta função é utilizada. Eu usei o AI Expert Advisor como base.
Eu não tive tempo suficiente para verificar como a função funciona por tempo. Isto é, acredito que o sinal deve ser verificado novamente depois de 8 minutos passados.
Acrescentou a geração de erros do servidor comercial que permitirá estudar minuciosamente a operação da função e detectar erros.
errTest - seqüência de erros gerados, nenhum erro 0. Esta é uma seqüência aleatória e não há nenhum senão para ser encontrado nela.


Estou esperando por críticas :)

Não quero saber da função, posso dizer uma coisa :), não vou ser original e dizer como sempre :) -- muito sobrecarregado.

Como resultado, o Expert Advisor se tornou um código limpo e claro de 32KB onde não tenho vontade de brincar.


Há perguntas sobre o código.

1. Se você desativar o Expert Advisor, ele não voltará a funcionar até que seja reiniciado. Por que não fazê-lo esperar por um período de tempo relativamente longo?

2. Rede neural -- antes de tudo, ela nunca emite o sinal de um flat. Em segundo lugar, como você pode esperar que ele otimize algo, se não tem limite? Ao faltar um limite, você mata 80% de sua eficiência já baixa (linear, no entanto).



SZZH: Sem ofensa, eu sou um crítico neste tópico :) .

1...242526272829303132333435363738...128
Novo comentário
Razão: