Wie sehen Sie den Metatrader X im Jahr 2030? - Seite 6

Neuer Kommentar
 
fxsaber:

Das Schreiben von Daten in das Global kann in den entsprechenden Feldern hier eingesehen werden.

OK, ich habe diese Lösung nicht gesehen.

Das ist nicht leicht herauszufinden, man muss nachsehen

 
fxsaber:

Hier können Sie alle Daten sehen, die in die globalen Dateien geschrieben wurden.

Ist Ihnen bewusst, dass es neben den Zecken noch eine riesige Welt anderer Daten gibt? Sie wollen das Seltsame - Daten einer Klasseninstanz schreiben/lesen.

 
Igor Makanu:

OK, ich habe diese Lösung nicht gesehen.

Das ist nicht leicht herauszufinden, man muss es selbst überprüfen.

Ja, Schreiben und Lesen von Rohdaten in/aus der Ressource. Gutes Beispiel, danke!

Aber wie wäre es, wenn mein geschätzter fxsaber das Gleiche mit Klassen machen würde? Kann auch mit definiert, die Menschen versprechen, nicht verrückt zu werden )))

 
Alexey Volchanskiy:

Ist das nicht Koks, oh, Omas.


Nein. Lebkuchen-Futures.

 
Alexey Volchanskiy:

Ist Ihnen bewusst, dass es neben den Zecken noch eine riesige Welt von anderen Daten gibt?

Forum zum Thema Handel, automatisierte Handelssysteme und Strategietests

Brauchen wir globale Terminalvariablen wie string?

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


Ich möchte die seltsame - schreiben / lesen Daten einer Instanz einer Klasse.

Ich speichere Daten in Strukturen, genau wie die Entwickler. Das ist praktisch und logisch. Daher habe ich in dieser Ausgabe nicht nach Klassen gesucht, auch wenn es keine Hinweise auf Strukturen gibt.

 
fxsaber:


Ich speichere Daten in Strukturen, wie es auch die Entwickler tun. Es ist bequem und logisch. Deshalb habe ich mich in dieser Angelegenheit nicht mit Klassen befasst, auch wenn ich keine Zeiger auf Strukturen habe.

Ich baute das Skript für die Überprüfung, aber ich weiß nicht, wie man MqlTick Array lesen

#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: Compiler-Warnungen wegen möglicher Verwendung einer nicht initialisierten Variable 'Res', sollte nach Möglichkeit entfernt werden


 
Alexey Volchanskiy:

Ich persönlich vermisse Multitasking. Ich erinnere mich (10 Zeilen Nostalgie, die Jugend überspringt), dass ich mich im Jahr 2000 im RSDN-Programmiererforum herumtrieb, als der Pentium 4 veröffentlicht wurde. Und Intel sprach immer wieder davon, wie schnell der P4 15 GHz erreichen würde. Ja, ich mache keine Witze, es war überall. Nun, ich weiß nicht, ob sie das wirklich dachten oder ob es ein Scherz war, aber ich habe es nicht geglaubt, schließlich bin ich ein Ironman.

Ich habe dann einen großen Thread über Multicore gemacht, der bald kommen wird, Sie werden sehen, wir müssen uns darauf vorbereiten. Die Leute haben gelacht, es war wie ein Märchen, wie kann man parallelen Code programmieren? Das ist ein Hirngespinst.

Und wer hatte Recht? Intel scheiterte mit seinem 15Ghz, dann erhielt die Desktop-Version den Dual-Core Pentium D und dann den bahnbrechenden Duo.

Und wir leben immer noch in 199*s auf MQL5. Kein Multithreading, keine Ausnahmen... Wollte aus Kummer eine Wassermelone...

Aus der Beschreibung von MT5 geht hervor, dass es sich um ein Multithreading-System handelt. Aufgrund der Tatsache, dass die moderne CPU ist ein Müllcontainer von ausführbaren Code unter dem Benutzer, dann gibt es Wassermelonen, gibt es keinen pragmatischen Sinn in all dem Threading. Die Wirtschaft ist weder an effizienten Codes noch an einer rationellen Nutzung der Rechenleistung interessiert: Wenn es nicht genug davon gibt, kauft man mehr.

P.S. Vielleicht 1,5GHz? Ich könnte mich irren, aber in jenen Jahren wurde eine physikalische Technologiegrenze von 5 nm definiert, und davon ausgehend die angebliche GHz-Grenze. Ich würde gerne in ein paar Jahren von 200nm auf 5nm umsteigen - das würde ich auf jeden Fall tun.

 

Im Jahr 2030 wird der Metatrader verboten sein,

wird die Person an die Macht kommen, die alles verbieten will.

Dann wird es ein einziges Zahlungssystem in der Welt geben.

Und ein Herrscher über die ganze Welt.

Er wird damit beginnen, Chips in alle Menschen einzubauen und alle mit GLONASS und 5G auszustatten.

Es wird kein Bargeld geben. Die Zahlungen werden über in den Körper implantierte Chips erfolgen.

Nur privilegierten Mitgliedern der Gesellschaft wird es erlaubt sein, im Internet zu handeln - denjenigen, die diesen Herrscher für einen echten Gott halten...


Amen.

 
Igor Makanu:

Ich habe ein Skript erstellt, um es zu testen, aber ich weiß nicht, wie man das MqlTick-Array liest.

Diese Überlast hinzufügen

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: Compiler-Warnungen wegen möglicher Verwendung einer nicht initialisierten Variable 'Res', könnte entfernt werden, wenn möglich

Diese Zeile hinzufügen

  T Res;
  ZeroMemory(Res);
 
Unicornis:

Aus der Beschreibung von MT5 geht hervor, dass es sich um ein Multithreading-System handelt. Aufgrund der Tatsache, dass moderne Prozessor in seiner Arbeit unter Benutzer ist ein Dump von ausführbaren Codes, gibt es noch Wassermelonen, gibt es keinen pragmatischen Sinn in allen Threading. Die Wirtschaft ist weder an effizienten Codes noch an einer rationellen Nutzung der Rechenleistung interessiert: Wenn es nicht genug davon gibt, kauft man mehr.

P.S. Vielleicht 1,5GHz? Ich könnte mich irren, aber in jenen Jahren wurde die physikalische Grenze der Technologie auf 5 nm festgelegt, und davon ausgehend das angebliche GHz. Ich würde gerne von 200 nm auf 5 nm umsteigen, einfach so, in ein paar Jahren - natürlich würde ich das tun.

Ich bin Analphabet und kann keine Anleitungen lesen. Aber ich weiß, dass MT5 nur im Optimierer multi-threaded ist). In der Testversion funktioniert es nur in einem Thread.

Zur Parallelisierung können Sie OpenCL verwenden, aber diese Technologie wird nur von MT5 unterstützt.

Und über 15GHz in der Roadmap bin ich mir sicher, ich habe das Gedächtnis eines Programmierers, was ich sehe, werde ich nie vergessen.

12345678910
Neuer Kommentar