Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 421
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
Fatto il calcolo solo al cambio di barra - il mio metodo :) Se avete delle idee per l'ottimizzazione - vi ascolterò!
//+------------------------------------------------------------------+
//| 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);
}
}
}
}
//+------------------------------------------------------------------+
Sbagliato - l'enumerazione funziona così com'è, se il valore dell'indice superasse la dimensione dell'array, verrebbe maledetto, e non è così. C'è un valore con degli zeri, e N può essere non zero! Si scopre che anche il controllo avviene, poi si scopre che l'array non scrive dati.
Non stavo tirando a indovinare, stavo sottolineando la scorrettezza del ciclo proposto. Pensate a voi stessi from-where e to-where con un array di dimensioni pari a cinque, è necessario fare un ciclo...
Sia il mio che il tuo hanno cinque valori, qual è la differenza - spiega per favore.
La dimensione della matrice è cinque. Se indicizzate l'array da 4 a 0, compreso lo zero, il ciclo passerà attraverso tutti i valori dell'array. Se cercate di indicizzare da cinque, l'array è fuori portata. Se indicizzate da 4 a zero, senza includere lo zero, il ciclo non passerà attraverso tutto l'array - la cella zero dell'array non sarà letta.
Cioè questo è corretto:
for(int i=4; i>=0; i--) {}
o
for(int i=0; i<5; i++) {}
La dimensione della matrice è cinque. Se indicizzate l'array da 4 a 0, compreso lo zero, il ciclo passerà attraverso tutti i valori dell'array. Se cercate di indicizzare da cinque, l'array è fuori portata. Se indicizzate da 4 a zero, senza includere lo zero, il ciclo non passerà attraverso tutto l'array - la cella zero dell'array non sarà letta.
Cioè questo è corretto:
for(int i=4; i>=0; i--) {}
o
for(int i=0; i<5; i++) {}
fare un attacco di forza bruta dalla fine (poiché l'attacco di forza bruta potrebbe prima perdere dati se la lista viene cambiata)
Leanid Aladzyeu:
Leanid Aladzyeu:
Fare il re-build dalla fine (poiché il re-build può perdere i dati prima quando si cambia la lista)
Non smette mai di stupirmi... Perché invece di imparare a usare gli specchietti retrovisori, la gente impara solo una regola del traffico e gira l'angolo senza guardare e va avanti...?
Non so perché una volta ho letto che quando si chiudono diversi ordini dalla lista di quelli aperti si deve passare da un indice più grande a uno più piccolo e anche consigliare agli altri di andare sempre in questa direzione...
Non smette mai di stupirmi... Perché invece di imparare a usare gli specchietti retrovisori, la gente impara solo un punto delle regole del traffico e gira l'angolo senza guardare e va dritto?
Perché una volta leggere che se chiudiamo diversi ordini da una lista di quelli aperti, dovremmo guardare da un indice più grande a uno più piccolo e consigliare agli altri di usare sempre questa direzione...?
Non smette mai di stupirmi... Perché invece di imparare a usare gli specchietti retrovisori, la gente impara solo un punto delle regole del traffico e gira l'angolo senza guardare e va dritto?
Perché una volta leggere che se si chiudono diversi ordini da una lista di quelli aperti si deve passare da un indice più grande a uno più piccolo e consigliare agli altri di andare sempre in questa direzione...?
Duck, puoi farlo come vuoi, io mi sforzavo di chiudere dall'ultimo al primo, avrei dovuto farlo al contrario. E l'ho fatto, solo che ci sono delle sfumature, non solo il contatore da girare.
Questo è vero per tutto ciò che viene cancellato nel ciclo (ordini, oggetti del grafico, ecc.) perché la cancellazione riempie le celle precedenti dell'"array di oggetti" con "oggetti" successivi. In generale, ovviamente, dobbiamo considerare la situazione. Per esempio, quando si scrivono gli indicatori, è sciocco, per usare un eufemismo, iniziare a disegnare dall'ultimo elemento (rates_total-1).
Stai cercando di spiegarmi come farlo correttamente? O forse ho capito male qualcosa?
In realtà, se sto guidando su una strada deserta e non vedo una sola macchina o trattore in giro, non giro.