Come vede Metatrader X nel 2030? - pagina 6

Nuovo commento
 
fxsaber:

Scrivere qualsiasi dato nel globale può essere visto negli inludi corrispondenti qui.

OK, non ho visto questa soluzione.

Non è facile da capire, bisogna controllare

 
fxsaber:

Qualsiasi dato scritto nel globale può essere visto negli inludi corrispondenti qui.

Sei consapevole che c'è un enorme mondo di altri dati oltre alle zecche? Volete lo strano - scrivere/leggere i dati di un'istanza di classe.

 
Igor Makanu:

OK, non ho visto questa soluzione.

Non è facile da capire, bisogna controllare.

Sì, scrivere e leggere dati grezzi da e verso la risorsa. Buon esempio, grazie!

Ma che ne dice il mio stimato fxsaber di fare la stessa cosa con le classi? Può anche con definizioni, la gente promette di non impazzire )))

 
Alexey Volchanskiy:

Non è cocaina, oh, nonnine.


No. Futuri di pan di zenzero.

 
Alexey Volchanskiy:

Siete consapevoli che c'è un enorme mondo di altri dati oltre alle zecche?

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

Abbiamo bisogno di variabili terminali globali come le stringhe?

fxsaber, 2017.04.10 18:25

void OnStart()
{
  string Name = "Name";

// Записываем/считываем строки
  _GlobalVariableSet(Name, "Hello World!");
  Print(_GlobalVariableGet<string>(Name));

// Записываем/считываем простые структуры
  MqlTick Tick;
  SymbolInfoTick(_Symbol, Tick);

  _GlobalVariableSet(Name, Tick);
  Print(_GlobalVariableGet<MqlTick>(Name).time);

// Записываем/считываем массивы
  MqlTick Ticks[2];

  Ticks[0] = Tick;
  Ticks[1] = Tick;

  _GlobalVariableSet(Name, Ticks);

  MqlTick NewTicks[];

//  if (_GlobalVariableGet(Name, NewTicks)) // https://www.mql5.com/ru/forum/1111/page1868#comment_4853867
//    Print(NewTicks[1].time);

  _GlobalVariableDel(Name);
}


Voglio lo strano - scrivere/leggere i dati di un'istanza di una classe.

Memorizzo i dati in strutture, proprio come gli sviluppatori. È comodo e logico. Quindi non ho guardato verso le classi in questo numero, anche se non ci sono puntatori alle strutture.

 
fxsaber:


Memorizzo i dati in strutture, come fanno gli sviluppatori. È conveniente e logico. Pertanto, non ho guardato le classi in questa materia, anche se non ho puntatori alle strutture.

Ho costruito lo script per il controllo, ma non so come leggere l'array MqlTick

#property strict
#include <fxsaber\TypeToBytes.mqh>        //https://www.mql5.com/ru/code/16282
#define  POSTFIX "___"

string GetName( const string Name, const int Num, const string PostFix = POSTFIX )
{
  return(Name + PostFix + (string)Num);
}

bool _GlobalVariableDel( const string Name )
{
  return(GlobalVariableDel(Name) && (GlobalVariablesDeleteAll(Name + POSTFIX) >= 0));
}

#define  GLOBAL_VARIABLE_SET(A)                                                        \
template <typename T>                                                                 \
  datetime _GlobalVariableSet( const string Name, const T A )                         \
  {                                                                                   \
    _GlobalVariableDel(Name);                                                         \
                                                                                      \
    double Array[];                                                                   \
                                                                                      \
    const datetime Res = GlobalVariableSet(Name, _ArrayCopy(Array, _R(Value).Bytes)); \
    const int Size = ArraySize(Array);                                                \
                                                                                      \
    for (int i = 0; i < Size; i++)                                                    \
      GlobalVariableSet(GetName(Name, i), Array[i]);                                  \
                                                                                      \
    return(Res);                                                                      \
  }

GLOBAL_VARIABLE_SET(Value)
GLOBAL_VARIABLE_SET(&Value)
GLOBAL_VARIABLE_SET(&Value[])

#define  GLOBAL_VARIABLE_GET(A)                                              \
  {                                                                         \
    double Array[];                                                         \
                                                                            \
    const int Amount = (int)Tmp;                                            \
    const int Size = ArrayResize(Array, Amount / sizeof(double) +           \
                                 ((Amount % sizeof(double) == 0) ? 0 : 1)); \
                                                                            \
    for (int i = 0; i < Size; i++)                                          \
      Array[i] = GlobalVariableGet(GetName(Name, i));                       \
                                                                            \
    uchar Bytes[];                                                          \
                                                                            \
    _ArrayCopy(Bytes, Array, 0, 0, Amount);                                 \
                                                                            \
    _W(A) = Bytes;                                                          \
  }

template <typename T>
const T _GlobalVariableGet( const string Name )
{
  T Res; // https://www.mql5.com/ru/forum/1111/page1869#comment_4854112

  double Tmp;

  if (GlobalVariableGet(Name, Tmp))
    GLOBAL_VARIABLE_GET(Res)

  return(Res);
}

template <typename T>
bool _GlobalVariableGet( const string Name, T &Value )
{
  double Tmp;
  const bool Res = GlobalVariableGet(Name, Tmp);

  if (Res)
    GLOBAL_VARIABLE_GET(Value)

  return(Res);
}


void OnStart()
  {
   string Name="Name";

// Записываем/считываем строки
   _GlobalVariableSet(Name,"Hello World!");
   Print(_GlobalVariableGet<string>(Name));

// Записываем/считываем простые структуры
   MqlTick Tick;
   SymbolInfoTick(_Symbol,Tick);

   _GlobalVariableSet(Name,Tick);
   Print("time --> ",_GlobalVariableGet<MqlTick>(Name).time);
   Print("bid --> ",_GlobalVariableGet<MqlTick>(Name).bid);

// Записываем/считываем массивы
   MqlTick Ticks[2];

   Ticks[0] = Tick;
   Ticks[1] = Tick;

   _GlobalVariableSet(Name,Ticks);
   
//    Print("time --> ",_GlobalVariableGet<MqlTick>(Name).time);
//    Print("bid --> ",_GlobalVariableGet<MqlTick>(Name).bid);
   
   _GlobalVariableDel(Name);
  }
//+------------------------------------------------------------------+


PS: avvisi del compilatore possibile uso di una variabile non inizializzata 'Res', dovrebbe essere rimossa se possibile


 
Alexey Volchanskiy:

Personalmente, mi manca il multitasking. Mi ricordo (10 righe di nostalgia, salto di gioventù), nel 2000 bazzicavo il forum dei programmatori RSDN quando fu rilasciato il Pentium 4. E Intel continuava a parlare di 15GHz nelle sue roadmap. Sì, non sto scherzando, era dappertutto. Beh, non so se lo pensavano davvero o se era una bufala, ma io non ci credevo, dopo tutto sono un ironman.

Ho poi fatto un grande thread sul multicore in arrivo, vedrete, dobbiamo prepararci. La gente rideva, era come una favola, come si può programmare il codice parallelo? È una fantasia.

E chi aveva ragione? Intel ha fallito con i suoi 15Ghz, poi la versione desktop ha ricevuto il Pentium D dual core e poi il Duo di rottura.

E stiamo ancora vivendo nel 199* su MQL5. Nessun multithreading, nessuna eccezione... Ha preso un'anguria per il dolore...

Dalla descrizione di MT5 segue che è multi-threaded. A causa del fatto che la CPU moderna è un cassonetto di codice eseguibile sotto l'utente, rimangono le angurie, non c'è alcun senso pragmatico in tutto il threading. Il business non è interessato né a codici efficienti, né a un uso razionale della potenza di calcolo: se non ce n'è abbastanza - comprane di più.

P.S. Forse 1.5GHz? Potrei sbagliarmi, in quegli anni hanno definito il limite fisico della tecnologia a 5nm, e da questo i presunti GHz. Vorrei passare da 200nm a 5nm, proprio così in un paio d'anni - certamente lo farei.

 

Nel 2030 metatrader sarà vietato,

la persona che vieterà tutto andrà al potere.

Allora ci sarà un unico sistema di pagamento nel mondo.

E un solo sovrano in tutto il mondo.

Comincerà a mettere chip in tutti e a mettere tutti sotto GLONASS, 5G.

Non ci saranno contanti. I pagamenti saranno effettuati tramite chip impiantati nel corpo.

Solo i membri privilegiati della società saranno autorizzati a commerciare su internet - quelli che pensano che questo sovrano sia un vero dio...


Amen.

 
Igor Makanu:

Ho costruito uno script per testarlo, ma non so come leggere l'array MqlTick.

Aggiungere questo sovraccarico

template <typename T>
bool _GlobalVariableGet( const string Name, T &Value[] )
{
  double Tmp;
  const bool Res = GlobalVariableGet(Name, Tmp);

  if (Res)
  {
    double Array[];                                                         
                                                                            
    const int Amount = (int)Tmp;                                            
    const int Size = ArrayResize(Array, Amount / sizeof(double) +           
                                 ((Amount % sizeof(double) == 0) ? 0 : 1)); 
                                                                            
    for (int i = 0; i < Size; i++)                                          
      Array[i] = GlobalVariableGet(GetName(Name, i));                       
                                                                                                                                                        
    _ArrayCopy(Value, Array, 0, 0, Amount);
  }  

  return(Res);
}
Igor Makanu:

PS: avvisi del compilatore possibile uso di una variabile non inizializzata 'Res', potrebbe essere rimosso se possibile

Aggiungere questa linea

  T Res;
  ZeroMemory(Res);
 
Unicornis:

Dalla descrizione di MT5 segue che è multi-threaded. A causa del fatto che il processore moderno nel suo lavoro sotto l'utente è un dump di codici eseguibili, ci sono ancora cocomeri, non c'è senso pragmatico in tutti i threading. Il business non è interessato né a codici efficienti, né a un uso razionale della potenza di calcolo: se non ce n'è abbastanza - comprane di più.

P.S. Forse 1.5GHz? Potrei sbagliarmi, in quegli anni hanno definito il limite fisico della tecnologia a 5nm, e da questo i presunti GHz. Mi piacerebbe passare da 200nm a 5nm, proprio così, in un paio d'anni - certo che sì.

Sono un analfabeta e non leggo le istruzioni. Ma so che MT5 è multi-threaded solo in optimizer). Nel tester funziona in un solo thread.

Per parallelizzarlo si può usare OpenCL ma questa tecnologia di per sé è solo supportata da MT5.

E circa 15GHz nella roadmap sono sicuro, ho la memoria del programmatore, quello che vedo, non lo dimenticherò mai.

12345678910
Nuovo commento