src/test/test-math-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <float.h>
   4
   5 #include "math-util.h"
   6 #include "tests.h"
   7
   8 TEST(iszero_safe) {
   9         /* zeros */
  10         assert_se(iszero_safe(0.0));
  11         assert_se(iszero_safe(-0.0));
  12         assert_se(iszero_safe(0e0));
  13         assert_se(iszero_safe(-0e0));
  14         assert_se(iszero_safe(0e+0));
  15         assert_se(iszero_safe(0e-0));
  16         assert_se(iszero_safe(-0e-0));
  17         assert_se(iszero_safe(-0e000));
  18         assert_se(iszero_safe(0e000));
  19
  20         /* non-zero normal values */
  21         assert_se(!iszero_safe(42.0));
  22         assert_se(!iszero_safe(M_PI));
  23         assert_se(!iszero_safe(DBL_MAX));
  24         assert_se(!iszero_safe(-DBL_MAX));
  25         assert_se(!iszero_safe(DBL_MIN));
  26         assert_se(!iszero_safe(-DBL_MIN));
  27         assert_se(!iszero_safe(1 / DBL_MAX));
  28
  29         /* subnormal values */
  30         assert_se(!iszero_safe(DBL_MIN / 2));
  31         assert_se(!iszero_safe(-DBL_MIN / 42));
  32         assert_se(!iszero_safe(1 / DBL_MAX / 2));
  33
  34         /* too small values which cannot be in subnormal form */
  35         assert_se( iszero_safe(DBL_MIN / DBL_MAX));
  36         assert_se( iszero_safe(DBL_MIN / -DBL_MAX));
  37         assert_se( iszero_safe(-DBL_MIN / DBL_MAX));
  38         assert_se( iszero_safe(-DBL_MIN / -DBL_MAX));
  39
  40         /* NaN or infinity */
  41         assert_se(!iszero_safe(NAN));
  42         assert_se(!iszero_safe(INFINITY));
  43         assert_se(!iszero_safe(-INFINITY));
  44         assert_se(!iszero_safe(1 / NAN));
  45
  46         /* inverse of infinity */
  47         assert_se( iszero_safe(1 / INFINITY));
  48         assert_se( iszero_safe(1 / -INFINITY));
  49         assert_se( iszero_safe(-1 / INFINITY));
  50         assert_se( iszero_safe(-1 / -INFINITY));
  51         assert_se( iszero_safe(42 / -INFINITY));
  52         assert_se( iszero_safe(-42 / -INFINITY));
  53         assert_se( iszero_safe(DBL_MIN / INFINITY));
  54         assert_se( iszero_safe(DBL_MIN / -INFINITY));
  55         assert_se( iszero_safe(DBL_MAX / INFINITY / 2));
  56         assert_se( iszero_safe(DBL_MAX / -INFINITY * DBL_MAX));
  57 #if defined(__i386__) && !defined(__SSE2_MATH__)
  58         /* On 32bit x86, -mfpmath=387 is the default and SSE2 is not used. Then, floating point values are
  59          * calculated in 80bit, and truncated to the length of the used type (double in this case). Hence,
  60          * DBL_MAX * 2 is temporary calculated as a normal value, and goes to zero when divided with
  61          * INFINITY. See issue #25044. */
  62         log_debug("i386 architecture without SSE2 is detected. "
  63                   "Skipping \"assert_se(!iszero_safe(DBL_MAX * 2 / INFINITY))\".");
  64 #else
  65         assert_se(!iszero_safe(DBL_MAX * 2 / INFINITY));
  66 #endif
  67
  68         /* infinity / infinity is NaN */
  69         assert_se(!iszero_safe(INFINITY / INFINITY));
  70         assert_se(!iszero_safe(INFINITY * 2 / INFINITY));
  71         assert_se(!iszero_safe(INFINITY / DBL_MAX / INFINITY));
  72 }
  73
  74 TEST(fp_equal) {
  75         /* normal values */
  76         assert_se( fp_equal(0.0, -0e0));
  77         assert_se( fp_equal(3.0, 3));
  78         assert_se(!fp_equal(3.000001, 3));
  79         assert_se( fp_equal(M_PI, M_PI));
  80         assert_se(!fp_equal(M_PI, -M_PI));
  81         assert_se( fp_equal(DBL_MAX, DBL_MAX));
  82         assert_se(!fp_equal(DBL_MAX, -DBL_MAX));
  83         assert_se(!fp_equal(-DBL_MAX, DBL_MAX));
  84         assert_se( fp_equal(-DBL_MAX, -DBL_MAX));
  85         assert_se( fp_equal(DBL_MIN, DBL_MIN));
  86         assert_se(!fp_equal(DBL_MIN, -DBL_MIN));
  87         assert_se(!fp_equal(-DBL_MIN, DBL_MIN));
  88         assert_se( fp_equal(-DBL_MIN, -DBL_MIN));
  89
  90         /* subnormal values */
  91         assert_se( fp_equal(DBL_MIN / 10, DBL_MIN / 10));
  92         assert_se(!fp_equal(DBL_MIN / 10, -DBL_MIN / 10));
  93         assert_se(!fp_equal(-DBL_MIN / 10, DBL_MIN / 10));
  94         assert_se( fp_equal(-DBL_MIN / 10, -DBL_MIN / 10));
  95         assert_se(!fp_equal(DBL_MIN / 10, DBL_MIN / 15));
  96         assert_se(!fp_equal(DBL_MIN / 10, DBL_MIN / 15));
  97
  98         /* subnormal difference */
  99         assert_se(!fp_equal(DBL_MIN / 10, DBL_MIN + DBL_MIN / 10));
 100         assert_se( fp_equal(3.0, 3.0 + DBL_MIN / 2)); /* 3.0 + DBL_MIN / 2 is truncated to 3.0 */
 101
 102         /* too small values */
 103         assert_se( fp_equal(DBL_MIN / DBL_MAX, -DBL_MIN / DBL_MAX));
 104
 105         /* NaN or infinity */
 106         assert_se(!fp_equal(NAN, NAN));
 107         assert_se(!fp_equal(NAN, 0));
 108         assert_se(!fp_equal(NAN, INFINITY));
 109         assert_se(!fp_equal(INFINITY, INFINITY));
 110         assert_se(!fp_equal(INFINITY, -INFINITY));
 111         assert_se(!fp_equal(-INFINITY, INFINITY));
 112         assert_se(!fp_equal(-INFINITY, -INFINITY));
 113
 114         /* inverse of infinity */
 115         assert_se( fp_equal(0, 1 / INFINITY));
 116         assert_se( fp_equal(42 / INFINITY, 1 / -INFINITY));
 117         assert_se(!fp_equal(42 / INFINITY, INFINITY / INFINITY));
 118 }
 119
 120 DEFINE_TEST_MAIN(LOG_DEBUG);