Questions from Beginners MQL5 MT5 MetaTrader 5 - page 420
You are missing trading opportunities:
- Free trading apps
- Over 8,000 signals for copying
- Economic news for exploring financial markets
Registration
Log in
You agree to website policy and terms of use
If you do not have an account, please register
This is not convenient, especially with a large number of parameters...
It's an interesting solution via an array. Especially interesting how to find the closest variable value when averaging the total number of values.
This is the kind of code I got.
//+------------------------------------------------------------------+
//| 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
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
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 NN=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 NN=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++)
{
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,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],"MaxBuy=",TargetMassivOk[MaxSell],"MinBuy=",TargetMassivOk[MinSell]);
Print("Среднее значение массива TargetMassivOk= ",sr_Target);
Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
Print("Target= ",Target);
}
}
}
//+------------------------------------------------------------------+
I can't understand why data is lost from TargetMassivOk array if Sell==1, but when Buy==1 everything works?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
I can't understand why data is lost from TargetMassivOk array if Sell==1, but when Buy==1 everything works?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Do the brute force attack from the end ( as in the brute force attack, data may be lost first if the list is modified)
for(int i=5; i>0; i--)
Do the brute force attack from the end ( as the brute force attack may first lose data if the list is modified)
for(int i=5; i>0; i--)
Not like that. From 4 to >=0.
I thought his total number was odd too, so I put the same...
Got it one higher.
Start the brute force attack at the end of the list (because the brute force attack may first lose data if the list is changed)
for(int i=5; i>0; i--)
Not so. From 4 to >=0
If the code is corrected like this
TargetMassiv[0]=0.1;//NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
TargetMassiv[1]=0.2;//NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
TargetMassiv[2]=0.3;//NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
TargetMassiv[3]=2.4;//NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
TargetMassiv[4]=0.5;//NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);
If the code is corrected in the following way
TargetMassiv[0]=0.1;//NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
TargetMassiv[1]=0.2;//NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
TargetMassiv[2]=0.3;//NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
TargetMassiv[3]=2.4;//NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
TargetMassiv[4]=0.5;//NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);
I figured it out - when I was checking for adequate work with negative numbers I put reverse sorting of the array - I don't think it's relevant now.
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);