MpfrFloat::MpfrFloat(long double value)
{
if(value == 0.0L)
{
mData = mpfrFloatDataContainer().const_0();
++(mData->mRefCount);
}
else
{
mData = mpfrFloatDataContainer().allocateMpfrFloatData(false);
mpfr_set_ld(mData->mFloat, value, GMP_RNDN);
}
}
int
mpfr_cmp_ld (mpfr_srcptr b, long double d)
{
mpfr_t tmp;
int res;
mpfr_init2 (tmp, MPFR_LDBL_MANT_DIG);
res = mpfr_set_ld (tmp, d, GMP_RNDN);
MPFR_ASSERTD (res == 0);
res = mpfr_cmp (b, tmp);
mpfr_clear (tmp);
return res;
}
MpfrFloat& MpfrFloat::operator=(long double value)
{
if(value == 0.0L)
{
mpfrFloatDataContainer().releaseMpfrFloatData(mData);
mData = mpfrFloatDataContainer().const_0();
++(mData->mRefCount);
}
else
{
if(mData->mRefCount > 1)
{
--(mData->mRefCount);
mData = mpfrFloatDataContainer().allocateMpfrFloatData(false);
}
mpfr_set_ld(mData->mFloat, value, GMP_RNDN);
}
return *this;
}
int
main (void)
{
mpfr_t x;
int c;
tests_start_mpfr ();
mpfr_init2(x, MPFR_LDBL_MANT_DIG);
mpfr_set_ld (x, 2.34763465, GMP_RNDN);
if (mpfr_cmp_ld(x, 2.34763465)!=0) {
printf("Error in mpfr_cmp_ld 2.34763465 and ");
mpfr_out_str(stdout, 10, 0, x, GMP_RNDN); putchar('\n');
exit(1);
}
if (mpfr_cmp_ld(x, 2.345)<=0) {
printf("Error in mpfr_cmp_ld 2.345 and ");
mpfr_out_str(stdout, 10, 0, x, GMP_RNDN); putchar('\n');
exit(1);
}
if (mpfr_cmp_ld(x, 2.4)>=0) {
printf("Error in mpfr_cmp_ld 2.4 and ");
mpfr_out_str(stdout, 10, 0, x, GMP_RNDN); putchar('\n');
exit(1);
}
mpfr_set_ui (x, 0, GMP_RNDZ);
mpfr_neg (x, x, GMP_RNDZ);
if (mpfr_cmp_ld (x, 0.0)) {
printf("Error in mpfr_cmp_ld 0.0 and ");
mpfr_out_str(stdout, 10, 0, x, GMP_RNDN); putchar('\n');
exit(1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_ui_div (x, 1, x, GMP_RNDU);
if (mpfr_cmp_ld (x, 0.0) == 0)
{
printf ("Error in mpfr_cmp_ld (Inf, 0)\n");
exit (1);
}
/* Check NAN */
mpfr_clear_erangeflag ();
c = mpfr_cmp_ld (x, DBL_NAN);
if (c != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for NAN (1)\n");
exit (1);
}
mpfr_set_nan (x);
mpfr_clear_erangeflag ();
c = mpfr_cmp_ld (x, 2.0);
if (c != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for NAN (2)\n");
exit (1);
}
mpfr_clear(x);
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_t x;
tests_start_mpfr ();
mpfr_init2(x, MPFR_LDBL_MANT_DIG);
mpfr_set_ld (x, 2.34763465L, MPFR_RNDN);
if (mpfr_cmp_ld(x, 2.34763465L)!=0) {
printf("Error in mpfr_cmp_ld 2.34763465 and ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN); putchar('\n');
exit(1);
}
if (mpfr_cmp_ld(x, 2.345L)<=0) {
printf("Error in mpfr_cmp_ld 2.345 and ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN); putchar('\n');
exit(1);
}
if (mpfr_cmp_ld(x, 2.4L)>=0) {
printf("Error in mpfr_cmp_ld 2.4 and ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN); putchar('\n');
exit(1);
}
mpfr_set_ui (x, 0, MPFR_RNDZ);
mpfr_neg (x, x, MPFR_RNDZ);
if (mpfr_cmp_ld (x, 0.0)) {
printf("Error in mpfr_cmp_ld 0.0 and ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN); putchar('\n');
exit(1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_ui_div (x, 1, x, MPFR_RNDU);
if (mpfr_cmp_ld (x, 0.0) == 0)
{
printf ("Error in mpfr_cmp_ld (Inf, 0)\n");
exit (1);
}
#if !defined(MPFR_ERRDIVZERO)
/* Check NAN */
{
int c;
mpfr_clear_erangeflag ();
c = mpfr_cmp_ld (x, DBL_NAN);
if (c != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for NAN (1)\n");
#ifdef MPFR_NANISNAN
printf ("The reason is that NAN == NAN. Please look at the configure "
"output\nand Section \"In case of problem\" of the INSTALL "
"file.\n");
#endif
exit (1);
}
mpfr_set_nan (x);
mpfr_clear_erangeflag ();
c = mpfr_cmp_ld (x, 2.0);
if (c != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for NAN (2)\n");
#ifdef MPFR_NANISNAN
printf ("The reason is that NAN == NAN. Please look at the configure "
"output\nand Section \"In case of problem\" of the INSTALL "
"file.\n");
#endif
exit (1);
}
}
#endif /* MPFR_ERRDIVZERO */
mpfr_clear(x);
tests_end_mpfr ();
return 0;
}
void regressMinRelError_fr(int n, int m, mpfr_t **x, mpfr_t *result) {
int m0 = n * 3, n0 = m + 2 * n, i, j;
mpfr_t **a0, *c0, *result0;
int in0[m0];
a0 = malloc(sizeof(mpfr_t *) * m0);
for(i=0;i<m0;i++) {
a0[i] = calloc(n0+1, sizeof(mpfr_t));
for(j=0;j<n0+1;j++) mpfr_zinit(a0[i][j]);
}
c0 = calloc(n0+1, sizeof(mpfr_t));
result0 = calloc(n0+1, sizeof(mpfr_t));
for(j=0;j<n0+1;j++) {
mpfr_zinit(c0[j]);
mpfr_zinit(result0[j]);
}
for(i=0;i<n;i++) {
long double ld = mpfr_get_ld(x[m][i], GMP_RNDN);
if (ld < DBL_MIN) ld = 1;
#if 1
mpfr_set_ld(c0[m+i +1], 1.0/fabsl(ld), GMP_RNDN);
mpfr_set_ld(c0[m+n+i+1], 1.0/fabsl(ld), GMP_RNDN);
#else
int e;
frexpl(ld, &e);
ld = 1.0 / ldexpl(1.0, e);
mpfr_set_ld(c0[m+i +1], ld, GMP_RNDN);
mpfr_set_ld(c0[m+n+i+1], ld, GMP_RNDN);
#endif
mpfr_set_d(a0[i*3+0][m+i+1], 1, GMP_RNDN);
in0[i*3+0] = GEQ;
mpfr_set_d(a0[i*3+1][m+n+i+1], 1, GMP_RNDN);
in0[i*3+1] = GEQ;
for(j=0;j<m;j++) {
mpfr_set(a0[i*3+2][j+1], x[j][i], GMP_RNDN);
}
mpfr_set_d(a0[i*3+2][m+i+1], 1, GMP_RNDN);
mpfr_set_d(a0[i*3+2][m+n+i+1], -1, GMP_RNDN);
in0[i*3+2] = EQU;
mpfr_set(a0[i*3+2][0], x[m][i], GMP_RNDN);
mpfr_neg(a0[i*3+2][0], a0[i*3+2][0], GMP_RNDN);
}
int status = solve_fr(result0, n0, m0, a0, in0, c0);
if (status == NOT_FEASIBLE) {
printf("not feasible\n");
} else {
if (status == MAXIMIZABLE_TO_INFINITY) printf("maximizable to inf\n");
}
for(i=0;i<m;i++) {
mpfr_set(result[i], result0[i+1], GMP_RNDN);
}
free(result0);
free(c0);
}
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_RE(z), fr) != 0 || mpfr_cmp_si (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_d", prec, z);
#if defined _MPC_H_HAVE_COMPLEX
mpc_set_dc (z, I*1.23456789+1.23456789, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_c", prec, z);
#endif
mpc_set_ui (z, u, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_d_d", prec, z);
mpc_set_si (z, lo, MPC_RNDNN);
if (mpfr_cmp_si (MPC_RE(z), lo) != 0 || mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_ld_ld", prec, z);
#if defined _MPC_H_HAVE_COMPLEX
mpc_set_ldc (z, I*1.23456789L+1.23456789L, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(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_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(x), fr, GMP_RNDN);
mpfr_set(MPC_IM(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_RE(z), lo) != 0
|| mpfr_cmp_si (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(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_RE (z), u) != 0
|| mpfr_cmp (MPC_IM (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_RE (z), fr) != 0
|| mpfr_cmp_ui (MPC_IM (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_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(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_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE (z), fr) != 0
|| mpfr_cmp_si (MPC_IM (z), lo) != 0
|| mpfr_erangeflag_p ())
PRINT_ERROR ("mpc_set_f", prec, z);
mpc_set_nan (z);
if (!mpfr_nan_p (MPC_RE(z)) || !mpfr_nan_p (MPC_IM(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_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_uj", prec, z);
mpc_set_sj (z, im, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(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_RE(z), GMP_RNDN) != im ||
mpfr_cmp_ui (MPC_IM(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_RE(z), GMP_RNDN) != im ||
mpfr_get_sj (MPC_IM(z), GMP_RNDN) != im)
PRINT_ERROR ("mpc_set_sj_sj (2)", im, z);
}
#endif /* _MPC_H_HAVE_INTMAX_T */
#if defined _MPC_H_HAVE_COMPLEX
{
double _Complex c = 1.0 - 2.0*I;
long double _Complex lc = c;
mpc_set_dc (z, c, MPC_RNDNN);
if (mpc_get_dc (z, MPC_RNDNN) != c)
PRINT_ERROR ("mpc_get_c", prec, z);
mpc_set_ldc (z, lc, MPC_RNDNN);
if (mpc_get_ldc (z, MPC_RNDNN) != lc)
PRINT_ERROR ("mpc_get_lc", prec, z);
}
#endif
}
mpz_clear (mpz);
mpq_clear (mpq);
mpf_clear (mpf);
mpfr_clear (fr);
mpc_clear (x);
mpc_clear (z);
}
