357 lines
No EOL
29 KiB
MQL5
357 lines
No EOL
29 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| math_test.mq5 |
|
|
//| Copyright © 2018, Amr Ali |
|
|
//| https://www.mql5.com/en/users/amrali |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright © 2018, Amr Ali"
|
|
#property link "https://www.mql5.com/en/users/amrali"
|
|
#property version "4.0"
|
|
#property description "A script to test math_utils library."
|
|
|
|
#include <math_utils.mqh>
|
|
//+------------------------------------------------------------------+
|
|
//| Only failed tests should print an error message. |
|
|
//+------------------------------------------------------------------+
|
|
#define ASSERT(booleanExpression) \
|
|
if(!(booleanExpression)) Print("line ",__LINE__,": assertion failed ",#booleanExpression)
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void OnStart()
|
|
{
|
|
Print("** Testing loose comparisons");
|
|
//--- difference < 0.5 price point
|
|
ASSERT( EQ(1.1239, 1.1236, 3) == true );
|
|
ASSERT( NE(1.1239, 1.1236, 3) == false );
|
|
ASSERT( GT(1.1239, 1.1236, 3) == false );
|
|
ASSERT( LT(1.1239, 1.1236, 3) == false );
|
|
ASSERT( GTE(1.1239, 1.1236, 3) == true );
|
|
ASSERT( LTE(1.1239, 1.1236, 3) == true );
|
|
|
|
//--- difference >= 0.5 price point
|
|
ASSERT( EQ(1.1239, 1.1231, 3) == false );
|
|
ASSERT( NE(1.1239, 1.1231, 3) == true );
|
|
ASSERT( GT(1.1239, 1.1231, 3) == true );
|
|
ASSERT( LT(1.1239, 1.1231, 3) == false );
|
|
ASSERT( GTE(1.1239, 1.1231, 3) == true );
|
|
ASSERT( LTE(1.1239, 1.1231, 3) == false );
|
|
|
|
//--- difference <= 1 epsilon
|
|
ASSERT( 0.1 + 0.2 != 0.3 );
|
|
ASSERT( AlmostEqual(0.1 + 0.2, 0.3) );
|
|
|
|
Print("** Testing round to digits");
|
|
//--- testing simple cases
|
|
ASSERT( Round(5.12, 1) == 5.1 );
|
|
ASSERT( Round(-5.12, 1) == -5.1 );
|
|
ASSERT( Ceil(5.12, 1) == 5.2 );
|
|
ASSERT( Ceil(-5.12, 1) == -5.1 );
|
|
ASSERT( Floor(5.12, 1) == 5.1 );
|
|
ASSERT( Floor(-5.12, 1) == -5.2 );
|
|
|
|
//--- testing very small numbers
|
|
ASSERT( Ceil(1e-8, 2) == 0.01 );
|
|
ASSERT( Floor(1e-8, 2) == 0 );
|
|
|
|
//--- testing edge cases for round
|
|
ASSERT( Round(1.005, 2) == 1.01 );
|
|
ASSERT( Round(39.425, 2) == 39.43 );
|
|
ASSERT( Round(-1.005, 2) == -1.01 );
|
|
ASSERT( Round(-39.425, 2) == -39.43 );
|
|
|
|
//--- testing edge cases for ceil
|
|
ASSERT( Ceil(9.130, 2) == 9.13 );
|
|
ASSERT( Ceil(65.180, 2) == 65.18 );
|
|
ASSERT( Ceil(-2.260, 2) == -2.26 );
|
|
ASSERT( Ceil(-18.150, 2) == -18.15 );
|
|
ASSERT( Ceil((0.1+0.2)*10, 0) == 3 );
|
|
|
|
//--- testing edge cases for floor
|
|
ASSERT( Floor(2.260, 2) == 2.26 );
|
|
ASSERT( Floor(18.150, 2) == 18.15 );
|
|
ASSERT( Floor(-9.130, 2) == -9.13 );
|
|
ASSERT( Floor(-65.180, 2) == -65.18 );
|
|
ASSERT( Floor((0.1+0.7)*10, 0) == 8 );
|
|
|
|
Print("** Testing round to step");
|
|
//--- testing simple cases
|
|
ASSERT( Round(5.12, 0.1) == 5.1 );
|
|
ASSERT( Round(-5.12, 0.1) == -5.1 );
|
|
ASSERT( Ceil(5.12, 0.1) == 5.2 );
|
|
ASSERT( Ceil(-5.12, 0.1) == -5.1 );
|
|
ASSERT( Floor(5.12, 0.1) == 5.1 );
|
|
ASSERT( Floor(-5.12, 0.1) == -5.2 );
|
|
|
|
//--- testing very small numbers
|
|
ASSERT( Ceil(1e-8, 0.01) == 0.01 );
|
|
ASSERT( Floor(1e-8, 0.01) == 0 );
|
|
|
|
//--- testing edge cases for round
|
|
ASSERT( Round(1.005, 0.01) == 1.01 );
|
|
ASSERT( Round(39.425, 0.01) == 39.43 );
|
|
ASSERT( Round(-1.005, 0.01) == -1.01 );
|
|
ASSERT( Round(-39.425, 0.01) == -39.43 );
|
|
|
|
//--- testing edge cases for ceil
|
|
ASSERT( Ceil(9.130, 0.01) == 9.13 );
|
|
ASSERT( Ceil(65.180, 0.01) == 65.18 );
|
|
ASSERT( Ceil(-2.260, 0.01) == -2.26 );
|
|
ASSERT( Ceil(-18.150, 0.01) == -18.15 );
|
|
|
|
//--- testing edge cases for floor
|
|
ASSERT( Floor(2.260, 0.01) == 2.26 );
|
|
ASSERT( Floor(18.150, 0.01) == 18.15 );
|
|
ASSERT( Floor(-9.130, 0.01) == -9.13 );
|
|
ASSERT( Floor(-65.180, 0.01) == -65.18 );
|
|
|
|
Print("** Testing if number rounds exactly to itself");
|
|
|
|
//--- NormalizeDouble(price, digits) sometimes fails this test,
|
|
//--- because its return value may be off by 1 ulp.
|
|
|
|
//--- See example on forum thread "Can price != price ?"
|
|
//--- https://www.mql5.com/en/forum/136997
|
|
|
|
//--- testing round to digits
|
|
ASSERT( 1.14 == Round(1.14, 2) );
|
|
ASSERT( 1.93 == Round(1.93, 2) );
|
|
ASSERT( 1.378 == Round(1.378, 3) );
|
|
ASSERT( 1.757 == Round(1.757, 3) );
|
|
ASSERT( 1.26008 == Round(1.26008, 5) );
|
|
ASSERT( 1.54289 == Round(1.54289, 5) );
|
|
ASSERT( 1.57373 == Round(1.57373, 5) );
|
|
|
|
//--- testing round to step
|
|
ASSERT( 1.14 == Round(1.14, 0.01) );
|
|
ASSERT( 1.93 == Round(1.93, 0.01) );
|
|
ASSERT( 1.378 == Round(1.378, 0.001) );
|
|
ASSERT( 1.757 == Round(1.757, 0.001) );
|
|
ASSERT( 1.26008 == Round(1.26008, 0.00001) );
|
|
ASSERT( 1.54289 == Round(1.54289, 0.00001) );
|
|
ASSERT( 1.57373 == Round(1.57373, 0.00001) );
|
|
|
|
Print("** Testing GetDigits()");
|
|
ASSERT( GetDigits(1) == 0 );
|
|
ASSERT( GetDigits(0.1) == 1 );
|
|
ASSERT( GetDigits(0.01) == 2 );
|
|
ASSERT( GetDigits(0.001) == 3 );
|
|
ASSERT( GetDigits(0.0001) == 4 );
|
|
ASSERT( GetDigits(0.00001) == 5 );
|
|
ASSERT( GetDigits(0.000001) == 6 );
|
|
ASSERT( GetDigits(0.0000001) == 7 );
|
|
ASSERT( GetDigits(0.00000001) == 8 );
|
|
ASSERT( GetDigits(0.000000001) == 9 );
|
|
ASSERT( GetDigits(0.0000000001) == 10 );
|
|
ASSERT( GetDigits(0.00000000001) == 11 );
|
|
ASSERT( GetDigits(0.000000000001) == 12 );
|
|
ASSERT( GetDigits(0.0000000000001) == 13 );
|
|
ASSERT( GetDigits(0.00000000000001) == 14 );
|
|
ASSERT( GetDigits(0.000000000000001) == 15 );
|
|
ASSERT( GetDigits(0.0000000000000001) == 16 );
|
|
ASSERT( GetDigits(0.00000000000000001) == 17 );
|
|
ASSERT( GetDigits(0.000000000000000001) == 18 );
|
|
ASSERT( GetDigits(0.0000000000000000001) == 19 );
|
|
|
|
ASSERT( GetDigits(1) == 0 );
|
|
ASSERT( GetDigits(1.1) == 1 );
|
|
ASSERT( GetDigits(1.12) == 2 );
|
|
ASSERT( GetDigits(1.123) == 3 );
|
|
ASSERT( GetDigits(1.1234) == 4 );
|
|
ASSERT( GetDigits(1.12345) == 5 );
|
|
ASSERT( GetDigits(1.123456) == 6 );
|
|
ASSERT( GetDigits(1.1234567) == 7 );
|
|
ASSERT( GetDigits(1.12345678) == 8 );
|
|
ASSERT( GetDigits(1.123456789) == 9 );
|
|
ASSERT( GetDigits(1.1234567891) == 10 );
|
|
ASSERT( GetDigits(1.12345678912) == 11 );
|
|
ASSERT( GetDigits(1.123456789123) == 12 );
|
|
ASSERT( GetDigits(1.1234567891234) == 13 );
|
|
ASSERT( GetDigits(1.12345678912345) == 14 );
|
|
ASSERT( GetDigits(0.012345678912345) == 15 );
|
|
ASSERT( GetDigits(0.0123456789123456) == 16 );
|
|
ASSERT( GetDigits(0.00123456789123456) == 17 );
|
|
ASSERT( GetDigits(0.000123456789123456) == 18 );
|
|
ASSERT( GetDigits(0.0000123456789123456) == 19 );
|
|
|
|
ASSERT( GetDigits(1.12) == 2 );
|
|
ASSERT( GetDigits(1.14) == 2 );
|
|
ASSERT( GetDigits(1.36) == 2 );
|
|
ASSERT( GetDigits(1.57) == 2 );
|
|
ASSERT( GetDigits(1.93) == 2 );
|
|
ASSERT( GetDigits(1.118) == 3 );
|
|
ASSERT( GetDigits(1.378) == 3 );
|
|
ASSERT( GetDigits(1.757) == 3 );
|
|
ASSERT( GetDigits(1.816) == 3 );
|
|
ASSERT( GetDigits(90.268) == 3 );
|
|
ASSERT( GetDigits(1.0778) == 4 );
|
|
ASSERT( GetDigits(1.0954) == 4 );
|
|
ASSERT( GetDigits(1.2749) == 4 );
|
|
ASSERT( GetDigits(0.85919) == 5 );
|
|
ASSERT( GetDigits(1.09545) == 5 );
|
|
ASSERT( GetDigits(1.26008) == 5 );
|
|
ASSERT( GetDigits(1.27481) == 5 );
|
|
ASSERT( GetDigits(1.27483) == 5 );
|
|
ASSERT( GetDigits(1.27571) == 5 );
|
|
ASSERT( GetDigits(1.30418) == 5 );
|
|
ASSERT( GetDigits(1.42147) == 5 );
|
|
ASSERT( GetDigits(1.54289) == 5 );
|
|
ASSERT( GetDigits(1.56849) == 5 );
|
|
ASSERT( GetDigits(1.61465) == 5 );
|
|
ASSERT( GetDigits(1.69292) == 5 );
|
|
ASSERT( GetDigits(1.005) == 3 );
|
|
ASSERT( GetDigits(1.275) == 3 );
|
|
ASSERT( GetDigits(2.175) == 3 );
|
|
ASSERT( GetDigits(4.015) == 3 );
|
|
ASSERT( GetDigits(4.475) == 3 );
|
|
ASSERT( GetDigits(4.515) == 3 );
|
|
ASSERT( GetDigits(2.0315) == 4 );
|
|
ASSERT( GetDigits(4.0005) == 4 );
|
|
ASSERT( GetDigits(4.0245) == 4 );
|
|
ASSERT( GetDigits(4.0485) == 4 );
|
|
ASSERT( GetDigits(4.0535) == 4 );
|
|
ASSERT( GetDigits(4.0745) == 4 );
|
|
ASSERT( GetDigits(4.0855) == 4 );
|
|
ASSERT( GetDigits(4.0905) == 4 );
|
|
ASSERT( GetDigits(1.03015) == 5 );
|
|
ASSERT( GetDigits(1.10065) == 5 );
|
|
ASSERT( GetDigits(1.21555) == 5 );
|
|
ASSERT( GetDigits(1.31245) == 5 );
|
|
ASSERT( GetDigits(1.31435) == 5 );
|
|
ASSERT( GetDigits(1.44555) == 5 );
|
|
ASSERT( GetDigits(1.52005) == 5 );
|
|
ASSERT( GetDigits(1.62085) == 5 );
|
|
ASSERT( GetDigits(1.064315) == 6 );
|
|
ASSERT( GetDigits(1.157795) == 6 );
|
|
ASSERT( GetDigits(1.198775) == 6 );
|
|
ASSERT( GetDigits(1.275305) == 6 );
|
|
|
|
Print("** Testing GetSignificantDigits()");
|
|
ASSERT( GetSignificantDigits(0) == 0 );
|
|
ASSERT( GetSignificantDigits(4) == 1 );
|
|
ASSERT( GetSignificantDigits(1234) == 4 );
|
|
ASSERT( GetSignificantDigits(54321) == 5 );
|
|
ASSERT( GetSignificantDigits(1.12345) == 6 );
|
|
ASSERT( GetSignificantDigits(123.1234) == 7 );
|
|
ASSERT( GetSignificantDigits(123.12345) == 8 );
|
|
ASSERT( GetSignificantDigits(127.12345) == 8 );
|
|
ASSERT( GetSignificantDigits(123.001234) == 9 );
|
|
ASSERT( GetSignificantDigits(1.000001234) == 10 );
|
|
ASSERT( GetSignificantDigits(1.0000012345) == 11 );
|
|
ASSERT( GetSignificantDigits(0.000001234) == 4 );
|
|
ASSERT( GetSignificantDigits(0.0000012345) == 5 );
|
|
ASSERT( GetSignificantDigits(0.000001234915) == 7 );
|
|
ASSERT( GetSignificantDigits(0.1234567e-20) == 7 );
|
|
ASSERT( GetSignificantDigits(0.12345672e-20) == 8 );
|
|
ASSERT( GetSignificantDigits(0.12345677777777e-20) == 15 );
|
|
ASSERT( GetSignificantDigits(DBL_EPSILON) == 16 );
|
|
ASSERT( GetSignificantDigits(double("nan")) == 0 );
|
|
|
|
ASSERT( GetSignificantDigits(1) == 1 );
|
|
ASSERT( GetSignificantDigits(0.1) == 1 );
|
|
ASSERT( GetSignificantDigits(0.01) == 1 );
|
|
ASSERT( GetSignificantDigits(0.001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.00001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.00000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.00000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.00000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.000000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0000000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.00000000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.000000000000000001) == 1 );
|
|
ASSERT( GetSignificantDigits(0.0000000000000000001) == 1 );
|
|
|
|
ASSERT( GetSignificantDigits(1) == 1 );
|
|
ASSERT( GetSignificantDigits(1.1) == 2 );
|
|
ASSERT( GetSignificantDigits(1.12) == 3 );
|
|
ASSERT( GetSignificantDigits(1.123) == 4 );
|
|
ASSERT( GetSignificantDigits(1.1234) == 5 );
|
|
ASSERT( GetSignificantDigits(1.12345) == 6 );
|
|
ASSERT( GetSignificantDigits(1.123456) == 7 );
|
|
ASSERT( GetSignificantDigits(1.1234567) == 8 );
|
|
ASSERT( GetSignificantDigits(1.12345678) == 9 );
|
|
ASSERT( GetSignificantDigits(1.123456789) == 10 );
|
|
ASSERT( GetSignificantDigits(1.1234567891) == 11 );
|
|
ASSERT( GetSignificantDigits(1.12345678912) == 12 );
|
|
ASSERT( GetSignificantDigits(1.123456789123) == 13 );
|
|
ASSERT( GetSignificantDigits(1.1234567891234) == 14 );
|
|
ASSERT( GetSignificantDigits(1.12345678912345) == 15 );
|
|
ASSERT( GetSignificantDigits(0.012345678912345) == 14 );
|
|
ASSERT( GetSignificantDigits(0.0123456789123456) == 15 );
|
|
ASSERT( GetSignificantDigits(0.00123456789123456) == 15 );
|
|
ASSERT( GetSignificantDigits(0.000123456789123456) == 15 );
|
|
ASSERT( GetSignificantDigits(0.0000123456789123456) == 15 );
|
|
|
|
ASSERT( GetSignificantDigits(1.12) == 3 );
|
|
ASSERT( GetSignificantDigits(1.14) == 3 );
|
|
ASSERT( GetSignificantDigits(1.36) == 3 );
|
|
ASSERT( GetSignificantDigits(1.57) == 3 );
|
|
ASSERT( GetSignificantDigits(1.93) == 3 );
|
|
ASSERT( GetSignificantDigits(1.118) == 4 );
|
|
ASSERT( GetSignificantDigits(1.378) == 4 );
|
|
ASSERT( GetSignificantDigits(1.757) == 4 );
|
|
ASSERT( GetSignificantDigits(1.816) == 4 );
|
|
ASSERT( GetSignificantDigits(90.268) == 5 );
|
|
ASSERT( GetSignificantDigits(1.0778) == 5 );
|
|
ASSERT( GetSignificantDigits(1.0954) == 5 );
|
|
ASSERT( GetSignificantDigits(1.2749) == 5 );
|
|
ASSERT( GetSignificantDigits(0.85919) == 5 );
|
|
ASSERT( GetSignificantDigits(1.09545) == 6 );
|
|
ASSERT( GetSignificantDigits(1.26008) == 6 );
|
|
ASSERT( GetSignificantDigits(1.27481) == 6 );
|
|
ASSERT( GetSignificantDigits(1.27483) == 6 );
|
|
ASSERT( GetSignificantDigits(1.27571) == 6 );
|
|
ASSERT( GetSignificantDigits(1.30418) == 6 );
|
|
ASSERT( GetSignificantDigits(1.42147) == 6 );
|
|
ASSERT( GetSignificantDigits(1.54289) == 6 );
|
|
ASSERT( GetSignificantDigits(1.56849) == 6 );
|
|
ASSERT( GetSignificantDigits(1.61465) == 6 );
|
|
ASSERT( GetSignificantDigits(1.69292) == 6 );
|
|
ASSERT( GetSignificantDigits(1.005) == 4 );
|
|
ASSERT( GetSignificantDigits(1.275) == 4 );
|
|
ASSERT( GetSignificantDigits(2.175) == 4 );
|
|
ASSERT( GetSignificantDigits(4.015) == 4 );
|
|
ASSERT( GetSignificantDigits(4.475) == 4 );
|
|
ASSERT( GetSignificantDigits(4.515) == 4 );
|
|
ASSERT( GetSignificantDigits(2.0315) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0005) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0245) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0485) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0535) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0745) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0855) == 5 );
|
|
ASSERT( GetSignificantDigits(4.0905) == 5 );
|
|
ASSERT( GetSignificantDigits(1.03015) == 6 );
|
|
ASSERT( GetSignificantDigits(1.10065) == 6 );
|
|
ASSERT( GetSignificantDigits(1.21555) == 6 );
|
|
ASSERT( GetSignificantDigits(1.31245) == 6 );
|
|
ASSERT( GetSignificantDigits(1.31435) == 6 );
|
|
ASSERT( GetSignificantDigits(1.44555) == 6 );
|
|
ASSERT( GetSignificantDigits(1.52005) == 6 );
|
|
ASSERT( GetSignificantDigits(1.62085) == 6 );
|
|
ASSERT( GetSignificantDigits(1.064315) == 7 );
|
|
ASSERT( GetSignificantDigits(1.157795) == 7 );
|
|
ASSERT( GetSignificantDigits(1.198775) == 7 );
|
|
ASSERT( GetSignificantDigits(1.275305) == 7 );
|
|
|
|
Print("All tests were passed successfully!");
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
/*
|
|
** Testing loose comparisons
|
|
** Testing round to digits
|
|
** Testing round to step
|
|
** Testing if number rounds exactly to itself
|
|
** Testing GetDigits()
|
|
** Testing GetSignificantDigits()
|
|
All tests were passed successfully!
|
|
|
|
*/ |