¿Cómo ve a Metatrader X en 2030? - página 6

Nuevo comentario
 
fxsaber:

La escritura de cualquier dato a nivel global se puede ver en los correspondientes inludios aquí.

OK, no he visto esta solución.

No es fácil de averiguar, hay que comprobar

 
fxsaber:

Puedes ver cualquier dato escrito en los inlays globales aquí.

¿Es consciente de que hay un mundo enorme de otros datos además de las garrapatas? Quieres lo extraño - escribir/leer datos de una instancia de clase.

 
Igor Makanu:

Vale, no he visto esta solución.

No es fácil de averiguar, hay que comprobarlo.

Sí, escribiendo y leyendo datos en bruto hacia/desde el recurso. Buen ejemplo, ¡gracias!

Pero, ¿qué tal mi estimado fxsaber para hacer lo mismo con las clases? Puede incluso con las definiciones, la gente promete no volverse loca )))

 
Alexey Volchanskiy:

¿No es eso cocaína, oh, abuelas.


No. Futuros del pan de jengibre.

 
Alexey Volchanskiy:

¿Es consciente de que hay un mundo enorme de otros datos además de las garrapatas?

Foro sobre comercio, sistemas de comercio automatizados y pruebas de estrategias

¿Necesitamos variables terminales globales como la cadena?

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);
}


Quiero lo extraño - escribir/leer datos de una instancia de una clase.

Almaceno los datos en estructuras, al igual que los desarrolladores. Es conveniente y lógico. Así que no he mirado hacia las clases en este asunto, aunque no hay punteros a las estructuras.

 
fxsaber:


Yo almaceno los datos en estructuras, al igual que los desarrolladores. Esto es conveniente y lógico. Por lo tanto, no miré las clases en este asunto, aunque no hay punteros a las estructuras.

Construí el script para la comprobación, pero no entiendo cómo leer la matriz 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);
  }
//+------------------------------------------------------------------+


PD: el compilador advierte del posible uso de una variable no inicializada 'Res', que debería eliminarse si es posible


 
Alexey Volchanskiy:

Personalmente, echo de menos la multitarea. Recuerdo (10 líneas de nostalgia, salto de juventud), allá por el año 2000 andaba por el foro de programadores de RSDN cuando salió el Pentium 4. Y Intel hablaba de 15 GHz en sus hojas de ruta. Sí, no estoy bromeando, estaba por todas partes. Bueno, no sé si realmente lo pensaban o si era un bulo, pero no me lo creí, al fin y al cabo soy un ironman.

Luego hice un gran hilo sobre el multinúcleo que se avecina, ya verás, hay que prepararse. La gente se reía, era como un cuento de hadas, ¿cómo se puede programar código paralelo? Es una fantasía.

¿Y quién tenía razón? Intel fracasó con su 15Ghz, luego la versión de sobremesa recibió el Pentium D de doble núcleo y después el rompedor Duo.

Y seguimos viviendo en los 199*s en MQL5. No hay multihilo, no hay excepciones... Fue a por una sandía por pena...

De la descripción de MT5 se deduce que es multihilo. Debido a que la CPU moderna es un basurero de código ejecutable bajo el usuario, quedan sandías, no tiene sentido pragmático todo el roscado. A las empresas no les interesan ni los códigos eficientes ni el uso racional de la potencia de cálculo: si no hay suficiente, compra más.

P.D. ¿Tal vez 1,5GHz? Puedo estar equivocado, en aquellos años definieron el límite físico de la tecnología en 5nm, y a partir de ahí los supuestos GHz. Me gustaría pasar de los 200nm a los 5nm en un par de años.

 

En 2030 metatrader será prohibido,

la persona que prohibirá todo llegará al poder.

Entonces habrá un único sistema de pago en el mundo.

Y un solo gobernante en todo el mundo.

Empezará a poner chips en todo el mundo y pondrá a todos bajo GLONASS, 5G.

No habrá dinero en efectivo. Los pagos se harán a través de chips implantados en el cuerpo.

Sólo los miembros privilegiados de la sociedad podrán comerciar en Internet: los que piensan que este gobernante es un verdadero dios...


Amén.

 
Igor Makanu:

He construido un script para probarlo, pero no sé cómo leer el array MqlTick.

Añade esta sobrecarga

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: advertencias del compilador posible uso de la variable no inicializada 'Res' , podría ser eliminado si es posible

Añade esta línea

  T Res;
  ZeroMemory(Res);
 
Unicornis:

De la descripción de MT5 se deduce que es multihilo. Debido al hecho de que el procesador moderno en su trabajo bajo el usuario es un vertedero de códigos ejecutables, todavía hay sandías, no hay sentido pragmático en todo el roscado. A las empresas no les interesan ni los códigos eficientes ni el uso racional de la potencia de cálculo: si no hay suficiente, compra más.

P.D. ¿Tal vez 1,5GHz? Puedo estar equivocado, en aquellos años definieron el límite físico de la tecnología en 5nm, y a partir de ahí los supuestos GHz. Me gustaría pasar de 200nm a 5nm, así, en un par de años, claro que sí.

Soy una persona analfabeta y no leo las instrucciones. Pero sé que MT5 es multihilo sólo en el optimizador). En el probador funciona en un solo hilo.

Para paralelizarlo se puede utilizar OpenCL pero esta tecnología en sí misma sólo está soportada por MT5.

Y lo de los 15GHz en hoja de ruta estoy seguro, tengo memoria de programador, lo que veo, nunca lo olvidaré.

12345678910
Nuevo comentario