C++ (Cpp) BEGIN_LONG_DOUBLE_ROUNDING Examples

Example #1

File: test-truncl-ieee.c Project: Chainfire/android-ndk-compression-tools

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* See IEEE 754, section 6.3:
       "the sign of the result of the round floating-point number to
        integral value operation is the sign of the operand. These rules
        shall apply even when operands or results are zero or infinite."  */

  /* Zero.  */
  ASSERT (!signbit (truncl (0.0L)));
  ASSERT (!!signbit (truncl (minus_zerol)) == !!signbit (minus_zerol));
  /* Positive numbers.  */
  ASSERT (!signbit (truncl (0.3L)));
  ASSERT (!signbit (truncl (0.7L)));
  /* Negative numbers.  */
  ASSERT (!!signbit (truncl (-0.3L)) == !!signbit (minus_zerol));
  ASSERT (!!signbit (truncl (-0.7L)) == !!signbit (minus_zerol));

  /* [MX] shaded specification in POSIX.  */

  /* NaN.  */
  ASSERT (isnanl (truncl (NaNl ())));
  /* Infinity.  */
  ASSERT (truncl (Infinityl ()) == Infinityl ());
  ASSERT (truncl (- Infinityl ()) == - Infinityl ());

  return 0;
}

Example #2

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = sqrtl (x);
  ASSERT (y >= 0.7745966692L && y <= 0.7745966693L);

  /* Another particular value.  */
  {
    long double z;
    long double err;

    x = 8.1974099812331540680810141969554806865L;
    y = sqrtl (x);
    z = y * y - x;
    err = my_ldexpl (z, LDBL_MANT_DIG);
    if (err < 0)
      err = - err;
    ASSERT (err <= 100.0L);
  }

  test_function ();

  return 0;
}

Example #3

File: test-rintl.c Project: ajnelson/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* Consider the current rounding mode, cf.
     <http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/float.h.html>  */
  if (FLT_ROUNDS == 1)
    {
      /* The current rounding mode is round-to-nearest
         (the default in IEEE 754).  */

      /* Zero.  */
      ASSERT (rintl (0.0L) == 0.0L);
      ASSERT (rintl (minus_zerol) == 0.0L);
      /* Positive numbers.  */
      ASSERT (rintl (0.3L) == 0.0L);
      ASSERT (rintl (0.5L) == 0.0L); /* unlike roundl() */
      ASSERT (rintl (0.7L) == 1.0L);
      ASSERT (rintl (1.0L) == 1.0L);
      ASSERT (rintl (1.5L) == 2.0L);
      ASSERT (rintl (1.999L) == 2.0L);
      ASSERT (rintl (2.0L) == 2.0L);
      ASSERT (rintl (2.1L) == 2.0L);
      ASSERT (rintl (2.5L) == 2.0L); /* unlike roundl() */
      ASSERT (rintl (2.7L) == 3.0L);
      ASSERT (rintl (65535.999L) == 65536.0L);
      ASSERT (rintl (65536.0L) == 65536.0L);
      ASSERT (rintl (65536.001L) == 65536.0L);
      ASSERT (rintl (2.341e31L) == 2.341e31L);
      /* Negative numbers.  */
      ASSERT (rintl (-0.3L) == 0.0L);
      ASSERT (rintl (-0.5L) == 0.0L); /* unlike roundl() */
      ASSERT (rintl (-0.7L) == -1.0L);
      ASSERT (rintl (-1.0L) == -1.0L);
      ASSERT (rintl (-1.5L) == -2.0L);
      ASSERT (rintl (-1.999L) == -2.0L);
      ASSERT (rintl (-2.0L) == -2.0L);
      ASSERT (rintl (-2.1L) == -2.0L);
      ASSERT (rintl (-2.5L) == -2.0L); /* unlike roundl() */
      ASSERT (rintl (-2.7L) == -3.0L);
      ASSERT (rintl (-65535.999L) == -65536.0L);
      ASSERT (rintl (-65536.0L) == -65536.0L);
      ASSERT (rintl (-65536.001L) == -65536.0L);
      ASSERT (rintl (-2.341e31L) == -2.341e31L);

      test_function ();

      return 0;
    }
  else
    {
      fputs ("Skipping test: non-standard rounding mode\n", stderr);
      return 77;
    }
}

Example #4

File: test-fmal1.c Project: miyamuko/git-merge-changelog-for-windows

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  test_function (fmal);

  return 0;
}

Example #5

File: test-cosl.c Project: djmitche/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = cosl (x);
  ASSERT (y >= 0.8253356149L && y <= 0.8253356150L);

  return 0;
}

Example #6

File: test-acosl.c Project: djmitche/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = acosl (x);
  ASSERT (y >= 0.9272952180L && y <= 0.9272952181L);

  return 0;
}

Example #7

File: test-atanl.c Project: miyamuko/git-merge-changelog-for-windows

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = atanl (x);
  ASSERT (y >= 0.5404195002L && y <= 0.5404195003L);

  return 0;
}

Example #8

File: test-sinl.c Project: Distrotech/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = sinl (x);
  ASSERT (y >= 0.5646424733L && y <= 0.5646424734L);

  return 0;
}

Example #9

File: test-tanl.c Project: ajnelson/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = tanl (x);
  ASSERT (y >= 0.6841368083L && y <= 0.6841368084L);

  return 0;
}

Example #10

File: test-sqrtl.c Project: djmitche/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = sqrtl (x);
  ASSERT (y >= 0.7745966692L && y <= 0.7745966693L);

  return 0;
}

Example #11

File: test-asinl.c Project: djmitche/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = asinl (x);
  ASSERT (y >= 0.6435011087L && y <= 0.6435011088L);

  return 0;
}

Example #12

File: test-logl.c Project: DesmondWu/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = logl (x);
  ASSERT (y >= -0.5108256238L && y <= -0.5108256237L);

  return 0;
}

Example #13

File: test-expm1l.c Project: Distrotech/gnulib

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = expm1l (x);
  ASSERT (y >= 0.822118800L && y <= 0.822118801L);

  test_function ();

  return 0;
}

Example #14

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 0.6L;
  y = exp2l (x);
  ASSERT (y >= 1.515716566L && y <= 1.515716567L);

  test_function ();

  return 0;
}

Example #15

File: test-log2l.c Project: pombredanne/pygnulib

int
main ()
{
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    /* A particular value.  */
    x = 0.6L;
    y = log2l (x);
    ASSERT (y >= -0.7369655942L && y <= -0.7369655941L);

    test_function ();

    return 0;
}

Example #16

File: test-remainderl.c Project: Chainfire/android-ndk-compression-tools

int
main ()
{
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* A particular value.  */
  x = 9.245907126L;
  y = 3.141592654L;
  z = remainderl (x, y);
  ASSERT (z >= -0.178870837L && z <= -0.178870835L);

  test_function ();

  return 0;
}

Example #17

int
main ()
{
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    /* A particular value.  */
    x = 9.245907126L;
    y = 3.141592654L;
    z = fmodl (x, y);
    ASSERT (z >= 2.962721817L && z <= 2.962721819L);

    test_function ();

    return 0;
}

Example #18

File: test-hypotl.c Project: lamb0145/gnulib

int
main ()
{
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    /* A particular value.  */
    x = 0.4L;
    y = 0.6L;
    z = hypotl (x, y);
    ASSERT (z >= 0.7211102550L && z <= 0.7211102551L);

    test_function ();

    return 0;
}

Example #19

File: test-float.c Project: Prelude-SIEM/libidmef

int
main ()
{
  test_float ();
  test_double ();

  {
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    test_long_double ();

    END_LONG_DOUBLE_ROUNDING ();
  }

  return 0;
}

Example #20

File: test-roundl.c Project: praiskup/gnulib

int
main ()
{
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    /* Zero.  */
    ASSERT (roundl (0.0L) == 0.0L);
    ASSERT (roundl (minus_zerol) == 0.0L);
    /* Positive numbers.  */
    ASSERT (roundl (0.3L) == 0.0L);
    ASSERT (roundl (0.5L) == 1.0L);
    ASSERT (roundl (0.7L) == 1.0L);
    ASSERT (roundl (1.0L) == 1.0L);
    ASSERT (roundl (1.5L) == 2.0L);
    ASSERT (roundl (2.5L) == 3.0L);
    ASSERT (roundl (1.999L) == 2.0L);
    ASSERT (roundl (2.0L) == 2.0L);
    ASSERT (roundl (65535.999L) == 65536.0L);
    ASSERT (roundl (65536.0L) == 65536.0L);
    ASSERT (roundl (65536.001L) == 65536.0L);
    ASSERT (roundl (2.341e31L) == 2.341e31L);
    /* Negative numbers.  */
    ASSERT (roundl (-0.3L) == 0.0L);
    ASSERT (roundl (-0.5L) == -1.0L);
    ASSERT (roundl (-0.7L) == -1.0L);
    ASSERT (roundl (-1.0L) == -1.0L);
    ASSERT (roundl (-1.5L) == -2.0L);
    ASSERT (roundl (-2.5L) == -3.0L);
    ASSERT (roundl (-1.999L) == -2.0L);
    ASSERT (roundl (-2.0L) == -2.0L);
    ASSERT (roundl (-65535.999L) == -65536.0L);
    ASSERT (roundl (-65536.0L) == -65536.0L);
    ASSERT (roundl (-65536.001L) == -65536.0L);
    ASSERT (roundl (-2.341e31L) == -2.341e31L);
    /* Infinite numbers.  */
    ASSERT (roundl (Infinityl ()) == Infinityl ());
    ASSERT (roundl (- Infinityl ()) == - Infinityl ());
    /* NaNs.  */
    ASSERT (isnanl (roundl (NaNl ())));

    return 0;
}

Example #21

File: ldexpl.c Project: komh/gnulib-os2

long double
ldexpl (long double x, int exp)
{
  long double factor;
  int bit;
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  /* Check for zero, nan and infinity. */
  if (!(isnanl (x) || x + x == x))
    {
      if (exp < 0)
        {
          exp = -exp;
          factor = 0.5L;
        }
      else
        factor = 2.0L;

      if (exp > 0)
        for (bit = 1;;)
          {
            /* Invariant: Here bit = 2^i, factor = 2^-2^i or = 2^2^i,
               and bit <= exp.  */
            if (exp & bit)
              x *= factor;
            bit <<= 1;
            if (bit > exp)
              break;
            factor = factor * factor;
          }
    }

  END_LONG_DOUBLE_ROUNDING ();

  return x;
}

Example #22

File: test-printf-frexpl.c Project: Distrotech/libprelude

int
main ()
{
  int i;
  long double x;
  DECL_LONG_DOUBLE_ROUNDING

  BEGIN_LONG_DOUBLE_ROUNDING ();

  for (i = 1, x = 1.0L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.0L);
    }
  for (i = 1, x = 1.0L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.0L);
    }
  for (; i >= MIN_SUBNORMAL_EXP && x > 0.0L; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == LDBL_MIN_EXP - 1);
      ASSERT (mantissa == my_ldexp (1.0L, i - LDBL_MIN_EXP));
    }

  for (i = 1, x = 1.01L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.01L);
    }
  for (i = 1, x = 1.01L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.01L);
    }
  for (; i >= MIN_SUBNORMAL_EXP && x > 0.0L; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == LDBL_MIN_EXP - 1);
      ASSERT (mantissa >= my_ldexp (1.0L, i - LDBL_MIN_EXP));
      ASSERT (mantissa <= my_ldexp (2.0L, i - LDBL_MIN_EXP));
      ASSERT (mantissa == my_ldexp (x, - exp));
    }

  for (i = 1, x = 1.73205L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.73205L);
    }
  for (i = 1, x = 1.73205L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == i - 1);
      ASSERT (mantissa == 1.73205L);
    }
  for (; i >= MIN_SUBNORMAL_EXP && x > 0.0L; i--, x *= 0.5L)
    {
      int exp = -9999;
      long double mantissa = printf_frexpl (x, &exp);
      ASSERT (exp == LDBL_MIN_EXP - 1);
      ASSERT (mantissa >= my_ldexp (1.0L, i - LDBL_MIN_EXP));
      ASSERT (mantissa <= my_ldexp (2.0L, i - LDBL_MIN_EXP));
      ASSERT (mantissa == my_ldexp (x, - exp));
    }

  return 0;
}

Example #23

File: test-frexpl.c Project: h8youall/m4

int
main ()
{
    int i;
    long double x;
    DECL_LONG_DOUBLE_ROUNDING

    BEGIN_LONG_DOUBLE_ROUNDING ();

    {   /* NaN.  */
        int exp = -9999;
        long double mantissa;
        x = 0.0L / 0.0L;
        mantissa = frexpl (x, &exp);
        ASSERT (isnanl (mantissa));
    }

    {   /* Positive infinity.  */
        int exp = -9999;
        long double mantissa;
        x = 1.0L / 0.0L;
        mantissa = frexpl (x, &exp);
        ASSERT (mantissa == x);
    }

    {   /* Negative infinity.  */
        int exp = -9999;
        long double mantissa;
        x = -1.0L / 0.0L;
        mantissa = frexpl (x, &exp);
        ASSERT (mantissa == x);
    }

    {   /* Positive zero.  */
        int exp = -9999;
        long double mantissa;
        x = 0.0L;
        mantissa = frexpl (x, &exp);
        ASSERT (exp == 0);
        ASSERT (mantissa == x);
        ASSERT (!signbit (mantissa));
    }

    {   /* Negative zero.  */
        int exp = -9999;
        long double mantissa;
        x = minus_zero;
        mantissa = frexpl (x, &exp);
        ASSERT (exp == 0);
        ASSERT (mantissa == x);
        ASSERT (signbit (mantissa));
    }

    for (i = 1, x = 1.0L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.5L);
    }
    for (i = 1, x = 1.0L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.5L);
    }
    for (; i >= LDBL_MIN_EXP - 100 && x > 0.0L; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.5L);
    }

    for (i = 1, x = -1.0L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == -0.5L);
    }
    for (i = 1, x = -1.0L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == -0.5L);
    }
    for (; i >= LDBL_MIN_EXP - 100 && x < 0.0L; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == -0.5L);
    }

    for (i = 1, x = 1.01L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.505L);
    }
    for (i = 1, x = 1.01L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.505L);
    }
    for (; i >= LDBL_MIN_EXP - 100 && x > 0.0L; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa >= 0.5L);
        ASSERT (mantissa < 1.0L);
        ASSERT (mantissa == my_ldexp (x, - exp));
    }

    for (i = 1, x = 1.73205L; i <= LDBL_MAX_EXP; i++, x *= 2.0L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.866025L);
    }
    for (i = 1, x = 1.73205L; i >= MIN_NORMAL_EXP; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i);
        ASSERT (mantissa == 0.866025L);
    }
    for (; i >= LDBL_MIN_EXP - 100 && x > 0.0L; i--, x *= 0.5L)
    {
        int exp = -9999;
        long double mantissa = frexpl (x, &exp);
        ASSERT (exp == i || exp == i + 1);
        ASSERT (mantissa >= 0.5L);
        ASSERT (mantissa < 1.0L);
        ASSERT (mantissa == my_ldexp (x, - exp));
    }

    return 0;
}