Fragen von Anfängern MQL5 MT5 MetaTrader 5 - Seite 421
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Die Berechnung erfolgt nur beim Taktwechsel - meine Methode :) Wenn Sie Ideen zur Optimierung haben - ich habe ein offenes Ohr!
//+------------------------------------------------------------------+
//| Target.mq4 |
//| Copyright © 2008, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#property version "1.00"
#property strict
double CC;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
if (Close[1]-CC!=0)
{
CC=Close[1];
double MAT=NormalizeDouble(iMA(Symbol(),0,100,0,0,0,0),Digits);
double S=11*Point;
double Target;
int Buy=1;
int Sell=1;
if(Open[0]-MAT>S || MAT-Open[0]<S) //Условие убытка - надо искать новый TP
{
if(Buy==1) //Если условно ордеров на покупку больше, чем ордеров на продажу (проверять лучше по объему позиции)
{
double TargetMassiv[5]; //Создаем массив
double TargetMassivOk[5]; //Создаем массив
int N=0; //Переменная для изменения размера массива
int X=0; //Переменная для получение информации о номере индекса массива, наиболее соответствующему усредненному значению массива
int Max=0;
int Min=0;
int MaxBuy=0;
int MinBuy=0;
double sr_Target=0;
ArrayFree (TargetMassiv); //Очищаем массив
ArrayFree (TargetMassivOk); //Очищаем массив
ArrayResize(TargetMassiv,5,0); //Восстанавливаем размер массива
ArrayResize(TargetMassivOk,5,0); //Восстанавливаем размер массива
TargetMassiv[0]=NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
TargetMassiv[1]=NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
TargetMassiv[2]=NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
TargetMassiv[3]=NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
TargetMassiv[4]=NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);
for(int i=0;i<5;i++) //Записываем значение в новый массив по условию
{
if(TargetMassiv[i]>MAT && TargetMassiv[i]!=0)
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND); //Сортировка массива
if(N!=0)
{
ArrayResize(TargetMassivOk,N,0);
Max=ArrayMaximum(TargetMassiv,WHOLE_ARRAY,0);
Min=ArrayMinimum(TargetMassiv,WHOLE_ARRAY,0);
MaxBuy=ArrayMaximum(TargetMassivOk,WHOLE_ARRAY,0);
MinBuy=ArrayMinimum(TargetMassivOk,WHOLE_ARRAY,0);
sr_Target=NormalizeDouble(iMAOnArray(TargetMassivOk,0,N,0,0,0),Digits);
if(N==0)
{X=N;}
else
{
for(int i=0;i<N-1;i++)
{
if(sr_Target<=TargetMassivOk[i] && sr_Target>TargetMassivOk[i+1]) X=i; //Берем большее значение т.к. для ордеров на покупку
}
}
Target=TargetMassivOk[X];
}
else
{
Max=0;
Min=0;
MaxBuy=0;
MinBuy=0;
sr_Target=0;
Target=-1;
}
Print("Покупка");
Print("Значения последних 5 элементов массива");
for(int i=0;i<5;i++) printf("TargetMassiv[%d] = %G",i,TargetMassiv[i]);
for(int i=0;i<N;i++) printf("TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);
Print("MAT= ",MAT);
Print("Max= ",TargetMassiv[Max],"Min=",TargetMassiv[Min],"MaxBuy=",TargetMassivOk[MaxBuy],"MinBuy=",TargetMassivOk[MinBuy]);
Print("Среднее значение массива TargetMassivOk= ",sr_Target);
Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
Print("Target= ",Target);
}
/////////////////////////////////////////////////////////////////////////////
if(Sell==1) //Если условно ордеров на продажу больше, чем ордеров на продажу (проверять лучше по объему позиции)
{
double TargetMassiv[5]; //Создаем массив
double TargetMassivOk[5]; //Создаем массив
int N=0; //Переменная для изменения размера массива
int X=0; //Переменная для получение информации о номере индекса массива, наиболее соответствующему усредненному значению массива
int Max=0;
int Min=0;
int MaxSell=0;
int MinSell=0;
double sr_Target=0;
ArrayFree (TargetMassiv); //Очищаем массив
ArrayFree (TargetMassivOk); //Очищаем массив
ArrayResize(TargetMassiv,5,0); //Восстанавливаем размер массива
ArrayResize(TargetMassivOk,5,0); //Восстанавливаем размер массива
TargetMassiv[0]=NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
TargetMassiv[1]=NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
TargetMassiv[2]=NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
TargetMassiv[3]=NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
TargetMassiv[4]=NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);
// for(int i=0;i<5;i++)
for(int i=4; i>=0; i--)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Print("N=",N);
for(int i=0;i<N;i++) printf("До обработки TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);
ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND);
// ArraySort(TargetMassivOk,N,0,MODE_ASCEND); //Сортировка массива
if(N!=0)
{
ArrayResize(TargetMassivOk,N,0);
// ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND); //Дополнительная сортировка
Max=ArrayMaximum(TargetMassiv,WHOLE_ARRAY,0);
Min=ArrayMinimum(TargetMassiv,WHOLE_ARRAY,0);
MaxSell=ArrayMaximum(TargetMassivOk,WHOLE_ARRAY,0);
MinSell=ArrayMinimum(TargetMassivOk,WHOLE_ARRAY,0);
sr_Target=NormalizeDouble(iMAOnArray(TargetMassivOk,0,N,0,0,0),Digits);
for(int i=0;i<N-1;i++)
{
if(sr_Target<=TargetMassivOk[i] && sr_Target>TargetMassivOk[i+1]) X=i;
// if (X=!0) X=X-1;
}
Target=TargetMassivOk[X];
}
else
{
Max=0;
Min=0;
MaxSell=0;
MinSell=0;
sr_Target=0;
Target=-1;
}
Print("Продажа");
Print("Значения последних 5 элементов массива");
for(int i=0;i<5;i++) printf("TargetMassiv[%d] = %G",i,TargetMassiv[i]);
for(int i=0;i<N;i++) printf("TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);
Print("MAT=",MAT);
Print("Max=",TargetMassiv[Max],"Min=",TargetMassiv[Min],"MaxSell=",TargetMassivOk[MaxSell],"MaxSell=",TargetMassivOk[MinSell]);
Print("Среднее значение массива TargetMassivOk= ",sr_Target);
Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
Print("Target= ",Target);
}
}
}
}
//+------------------------------------------------------------------+
Falsch - die Aufzählung funktioniert so wie sie ist, wenn der Indexwert die Array-Größe überschreitet, würde es Flüche geben, und es gibt keine. Es gibt einen Wert mit Nullen, und N kann ungleich Null sein! Es stellt sich heraus, dass die Prüfung auch passiert, dann stellt sich heraus, dass das Array keine Daten schreibt.
Ich habe nicht geraten, sondern auf die Fehlerhaftigkeit der vorgeschlagenen Schleife hingewiesen. Denken Sie sich von-wo und nach-wo mit einer Array-Größe gleich fünf, müssen Sie eine Schleife machen...
Sowohl meine als auch Ihre haben fünf Werte, worin besteht der Unterschied - bitte erklären Sie das.
Die Größe des Feldes ist fünf. Wenn Sie das Array von 4 bis 0, einschließlich Null, indizieren, durchläuft die Schleife alle Werte des Arrays. Wenn Sie versuchen, ab fünf zu indizieren, liegt das Feld außerhalb des Bereichs. Wenn Sie von 4 bis Null indexieren, ohne Null einzuschließen, wird die Schleife nicht durch das gesamte Array gehen - die Nullzelle des Arrays wird nicht gelesen.
D.h. dies ist richtig:
for(int i=4; i>=0; i--) {}
oder
for(int i=0; i<5; i++) {}
Die Größe des Feldes ist fünf. Wenn Sie das Array von 4 bis 0, einschließlich Null, indizieren, durchläuft die Schleife alle Werte des Arrays. Wenn Sie versuchen, ab fünf zu indizieren, liegt das Feld außerhalb des Bereichs. Wenn Sie von 4 bis Null indexieren, ohne Null einzuschließen, wird die Schleife nicht durch das gesamte Array gehen - die Nullzelle des Arrays wird nicht gelesen.
D.h. dies ist richtig:
for(int i=4; i>=0; i--) {}
oder
for(int i=0; i<5; i++) {}
einen Brute-Force-Angriff vom Ende aus durchführen (da der Brute-Force-Angriff zunächst Daten verlieren kann, wenn die Liste geändert wird)
Leanid Aladzyeu:
Leanid Aladzyeu:
Führen Sie die Neuerstellung vom Ende her durch (da bei der Neuerstellung zunächst Daten verloren gehen können, wenn die Liste geändert wird).
Es erstaunt mich immer wieder... Warum lernen die Leute nicht, wie man die Rückspiegel benutzt, sondern lernen nur eine Verkehrsregel und biegen um die Ecke, ohne zu schauen, und fahren einfach weiter...?
Warum haben Sie einmal gelesen, dass man beim Schließen mehrerer Aufträge aus einer Liste offener Aufträge vom größten zum kleinsten Index übergehen muss, und raten sogar anderen, überall in diese Richtung zu gehen...
Es erstaunt mich immer wieder... Warum lernen die Leute nicht, wie man Rückspiegel benutzt, sondern lernen nur einen Punkt der Verkehrsregeln und biegen ohne zu schauen um die Ecke und fahren geradeaus?
Warum haben wir einmal gelesen, dass wir, wenn wir mehrere Aufträge aus einer Liste offener Aufträge schließen, versuchen sollten, von einem größeren zu einem kleineren Index überzugehen, und anderen raten, dies überall zu tun...?
Es erstaunt mich immer wieder... Wie kommt es, dass die Leute, anstatt zu lernen, wie man Rückspiegel benutzt, nur einen Punkt der Verkehrsregeln lernen und um die Ecke biegen, ohne zu schauen und geradeaus zu fahren?
Warum haben Sie einmal gelesen, dass Sie, wenn Sie mehrere Aufträge aus einer Liste offener Aufträge schließen, von einem größeren zu einem kleineren Index übergehen müssen und anderen raten, immer in diese Richtung zu gehen...?
Duck, du kannst es machen, wie du willst, ich habe mich bemüht, vom Letzten zum Ersten zu kommen, ich hätte es umgekehrt machen sollen. Und das habe ich getan, nur gibt es Nuancen, nicht nur den Zähler zu drehen.
Dies gilt für alles, was in der Schleife gelöscht wird (Aufträge, Diagrammobjekte usw.), da beim Löschen die vorherigen Zellen des "Objekt-Arrays" mit nachfolgenden "Objekten" gefüllt werden. Im Allgemeinen müssen wir natürlich die Situation berücksichtigen. Wenn Sie zum Beispiel Indikatoren schreiben, ist es gelinde gesagt dumm, mit dem letzten Element (rates_total-1) zu beginnen.
Versuchen Sie, mir zu erklären, wie man es richtig macht? Oder habe ich vielleicht etwas missverstanden?
Wenn ich auf einer menschenleeren Straße fahre und kein einziges Auto oder einen Traktor sehe, biege ich auch nicht ab.