static void _fmpq_poly_oz_sqrt_approx_scale(fmpq_poly_t y, fmpq_poly_t z, const long n, const mpfr_prec_t prec) {
/* We scale by about |det(y) · det(z)|^(-1/(2n)) to make it converge faster */
mpfr_t gamma;
mpfr_init2(gamma, prec);
mpfr_t tmp;
mpfr_init2(tmp, prec);
fmpq_t gamma_q;
fmpq_init(gamma_q);
/* det(y) */
fmpq_poly_oz_ideal_norm(gamma_q, y, n, 1);
fmpq_get_mpfr(gamma, gamma_q, MPFR_RNDN);
/* det(y) · det(z) */
fmpq_poly_oz_ideal_norm(gamma_q, z, n, 1);
fmpq_get_mpfr(tmp, gamma_q, MPFR_RNDN);
mpfr_mul(gamma, gamma, tmp, MPFR_RNDN);
/* (det(y) · det(z))^(-1/(2n)) */
mpfr_root(gamma, gamma, 2*n, MPFR_RNDN);
mpfr_ui_div(gamma, 1, gamma, MPFR_RNDN);
mpfr_abs(gamma, gamma, MPFR_RNDN);
fmpq_set_mpfr(gamma_q, gamma, MPFR_RNDN);
fmpq_poly_scalar_mul_fmpq(y, y, gamma_q);
fmpq_poly_scalar_mul_fmpq(z, z, gamma_q);
fmpq_clear(gamma_q);
mpfr_clear(gamma);
mpfr_clear(tmp);
}
SeedValue seed_mpfr_root (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op;
gint ret;
gulong k;
CHECK_ARG_COUNT("mpfr.root", 3);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[2], exception);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) )
{
op = seed_object_get_private(args[0]);
}
else
{
TYPE_EXCEPTION("mpfr.root", "mpfr_t");
}
if ( seed_value_is_number(ctx, args[1]) )
{
k = seed_value_to_ulong(ctx, args[1], exception);
}
else
{
TYPE_EXCEPTION("mpfr.root", "unsigned long int");
}
ret = mpfr_root(rop, op, k, rnd);
return seed_value_from_int(ctx, ret, exception);
}
static void
special (void)
{
mpfr_t x, y;
int i;
mpfr_init (x);
mpfr_init (y);
/* root(NaN) = NaN */
mpfr_set_nan (x);
mpfr_root (y, x, 17, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: root(NaN,17) <> NaN\n");
exit (1);
}
/* root(+Inf) = +Inf */
mpfr_set_inf (x, 1);
mpfr_root (y, x, 42, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error: root(+Inf,42) <> +Inf\n");
exit (1);
}
/* root(-Inf, 17) = -Inf */
mpfr_set_inf (x, -1);
mpfr_root (y, x, 17, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) > 0)
{
printf ("Error: root(-Inf,17) <> -Inf\n");
exit (1);
}
/* root(-Inf, 42) = NaN */
mpfr_set_inf (x, -1);
mpfr_root (y, x, 42, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: root(-Inf,42) <> -Inf\n");
exit (1);
}
/* root(+/-0) = +/-0 */
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_root (y, x, 17, GMP_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error: root(+0,17) <> +0\n");
exit (1);
}
mpfr_neg (x, x, GMP_RNDN);
mpfr_root (y, x, 42, GMP_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) > 0)
{
printf ("Error: root(-0,42) <> -0\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_str (x, "8.39005285514734966412e-01", 10, GMP_RNDN);
mpfr_root (x, x, 3, GMP_RNDN);
if (mpfr_cmp_str1 (x, "9.43166207799662426048e-01"))
{
printf ("Error in root3 (1)\n");
printf ("expected 9.43166207799662426048e-01\n");
printf ("got ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.10000100001100101001001001011001");
mpfr_root (x, x, 3, GMP_RNDN);
mpfr_set_str_binary (y, "0.11001101011000100111000111111001");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (2)\n");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "-0.1100001110110000010101011001011");
mpfr_root (x, x, 3, GMP_RNDD);
mpfr_set_str_binary (y, "-0.11101010000100100101000101011001");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (3)\n");
exit (1);
}
mpfr_set_prec (x, 82);
mpfr_set_prec (y, 27);
mpfr_set_str_binary (x, "0.1010001111011101011011000111001011001101100011110110010011011011011010011001100101e-7");
mpfr_root (y, x, 3, GMP_RNDD);
mpfr_set_str_binary (x, "0.101011110001110001000100011E-2");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (4)\n");
exit (1);
}
mpfr_set_prec (x, 204);
mpfr_set_prec (y, 38);
mpfr_set_str_binary (x, "0.101000000001101000000001100111111011111001110110100001111000100110100111001101100111110001110001011011010110010011100101111001111100001010010100111011101100000011011000101100010000000011000101001010001001E-5");
mpfr_root (y, x, 3, GMP_RNDD);
mpfr_set_str_binary (x, "0.10001001111010011011101000010110110010E-1");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (5)\n");
exit (1);
}
/* Worst case found on 2006-11-25 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.0100001101101101001100110001001000000101001101100011E28");
mpfr_root (y, x, 35, GMP_RNDN);
mpfr_set_str_binary (x, "1.1100000010110101100011101011000010100001101100100011E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 35, GMP_RNDN) for\n"
"x = 1.0100001101101101001100110001001000000101001101100011E28\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
/* Worst cases found on 2006-11-26 */
mpfr_set_str_binary (x, "1.1111010011101110001111010110000101110000110110101100E17");
mpfr_root (y, x, 36, GMP_RNDD);
mpfr_set_str_binary (x, "1.0110100111010001101001010111001110010100111111000010E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 36, GMP_RNDD) for\n"
"x = 1.1111010011101110001111010110000101110000110110101100E17\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_str_binary (x, "1.1100011101101101100010110001000001110001111110010000E23");
mpfr_root (y, x, 36, GMP_RNDU);
mpfr_set_str_binary (x, "1.1001010100001110000110111111100011011101110011000100E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 36, GMP_RNDU) for\n"
"x = 1.1100011101101101100010110001000001110001111110010000E23\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
/* Check for k = 1 */
mpfr_set_ui (x, 17, GMP_RNDN);
i = mpfr_root (y, x, 1, GMP_RNDN);
if (mpfr_cmp_ui (x, 17) || i != 0)
{
printf ("Error in root (17^(1/1))\n");
exit (1);
}
#if 0
/* Check for k == 0:
For 0 <= x < 1 => +0.
For x = 1 => 1.
For x > 1, => +Inf.
For x < 0 => NaN. */
i = mpfr_root (y, x, 0, GMP_RNDN);
if (!MPFR_IS_INF (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 17^(1/0)\n");
exit (1);
}
mpfr_set_ui (x, 1, GMP_RNDN);
i = mpfr_root (y, x, 0, GMP_RNDN);
if (mpfr_cmp_ui (y, 1) || i != 0)
{
printf ("Error in root 1^(1/0)\n");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
i = mpfr_root (y, x, 0, GMP_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 0+^(1/0)\n");
exit (1);
}
MPFR_CHANGE_SIGN (x);
i = mpfr_root (y, x, 0, GMP_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 0-^(1/0)\n");
exit (1);
}
mpfr_set_ui_2exp (x, 17, -5, GMP_RNDD);
i = mpfr_root (y, x, 0, GMP_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root (17/2^5)^(1/0)\n");
exit (1);
}
#endif
mpfr_set_ui (x, 0, GMP_RNDN);
i = mpfr_root (y, x, 0, GMP_RNDN);
if (!MPFR_IS_NAN (y) || i != 0)
{
printf ("Error in root 0+^(1/0)\n");
exit (1);
}
/* Check for k==2 */
mpfr_set_si (x, -17, GMP_RNDD);
i = mpfr_root (y, x, 2, GMP_RNDN);
if (!MPFR_IS_NAN (y) || i != 0)
{
printf ("Error in root (-17)^(1/2)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
int
main (void)
{
mpfr_t x;
int r;
mp_prec_t p;
unsigned long k;
tests_start_mpfr ();
special ();
mpfr_init (x);
for (p = 2; p < 100; p++)
{
mpfr_set_prec (x, p);
for (r = 0; r < GMP_RND_MAX; r++)
{
mpfr_set_ui (x, 1, GMP_RNDN);
k = 2 + randlimb () % 4; /* 2 <= k <= 5 */
mpfr_root (x, x, k, (mp_rnd_t) r);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_root(%lu) for x=1, rnd=%s\ngot ",
k, mpfr_print_rnd_mode ((mp_rnd_t) r));
mpfr_out_str (stdout, 2, 0, x, GMP_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_si (x, -1, GMP_RNDN);
if (k % 2)
{
mpfr_root (x, x, k, (mp_rnd_t) r);
if (mpfr_cmp_si (x, -1))
{
printf ("Error in mpfr_root(%lu) for x=-1, rnd=%s\ngot ",
k, mpfr_print_rnd_mode ((mp_rnd_t) r));
mpfr_out_str (stdout, 2, 0, x, GMP_RNDN);
printf ("\n");
exit (1);
}
}
if (p >= 5)
{
int i;
for (i = -12; i <= 12; i++)
{
mpfr_set_ui (x, 27, GMP_RNDN);
mpfr_mul_2si (x, x, 3*i, GMP_RNDN);
mpfr_root (x, x, 3, GMP_RNDN);
if (mpfr_cmp_si_2exp (x, 3, i))
{
printf ("Error in mpfr_root(3) for "
"x = 27.0 * 2^(%d), rnd=%s\ngot ",
3*i, mpfr_print_rnd_mode ((mp_rnd_t) r));
mpfr_out_str (stdout, 2, 0, x, GMP_RNDN);
printf ("\ninstead of 3 * 2^(%d)\n", i);
exit (1);
}
}
}
}
}
mpfr_clear (x);
test_generic_ui (2, 200, 30);
tests_end_mpfr ();
return 0;
}
void generate_2D_sample (FILE *output, struct speed_params2D param)
{
mpfr_t temp;
double incr_prec;
mpfr_t incr_x;
mpfr_t x, x2;
double prec;
struct speed_params s;
int i;
int test;
int nb_functions;
double *t; /* store the timing of each implementation */
/* We first determine how many implementations we have */
nb_functions = 0;
while (param.speed_funcs[nb_functions] != NULL)
nb_functions++;
t = malloc (nb_functions * sizeof (double));
if (t == NULL)
{
fprintf (stderr, "Can't allocate memory.\n");
abort ();
}
mpfr_init2 (temp, MPFR_SMALL_PRECISION);
/* The precision is sampled from min_prec to max_prec with */
/* approximately nb_points_prec points. If logarithmic_scale_prec */
/* is true, the precision is multiplied by incr_prec at each */
/* step. Otherwise, incr_prec is added at each step. */
if (param.logarithmic_scale_prec)
{
mpfr_set_ui (temp, (unsigned long int)param.max_prec, MPFR_RNDU);
mpfr_div_ui (temp, temp, (unsigned long int)param.min_prec, MPFR_RNDU);
mpfr_root (temp, temp,
(unsigned long int)param.nb_points_prec, MPFR_RNDU);
incr_prec = mpfr_get_d (temp, MPFR_RNDU);
}
else
{
incr_prec = (double)param.max_prec - (double)param.min_prec;
incr_prec = incr_prec/((double)param.nb_points_prec);
}
/* The points x are sampled according to the following rule: */
/* If logarithmic_scale_x = 0: */
/* nb_points_x points are equally distributed between min_x and max_x */
/* If logarithmic_scale_x = 1: */
/* nb_points_x points are sampled from 2^(min_x) to 2^(max_x). At */
/* each step, the current point is multiplied by incr_x. */
/* If logarithmic_scale_x = -1: */
/* nb_points_x/2 points are sampled from -2^(max_x) to -2^(min_x) */
/* (at each step, the current point is divided by incr_x); and */
/* nb_points_x/2 points are sampled from 2^(min_x) to 2^(max_x) */
/* (at each step, the current point is multiplied by incr_x). */
mpfr_init2 (incr_x, param.max_prec);
if (param.logarithmic_scale_x == 0)
{
mpfr_set_d (incr_x,
(param.max_x - param.min_x)/(double)param.nb_points_x,
MPFR_RNDU);
}
else if (param.logarithmic_scale_x == -1)
{
mpfr_set_d (incr_x,
2.*(param.max_x - param.min_x)/(double)param.nb_points_x,
MPFR_RNDU);
mpfr_exp2 (incr_x, incr_x, MPFR_RNDU);
}
else
{ /* other values of param.logarithmic_scale_x are considered as 1 */
mpfr_set_d (incr_x,
(param.max_x - param.min_x)/(double)param.nb_points_x,
MPFR_RNDU);
mpfr_exp2 (incr_x, incr_x, MPFR_RNDU);
}
/* Main loop */
mpfr_init2 (x, param.max_prec);
mpfr_init2 (x2, param.max_prec);
prec = (double)param.min_prec;
while (prec <= param.max_prec)
{
printf ("prec = %d\n", (int)prec);
if (param.logarithmic_scale_x == 0)
mpfr_set_d (temp, param.min_x, MPFR_RNDU);
else if (param.logarithmic_scale_x == -1)
{
mpfr_set_d (temp, param.max_x, MPFR_RNDD);
mpfr_exp2 (temp, temp, MPFR_RNDD);
mpfr_neg (temp, temp, MPFR_RNDU);
}
else
{
mpfr_set_d (temp, param.min_x, MPFR_RNDD);
mpfr_exp2 (temp, temp, MPFR_RNDD);
}
/* We perturb x a little bit, in order to avoid trailing zeros that */
/* might change the behavior of algorithms. */
mpfr_const_pi (x, MPFR_RNDN);
mpfr_div_2ui (x, x, 7, MPFR_RNDN);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
mpfr_mul (x, x, temp, MPFR_RNDN);
test = 1;
while (test)
{
mpfr_fprintf (output, "%e\t", mpfr_get_d (x, MPFR_RNDN));
mpfr_fprintf (output, "%Pu\t", (mpfr_prec_t)prec);
s.r = (mp_limb_t)mpfr_get_exp (x);
s.size = (mpfr_prec_t)prec;
s.align_xp = (mpfr_sgn (x) > 0)?1:2;
mpfr_set_prec (x2, (mpfr_prec_t)prec);
mpfr_set (x2, x, MPFR_RNDU);
s.xp = x2->_mpfr_d;
for (i=0; i<nb_functions; i++)
{
t[i] = speed_measure (param.speed_funcs[i], &s);
mpfr_fprintf (output, "%e\t", t[i]);
}
fprintf (output, "%d\n", 1 + find_best (t, nb_functions));
if (param.logarithmic_scale_x == 0)
{
mpfr_add (x, x, incr_x, MPFR_RNDU);
if (mpfr_cmp_d (x, param.max_x) > 0)
test=0;
}
else
{
if (mpfr_sgn (x) < 0 )
{ /* if x<0, it means that logarithmic_scale_x=-1 */
mpfr_div (x, x, incr_x, MPFR_RNDU);
mpfr_abs (temp, x, MPFR_RNDD);
mpfr_log2 (temp, temp, MPFR_RNDD);
if (mpfr_cmp_d (temp, param.min_x) < 0)
mpfr_neg (x, x, MPFR_RNDN);
}
else
{
mpfr_mul (x, x, incr_x, MPFR_RNDU);
mpfr_set (temp, x, MPFR_RNDD);
mpfr_log2 (temp, temp, MPFR_RNDD);
if (mpfr_cmp_d (temp, param.max_x) > 0)
test=0;
}
}
}
prec = ( (param.logarithmic_scale_prec) ? (prec * incr_prec)
: (prec + incr_prec) );
fprintf (output, "\n");
}
free (t);
mpfr_clear (incr_x);
mpfr_clear (x);
mpfr_clear (x2);
mpfr_clear (temp);
return;
}
int
arf_root(arf_ptr z, arf_srcptr x, ulong k, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, zn, val;
mp_srcptr xptr;
mp_ptr tmp, zptr;
mpfr_t xf, zf;
fmpz_t q, r;
int inexact;
if (k == 0)
{
arf_nan(z);
return 0;
}
if (k == 1)
return arf_set_round(z, x, prec, rnd);
if (k == 2)
return arf_sqrt(z, x, prec, rnd);
if (arf_is_special(x))
{
if (arf_is_neg_inf(x))
arf_nan(z);
else
arf_set(z, x);
return 0;
}
if (ARF_SGNBIT(x))
{
arf_nan(z);
return 0;
}
fmpz_init(q);
fmpz_init(r);
/* x = m * 2^e where e = qk + r */
/* x^(1/k) = (m * 2^(qk+r))^(1/k) */
/* x^(1/k) = (m * 2^r)^(1/k) * 2^q */
fmpz_set_ui(r, k);
fmpz_fdiv_qr(q, r, ARF_EXPREF(x), r);
ARF_GET_MPN_READONLY(xptr, xn, x);
zn = (prec + FLINT_BITS - 1) / FLINT_BITS;
zf->_mpfr_d = tmp = flint_malloc(zn * sizeof(mp_limb_t));
zf->_mpfr_prec = prec;
zf->_mpfr_sign = 1;
zf->_mpfr_exp = 0;
xf->_mpfr_d = (mp_ptr) xptr;
xf->_mpfr_prec = xn * FLINT_BITS;
xf->_mpfr_sign = 1;
xf->_mpfr_exp = fmpz_get_ui(r);
inexact = mpfr_root(zf, xf, k, arf_rnd_to_mpfr(rnd));
inexact = (inexact != 0);
val = 0;
while (tmp[val] == 0)
val++;
ARF_GET_MPN_WRITE(zptr, zn - val, z);
flint_mpn_copyi(zptr, tmp + val, zn - val);
fmpz_add_si(ARF_EXPREF(z), q, zf->_mpfr_exp);
flint_free(tmp);
fmpz_clear(q);
fmpz_clear(r);
return inexact;
}
MpfrFloat MpfrFloat::root(const MpfrFloat& value, unsigned long root)
{
MpfrFloat retval(MpfrFloat::kNoInitialization);
mpfr_root(retval.mData->mFloat, value.mData->mFloat, root, GMP_RNDN);
return retval;
}
int main(int argc, char **argv) {
mpfr_t tmp1;
mpfr_t tmp2;
mpfr_t tmp3;
mpfr_t s1;
mpfr_t s2;
mpfr_t r;
mpfr_t a1;
mpfr_t a2;
time_t start_time;
time_t end_time;
// Parse command line opts
int hide_pi = 0;
if(argc == 2) {
if(strcmp(argv[1], "--hide-pi") == 0) {
hide_pi = 1;
} else if((precision = atoi(argv[1])) == 0) {
fprintf(stderr, "Invalid precision specified. Aborting.\n");
return 1;
}
} else if(argc == 3) {
if(strcmp(argv[1], "--hide-pi") == 0) {
hide_pi = 1;
}
if((precision = atoi(argv[2])) == 0) {
fprintf(stderr, "Invalid precision specified. Aborting.\n");
return 1;
}
}
// If the precision was not specified, default it
if(precision == 0) {
precision = DEFAULT_PRECISION;
}
// Actual number of correct digits is roughly 3.35 times the requested precision
precision *= 3.35;
mpfr_set_default_prec(precision);
mpfr_inits(tmp1, tmp2, tmp3, s1, s2, r, a1, a2, NULL);
start_time = time(NULL);
// a0 = 1/3
mpfr_set_ui(a1, 1, MPFR_RNDN);
mpfr_div_ui(a1, a1, 3, MPFR_RNDN);
// s0 = (3^.5 - 1) / 2
mpfr_sqrt_ui(s1, 3, MPFR_RNDN);
mpfr_sub_ui(s1, s1, 1, MPFR_RNDN);
mpfr_div_ui(s1, s1, 2, MPFR_RNDN);
unsigned long i = 0;
while(i < MAX_ITERS) {
// r = 3 / (1 + 2(1-s^3)^(1/3))
mpfr_pow_ui(tmp1, s1, 3, MPFR_RNDN);
mpfr_ui_sub(r, 1, tmp1, MPFR_RNDN);
mpfr_root(r, r, 3, MPFR_RNDN);
mpfr_mul_ui(r, r, 2, MPFR_RNDN);
mpfr_add_ui(r, r, 1, MPFR_RNDN);
mpfr_ui_div(r, 3, r, MPFR_RNDN);
// s = (r - 1) / 2
mpfr_sub_ui(s2, r, 1, MPFR_RNDN);
mpfr_div_ui(s2, s2, 2, MPFR_RNDN);
// a = r^2 * a - 3^i(r^2-1)
mpfr_pow_ui(tmp1, r, 2, MPFR_RNDN);
mpfr_mul(a2, tmp1, a1, MPFR_RNDN);
mpfr_sub_ui(tmp1, tmp1, 1, MPFR_RNDN);
mpfr_ui_pow_ui(tmp2, 3UL, i, MPFR_RNDN);
mpfr_mul(tmp1, tmp1, tmp2, MPFR_RNDN);
mpfr_sub(a2, a2, tmp1, MPFR_RNDN);
// s1 = s2
mpfr_set(s1, s2, MPFR_RNDN);
// a1 = a2
mpfr_set(a1, a2, MPFR_RNDN);
i++;
}
// pi = 1/a
mpfr_ui_div(a2, 1, a2, MPFR_RNDN);
end_time = time(NULL);
mpfr_clears(tmp1, tmp2, tmp3, s1, s2, r, a1, NULL);
// Write the digits to a string for accuracy comparison
char *pi = malloc(precision + 100);
if(pi == NULL) {
fprintf(stderr, "Failed to allocated memory for output string.\n");
return 1;
}
mpfr_sprintf(pi, "%.*R*f", precision, MPFR_RNDN, a2);
// Check out accurate we are
unsigned long accuracy = check_digits(pi);
// Print the results (only print the digits that are accurate)
if(!hide_pi) {
// Plus two for the "3." at the beginning
for(unsigned long i=0; i<(unsigned long)(precision/3.35)+2; i++) {
printf("%c", pi[i]);
}
printf("\n");
} // Send the time and accuracy to stderr so pi can be redirected to a file if necessary
fprintf(stderr, "Time: %d seconds\nAccuracy: %lu digits\n", (int)(end_time - start_time), accuracy);
mpfr_clear(a2);
free(pi);
pi = NULL;
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("root....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits;
ulong k;
fmpr_t x, z, w;
mpfr_t X, Z;
bits = 2 + n_randint(state, 200);
k = 1 + n_randint(state, 20);
fmpr_init(x);
fmpr_init(z);
fmpr_init(w);
mpfr_init2(X, k * (bits + 100));
mpfr_init2(Z, bits);
fmpr_randtest_special(x, state, bits + n_randint(state, 100), 10);
fmpr_abs(x, x);
fmpr_randtest_special(z, state, bits + n_randint(state, 100), 10);
/* occasionally produce perfect powers */
if (n_randint(state, 4) == 0)
fmpr_mul(x, x, x, k * bits, FMPR_RND_DOWN);
fmpr_get_mpfr(X, x, MPFR_RNDN);
switch (n_randint(state, 4))
{
case 0:
mpfr_root(Z, X, k, MPFR_RNDZ);
fmpr_root(z, x, k, bits, FMPR_RND_DOWN);
break;
case 1:
mpfr_root(Z, X, k, MPFR_RNDA);
fmpr_root(z, x, k, bits, FMPR_RND_UP);
break;
case 2:
mpfr_root(Z, X, k, MPFR_RNDD);
fmpr_root(z, x, k, bits, FMPR_RND_FLOOR);
break;
case 3:
mpfr_root(Z, X, k, MPFR_RNDU);
fmpr_root(z, x, k, bits, FMPR_RND_CEIL);
break;
}
fmpr_set_mpfr(w, Z);
if (!fmpr_equal(z, w))
{
flint_printf("FAIL\n\n");
flint_printf("bits = %wd, k = %wu\n", bits, k);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("w = "); fmpr_print(w); flint_printf("\n\n");
abort();
}
fmpr_clear(x);
fmpr_clear(z);
fmpr_clear(w);
mpfr_clear(X);
mpfr_clear(Z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("can_round_mpfr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000000; iter++)
{
mpfr_t x, y1, y2;
int r1, r2;
arb_t t;
slong prec;
mpfr_rnd_t rnd;
prec = 2 + n_randint(state, 300);
mpfr_init2(x, 2 + n_randint(state, 300));
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
arb_init(t);
switch (n_randint(state, 5))
{
case 0: rnd = MPFR_RNDN; break;
case 1: rnd = MPFR_RNDZ; break;
case 2: rnd = MPFR_RNDU; break;
case 3: rnd = MPFR_RNDD; break;
default: rnd = MPFR_RNDA;
}
arf_randtest(arb_midref(t), state, mpfr_get_prec(x), 1 + n_randint(state, 10));
arf_abs(arb_midref(t), arb_midref(t));
arf_get_mpfr(x, arb_midref(t), MPFR_RNDN);
arb_root_ui(t, t, 4, 2 + n_randint(state, 300));
if (arb_can_round_mpfr(t, prec, rnd))
{
r1 = mpfr_root(y1, x, 4, rnd);
r2 = arf_get_mpfr(y2, arb_midref(t), rnd);
if (r1 != r2 || !mpfr_equal_p(y1, y2))
{
flint_printf("FAIL! %ld\n");
flint_printf("r1 = %d, r2 = %d, prec = %wd\n", r1, r2, prec);
flint_printf("x = "); mpfr_dump(x); flint_printf("\n");
flint_printf("y1 = "); mpfr_dump(y1); flint_printf("\n");
flint_printf("y2 = "); mpfr_dump(y2); flint_printf("\n");
abort();
}
}
arb_clear(t);
mpfr_clear(x);
mpfr_clear(y1);
mpfr_clear(y2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
