Hatalar, hatalar, sorular

Andrey Dik 2017.03.17 08:02 #18331

fxsaber 2017.03.17 08:43 #18332

Andrey Dik :

Ben bir çelişki görmüyorum.

Rashid Umarov 2017.03.17 09:07 #18333

transcendreamer :

Daha önce olmuş olabilir ama yine de sorayım:

POSITION_COMMISSION neden vurgulanmıyor ve yardımda yok?

Bu sabit artık alakalı değil, ancak ne yazık ki reddedemeyiz. Bu nedenle, vurgulamadan derleyicide bırakılır

Andrey Dik 2017.03.17 09:15 #18334

fxsaber :
Ben bir çelişki görmüyorum.

Ne ile çatışma?

Test cihazında negatif bakiye gösterdim. Ayrıca öz sermaye sıfırın altına indi. Bunun bir bug olduğu varsayılmalıdır.

Konstantin 2017.03.17 10:08 #18335

Hiçbir şey anlamıyorum, MT5 sürümü 1545. Önceki sürümlerde Math.mqh listesi aşağıdaki işlevleri içeriyordu:

 //+------------------------------------------------------------------+
//| 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);
  }

ve şimdi bu listede yoklar, Math kataloğunun diğer listelerine baktım ama bu işlevleri orada da bulamadım.

Hiç mi kaldırıldılar yoksa yanlışlıkla mı silindiler?

Meta Trader'da spread ticareti mql4 ile basit POST/GET Yeni başlayanlardan sorular MQL4

Konstantin 2017.03.17 10:32 #18336

1554 MT5 sürümüne kadar kontrol edildi, aynı hikaye, bu işlevler artık mevcut değil

Alexey Viktorov 2017.03.17 11:24 #18337

luser.2017 :
1554 MT5 sürümüne kadar kontrol edildi, aynı hikaye, bu işlevler artık mevcut değil

Ve bir dizi matematiksel fonksiyon varsa, neden orada ihtiyaç duyuluyor?

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

www.mql5.com

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

Konstantin 2017.03.17 12:49 #18338

Alexey Viktorov :
Ve bir dizi matematiksel fonksiyon varsa, neden orada ihtiyaç duyuluyor?

Cevap vermeden önce, listede benim tarafımdan yayınlananlarla karşılaştırın. Bu arada, bu işlevler standart kitaplık yardımında listelenmiştir, bu nedenle birileri yanlışlıkla onları yanlış yerleştirmiş gibi görünüyor.

Konstantin 2017.03.18 08:09 #18339

Konstantin :

Cevap vermeden önce, listede benim tarafımdan yayınlananlarla karşılaştırın. Bu arada, bu işlevler standart kitaplık yardımında listelenmiştir, bu nedenle birileri yanlışlıkla onları yanlış yerleştirmiş gibi görünüyor.

Servis masasından cevap alındı, bu işlevler kütüphanenin standart teslimatından bilinçli olarak çıkarıldı, soru kaldırıldı. Yardımın da sıraya konması gerekir, aksi takdirde bazen artık işlevsel olmayan bir şeyi aramak için zaman kaybedilir.

Azarlamak :) Bu konudaki Ücretsiz bir danışman yazacağım DC'nin danışmanın işini azalttığı

Aleksandr Novikov 2017.03.19 20:19 #18340

Bu nasıl olabilir? btc-e.com şirketinin bir sunucusunda demo hesabı açıyorum ve başka bir şirketin tamamen farklı bir sunucusunda açılıyor!

Hatalar, hatalar, sorular - sayfa 1834