int main() {
#define ni 5
slong n, i, f;
double b[ni][2] = { { 0, 1}, {-1, 1}, {0, 10}, {-20, 3}, {0, 3.14} };
const slong prec = 40;
#define nf 5
arb_func_t func[nf] = { (arb_func_t)&f_1x2, (arb_func_t)&f_pol, (arb_func_t)&f_thsh, (arb_func_t)&f_thsh_shift, (arb_func_t)&f_aj };
#if VERBOSE
char * fn[nf] = { "1/(1+x^2)", "1/p(x)", "th(sh(x))", "th(sh(x+.7I))" , "1/y" };
#endif
params_t p[nf];
arf_t tmin, tmax;
mag_t max;
flint_printf("max_func...");
fflush(stdout);
p[1].len = 3;
p[1].z = _acb_vec_init(3);
acb_set_d_d(p[1].z + 0, 2, 1);
acb_set_d_d(p[1].z + 1, 2, .1);
acb_set_d_d(p[1].z + 2, 1, .1);
p[4] = p[1];
arf_init(tmin);
arf_init(tmax);
mag_init(max);
for (i = 0; i < ni; i++)
{
arf_set_d(tmin, b[i][0]);
arf_set_d(tmax, b[i][1]);
for (f = 0; f < nf; f++)
{
for (n = 5; n < 100; n *= 2)
{
slong count;
count = mag_func_arf(max, func[f], (void *)&p[f], tmin, tmax, n, prec);
#if VERBOSE
flint_printf("\nmax %s on [%lf, %lf] <= ",fn[f],b[i][0],b[i][1]);
mag_printd(max,8);
flint_printf(" [asked %ld, did %ld]", n, count);
#endif
}
}
}
mag_clear(max);
arf_clear(tmin);
arf_clear(tmax);
printf("PASS\n");
return 0;
}
static void
acb_set_dddd(acb_t z, double a, double ar, double b, double br)
{
arf_set_d(arb_midref(acb_realref(z)), a);
mag_set_d(arb_radref(acb_realref(z)), ar);
arf_set_d(arb_midref(acb_imagref(z)), b);
mag_set_d(arb_radref(acb_imagref(z)), br);
}
int arf_cmpabs_d(const arf_t x, double y)
{
arf_t t;
arf_init(t); /* no need to free */
arf_set_d(t, y);
return arf_cmpabs(x, t);
}
void Lib_Arb_Set_D(ArbPtr x, double d)
{
arf_t rop;
arf_init(rop);
arf_set_d(rop, d);
arb_set_arf((arb_ptr)x, rop);
arf_clear(rop);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cauchy_bound....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100; iter++)
{
arb_t b, radius, ans;
acb_t x;
slong r, prec, maxdepth;
arb_init(b);
arb_init(radius);
arb_init(ans);
acb_init(x);
acb_set_ui(x, 5);
r = 1 + n_randint(state, 10);
arb_set_ui(radius, r);
prec = 2 + n_randint(state, 100);
maxdepth = n_randint(state, 10);
acb_calc_cauchy_bound(b, sin_x, NULL, x, radius, maxdepth, prec);
arf_set_d(arb_midref(ans), answers[r-1]);
mag_set_d(arb_radref(ans), 1e-8);
if (!arb_overlaps(b, ans))
{
flint_printf("FAIL\n");
flint_printf("r = %wd, prec = %wd, maxdepth = %wd\n\n", r, prec, maxdepth);
arb_printd(b, 15); flint_printf("\n\n");
arb_printd(ans, 15); flint_printf("\n\n");
abort();
}
arb_clear(b);
arb_clear(radius);
arb_clear(ans);
acb_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_d....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
double x;
arf_t y, z;
mpfr_t m;
arf_init(y);
arf_init(z);
mpfr_init2(m, 53);
x = d_randtest_special(state, -1200, 1200);
arf_set_d(y, x);
mpfr_set_d(m, x, MPFR_RNDN);
arf_set_mpfr(z, m);
if (!arf_equal(y, z))
{
flint_printf("FAIL:\n\n");
flint_printf("x = %.17g\n\n", x);
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_abort();
}
arf_clear(y);
arf_clear(z);
mpfr_clear(m);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
/* - is contained in emb +/- rad 2 */
void randomized_embedding(arb_t res, double emb, double rad1, double rad2)
{
double t; /* in +/- (rad2 - rad1) / 2 */
double r; /* in [rad1 + |t|, rad2 - |t|]*/
if (rad1 <= 0 || rad2 <= 0 || rad1 >= rad2)
abort();
t = (rad1 - rad2) / 2 + (rand() * (rad2 - rad1)) / RAND_MAX;
if (2 * fabs(t) > (rad2 - rad1))
abort();
r = (rad1 + fabs(t)) + (rand() * (rad2 - rad1 - 2 * fabs(t))) / RAND_MAX;
if (r < rad1 + fabs(t) || r > rad2 - fabs(t))
abort();
arf_set_d(arb_midref(res), emb + t);
mag_set_d(arb_radref(res), r);
}
int main(int argc, char *argv[])
{
arf_interval_ptr blocks;
arb_calc_func_t function;
int * info;
long digits, low_prec, high_prec, i, num, found_roots, found_unknown;
long maxdepth, maxeval, maxfound;
int refine;
double a, b;
arf_t C;
arf_interval_t t, interval;
arb_t v, w, z;
if (argc < 4)
{
printf("real_roots function a b [-refine d] [-verbose] "
"[-maxdepth n] [-maxeval n] [-maxfound n] [-prec n]\n");
printf("available functions:\n");
printf(" 0 Z(x), Riemann-Siegel Z-function\n");
printf(" 1 sin(x)\n");
printf(" 2 sin(x^2)\n");
printf(" 3 sin(1/x)\n");
return 1;
}
switch (atoi(argv[1]))
{
case 0:
function = z_function;
break;
case 1:
function = sin_x;
break;
case 2:
function = sin_x2;
break;
case 3:
function = sin_1x;
break;
default:
printf("require a function 0-3\n");
return 1;
}
a = atof(argv[2]);
b = atof(argv[3]);
if (a >= b)
{
printf("require a < b!\n");
return 1;
}
refine = 0;
digits = 0;
maxdepth = 30;
maxeval = 100000;
maxfound = 100000;
low_prec = 30;
for (i = 4; i < argc; i++)
{
if (!strcmp(argv[i], "-refine"))
{
refine = 1;
digits = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-verbose"))
{
arb_calc_verbose = 1;
}
else if (!strcmp(argv[i], "-maxdepth"))
{
maxdepth = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-maxeval"))
{
maxeval = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-maxfound"))
{
maxfound = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-prec"))
{
low_prec = atol(argv[i+1]);
}
}
high_prec = digits * 3.32192809488736 + 10;
found_roots = 0;
found_unknown = 0;
arf_init(C);
arf_interval_init(t);
arf_interval_init(interval);
arb_init(v);
arb_init(w);
arb_init(z);
arf_set_d(&interval->a, a);
arf_set_d(&interval->b, b);
printf("interval: ");
arf_interval_printd(interval, 15);
printf("\n");
printf("maxdepth = %ld, maxeval = %ld, maxfound = %ld, low_prec = %ld\n",
maxdepth, maxeval, maxfound, low_prec);
TIMEIT_ONCE_START
num = arb_calc_isolate_roots(&blocks, &info, function,
NULL, interval, maxdepth, maxeval, maxfound, low_prec);
for (i = 0; i < num; i++)
{
if (info[i] != 1)
{
if (arb_calc_verbose)
{
printf("unable to count roots in ");
arf_interval_printd(blocks + i, 15);
printf("\n");
}
found_unknown++;
continue;
}
found_roots++;
if (!refine)
continue;
if (arb_calc_refine_root_bisect(t,
function, NULL, blocks + i, 5, low_prec)
!= ARB_CALC_SUCCESS)
{
printf("warning: some bisection steps failed!\n");
}
if (arb_calc_verbose)
{
printf("after bisection 1: ");
arf_interval_printd(t, 15);
printf("\n");
}
if (arb_calc_refine_root_bisect(blocks + i,
function, NULL, t, 5, low_prec)
!= ARB_CALC_SUCCESS)
{
printf("warning: some bisection steps failed!\n");
}
if (arb_calc_verbose)
{
printf("after bisection 2: ");
arf_interval_printd(blocks + i, 15);
printf("\n");
}
arf_interval_get_arb(v, t, high_prec);
arb_calc_newton_conv_factor(C, function, NULL, v, low_prec);
arf_interval_get_arb(w, blocks + i, high_prec);
if (arb_calc_refine_root_newton(z, function, NULL,
w, v, C, 10, high_prec) != ARB_CALC_SUCCESS)
{
printf("warning: some newton steps failed!\n");
}
printf("refined root:\n");
arb_printd(z, digits + 2);
printf("\n\n");
}
printf("---------------------------------------------------------------\n");
printf("Found roots: %ld\n", found_roots);
printf("Subintervals possibly containing undetected roots: %ld\n", found_unknown);
printf("Function evaluations: %ld\n", eval_count);
TIMEIT_ONCE_STOP
SHOW_MEMORY_USAGE
for (i = 0; i < num; i++)
arf_interval_clear(blocks + i);
flint_free(blocks);
flint_free(info);
arf_interval_clear(t);
arf_interval_clear(interval);
arf_clear(C);
arb_clear(v);
arb_clear(w);
arb_clear(z);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("euler_product_real_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000 * arb_test_multiplier(); iter++)
{
arb_t res1, res2;
ulong s;
slong prec1, prec2, accuracy;
int choice, reciprocal1, reciprocal2;
if (iter % 10 == 0)
{
s = n_randtest(state);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
}
else
{
s = 6 + n_randint(state, 1 << n_randint(state, 12));
prec1 = 2 + n_randint(state, 12 * s);
prec2 = 2 + n_randint(state, 12 * s);
}
if (n_randint(state, 30) == 0)
prec1 = 2 + n_randint(state, 4000);
choice = n_randint(state, 7);
reciprocal1 = n_randint(state, 2);
reciprocal2 = n_randint(state, 2);
arb_init(res1);
arb_init(res2);
arb_randtest(res1, state, 200, 100);
_acb_dirichlet_euler_product_real_ui(res1, s, chi[choice] + 1,
chi[choice][0], reciprocal1, prec1);
_acb_dirichlet_euler_product_real_ui(res2, s, chi[choice] + 1,
chi[choice][0], reciprocal2, prec2);
if (reciprocal1 != reciprocal2)
arb_inv(res2, res2, prec2);
if (!arb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("s = %wu\n\n", s);
flint_printf("chi: %d\n", choice);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n");
abort();
}
if (s >= 6 && prec1 < 2 * s * log(s))
{
accuracy = arb_rel_accuracy_bits(res1);
if (accuracy < prec1 - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec1);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
abort();
}
}
if (s == 10)
{
arf_set_d(arb_midref(res2), L10[choice]);
mag_set_d(arb_radref(res2), 1e-15);
if (reciprocal1)
arb_inv(res2, res2, 53);
if (!arb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap (2)\n\n");
flint_printf("s = %wu\n\n", s);
flint_printf("chi: %d\n", choice);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n");
abort();
}
}
arb_clear(res1);
arb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
acb_t r, s, a, b;
arf_t inr, outr;
long digits, prec;
if (argc < 2)
{
printf("integrals d\n");
printf("compute integrals using d decimal digits of precision\n");
return 1;
}
acb_init(r);
acb_init(s);
acb_init(a);
acb_init(b);
arf_init(inr);
arf_init(outr);
arb_calc_verbose = 0;
digits = atol(argv[1]);
prec = digits * 3.32193;
printf("Digits: %ld\n", digits);
printf("----------------------------------------------------------------\n");
printf("Integral of sin(t) from 0 to 100.\n");
arf_set_d(inr, 0.125);
arf_set_d(outr, 1.0);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_set_si(b, 100);
acb_calc_integrate_taylor(r, sinx, NULL, a, b, inr, outr, prec, 1.1 * prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
printf("----------------------------------------------------------------\n");
printf("Elliptic integral F(phi, m) = integral of 1/sqrt(1 - m*sin(t)^2)\n");
printf("from 0 to phi, with phi = 6+6i, m = 1/2. Integration path\n");
printf("0 -> 6 -> 6+6i.\n");
arf_set_d(inr, 0.2);
arf_set_d(outr, 0.5);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_set_si(b, 6);
acb_calc_integrate_taylor(r, elliptic, NULL, a, b, inr, outr, prec, 1.1 * prec);
acb_set_si(a, 6);
arb_set_si(acb_realref(b), 6);
arb_set_si(acb_imagref(b), 6);
acb_calc_integrate_taylor(s, elliptic, NULL, a, b, inr, outr, prec, 1.1 * prec);
acb_add(r, r, s, prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
printf("----------------------------------------------------------------\n");
printf("Bessel function J_n(z) = (1/pi) * integral of cos(t*n - z*sin(t))\n");
printf("from 0 to pi. With n = 10, z = 20 + 10i.\n");
arf_set_d(inr, 0.1);
arf_set_d(outr, 0.5);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_const_pi(b, 3 * prec);
acb_calc_integrate_taylor(r, bessel, NULL, a, b, inr, outr, prec, 3 * prec);
acb_div(r, r, b, prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
acb_clear(r);
acb_clear(s);
acb_clear(a);
acb_clear(b);
arf_clear(inr);
arf_clear(outr);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("agm1....");
fflush(stdout);
flint_randinit(state);
/* check particular values against table */
{
acb_t z, t;
acb_ptr w1;
slong i, j, prec, cnj;
acb_init(z);
acb_init(t);
w1 = _acb_vec_init(NUM_DERIVS);
for (prec = 32; prec <= 512; prec *= 4)
{
for (i = 0; i < NUM_TESTS; i++)
{
for (cnj = 0; cnj < 2; cnj++)
{
if (cnj == 1 && agm_testdata[i][0] < 0 &&
agm_testdata[i][1] == 0)
continue;
acb_zero(z);
arf_set_d(arb_midref(acb_realref(z)), agm_testdata[i][0]);
arf_set_d(arb_midref(acb_imagref(z)), cnj ? -agm_testdata[i][1] : agm_testdata[i][1]);
acb_agm1_cpx(w1, z, NUM_DERIVS, prec);
for (j = 0; j < NUM_DERIVS; j++)
{
arf_set_d(arb_midref(acb_realref(t)), agm_testdata[i][2+2*j]);
mag_set_d(arb_radref(acb_realref(t)), fabs(agm_testdata[i][2+2*j]) * EPS);
arf_set_d(arb_midref(acb_imagref(t)), cnj ? -agm_testdata[i][2+2*j+1] : agm_testdata[i][2+2*j+1]);
mag_set_d(arb_radref(acb_imagref(t)), fabs(agm_testdata[i][2+2*j+1]) * EPS);
if (!acb_overlaps(w1 + j, t))
{
flint_printf("FAIL\n\n");
flint_printf("j = %wd\n\n", j);
flint_printf("z = "); acb_printd(z, 15); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 15); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1 + j, 15); flint_printf("\n\n");
abort();
}
}
}
}
}
_acb_vec_clear(w1, NUM_DERIVS);
acb_clear(z);
acb_clear(t);
}
/* self-consistency test */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_ptr m1, m2;
acb_t z1, z2, t;
slong i, len1, len2, prec1, prec2;
len1 = n_randint(state, 10);
len2 = n_randint(state, 10);
prec1 = 2 + n_randint(state, 2000);
prec2 = 2 + n_randint(state, 2000);
m1 = _acb_vec_init(len1);
m2 = _acb_vec_init(len2);
acb_init(z1);
acb_init(z2);
acb_init(t);
acb_randtest(z1, state, prec1, 1 + n_randint(state, 100));
if (n_randint(state, 2))
{
acb_set(z2, z1);
}
else
{
acb_randtest(t, state, prec2, 1 + n_randint(state, 100));
acb_add(z2, z1, t, prec2);
acb_sub(z2, z2, t, prec2);
}
acb_agm1_cpx(m1, z1, len1, prec1);
acb_agm1_cpx(m2, z2, len2, prec2);
for (i = 0; i < FLINT_MIN(len1, len2); i++)
{
if (!acb_overlaps(m1 + i, m2 + i))
{
flint_printf("FAIL (overlap)\n\n");
flint_printf("iter = %wd, i = %wd, len1 = %wd, len2 = %wd, prec1 = %wd, prec2 = %wd\n\n",
iter, i, len1, len2, prec1, prec2);
flint_printf("z1 = "); acb_printd(z1, 30); flint_printf("\n\n");
flint_printf("z2 = "); acb_printd(z2, 30); flint_printf("\n\n");
flint_printf("m1 = "); acb_printd(m1, 30); flint_printf("\n\n");
flint_printf("m2 = "); acb_printd(m2, 30); flint_printf("\n\n");
abort();
}
}
_acb_vec_clear(m1, len1);
_acb_vec_clear(m2, len2);
acb_clear(z1);
acb_clear(z2);
acb_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("integrate_taylor....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 150 * arb_test_multiplier(); iter++)
{
acb_t ans, res, a, b;
arf_t inr, outr;
double t;
slong goal, prec;
acb_init(ans);
acb_init(res);
acb_init(a);
acb_init(b);
arf_init(inr);
arf_init(outr);
goal = 2 + n_randint(state, 300);
prec = 2 + n_randint(state, 300);
acb_randtest(a, state, 1 + n_randint(state, 200), 2);
acb_randtest(b, state, 1 + n_randint(state, 200), 2);
acb_cos(ans, a, prec);
acb_cos(res, b, prec);
acb_sub(ans, ans, res, prec);
t = (1 + n_randint(state, 20)) / 10.0;
arf_set_d(inr, t);
arf_set_d(outr, t + (1 + n_randint(state, 20)) / 5.0);
acb_calc_integrate_taylor(res, sin_x, NULL,
a, b, inr, outr, goal, prec);
if (!acb_overlaps(res, ans))
{
flint_printf("FAIL! (iter = %wd)\n", iter);
flint_printf("prec = %wd, goal = %wd\n", prec, goal);
flint_printf("inr = "); arf_printd(inr, 15); flint_printf("\n");
flint_printf("outr = "); arf_printd(outr, 15); flint_printf("\n");
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n");
flint_printf("b = "); acb_printd(b, 15); flint_printf("\n");
flint_printf("res = "); acb_printd(res, 15); flint_printf("\n\n");
flint_printf("ans = "); acb_printd(ans, 15); flint_printf("\n\n");
abort();
}
acb_clear(ans);
acb_clear(res);
acb_clear(a);
acb_clear(b);
arf_clear(inr);
arf_clear(outr);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_d....");
fflush(stdout);
flint_randinit(state);
/* test exact roundtrip */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x, z;
double y;
arf_rnd_t rnd;
arf_init(x);
arf_init(z);
switch (n_randint(state, 4))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
case 3: rnd = ARF_RND_CEIL; break;
default: rnd = ARF_RND_NEAR; break;
}
arf_randtest_special(x, state, 53, 8);
y = arf_get_d(x, rnd);
arf_set_d(z, y);
if (!arf_equal(x, z))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = %.17g\n\n", y);
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(z);
}
/* test rounding */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x, z, w;
arf_rnd_t rnd;
double y;
arf_init(x);
arf_init(z);
arf_init(w);
arf_randtest_special(x, state, 300, 8);
switch (n_randint(state, 4))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
default: rnd = ARF_RND_CEIL; break;
}
y = arf_get_d(x, rnd);
arf_set_d(w, y);
arf_set_round(z, x, 53, rnd);
if (!arf_equal(w, z))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = %.17g\n\n", y);
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_printf("w = "); arf_print(w); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(z);
arf_clear(w);
}
/* compare with mpfr */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x, r1, r2;
arf_rnd_t rnd;
mpfr_t t;
double d1, d2;
arf_init(x);
arf_init(r1);
arf_init(r2);
mpfr_init2(t, 300);
arf_randtest_special(x, state, 300, 20);
arf_get_mpfr(t, x, MPFR_RNDD);
switch (n_randint(state, 4))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
case 3: rnd = ARF_RND_CEIL; break;
default: rnd = ARF_RND_NEAR; break;
}
d1 = arf_get_d(x, rnd);
d2 = mpfr_get_d(t, rnd_to_mpfr(rnd));
arf_set_d(r1, d1);
arf_set_d(r2, d2);
if (!arf_equal(r1, r2))
{
flint_printf("FAIL:\n\n");
flint_printf("rnd = %i\n\n", rnd);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("d1 = %.17g\n\n", d1);
flint_printf("d2 = %.17g\n\n", d2);
flint_printf("r1 = "); arf_print(r1); flint_printf("\n\n");
flint_printf("r2 = "); arf_print(r2); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(r1);
arf_clear(r2);
mpfr_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
flint_rand_t state;
arb_t t, u, v;
double x;
int error, bracket;
char tmp[256];
long i, j;
printf("set_str....");
fflush(stdout);
flint_randinit(state);
arb_init(t);
arb_init(u);
arb_init(v);
flint_randinit(state);
for (i = 0; testdata_floats[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_floats[i], 53);
x = strtod(testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", testdata_floats[i]);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_floats[i] != NULL; i++)
{
for (j = 0; testdata_floats[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
/* allow empty string for midpoint */
strcat(tmp, (i == 0) ? "" : testdata_floats[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_floats[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
x = strtod((i == 0) ? "0" : testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
x = strtod(testdata_floats[j], NULL);
arf_set_d(arb_midref(v), x);
mag_zero(arb_radref(v));
arb_abs(v, v);
arb_add_error(u, v);
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_invalid[i], 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", testdata_invalid[i]);
arb_printd(t, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
for (j = 0; testdata_invalid[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
strcat(tmp, testdata_invalid[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_invalid[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
abort();
}
}
}
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
