Perguntas de Iniciantes MQL5 MT5 MetaTrader 5 - página 420
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Isto não é conveniente, especialmente com um grande número de parâmetros...
É uma solução interessante através de uma matriz. Especialmente interessante como encontrar o valor variável mais próximo quando se faz a média do número total de valores.
Este é o tipo de código que eu tenho.
//+------------------------------------------------------------------+
//| 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);
}
}
}
//+------------------------------------------------------------------+
Não consigo compreender porque é que se perdem dados da matriz TargetMassivOk se Vender===1, mas quando Comprar===1 tudo funciona?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Não consigo compreender porque é que se perdem dados da matriz TargetMassivOk se Vender===1, mas quando Comprar===1 tudo funciona?
for(int i=0;i<5;i++)
{
if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
{
TargetMassivOk[i]=TargetMassiv[i];
N++;
}
}
Fazer o ataque por força bruta a partir do fim (como no ataque por força bruta, os dados podem ser perdidos primeiro se a lista for modificada)
for(int i=5; i>0; i--)
Fazer o ataque por força bruta a partir do fim (pois o ataque por força bruta pode primeiro perder dados se a lista for modificada)
for(int i=5; i>0; i--)
Não é bem assim. De 4 a >=0.
Também achei o seu número total estranho, por isso coloquei o mesmo...
Consegui um mais alto.
Iniciar o ataque por força bruta no final da lista (porque o ataque por força bruta pode primeiro perder dados se a lista for alterada)
for(int i=5; i>0; i--)
Não é assim. De 4 a >=0
Se o código for corrigido desta forma
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 o código for corrigido da seguinte forma
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);
Descobri-o - quando estava a verificar se havia trabalho adequado com números negativos coloquei uma classificação inversa da matriz - não acho que seja relevante agora.
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);