mono/mini/basic-math.cs

   1 using System;
   2 using System.Reflection;
   3
   4 /*
   5  * Regression tests for the mono JIT.
   6  *
   7  * Each test needs to be of the form:
   8  *
   9  * public static int test_<result>_<name> ();
  10  *
  11  * where <result> is an integer (the value that needs to be returned by
  12  * the method to make it pass.
  13  * <name> is a user-displayed name used to identify the test.
  14  *
  15  * The tests can be driven in two ways:
  16  * *) running the program directly: Main() uses reflection to find and invoke
  17  *      the test methods (this is useful mostly to check that the tests are correct)
  18  * *) with the --regression switch of the jit (this is the preferred way since
  19  *      all the tests will be run with optimizations on and off)
  20  *
  21  * The reflection logic could be moved to a .dll since we need at least another
  22  * regression test file written in IL code to have better control on how
  23  * the IL code looks.
  24  */
  25
  26 #if __MOBILE__
  27 class MathTests
  28 #else
  29 class Tests
  30 #endif
  31 {
  32
  33 #if !__MOBILE__
  34         public static int Main (string[] args) {
  35                 return TestDriver.RunTests (typeof (Tests), args);
  36         }
  37 #endif
  38
  39         public static int test_0_sin_precision () {
  40                 double d1 = Math.Sin (1);
  41                 double d2 = Math.Sin (1) - d1;
  42                 return (d2 == 0) ? 0 : 1;
  43         }
  44
  45         public static int test_0_cos_precision () {
  46                 double d1 = Math.Cos (1);
  47                 double d2 = Math.Cos (1) - d1;
  48                 return (d2 == 0) ? 0 : 1;
  49         }
  50
  51         public static int test_0_tan_precision () {
  52                 double d1 = Math.Tan (1);
  53                 double d2 = Math.Tan (1) - d1;
  54                 return (d2 == 0) ? 0 : 1;
  55         }
  56
  57         public static int test_0_atan_precision () {
  58                 double d1 = Math.Atan (double.NegativeInfinity);
  59                 double d2 = Math.Atan (double.NegativeInfinity) - d1;
  60                 return (d2 == 0) ? 0 : 1;
  61         }
  62
  63         public static int test_0_sqrt_precision () {
  64                 double d1 = Math.Sqrt (2);
  65                 double d2 = Math.Sqrt (2) - d1;
  66                 return (d2 == 0) ? 0 : 1;
  67         }
  68
  69         public static int test_2_sqrt () {
  70                 return (int) Math.Sqrt (4);
  71         }
  72         public static int test_0_sqrt_precision_and_not_spill () {
  73                 double expected = 0;
  74                 double[] operands = new double[3];
  75                 double[] temporaries = new double[3];
  76                 for (int i = 0; i < 3; i++) {
  77                         operands [i] = (i+1) * (i+1) * (i+1);
  78                         if (i == 0) {
  79                                 expected = operands [0];
  80                         } else {
  81                                 temporaries [i] =  operands [i] / expected;
  82                                 temporaries [i] = Math.Sqrt (temporaries [i]);
  83                                 expected = temporaries [i];
  84                         }
  85
  86                         //Console.Write( "{0}: {1}\n", i, temporaries [i] );
  87                 }
  88                 expected = temporaries [2];
  89
  90                 double result = Math.Sqrt (operands [2] / Math.Sqrt (operands [1] / operands [0]));
  91
  92                 //Console.Write( "result: {0,20:G}\n", result );
  93
  94                 return (result == expected) ? 0 : 1;
  95         }
  96
  97         public static int test_0_sqrt_precision_and_spill () {
  98                 double expected = 0;
  99                 double[] operands = new double[9];
 100                 double[] temporaries = new double[9];
 101                 for (int i = 0; i < 9; i++) {
 102                         operands [i] = (i+1) * (i+1) * (i+1);
 103                         if (i == 0) {
 104                                 expected = operands [0];
 105                         } else {
 106                                 temporaries [i] =  operands [i] / expected;
 107                                 temporaries [i] = Math.Sqrt (temporaries [i]);
 108                                 expected = temporaries [i];
 109                         }
 110
 111                         //Console.Write( "{0}: {1}\n", i, temporaries [i] );
 112                 }
 113                 expected = temporaries [8];
 114
 115                 double result = Math.Sqrt (operands [8] / Math.Sqrt (operands [7] / Math.Sqrt (operands [6] / Math.Sqrt (operands [5] / Math.Sqrt (operands [4] / Math.Sqrt (operands [3] / Math.Sqrt (operands [2] / Math.Sqrt (operands [1] / operands [0]))))))));
 116
 117                 //Console.Write( "result: {0,20:G}\n", result );
 118
 119                 return (result == expected) ? 0 : 1;
 120         }
 121
 122         public static int test_0_div_precision_and_spill () {
 123                 double expected = 0;
 124                 double[] operands = new double[9];
 125                 double[] temporaries = new double[9];
 126                 for (int i = 0; i < 9; i++) {
 127                         operands [i] = (i+1) * (i+1);
 128                         if (i == 0) {
 129                                 expected = operands [0];
 130                         } else {
 131                                 temporaries [i] =  operands [i] / expected;
 132                                 expected = temporaries [i];
 133                         }
 134
 135                         //Console.Write( "{0}: {1}\n", i, temporaries [i] );
 136                 }
 137                 expected = temporaries [8];
 138
 139                 double result = (operands [8] / (operands [7] / (operands [6] / (operands [5] / (operands [4] / (operands [3] / (operands [2] / (operands [1] / operands [0]))))))));
 140
 141                 //Console.Write( "result: {0,20:G}\n", result );
 142
 143                 return (result == expected) ? 0 : 1;
 144         }
 145
 146         public static int test_0_sqrt_nan () {
 147                 return Double.IsNaN (Math.Sqrt (Double.NaN)) ? 0 : 1;
 148         }
 149
 150         public static int test_0_sin_nan () {
 151                 return Double.IsNaN (Math.Sin (Double.NaN)) ? 0 : 1;
 152         }
 153
 154         public static int test_0_cos_nan () {
 155                 return Double.IsNaN (Math.Cos (Double.NaN)) ? 0 : 1;
 156         }
 157
 158         public static int test_0_tan_nan () {
 159                 return Double.IsNaN (Math.Tan (Double.NaN)) ? 0 : 1;
 160         }
 161
 162         public static int test_0_atan_nan () {
 163                 return Double.IsNaN (Math.Atan (Double.NaN)) ? 0 : 1;
 164         }
 165
 166         public static int test_0_min () {
 167                 if (Math.Min (5, 6) != 5)
 168                         return 1;
 169                 if (Math.Min (6, 5) != 5)
 170                         return 2;
 171                 if (Math.Min (-100, -101) != -101)
 172                         return 3;
 173                 if (Math.Min ((long)5, (long)6) != 5)
 174                         return 4;
 175                 if (Math.Min ((long)6, (long)5) != 5)
 176                         return 5;
 177                 if (Math.Min ((long)-100, (long)-101) != -101)
 178                         return 6;
 179                 // this will trip if Min is accidentally using unsigned/logical comparison
 180                 if (Math.Min((long)-100000000000L, (long)0L) != (long)-100000000000L)
 181                         return 7;
 182                 return 0;
 183         }
 184
 185         public static int test_0_max () {
 186                 if (Math.Max (5, 6) != 6)
 187                         return 1;
 188                 if (Math.Max (6, 5) != 6)
 189                         return 2;
 190                 if (Math.Max (-100, -101) != -100)
 191                         return 3;
 192                 if (Math.Max ((long)5, (long)6) != 6)
 193                         return 4;
 194                 if (Math.Max ((long)6, (long)5) != 6)
 195                         return 5;
 196                 if (Math.Max ((long)-100, (long)-101) != -100)
 197                         return 6;
 198                 // this will trip if Max is accidentally using unsigned/logical comparison
 199                 if (Math.Max((long)-100000000000L, (long)0L) != (long)0L)
 200                         return 7;
 201                 return 0;
 202         }
 203
 204         public static int test_0_min_un () {
 205                 uint a = (uint)int.MaxValue + 10;
 206
 207                 for (uint b = 7; b <= 10; ++b) {
 208                         if (Math.Min (a, b) != b)
 209                                 return (int)b;
 210                         if (Math.Min (b, a) != b)
 211                                 return (int)b;
 212                 }
 213
 214                 if (Math.Min ((ulong)5, (ulong)6) != 5)
 215                         return 4;
 216                 if (Math.Min ((ulong)6, (ulong)5) != 5)
 217                         return 5;
 218
 219                 ulong la = (ulong)long.MaxValue + 10;
 220
 221                 for (ulong b = 7; b <= 10; ++b) {
 222                         if (Math.Min (la, b) != b)
 223                                 return (int)b;
 224                         if (Math.Min (b, la) != b)
 225                                 return (int)b;
 226                 }
 227
 228                 return 0;
 229         }
 230
 231         public static int test_0_max_un () {
 232                 uint a = (uint)int.MaxValue + 10;
 233
 234                 for (uint b = 7; b <= 10; ++b) {
 235                         if (Math.Max (a, b) != a)
 236                                 return (int)b;
 237                         if (Math.Max (b, a) != a)
 238                                 return (int)b;
 239                 }
 240
 241                 if (Math.Max ((ulong)5, (ulong)6) != 6)
 242                         return 4;
 243                 if (Math.Max ((ulong)6, (ulong)5) != 6)
 244                         return 5;
 245
 246                 ulong la = (ulong)long.MaxValue + 10;
 247
 248                 for (ulong b = 7; b <= 10; ++b) {
 249                         if (Math.Max (la, b) != la)
 250                                 return (int)b;
 251                         if (Math.Max (b, la) != la)
 252                                 return (int)b;
 253                 }
 254
 255                 return 0;
 256         }
 257
 258         public static int test_0_abs () {
 259                 double d = -5.0;
 260
 261                 if (Math.Abs (d) != 5.0)
 262                         return 1;
 263                 return 0;
 264         }
 265
 266         public static int test_0_float_abs () {
 267                 float f = -1.0f;
 268
 269                 if (Math.Abs (f) != 1.0f)
 270                         return 1;
 271                 return 0;
 272         }
 273
 274         public static int test_0_round () {
 275                 if (Math.Round (5.0) != 5.0)
 276                         return 1;
 277
 278                 if (Math.Round (5.000000000000001) != 5.0)
 279                         return 2;
 280
 281                 if (Math.Round (5.499999999999999) != 5.0)
 282                         return 3;
 283
 284                 if (Math.Round (5.5) != 6.0)
 285                         return 4;
 286
 287                 if (Math.Round (5.999999999999999) != 6.0)
 288                         return 5;
 289
 290                 if (Math.Round (Double.Epsilon) != 0)
 291                         return 6;
 292
 293                 if (!Double.IsNaN (Math.Round (Double.NaN)))
 294                         return 7;
 295
 296                 if (!Double.IsPositiveInfinity (Math.Round (Double.PositiveInfinity)))
 297                         return 8;
 298
 299                 if (!Double.IsNegativeInfinity (Math.Round (Double.NegativeInfinity)))
 300                         return 9;
 301
 302                 if (Math.Round (Double.MinValue) != Double.MinValue)
 303                         return 10;
 304
 305                 if (Math.Round (Double.MaxValue) != Double.MaxValue)
 306                         return 11;
 307
 308                 return 0;
 309         }
 310
 311         public static int test_0_mathf_sin () {
 312                 float f = MathF.Sin (3.14159f);
 313                 return f < 0.01f ? 0 : 1;
 314         }
 315
 316         public static int test_0_mathf_cos () {
 317                 float f = MathF.Cos (3.14159f);
 318                 return f - -1f < 0.01f ? 0 : 1;
 319         }
 320
 321         public static int test_0_mathf_abs () {
 322                 float f;
 323
 324                 f = MathF.Abs (2.25f) - 2.25f;
 325                 if (f > 0.01f || f < -0.01f)
 326                         return 1;
 327                 f = MathF.Abs (-2.25f) - 2.25f;
 328                 if (f > 0.01f || f < -0.01f)
 329                         return 2;
 330                 return 0;
 331         }
 332
 333         public static int test_0_mathf_sqrt () {
 334                 float f;
 335
 336                 f = MathF.Sqrt (16.0f) - 4.0f;
 337                 if (f > 0.01f || f < -0.01f)
 338                         return 1;
 339                 return 0;
 340         }
 341
 342         public static int test_0_mathf_max () {
 343                 float f;
 344
 345                 f = MathF.Max (1.0f, 2.0f) - 2.0f;
 346                 if (f > 0.01f || f < -0.01f)
 347                         return 1;
 348                 f = MathF.Max (2.0f, 1.0f) - 2.0f;
 349                 if (f > 0.01f || f < -0.01f)
 350                         return 2;
 351                 return 0;
 352         }
 353
 354         public static int test_0_mathf_pow () {
 355                 float f;
 356
 357                 f = MathF.Pow (2.0f, 4.0f) - 16.0f;
 358                 if (f > 0.01f || f < -0.01f)
 359                         return 1;
 360                 return 0;
 361         }
 362 }