/* f(z) = sin((1/1000 + (1-z)^2)^(-3/2)), example from Mioara Joldes' thesis
(suggested by Nicolas Brisebarre) */
int
f_sin_near_essing(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t, u;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_init(u);
acb_sub_ui(t, z, 1, prec);
acb_neg(t, t);
acb_mul(t, t, t, prec);
acb_one(u);
acb_div_ui(u, u, 1000, prec);
acb_add(t, t, u, prec);
acb_set_d(u, -1.5);
acb_pow_analytic(t, t, u, order != 0, prec);
acb_sin(res, t, prec);
acb_clear(t);
acb_clear(u);
return 0;
}
void
_acb_poly_sin_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
acb_sin(g, h, prec);
_acb_vec_zero(g + 1, n - 1);
}
else if (n == 2)
{
acb_t t;
acb_init(t);
acb_sin_cos(g, t, h, prec);
acb_mul(g + 1, h + 1, t, prec); /* safe since hlen >= 2 */
acb_clear(t);
}
else
{
acb_ptr t = _acb_vec_init(n);
_acb_poly_sin_cos_series(g, t, h, hlen, n, prec);
_acb_vec_clear(t, n);
}
}
int
f_monster(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_exp(t, z, prec);
acb_real_floor(res, t, order != 0, prec);
if (acb_is_finite(res))
{
acb_sub(res, t, res, prec);
acb_add(t, t, z, prec);
acb_sin(t, t, prec);
acb_mul(res, res, t, prec);
}
acb_clear(t);
return 0;
}
/* f(z) = sin(z) */
int
f_sin(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_sin(res, z, prec);
return 0;
}
/* f(z) = sin(z) + exp(-200-z^2) */
int
f_sin_plus_small(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_mul(t, z, z, prec);
acb_add_ui(t, t, 200, prec);
acb_neg(t, t);
acb_exp(t, t, prec);
acb_sin(res, z, prec);
acb_add(res, res, t, prec);
acb_clear(t);
return 0;
}
/* f(z) = sin(1/z), assume on real interval */
int
f_essing(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
if ((order == 0) && acb_is_real(z) && arb_contains_zero(acb_realref(z)))
{
/* todo: arb_zero_pm_one, arb_unit_interval? */
acb_zero(res);
mag_one(arb_radref(acb_realref(res)));
}
else
{
acb_inv(res, z, prec);
acb_sin(res, res, prec);
}
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sinc....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c, d;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_randtest(a, state, 1 + n_randint(state, 400), 2 + n_randint(state, 100));
acb_randtest(b, state, 1 + n_randint(state, 400), 2 + n_randint(state, 100));
acb_randtest(c, state, 1 + n_randint(state, 400), 2 + n_randint(state, 100));
acb_sinc(b, a, 2 + n_randint(state, 400));
acb_sin(c, a, 2 + n_randint(state, 400));
acb_mul(d, b, a, 2 + n_randint(state, 400));
/* check consistency */
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n");
flint_printf("b = "); acb_printd(b, 30); flint_printf("\n\n");
flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n");
flint_printf("d = "); acb_printd(d, 30); flint_printf("\n\n");
abort();
}
acb_set(c, a);
acb_sinc(c, c, 2 + n_randint(state, 400));
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n");
flint_printf("b = "); acb_printd(c, 30); flint_printf("\n\n");
flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("asin....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t x, a, b;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(x);
acb_init(a);
acb_init(b);
acb_randtest_special(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_randtest_special(a, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_randtest_special(b, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_asin(a, x, prec1);
acb_asin(b, x, prec2);
/* check consistency */
if (!acb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_printd(b, 15); flint_printf("\n\n");
abort();
}
/* check sin(asin(x)) = x */
acb_sin(b, b, prec1);
if (!acb_contains(b, x))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("b = "); acb_printd(b, 15); flint_printf("\n\n");
abort();
}
acb_asin(x, x, prec1);
if (!acb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n\n");
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(a);
acb_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t x, y, a, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(x);
acb_init(y);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_sin_pi(a, x, prec1);
acb_sin_pi(b, x, prec2);
/* check consistency */
if (!acb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
abort();
}
/* compare with cos */
arb_const_pi(acb_realref(c), prec1);
acb_mul_arb(y, x, acb_realref(c), prec1);
acb_sin(c, y, prec1);
if (!acb_overlaps(a, c))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("y = "); acb_print(y); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_sin_pi(x, x, prec1);
if (!acb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(y);
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
