ForumKategorien

Ermitteln der Anzahl der Dezimalstellen beliebiger Zahlen (nicht nur Anführungszeichen) unter Umgehung von Digits() in MQL4 und MQL5 - Seite 16

Neuer Kommentar

Hier ist eine weitere interessante Aufgabe: eine Array-Sortierfunktion schneller zu machen als die eingebaute ArraySort.

Ilya Malev:
sizeof(S)/sizeof(T)

Ist garantiert, dass die Größe aller Strukturen durch die Größe aller Variablen geteilt wird?

struct SZ{
   char x1;
   char x2;
   char x3;   
};

Print(sizeof(SZ)/sizeof(int)); // 0
fxsaber:

Kann ich Brainstorming auf eine schnelle Implementierung der Übersetzung eines Arrays von Strukturen (Länge Vielfache von sizeof(int)) zu und von einem int[] Array?

///

Schreiben Sie einfach nach der Beschreibung einer Struktur ein paar weitere Zeilen mit einer Union, die diese Struktur und ein Array enthält.

struct SS{
   int a;
   double b;
};

union UX{
   SS s;
   char a[sizeof(S)];
};


Es ist sogar möglich, nicht nach jeder Struktur zu schreiben, sondern eine Schablone zu verwenden - je nachdem, was für Sie bequem ist.

Dmitry Fedoseev:

Ist die Größe aller Strukturen garantiert durch die Größe aller Variablen geteilt?

Forum für Handel, automatisierte Handelssysteme und Strategietests

Ermitteln der Anzahl der Dezimalstellen beliebiger Zahlen (nicht nur Anführungszeichen) unter Umgehung von Digits() in MQL4 und MQL5

fxsaber, 2018.12.07 15:12

Kann ich Brainstorming auf eine schnelle Implementierung zu konvertieren ein Array von Strukturen (Länge Vielfache von sizeof(int)) in und aus einem int[] Array?

Im Allgemeinen liegt die Lösung in der gleichen Verbindung, aber wegen der Vielseitigkeit gibt es dort eine Bremse. Vielfältigkeit ist also eine verständliche Zusatzbedingung.

Dies erschien auch.

Forum zum Thema Handel, automatisierte Handelssysteme und Strategietests

Neue Version von MetaTrader 5 build 1930: Floating Chart Window und .Net Library in MQL5

MetaQuotes Software Corp., 2018.10.25 17:18

  1. MQL5: Die Eigenschaft pack( integer_value ) wurde für Strukturen hinzugefügt. Sie ermöglicht es Ihnen, die Ausrichtung der Felder innerhalb der Struktur festzulegen, was bei der Arbeit mit DLL notwendig sein kann. Denn integer_value kann die Werte 1, 2, 4, 8 und 16 haben.
    Wenn die Eigenschaft nicht definiert ist, ist die Standardausrichtung 1 Byte - pack(1).

    Beispiel für die Verwendung:
    //+------------------------------------------------------------------+
//| Default packing                                                  |
//+------------------------------------------------------------------+
struct A
  {
   char              a;
   int               b;
  };
//+------------------------------------------------------------------+
//| Specified packing                                                |
//+------------------------------------------------------------------+
struct B pack(4)
  {
   char              a;
   int               b;
  };
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   Print("sizeof(A)=",sizeof(A));
   Print("sizeof(B)=",sizeof(B));
  }
//+------------------------------------------------------------------+
    Ausgabe:
    sizeof(A)=5
sizeof(B)=8
    Weitere Informationen zur Ausrichtung in Strukturen finden Sie auf MSDN.
Dmitry Fedoseev:

Schreiben Sie einfach nach der Beschreibung der Struktur ein paar weitere Zeilen mit einer Union, die diese Struktur und das Array umfasst.

Sie können auch nicht nach jeder Struktur schreiben, sondern sie als Vorlage verwenden - was immer bequemer ist.

Das verstehe ich nicht. Wenn Sie teilnehmen möchten, schreiben Sie bitte Ihre Variante.

fxsaber:

Kann ich Brainstorming auf eine schnelle Implementierung der Übersetzung eines Arrays von Strukturen (Länge Vielfaches von sizeof(int)) zu und von int[] Array?

Warum zu int? und nicht zu char?

(und sie wird länger sein - sie wird schneller kopiert)

Ilya Malev:

Offensichtlich ist Ihrer bereits schneller :)

// Перевод массива тиков в массив int[].
int TicksToIntArray_fxsaber3( const MqlTick &Ticks[], int &Array[] )
{
  INTEGER<MqlTick> TickInteger;

  const int Size = ArraySize(Ticks);
  ArrayResize(Array, Size * sizeof(MqlTick) / sizeof(int));
  
  int j = 0;

  for (int i = 0; i < Size; i++)
  {
    TickInteger.Data = Ticks[i];

//    j += ArrayCopy(Array, TickInteger.Integer, j);
    for (int k = 0; k < sizeof(MqlTick) / sizeof(int); k++)
      Array[j++] = TickInteger.Integer[k];
  }

  return(j);
}

// Перевод массива int[] в массив тиков.
int IntArrayToTicks_fxsaber3( const int &Array[], MqlTick &Ticks[] )
{
  INTEGER<MqlTick> TickInteger = {0};

  const int Size = ArraySize(Array);
  ArrayResize(Ticks, Size * sizeof(int) / sizeof(MqlTick));
  
  int j = 0;

  for (int i = 0; i < Size; j++)
  {
//    i += ArrayCopy(TickInteger.Integer, Array, 0, i, sizeof(MqlTick) / sizeof(int));
    for (int k = 0; k < sizeof(MqlTick) / sizeof(int); k++)
      TickInteger.Integer[k] = Array[i++];

    Ticks[j] = TickInteger.Data;
  }

  return(j);
}


Ich werde versuchen, das Ganze erheblich zu beschleunigen.

fxsaber:

Das verstehe ich nicht. Wenn Sie teilnehmen möchten, geben Sie bitte Ihre Option an.

Das habe ich.

fxsaber:

Im allgemeinen Fall liegt die Lösung in der gleichen Verbindung, aber wegen der Universalität gibt es Bremsen. Daher ist die Multiplizität eine verständliche Zusatzbedingung.

Dies erscheint auch.

Wer wird diese Vielfalt kontrollieren?

1...910111213141516171819202122
Neuer Kommentar