/// @brief cos keyword implementation
///
void program::rpn_cos(void) {
MIN_ARGUMENTS(1);
if (_stack->get_type(0) == cmd_number) {
floating_t* left = &((number*)_stack->get_obj(0))->_value;
CHECK_MPFR(mpfr_cos(left->mpfr, left->mpfr, floating_t::s_mpfr_rnd));
} else if (_stack->get_type(0) == cmd_complex) {
// cos(x+iy) = cos(x)cosh(y) - isin(x)sinh(y)
stack::copy_and_push_back(*_stack, _stack->size() - 1, _calc_stack);
floating_t* tmp = &((number*)_calc_stack.allocate_back(number::calc_size(), cmd_number))->_value;
floating_t* x = ((complex*)_calc_stack.get_obj(1))->re();
floating_t* y = ((complex*)_calc_stack.get_obj(1))->im();
floating_t* re = ((complex*)_stack->get_obj(0))->re();
floating_t* im = ((complex*)_stack->get_obj(0))->im();
CHECK_MPFR(mpfr_cos(re->mpfr, x->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_cosh(tmp->mpfr, y->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_mul(re->mpfr, re->mpfr, tmp->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_sin(im->mpfr, x->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_sinh(tmp->mpfr, y->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_mul(im->mpfr, im->mpfr, tmp->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_neg(im->mpfr, im->mpfr, floating_t::s_mpfr_rnd));
_calc_stack.pop_back(2);
} else
ERR_CONTEXT(ret_bad_operand_type);
}
real cos(const real & a)
{
real x;
mpfr_cos(x.r, a.r, MPFR_RNDN);
return x;
}
static PyObject *
GMPy_Complex_Rect(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPFR_Object *tempx, *tempy;
MPC_Object *result;
CHECK_CONTEXT(context);
tempx = GMPy_MPFR_From_Real(x, 1, context);
tempy = GMPy_MPFR_From_Real(y, 1, context);
result = GMPy_MPC_New(0, 0, context);
if (!tempx || !tempy || !result) {
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_XDECREF((PyObject*)result);
return NULL;
}
mpfr_cos(mpc_realref(result->c), tempy->f, GET_REAL_ROUND(context));
mpfr_mul(mpc_realref(result->c), mpc_realref(result->c), tempx->f, GET_REAL_ROUND(context));
mpfr_sin(mpc_imagref(result->c), tempy->f, GET_IMAG_ROUND(context));
mpfr_mul(mpc_imagref(result->c), mpc_imagref(result->c), tempx->f, GET_IMAG_ROUND(context));
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
GMPY_MPC_CLEANUP(result, context, "rect()");
return (PyObject*)result;
}
static int
mpc_sin_cos_real (mpc_ptr rop_sin, mpc_ptr rop_cos, mpc_srcptr op,
mpc_rnd_t rnd_sin, mpc_rnd_t rnd_cos)
/* assumes that op is real */
{
int inex_sin_re = 0, inex_cos_re = 0;
/* Until further notice, assume computations exact; in particular,
by definition, for not computed values. */
mpfr_t s, c;
int inex_s, inex_c;
int sign_im_op = mpfr_signbit (MPC_IM (op));
/* sin(x +-0*i) = sin(x) +-0*i*sign(cos(x)) */
/* cos(x +-i*0) = cos(x) -+i*0*sign(sin(x)) */
if (rop_sin != 0)
mpfr_init2 (s, MPC_PREC_RE (rop_sin));
else
mpfr_init2 (s, 2); /* We need only the sign. */
if (rop_cos != NULL)
mpfr_init2 (c, MPC_PREC_RE (rop_cos));
else
mpfr_init2 (c, 2);
inex_s = mpfr_sin (s, MPC_RE (op), MPC_RND_RE (rnd_sin));
inex_c = mpfr_cos (c, MPC_RE (op), MPC_RND_RE (rnd_cos));
/* We cannot use mpfr_sin_cos since we may need two distinct rounding
modes and the exact return values. If we need only the sign, an
arbitrary rounding mode will work. */
if (rop_sin != NULL) {
mpfr_set (MPC_RE (rop_sin), s, GMP_RNDN); /* exact */
inex_sin_re = inex_s;
mpfr_set_ui (MPC_IM (rop_sin), 0ul, GMP_RNDN);
if ( ( sign_im_op && !mpfr_signbit (c))
|| (!sign_im_op && mpfr_signbit (c)))
MPFR_CHANGE_SIGN (MPC_IM (rop_sin));
/* FIXME: simpler implementation with mpfr-3:
mpfr_set_zero (MPC_IM (rop_sin),
( ( mpfr_signbit (MPC_IM(op)) && !mpfr_signbit(c))
|| (!mpfr_signbit (MPC_IM(op)) && mpfr_signbit(c)) ? -1 : 1);
there is no need to use the variable sign_im_op then, needed now in
the case rop_sin == op */
}
if (rop_cos != NULL) {
mpfr_set (MPC_RE (rop_cos), c, GMP_RNDN); /* exact */
inex_cos_re = inex_c;
mpfr_set_ui (MPC_IM (rop_cos), 0ul, GMP_RNDN);
if ( ( sign_im_op && mpfr_signbit (s))
|| (!sign_im_op && !mpfr_signbit (s)))
MPFR_CHANGE_SIGN (MPC_IM (rop_cos));
/* FIXME: see previous MPFR_CHANGE_SIGN */
}
mpfr_clear (s);
mpfr_clear (c);
return MPC_INEX12 (MPC_INEX (inex_sin_re, 0), MPC_INEX (inex_cos_re, 0));
}
decimal r_cos(const decimal& a,bool round)
{
#ifdef USE_CGAL
CGAL::Gmpfr m;
CGAL::Gmpfr n=to_gmpfr(a);
mpfr_cos(m.fr(),n.fr(),MPFR_RNDN);
return r_round_preference(decimal(m),round);
#else
return r_round_preference(cos(a),round);
#endif
}
static void
bug20091030 (void)
{
mpfr_t x, y;
mpfr_init2 (x, 5);
mpfr_init2 (y, 2);
mpfr_set_str (x, "-0.11001E3", 2, MPFR_RNDN);
mpfr_cos (y, x, MPFR_RNDN);
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_flags (void)
{
mpfr_t x;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_init (x);
/* Check the functions not the macros ! */
(mpfr_clear_flags)();
mpfr_set_double_range ();
mpfr_set_ui (x, 1, MPFR_RNDN);
(mpfr_clear_overflow)();
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
if (!(mpfr_overflow_p)())
ERROR("ERROR: No overflow detected!\n");
(mpfr_clear_underflow)();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
if (!(mpfr_underflow_p)())
ERROR("ERROR: No underflow detected!\n");
(mpfr_clear_nanflag)();
MPFR_SET_NAN(x);
mpfr_add (x, x, x, MPFR_RNDN);
if (!(mpfr_nanflag_p)())
ERROR("ERROR: No NaN flag!\n");
(mpfr_clear_inexflag)();
mpfr_set_ui(x, 2, MPFR_RNDN);
mpfr_cos(x, x, MPFR_RNDN);
if (!(mpfr_inexflag_p)())
ERROR("ERROR: No inexact flag!\n");
(mpfr_clear_erangeflag) ();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_get_ui (x, MPFR_RNDN);
if (!(mpfr_erangeflag_p)())
ERROR ("ERROR: No erange flag!\n");
mpfr_clear (x);
set_emin (old_emin);
set_emax (old_emax);
}
static int
mpc_sin_cos_real (mpc_ptr rop_sin, mpc_ptr rop_cos, mpc_srcptr op,
mpc_rnd_t rnd_sin, mpc_rnd_t rnd_cos)
/* assumes that op is real */
{
int inex_sin_re = 0, inex_cos_re = 0;
/* Until further notice, assume computations exact; in particular,
by definition, for not computed values. */
mpfr_t s, c;
int inex_s, inex_c;
int sign_im = mpfr_signbit (mpc_imagref (op));
/* sin(x +-0*i) = sin(x) +-0*i*sign(cos(x)) */
/* cos(x +-i*0) = cos(x) -+i*0*sign(sin(x)) */
if (rop_sin != 0)
mpfr_init2 (s, MPC_PREC_RE (rop_sin));
else
mpfr_init2 (s, 2); /* We need only the sign. */
if (rop_cos != NULL)
mpfr_init2 (c, MPC_PREC_RE (rop_cos));
else
mpfr_init2 (c, 2);
inex_s = mpfr_sin (s, mpc_realref (op), MPC_RND_RE (rnd_sin));
inex_c = mpfr_cos (c, mpc_realref (op), MPC_RND_RE (rnd_cos));
/* We cannot use mpfr_sin_cos since we may need two distinct rounding
modes and the exact return values. If we need only the sign, an
arbitrary rounding mode will work. */
if (rop_sin != NULL) {
mpfr_set (mpc_realref (rop_sin), s, MPFR_RNDN); /* exact */
inex_sin_re = inex_s;
mpfr_set_zero (mpc_imagref (rop_sin),
( ( sign_im && !mpfr_signbit(c))
|| (!sign_im && mpfr_signbit(c)) ? -1 : 1));
}
if (rop_cos != NULL) {
mpfr_set (mpc_realref (rop_cos), c, MPFR_RNDN); /* exact */
inex_cos_re = inex_c;
mpfr_set_zero (mpc_imagref (rop_cos),
( ( sign_im && mpfr_signbit(s))
|| (!sign_im && !mpfr_signbit(s)) ? -1 : 1));
}
mpfr_clear (s);
mpfr_clear (c);
return MPC_INEX12 (MPC_INEX (inex_sin_re, 0), MPC_INEX (inex_cos_re, 0));
}
void fmpq_poly_sample_D1(fmpq_poly_t f, int n, mpfr_prec_t prec, gmp_randstate_t state) {
mpfr_t u1; mpfr_init2(u1, prec);
mpfr_t u2; mpfr_init2(u2, prec);
mpfr_t z1; mpfr_init2(z1, prec);
mpfr_t z2; mpfr_init2(z2, prec);
mpfr_t pi2; mpfr_init2(pi2, prec);
mpfr_const_pi(pi2, MPFR_RNDN);
mpfr_mul_si(pi2, pi2, 2, MPFR_RNDN);
mpf_t tmp_f;
mpq_t tmp_q;
mpf_init(tmp_f);
mpq_init(tmp_q);
assert(n%2==0);
for(long i=0; i<n; i+=2) {
mpfr_urandomb(u1, state);
mpfr_urandomb(u2, state);
mpfr_log(u1, u1, MPFR_RNDN);
mpfr_mul_si(u1, u1, -2, MPFR_RNDN);
mpfr_sqrt(u1, u1, MPFR_RNDN);
mpfr_mul(u2, pi2, u2, MPFR_RNDN);
mpfr_cos(z1, u2, MPFR_RNDN);
mpfr_mul(z1, z1, u1, MPFR_RNDN); //z1 = sqrt(-2*log(u1)) * cos(2*pi*u2)
mpfr_sin(z2, u2, MPFR_RNDN);
mpfr_mul(z2, z2, u1, MPFR_RNDN); //z1 = sqrt(-2*log(u1)) * sin(2*pi*U2)
mpfr_get_f(tmp_f, z1, MPFR_RNDN);
mpq_set_f(tmp_q, tmp_f);
fmpq_poly_set_coeff_mpq(f, i, tmp_q);
mpfr_get_f(tmp_f, z2, MPFR_RNDN);
mpq_set_f(tmp_q, tmp_f);
fmpq_poly_set_coeff_mpq(f, i+1, tmp_q);
}
mpf_clear(tmp_f);
mpq_clear(tmp_q);
mpfr_clear(pi2);
mpfr_clear(u1);
mpfr_clear(u2);
mpfr_clear(z1);
mpfr_clear(z2);
}
static void
pure_imaginary_argument (void)
{
/* cosh(+0 +i*y) = cos y +i*0*sin y */
/* cosh(-0 +i*y) = cos y -i*0*sin y */
mpc_t u;
mpc_t z;
mpc_t cosh_z;
mpc_init2 (z, 2);
mpc_init2 (u, 100);
mpc_init2 (cosh_z, 100);
/* cosh(+0 +i) = cos(1) + i*0 */
mpc_set_ui_ui (z, 0, 1, MPC_RNDNN);
mpfr_cos (MPC_RE (u), MPC_IM (z), GMP_RNDN);
mpfr_set_ui (MPC_IM (u), 0, GMP_RNDN);
mpc_cosh (cosh_z, z, MPC_RNDNN);
if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z)))
TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN);
/* cosh(+0 -i) = cos(1) - i*0 */
mpc_conj (z, z, MPC_RNDNN);
mpc_conj (u, u, MPC_RNDNN);
mpc_cosh (cosh_z, z, MPC_RNDNN);
if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z)))
TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN);
/* cosh(-0 +i) = cos(1) - i*0 */
mpc_neg (z, z, MPC_RNDNN);
mpc_cosh (cosh_z, z, MPC_RNDNN);
if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z)))
TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN);
/* cosh(-0 -i) = cos(1) + i*0 */
mpc_conj (z, z, MPC_RNDNN);
mpc_conj (u, u, MPC_RNDNN);
mpc_cosh (cosh_z, z, MPC_RNDNN);
if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z)))
TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN);
mpc_clear (cosh_z);
mpc_clear (z);
mpc_clear (u);
}
static int
test_cos (mpfr_ptr a, mpfr_srcptr b, mpfr_rnd_t rnd_mode)
{
int res;
int ok = rnd_mode == MPFR_RNDN && mpfr_number_p (b) && mpfr_get_prec (a)>=53;
if (ok)
{
mpfr_print_raw (b);
}
res = mpfr_cos (a, b, rnd_mode);
if (ok)
{
printf (" ");
mpfr_print_raw (a);
printf ("\n");
}
return res;
}
//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_float::cos() {
#ifdef KNUMBER_USE_MPFR
mpfr_t mpfr;
mpfr_init_set_f(mpfr, mpf_, rounding_mode);
mpfr_cos(mpfr, mpfr, rounding_mode);
mpfr_get_f(mpf_, mpfr, rounding_mode);
mpfr_clear(mpfr);
return this;
#else
const double x = mpf_get_d(mpf_);
if(isinf(x)) {
delete this;
return new knumber_error(knumber_error::ERROR_POS_INFINITY);
} else {
return execute_libc_func< ::cos>(x);
}
#endif
}
REAL _cos(REAL a, REAL, QByteArray &)
{
mpfr_t tmp1; mpfr_init2(tmp1, NUMBITS);
mpfr_t result; mpfr_init2(result, NUMBITS);
try
{
// mpfr_init_set_f(tmp1, a.get_mpf_t(), MPFR_RNDN);
mpfr_set_str(tmp1, getString(a).data(), 10, MPFR_RNDN);
mpfr_cos(result, tmp1, MPFR_RNDN);
mpfr_get_f(a.get_mpf_t(), result, MPFR_RNDN);
}
catch(...)
{
mpfr_clear(tmp1);
mpfr_clear(result);
return ZERO;
}
mpfr_clear(tmp1);
mpfr_clear(result);
return a;
}
/* Bug reported by Laurent Fousse for the 2.4 branch.
No problem in the trunk.
https://sympa.inria.fr/sympa/arc/mpfr/2009-11/msg00044.html */
static void
bug20091122 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 3;
mpfr_rnd_t r = MPFR_RNDN;
mpfr_init2 (x, 5);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "0.11111E49", 2, MPFR_RNDN);
mpfr_sin_cos (yref, zref, x, r);
mpfr_sin (y, x, r);
mpfr_cos (z, x, r);
if (! mpfr_equal_p (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sin disagree (bug20091122)\n");
printf ("yref = "); mpfr_dump (yref);
printf ("y = "); mpfr_dump (y);
exit (1);
}
if (! mpfr_equal_p (z, zref))
{
printf ("mpfr_sin_cos and mpfr_cos disagree (bug20091122)\n");
printf ("zref = "); mpfr_dump (zref);
printf ("z = "); mpfr_dump (z);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
/// @brief tan keyword implementation
///
void program::rpn_tan(void) {
MIN_ARGUMENTS(1);
if (_stack->get_type(0) == cmd_number) {
floating_t* left = &((number*)_stack->get_obj(0))->_value;
CHECK_MPFR(mpfr_tan(left->mpfr, left->mpfr, floating_t::s_mpfr_rnd));
} else if (_stack->get_type(0) == cmd_complex) {
// tan(x+iy) = (sin(2x)+isinh(2y)) / cosh(2y)+cos(2x)
stack::copy_and_push_back(*_stack, _stack->size() - 1, _calc_stack);
floating_t* tmp = &((number*)_calc_stack.allocate_back(number::calc_size(), cmd_number))->_value;
floating_t* x = ((complex*)_calc_stack.get_obj(1))->re();
floating_t* y = ((complex*)_calc_stack.get_obj(1))->im();
floating_t* re = ((complex*)_stack->get_obj(0))->re();
floating_t* im = ((complex*)_stack->get_obj(0))->im();
// x->2x
CHECK_MPFR(mpfr_mul_si(x->mpfr, x->mpfr, 2, floating_t::s_mpfr_rnd));
// y->2y
CHECK_MPFR(mpfr_mul_si(y->mpfr, y->mpfr, 2, floating_t::s_mpfr_rnd));
// sin(2x)+sinh(2y)
CHECK_MPFR(mpfr_sin(re->mpfr, x->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_sinh(im->mpfr, y->mpfr, floating_t::s_mpfr_rnd));
// cosh(2y)+cos(2x)
CHECK_MPFR(mpfr_cosh(tmp->mpfr, y->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_cos(x->mpfr, x->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_add(tmp->mpfr, tmp->mpfr, x->mpfr, floating_t::s_mpfr_rnd));
// sin(2x)+sinh(2y) / (cosh(2y)+cos(2x))
CHECK_MPFR(mpfr_div(re->mpfr, re->mpfr, tmp->mpfr, floating_t::s_mpfr_rnd));
CHECK_MPFR(mpfr_div(im->mpfr, im->mpfr, tmp->mpfr, floating_t::s_mpfr_rnd));
_calc_stack.pop_back(2);
} else
ERR_CONTEXT(ret_bad_operand_type);
}
int fmpq_poly_oz_sqrt_approx_pade(fmpq_poly_t f_sqrt, const fmpq_poly_t f, const long n, const int p, const mpfr_prec_t prec, const mpfr_prec_t bound, oz_flag_t flags, const fmpq_poly_t init) {
fmpq_poly_t y; fmpq_poly_init(y);
fmpq_poly_t y_next; fmpq_poly_init(y_next);
fmpq_poly_t z; fmpq_poly_init(z);
fmpq_poly_t z_next; fmpq_poly_init(z_next);
mpfr_t norm; mpfr_init2(norm, prec);
mpfr_t prev_norm; mpfr_init2(prev_norm, prec);
mpfr_t log_f; mpfr_init2(log_f, prec);
if (init) {
// z = y/x
fmpq_poly_set(y, init);
_fmpq_poly_oz_invert_approx(z, f, n, prec);
fmpq_poly_oz_mul(z, z, y, n);
} else {
fmpq_poly_set(y, f);
fmpq_poly_set_coeff_si(z, 0, 1);
}
fmpq_t *xi = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_t *a2 = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_t *c = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_poly_t *t_ = (fmpq_poly_t*)calloc(p, sizeof(fmpq_poly_t));
fmpq_poly_t *s_ = (fmpq_poly_t*)calloc(p, sizeof(fmpq_poly_t));
mpfr_t pi; mpfr_init2(pi, 4*prec);
mpfr_const_pi(pi, MPFR_RNDN);
#pragma omp parallel for
for(int i=0; i<p; i++) {
mpfr_t xi_r; mpfr_init2(xi_r, 4*prec);
mpfr_t a2_r; mpfr_init2(a2_r, 4*prec);
/* ζ_i = 1/2 * (1 + cos( (2·i -1)·π/(2·p) )) */
mpfr_set_si(xi_r, 2*i+1, MPFR_RNDN);
mpfr_mul(xi_r, xi_r, pi, MPFR_RNDN);
mpfr_div_si(xi_r, xi_r, 2*p, MPFR_RNDN);
mpfr_cos(xi_r, xi_r, MPFR_RNDN);
mpfr_add_si(xi_r, xi_r, 1, MPFR_RNDN);
mpfr_div_si(xi_r, xi_r, 2, MPFR_RNDN);
/* α_i^2 = 1/ζ_i -1 */
mpfr_set_si(a2_r, 1, MPFR_RNDN);
mpfr_div(a2_r, a2_r, xi_r, MPFR_RNDN);
mpfr_sub_si(a2_r, a2_r, 1, MPFR_RNDN);
fmpq_init(xi[i]);
fmpq_init(a2[i]);
fmpq_set_mpfr(xi[i], xi_r, MPFR_RNDN);
fmpq_set_mpfr(a2[i], a2_r, MPFR_RNDN);
fmpq_init(c[i]);
fmpq_poly_init(t_[i]);
fmpq_poly_init(s_[i]);
mpfr_clear(xi_r);
mpfr_clear(a2_r);
}
mpfr_clear(pi);
uint64_t t = oz_walltime(0);
int r = 0;
int cont = 1;
for(long k=0; cont; k++) {
if (k == 0 || mpfr_cmp_ui(prev_norm, 1) > 0)
_fmpq_poly_oz_sqrt_approx_scale(y, z, n, prec);
/* T = sum([1/xi[i] * ~(Z*Y + a2[i]) for i in range(p)]) */
#pragma omp parallel for
for(int i=0; i<p; i++) {
fmpq_poly_oz_mul(t_[i], z, y, n);
fmpq_poly_get_coeff_fmpq(c[i], t_[i], 0);
fmpq_add(c[i], c[i], a2[i]);
fmpq_poly_set_coeff_fmpq(t_[i], 0, c[i]);
fmpq_poly_scalar_mul_fmpq(t_[i], t_[i], xi[i]);
_fmpq_poly_oz_invert_approx(s_[i], t_[i], n, prec);
}
for(int i=1; i<p; i++)
fmpq_poly_add(s_[0], s_[0], s_[i]);
#pragma omp parallel sections
{
#pragma omp section
{
fmpq_poly_oz_mul(y_next, y, s_[0], n);
fmpq_poly_scalar_div_si(y_next, y_next, p);
fmpq_poly_set(y, y_next);
}
#pragma omp section
{
fmpq_poly_oz_mul(z_next, z, s_[0], n);
fmpq_poly_scalar_div_si(z_next, z_next, p);
fmpq_poly_set(z, z_next);
}
}
cont = !_fmpq_poly_oz_sqrt_approx_break(norm, y, f, n, bound, prec);
if(flags & OZ_VERBOSE) {
mpfr_log2(log_f, norm, MPFR_RNDN);
mpfr_fprintf(stderr, "Computing sqrt(Σ):: k: %4d, Δ=|sqrt(Σ)^2-Σ|: %7.2Rf", k, log_f);
fprintf(stderr, " <? %4ld, ", -bound);
fprintf(stderr, "t: %8.2fs\n", oz_seconds(oz_walltime(t)));
fflush(0);
}
if (cont) {
if (k>0 && mpfr_cmp_ui_2exp(norm, 1, bound) >= 0) {
/* something went really wrong */
r = -1;
break;
}
if (k>0 && mpfr_cmp(norm, prev_norm) >= 0) {
/* we don't converge any more */
r = 1;
break;
}
mpfr_set(prev_norm, norm, MPFR_RNDN);
}
}
for(int i=0; i<p; i++) {
fmpq_clear(xi[i]);
fmpq_clear(a2[i]);
fmpq_clear(c[i]);
fmpq_poly_clear(t_[i]);
fmpq_poly_clear(s_[i]);
}
free(xi);
free(a2);
free(c);
free(t_);
free(s_);
mpfr_clear(log_f);
fmpq_poly_set(f_sqrt, y);
mpfr_clear(norm);
mpfr_clear(prev_norm);
fmpq_poly_clear(y_next);
fmpq_poly_clear(y);
fmpq_poly_clear(z_next);
fmpq_poly_clear(z);
return r;
}
static void
overflowed_cos0 (void)
{
mpfr_t x, y;
int emax, i, inex, rnd, err = 0;
mpfr_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (emax = -1; emax <= 0; emax++)
{
mpfr_set_ui_2exp (y, 1, emax, MPFR_RNDN);
mpfr_nextbelow (y);
set_emax (emax); /* 1 is not representable. */
/* and if emax < 0, 1 - eps is not representable either. */
for (i = -1; i <= 1; i++)
RND_LOOP (rnd)
{
mpfr_set_si_2exp (x, i, -512 * ABS (i), MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_cos (x, x, (mpfr_rnd_t) rnd);
if ((i == 0 || emax < 0 || rnd == MPFR_RNDN || rnd == MPFR_RNDU) &&
! mpfr_overflow_p ())
{
printf ("Error in overflowed_cos0 (i = %d, rnd = %s):\n"
" The overflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (rnd == MPFR_RNDZ || rnd == MPFR_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_cos0 (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_cos0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E%d.\n", emax);
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_cos0 (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_cos0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
int n, prec, st, st2, N, i;
mpfr_t x, y, z;
if (argc != 2 && argc != 3)
{
fprintf(stderr, "Usage: timing digits \n");
exit(1);
}
printf ("Using MPFR-%s with GMP-%s\n", mpfr_version, gmp_version);
n = atoi(argv[1]);
prec = (int) ( n * log(10.0) / log(2.0) + 1.0 );
printf("[precision is %u bits]\n", prec);
mpfr_init2(x, prec); mpfr_init2(y, prec); mpfr_init2(z, prec);
mpfr_set_d(x, 3.0, GMP_RNDN); mpfr_sqrt(x, x, GMP_RNDN); mpfr_sub_ui (x, x, 1, GMP_RNDN);
mpfr_set_d(y, 5.0, GMP_RNDN); mpfr_sqrt(y, y, GMP_RNDN);
mpfr_log (z, x, GMP_RNDN);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_mul(z, x, y, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("x*y took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_mul(z, x, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("x*x took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_div(z, x, y, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("x/y took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_sqrt(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("sqrt(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_exp(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("exp(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_log(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("log(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_sin(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("sin(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_cos(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("cos(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_acos(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("arccos(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
N=1; st = cputime();
do {
for (i=0;i<N;i++) mpfr_atan(z, x, GMP_RNDN);
N=2*N;
st2=cputime();
} while (st2-st<1000);
printf("arctan(x) took %f ms (%d eval in %d ms)\n",
(double)(st2-st)/(N-1),N-1,st2-st);
mpfr_clear(x); mpfr_clear(y); mpfr_clear(z);
return 0;
}
int main()
{
long iter;
flint_rand_t state;
printf("cos....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t a, b;
fmpq_t q;
mpfr_t t;
long prec0, prec;
prec0 = 400;
if (iter % 100 == 0)
prec0 = 8000;
prec = 2 + n_randint(state, prec0);
arb_init(a);
arb_init(b);
fmpq_init(q);
mpfr_init2(t, prec0 + 100);
arb_randtest(a, state, 1 + n_randint(state, prec0), 6);
arb_randtest(b, state, 1 + n_randint(state, prec0), 6);
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, prec0));
fmpq_get_mpfr(t, q, MPFR_RNDN);
mpfr_cos(t, t, MPFR_RNDN);
arb_cos(b, a, prec);
if (!arb_contains_mpfr(b, t))
{
printf("FAIL: containment\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
abort();
}
arb_cos(a, a, prec);
if (!arb_equal(a, b))
{
printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* check large arguments */
for (iter = 0; iter < 1000000; iter++)
{
arb_t a, b, c, d;
long prec0, prec1, prec2;
if (iter % 10 == 0)
prec0 = 10000;
else
prec0 = 1000;
prec1 = 2 + n_randint(state, prec0);
prec2 = 2 + n_randint(state, prec0);
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_special(a, state, 1 + n_randint(state, prec0), prec0);
arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100);
arb_randtest_special(c, state, 1 + n_randint(state, prec0), 100);
arb_randtest_special(d, state, 1 + n_randint(state, prec0), 100);
arb_cos(b, a, prec1);
arb_cos(c, a, prec2);
if (!arb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
abort();
}
/* check cos(2a) = 2cos(a)^2-1 */
arb_mul_2exp_si(c, a, 1);
arb_cos(c, c, prec1);
arb_mul(b, b, b, prec1);
arb_mul_2exp_si(b, b, 1);
arb_sub_ui(b, b, 1, prec1);
if (!arb_overlaps(b, c))
{
printf("FAIL: functional equation\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
mpfr_t x, c, s, c2, s2;
tests_start_mpfr ();
check_regression ();
check_nans ();
/* worst case from PhD thesis of Vincent Lefe`vre: x=8980155785351021/2^54 */
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDN);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDD);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDZ);
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDU);
check53 ("1.00031274099908640274", "8.416399183372403892e-1", MPFR_RNDN);
check53 ("1.00229256850978698523", "8.427074524447979442e-1", MPFR_RNDZ);
check53 ("1.00288304857059840103", "8.430252033025980029e-1", MPFR_RNDZ);
check53 ("1.00591265847407274059", "8.446508805292128885e-1", MPFR_RNDN);
/* Other worst cases showing a bug introduced on 2005-01-29 in rev 3248 */
check53b ("1.0111001111010111010111111000010011010001110001111011e-21",
"1.0111001111010111010111111000010011010001101001110001e-21",
MPFR_RNDU);
check53b ("1.1011101111111010000001010111000010000111100100101101",
"1.1111100100101100001111100000110011110011010001010101e-1",
MPFR_RNDU);
mpfr_init2 (x, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
test_sin (x, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp (x, 3, -3)) /* x != 0.375 = 3/8 */
{
printf ("mpfr_sin(0.5, MPFR_RNDD) failed with precision=2\n");
exit (1);
}
/* bug found by Kevin Ryde */
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_ui (x, x, 3L, MPFR_RNDN);
mpfr_div_ui (x, x, 2L, MPFR_RNDN);
test_sin (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) >= 0)
{
printf ("Error: wrong sign for sin(3*Pi/2)\n");
exit (1);
}
/* Can fail on an assert */
mpfr_set_prec (x, 53);
mpfr_set_str (x, "77291789194529019661184401408", 10, MPFR_RNDN);
mpfr_init2 (c, 4); mpfr_init2 (s, 42);
mpfr_init2 (c2, 4); mpfr_init2 (s2, 42);
test_sin (s, x, MPFR_RNDN);
mpfr_cos (c, x, MPFR_RNDN);
mpfr_sin_cos (s2, c2, x, MPFR_RNDN);
if (mpfr_cmp (c2, c))
{
printf("cos differs for x=77291789194529019661184401408");
exit (1);
}
if (mpfr_cmp (s2, s))
{
printf("sin differs for x=77291789194529019661184401408");
exit (1);
}
mpfr_set_str_binary (x, "1.1001001000011111101101010100010001000010110100010011");
test_sin (x, x, MPFR_RNDZ);
if (mpfr_cmp_str (x, "1.1111111111111111111111111111111111111111111111111111e-1", 2, MPFR_RNDN))
{
printf ("Error for x= 1.1001001000011111101101010100010001000010110100010011\nGot ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (s, 9);
mpfr_set_prec (x, 190);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_sin (s, x, MPFR_RNDZ);
if (mpfr_cmp_str (s, "0.100000101e-196", 2, MPFR_RNDN))
{
printf ("Error for x ~= pi\n");
mpfr_dump (s);
exit (1);
}
mpfr_clear (s2);
mpfr_clear (c2);
mpfr_clear (s);
mpfr_clear (c);
mpfr_clear (x);
test_generic (2, 100, 15);
test_generic (MPFR_SINCOS_THRESHOLD-1, MPFR_SINCOS_THRESHOLD+1, 2);
test_sign ();
check_tiny ();
data_check ("data/sin", mpfr_sin, "mpfr_sin");
bad_cases (mpfr_sin, mpfr_asin, "mpfr_sin", 256, -40, 0, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
/* (y, z) <- (sin(x), cos(x)), return value is 0 iff both results are exact
ie, iff x = 0 */
int
mpfr_sin_cos (mpfr_ptr y, mpfr_ptr z, mpfr_srcptr x, mp_rnd_t rnd_mode)
{
mp_prec_t prec, m;
int neg, reduce;
mpfr_t c, xr;
mpfr_srcptr xx;
mp_exp_t err, expx;
MPFR_ZIV_DECL (loop);
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
{
if (MPFR_IS_NAN(x) || MPFR_IS_INF(x))
{
MPFR_SET_NAN (y);
MPFR_SET_NAN (z);
MPFR_RET_NAN;
}
else /* x is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (x));
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
/* y = 0, thus exact, but z is inexact in case of underflow
or overflow */
return mpfr_set_ui (z, 1, rnd_mode);
}
}
MPFR_LOG_FUNC (("x[%#R]=%R rnd=%d", x, x, rnd_mode),
("sin[%#R]=%R cos[%#R]=%R", y, y, z, z));
prec = MAX (MPFR_PREC (y), MPFR_PREC (z));
m = prec + MPFR_INT_CEIL_LOG2 (prec) + 13;
expx = MPFR_GET_EXP (x);
mpfr_init (c);
mpfr_init (xr);
MPFR_ZIV_INIT (loop, m);
for (;;)
{
/* the following is copied from sin.c */
if (expx >= 2) /* reduce the argument */
{
reduce = 1;
mpfr_set_prec (c, expx + m - 1);
mpfr_set_prec (xr, m);
mpfr_const_pi (c, GMP_RNDN);
mpfr_mul_2ui (c, c, 1, GMP_RNDN);
mpfr_remainder (xr, x, c, GMP_RNDN);
mpfr_div_2ui (c, c, 1, GMP_RNDN);
if (MPFR_SIGN (xr) > 0)
mpfr_sub (c, c, xr, GMP_RNDZ);
else
mpfr_add (c, c, xr, GMP_RNDZ);
if (MPFR_IS_ZERO(xr) || MPFR_EXP(xr) < (mp_exp_t) 3 - (mp_exp_t) m
|| MPFR_EXP(c) < (mp_exp_t) 3 - (mp_exp_t) m)
goto next_step;
xx = xr;
}
else /* the input argument is already reduced */
{
reduce = 0;
xx = x;
}
neg = MPFR_IS_NEG (xx); /* gives sign of sin(x) */
mpfr_set_prec (c, m);
mpfr_cos (c, xx, GMP_RNDZ);
/* If no argument reduction was performed, the error is at most ulp(c),
otherwise it is at most ulp(c) + 2^(2-m). Since |c| < 1, we have
ulp(c) <= 2^(-m), thus the error is bounded by 2^(3-m) in that later
case. */
if (reduce == 0)
err = m;
else
err = MPFR_GET_EXP (c) + (mp_exp_t) (m - 3);
if (!mpfr_can_round (c, err, GMP_RNDN, rnd_mode,
MPFR_PREC (z) + (rnd_mode == GMP_RNDN)))
goto next_step;
mpfr_set (z, c, rnd_mode);
mpfr_sqr (c, c, GMP_RNDU);
mpfr_ui_sub (c, 1, c, GMP_RNDN);
err = 2 + (- MPFR_GET_EXP (c)) / 2;
mpfr_sqrt (c, c, GMP_RNDN);
if (neg)
MPFR_CHANGE_SIGN (c);
/* the absolute error on c is at most 2^(err-m), which we must put
in the form 2^(EXP(c)-err). If there was an argument reduction,
we need to add 2^(2-m); since err >= 2, the error is bounded by
2^(err+1-m) in that case. */
err = MPFR_GET_EXP (c) + (mp_exp_t) m - (err + reduce);
if (mpfr_can_round (c, err, GMP_RNDN, rnd_mode,
MPFR_PREC (y) + (rnd_mode == GMP_RNDN)))
break;
/* check for huge cancellation */
if (err < (mp_exp_t) MPFR_PREC (y))
m += MPFR_PREC (y) - err;
/* Check if near 1 */
if (MPFR_GET_EXP (c) == 1
&& MPFR_MANT (c)[MPFR_LIMB_SIZE (c)-1] == MPFR_LIMB_HIGHBIT)
m += m;
next_step:
MPFR_ZIV_NEXT (loop, m);
mpfr_set_prec (c, m);
}
MPFR_ZIV_FREE (loop);
mpfr_set (y, c, rnd_mode);
mpfr_clear (c);
mpfr_clear (xr);
MPFR_RET (1); /* Always inexact */
}
int
mpc_exp (mpc_ptr rop, mpc_srcptr op, mpc_rnd_t rnd)
{
mpfr_t x, y, z;
mpfr_prec_t prec;
int ok = 0;
int inex_re, inex_im;
int saved_underflow, saved_overflow;
/* special values */
if (mpfr_nan_p (mpc_realref (op)) || mpfr_nan_p (mpc_imagref (op)))
/* NaNs
exp(nan +i*y) = nan -i*0 if y = -0,
nan +i*0 if y = +0,
nan +i*nan otherwise
exp(x+i*nan) = +/-0 +/-i*0 if x=-inf,
+/-inf +i*nan if x=+inf,
nan +i*nan otherwise */
{
if (mpfr_zero_p (mpc_imagref (op)))
return mpc_set (rop, op, MPC_RNDNN);
if (mpfr_inf_p (mpc_realref (op)))
{
if (mpfr_signbit (mpc_realref (op)))
return mpc_set_ui_ui (rop, 0, 0, MPC_RNDNN);
else
{
mpfr_set_inf (mpc_realref (rop), +1);
mpfr_set_nan (mpc_imagref (rop));
return MPC_INEX(0, 0); /* Inf/NaN are exact */
}
}
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
return MPC_INEX(0, 0); /* NaN is exact */
}
if (mpfr_zero_p (mpc_imagref(op)))
/* special case when the input is real
exp(x-i*0) = exp(x) -i*0, even if x is NaN
exp(x+i*0) = exp(x) +i*0, even if x is NaN */
{
inex_re = mpfr_exp (mpc_realref(rop), mpc_realref(op), MPC_RND_RE(rnd));
inex_im = mpfr_set (mpc_imagref(rop), mpc_imagref(op), MPC_RND_IM(rnd));
return MPC_INEX(inex_re, inex_im);
}
if (mpfr_zero_p (mpc_realref (op)))
/* special case when the input is imaginary */
{
inex_re = mpfr_cos (mpc_realref (rop), mpc_imagref (op), MPC_RND_RE(rnd));
inex_im = mpfr_sin (mpc_imagref (rop), mpc_imagref (op), MPC_RND_IM(rnd));
return MPC_INEX(inex_re, inex_im);
}
if (mpfr_inf_p (mpc_realref (op)))
/* real part is an infinity,
exp(-inf +i*y) = 0*(cos y +i*sin y)
exp(+inf +i*y) = +/-inf +i*nan if y = +/-inf
+inf*(cos y +i*sin y) if 0 < |y| < inf */
{
mpfr_t n;
mpfr_init2 (n, 2);
if (mpfr_signbit (mpc_realref (op)))
mpfr_set_ui (n, 0, GMP_RNDN);
else
mpfr_set_inf (n, +1);
if (mpfr_inf_p (mpc_imagref (op)))
{
inex_re = mpfr_set (mpc_realref (rop), n, GMP_RNDN);
if (mpfr_signbit (mpc_realref (op)))
inex_im = mpfr_set (mpc_imagref (rop), n, GMP_RNDN);
else
{
mpfr_set_nan (mpc_imagref (rop));
inex_im = 0; /* NaN is exact */
}
}
else
{
mpfr_t c, s;
mpfr_init2 (c, 2);
mpfr_init2 (s, 2);
mpfr_sin_cos (s, c, mpc_imagref (op), GMP_RNDN);
inex_re = mpfr_copysign (mpc_realref (rop), n, c, GMP_RNDN);
inex_im = mpfr_copysign (mpc_imagref (rop), n, s, GMP_RNDN);
mpfr_clear (s);
mpfr_clear (c);
}
mpfr_clear (n);
return MPC_INEX(inex_re, inex_im);
}
if (mpfr_inf_p (mpc_imagref (op)))
/* real part is finite non-zero number, imaginary part is an infinity */
{
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
return MPC_INEX(0, 0); /* NaN is exact */
}
/* from now on, both parts of op are regular numbers */
prec = MPC_MAX_PREC(rop)
+ MPC_MAX (MPC_MAX (-mpfr_get_exp (mpc_realref (op)), 0),
-mpfr_get_exp (mpc_imagref (op)));
/* When op is close to 0, then exp is close to 1+Re(op), while
cos is close to 1-Im(op); to decide on the ternary value of exp*cos,
we need a high enough precision so that none of exp or cos is
computed as 1. */
mpfr_init2 (x, 2);
mpfr_init2 (y, 2);
mpfr_init2 (z, 2);
/* save the underflow or overflow flags from MPFR */
saved_underflow = mpfr_underflow_p ();
saved_overflow = mpfr_overflow_p ();
do
{
prec += mpc_ceil_log2 (prec) + 5;
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_prec (z, prec);
/* FIXME: x may overflow so x.y does overflow too, while Re(exp(op))
could be represented in the precision of rop. */
mpfr_clear_overflow ();
mpfr_clear_underflow ();
mpfr_exp (x, mpc_realref(op), GMP_RNDN); /* error <= 0.5ulp */
mpfr_sin_cos (z, y, mpc_imagref(op), GMP_RNDN); /* errors <= 0.5ulp */
mpfr_mul (y, y, x, GMP_RNDN); /* error <= 2ulp */
ok = mpfr_overflow_p () || mpfr_zero_p (x)
|| mpfr_can_round (y, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_RE(rop) + (MPC_RND_RE(rnd) == GMP_RNDN));
if (ok) /* compute imaginary part */
{
mpfr_mul (z, z, x, GMP_RNDN);
ok = mpfr_overflow_p () || mpfr_zero_p (x)
|| mpfr_can_round (z, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_IM(rop) + (MPC_RND_IM(rnd) == GMP_RNDN));
}
}
while (ok == 0);
inex_re = mpfr_set (mpc_realref(rop), y, MPC_RND_RE(rnd));
inex_im = mpfr_set (mpc_imagref(rop), z, MPC_RND_IM(rnd));
if (mpfr_overflow_p ()) {
/* overflow in real exponential, inex is sign of infinite result */
inex_re = mpfr_sgn (y);
inex_im = mpfr_sgn (z);
}
else if (mpfr_underflow_p ()) {
/* underflow in real exponential, inex is opposite of sign of 0 result */
inex_re = (mpfr_signbit (y) ? +1 : -1);
inex_im = (mpfr_signbit (z) ? +1 : -1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
/* restore underflow and overflow flags from MPFR */
if (saved_underflow)
mpfr_set_underflow ();
if (saved_overflow)
mpfr_set_overflow ();
return MPC_INEX(inex_re, inex_im);
}
int
mpfr_sin (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
mpfr_t c, xr;
mpfr_srcptr xx;
mpfr_exp_t expx, err;
mpfr_prec_t precy, m;
int inexact, sign, reduce;
MPFR_ZIV_DECL (loop);
MPFR_SAVE_EXPO_DECL (expo);
MPFR_LOG_FUNC (("x[%#R]=%R rnd=%d", x, x, rnd_mode),
("y[%#R]=%R inexact=%d", y, y, inexact));
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
{
if (MPFR_IS_NAN (x) || MPFR_IS_INF (x))
{
MPFR_SET_NAN (y);
MPFR_RET_NAN;
}
else /* x is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (x));
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0);
}
}
/* sin(x) = x - x^3/6 + ... so the error is < 2^(3*EXP(x)-2) */
MPFR_FAST_COMPUTE_IF_SMALL_INPUT (y, x, -2 * MPFR_GET_EXP (x), 2, 0,
rnd_mode, {});
MPFR_SAVE_EXPO_MARK (expo);
/* Compute initial precision */
precy = MPFR_PREC (y);
if (precy >= MPFR_SINCOS_THRESHOLD)
return mpfr_sin_fast (y, x, rnd_mode);
m = precy + MPFR_INT_CEIL_LOG2 (precy) + 13;
expx = MPFR_GET_EXP (x);
mpfr_init (c);
mpfr_init (xr);
MPFR_ZIV_INIT (loop, m);
for (;;)
{
/* first perform argument reduction modulo 2*Pi (if needed),
also helps to determine the sign of sin(x) */
if (expx >= 2) /* If Pi < x < 4, we need to reduce too, to determine
the sign of sin(x). For 2 <= |x| < Pi, we could avoid
the reduction. */
{
reduce = 1;
/* As expx + m - 1 will silently be converted into mpfr_prec_t
in the mpfr_set_prec call, the assert below may be useful to
avoid undefined behavior. */
MPFR_ASSERTN (expx + m - 1 <= MPFR_PREC_MAX);
mpfr_set_prec (c, expx + m - 1);
mpfr_set_prec (xr, m);
mpfr_const_pi (c, MPFR_RNDN);
mpfr_mul_2ui (c, c, 1, MPFR_RNDN);
mpfr_remainder (xr, x, c, MPFR_RNDN);
/* The analysis is similar to that of cos.c:
|xr - x - 2kPi| <= 2^(2-m). Thus we can decide the sign
of sin(x) if xr is at distance at least 2^(2-m) of both
0 and +/-Pi. */
mpfr_div_2ui (c, c, 1, MPFR_RNDN);
/* Since c approximates Pi with an error <= 2^(2-expx-m) <= 2^(-m),
it suffices to check that c - |xr| >= 2^(2-m). */
if (MPFR_SIGN (xr) > 0)
mpfr_sub (c, c, xr, MPFR_RNDZ);
else
mpfr_add (c, c, xr, MPFR_RNDZ);
if (MPFR_IS_ZERO(xr)
|| MPFR_EXP(xr) < (mpfr_exp_t) 3 - (mpfr_exp_t) m
|| MPFR_EXP(c) < (mpfr_exp_t) 3 - (mpfr_exp_t) m)
goto ziv_next;
/* |xr - x - 2kPi| <= 2^(2-m), thus |sin(xr) - sin(x)| <= 2^(2-m) */
xx = xr;
}
else /* the input argument is already reduced */
{
reduce = 0;
xx = x;
}
sign = MPFR_SIGN(xx);
/* now that the argument is reduced, precision m is enough */
mpfr_set_prec (c, m);
mpfr_cos (c, xx, MPFR_RNDZ); /* can't be exact */
mpfr_nexttoinf (c); /* now c = cos(x) rounded away */
mpfr_mul (c, c, c, MPFR_RNDU); /* away */
mpfr_ui_sub (c, 1, c, MPFR_RNDZ);
mpfr_sqrt (c, c, MPFR_RNDZ);
if (MPFR_IS_NEG_SIGN(sign))
MPFR_CHANGE_SIGN(c);
/* Warning: c may be 0! */
if (MPFR_UNLIKELY (MPFR_IS_ZERO (c)))
{
/* Huge cancellation: increase prec a lot! */
m = MAX (m, MPFR_PREC (x));
m = 2 * m;
}
else
{
/* the absolute error on c is at most 2^(3-m-EXP(c)),
plus 2^(2-m) if there was an argument reduction.
Since EXP(c) <= 1, 3-m-EXP(c) >= 2-m, thus the error
is at most 2^(3-m-EXP(c)) in case of argument reduction. */
err = 2 * MPFR_GET_EXP (c) + (mpfr_exp_t) m - 3 - (reduce != 0);
if (MPFR_CAN_ROUND (c, err, precy, rnd_mode))
break;
/* check for huge cancellation (Near 0) */
if (err < (mpfr_exp_t) MPFR_PREC (y))
m += MPFR_PREC (y) - err;
/* Check if near 1 */
if (MPFR_GET_EXP (c) == 1)
m += m;
}
ziv_next:
/* Else generic increase */
MPFR_ZIV_NEXT (loop, m);
}
MPFR_ZIV_FREE (loop);
inexact = mpfr_set (y, c, rnd_mode);
/* inexact cannot be 0, since this would mean that c was representable
within the target precision, but in that case mpfr_can_round will fail */
mpfr_clear (c);
mpfr_clear (xr);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (y, inexact, rnd_mode);
}
/* (y, z) <- (sin(x), cos(x)), return value is 0 iff both results are exact */
int
mpfr_sin_cos (mpfr_ptr y, mpfr_ptr z, mpfr_srcptr x, mp_rnd_t rnd_mode)
{
int prec, m, ok, e, inexact, neg;
mpfr_t c, k;
if (MPFR_IS_NAN(x) || MPFR_IS_INF(x))
{
MPFR_SET_NAN(y);
MPFR_SET_NAN(z);
MPFR_RET_NAN;
}
if (MPFR_IS_ZERO(x))
{
MPFR_CLEAR_FLAGS(y);
MPFR_SET_ZERO(y);
MPFR_SET_SAME_SIGN(y, x);
mpfr_set_ui (z, 1, GMP_RNDN);
MPFR_RET(0);
}
prec = MAX(MPFR_PREC(y), MPFR_PREC(z));
m = prec + _mpfr_ceil_log2 ((double) prec) + ABS(MPFR_EXP(x)) + 13;
mpfr_init2 (c, m);
mpfr_init2 (k, m);
/* first determine sign */
mpfr_const_pi (c, GMP_RNDN);
mpfr_mul_2ui (c, c, 1, GMP_RNDN); /* 2*Pi */
mpfr_div (k, x, c, GMP_RNDN); /* x/(2*Pi) */
mpfr_floor (k, k); /* floor(x/(2*Pi)) */
mpfr_mul (c, k, c, GMP_RNDN);
mpfr_sub (k, x, c, GMP_RNDN); /* 0 <= k < 2*Pi */
mpfr_const_pi (c, GMP_RNDN); /* cached */
neg = mpfr_cmp (k, c) > 0;
mpfr_clear (k);
do
{
mpfr_cos (c, x, GMP_RNDZ);
if ((ok = mpfr_can_round (c, m, GMP_RNDZ, rnd_mode, MPFR_PREC(z))))
{
inexact = mpfr_set (z, c, rnd_mode);
mpfr_mul (c, c, c, GMP_RNDU);
mpfr_ui_sub (c, 1, c, GMP_RNDN);
e = 2 + (-MPFR_EXP(c)) / 2;
mpfr_sqrt (c, c, GMP_RNDN);
if (neg)
mpfr_neg (c, c, GMP_RNDN);
/* the absolute error on c is at most 2^(e-m) = 2^(EXP(c)-err) */
e = MPFR_EXP(c) + m - e;
ok = (e >= 0) && mpfr_can_round (c, e, GMP_RNDN, rnd_mode,
MPFR_PREC(y));
}
if (ok == 0)
{
m += _mpfr_ceil_log2 ((double) m);
mpfr_set_prec (c, m);
}
}
while (ok == 0);
inexact = mpfr_set (y, c, rnd_mode) || inexact;
mpfr_clear (c);
return inexact; /* inexact */
}
static void
consistency (void)
{
mpfr_t x, s1, s2, c1, c2;
mpfr_exp_t emin, emax;
mpfr_rnd_t rnd;
unsigned int flags_sin, flags_cos, flags, flags_before, flags_ref;
int inex_sin, is, inex_cos, ic, inex, inex_ref;
int i;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
for (i = 0; i <= 10000; i++)
{
mpfr_init2 (x, MPFR_PREC_MIN + (randlimb () % 8));
mpfr_inits2 (MPFR_PREC_MIN + (randlimb () % 8), s1, s2, c1, c2,
(mpfr_ptr) 0);
if (i < 8 * MPFR_RND_MAX)
{
int j = i / MPFR_RND_MAX;
if (j & 1)
mpfr_set_emin (MPFR_EMIN_MIN);
mpfr_set_si (x, (j & 2) ? 1 : -1, MPFR_RNDN);
mpfr_set_exp (x, mpfr_get_emin ());
rnd = (mpfr_rnd_t) (i % MPFR_RND_MAX);
flags_before = 0;
if (j & 4)
mpfr_set_emax (-17);
}
else
{
tests_default_random (x, 256, -5, 50, 0);
rnd = RND_RAND ();
flags_before = (randlimb () & 1) ?
(unsigned int) (MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE) :
(unsigned int) 0;
}
__gmpfr_flags = flags_before;
inex_sin = mpfr_sin (s1, x, rnd);
is = inex_sin < 0 ? 2 : inex_sin > 0 ? 1 : 0;
flags_sin = __gmpfr_flags;
__gmpfr_flags = flags_before;
inex_cos = mpfr_cos (c1, x, rnd);
ic = inex_cos < 0 ? 2 : inex_cos > 0 ? 1 : 0;
flags_cos = __gmpfr_flags;
__gmpfr_flags = flags_before;
inex = mpfr_sin_cos (s2, c2, x, rnd);
flags = __gmpfr_flags;
inex_ref = is + 4 * ic;
flags_ref = flags_sin | flags_cos;
if (!(mpfr_equal_p (s1, s2) && mpfr_equal_p (c1, c2)) ||
inex != inex_ref || flags != flags_ref)
{
printf ("mpfr_sin_cos and mpfr_sin/mpfr_cos disagree on %s,"
" i = %d\nx = ", mpfr_print_rnd_mode (rnd), i);
mpfr_dump (x);
printf ("s1 = ");
mpfr_dump (s1);
printf ("s2 = ");
mpfr_dump (s2);
printf ("c1 = ");
mpfr_dump (c1);
printf ("c2 = ");
mpfr_dump (c2);
printf ("inex_sin = %d (s = %d), inex_cos = %d (c = %d), "
"inex = %d (expected %d)\n",
inex_sin, is, inex_cos, ic, inex, inex_ref);
printf ("flags_sin = 0x%x, flags_cos = 0x%x, "
"flags = 0x%x (expected 0x%x)\n",
flags_sin, flags_cos, flags, flags_ref);
exit (1);
}
mpfr_clears (x, s1, s2, c1, c2, (mpfr_ptr) 0);
mpfr_set_emin (emin);
mpfr_set_emax (emax);
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double *prec,*eoutr,*eouti;
int mrows,ncols;
char *input_buf;
char *w1,*w2;
int buflen,status;
mpfr_t xr,xi,yr,yi,zr,zi,temp,temp1,temp2,temp3,temp4;
mp_exp_t expptr;
/* Check for proper number of arguments. */
if(nrhs!=5) {
mexErrMsgTxt("5 inputs required.");
} else if(nlhs>4) {
mexErrMsgTxt("Too many output arguments");
}
/* The input must be a noncomplex scalar double.*/
mrows = mxGetM(prhs[0]);
ncols = mxGetN(prhs[0]);
if( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
!(mrows==1 && ncols==1) ) {
mexErrMsgTxt("Input must be a noncomplex scalar double.");
}
/* Set precision and initialize mpfr variables */
prec = mxGetPr(prhs[0]);
mpfr_set_default_prec(*prec);
mpfr_init(xr); mpfr_init(xi);
mpfr_init(yr); mpfr_init(yi);
mpfr_init(zr); mpfr_init(zi);
mpfr_init(temp); mpfr_init(temp1);
mpfr_init(temp2); mpfr_init(temp3);
mpfr_init(temp4);
/* Read the input strings into mpfr x real */
buflen = (mxGetM(prhs[1]) * mxGetN(prhs[1])) + 1;
input_buf=mxCalloc(buflen, sizeof(char));
status = mxGetString(prhs[1], input_buf, buflen);
mpfr_set_str(xr,input_buf,10,GMP_RNDN);
/* Read the input strings into mpfr x imag */
buflen = (mxGetM(prhs[2]) * mxGetN(prhs[2])) + 1;
input_buf=mxCalloc(buflen, sizeof(char));
status = mxGetString(prhs[2], input_buf, buflen);
mpfr_set_str(xi,input_buf,10,GMP_RNDN);
/* Read the input strings into mpfr y real */
buflen = (mxGetM(prhs[3]) * mxGetN(prhs[3])) + 1;
input_buf=mxCalloc(buflen, sizeof(char));
status = mxGetString(prhs[3], input_buf, buflen);
mpfr_set_str(yr,input_buf,10,GMP_RNDN);
/* Read the input strings into mpfr y imag */
buflen = (mxGetM(prhs[4]) * mxGetN(prhs[4])) + 1;
input_buf=mxCalloc(buflen, sizeof(char));
status = mxGetString(prhs[4], input_buf, buflen);
mpfr_set_str(yi,input_buf,10,GMP_RNDN);
/* Mathematical operation */
/* ln(magnitude) */
mpfr_mul(temp,xr,xr,GMP_RNDN);
mpfr_mul(temp1,xi,xi,GMP_RNDN);
mpfr_add(temp,temp,temp1,GMP_RNDN);
mpfr_sqrt(temp,temp,GMP_RNDN);
mpfr_log(temp,temp,GMP_RNDN);
/* angle */
mpfr_atan2(temp1,xi,xr,GMP_RNDN);
/* real exp */
mpfr_mul(temp3,temp,yr,GMP_RNDN);
mpfr_mul(temp2,temp1,yi,GMP_RNDN);
mpfr_sub(temp3,temp3,temp2,GMP_RNDN);
mpfr_exp(temp3,temp3,GMP_RNDN);
/* cos sin argument */
mpfr_mul(temp2,temp1,yr,GMP_RNDN);
mpfr_mul(temp4,temp,yi,GMP_RNDN);
mpfr_add(temp2,temp2,temp4,GMP_RNDN);
mpfr_cos(zr,temp2,GMP_RNDN);
mpfr_mul(zr,zr,temp3,GMP_RNDN);
mpfr_sin(zi,temp2,GMP_RNDN);
mpfr_mul(zi,zi,temp3,GMP_RNDN);
/* Retrieve results */
mxFree(input_buf);
input_buf=mpfr_get_str (NULL, &expptr, 10, 0, zr, GMP_RNDN);
w1=malloc(strlen(input_buf)+20);
w2=malloc(strlen(input_buf)+20);
if (strncmp(input_buf, "-", 1)==0){
strcpy(w2,&input_buf[1]);
sprintf(w1,"-.%se%i",w2,expptr);
} else {
strcpy(w2,&input_buf[0]);
sprintf(w1,"+.%se%i",w2,expptr);
}
plhs[0] = mxCreateString(w1);
/* plhs[1] = mxCreateDoubleMatrix(mrows,ncols, mxREAL); */
/* eoutr=mxGetPr(plhs[1]); */
/* *eoutr=expptr; */
mpfr_free_str(input_buf);
input_buf=mpfr_get_str (NULL, &expptr, 10, 0, zi, GMP_RNDN);
free(w1);
free(w2);
w1=malloc(strlen(input_buf)+20);
w2=malloc(strlen(input_buf)+20);
if (strncmp(input_buf, "-", 1)==0){
strcpy(w2,&input_buf[1]);
sprintf(w1,"-.%se%i",w2,expptr);
} else {
strcpy(w2,&input_buf[0]);
sprintf(w1,"+.%se%i",w2,expptr);
}
plhs[1] = mxCreateString(w1);
/* plhs[3] = mxCreateDoubleMatrix(mrows,ncols, mxREAL); */
/* eouti=mxGetPr(plhs[3]); */
/* *eouti=expptr; */
mpfr_clear(xr); mpfr_clear(xi);
mpfr_clear(yr); mpfr_clear(yi);
mpfr_clear(zr); mpfr_clear(zi);
mpfr_clear(temp); mpfr_clear(temp1);
mpfr_clear(temp2); mpfr_clear(temp3);
mpfr_clear(temp4);
mpfr_free_str(input_buf);
free(w1);
free(w2);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
int inex;
tests_start_mpfr ();
special_overflow ();
check_nans ();
mpfr_init (x);
mpfr_init (y);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 2);
mpfr_set_str (x, "9.81333845856942e-1", 10, MPFR_RNDN);
test_cos (y, x, MPFR_RNDN);
mpfr_set_prec (x, 30);
mpfr_set_prec (y, 30);
mpfr_set_str_binary (x, "1.00001010001101110010100010101e-1");
test_cos (y, x, MPFR_RNDU);
mpfr_set_str_binary (x, "1.10111100010101011110101010100e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for prec=30, rnd=MPFR_RNDU\n");
printf ("expected "); mpfr_print_binary (x); puts ("");
printf (" got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 59);
mpfr_set_prec (y, 59);
mpfr_set_str_binary (x, "1.01101011101111010011111110111111111011011101100111100011e-3");
test_cos (y, x, MPFR_RNDU);
mpfr_set_str_binary (x, "1.1111011111110010001001001011100111101110100010000010010011e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for prec=59, rnd=MPFR_RNDU\n");
printf ("expected "); mpfr_print_binary (x); puts ("");
printf (" got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 5);
mpfr_set_prec (y, 5);
mpfr_set_str_binary (x, "1.1100e-2");
test_cos (y, x, MPFR_RNDD);
mpfr_set_str_binary (x, "1.1100e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for x=1.1100e-2, rnd=MPFR_RNDD\n");
printf ("expected 1.1100e-1, got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.10001000001001011000100001E-6");
mpfr_set_str_binary (y, "0.1111111111111101101111001100001");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "-0.1101011110111100111010011001011E-1");
mpfr_set_str_binary (y, "0.11101001100110111011011010100011");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (2)\n");
exit (1);
}
/* huge argument reduction */
mpfr_set_str_binary (x, "0.10000010000001101011101111001011E40");
mpfr_set_str_binary (y, "0.10011000001111010000101011001011E-1");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (3)\n");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 3);
mpfr_set_str_binary (x, "0.110E60");
inex = mpfr_cos (y, x, MPFR_RNDD);
MPFR_ASSERTN(inex < 0);
/* worst case from PhD thesis of Vincent Lefe`vre: x=8980155785351021/2^54 */
check53 ("4.984987858808754279e-1", "8.783012931285841817e-1", MPFR_RNDN);
check53 ("4.984987858808754279e-1", "8.783012931285840707e-1", MPFR_RNDD);
check53 ("4.984987858808754279e-1", "8.783012931285840707e-1", MPFR_RNDZ);
check53 ("4.984987858808754279e-1", "8.783012931285841817e-1", MPFR_RNDU);
check53 ("1.00031274099908640274", "0.540039116973283217504", MPFR_RNDN);
check53 ("1.00229256850978698523", "0.538371757797526551137", MPFR_RNDZ);
check53 ("1.00288304857059840103", "0.537874062022526966409", MPFR_RNDZ);
check53 ("1.00591265847407274059", "0.53531755997839769456", MPFR_RNDN);
check53 ("1.00591265847407274059", "0.53531755997839769456", MPFR_RNDN);
overflowed_cos0 ();
test_generic (2, 100, 15);
/* check inexact flag */
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 13);
mpfr_set_str_binary (x, "-0.100E196");
inex = mpfr_cos (y, x, MPFR_RNDU);
mpfr_set_prec (x, 13);
mpfr_set_str_binary (x, "0.1111111100101");
MPFR_ASSERTN (inex > 0 && mpfr_equal_p (x, y));
mpfr_clear (x);
mpfr_clear (y);
bug20091030 ();
data_check ("data/cos", mpfr_cos, "mpfr_cos");
bad_cases (mpfr_cos, mpfr_acos, "mpfr_cos", 256, -40, 0, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
void bvisit(const Cos &x) {
apply(result_, *(x.get_arg()));
mpfr_cos(result_, result_, rnd_);
}
void
_arith_cos_minpoly(fmpz * coeffs, slong d, ulong n)
{
slong i, j;
fmpz * alpha;
fmpz_t half;
mpfr_t t, u;
mp_bitcnt_t prec;
slong exp;
if (n <= MAX_32BIT)
{
for (i = 0; i <= d; i++)
fmpz_set_si(coeffs + i, lookup_table[n - 1][i]);
return;
}
/* Direct formula for odd primes > 3 */
if (n_is_prime(n))
{
slong s = (n - 1) / 2;
switch (s % 4)
{
case 0:
fmpz_set_si(coeffs, WORD(1));
fmpz_set_si(coeffs + 1, -s);
break;
case 1:
fmpz_set_si(coeffs, WORD(1));
fmpz_set_si(coeffs + 1, s + 1);
break;
case 2:
fmpz_set_si(coeffs, WORD(-1));
fmpz_set_si(coeffs + 1, s);
break;
case 3:
fmpz_set_si(coeffs, WORD(-1));
fmpz_set_si(coeffs + 1, -s - 1);
break;
}
for (i = 2; i <= s; i++)
{
slong b = (s - i) % 2;
fmpz_mul2_uiui(coeffs + i, coeffs + i - 2, s+i-b, s+2-b-i);
fmpz_divexact2_uiui(coeffs + i, coeffs + i, i, i-1);
fmpz_neg(coeffs + i, coeffs + i);
}
return;
}
prec = magnitude_bound(d) + 5 + FLINT_BIT_COUNT(d);
alpha = _fmpz_vec_init(d);
fmpz_init(half);
mpfr_init2(t, prec);
mpfr_init2(u, prec);
fmpz_one(half);
fmpz_mul_2exp(half, half, prec - 1);
mpfr_const_pi(t, prec);
mpfr_div_ui(t, t, n, MPFR_RNDN);
for (i = j = 0; j < d; i++)
{
if (n_gcd(n, i) == 1)
{
mpfr_mul_ui(u, t, 2 * i, MPFR_RNDN);
mpfr_cos(u, u, MPFR_RNDN);
mpfr_neg(u, u, MPFR_RNDN);
exp = mpfr_get_z_2exp(_fmpz_promote(alpha + j), u);
_fmpz_demote_val(alpha + j);
fmpz_mul_or_div_2exp(alpha + j, alpha + j, exp + prec);
j++;
}
}
balanced_product(coeffs, alpha, d, prec);
/* Scale and round */
for (i = 0; i < d + 1; i++)
{
slong r = d;
if ((n & (n - 1)) == 0)
r--;
fmpz_mul_2exp(coeffs + i, coeffs + i, r);
fmpz_add(coeffs + i, coeffs + i, half);
fmpz_fdiv_q_2exp(coeffs + i, coeffs + i, prec);
}
fmpz_clear(half);
mpfr_clear(t);
mpfr_clear(u);
_fmpz_vec_clear(alpha, d);
}
MpfrFloat MpfrFloat::cos(const MpfrFloat& value)
{
MpfrFloat retval(MpfrFloat::kNoInitialization);
mpfr_cos(retval.mData->mFloat, value.mData->mFloat, GMP_RNDN);
return retval;
}