src/mpc-1.0.3/tests/tset.c - stadia-controller/gcc-arm-none-eabi - Git at Google

 /* tset -- Test file for mpc_set_x and mpc_set_x_x functions.

 Copyright (C) 2009, 2010, 2011 INRIA

 This file is part of GNU MPC.

 GNU MPC is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; either version 3 of the License, or (at your
 option) any later version.

 GNU MPC is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
 more details.

 You should have received a copy of the GNU Lesser General Public License
 along with this program. If not, see http://www.gnu.org/licenses/ .
 */

 #include "config.h"
 #include <limits.h> /* for LONG_MAX */

 #ifdef HAVE_INTTYPES_H
 # include <inttypes.h> /* for intmax_t */
 #else
 # ifdef HAVE_STDINT_H
 #  include <stdint.h>
 # endif
 #endif

 #ifdef HAVE_COMPLEX_H
 # include <complex.h>
 #endif

 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif

 #include "mpc-tests.h"

 #define PRINT_ERROR(function_name, precision, a)                \
   do {                                                          \
     printf ("Error in "function_name" for prec = %lu\n",        \
             (unsigned long int) precision);                     \
     MPC_OUT(a);                                                     \
     exit (1);                                                   \
   } while (0)

 /* test MPC_SET_X_Y through some functions */
 static int
 mpc_set_ui_fr (mpc_ptr z, unsigned long int a, mpfr_srcptr b, mpc_rnd_t rnd)
   MPC_SET_X_Y (ui, fr, z, a, b, rnd)

 static int
 mpc_set_fr_ui (mpc_ptr z, mpfr_srcptr a, unsigned long int b, mpc_rnd_t rnd)
   MPC_SET_X_Y (fr, ui, z, a, b, rnd)

 static int
 mpc_set_f_si (mpc_ptr z, mpf_t a, long int b, mpc_rnd_t rnd)
   MPC_SET_X_Y (f, si, z, a, b, rnd)


 static void
 check_set (void)
 {
   long int lo;
   mpz_t mpz;
   mpq_t mpq;
   mpf_t mpf;
   mpfr_t fr;
   mpc_t x, z;
   mpfr_prec_t prec;

   mpz_init (mpz);
   mpq_init (mpq);
   mpf_init2 (mpf, 1000);
   mpfr_init2 (fr, 1000);
   mpc_init2 (x, 1000);
   mpc_init2 (z, 1000);

   mpz_set_ui (mpz, 0x4217);
   mpq_set_si (mpq, -1, 0x4321);
   mpf_set_q (mpf, mpq);

   for (prec = 2; prec <= 1000; prec++)
     {
       unsigned long int u = (unsigned long int) prec;

       mpc_set_prec (z, prec);
       mpfr_set_prec (fr, prec);

       lo = -prec;

       mpfr_set_d (fr, 1.23456789, GMP_RNDN);

       mpc_set_d (z, 1.23456789, MPC_RNDNN);
       if (mpfr_cmp (mpc_realref(z), fr) != 0 || mpfr_cmp_si (mpc_imagref(z), 0) != 0)
         PRINT_ERROR ("mpc_set_d", prec, z);

 #if defined HAVE_COMPLEX_H
       mpc_set_dc (z, I*1.23456789+1.23456789, MPC_RNDNN);
       if (mpfr_cmp (mpc_realref(z), fr) != 0 || mpfr_cmp (mpc_imagref(z), fr) != 0)
         PRINT_ERROR ("mpc_set_c", prec, z);
 #endif

       mpc_set_ui (z, u, MPC_RNDNN);
       if (mpfr_cmp_ui (mpc_realref(z), u) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
         PRINT_ERROR ("mpc_set_ui", prec, z);

       mpc_set_d_d (z, 1.23456789, 1.23456789, MPC_RNDNN);
       if (mpfr_cmp (mpc_realref(z), fr) != 0 || mpfr_cmp (mpc_imagref(z), fr) != 0)
         PRINT_ERROR ("mpc_set_d_d", prec, z);

       mpc_set_si (z, lo, MPC_RNDNN);
       if (mpfr_cmp_si (mpc_realref(z), lo) != 0 || mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
         PRINT_ERROR ("mpc_set_si", prec, z);

       mpfr_set_ld (fr, 1.23456789L, GMP_RNDN);

       mpc_set_ld_ld (z, 1.23456789L, 1.23456789L, MPC_RNDNN);
       if (mpfr_cmp (mpc_realref(z), fr) != 0 || mpfr_cmp (mpc_imagref(z), fr) != 0)
         PRINT_ERROR ("mpc_set_ld_ld", prec, z);

 #if defined HAVE_COMPLEX_H
       mpc_set_ldc (z, I*1.23456789L+1.23456789L, MPC_RNDNN);
       if (mpfr_cmp (mpc_realref(z), fr) != 0 || mpfr_cmp (mpc_imagref(z), fr) != 0)
         PRINT_ERROR ("mpc_set_lc", prec, z);
 #endif
       mpc_set_ui_ui (z, u, u, MPC_RNDNN);
       if (mpfr_cmp_ui (mpc_realref(z), u) != 0
           || mpfr_cmp_ui (mpc_imagref(z), u) != 0)
         PRINT_ERROR ("mpc_set_ui_ui", prec, z);

       mpc_set_ld (z, 1.23456789L, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_ld", prec, z);

       mpc_set_prec (x, prec);
       mpfr_set_ui(fr, 1, GMP_RNDN);
       mpfr_div_ui(fr, fr, 3, GMP_RNDN);
       mpfr_set(mpc_realref(x), fr, GMP_RNDN);
       mpfr_set(mpc_imagref(x), fr, GMP_RNDN);

       mpc_set (z, x, MPC_RNDNN);
       mpfr_clear_flags (); /* mpc_cmp set erange flag when an operand is a
                               NaN */
       if (mpc_cmp (z, x) != 0 || mpfr_erangeflag_p())
         {
           printf ("Error in mpc_set for prec = %lu\n",
                   (unsigned long int) prec);
           MPC_OUT(z);
           MPC_OUT(x);
           exit (1);
         }

       mpc_set_si_si (z, lo, lo, MPC_RNDNN);
       if (mpfr_cmp_si (mpc_realref(z), lo) != 0
           || mpfr_cmp_si (mpc_imagref(z), lo) != 0)
         PRINT_ERROR ("mpc_set_si_si", prec, z);

       mpc_set_fr (z, fr, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_fr", prec, z);

       mpfr_set_z (fr, mpz, GMP_RNDN);
       mpc_set_z_z (z, mpz, mpz, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp (mpc_imagref(z), fr) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_z_z", prec, z);

       mpc_set_fr_fr (z, fr, fr, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp (mpc_imagref(z), fr) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_fr_fr", prec, z);

       mpc_set_z (z, mpz, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_z", prec, z);

       mpfr_set_q (fr, mpq, GMP_RNDN);
       mpc_set_q_q (z, mpq, mpq, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp (mpc_imagref(z), fr) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_q_q", prec, z);

       mpc_set_ui_fr (z, u, fr, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp_ui (mpc_realref (z), u) != 0
           || mpfr_cmp (mpc_imagref (z), fr) != 0
           || mpfr_erangeflag_p ())
         PRINT_ERROR ("mpc_set_ui_fr", prec, z);

       mpc_set_fr_ui (z, fr, u, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref (z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref (z), u) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_fr_ui", prec, z);

       mpc_set_q (z, mpq, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_q", prec, z);

       mpfr_set_f (fr, mpf, GMP_RNDN);
       mpc_set_f_f (z, mpf, mpf, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp (mpc_imagref(z), fr) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_f_f", prec, z);

       mpc_set_f (z, mpf, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref(z), fr) != 0
           || mpfr_cmp_ui (mpc_imagref(z), 0) != 0
           || mpfr_erangeflag_p())
         PRINT_ERROR ("mpc_set_f", prec, z);

       mpc_set_f_si (z, mpf, lo, MPC_RNDNN);
       mpfr_clear_flags ();
       if (mpfr_cmp (mpc_realref (z), fr) != 0
           || mpfr_cmp_si (mpc_imagref (z), lo) != 0
           || mpfr_erangeflag_p ())
         PRINT_ERROR ("mpc_set_f", prec, z);

       mpc_set_nan (z);
       if (!mpfr_nan_p (mpc_realref(z)) || !mpfr_nan_p (mpc_imagref(z)))
         PRINT_ERROR ("mpc_set_nan", prec, z);

 #ifdef _MPC_H_HAVE_INTMAX_T
       {
         uintmax_t uim = (uintmax_t) prec;
         intmax_t im = (intmax_t) prec;

         mpc_set_uj (z, uim, MPC_RNDNN);
         if (mpfr_cmp_ui (mpc_realref(z), u) != 0
             || mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
           PRINT_ERROR ("mpc_set_uj", prec, z);

         mpc_set_sj (z, im, MPC_RNDNN);
         if (mpfr_cmp_ui (mpc_realref(z), u) != 0
             || mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
           PRINT_ERROR ("mpc_set_sj (1)", prec, z);

         mpc_set_uj_uj (z, uim, uim, MPC_RNDNN);
         if (mpfr_cmp_ui (mpc_realref(z), u) != 0
             || mpfr_cmp_ui (mpc_imagref(z), u) != 0)
           PRINT_ERROR ("mpc_set_uj_uj", prec, z);

         mpc_set_sj_sj (z, im, im, MPC_RNDNN);
         if (mpfr_cmp_ui (mpc_realref(z), u) != 0
             || mpfr_cmp_ui (mpc_imagref(z), u) != 0)
           PRINT_ERROR ("mpc_set_sj_sj (1)", prec, z);

         im = LONG_MAX;
         if (sizeof (intmax_t) == 2 * sizeof (unsigned long))
           im = 2 * im * im + 4 * im + 1; /* gives 2^(2n-1)-1 from 2^(n-1)-1 */

         mpc_set_sj (z, im, MPC_RNDNN);
         if (mpfr_get_sj (mpc_realref(z), GMP_RNDN) != im ||
             mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
           PRINT_ERROR ("mpc_set_sj (2)", im, z);

         mpc_set_sj_sj (z, im, im, MPC_RNDNN);
         if (mpfr_get_sj (mpc_realref(z), GMP_RNDN) != im ||
             mpfr_get_sj (mpc_imagref(z), GMP_RNDN) != im)
           PRINT_ERROR ("mpc_set_sj_sj (2)", im, z);
       }
 #endif /* _MPC_H_HAVE_INTMAX_T */

 #if defined HAVE_COMPLEX_H
       {
         double _Complex c = 1.0 - 2.0*I, d;
         long double _Complex lc = c, ld;

          mpc_set_dc (z, c, MPC_RNDNN);
          if ((d = mpc_get_dc (z, MPC_RNDNN)) != c)
            {
              printf ("expected (%f,%f)\n", creal (c), cimag (c));
              printf ("got      (%f,%f)\n", creal (d), cimag (d));
              PRINT_ERROR ("mpc_get_dc", prec, z);
            }
          mpc_set_ldc (z, lc, MPC_RNDNN);
          if ((ld = mpc_get_ldc (z, MPC_RNDNN)) != lc)
            {
              printf ("expected (%Lf,%Lf)\n", creall (lc), cimagl (lc));
              printf ("got      (%Lf,%Lf)\n", creall (ld), cimagl (ld));
              PRINT_ERROR ("mpc_get_ldc", prec, z);
            }
       }
 #endif
     }

   mpz_clear (mpz);
   mpq_clear (mpq);
   mpf_clear (mpf);
   mpfr_clear (fr);
   mpc_clear (x);
   mpc_clear (z);
 }

 static void
 check_set_str (mpfr_exp_t exp_max)
 {
   mpc_t expected;
   mpc_t got;
   char *str;

   mpfr_prec_t prec;
   mpfr_exp_t exp_min;
   int base;

   mpc_init2 (expected, 1024);
   mpc_init2 (got, 1024);

   exp_min = mpfr_get_emin ();
   if (exp_max <= 0)
     exp_max = mpfr_get_emax ();
   else if (exp_max > mpfr_get_emax ())
     exp_max = mpfr_get_emax();
   if (-exp_max > exp_min)
     exp_min = - exp_max;

   for (prec = 2; prec < 1024; prec += 7)
     {
       mpc_set_prec (got, prec);
       mpc_set_prec (expected, prec);

       base = 2 + (int) gmp_urandomm_ui (rands, 35);
          /* uses external variable rands from random.c */

       mpfr_set_nan (mpc_realref (expected));
       mpfr_set_inf (mpc_imagref (expected), prec % 2 - 1);
       str = mpc_get_str (base, 0, expected, MPC_RNDNN);
       if (mpfr_nan_p (mpc_realref (got)) == 0
           || mpfr_cmp (mpc_imagref (got), mpc_imagref (expected)) != 0)
         {
           printf ("Error: mpc_set_str o mpc_get_str != Id\n"
                   "in base %u with str=\"%s\"\n", base, str);
           MPC_OUT (expected);
           printf ("     ");
           MPC_OUT (got);
           exit (1);
         }
       mpc_free_str (str);

       test_default_random (expected, exp_min, exp_max, 128, 25);
       str = mpc_get_str (base, 0, expected, MPC_RNDNN);
       if (mpc_set_str (got, str, base, MPC_RNDNN) == -1
           || mpc_cmp (got, expected) != 0)
         {
           printf ("Error: mpc_set_str o mpc_get_str != Id\n"
                   "in base %u with str=\"%s\"\n", base, str);
           MPC_OUT (expected);
           printf ("     ");
           MPC_OUT (got);
           exit (1);
         }
       mpc_free_str (str);
     }

 #ifdef HAVE_SETLOCALE
   {
     /* Check with ',' as a decimal point */
     char *old_locale;

     old_locale = setlocale (LC_ALL, "de_DE");
     if (old_locale != NULL)
       {
         str = mpc_get_str (10, 0, expected, MPC_RNDNN);
         if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
             || mpc_cmp (got, expected) != 0)
           {
             printf ("Error: mpc_set_str o mpc_get_str != Id\n"
                     "with str=\"%s\"\n", str);
             MPC_OUT (expected);
             printf ("     ");
             MPC_OUT (got);
             exit (1);
           }
         mpc_free_str (str);

         setlocale (LC_ALL, old_locale);
       }
   }
 #endif /* HAVE_SETLOCALE */

   /* the real part has a zero exponent in base ten (fixed in r439) */
   mpc_set_prec (expected, 37);
   mpc_set_prec (got, 37);
   mpc_set_str (expected, "921FC04EDp-35  ", 16, GMP_RNDN);
   str = mpc_get_str (10, 0, expected, MPC_RNDNN);
   if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
       || mpc_cmp (got, expected) != 0)
     {
       printf ("Error: mpc_set_str o mpc_get_str != Id\n"
               "with str=\"%s\"\n", str);
       MPC_OUT (expected);
       printf ("     ");
       MPC_OUT (got);
       exit (1);
     }
   mpc_free_str (str);

   str = mpc_get_str (1, 0, expected, MPC_RNDNN);
   if (str != NULL)
     {
       printf ("Error: mpc_get_str with base==1 should fail\n");
       exit (1);
     }

   mpc_clear (expected);
   mpc_clear (got);
 }

 int
 main (void)
 {
   test_start ();

   check_set ();
   check_set_str (1024);

   test_end ();

   return 0;
 }
	/* tset -- Test file for mpc_set_x and mpc_set_x_x functions.

	Copyright (C) 2009, 2010, 2011 INRIA

	This file is part of GNU MPC.

	GNU MPC is free software; you can redistribute it and/or modify it under
	the terms of the GNU Lesser General Public License as published by the
	Free Software Foundation; either version 3 of the License, or (at your
	option) any later version.

	GNU MPC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
	more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program. If not, see http://www.gnu.org/licenses/ .
	*/

	#include "config.h"
	#include <limits.h> /* for LONG_MAX */

	#ifdef HAVE_INTTYPES_H
	# include <inttypes.h> /* for intmax_t */
	#else
	# ifdef HAVE_STDINT_H
	# include <stdint.h>
	# endif
	#endif

	#ifdef HAVE_COMPLEX_H
	# include <complex.h>
	#endif

	#ifdef HAVE_LOCALE_H
	#include <locale.h>
	#endif

	#include "mpc-tests.h"

	#define PRINT_ERROR(function_name, precision, a) \
	do { \
	printf ("Error in "function_name" for prec = %lu\n", \
	(unsigned long int) precision); \
	MPC_OUT(a); \
	exit (1); \
	} while (0)

	/* test MPC_SET_X_Y through some functions */
	static int
	mpc_set_ui_fr (mpc_ptr z, unsigned long int a, mpfr_srcptr b, mpc_rnd_t rnd)
	MPC_SET_X_Y (ui, fr, z, a, b, rnd)

	static int
	mpc_set_fr_ui (mpc_ptr z, mpfr_srcptr a, unsigned long int b, mpc_rnd_t rnd)
	MPC_SET_X_Y (fr, ui, z, a, b, rnd)

	static int
	mpc_set_f_si (mpc_ptr z, mpf_t a, long int b, mpc_rnd_t rnd)
	MPC_SET_X_Y (f, si, z, a, b, rnd)


	static void
	check_set (void)
	{
	long int lo;
	mpz_t mpz;
	mpq_t mpq;
	mpf_t mpf;
	mpfr_t fr;
	mpc_t x, z;
	mpfr_prec_t prec;

	mpz_init (mpz);
	mpq_init (mpq);
	mpf_init2 (mpf, 1000);
	mpfr_init2 (fr, 1000);
	mpc_init2 (x, 1000);
	mpc_init2 (z, 1000);

	mpz_set_ui (mpz, 0x4217);
	mpq_set_si (mpq, -1, 0x4321);
	mpf_set_q (mpf, mpq);

	for (prec = 2; prec <= 1000; prec++)
	{
	unsigned long int u = (unsigned long int) prec;

	mpc_set_prec (z, prec);
	mpfr_set_prec (fr, prec);

	lo = -prec;

	mpfr_set_d (fr, 1.23456789, GMP_RNDN);

	mpc_set_d (z, 1.23456789, MPC_RNDNN);
	if (mpfr_cmp (mpc_realref(z), fr) != 0 \|\| mpfr_cmp_si (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_d", prec, z);

	#if defined HAVE_COMPLEX_H
	mpc_set_dc (z, I*1.23456789+1.23456789, MPC_RNDNN);
	if (mpfr_cmp (mpc_realref(z), fr) != 0 \|\| mpfr_cmp (mpc_imagref(z), fr) != 0)
	PRINT_ERROR ("mpc_set_c", prec, z);
	#endif

	mpc_set_ui (z, u, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_ui", prec, z);

	mpc_set_d_d (z, 1.23456789, 1.23456789, MPC_RNDNN);
	if (mpfr_cmp (mpc_realref(z), fr) != 0 \|\| mpfr_cmp (mpc_imagref(z), fr) != 0)
	PRINT_ERROR ("mpc_set_d_d", prec, z);

	mpc_set_si (z, lo, MPC_RNDNN);
	if (mpfr_cmp_si (mpc_realref(z), lo) != 0 \|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_si", prec, z);

	mpfr_set_ld (fr, 1.23456789L, GMP_RNDN);

	mpc_set_ld_ld (z, 1.23456789L, 1.23456789L, MPC_RNDNN);
	if (mpfr_cmp (mpc_realref(z), fr) != 0 \|\| mpfr_cmp (mpc_imagref(z), fr) != 0)
	PRINT_ERROR ("mpc_set_ld_ld", prec, z);

	#if defined HAVE_COMPLEX_H
	mpc_set_ldc (z, I*1.23456789L+1.23456789L, MPC_RNDNN);
	if (mpfr_cmp (mpc_realref(z), fr) != 0 \|\| mpfr_cmp (mpc_imagref(z), fr) != 0)
	PRINT_ERROR ("mpc_set_lc", prec, z);
	#endif
	mpc_set_ui_ui (z, u, u, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), u) != 0)
	PRINT_ERROR ("mpc_set_ui_ui", prec, z);

	mpc_set_ld (z, 1.23456789L, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_ld", prec, z);

	mpc_set_prec (x, prec);
	mpfr_set_ui(fr, 1, GMP_RNDN);
	mpfr_div_ui(fr, fr, 3, GMP_RNDN);
	mpfr_set(mpc_realref(x), fr, GMP_RNDN);
	mpfr_set(mpc_imagref(x), fr, GMP_RNDN);

	mpc_set (z, x, MPC_RNDNN);
	mpfr_clear_flags (); /* mpc_cmp set erange flag when an operand is a
	NaN */
	if (mpc_cmp (z, x) != 0 \|\| mpfr_erangeflag_p())
	{
	printf ("Error in mpc_set for prec = %lu\n",
	(unsigned long int) prec);
	MPC_OUT(z);
	MPC_OUT(x);
	exit (1);
	}

	mpc_set_si_si (z, lo, lo, MPC_RNDNN);
	if (mpfr_cmp_si (mpc_realref(z), lo) != 0
	\|\| mpfr_cmp_si (mpc_imagref(z), lo) != 0)
	PRINT_ERROR ("mpc_set_si_si", prec, z);

	mpc_set_fr (z, fr, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_fr", prec, z);

	mpfr_set_z (fr, mpz, GMP_RNDN);
	mpc_set_z_z (z, mpz, mpz, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp (mpc_imagref(z), fr) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_z_z", prec, z);

	mpc_set_fr_fr (z, fr, fr, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp (mpc_imagref(z), fr) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_fr_fr", prec, z);

	mpc_set_z (z, mpz, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_z", prec, z);

	mpfr_set_q (fr, mpq, GMP_RNDN);
	mpc_set_q_q (z, mpq, mpq, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp (mpc_imagref(z), fr) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_q_q", prec, z);

	mpc_set_ui_fr (z, u, fr, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp_ui (mpc_realref (z), u) != 0
	\|\| mpfr_cmp (mpc_imagref (z), fr) != 0
	\|\| mpfr_erangeflag_p ())
	PRINT_ERROR ("mpc_set_ui_fr", prec, z);

	mpc_set_fr_ui (z, fr, u, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref (z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref (z), u) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_fr_ui", prec, z);

	mpc_set_q (z, mpq, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_q", prec, z);

	mpfr_set_f (fr, mpf, GMP_RNDN);
	mpc_set_f_f (z, mpf, mpf, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp (mpc_imagref(z), fr) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_f_f", prec, z);

	mpc_set_f (z, mpf, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref(z), fr) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0
	\|\| mpfr_erangeflag_p())
	PRINT_ERROR ("mpc_set_f", prec, z);

	mpc_set_f_si (z, mpf, lo, MPC_RNDNN);
	mpfr_clear_flags ();
	if (mpfr_cmp (mpc_realref (z), fr) != 0
	\|\| mpfr_cmp_si (mpc_imagref (z), lo) != 0
	\|\| mpfr_erangeflag_p ())
	PRINT_ERROR ("mpc_set_f", prec, z);

	mpc_set_nan (z);
	if (!mpfr_nan_p (mpc_realref(z)) \|\| !mpfr_nan_p (mpc_imagref(z)))
	PRINT_ERROR ("mpc_set_nan", prec, z);

	#ifdef _MPC_H_HAVE_INTMAX_T
	{
	uintmax_t uim = (uintmax_t) prec;
	intmax_t im = (intmax_t) prec;

	mpc_set_uj (z, uim, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_uj", prec, z);

	mpc_set_sj (z, im, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_sj (1)", prec, z);

	mpc_set_uj_uj (z, uim, uim, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), u) != 0)
	PRINT_ERROR ("mpc_set_uj_uj", prec, z);

	mpc_set_sj_sj (z, im, im, MPC_RNDNN);
	if (mpfr_cmp_ui (mpc_realref(z), u) != 0
	\|\| mpfr_cmp_ui (mpc_imagref(z), u) != 0)
	PRINT_ERROR ("mpc_set_sj_sj (1)", prec, z);

	im = LONG_MAX;
	if (sizeof (intmax_t) == 2 * sizeof (unsigned long))
	im = 2 * im * im + 4 * im + 1; /* gives 2^(2n-1)-1 from 2^(n-1)-1 */

	mpc_set_sj (z, im, MPC_RNDNN);
	if (mpfr_get_sj (mpc_realref(z), GMP_RNDN) != im \|\|
	mpfr_cmp_ui (mpc_imagref(z), 0) != 0)
	PRINT_ERROR ("mpc_set_sj (2)", im, z);

	mpc_set_sj_sj (z, im, im, MPC_RNDNN);
	if (mpfr_get_sj (mpc_realref(z), GMP_RNDN) != im \|\|
	mpfr_get_sj (mpc_imagref(z), GMP_RNDN) != im)
	PRINT_ERROR ("mpc_set_sj_sj (2)", im, z);
	}
	#endif /* _MPC_H_HAVE_INTMAX_T */

	#if defined HAVE_COMPLEX_H
	{
	double _Complex c = 1.0 - 2.0*I, d;
	long double _Complex lc = c, ld;

	mpc_set_dc (z, c, MPC_RNDNN);
	if ((d = mpc_get_dc (z, MPC_RNDNN)) != c)
	{
	printf ("expected (%f,%f)\n", creal (c), cimag (c));
	printf ("got (%f,%f)\n", creal (d), cimag (d));
	PRINT_ERROR ("mpc_get_dc", prec, z);
	}
	mpc_set_ldc (z, lc, MPC_RNDNN);
	if ((ld = mpc_get_ldc (z, MPC_RNDNN)) != lc)
	{
	printf ("expected (%Lf,%Lf)\n", creall (lc), cimagl (lc));
	printf ("got (%Lf,%Lf)\n", creall (ld), cimagl (ld));
	PRINT_ERROR ("mpc_get_ldc", prec, z);
	}
	}
	#endif
	}

	mpz_clear (mpz);
	mpq_clear (mpq);
	mpf_clear (mpf);
	mpfr_clear (fr);
	mpc_clear (x);
	mpc_clear (z);
	}

	static void
	check_set_str (mpfr_exp_t exp_max)
	{
	mpc_t expected;
	mpc_t got;
	char *str;

	mpfr_prec_t prec;
	mpfr_exp_t exp_min;
	int base;

	mpc_init2 (expected, 1024);
	mpc_init2 (got, 1024);

	exp_min = mpfr_get_emin ();
	if (exp_max <= 0)
	exp_max = mpfr_get_emax ();
	else if (exp_max > mpfr_get_emax ())
	exp_max = mpfr_get_emax();
	if (-exp_max > exp_min)
	exp_min = - exp_max;

	for (prec = 2; prec < 1024; prec += 7)
	{
	mpc_set_prec (got, prec);
	mpc_set_prec (expected, prec);

	base = 2 + (int) gmp_urandomm_ui (rands, 35);
	/* uses external variable rands from random.c */

	mpfr_set_nan (mpc_realref (expected));
	mpfr_set_inf (mpc_imagref (expected), prec % 2 - 1);
	str = mpc_get_str (base, 0, expected, MPC_RNDNN);
	if (mpfr_nan_p (mpc_realref (got)) == 0
	\|\| mpfr_cmp (mpc_imagref (got), mpc_imagref (expected)) != 0)
	{
	printf ("Error: mpc_set_str o mpc_get_str != Id\n"
	"in base %u with str=\"%s\"\n", base, str);
	MPC_OUT (expected);
	printf (" ");
	MPC_OUT (got);
	exit (1);
	}
	mpc_free_str (str);

	test_default_random (expected, exp_min, exp_max, 128, 25);
	str = mpc_get_str (base, 0, expected, MPC_RNDNN);
	if (mpc_set_str (got, str, base, MPC_RNDNN) == -1
	\|\| mpc_cmp (got, expected) != 0)
	{
	printf ("Error: mpc_set_str o mpc_get_str != Id\n"
	"in base %u with str=\"%s\"\n", base, str);
	MPC_OUT (expected);
	printf (" ");
	MPC_OUT (got);
	exit (1);
	}
	mpc_free_str (str);
	}

	#ifdef HAVE_SETLOCALE
	{
	/* Check with ',' as a decimal point */
	char *old_locale;

	old_locale = setlocale (LC_ALL, "de_DE");
	if (old_locale != NULL)
	{
	str = mpc_get_str (10, 0, expected, MPC_RNDNN);
	if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
	\|\| mpc_cmp (got, expected) != 0)
	{
	printf ("Error: mpc_set_str o mpc_get_str != Id\n"
	"with str=\"%s\"\n", str);
	MPC_OUT (expected);
	printf (" ");
	MPC_OUT (got);
	exit (1);
	}
	mpc_free_str (str);

	setlocale (LC_ALL, old_locale);
	}
	}
	#endif /* HAVE_SETLOCALE */

	/* the real part has a zero exponent in base ten (fixed in r439) */
	mpc_set_prec (expected, 37);
	mpc_set_prec (got, 37);
	mpc_set_str (expected, "921FC04EDp-35 ", 16, GMP_RNDN);
	str = mpc_get_str (10, 0, expected, MPC_RNDNN);
	if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
	\|\| mpc_cmp (got, expected) != 0)
	{
	printf ("Error: mpc_set_str o mpc_get_str != Id\n"
	"with str=\"%s\"\n", str);
	MPC_OUT (expected);
	printf (" ");
	MPC_OUT (got);
	exit (1);
	}
	mpc_free_str (str);

	str = mpc_get_str (1, 0, expected, MPC_RNDNN);
	if (str != NULL)
	{
	printf ("Error: mpc_get_str with base==1 should fail\n");
	exit (1);
	}

	mpc_clear (expected);
	mpc_clear (got);
	}

	int
	main (void)
	{
	test_start ();

	check_set ();
	check_set_str (1024);

	test_end ();

	return 0;
	}