Errori, bug, domande

Andrey Dik 2017.03.17 09:02 #18331

fxsaber 2017.03.17 09:43 #18332

Andrey Dik:

Non vedo una contraddizione.

Rashid Umarov 2017.03.17 10:07 #18333

transcendreamer:

Forse è già stato fatto, ma lasciatemi chiedere:

perchéPOSITION_COMMISSION non è evidenziato e non è nell'aiuto?

Questa costante non è più rilevante, ma purtroppo non possiamo rifiutarla. Ecco perché è lasciato spento nel compilatore

Andrey Dik 2017.03.17 10:15 #18334

fxsaber:
Non vedo una contraddizione.

Contraddizione con cosa?

Ho mostrato un saldo negativo nel tester. Inoltre, l'equity stava andando sotto zero. Devo supporre che sia un bug.

Konstantin 2017.03.17 11:08 #18335

Non ci capisco niente, MT5 versione 1545. Nelle versioni precedenti c'erano funzioni nell'elenco 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);
  }

e ora non sono in questo elenco, ho cercato in altri elenchi di Math, ma non ho trovato queste funzioni neanche lì.

Sono stati rimossi del tutto o sono stati cancellati accidentalmente?

Librerie: MultiTester Discussione sull articolo "Come [Qualsiasi domanda da principiante,

Konstantin 2017.03.17 11:32 #18336

controllato alla versione 1554 di MT5, stessa storia, queste funzioni non sono più disponibili

Alexey Viktorov 2017.03.17 12:24 #18337

luser.2017:
Ho controllato fino alla versione 1554 di MT5, stessa storia, queste funzioni non ci sono più

Perché avete bisogno di loro quando avete l'intera suite di funzioni matematiche.

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

www.mql5.com

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

Konstantin 2017.03.17 13:49 #18338

Alexey Viktorov:
Perché avete bisogno di loro quando avete tutto l'insieme delle funzioni matematiche.

Prima di rispondere, confrontalo con quelli che ho postato nell'annuncio. A proposito, queste funzioni sono elencate nell'aiuto della libreria standard, quindi è più probabile che qualcuno le abbia accidentalmente cancellate.

Discussione sull articolo "Operazioni [ARCHIVIO]Qualsiasi domanda da principiante, Firebird EA

Konstantin 2017.03.18 09:09 #18339

Konstantin:

Prima di rispondere, confrontalo con quelli che ho postato nell'annuncio. A proposito, queste funzioni sono elencate nell'aiuto della libreria standard, quindi è più probabile che qualcuno le abbia accidentalmente cancellate.

La risposta di servicedesk, le funzioni dati della libreria standard sono state rimosse di proposito, il problema è risolto. Anche l'aiuto dovrebbe essere messo in fila, perché a volte si perde tempo a cercare qualcosa che non è più nella funzionalità.

Auguri per MQL5 L'apprendimento automatico nel trading: e di nuovo dll

Aleksandr Novikov 2017.03.19 21:19 #18340

Come può essere? Apro un conto demo su un server della società btc-e.com, ma si apre su un server completamente diverso di un'altra società!

Errori, bug, domande - pagina 1834