vector<double/complex> operator[](const int i) const; vector<double/complex> operator[](const ulong i) const;Sie wurden durch eine einzige Methode mit einem konstanten Rückgabewert ersetzt:
const vector<double/complex> operator[](const ulong i) const;Diese Änderung wird dazu beitragen, die falsche Verwendung des Ergebnisses an Ort und Stelle zu erfassen, da in der neuen Alglib-Version der Code mat[row][col]=x anders funktioniert als in der alten Version. Zuvor war damit das Schreiben in eine Matrix gemeint. Jetzt wird der Wert in ein temporäres Objekt vector<double/complex> geschrieben, das nach der Aufzeichnung sofort zerstört wird.
bool ArrayToFP16(ushort &dst_array[],const float &src_array[],ENUM_FLOAT16_FORMAT fmt); bool ArrayToFP16(ushort &dst_array[],const double &src_array[],ENUM_FLOAT16_FORMAT fmt); bool ArrayToFP8(uchar &dst_array[],const float &src_array[],ENUM_FLOAT8_FORMAT fmt); bool ArrayToFP8(uchar &dst_array[],const double &src_array[],ENUM_FLOAT8_FORMAT fmt); bool ArrayFromFP16(float &dst_array[],const ushort &src_array[],ENUM_FLOAT16_FORMAT fmt); bool ArrayFromFP16(double &dst_array[],const ushort &src_array[],ENUM_FLOAT16_FORMAT fmt); bool ArrayFromFP8(float &dst_array[],const uchar &src_array[],ENUM_FLOAT8_FORMAT fmt); bool ArrayFromFP8(double &dst_array[],const uchar &src_array[],ENUM_FLOAT8_FORMAT fmt);Da sich die realen Zahlenformate für 16 und 8 Bit unterscheiden können, muss der Parameter „fmt“ in den Konvertierungsfunktionen angeben, welches Zahlenformat verarbeitet werden muss. Für 16-Bit-Versionen wird die neue Enumeration NUM_FLOAT16_FORMAT verwendet, die derzeit folgende Werte hat:
Terminal
MQL5
MetaEditor
Tester
Web-Terminal
Terminal
MQL5
MetaTrader 5 Web-Terminal
Terminal
MetaTrader 5 Web-Terminal
Terminal
MQL5
//+------------------------------------------------------------------+ //| Skript Programm Start Funktion | //+------------------------------------------------------------------+ void OnStart() { complex a=1+1i; complex b=a.Conjugate(); Print(a, " ", b); /* (1,1) (1,-1) */ vectorc va= {0.1+0.1i, 0.2+0.2i, 0.3+0.3i}; vectorc vb=va.Conjugate(); Print(va, " ", vb); /* [(0.1,0.1),(0.2,0.2),(0.3,0.3)] [(0.1,-0.1),(0.2,-0.2),(0.3,-0.3)] */ matrixc ma(2, 3); ma.Row(va, 0); ma.Row(vb, 1); matrixc mb=ma.Conjugate(); Print(ma); Print(mb); /* [[(0.1,0.1),(0.2,0.2),(0.3,0.3)] [(0.1,-0.1),(0.2,-0.2),(0.3,-0.3)]] [[(0.1,-0.1),(0.2,-0.2),(0.3,-0.3)] [(0.1,0.1),(0.2,0.2),(0.3,0.3)]] */ ma=mb.Transpose().Conjugate(); Print(ma); /* [[(0.1,0.1),(0.1,-0.1)] [(0.2,0.2),(0.2,-0.2)] [(0.3,0.3),(0.3,-0.3)]] */ }
from sys import argv data_path=argv[0] last_index=data_path.rfind("\\")+1 data_path=data_path[0:last_index] from sklearn.datasets import load_iris iris_dataset = load_iris() from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(iris_dataset['data'], iris_dataset['target'], random_state=0) from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors=1) knn.fit(X_train, y_train) # Konvertierung ins ONNX-Format from skl2onnx import convert_sklearn from skl2onnx.common.data_types import FloatTensorType initial_type = [('float_input', FloatTensorType([None, 4]))] onx = convert_sklearn(knn, initial_types=initial_type) path = data_path+"iris.onnx" with open(path, "wb") as f: f.write(onx.SerializeToString())Öffnen Sie die erstellte onnx-Datei in MetaEditor:
struct MyMap { long key[]; float value[]; };Hier haben wir dynamische Arrays mit entsprechenden Typen verwendet. In diesem Fall können wir feste Arrays verwenden, da die Map für dieses Modell immer 3 Schlüssel/Wertpaare enthält.
//--- ein Array deklarieren, um Daten von der Ausgabeschicht output_probability zu erhalten MyMap output_probability[]; ... //--- Modell läuft OnnxRun(model,ONNX_DEBUG_LOGS,float_input,output_label,output_probability);
MetaEditor
MetaTrader 5 Web Terminal build 3980
Terminal
Der Bericht ist in vier Registerkarten unterteilt, die jeweils aggregierte Informationen enthalten:
Neue Berichte ermöglichen es Ihnen, die Handelsergebnisse unter verschiedenen Aspekten visuell auszuwerten, indem Sie einfach auf die Registerkarten klicken. Histogramme, Schaubilder und Diagramme sind interaktiv und liefern zusätzliche Informationen, wenn der Mauszeiger über sie bewegt wird. Unsere Designer haben sich viel Mühe gegeben, die Berichte so einfach und klar wie möglich zu gestalten. Probieren Sie sie einfach aus!
Terminal MetaTrader 5 x64 build 3914 started for MetaQuotes Software Corp.
Terminal Windows 10 build 19045, 20 x Intel Xeon E5-2630 v4 @ 2.20GHz, AVX, 41 / 63 Gb memory, 58 / 280 Gb disk, UAC, GMT+2
VPS-Hosting
MQL5
#define MACRO1 /* #define MACRO2 */ void OnStart() { #ifdef MACRO2 Print( 2 ); #else Print( 1 ); #endif }
void OnStart() { Print("CPU name: ",TerminalInfoString(TERMINAL_CPU_NAME)); Print("CPU cores: ",TerminalInfoInteger(TERMINAL_CPU_CORES)); Print("CPU architecture: ",TerminalInfoString(TERMINAL_CPU_ARCHITECTURE)); Print(""); Print("EX5 architecture: ",__CPU_ARCHITECTURE__); } CPU name: 12th Gen Intel Core i9-12900K CPU cores: 24 CPU architecture: AVX2 + FMA3 EX5 architecture: AVX
extern int X=0; void OnStart() { }
extern int X; void OnStart() { }
extern int X; int Y=X; void OnStart(void) { Print("Y=",Y," X=",X); } int X=_Digits;
Lösungen an
Die ALGLIB-Bibliothek wurde auf die Version 3.19 aktualisiert. ALGLIB ist eine leistungsstarke Bibliothek für numerische Analysen, die für die Arbeit mit numerischen Methoden und Datenanalysealgorithmen entwickelt wurde.
Wir haben bestehende
Bibliotheksklassen überarbeitet, um Matrizen und Vektoren zu verwenden,
und auch neue Funktionen aus ALGLIB 3.19 hinzugefügt. Der gesamte
Quellcode wurde überarbeitet und in einen einheitlichen Designstil
gebracht. Der Quellcode der ALGLIB-Bibliothek befindet sich im
Verzeichnis <Terminaldaten>\MQL5\Include\Math\Alglib. Die
Testskripts befinden sich in MQL5\Scripts\UnitTests\Alglib.
Neben der Bibliothek selbst wurden auch die Testskripte aktualisiert — die Anzahl der Tests stieg von 62 auf 91 für Klassen und von 143 auf 152 für Schnittstellen. Daher bieten die Entwickler der MetaTrader 5-Plattform den Händlern die effizientesten
MetaEditor
Tester
Behoben wurde ein Fehler in den Absturzprotokollen.
MetaTrader 5 Web Terminal Build 3950
Terminal
MQL5
double vector::RegressionMetric( const vector& vector_true, // true values const ENUM_REGRESSION_METRIC metric // metric ); double matrix::RegressionMetric( const matrix& matrix_true, // true values const ENUM_REGRESSION_METRIC metric // metric ); vector matrix::RegressionMetric( const matrix& matrix_true, // true values const ENUM_REGRESSION_METRIC metric, // metric const int axis // axis );
vector vector::LinearRegression(); matrix matrix::LinearRegression( ENUM_MATRIX_AXIS axis=AXIS_NONE // Achse, entlang der die Regression berechnet wird );Beispiel:
vector vector_a; //--- den Vektor mit Preisen füllen vector_a.CopyRates(_Symbol,_Period,COPY_RATES_CLOSE,1,100); //--- eine lineare Regression erhalten vector vector_r=vector_a.LinearRegression();Die Ergebnisse sind in der Grafik dargestellt:
ulong vector::HasNan(); ulong matrix::HasNan();Wenn ein entsprechende Paar von Elementen mit NaN-Werten verglichen wird, betrachten die Methoden Compare und CompareByDigits diese Elemente als gleich, während bei einem gewöhnlichen Vergleich von Fließkommazahlen NaN != NaN.
Die Struktur OnnxTypeInfo, die für Operationen mit ONNX-Modellen verwendet wird, wurde geändert:
struct OnnxTypeInfo { ENUM_ONNX_TYPE type; // parameter type OnnxTensorTypeInfo tensor; // tensor description OnnxMapTypeInfo map; // map description OnnxSequenceTypeInfo sequence; // sequence description };
Der Datentyp wird in der Struktur über neue Unterstrukturen angegeben:
struct OnnxTensorTypeInfo { ENUM_ONNX_DATATYPE data_type; // data type in the tensor long dimensions[]; // number of elements }; struct OnnxMapTypeInfo { ENUM_ONNX_DATA_TYPE key_type; // key type OnnxTypeInfo type_info; // value type }; struct OnnxSequenceTypeInfo { OnnxTypeInfo type_info; // data type in the sequence };Je nach OnnxTypeInfo::type (ONNX_TYPE_TENSOR, ONNX_TYPE_MAP oder ONNX_TYPE_SEQUENCE) wird die entsprechende Unterstruktur gefüllt.
bool vector<T>::CopyIndicatorBuffer(long indicator_handle,ulong buffer_index,ulong start_pos,ulong count); bool vector<T>::CopyIndicatorBuffer(long indicator_handle,ulong buffer_index,datetime start_time,ulong count); bool vector<T>::CopyIndicatorBuffer(long indicator_handle,ulong buffer_index,datetime start_time,datetime stop_time);
MetaEditor
Tester
Behoben wurde ein Fehler in den Absturzprotokollen.
Web Terminal
MQL5.community
Terminal
MQL5
Web Terminal
Web Terminal
MQL5
MQL5: Hinzugefügt wurden die Flags COPY_TICKS_VERTICAL und COPY_RATES_VERTICAL für die Methoden CopyTicks, CopyTicksRange und CopyRates.
Standardmäßig werden Ticks und Zeitreihendaten entsprechend einer horizontalen Achse in die Matrix kopiert, d. h. die Daten werden am rechten Ende der Zeilen hinzugefügt. Für das Training von ONNX-Modelllaufaufgaben muss eine solche Matrix transponiert werden, um die Eingabedaten einzugeben:
const long ExtOutputShape[] = {1,1}; // Ausgangsform des Modells
const long ExtInputShape [] = {1,10,4}; // Eingangsform des Modells
#resource "Python/model.onnx" as uchar ExtModel[]// das Modell als Resource
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
int OnStart(void)
{
matrix rates;
//--- get 10 bars
if(!rates.CopyRates("EURUSD",PERIOD_H1,COPY_RATES_OHLC,2,10))
return(-1);
//--- input a set of OHLC vectors
matrix x_norm=rates.Transpose();
vector m=x_norm.Mean(0);
vector s=x_norm.Std(0);
matrix mm(10,4);
matrix ms(10,4);
Durch die Angabe des zusätzlichen Flags COPY_RATES_VERTICAL (bzw. COPY_TICKS_VERTICAL für Ticks) beim Aufruf der Methode können Sie die zusätzliche Datentransposition vermeiden:
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
int OnStart(void)
{
matrix rates;
//--- get 10 bars
if(!rates.CopyRates("EURUSD",PERIOD_H1,COPY_RATES_OHLC|COPY_RATES_VERTICAL,2,10))
return(-1);
//--- input a set of OHLC vectors
MetaEditor
Terminal
Terminal
MQL5
Kompilieren Sie das Projekt und lassen Sie es auf EURUSD H1 laufen, um das Ergebnis zu sehen.
Neben
dem Modell und dem MQL5-Code, der es ausführt, enthält das Projekt auch
das Python-Skript PricePredictionTraining.py. Es zeigt, wie Sie selbst
ein ONNX-Modell erstellen können. Um das Skript auszuführen,
installieren Sie Python auf Ihrem Computer und die erforderlichen Module
über die Eingabeaufforderung:
#import "mmlib.dll"
bool sgemm(uint flags,matrix<float> &C,const matrix<float> &A,const matrix<float> &B,ulong M,ulong N,ulong K,float alpha,float beta);
#import
C++extern "C" __declspec(dllexport) bool sgemm(UINT flags,float *C,const float *A,const float *B,UINT64 M,UINT64 N,UINT64 K,float alpha,float beta)
Zusätzlich zu den Puffern sollten Sie Matrix- und Vektorgrößen für eine korrekte Verarbeitung übergeben.Die neue Funktion CopySeries zum Kopieren von synchronisierten Zeitreihen aus MqlRates in separate Arrays hinzugefügt.
Die Funktion CopySeries ermöglicht es, mit einem einzigen Aufruf nur die erforderlichen Zeitreihen in verschiedene spezifizierte Arrays zu erhalten, wobei alle Zeitreihendaten synchronisiert werden. Das bedeutet, dass alle Werte in den resultierenden Arrays bei einem bestimmten Index N zum selben Balken des angegebenen Symbol/Zeitrahmenpaares gehören. Daher muss der Programmierer die empfangenen Zeitreihen nicht zusätzlich mit der Eröffnungszeit der Balken synchronisieren.
Im Gegensatz zu CopyRates, das den gesamten Satz von Zeitreihen als MqlRates-Array zurückgibt, ermöglicht die Funktion CopySeries, bestimmte erforderliche Zeitreihen in separaten Arrays zu erhalten. Dies kann durch die Angabe einer Kombination von Flags geschehen, um den Typ der Zeitreihe auszuwählen. Die Reihenfolge der an die Funktion übergebenen Arrays muss mit der Reihenfolge der Felder in der MqlRates-Struktur übereinstimmen:
struct MqlRates
{
datetime time; // period beginning time
double open; // open price
double high; // high price for the period
double low; // low price for the period
double close; // close price
long tick_volume; // tick volume
int spread; // spread
long real_volume; // exchange volume
}
Wenn Sie also die Werte der Zeitreihen „time“, „close“ und „real_volume“ für die letzten 100 Balken des aktuellen Symbols/Zeitrahmens abrufen möchten, sollten Sie den folgenden Aufruf verwenden:
datetime time[];
double close[];
long volume[];
CopySeries(NULL,0,0,100,COPY_RATES_TIME|COPY_RATES_CLOSE|COPY_RATES_VOLUME_REAL,time,close,volume);
Die Reihenfolge der Arrays „time, close, volume“ muss mit der Reihenfolge der Felder in der Struktur MqlRates übereinstimmen. Die Reihenfolge der Werte in der Maske rates_mask wird nicht berücksichtigt. Die Maske könnte auch folgendermaßen aussehen:
COPY_RATES_VOLUME_REAL|COPY_RATES_TIME|COPY_RATES_CLOSE
Beispiel
//--- input parameters
input datetime InpDateFrom=D'2022.01.01 00:00:00';
input datetime InpDateTo =D'2023.01.01 00:00:00';
input uint InpCount =20;
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart(void)
{
//--- arrays to get timeseries from the Rates structure
double open[];
double close[];
float closef[];
datetime time1[], time2[];
//---request close prices to a double array
ResetLastError();
int res1=CopySeries(NULL, PERIOD_CURRENT, 0, InpCount,
COPY_RATES_TIME|COPY_RATES_CLOSE, time1, close);
PrintFormat("1. CopySeries returns %d values. Error code=%d", res1, GetLastError());
ArrayPrint(close);
//--- now also request open prices; use float array for close prices
ResetLastError();
int res2=CopySeries(NULL, PERIOD_CURRENT, 0, InpCount,
COPY_RATES_TIME|COPY_RATES_CLOSE|COPY_RATES_OPEN, time2, open, closef);
PrintFormat("2. CopySeries returns %d values. Error code=%d", res2, GetLastError());
ArrayPrint(closef);
//--- compare the received data
if((res1==res2) && (time1[0]==time2[0]))
{
Print(" | Time | Open | Close double | Close float |");
for(int i=0; i<10; i++)
{
PrintFormat("%d | %s | %.5f | %.5f | %.5f |",
i, TimeToString(time1[i]), open[i], close[i], closef[i]);
}
}
/* Result
1. CopySeries returns 0 values. Error code=0
[ 0] 1.06722 1.06733 1.06653 1.06520 1.06573 1.06649 1.06694 1.06675 1.06684 1.06604
[10] 1.06514 1.06557 1.06456 1.06481 1.06414 1.06394 1.06364 1.06386 1.06239 1.06247
2. CopySeries returns 0 values. Error code=0
[ 0] 1.06722 1.06733 1.06653 1.06520 1.06573 1.06649 1.06694 1.06675 1.06684 1.06604
[10] 1.06514 1.06557 1.06456 1.06481 1.06414 1.06394 1.06364 1.06386 1.06239 1.06247
| Time | Open | Close double | Close float |
0 | 2023.03.01 17:00 | 1.06660 | 1.06722 | 1.06722 |
1 | 2023.03.01 18:00 | 1.06722 | 1.06733 | 1.06733 |
2 | 2023.03.01 19:00 | 1.06734 | 1.06653 | 1.06653 |
3 | 2023.03.01 20:00 | 1.06654 | 1.06520 | 1.06520 |
4 | 2023.03.01 21:00 | 1.06520 | 1.06573 | 1.06573 |
5 | 2023.03.01 22:00 | 1.06572 | 1.06649 | 1.06649 |
6 | 2023.03.01 23:00 | 1.06649 | 1.06694 | 1.06694 |
7 | 2023.03.02 00:00 | 1.06683 | 1.06675 | 1.06675 |
8 | 2023.03.02 01:00 | 1.06675 | 1.06684 | 1.06684 |
9 | 2023.03.02 02:00 | 1.06687 | 1.06604 | 1.06604 |
*/
}
MetaEditor
Tester
MetaTrader 5 Web Terminal Build 3620
MetaTrader 5 Client Terminal Build 3550
MetaTrader 5 Web Terminal Build 3550
Web Terminal
Terminal
MQL5
long preferred_workgroup_size_multiple=OpenCL.GetDeviceInfo(0x1067);
void OnStart() { string cpu,os; //--- cpu=TerminalInfoString(TERMINAL_CPU_NAME); os=TerminalInfoString(TERMINAL_OS_VERSION); PrintFormat(„CPU: %s, OS: %s“,cpu,os); }Ergebnis:
MetaEditor
Terminal
MQL5
//--- the first handle parameter is ignored when obtaining the last error code
int code = (int)CLGetInfoInteger(0,CL_LAST_ERROR);
//--- get the code of the last OpenCL error
int code = (int)CLGetInfoInteger(0,CL_LAST_ERROR);
string desc; // to get the text description of the error
//--- use the error code to get the text description of the error
if(!CLGetInfoString(code,CL_ERROR_DESCRIPTION,desc))
desc = "cannot get OpenCL error description, " + (string)GetLastError();
Print(desc);
//--- to get the description of the last OpenCL error without receiving the code, pass CL_LAST_ERROR
if(!CLGetInfoString(CL_LAST_ERROR,CL_ERROR_DESCRIPTION, desc))
desc = "cannot get OpenCL error description, " + (string)GetLastError();
Print(desc);
Der interne Name der Enumeration wird als Fehlerbeschreibung übergeben. Die Erklärung dazu finden Sie unter https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#CL_SUCCESS.
Der Wert CL_INVALID_KERNEL_ARGS bedeutet beispielsweise "Wird
zurückgegeben, wenn der Kernel in die Prozess-Enqueue gestellt wird und
einige Kernel-Argumente nicht gesetzt oder ungültig sind." MetaTrader 5 WebTerminal
Terminal
MQL5
Klasse A { }; void OnStart(void) { const A *const arr[][2][3]={}; Print(typename(arr)); }Ergebnis:
"class A const * const [][2][3]"
Terminal
MQL5
Fehler in den Absturzprotokollen wurden behoben.
MetaTrader 5 WebTerminal Version 3500
Mobile Version der Webplattform
Das neue Web-Terminal bietet eine umfassende Unterstützung für mobile Geräte. Die Oberfläche passt sich automatisch an die Bildschirmgröße an und ermöglicht so eine effiziente Bedienung von iOS- und Android-Handys und -Tablets:
Außerdem bietet das Web-Terminal eine Reihe von Korrekturen und Verbesserungen.
Das neue MetaTrader 5 Web-Terminal unterstützt den vollen Umfang der Handelsfunktionen. Es ermöglicht den Nutzern:
Terminal
MQL5
bool matrix::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
bool vector::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);
bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);
Der kopierte Datentyp wird im Parameter rates_mask unter Verwendung der Enumeration ENUM_COPY_RATES angegeben. Die folgenden Werte sind verfügbar:COPY_TICKS_INFO = 1, // Ticks aufgrund der Änderungen von Bid and/or Ask
COPY_TICKS_TRADE = 2, // Ticks aufgrund der Änderungen von Last und Volumen
COPY_TICKS_ALL = 3, // alle Ticks haben sich geändert
COPY_TICKS_TIME_MS = 1<<8, // Zeit in Millisekunden
COPY_TICKS_BID = 1<<9, // Bid-Preis
COPY_TICKS_ASK = 1<<10, // Ask-Preis
COPY_TICKS_LAST = 1<<11, // Last-Preis
COPY_TICKS_VOLUME = 1<<12, // Volume
COPY_TICKS_FLAGS = 1<<13, // Tick-Flags
Wenn mehrere Datentypen ausgewählt werden (nur bei Matrizen möglich), entspricht die Reihenfolge der Zeilen in der Matrix der Reihenfolge der Werte in der Enumeration.bool matrix::Assign(const vector &vec);
Das Ergebnis wird eine einzeilige Matrix sein.bool vector::Assign(const matrix &mat);
bool vector::Swap(vector &vec);
bool vector::Swap(matrix &vec);
bool vector::Swap(double &arr[]);
bool matrix::Swap(vector &vec);
bool matrix::Swap(matrix &vec);
bool matrix::Swap(double &arr[]);
Jedes Array, jeder Vektor oder jede Matrix verweist auf einen Speicherpuffer, der die Elemente des betreffenden Objekts enthält. Die Swap-Methode tauscht tatsächlich die Zeiger auf diese Puffer aus, ohne die Elemente in den Speicher zu schreiben. Eine Matrix bleibt also eine Matrix, und ein Vektor bleibt ein Vektor. Das Vertauschen einer Matrix und eines Vektors führt zu einer einzeiligen Matrix mit Vektorelementen und einem Vektor mit Matrixelementen in einer flachen Darstellung (siehe die Methode Flat).//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//---
matrix a= {{1, 2, 3}, {4, 5, 6}};
Print("a vor dem Tausch: \n", a);
matrix b= {{5, 10, 15, 20}, {25, 30, 35, 40}, {45, 50, 55, 60}};
Print("b vor dem Tausch: \n", b);
//--- Tausch der Matrix-Pointer
a.Swap(b);
Print("a nach dem Tausch: \n", a);
Print("b nach dem Tausch: \n", b);
/*
a vor dem Tausch:
[[1,2,3]
[4,5,6]]
b vor dem Tausch:
[[5,10,15,20]
[25,30,35,40]
[45,50,55,60]]
a nach dem Tausch:
[[5,10,15,20]
[25,30,35,40]
[45,50,55,60]]
b nach dem Tausch:
[[1,2,3]
[4,5,6]]
*/
vector v=vector::Full(10, 7);
Print("v vor dem Tausch: \n", v);
Print("b vor dem Tausch: \n", b);
v.Swap(b);
Print("v nach dem Tausch: \n", v);
Print("b nach dem Tausch: \n", b);
/*
v vor dem Tausch:
[7,7,7,7,7,7,7,7,7,7]
b vor dem Tausch:
[[1,2,3]
[4,5,6]]
v nach dem Tausch:
[1,2,3,4,5,6]
b nach dem Tausch:
[[7,7,7,7,7,7,7,7,7,7]]
*/
}
Die Methode Swap() ermöglicht auch Operationen mit dynamischen Arrays (Arrays fester Größe können nicht als Parameter übergeben werden). Das Array kann eine beliebige Dimension haben, aber eine vereinbarte Größe, was bedeutet, dass die Gesamtgröße einer Matrix oder eines Vektors ein Vielfaches der Dimension Null des Arrays sein muss. Die Dimension Null des Arrays enthält die Anzahl der Elemente, die im ersten Index enthalten sind. Bei einem dynamischen dreidimensionalen Array ‚double array[][2][3]‘ beispielsweise ist die Dimension Null das Produkt aus der Größe der zweiten und dritten Dimension: 2x3=6. Daher kann ein solches Array bei der Swap-Methode nur mit Matrizen und Vektoren verwendet werden, deren Gesamtgröße ein Vielfaches von 6 ist: 6, 12, 18, 24, usw.//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//--- Füllen einer 1x10 Matrix mit dem Wert 7.0
matrix m= matrix::Full(1, 10, 7.0);
Print("matrix vor dem Tausch:\n", m);
//--- Tauschversuch von Matrix und Array
double array_small[2][5]= {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
Print("array_small vor dem Tausch:");
ArrayPrint(array_small);
if(m.Swap(array_small))
{
Print("array_small nach dem Tausch:");
ArrayPrint(array_small);
Print("matrix nach dem Tausch: \n", m);
}
else // Die Größe der Matrix ist kein Vielfaches der ersten Dimension
{
Print("m.Swap(array_small) failed. Error ", GetLastError());
}
/*
matrix vor dem Tausch:
[[7,7,7,7,7,7,7,7,7,7]]
array_small vor dem Tausch:
[,0] [,1] [,2] [,3] [,4]
[0,] 1.00000 2.00000 3.00000 4.00000 5.00000
[1,] 6.00000 7.00000 8.00000 9.00000 10.00000
m.Swap(array_small) failed. Error 4006
*/
//--- neuer Versuch des Tausches mit einer größeren Matrix
double array_static[3][10]= {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
{3, 6, 9, 12, 15, 18, 21, 24, 27, 30}
};
Print("array_static vor dem Tausch:");
ArrayPrint(array_static);
if(m.Swap(array_static))
{
Print("array_static nach dem Tausch:");
ArrayPrint(array_static);
Print("matrix nach dem Tausch: \n", m);
}
else // ein statisches Array kann nicht für einen Matrix-Tausch verwendet werden
{
Print("m.Swap(array_static) failed. Error ", GetLastError());
}
/*
array_static vor dem Tausch:
[,0] [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
[0,] 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 10.00000
[1,] 2.00000 4.00000 6.00000 8.00000 10.00000 12.00000 14.00000 16.00000 18.00000 20.00000
[2,] 3.00000 6.00000 9.00000 12.00000 15.00000 18.00000 21.00000 24.00000 27.00000 30.00000
m.Swap(array_static) failed. Error 4006
*/
//--- ein weiterer Tauschversuch von Array und matrix
double array_dynamic[][10]; // dynamischer Array
ArrayResize(array_dynamic, 3); // setzen der Größe der ersten Dimension
ArrayCopy(array_dynamic, array_static);
//--- jetzt die Verwendung eines dynamischen Arrays für dejn Tausch
if(m.Swap(array_dynamic))
{
Print("array_dynamic nach dem Tausch:");
ArrayPrint(array_dynamic);
Print("matrix nach dem Tausch: \n", m);
}
else // no error
{
Print("m.Swap(array_dynamic) failed. Error ", GetLastError());
}
/*
array_dynamic nach dem Tausch:
[,0] [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
[0,] 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000
matrix nach dem Tausch:
[[1,2,3,4,5,6,7,8,9,10,2,4,6,8,10,12,14,16,18,20,3,6,9,12,15,18,21,24,27,30]]
*/
}
vector vector::LossGradient(const vector &expected,ENUM_LOSS_FUNCTION loss) const;
matrix matrix::LossGradient(const matrix &expected,ENUM_LOSS_FUNCTION loss) const;
CREATE TABLE artist(
artistid INTEGER PRIMARY KEY,
artistname TEXT
);
CREATE TABLE track(
trackid INTEGER,
trackname TEXT,
trackartist INTEGER,
FOREIGN KEY(trackartist) REFERENCES artist(artistid)
);
MetaEditor
MetaTester
Terminal
MQL5
bool vector<TDst>::Assign(const vector<TSrc> &assign); bool matrix<TDst>::Assign(const matrix<TSrc> &assign);Beispiel:
//--- copying matrices matrix b={}; matrix a=b; a.Assign(b); //--- copying an array to a matrix double arr[5][5]={{1,2},{3,4},{5,6}}; Print("array arr"); ArrayPrint(arr); b.Assign(arr); Print("matrix b \n",b); /* array arr [,0] [,1] [,2] [,3] [,4] [0,] 1.00000 2.00000 0.00000 0.00000 0.00000 [1,] 3.00000 4.00000 0.00000 0.00000 0.00000 [2,] 5.00000 6.00000 0.00000 0.00000 0.00000 [3,] 0.00000 0.00000 0.00000 0.00000 0.00000 [4,] 0.00000 0.00000 0.00000 0.00000 0.00000 matrix b [[1,2,0,0,0] [3,4,0,0,0] [5,6,0,0,0] [0,0,0,0,0] [0,0,0,0,0]] */
bool matrix::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count); bool vector::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count);Der kopierte Datentyp wird im Parameter rates_mask unter Verwendung der Enumeration ENUM_COPY_RATES angegeben. Die folgenden Werte sind verfügbar:
Fehler beim Ändern eines konstanten Parameters, der als Objektzeigerreferenz an eine Funktion übergeben wurde, behoben.
Der Spezifizierer const deklariert eine Variable als Konstante, um zu verhindern, dass sie während der Programmausführung geändert wird. Es erlaubt nur die einmalige Initialisierung von Variablen während der Deklaration. Ein Beispiel für konstante Variablen in der Funktion OnCalculate:
int OnCalculate (const int rates_total, // price[] array size const int prev_calculated, // bars processed on previous call const int begin, // meaningful data starts at const double& price[] // array for calculation );
Das folgende Beispiel enthält einen Compilerfehler, der ein implizites Zeiger-Casting für Referenzparameter zuließ:
class A {}; const A *a = new A; void foo( const A*& b ) { b = a; } void OnStart() { A *b; foo(b); // not allowed Print( a,":",b ); }Der Compiler erkennt solche illegalen Operationen und gibt den entsprechenden Fehler zurück.
MetaEditor
Neues MetaTrader 5 Web-Terminal
Wir
haben ein überarbeitetes MetaTrader 5 Web-Terminal veröffentlicht, das
eine aktualisierte Oberfläche und einen neu gestalteten Kern aufweist.
Die neue Oberfläche ähnelt der Terminalversion für das iPad:
Außerdem bietet es eine Fülle neuer Funktionen:
Versuchen Sie das neue Webterminal unter www.mql5.com gleich jetzt. Es wird in Kürze für Ihre Makler verfügbar sein.
Terminal
MQL5
//--- matrix a= {{1, 4}, {9, 16}}; Print("matrix a=\n",a); a=MathSqrt(a); Print("MatrSqrt(a)=\n",a); /* matrix a= [[1,4] [9,16]] MatrSqrt(a)= [[1,2] [3,4]] */Bei MathMod und MathPow kann das zweite Element entweder ein Skalar oder eine Matrix/ein Vektor mit der entsprechenden Größe sein.
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Use the initializing function to populate the vector vector r(10, ArrayRandom); // Array of random numbers from 0 to 1 //--- Calculate the average value double avr=r.Mean(); // Array mean value vector d=r-avr; // Calculate an array of deviations from the mean Print("avr(r)=", avr); Print("r=", r); Print("d=", d); vector s2=MathPow(d, 2); // Array of squared deviations double sum=s2.Sum(); // Sum of squared deviations //--- Calculate standard deviation in two ways double std=MathSqrt(sum/r.Size()); Print(" std(r)=", std); Print("r.Std()=", r.Std()); } /* avr(r)=0.5300302133243813 r=[0.8346201971495713,0.8031556138798182,0.6696676534318063,0.05386516922513505,0.5491195410016175,0.8224433118686484,... d=[0.30458998382519,0.2731254005554369,0.1396374401074251,-0.4761650440992462,0.01908932767723626,0.2924130985442671, ... std(r)=0.2838269732183663 r.Std()=0.2838269732183663 */ //+------------------------------------------------------------------+ //| Fills the vector with random values | //+------------------------------------------------------------------+ void ArrayRandom(vector& v) { for(ulong i=0; i<v.Size(); i++) v[i]=double(MathRand())/32767.; }
Verbesserte mathematische Funktionen für Operationen mit dem Typ float.
Die neu implementierte Möglichkeit, mathematische Funktionen auf
'float'-Matrizen und -Vektoren anzuwenden, hat eine Verbesserung der auf
'float'-Skalare angewandten mathematischen Funktionen ermöglicht. Zuvor
wurden diese Funktionsparameter bedingungslos in den Typ "double"
umgewandelt, dann wurde die entsprechende Implementierung der
mathematischen Funktion aufgerufen, und das Ergebnis wurde in den Typ
"float" zurückgewandelt. Jetzt werden die Operationen ohne zusätzliches
Typenumwandlung (Casting) implementiert.
Das folgende Beispiel zeigt den Unterschied in den mathematischen Sinusberechnungen:
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Array of random numbers from 0 to 1 vector d(10, ArrayRandom); for(ulong i=0; i<d.Size(); i++) { double delta=MathSin(d[i])-MathSin((float)d[i]); Print(i,". delta=",delta); } } /* 0. delta=5.198186103783087e-09 1. delta=8.927621308885136e-09 2. delta=2.131878673594656e-09 3. delta=1.0228555918923021e-09 4. delta=2.0585739779477308e-09 5. delta=-4.199390279957527e-09 6. delta=-1.3221741035351897e-08 7. delta=-1.742922250969059e-09 8. delta=-8.770715820283215e-10 9. delta=-1.2543186267421902e-08 */ //+------------------------------------------------------------------+ //| Fills the vector with random values | //+------------------------------------------------------------------+ void ArrayRandom(vector& v) { for(ulong i=0; i<v.Size(); i++) v[i]=double(MathRand())/32767.; }
AF_ELU | Exponential-Linear-Einheit |
AF_EXP | Exponential |
AF_GELU | Gaußscher Fehler Lineare Einheit |
AF_HARD_SIGMOID | Hartes Sigmoid |
AF_LINEAR | Linear |
AF_LRELU | Undichte rektifizierte Lineareinheit |
AF_RELU | Rektifizierte Lineareinheit |
AF_SELU | Skalierte Exponential-Linear-Einheit |
AF_SIGMOID | Sigmoid |
AF_SOFTMAX | Softmax |
AF_SOFTPLUS | Softplus |
AF_SOFTSIGN | Softsign |
AF_SWISH | Swish |
AF_TANH | Hyperbolischer Tangens |
AF_TRELU | Schwellenwerteinheit (Rectified Linear Unit) |
LOSS_MSE | Mittlerer quadratischer Fehler |
LOSS_MAE | Mittlerer absoluter Fehler |
LOSS_CCE | Kategoriale Kreuzentropie |
LOSS_BCE | Binäre Kreuzentropie |
LOSS_MAPE | Mittlerer absoluter prozentualer Fehler |
LOSS_MSLE | Mittlerer quadratischer logarithmischer Fehler |
LOSS_KLD | Kullback-Leibler Divergenz |
LOSS_COSINE | Kosinus-Ähnlichkeit/-Nähe |
LOSS_POISSON | Poisson |
LOSS_HINGE | Hinge-Verlustfunktion |
LOSS_SQ_HINGE | Quadratische Hinge-Verlustfunktion |
LOSS_CAT_HINGE | Kategoriale Hinge-Verlustfunktion |
LOSS_LOG_COSH | Logarithmus des Hyperbolischen Kosinus |
LOSS_HUBER | Huber-Verlustfunktion |
int cl_ctx; //--- Initializing the OpenCL context if((cl_ctx=CLContextCreate(CL_USE_GPU_DOUBLE_ONLY))==INVALID_HANDLE) { Print("OpenCL not found"); return; }
CalendarValueLast(change, result, "", "EUR")
MetaEditor
'levels.bmp' as 'uint levels[18990]'