Il mio approccio. Il nucleo è il motore. - pagina 126

Nuovo commento
 
Nikolai Semko:
Se è MT4, allora sì.
MT5, come ho capito, supporta pienamente il multi-core e il multi-threading, a differenza di MT4.

Sembra che per togliere il carico si debba usare OpenCL. Ma MT4 non ce l'ha. O si può semplicemente sopportare.

Un'altra variante è quella di permettere all'utente di regolare la velocità di ridisegno dell'animazione. In questo caso, sarà in grado di ridurre il carico sul processore quando è necessario e di aumentarlo di nuovo se vuole.

 
Реter Konow:

Sembra che tu abbia bisogno di usare OpenCL per togliere il carico. Ma MT4 non ce l'ha. O semplicemente sopportarlo.

Un'altra opzione è quella di permettere all'utente di regolare la velocità di ridisegno dell'animazione. In questo caso, sarà in grado di ridurre il carico sul processore quando necessario, e di aumentarlo di nuovo se vuole.

Sono già passato a MT5.
È interessante testare il lavoro di due EAs in MT5 che sono installati su finestre diverse ma lavorano con risorse di una sola finestra. Dopo tutto, ogni EA ha il proprio thread e, come sapete, non potete mettere più di un EA in una finestra.
 
Nikolai Semko:
È interessante testare in MT5 il lavoro di due EAs che sono installati su finestre diverse ma lavorano con le risorse di una sola finestra. Perché ogni EA ha il proprio thread e, come sapete, non potete mettere più di un Expert Advisor in una finestra.

In MT4, ogni EA ha anche un proprio thread. Se non mi sbaglio...

Il filo è diverso, ma il processore è lo stesso per tutti...

Penso che questa sia la ragione per creare un grafico.

 

C'è un'altra sfumatura.

Se l'animazione è ciclica (come una gif), non è necessario reinizializzare l'array di pixel ogni volta. Potete passare attraverso un ciclo di disegno dell'animazione e memorizzare ogni fotogramma in una risorsa. Poi, basta alternare l'immagine. In parte, ho implementato questo e, grazie a questo, ho ottenuto più velocità di animazione (all'inizio, la velocità di animazione era terribile, perché ogni volta ridisegnavo l'immagine originale, e poi ci disegnavo sopra una nuova immagine).

 
Реter Konow:

In MT4, ogni EA ha anche un proprio thread. Se non mi sbaglio...

Il filo è diverso, ma il processore è lo stesso per tutti...

Penso che sia per questo che hanno creato una mappa grafica.

Solo per apprezzare la differenza tra MT4 e MT5, eseguite questo codice su entrambe le piattaforme (il codice funziona lì e lì) e vedrete che in MT4 gira molto più lentamente:

#define protected public
#include <Canvas\Canvas.mqh>
#undef protected
#property script_show_inputs 
input uint N=8; // количество центов гравитации
void OnStart()
  {
   ChartSetInteger(0,CHART_FOREGROUND,true);
   CCanvas C;
   int Width=(ushort)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);                               // get Window width
   int Height=(ushort)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);                             // get Window height 
   if(!C.CreateBitmapLabel(0,0,"CanvasExamlple",0,0,Width,Height,COLOR_FORMAT_XRGB_NOALPHA)) // create canvas with the size of the current window
      Print("Error creating canvas: ",GetLastError());
   uint i=0,j=100000;
   int size=Width*Height;
   uchar h[25600];
   ArrayInitialize(h,0);
   uint w;
   for(w=0;w<25600;w++) h[w]=uchar(128+128*sin(double(w)/256)); //create an array to speed up the work
   double SQRT[];
   uint ss=Width*Width+Height*Height;
   Print(ss);
   ArrayResize(SQRT,ss);
   for(w=0;w<ss;w++) SQRT[(int)w]=sqrt(w); //create an array to speed up the work 
   int k[]; ArrayResize(k,N*2);
   for(w=0;w<N*2;w++) k[w]=20+rand()%200;
   double XP[],YP[],D[],D1[];
   ArrayResize(XP,N);
   ArrayResize(YP,N);
   ArrayResize(D,N);
   ArrayInitialize(XP,0);
   ArrayInitialize(YP,0);
   ulong t=0,sum=0, f=0;
   C.FontSet("Verdana",50,FW_MEDIUM);
   while(!IsStopped())
     {
      int pos=int(i%size);
      if(pos==0)
        {
         //Sleep(20); //For those who have a too powerful computer.
         if (i>0) {t=GetMicrosecondCount()-t; sum+=t; f++; 
         C.TextOut(Width/2,Height/2,"Время формирования кадра = "+IntegerToString(sum/f)+" мкс",clrBlueViolet,TA_CENTER|TA_VCENTER);}
         C.Update();
         t=GetMicrosecondCount();
         for(w=0;w<N;w++)
           {
            XP[w]= Width/2-(sin((double)j/k[2*w])*(double)Width/2);
            YP[w]= Height/2-(cos((double)j/k[2*w+1])*(double)Height/2);
           }
         j++;
        }
      int X=pos%Width;
      int Y=int(pos/Width);
      
     // for(int w=0;w<N;w++) D1[w]=SQRT[int((XP[w]-X)*(XP[w]-X)+(YP[w]-Y)*(YP[w]-Y))];
      for(w=0;w<N;w++) D[w]=    sqrt((XP[w]-X)*(XP[w]-X)+(YP[w]-Y)*(YP[w]-Y));
      double S1=0,S2;
      for(w=0;w<N/2;w++) S1+=D[w];
      S2=S1;
      for(w=N/2;w<N;w++) S2+=D[w];
      double d=S1/S2;
      
      //double d= (D[0]+D[1]+D[2]+D[3])/(D[0]+D[1]+D[2]+D[3]+D[4]+D[5]+D[6]+D[7]);
       //d= (D[0]+D[1])/(D[0]+D[1]+D[2]+D[3]);
      C.m_pixels[pos]=XRGB(h[int(d*11520)],h[int(d*17920)],h[int(d*6400)]);// works a little faster, but requires transferring the array m_pixels from protected to public in Canvas.mqh
      //C.PixelSet(X,Y,XRGB(h[int(d*11520)],h[int(d*17920)],h[int(d*6400)]));
      i++;
     }
   C.Destroy();
  }
//+------------------------------------------------------------------+
 
Nikolai Semko:

Solo per apprezzare la differenza tra MT4 e MT5, eseguite questo codice su entrambe le piattaforme (il codice funziona lì e lì) e vedrete che è un ordine di grandezza più lento in MT4:

Sì, mettilo lì e lì. La differenza è circa un fattore 10. Esattamente perché in MT5 gli array sono inizializzati 10 volte o più velocemente. Ho controllato.

Tuttavia, anche su MT4 tutto dovrebbe essere molto più veloce. Dopo tutto, stai solo ridisegnando l'immagine. È diverso se lo stai elaborando ripetutamente in un array.

Non so perché sia così lento su MT4.

 

Tuttavia, forse il punto è che state reinizializzando OGNI pixel nell'intero spazio kanvas della dimensione del grafico.

Nella mia animazione, solo le singole aree sono disegnate, e la parte principale dell'immagine è presa interamente dalla risorsa. Non hai la parte principale, e l'immagine è creata interamente. Pertanto, rallenta.

È la dimensione del disegno.

 
Реter Konow:

Tuttavia, forse è perché stai reinizializzando OGNI pixel in tutto lo spazio della tela della dimensione del grafico.

Nella mia animazione, solo le singole aree sono disegnate, e la parte principale dell'immagine è presa interamente dalla risorsa. Non hai la parte principale, e l'immagine è creata interamente. Pertanto, rallenta.

È la dimensione del disegno.

Che differenza. Questo è un esempio volutamente estremo che dimostra chiaramente i vantaggi di mt5 in termini di velocità di kanvas. E questo numero è archiviato nel suo cervello. Questo è il motivo per cui dico da molto tempo - vai a MQL5.
Il fatto rimane. L'inquadratura delle immagini su mt5 è 10 volte più veloce che su mt4. E questo è un argomento molto convincente.
 
Nikolai Semko:
Che differenza. Questo è un esempio volutamente estremo che dimostra chiaramente i vantaggi di mt5 nella velocità dei kanvas. E questo numero è archiviato nel suo cervello. Questo è il motivo per cui dico da molto tempo - vai a MQL5.
Il fatto rimane. L'imaging su MT5 è 10 volte più veloce che su MT4. E questo è un argomento molto valido.

I lati negativi di MT4, sono ciò che è necessario nello sviluppo. Non devi scappare da loro. Ti costringono a pensare e a migliorare le tue soluzioni.

Su MT5, non devi nemmeno sforzarti molto. Tutto funziona abbastanza velocemente così com'è. Pertanto, la migrazione a MT5 è prevista per la fase finale.

 
Реter Konow:

Infine, la tabella dinamica è fatta. Devo dire che non è stato facile. Si scopre che ci sono molte sfumature.

Inoltre, questa tabella è "condizionatamente" dinamica. Cioè, il numero massimo di righe è predeterminato. Non era ancora possibile rendere "assolutamente" dinamico.

Questa tabella ha 20 possibili righe. Quindi, può visualizzare 20 posizioni aperte. Potremmo farne di più, ma per ora è solo una dimostrazione.

Clicca per vedere.

Ecco i file di connessione (messi nell'inclusione), il motore (nella cartella indicators), e il test.EA (nella cartella experts):

Peter, mi dispiace ma il tuo lavoro non è accettato in quanto quello che hai inviato è un raro lavoro di hacking. Mi dispiace ma sembra che io sia l'unico che ha eseguito quello che hai inviato e oltre a me nessuno lo esaminerà.

Quindi, nell'ordine, l'incarico era il seguente:

Forum sul trading, sistemi di trading automatico e test di strategie di trading

Il mio approccio. Nucleo - Motore.

Vasiliy Sokolov, 2018.12.26 13:29

Peter, ecco il compito. Creare un pannello che mostri le attuali aperture degli ordini in MT4. Non c'è bisogno di fare una copia completa del pannello di sistema, visualizzare la tabella più semplice con le proprietà di base degli ordini aperti: prezzo di apertura, direzione, profitto. Il resto dipende da voi. La cosa principale è che quando un ordine viene chiuso, anche la sua indicazione nella tua tabella scompare. E viceversa, apparirebbe in questa tabella quando viene aperto un nuovo ordine.

Quello che vedo invece:

In primo luogo, le compravendite possono essere aperte solo nel tuo pannello cliccando il pulsante di acquisto/vendita. Se una posizione viene aperta attraverso la finestra standard, il trade non appare.

In secondo luogo, alcuni ordini vengono visualizzati con valori vuoti. Sono presenti nella tabella, ma le righe sono vuote.

In terzo luogo, (questo è davvero inquietante), se chiudiamo un ordine attraverso il dialogo standard, non scompare nella tabella. Ma la cosa più triste è che quando si ricarica il pannello, gli ordini chiusi sono di nuovo visualizzati come presumibilmente aperti! Che cos'è questo? Perché stai memorizzando informazioni irrilevanti da qualche parte e poi cerchi di caricarle?

In quarto luogo, cosa diavolo sono 20 ordini? Non ho una parola su questa restrizione nel mio incarico! È stato fatto apposta, per testare il vostro motore a lavorare con un ambiente dinamico e precedentemente sconosciuto. Il lavoro non è stato scelto a caso, avete cambiato i miei requisiti, in modo da nascondere tutti gli "spigoli vivi" del vostro motore. Ma il compito è stato dato per mostrare questi angoli.

Quinto, non è necessario farlo se si imposta uno stop loss o un take profit. Lascia questi campi vuoti.

E sì, anche il pulsante per chiudere la posizione (croce) nel tuo pannello non funziona.

In breve, Peter. Mi dispiace, ma quello che mi hai mandato è un lavoro di merda. Per favore correggetelo come da specifiche.

Chiarirò il compito ancora una volta, così non ci saranno domande:

  1. La tabella è dinamica e mostra gli stessi ordini della scheda Commercio. Se non ci sono ordini nella scheda, la tua tabella non li mostra nemmeno.
  2. Il numero degli ordini visualizzati nella vostra tabella dovrebbe essere qualsiasi cosa. Non ci sono limitazioni dall'alto.
  3. L'apertura di un ordine tramite la finestra di dialogo standard dovrebbe far apparire l'ordine nella tua tabella. La chiusura dell'ordine con mezzi standard dovrebbe comportare la scomparsa dell'ordine nella tua tabella.
  4. Uno stato non coerente non è accettabile! Se la vostra tabella mostra una cosa, ma la scheda Commercio ne mostra un'altra, questo è un errore.

Finora, un grasso no-go. Aspettando i vostri perfezionamenti. E niente rendering 3D fino a quando non l'avrete capito!
1...119120121122123124125126127128129130131132133...184
Nuovo commento
Motivazione: