Fiyat != Fiyat ? - sayfa 2

Yeni yorum
 

Karşılaştırma içinse, kendi işlevinizi kolayca oluşturabilirsiniz:

 bool checkDoubles( double a, double b, string check)
{
if (check== ">" ){
if (a - b > Point / 2 ) return ( 1 ); else return ( 0 );
} else if (check== "<" ){
if (b - a > Point / 2 ) return ( 1 ); else return ( 0 );
} else if (check== ">=" ){
if (a - b > - Point ) return ( 1 ); else return ( 0 );
} if (check== "<=" ){
if (b - a > - Point ) return ( 1 ); else return ( 0 );
} else if (check== "!=" ){
if ( MathAbs (a - b) > Point / 2 ) return ( 1 ); else return ( 0 );
} else {
Print ( "Sorry you've entered a wrong check value" );
}
return ( 0 );
}

Bu sadece bir düşünce.

 
heelflip43 :

Karşılaştırma içinse, kendi işlevinizi kolayca oluşturabilirsiniz:

Bu sadece bir düşünce.


Bu iyi bir fikir, bunun için teşekkür ederim :-)
 

"Puan" veya "Puan/2.0" kullanımı çok iyi bir fark değeri değil, IMO. NormalizeDouble tarafından sunulan yuvarlama hatası (bugün tarafından yakıldı), kesinlikle 8 basamaktan çok daha küçük, daha büyük olasılıkla 15 basamak.

Önceki ipuçları göz önüne alındığında ve bazı değişiklikler yaptı ve henüz tam olarak test edilmemiş olmasına rağmen, iyi çalışıyor gibi görünen ("fark" 15 ondalık basamağa kadar kullanılsa bile) aşağıdaki rutini bir araya getirdi:

 //+------------------------------------------------------------------+
bool AvsB( double A, string checkStr, double B)
{
   //checkStr = StringTrimLeft(StringTrimRight(checkStr));
   double diff = 0.000000000000001 ; // 15 decimal places
   //double diff = 0.000000005;
   //double diff = 0.00000001;
   if      (checkStr == ">" ){ if (A - B >  diff) return ( true ); else return ( false );}
   else if (checkStr == "<" ){ if (B - A >  diff) return ( true ); else return ( false );}
   else if (checkStr == ">=" ){ if (A - B > -diff) return ( true ); else return ( false );}
   else if (checkStr == "<=" ){ if (B - A > -diff) return ( true ); else return ( false );}
   else if (checkStr == "!=" ){ if (MathAbs(A - B) >  diff) return ( true ); else return ( false );}
   else if (checkStr == "=" || checkStr == "==" ){ if (MathAbs(A - B) <  diff) return ( true ); else return ( false );}
   else {Print( "Sorry, bad usage: AvsB(A, checkStr, B).  Wrong checkStr value: " ,checkStr);}
   return ( false );
} // end of AvsB
//+------------------------------------------------------------------+



Here is a check of the obvious:
   if ( 1.34929 == NormalizeDouble ( 1.34929 , 5 ))   Alert ( "MT4 Pass" );
   else Alert ( "MT4 FAIL.  ROUNDOFF BUG" );     // Yes, this is what MT4 does, a fail.

   if (AvsB( 1.34929 , "==" , NormalizeDouble ( 1.34929 , 5 )))   Alert ( "AvsB Pass" );   // It does pass using the AvsB routine!
   else Alert ( "AvsB FAIL.  ROUNDOFF BUG" );
 

Karşılaştırabilen, ancak aynı zamanda A ve/veya B'yi dahili olarak normalleştirebilen ve ayrıca (AB veya BA'nın) karşılaştırma farkını "rakamlara" dayalı daha büyük bir sayıya gevşetebilecek bir başka olası rutin daha. Yukarıdaki basit "AvsB" ile karşılaştırıldığında bu rutinin gerekli olduğundan şüpheliyim, ancak istediğiniz gibi kullanımınız için sunulmaktadır:

 //+------------------------------------------------------------------+
bool AvsB_nA_nB_digits( double A, string checkStr, double B, bool normalizeA, bool normalizeB, int digits)
{
   //checkStr = StringTrimLeft(StringTrimRight(checkStr));
   if (normalizeA) A = NormalizeDouble(A,MathMin( 8 ,digits));
   if (normalizeB) B = NormalizeDouble(B,MathMin( 8 ,digits));
   
   double diff;
   switch (digits)
   {
       case 0   : diff = 0.5 ; break ; // Or 1.0 ??
       case 1   : diff = 0.1 ; break ;
       case 2   : diff = 0.01 ; break ;
       case 3   : diff = 0.001 ; break ;
       case 4   : diff = 0.0001 ; break ;
       case 5   : diff = 0.00001 ; break ;
       case 6   : diff = 0.000001 ; break ;
       case 7   : diff = 0.0000001 ; break ;
       case 8   : diff = 0.00000001 ; break ;
       case 9   : diff = 0.000000001 ; break ;
       case 10 : diff = 0.0000000001 ; break ;
       case 11 : diff = 0.00000000001 ; break ;
       case 12 : diff = 0.000000000001 ; break ;
       case 13 : diff = 0.0000000000001 ; break ;
       case 14 : diff = 0.00000000000001 ; break ;
       default : diff = 0.000000000000001 ; break ; // 15 decimal places max (I think)
   }
   
   if      (checkStr == ">" ){ if (A - B >  diff) return ( true ); else return ( false );}
   else if (checkStr == "<" ){ if (B - A >  diff) return ( true ); else return ( false );}
   else if (checkStr == ">=" ){ if (A - B > -diff) return ( true ); else return ( false );}
   else if (checkStr == "<=" ){ if (B - A > -diff) return ( true ); else return ( false );}
   else if (checkStr == "!=" ){ if (MathAbs(A - B) >  diff) return ( true ); else return ( false );}
   else if (checkStr == "=" || checkStr == "==" ){ if (MathAbs(A - B) <  diff) return ( true ); else return ( false );}
   else {Print( "Sorry, bad usage: AvsB(A, checkStr, B).  Wrong checkStr value: " ,checkStr);}
   return ( false );
} // end of AvsB_nA_nB_digits
//+------------------------------------------------------------------+
 
pips4life :

"Puan" veya "Puan/2.0" kullanımı çok iyi bir fark değeri değil, IMO. NormalizeDouble tarafından sunulan yuvarlama hatası (bugün tarafından yakıldı), kesinlikle 8 basamaktan çok daha küçük, daha büyük olasılıkla 15 basamak.

Yuvarlama hatası sayılamayacak en büyük değeri veya eşdeğeri, fiyat değişikliği sayılamayacak en küçük değeri istiyorsunuz. Fiyatlar yalnızca noktanın katları kadar değişebileceğinden, nokta/2 tam da budur.

Aracının çifte değeri 1.2345750000000000 ile 1.2345849999999999999 arasında olabilir ve yine de aynı 1.23458 fiyat olarak kabul edilir.

Bunu kullanmış olsaydın, problemin olmazdı:

 if (a > b)
 if (a - b > Point / 2 .)
 if (a >= b)
 if (a - b > - Point /2.)
 if (a != b)
 if ( MathAbs (a - b) > Point / 2 .)
 

normalizedouble kullanmaktan kaçınmalı mıyız?

ya da olabilir.. MathRound işlevini kullanabileceğimizi düşündüm.

eski . çift x= ( MathRound ( 1.37883 * 100000)) / 100000 ;

böylece fonksiyon yapabiliriz

 double round ( double value )

{ int D= MathPow ( 10 , Digits );

double x =  ( MathRound (value * D)) / D ;

return (x);

}
 
*Kravatını iki parmağıyla yerine sallar* Sadece double olan her yerde değil, double değeri içeren hesaplamalarda sadece double'ı normalleştirmeyi kullanın.
 
tonny :
*Kravatını iki parmağıyla yerine sallar* Sadece double olan her yerde değil, double değeri içeren hesaplamalarda sadece double'ı normalleştirmeyi kullanın.
Veya NormalizeDouble()'ı hiç kullanmayın, çoğu zaman kullanıldığında kesinlikle kullanmanıza gerek yoktur. . . 4107 hatası NormalizeDouble() kullanılarak giderilebilir, ancak başka yollar da vardır. Önceden Tanımlanmış Değişkenler veya zaman serisi işlevlerinden gelen herhangi bir fiyatın hiçbir zaman Normalleştirilmesi gerekmeyecek ve bir tam sayının Nokta ile çarpımı sonucu da olmayacaktır.
 
WDholic :

normalizedouble kullanmaktan kaçınmalı mıyız?

ya da olabilir.. MathRound işlevini kullanabileceğimizi düşündüm.

eski . çift x= ( MathRound ( 1.37883 * 100000)) / 100000 ;


Hala bir çift ve hala fiyat olasılığı var != fiyat

Double'ları karşılaştırmak amacıyla double'ları int'lere dönüştüren bu çözüme ulaştım. . .

 int Flat( double ValueToFlatten)
   {
   double Power = MathPow ( 10 , Digits );
   int ReturnValue;
   
   ReturnValue = MathRound (Power * (ValueToFlatten + ( 4.9 / (Power* 10 ) ) ) ) ;
   return (ReturnValue);
   
   }

Böylece . . . 

Flat(price) != Flat(price)

asla doğru olmayacak.

 
Basit çözüm yerine çok sayıda hesaplamada
12345678
Yeni yorum