Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 420
![MQL5 - Linguaggio delle strategie di trading integrato nel client terminal MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Questo non è conveniente, specialmente con un gran numero di parametri...
È una soluzione interessante tramite un array. Particolarmente interessante come trovare il valore della variabile più vicino quando si fa la media del numero totale di valori.
Questo è il tipo di codice che ho ricevuto.
//+------------------------------------------------------------------+
//| 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);
}
}
}
//+------------------------------------------------------------------+
Non riesco a capire perché i dati vengono persi dall'array TargetMassivOk se Sell==1, ma quando Buy==1 tutto funziona?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Non riesco a capire perché i dati vengono persi dall'array TargetMassivOk se Sell==1, ma quando Buy==1 tutto funziona?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Fare l'attacco di forza bruta dalla fine (come nell'attacco di forza bruta, i dati possono essere persi prima se la lista viene modificata)
for(int i=5; i>0; i--)
Fare l'attacco di forza bruta dalla fine (poiché l'attacco di forza bruta può prima perdere dati se la lista viene modificata)
for(int i=5; i>0; i--)
Non così. Da 4 a >=0.
Anch'io ho pensato che il suo numero totale fosse strano, così ho messo lo stesso...
L'ho preso uno più in alto.
Iniziare l'attacco di forza bruta alla fine della lista (perché l'attacco di forza bruta potrebbe prima perdere dati se la lista viene cambiata)
for(int i=5; i>0; i--)
Non è così. Da 4 a >=0
Se il codice è corretto come questo
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);
Se il codice viene corretto nel modo seguente
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);
L'ho capito - quando stavo controllando per un lavoro adeguato con i numeri negativi ho messo l'ordinamento inverso dell'array - non credo che sia rilevante ora.
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);