Algorithmen, Lösungsmethoden, Vergleich ihrer Leistung

Sergey Dzyublik 2017.12.11 10:21 #191

Реter Konow:

Ich weiß nicht, warum Sie einer idealen Lösung Entitäten hinzufügen sollten. Ich verstehe nicht, was das soll.

Man kann nicht zwei Hüte gleichzeitig tragen. Und warum ist das so?

Erklären Sie zunächst Folgendes. ))

"Sie foltern Menschen und lassen sie leiden, erniedrigen sie moralisch und psychologisch...."

Verfluchte Welt (Gesammelte Werke)Autoren: Dmitri Ganin

Реter Konow 2017.12.11 10:37 #192

Sergey Dzyublik:

"Man foltert Menschen und lässt sie leiden, man erniedrigt sie moralisch und psychologisch...."

Die verfluchte Welt (Sammlung)Autoren: Dmitry Ganin

Ich entschuldige mich aufrichtig bei allen, die ich unbeabsichtigt moralisch und psychologisch leiden ließ.

Einen anderen Zweck als die perfekte Lösung für ein bestimmtes Problem zu finden, habe ich nicht verfolgt.

Im Gegenteil, ich habe selbst unverständliche Angriffe und unmotivierte Aggressionen erlebt.

Offenbar ist dies der Preis, den jeder zahlt, der nicht mit der Gesellschaft "mithalten" will.

Nun, ich habe meine Entscheidung getroffen und ich gebe niemandem die Schuld...

Wünsche für MT5 Maschinelles Lernen im Handel: Warum bewegen sich die

Alexandr Andreev 2017.12.11 10:40 #193

Реter Konow:

Ich weiß nicht, warum Sie einer idealen Lösung Entitäten hinzufügen sollten.

Vielleicht ist es noch zu früh, um über Ihren Code als ideale Lösung zu sprechen.

Und hier ist die aktuelle Hutsammlung

Реter Konow 2017.12.11 10:47 #194

Alexandr Andreev:

Vielleicht ist es noch zu früh, um über Ihren Code als perfekte Lösung zu sprechen

Ich habe sozusagen in allgemeinen Worten gesprochen...

"Warum sollte man zu einer idealen Lösung (egal welcher Art) Entitäten hinzufügen?"

Ich muss sagen, dass viele Leute mir sehr wertvolle Anregungen gegeben und mich auf die richtigen Fehler hingewiesen haben:

1. ein Fehler bei der Zeichenzählung.

2. Fehler, der durch Kollisionen von Teilzeichenfolgen innerhalb einer gemeinsamen Zeichenfolge verursacht wird.

3. Überlauf des für jede einzelne Zeichenfolge zugewiesenen Speichers. 4.

4. der Irrglaube, dass eine Änderung der Array-Größe zu einer Datenlöschung führt.

Vielen Dank an alle, die mich auf diese Fehler hingewiesen haben!

Diskussion über "Wie man Fragen zu MQL4 Gibt es den Gral?

Реter Konow 2017.12.11 10:56 #195

Реter Konow:
...

Vielen Dank an alle, die mich auf diese Fehler hingewiesen haben!

Um objektiv zu sein, die letzte, die ideale Lösung, gehört allen, denn ich habe sie durch das Aufzeigen von Fehlern, durch Kommunikation und Interaktion mit Menschen erreicht.

Alexandr Andreev 2017.12.11 11:00 #196

Реter Konow:

Um objektiv zu sein, die letzte, die ideale Lösung, gehört allen, denn ich bin durch das Aufzeigen von Fehlern, durch Kommunikation und Interaktion mit Menschen zu ihr gekommen.

Noch einmal: Die letzte Option ist nur eine Option, was davor kam, war überhaupt keine Option! Und die Tatsache, dass es perfekt ist, ist ein strittiger Punkt.

Реter Konow 2017.12.11 11:02 #197

Alexandr Andreev:

Noch einmal: Die letzte Option ist nur eine Option, was davor kam, war überhaupt keine Option! Und die Tatsache, dass es perfekt ist, ist ein strittiger Punkt.

(Gut. Es soll nur für mich perfekt sein. Jeder kann das nach seinem eigenen Maßstab beurteilen.

Alexandr Andreev 2017.12.11 11:05 #198

Ich schlage vor, wir machen weiter mit DEBAG-Drucken und Kometen - wer hat eine Idee?

Igor Makanu 2019.10.12 08:48 #199

die Laufzeit getestet, wenn die Funktion ist:

1. in einer Klasse verpackt

2. in eine Klasse eingeschlossen, wird eine Instanz der Klasse mit dem new-Operator erzeugt

3. Rufen Sie die Funktion einfach auf, ohne einen Wrapper zu verwenden.

//+------------------------------------------------------------------+

#define    SpeedTest(count_x10,msg,EX)        {uint mss=GetTickCount(); ulong count=(ulong)pow(10,count_x10);for(ulong i=0;i<count&&!_StopFlag;i++){EX;} \
                                              printf("%s: loops=%i ms=%u",msg,count,GetTickCount()-mss);}
//+------------------------------------------------------------------+
class COpen
{
private:
   string            m_symbol;
public:
                     COpen(const string symbol): m_symbol(symbol) {}
   double            getOpen(const int bar) const                 { return(iOpen(m_symbol, 0, bar)); }

};
//+------------------------------------------------------------------+
void OnStart()
{  #define  loop_x10 9
//1.
   COpen sym1(_Symbol);
   srand(GetTickCount());
   SpeedTest(loop_x10, "1. COpen", sym1.getOpen(rand()));
//2.
   srand(GetTickCount());
   SpeedTest(loop_x10, "2. new COpen",
             COpen *sym2 = new COpen(_Symbol);
             sym2.getOpen(rand());
             delete sym2;
            );
//3.            
   srand(GetTickCount());
   SpeedTest(loop_x10, "3. iOpen",iOpen(NULL,0,rand()););            
}
//_______________________________________________________________________

2019.10.12:39:29.802 SpeedTst_class (EURUSD,M1) 1. COpen: Schleifen=1000000000 ms=41016

2019.10.12:41:05.352 SpeedTst_class (EURUSD,M1) 2. new COpen: loops=1000000000 ms=95562

2019.10.12:41:45.939 SpeedTst_class (EURUSD,M1) 3. iOpen: loops=1000000000 ms=40578

Die Tests 1 und 3 liegen leistungsmäßig nebeneinander, d.h. die Einbindung von Funktionsaufrufen in die Klasse ist unkritisch, während Test 2 wegen der Konstruktor- und Destruktoraufrufe zusätzliche Zeit erfordert.

Algorithms, solution methods, comparison Fragen von Neueinsteigern zu Leinwand ist cool!

Igor Makanu 2019.12.11 16:19 #200

Test der Ausführungsgeschwindigkeit vonSymbolInfoDouble()

#property version   "1.00"
// количество итераций теста
#define  LOOPx10 8

#define    SpeedTest(count_x10,msg,EX)        {uint mss=GetTickCount(); ulong count=(ulong)pow(10,count_x10);for(ulong i=0;i<count&&!_StopFlag;i++){EX;} \
                                              printf("%s: loops=%i ms=%u",msg,count,GetTickCount()-mss);}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   double lot;

   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_my()", lot = rand() / 1000.0; calcNormVol_my(lot))

   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_alexeyvik()", lot = rand() / 1000.0; calcNormVol_alexeyvik(lot))
   
   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_fxsaber()", lot = rand() / 1000.0; calcNormVol_fxsaber(lot))
   
   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_my_2()", lot = rand() / 1000.0; calcNormVol_my_2(lot))

}
//+------------------------------------------------------------------+
double calcNormVol_my(const double value)
{
   const static string sym = _Symbol;
   return(NormalizeDouble(fmax(fmin(SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP) * round(value / SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP)), SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX)),
                               SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN)),  2));
}
//+------------------------------------------------------------------+
double calcNormVol_alexeyvik(const double value)
{
//   const string sym = _Symbol;
   return(
            NormalizeDouble(fmax(fmin(SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP) * round(value / SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP)),
                                      SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX)),  SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN)), 2)
         );
}
//+------------------------------------------------------------------+
const double VolumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
const double VolumeMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
const double VolumeMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
const int O_DigitsInVolumeStep = 2;
double calcNormVol_fxsaber( const double value )
{
   return((value > VolumeMax) ? VolumeMax
          : ((value < VolumeMin) ? VolumeMin
             : NormalizeDouble(VolumeStep * (int)(value / VolumeStep + 0.5), O_DigitsInVolumeStep)));
}
//+------------------------------------------------------------------+
double calcNormVol_my_2( const double value )
{
   const static double volumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   const static double volumeMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   const static double volumeMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   const static int o_digitsInVolumeStep = 2;
   return((value > volumeMax) ? volumeMax
          : ((value < volumeMin) ? volumeMin
             : NormalizeDouble(volumeStep * (int)(value / volumeStep + 0.5), o_digitsInVolumeStep)));
}
//+------------------------------------------------------------------+

2019.12.11 21:13:08.896 tst_volum (EURUSD,W1) calcNormVol_my(): loops=100000000 ms=173406

2019.12.11 21:15:45.425 tst_volum (EURUSD,W1) calcNormVol_alexeyvik(): loops=100000000 ms=156531

2019.12.11 21:15:45.533 tst_volum (EURUSD,W1) calcNormVol_fxsaber(): loops=100000000 ms=110

2019.12.11 21:15:45.916 tst_volum (EURUSD,W1) calcNormVol_my_2(): loops=100000000 ms=390

Algorithmen, Lösungsmethoden, Vergleich ihrer Leistung - Seite 20