Questions des débutants MQL5 MT5 MetaTrader 5 - page 421
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
J'ai fait le calcul seulement au changement de barre - ma méthode :) Si vous avez des idées d'optimisation, je vous écoute !
//+------------------------------------------------------------------+
//| 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);
}
}
}
}
//+------------------------------------------------------------------+
Faux - l'énumération fonctionne comme elle est, si la valeur de l'index dépassait la taille du tableau, elle serait maudite, et ce n'est pas le cas. Il existe une valeur avec des zéros, et N peut être non nul ! Il s'avère que la vérification se produit également, puis il s'avère que le tableau n'écrit pas de données.
Je ne faisais pas de suppositions, je soulignais l'inexactitude de la boucle proposée. En vous imaginant de-où et à-où avec un tableau de taille égale à cinq, vous devez faire une boucle...
Le mien et le vôtre ont tous deux cinq valeurs, quelle est la différence - veuillez expliquer.
La taille du tableau est de cinq. Si vous indexez le tableau de 4 à 0, y compris zéro, la boucle parcourra toutes les valeurs du tableau. Si vous essayez d'indexer à partir de cinq, le tableau est hors de portée. Si vous indexez de 4 à zéro, sans inclure zéro, la boucle ne parcourra pas tout le tableau - la cellule zéro du tableau ne sera pas lue.
C'est-à-dire que c'est correct :
for(int i=4 ; i>=0 ; i--) {}
ou
for(int i=0 ; i<5 ; i++) {}
La taille du tableau est de cinq. Si vous indexez le tableau de 4 à 0, y compris zéro, la boucle parcourra toutes les valeurs du tableau. Si vous essayez d'indexer à partir de cinq, le tableau est hors de portée. Si vous indexez de 4 à zéro, sans inclure zéro, la boucle ne parcourra pas tout le tableau - la cellule zéro du tableau ne sera pas lue.
C'est-à-dire que c'est correct :
for(int i=4 ; i>=0 ; i--) {}
ou
for(int i=0 ; i<5 ; i++) {}
faire une attaque par force brute à partir de la fin ( car l'attaque par force brute peut d'abord perdre des données si la liste est modifiée)
Leanid Aladzyeu:
Leanid Aladzyeu:
Faites la reconstruction à partir de la fin (car la reconstruction peut perdre des données lors du changement de liste).
Cela ne cesse de m'étonner... Pourquoi, au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent d'apprendre un seul code de la route et prennent le virage sans regarder et foncent... ?
Je ne sais pas pourquoi j'ai lu une fois que lorsque je ferme plusieurs ordres de la liste des ordres ouverts, je dois passer d'un indice plus grand à un indice plus petit et je conseille même aux autres de toujours aller dans cette direction...
Cela ne cesse de m'étonner... Pourquoi, au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent-ils d'apprendre un point du code de la route et prennent le virage sans regarder et vont tout droit ?
Pourquoi avoir lu une fois que si nous clôturons plusieurs ordres à partir d'une liste d'ordres ouverts, nous devons regarder d'un indice plus grand vers un indice plus petit et conseiller aux autres de toujours utiliser cette direction... ?
Cela ne cesse de m'étonner... Comment se fait-il qu'au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent d'apprendre un point du code de la route et tournent le coin sans regarder et vont tout droit ???
Pourquoi avoir lu une fois que si vous fermez plusieurs ordres d'une liste d'ordres ouverts, vous devez passer d'un indice plus grand à un indice plus petit et conseiller aux autres de toujours aller dans cette direction... ?
Duck, tu peux le faire de la manière que tu veux, je m'efforçais de fermer de la dernière à la première, j'aurais dû le faire dans l'autre sens. Et je l'ai fait, seulement il y a des nuances, pas seulement le compteur à tourner.
C'est vrai pour tout ce qui est supprimé dans la boucle (ordres, objets du graphique, etc.) car la suppression remplit les cellules précédentes du "tableau d'objets" avec les "objets" suivants. En général, bien sûr, nous devons considérer la situation. Par exemple, lorsque vous écrivez des indicateurs, il est idiot, pour ne pas dire plus, de commencer à dessiner à partir du dernier élément (taux_total-1).
Essayez-vous de m'expliquer comment le faire correctement ? Ou peut-être ai-je mal compris quelque chose ?
En fait, si je conduis sur une route déserte et que je ne vois pas une seule voiture ou un seul tracteur aux alentours, je ne tourne pas.