//+------------------------------------------------------------------+
//|                                                    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!

*/