Tiki in tempo reale - pagina 20

Nuovo commento
 
Roman:

Hai fatto un casino di tutto.

Come ho scritto prima, trade e level2 sono sottoscrizioni di dati diverse, quindi sono gestori di eventi diversi.
Ecco perché i trade devono essere chiamati da OnTick, e le bande di volume da OnBook.
Stai cercando di chiamare gli scambi da eventi OnBook e le bande da OnTick. Il tutto pensando che OnBook sarà più veloce per gli scambi.
Non sarà più veloce, penso che sia un'illusione confrontare due gestori di eventi destinati a ciascuno dei diversi thread di dati.
Capisco che questa è tutta sperimentazione, ma senza capire la logica delle prese confonderai all'infinito questi gestori OnTick e OnBook.

Ho già scritto, nel caso non abbiate visto, "per me non c'è alternativa a OnBookEvent()".

E tutti i codici, i risultati, le spiegazioni - per rendere chiaro il perché.

A giudicare dal tuo post - non capisci... :)

Forse stai leggendo il messaggio?

Posso ottenere tutti i dati rapidamente e facilmente tramite OnBookEvent() senza usare OnTick().

ma non posso ottenere tutti i dati con OnTick(). Allora perché dovrei usare OnTick()?

 
prostotrader:

Ho già scritto, nel caso non abbiate visto, "per me non c'è alternativa a OnBookEvent()".

E tutti i codici, i risultati, le spiegazioni - per rendere chiaro il perché.

A giudicare dal tuo post - non ti è chiaro... :)

Forse stai leggendo l 'argomento?

Sì, capisco che nel suo caso non ci sono alternative, e giustamente.
E capisco di cosa stai parlando. Volevo solo sottolineare questo punto, che gli scambi e il Level2 sono flussi di dati diversi.
Dobbiamo ricordarcene, e quelli che non lo sanno dovrebbero saperlo.
Ecco perché se avete bisogno di scambi, dovreste chiamare le funzioni necessarie per questo da OnTick,
Se avete bisogno di bid asc con volume, o profondità di una tazza, allora le funzioni appropriate devono essere chiamate da OnBook.
Non è corretto prendere gli eventi da OnBook e ottenere scambi, e cercare di ottenere volumi o profondità dagli eventi OnTick.
E così capisco che stai solo spiegando agli altri, e sperimentando lungo la strada.

 
Roman:



E così ho capito che stai solo spiegando agli altri, e sperimentando lungo la strada.

Hai capito bene.

Ho appena fatto esperimenti simili 7 anni fa, ho scelto OnbookEvent().

E ora ho deciso di controllare se qualcosa è cambiato... Non è così.

 
prostotrader:

Il fatto è che il mercato dei derivati (FORTS), anche su strumenti "altamente liquidi", è molto debole,

Significa che è possibile acquistare unnumero moltolimitato di contratti al prezzo giusto, quindi non è necessario solo il prezzo,

ma il volume dei contratti a questo prezzo è molto importante.


E SymbolInfo non dà il volume di questo prezzo.

Pertanto, abbiamo bisogno di usareMarketBookGet() che fornisce sia il prezzo che il volume per l'intero libro.

Cosa c'entra con l'argomento? Questo è l'unico motivo per cui sono bloccato. Non ho bisogno di OnBook per ottenere i tick, perché OnTick non è sicuramente più lento.

E perché dire 20 volte a testa l'indispensabilità di OnBook? Qualcuno ne dubita?


prostotrader:

E non sono d'accordo sul fatto che quando OnTck() viene attivato possiamo ottenere i tick dalla storia.

Ricordando l'ultimo tempo di tick, quando OnTck() viene attivato, possiamo ottenere i tick

un nuovo tick è arrivato in tempo reale - OnTck() è attivato, lo leggiamo immediatamente, cioè non è storia.

Qualsiasi zecca che entra nel terminale è già storia.

Ma non stavo parlando di questo, ma di costruire il nastro senza lacune(SymbolInfoTick non aiuta).

 
Aleksey Mavrin:

Ho voluto mettere il codice in prova prima

Ma non posso aprire il conto demo opener per qualcosa. Il tempo è probabilmente scaduto, o ci sono altre complicazioni?

Tiki in tempo reale

prostotrader, 2020.01.31 13:18

Conto : 1007932

Investitore FfiR87ty (password di sola lettura)
 
Andrey Khatimlianskii:

Cosa c'entra questo con l'argomento? Questo è l'unico motivo per cui ci sto entrando, non c'è bisogno di OnBook per ottenere i tick, poiché OnTick non è sicuramente più lento.

E perché dire 20 volte a testa l'indispensabilità di OnBook? C'è qualcuno che ne dubita?

Qualsiasi zecca che entra nel terminale è storia.

Ma non è di questo che stavo parlando, stavo parlando di costruire un nastro senza salti (SymbolInfoTick non aiuta in questo).

Sembra che vi siate fraintesi :)))
Lui ti parla dei migliori semi licitativi con volume, e tu gli parli di scambi e accordi :))
Bene, penso che abbiamo chiarito tutto.

Beh, dipende da come si guarda al prossimo tick - questa è storia.
Se per il server di scambio, allora sì, è storia, per il terminale no.
Perché il terminale per OnTick memorizza gli ultimi 4096 record nella cache, per accedervi a caldo, e poi li scarica nella cronologia sul disco.
Poi si scopre che non è ancora storia )), cioè l'arresto di emergenza non salverà la cache su disco.
E quando il terminale riparte, i dati persi nella cache saranno caricati dal server. Ma questo si applica solo ai dati OnTick.
OnBook probabilmente non caricherà i dati.

 

Pensavo che ci fosse almeno un OnBook per ogni OnTick. ma poi non ho capito questo


 

Mettete questo codice su Opening Demo, per calcolare il ritardo medio e massimo tra OnTick e il prossimo OnBook.

Il codice è a portata di mano, potrebbe essere storto, guarderò i risultati.

//+------------------------------------------------------------------+
//|                                                   TestOnBook.mq5 |
//|                                           Copyright 2019, Allex@ |
//|                                                 alex-all@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019, Allex@"
#property link      "alex-all@mail.ru"
#property version   "1.00"
//---
bool is_book;
enum ENUM_BOOK_OR_TICK
{
        USE_BOOK,       // Use OnBookEvent
        USE_TICK        // Use OnTick
};

input ENUM_BOOK_OR_TICK Mode = USE_BOOK;
input int   SecForPrint =  300;
//---
ulong TimeArrayBook[65536];
ulong TimeArrayTick[65536];
ushort curBook,curTick;
ulong  DelaySum=0,DelayCount=0;
int delay,delayMax=0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   curBook=0;
   curTick=0; 
   ArrayInitialize(TimeArrayBook,INT_MAX);
   ArrayInitialize(TimeArrayTick,INT_MAX);
  if(Mode == USE_BOOK) is_book = MarketBookAdd(Symbol());
  if (EventSetTimer(SecForPrint)) 
  return(INIT_SUCCEEDED);
  else return (INIT_FAILED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(Mode == USE_BOOK)
  {
    if(is_book == true) MarketBookRelease(Symbol());
  }  
}
//+------------------------------------------------------------------+
//| BookEvent function                                               |
//+------------------------------------------------------------------+
void OnBookEvent(const string &symbol)
{ 
  TimeArrayBook[curBook++]=GetMicrosecondCount();
 }
void OnTick()
{
  TimeArrayTick[curTick++]=GetMicrosecondCount();
}
//+------------------------------------------------------------------+
void OnTimer()
  {
   string out=NULL;
   int total=MathMax(curBook,curTick);
   int i=0,k=0;
   while(i<total)
     {
      while(i<total && TimeArrayBook[i]<TimeArrayTick[k] )
        {
          Print("Book ",TimeArrayBook[i++]);
        }    
      if(k<curTick-1)
        {
        if(i<total)
          {
           delay=TimeArrayBook[i]-TimeArrayTick[k];
           if (delay>delayMax) 
            delayMax=delay;
           if (delay>0)
              {
                 DelaySum+=delay;
                 DelayCount++;
              }
          }
         Print("Tick ",TimeArrayTick[k++]);
        }       
        i++;
     }
     if (curTick>0)
     {
     Print("Tick ",TimeArrayTick[curTick-1], " last");
     string out="Count Event Book after Tick "+DelayCount+". Delay Average "+DoubleToString(DelaySum/DelayCount,2)+". Max "+delayMax;
     Print (out);
     Comment(out);
     }
     curBook=0;
     curTick=0;
  }
//---  
 
Andrey Khatimlianskii:

Ogni zecca che entra nel terminale è già una storia.

Ma non è di questo che stavo parlando, stavo parlando di costruire un nastro senza salti (SymbolInfoTick non aiuta in questo).

Ok. Il suo punto sulla storia è abbastanza chiaro.

Ma resto della mia opinione, che il metodo per ottenere le zecche dipenderà da

la loro lettura (dalla storia o in tempo reale).

E non ero in disaccordo con te su SymbolInfoTick e sul nastro senza salti.

 

Questa è l'immagine del giorno. Naturalmente non abbiamo controllato se OnBook corrispondeva a Tick, ma abbiamo semplicemente preso il successivo, sperando che se OnTick era più avanti di OnBook, allora il corrispondente sarebbe stato lo stesso o leggermente più tardi.

Massimo naturalmente senza controlli aggiuntivi è nessun indicatore, o overshoot o davvero OnBook da qualche parte lento.


Ma questo è qualcuno che può spiegare? Perché così tanti OnTick non sono impostati, e non c'è un solo OnBook tra loro?


1...1314151617181920212223242526
Nuovo commento
Motivazione: