Erreurs, bugs, questions

fxsaber 2017.03.17 09:43 #18331

Andrey Dik:

Je ne vois pas de contradiction.

Rashid Umarov 2017.03.17 10:07 #18332

transcendreamer:

Cela a peut-être déjà été fait, mais laissez-moi demander :

pourquoiPOSITION_COMMISSION n'est pas mis en évidence et ne figure pas dans l'aide ?

Cette constante n'est plus pertinente, mais nous ne pouvons malheureusement pas la rejeter. C'est pourquoi il n'est pas éclairé dans le compilateur.

Andrey Dik 2017.03.17 10:15 #18333

fxsaber:
Je ne vois pas de contradiction.

Contradiction avec quoi ?

J'ai montré un solde négatif dans le testeur. De plus, l'équité était en dessous de zéro. Je dois supposer que c'est un bug.

Konstantin 2017.03.17 11:08 #18334

Je ne comprends rien, MT5 version 1545. Dans les versions précédentes, il y avait des fonctions dans le listing Math.mqh :

//+------------------------------------------------------------------+
//| Computes the minimum value in array[]                            |
//+------------------------------------------------------------------+
double MathMin(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count==0)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- first element by default, find minimum
   double min_value=array[ind1];

   for(int i=ind1+1; i<=ind2; i++)
      min_value=MathMin(min_value,array[i]);
//--- return minimum value
   return(min_value);
  }
//+------------------------------------------------------------------+
//| Computes the maximum value in array[]                            |
//+------------------------------------------------------------------+
double MathMax(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count==0)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- first element by default, find maximum
   double max_value=array[ind1];

   for(int i=ind1+1; i<=ind2; i++)
      max_value=MathMax(max_value,array[i]);
//--- return maximum value
   return(max_value);
  }
//+------------------------------------------------------------------+
//| Computes the range of the values in array[]                      |
//+------------------------------------------------------------------+
double MathRange(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count==0)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- default values, find minimum and maximum values
   double min_value=array[ind1];
   double max_value=array[ind1];

   for(int i=ind1+1; i<=ind2; i++)
     {
      double value=array[i];
      min_value=MathMin(min_value,value);
      max_value=MathMax(max_value,value);
     }
//--- return range
   return(max_value-min_value);
  }
//+------------------------------------------------------------------+
//| Computes the sum of the values in array[]                        |
//+------------------------------------------------------------------+
double MathSum(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count==0)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate sum
   double sum=0.0;
   for(int i=ind1; i<=ind2; i++)
      sum+=array[i];
//--- return sum
   return(sum);
  }
//+------------------------------------------------------------------+
//| Computes the standard deviation of the values in array[]         |
//+------------------------------------------------------------------+
double MathStandardDeviation(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<=1)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
//--- average mean
   mean=mean/data_count;
//--- calculate standard deviation   
   double sdev=0;
   for(int i=ind1; i<=ind2; i++)
      sdev+=MathPow(array[i]-mean,2);
//--- return standard deviation
   return MathSqrt(sdev/(data_count-1));
  }
//+------------------------------------------------------------------+
//| Computes the average absolute deviation of the values in array[] |
//+------------------------------------------------------------------+
double MathAverageDeviation(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<=1)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
   mean=mean/data_count;
//--- calculate average deviation
   double adev=0;
   for(int i=ind1; i<=ind2; i++)
      adev+=MathAbs(array[i]-mean);
   adev=adev/data_count;
//--- return average deviation
   return(adev);
  }
//+------------------------------------------------------------------+
//| Computes the median value of the values in array[]               |
//+------------------------------------------------------------------+
double MathMedian(double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count==0)
      return(QNaN);
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- prepare sorted values
   double sorted_values[];
   ArrayCopy(sorted_values,array,0,start,count);
   ArraySort(sorted_values);
//--- calculate median for odd and even cases
//--- data_count=odd
   if(data_count%2==1)
      return(sorted_values[data_count/2]);
   else
//--- data_count=even
      return(0.5*(sorted_values[(data_count-1)/2]+sorted_values[(data_count+1)/2]));
  }
//+------------------------------------------------------------------+
//| Computes the mean value of the values in array[]                 |
//+------------------------------------------------------------------+
double MathMean(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<1)
      return(QNaN); // need at least 1 observation
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
   mean=mean/data_count;
//--- return mean
   return(mean);
  }
//+------------------------------------------------------------------+
//| Computes the variance of the values in array[]                   |
//+------------------------------------------------------------------+
double MathVariance(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<2)
      return(QNaN); // need at least 2 observations
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
   mean=mean/data_count;
//--- calculate variance
   double variance=0;
   for(int i=ind1; i<=ind2; i++)
      variance+=MathPow(array[i]-mean,2);
   variance=variance/(data_count-1);
//--- return variance
   return(variance);
  }
//+------------------------------------------------------------------+
//| Computes the skewness of the values in array[]                   |
//+------------------------------------------------------------------+
double MathSkewness(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<3)
      return(QNaN); // need at least 3 observations
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
   mean=mean/data_count;
//--- calculate variance and skewness
   double variance=0;
   double skewness=0;
   for(int i=ind1; i<=ind2; i++)
     {
      double sqr_dev=MathPow(array[i]-mean,2);
      skewness+=sqr_dev*(array[i]-mean);
      variance+=sqr_dev;
     }
   variance=(variance)/(data_count-1);
   double v3=MathPow(MathSqrt(variance),3);
//---
   if(v3!=0)
     {
      skewness=skewness/(data_count*v3);
      //--- return skewness
      return(skewness);
     }
   else
      return(QNaN);
  }
//+------------------------------------------------------------------+
//| Computes the kurtosis of the values in array[]                   |
//+------------------------------------------------------------------+
double MathKurtosis(const double &array[],const int start=0,const int count=WHOLE_ARRAY)
  {
   int size=ArraySize(array);
   int data_count=0;
//--- set data count
   if(count==WHOLE_ARRAY)
      data_count=size;
   else
      data_count=count;
//--- check data range
   if(data_count<4)
      return(QNaN); // need at least 4 observations
   if(start+data_count>size)
      return(QNaN);
//--- set indexes
   int ind1=start;
   int ind2=ind1+data_count-1;
//--- calculate mean
   double mean=0.0;
   for(int i=ind1; i<=ind2; i++)
      mean+=array[i];
   mean=mean/data_count;
//--- calculate variance and kurtosis
   double variance=0;
   double kurtosis=0;
   for(int i=ind1; i<=ind2; i++)
     {
      double sqr_dev=MathPow(array[i]-mean,2);
      variance+=sqr_dev;
      kurtosis+=sqr_dev*sqr_dev;
     }
//--- calculate variance
   variance=(variance)/(data_count-1);
   double v4=MathPow(MathSqrt(variance),4);

   if(v4!=0)
     {
      //--- calculate kurtosis
      kurtosis=kurtosis/(data_count*v4);
      kurtosis-=3;
      //--- return kurtosis
      return(kurtosis);
     }
   else
      return(QNaN);
  }

et maintenant elles ne sont pas dans cette liste, j'ai regardé dans d'autres listes de l'annuaire Math, mais je n'ai pas trouvé ces fonctions là non plus.

Ont-ils été supprimés ou ont-ils été effacés accidentellement ?

L'Apprentissage Automatique dans le [Archive] Toute question de FOREX - Tendances, prévisions

Konstantin 2017.03.17 11:32 #18335

J'ai vérifié jusqu'à la version 1554 de MT5, même histoire, ces fonctions ne sont plus disponibles.

Alexey Viktorov 2017.03.17 12:24 #18336

luser.2017:
J'ai vérifié jusqu'à la version 1554 de MT5, même histoire, ces fonctions ne sont plus là.

Pourquoi en avez-vous besoin alors que vous disposez de toute la série de fonctions mathématiques ?

Документация по MQL5: Математические функции

www.mql5.com

Математические функции - справочник по языку алгоритмического/автоматического трейдинга для MetaTrader 5

Konstantin 2017.03.17 13:49 #18337

Alexey Viktorov:
Pourquoi en avez-vous besoin alors que vous disposez de l'ensemble des fonctions mathématiques.

Avant de répondre, comparez-la avec celles que j'ai publiées dans la liste. D'ailleurs, ces fonctions sont répertoriées dans l'aide de la bibliothèque standard, il est donc plus probable que quelqu'un les ait accidentellement effacées.

[ARCHIVE]Toute question de débutant, Discussion de l'article "Opérations Pourquoi certains grands codeurs

Konstantin 2017.03.18 09:09 #18338

Konstantin:

Avant de répondre, comparez-la avec celles que j'ai publiées dans la liste. Au fait, ces fonctions sont répertoriées dans l'aide de la bibliothèque standard, il est donc plus probable que quelqu'un les ait accidentellement effacées.

La réponse de servicedesk, les fonctions de données de la bibliothèque standard ont été supprimées volontairement, le problème est résolu. L'aide doit également être mise en ligne, car on perd parfois du temps à chercher quelque chose qui n'est plus dans la fonctionnalité.

[Toute question de débutant, Mon EA fait une nouveau mql4 fournissant des

Aleksandr Novikov 2017.03.19 21:19 #18339

Comment est-ce possible ? J'ouvre un compte de démonstration sur un serveur de la société btc-e.com, mais il s'ouvre sur un serveur complètement différent d'une autre société !

TheXpert 2017.03.19 22:07 #18340

btc-e fournit un pont MT4 à leur échange. fxopen sont parmi ceux qui l'utilisent et ont probablement été les premiers à le faire.

Je soupçonne btc-e de s'être mis d'accord avec eux pour ne pas s'embêter avec les comptes de démonstration. Ou peut-être qu'ils travaillent déjà entièrement à travers eux sur mt4.

Nouveau Forex L'avenir du trading automatisé 1200 abonnés ! !!

Erreurs, bugs, questions - page 1834