FórumSeções

Bibliotecas: OnTickMulti - página 3

Novo comentário
Stanislav Korotky #:

Não há previsão do futuro, pois, se para o momento X houver ticks em vários símbolos, então, junto com o primeiro evento em um dos instrumentos, nos demais símbolos (para os quais os eventos ainda estão na fila) haverá o tick anterior, e não o próximo (como no exemplo, 00:04 veio antes de 00:05, e não depois).

Para a sincronização, é preciso garantí-la algoritmicamente no código; por exemplo, no manipulador OnTick, consultar a hora dos ticks em todos os símbolos envolvidos antes de iniciar uma operação. Mas, em princípio, se a arbitragem for precisamente baseada em ticks (e não em barras ou minutos), é difícil imaginar uma sincronização confiável, pois os ticks em certos símbolos podem realmente ficar ausentes por alguns segundos.

Tudo é relativo: para um instrumento haverá atraso, enquanto para outro haverá avanço.

Lá tudo oscila; no depurador, tudo fica sincronizado, mesmo com o OnTick quase vazio.

É preciso converter as barras em ticks para o teste, a fim de simular corretamente a comissão e o spread.

Isso aqui tive que fazer no OnTick para que os cálculos do testador personalizado coincidissem com o MT

   int size=ArraySize(T);
   if(size==0) return;
   datetime dt1=(datetime)SymbolInfoInteger(name1,SYMBOL_TIME);
   datetime dt2=(datetime)SymbolInfoInteger(name2,SYMBOL_TIME);
   while(sh1<size && T[sh1]<dt1) sh1++;
   while(sh2<size && T[sh2]<dt2) sh2++;
   while(sh1<size && T[sh1]==dt1)
     {if(D1[sh1]>0)  Buy(name1);
      if(D1[sh1]<0) Sell(name1);
      if(D1[sh1]==0) Close(name1);
      sh1++;
     }
   while(sh2<size && T[sh2]==dt2)
     {if(D2[sh2]>0)  Buy(name2,D2[sh2]);
      if(D2[sh2]<0) Sell(name2,fabs(D2[sh2]));
      if(D2[sh2]==0) Close(name2);
      sh2++;
     }
Stanislav Korotky #:

Para sincronizar, é preciso garantir isso algoritmicamente no código; por exemplo, no manipulador OnTick, consultar o tempo dos ticks de todos os símbolos envolvidos antes de iniciar uma operação.

Receio que isso não permita que o OnTick perceba que a sequência de ticks com o tempo atual chegou ao fim. Provavelmente, apenas um OnTimer em milissegundos ajudará.

Rorschach #:

Tudo é relativo: para um instrumento, haverá um atraso; para outro, um avanço.

Existe o tempo atual (do testador) — somente em relação a ele é possível usar a terminologia de “antecipação do futuro”. Se o tempo atual for X e, para dois instrumentos, houver ticks correspondentes aos momentos X-1 e X-2, esses são os últimos ticks atuais conhecidos, e é sobre eles que o algoritmo deve fazer os cálculos. Ora, se no momento X-2 alguém tentasse calcular os ticks para X-1 e X, isso seria uma previsão do futuro. Mas, tecnicamente, o testador não permite que isso seja feito.
fxsaber #:

Receio que isso não permita que o OnTick perceba que a sequência de ticks com a hora atual chegou ao fim. Provavelmente, só um OnTimer em milissegundos resolverá o problema.

Depende de como escrever a condição no if em relação ao tempo — é preciso usar um > estrito, e não >=, e não contabilizar o tick que levou ao acionamento da condição. Com o temporizador, o resultado será semelhante.
Stanislav Korotky #:
Depende de como escrever a condição no if em relação ao tempo — é preciso usar um > estrito, e não >=, e não contabilizar o tick que fez com que a condição fosse acionada.
Não entendi.
Stanislav Korotky #:
Com o cronômetro, vai dar certo da mesma forma.
Lá é mais fácil.
fxsaber #:
Não entendi.

De cabeça, com identificação de tempo com precisão de milissegundos (o mesmo vale para segundos):

// TODO: ArrayResize(lookback, <número de símbolos>)
MqlTick lookback[];

void OnTickMulti(const string &symbol, const uint &index)
{
   static MqlTick t[1];
   static long timeCurrentMsc;
   
   SymbolInfoTick(symbol, t[0]);
   
   if(t[0].time_msc > timeCurrentMsc)
   {
      if(!timeCurrentMsc) // não é bem o início, então este é um novo milissegundo
      {
         // TODO: usar os ticks do lookback[] para análises e negociações
         // eles ainda não incluem o tick atual, pois ele corresponde ao próximo milissegundo
         // ...
      }
      timeCurrentMsc = t[0].time_msc;
   }

   // somente após a análise, atualize o registro com o novo carimbo de data/hora
   lookback[index] = t[0];
}

Mas vou repetir mais uma vez (para o Rorschach) que a sincronização em intervalos tão pequenos é ilusória. Os ticks de algum instrumento podem ficar ausentes por segundos; nesse caso, o preço atual para eles pode, na verdade, ficar “desatualizado”. Se para alguém for importante que todos os preços correspondam à mesma [mili]segundo, então, no trecho apresentado (no bloco de análise comentado), é preciso verificar adicionalmente a igualdade dos tempos dos ticks e só negociar se essa condição for cumprida.

Stanislav Korotky #:

De cabeça, com identificação do tempo com precisão de milissegundos (o mesmo vale para segundos):

Dessa forma, não é possível garantir a atualidade dos ticks de todos os símbolos. Isso só é possível por meio do OnTimer em milissegundos.
fxsaber #:
Dessa forma, não é possível garantir de jeito algum que os ticks de todos os instrumentos estejam atualizados. Isso só é possível por meio do OnTimer em milissegundos.
O que se entende por atualidade (esse método retorna os últimos ticks conhecidos para todos os instrumentos; é possível usar o CopyTicks, se for esse o caso)? E de que maneira o OnTimer proporcionaria um resultado diferente?

Stanislav Korotky #:
Что подразумевается под актуальностью (этот метод отдает последние известные тики по всем инструментам)?

Não haverá mais ticks com a última hora conhecida.

E de que maneira o OnTimer fornecerá um resultado diferente?

O OnTimer em milissegundos garante que todos os ticks tenham ocorrido ANTES desse evento do temporizador. Ou seja, os ticks estão atualizados para todos os símbolos.

12345
Novo comentário