int
main (int argc, char **argv)
{
mpfr_t x, y;
mpq_t a, b;
mpfi_t i;
mpq_init (a);
mpq_init (b);
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpq_set_si (a, -1, 3);
mpq_set_ui (b, +1, 1024);
mpfr_set_q (x, a, MPFI_RNDD);
mpfr_set_q (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, b, y, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_q (y, a, MPFI_RNDU);
check (i, a, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
mpq_clear (a);
mpq_clear (b);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
return 0;
}
int
mpfi_put_q (mpfi_ptr a, mpq_srcptr b)
{
int inexact_left = 0;
int inexact_right = 0;
int inexact = 0;
if ( MPFI_NAN_P (a) )
MPFR_RET_NAN;
if (mpfr_cmp_q (&(a->left), b) > 0 ) {
inexact_left = mpfr_set_q (&(a->left), b, MPFI_RNDD);
}
else if (mpfr_cmp_q (&(a->right), b) < 0 ) {
inexact_right = mpfr_set_q (&(a->right), b, MPFI_RNDU);
/* do not allow +0 as upper bound */
if (mpfr_zero_p (&(a->right)) && !mpfr_signbit (&(a->right))) {
mpfr_neg (&(a->right), &(a->right), MPFI_RNDD);
}
}
if (inexact_left)
inexact += 1;
if (inexact_right)
inexact += 2;
return inexact;
}
static void
check_nan_inf_mpq (void)
{
mpfr_t mpfr_value, mpfr_cmp;
mpq_t mpq_value;
int status;
mpfr_init2 (mpfr_value, MPFR_PREC_MIN);
mpq_init (mpq_value);
mpq_set_si (mpq_value, 0, 0);
mpz_set_si (mpq_denref (mpq_value), 0);
status = mpfr_set_q (mpfr_value, mpq_value, MPFR_RNDN);
if ((status != 0) || (!MPFR_IS_NAN (mpfr_value)))
{
mpfr_init2 (mpfr_cmp, MPFR_PREC_MIN);
mpfr_set_nan (mpfr_cmp);
printf ("mpfr_set_q with a NAN mpq value returned a wrong value :\n"
" waiting for ");
mpfr_print_binary (mpfr_cmp);
printf (" got ");
mpfr_print_binary (mpfr_value);
printf ("\n trinary value is %d\n", status);
exit (1);
}
mpq_set_si (mpq_value, -1, 0);
mpz_set_si (mpq_denref (mpq_value), 0);
status = mpfr_set_q (mpfr_value, mpq_value, MPFR_RNDN);
if ((status != 0) || (!MPFR_IS_INF (mpfr_value)) ||
(MPFR_SIGN(mpfr_value) != mpq_sgn(mpq_value)))
{
mpfr_init2 (mpfr_cmp, MPFR_PREC_MIN);
mpfr_set_inf (mpfr_cmp, -1);
printf ("mpfr_set_q with a -INF mpq value returned a wrong value :\n"
" waiting for ");
mpfr_print_binary (mpfr_cmp);
printf (" got ");
mpfr_print_binary (mpfr_value);
printf ("\n trinary value is %d\n", status);
exit (1);
}
mpq_clear (mpq_value);
mpfr_clear (mpfr_value);
}
static void
check0 (void)
{
mpq_t y;
mpfr_t x;
int inexact;
int r;
/* Check for +0 */
mpfr_init (x);
mpq_init (y);
mpq_set_si (y, 0, 1);
for (r = 0; r < MPFR_RND_MAX; r++)
{
mpfr_clear_flags ();
inexact = mpfr_set_q (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact ||
__gmpfr_flags != 0)
{
printf("mpfr_set_q(x,0) failed for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit(1);
}
}
mpfr_clear (x);
mpq_clear (y);
}
static void
_taylor_mpfr (gulong l, mpq_t q, mpfr_ptr res, mp_rnd_t rnd)
{
NcmBinSplit **bs_ptr = _ncm_mpsf_sbessel_get_bs ();
NcmBinSplit *bs = *bs_ptr;
_binsplit_spherical_bessel *data = (_binsplit_spherical_bessel *) bs->userdata;
gulong n;
data->l = l;
mpq_mul (data->mq2_2, q, q);
mpq_neg (data->mq2_2, data->mq2_2);
mpq_div_2exp (data->mq2_2, data->mq2_2, 1);
//mpfr_printf ("# Taylor %ld %Qd | %Qd\n", l, q, data->mq2_2);
ncm_binsplit_eval_prec (bs, binsplit_spherical_bessel_taylor, 10, mpfr_get_prec (res));
//mpfr_printf ("# Taylor %ld %Qd | %Zd %Zd\n", l, q, bs->T, bs->Q);
mpfr_set_q (res, q, rnd);
mpfr_pow_ui (res, res, l, rnd);
mpfr_mul_z (res, res, bs->T, rnd);
mpfr_div_z (res, res, bs->Q, rnd);
for (n = 1; n <= l; n++)
mpfr_div_ui (res, res, 2L * n + 1, rnd);
ncm_memory_pool_return (bs_ptr);
return;
}
int
fmpq_get_mpfr(mpfr_t r, const fmpq_t x, mpfr_rnd_t rnd)
{
__mpq_struct mpq;
fmpz p, q;
mp_limb_t pp, qq;
p = *fmpq_numref(x);
q = *fmpq_denref(x);
if (p == 0)
return mpfr_set_ui(r, 0, rnd);
if (COEFF_IS_MPZ(p))
mpq._mp_num = *COEFF_TO_PTR(p);
else
{
pp = FLINT_ABS(p);
mpq._mp_num._mp_alloc = 1;
mpq._mp_num._mp_size = (p < 0) ? -1 : 1;
mpq._mp_num._mp_d = &pp;
}
if (COEFF_IS_MPZ(q))
mpq._mp_den = *COEFF_TO_PTR(q);
else
{
qq = q;
mpq._mp_den._mp_alloc = 1;
mpq._mp_den._mp_size = 1;
mpq._mp_den._mp_d = &qq;
}
return mpfr_set_q(r, &mpq, rnd);
}
static void
test_specialq (mpfr_prec_t p0, mpfr_prec_t p1, unsigned int N,
int (*mpfr_func)(mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t),
void (*mpq_func)(mpq_ptr, mpq_srcptr, mpq_srcptr),
const char *op)
{
mpfr_t fra, frb, frq;
mpq_t q1, q2, qr;
unsigned int n;
mpfr_prec_t prec;
for (prec = p0 ; prec < p1 ; prec++)
{
mpfr_inits2 (prec, fra, frb, frq, (mpfr_ptr) 0);
mpq_init (q1); mpq_init(q2); mpq_init (qr);
for( n = 0 ; n < N ; n++)
{
mpq_set_ui(q1, randlimb(), randlimb() );
mpq_set_ui(q2, randlimb(), randlimb() );
mpq_canonicalize (q1);
mpq_canonicalize (q2);
mpq_func (qr, q1, q2);
mpfr_set_q (fra, q1, MPFR_RNDD);
mpfr_func (fra, fra, q2, MPFR_RNDD);
mpfr_set_q (frb, q1, MPFR_RNDU);
mpfr_func (frb, frb, q2, MPFR_RNDU);
mpfr_set_q (frq, qr, MPFR_RNDN);
/* We should have fra <= qr <= frb */
if ( (mpfr_cmp(fra, frq) > 0) || (mpfr_cmp (frq, frb) > 0))
{
printf("Range error for prec=%lu and %s",
(unsigned long) prec, op);
printf ("\nq1="); mpq_out_str(stdout, 2, q1);
printf ("\nq2="); mpq_out_str(stdout, 2, q2);
printf ("\nfr_dn="); mpfr_print_binary (fra);
printf ("\nfr_q ="); mpfr_print_binary (frq);
printf ("\nfr_up="); mpfr_print_binary (frb);
putchar('\n');
exit (1);
}
}
mpq_clear (q1); mpq_clear (q2); mpq_clear (qr);
mpfr_clears (fra, frb, frq, (mpfr_ptr) 0);
}
}
static void
check (long int n, long int d, mpfr_rnd_t rnd, const char *ys)
{
mpq_t q;
mpfr_t x, t;
int inexact, compare;
unsigned int flags, ex_flags;
mpfr_init2 (x, 53);
mpfr_init2 (t, mpfr_get_prec (x) + mp_bits_per_limb);
mpq_init (q);
mpq_set_si (q, n, d);
mpfr_clear_flags ();
inexact = mpfr_set_q (x, q, rnd);
flags = __gmpfr_flags;
/* check values */
if (mpfr_cmp_str1 (x, ys))
{
printf ("Error for q = %ld/%ld and rnd = %s\n", n, d,
mpfr_print_rnd_mode (rnd));
printf ("correct result is %s, mpfr_set_q gives ", ys);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
/* check inexact flag */
if (mpfr_mul_ui (t, x, (d < 0) ? (-d) : d, rnd))
{
printf ("t <- x * d should be exact\n");
exit (1);
}
compare = mpfr_cmp_si (t, n);
if (! SAME_SIGN (inexact, compare))
{
printf ("Wrong ternary value for q = %ld/%ld and rnd = %s:\n"
"expected %d or equivalent, got %d\n",
n, d, mpfr_print_rnd_mode (rnd), compare, inexact);
exit (1);
}
ex_flags = compare == 0 ? 0 : MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("Wrong flags for q = %ld/%ld and rnd = %s:\n",
n, d, mpfr_print_rnd_mode (rnd));
printf ("Expected flags:");
flags_out (ex_flags);
printf ("Got flags: ");
flags_out (flags);
exit (1);
}
mpfr_clear (x);
mpfr_clear (t);
mpq_clear (q);
}
void
ovm_q_mul(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
l->t = t_word;
l->v.w = 0;
break;
case t_word:
mpq_set_si(oqr(r), r->v.w, 1);
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_float:
l->t = t_float;
l->v.d = mpq_get_d(oqr(l)) * r->v.d;
break;
case t_mpz:
mpz_set_ui(ozs(r), 1);
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_mpq:
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_mul(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
l->t = t_cdd;
l->v.dd = mpq_get_d(oqr(l)) * r->v.dd;
check_cdd(l);
break;
case t_cqq:
l->t = t_cqq;
mpq_set_ui(oqi(l), 0, 1);
cqq_mul(oqq(l), oqq(l), oqq(r));
check_cqq(l);
break;
case t_mpc:
l->t = t_mpc;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpc_mul(occ(l), occ(l), occ(r), thr_rndc);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_number);
}
}
/**
* ncm_mpsf_sbessel_recur_set_q: (skip)
* @jlrec: a #NcmMpsfSBesselRecur
* @l: FIXME
* @q: FIXME
* @rnd: FIXME
*
* FIXME
*
*/
void
ncm_mpsf_sbessel_recur_set_q (NcmMpsfSBesselRecur *jlrec, glong l, mpq_ptr q, mp_rnd_t rnd)
{
jlrec->l = l;
mpq_set (jlrec->q, q);
mpfr_set_q (jlrec->x, q, rnd);
ncm_mpsf_sbessel (l + 0, q, jlrec->jl[0], rnd);
ncm_mpsf_sbessel (l + 1, q, jlrec->jl[1], rnd);
}
/**
* ncm_mpsf_sbessel_recur_set_d: (skip)
* @jlrec: a #NcmMpsfSBesselRecur
* @l: FIXME
* @x: FIXME
* @rnd: FIXME
*
* FIXME
*
*/
void
ncm_mpsf_sbessel_recur_set_d (NcmMpsfSBesselRecur *jlrec, glong l, gdouble x, mp_rnd_t rnd)
{
jlrec->l = l;
ncm_rational_coarce_double (x, jlrec->q);
mpfr_set_q (jlrec->x, jlrec->q, rnd);
ncm_mpsf_sbessel (l + 0, jlrec->q, jlrec->jl[0], rnd);
ncm_mpsf_sbessel (l + 1, jlrec->q, jlrec->jl[1], rnd);
}
static VALUE r_gmpq_to_fr(int argc, VALUE *argv, VALUE self)
{
mp_rnd_t rnd;
mp_prec_t prec;
MP_RAT *ptr_self;
VALUE ptr_return;
MPFR *ptr_mpfr;
r_mpfr_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
mpq_get_struct(self, ptr_self);
r_mpfr_make_struct_init2(ptr_return, ptr_mpfr, prec);
mpfr_set_q(ptr_mpfr, ptr_self, rnd);
return ptr_return;
}
void
ovm_q_rem(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
ovm_raise(except_floating_point_error);
case t_word:
if (r->v.w == 0)
ovm_raise(except_floating_point_error);
if (r->v.w > 0)
mpz_mul_ui(ozr(r), ozs(l), r->v.w);
else {
mpz_set_si(ozr(r), r->v.w);
mpz_mul(ozr(r), ozs(l), ozr(r));
}
mpz_tdiv_r(ozr(l), ozr(l), ozr(r));
mpq_canonicalize(oqr(l));
check_mpq(l);
break;
case t_float:
l->t = t_float;
l->v.d = fmod(mpq_get_d(oqr(l)), r->v.d);
break;
case t_mpz:
mpz_mul(ozr(r), ozs(l), ozr(r));
mpz_tdiv_r(ozr(l), ozr(l), ozr(r));
check_mpq(l);
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
case t_mpq:
mpq_div(oqr(l), oqr(l), oqr(r));
mpz_tdiv_r(ozr(l), ozr(l), ozs(l));
mpz_mul(ozs(l), ozs(l), ozs(r));
mpq_canonicalize(oqr(l));
if (mpq_sgn(oqr(r)) < 0)
mpq_neg(oqr(l), oqr(l));
check_mpq(l);
break;
case t_mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_fmod(orr(l), orr(l), orr(r), thr_rnd);
break;
default:
ovm_raise(except_not_a_real_number);
}
}
/* Function to generate the hypergeometric pdf */
void hypergeometricpdf(mpfr_t *out,mpz_t mu, mpz_t d,unsigned int mi,unsigned int conns,unsigned int phi, mpz_t bc_b_ai[], mpz_t mu_bc[])
{
unsigned int dini=(unsigned int)conns;
unsigned int dmax=(unsigned int)conns;
mpz_t bcm_b_ai;
mpz_init(bcm_b_ai);
mpq_t quotient;
mpq_init(quotient);
unsigned int odex=0;
unsigned int di;
// unsigned int phi;
unsigned int bi;
unsigned int ai_cnt;
//loop over d, phi and beta
for(di=dini;di<=dmax;di=di++)
{
//for(phi=1;phi<=di;phi++)
//{
for(bi=0;bi<=mi;bi++)
{
for(ai_cnt=phi;ai_cnt<=di;ai_cnt++)
{
if((mi-bi)<=0) //Then the number of successful picks is the number of draws with probability 1
{
if(ai_cnt==di)
mpq_set_d(quotient,1);
else
mpq_set_d(quotient,0);
}
else
{
mpz_mul(bcm_b_ai,bc_b_ai[bi*(dmax+1)+(ai_cnt)],bc_b_ai[(mi-bi)*(dmax+1)+(di-ai_cnt)]);
mpq_set_num(quotient, bcm_b_ai);
mpq_set_den(quotient, mu_bc[di-1]);
mpq_canonicalize(quotient);
}
mpfr_set_q(*(out+odex),quotient,MPFR_RNDN);
odex++; //Address array with simple counter increment;
}
}
//}
}
mpz_clear(bcm_b_ai);
mpq_clear(quotient);
}
static void
check (long int n, long int d, mpfr_rnd_t rnd, const char *ys)
{
mpq_t q;
mpfr_t x, t;
int inexact, compare;
mpfr_init2 (x, 53);
mpfr_init2 (t, mpfr_get_prec (x) + mp_bits_per_limb);
mpq_init (q);
mpq_set_si (q, n, d);
inexact = mpfr_set_q (x, q, rnd);
/* check values */
if (mpfr_cmp_str1(x, ys))
{
printf ("Error for q=%ld/%ld and rnd=%s\n", n, d,
mpfr_print_rnd_mode (rnd));
printf ("correct result is %s, mpfr_set_q gives ", ys);
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
putchar('\n');
exit (1);
}
/* check inexact flag */
if (mpfr_mul_ui (t, x, (d < 0) ? (-d) : d, rnd))
{
printf ("t <- x * d should be exact\n");
exit (1);
}
compare = mpfr_cmp_si (t, n);
if (((inexact == 0) && (compare != 0)) ||
((inexact < 0) && (compare >= 0)) ||
((inexact > 0) && (compare <= 0)))
{
printf ("wrong inexact flag: expected %d, got %d\n", compare,
inexact);
exit (1);
}
mpfr_clear (x);
mpfr_clear (t);
mpq_clear (q);
}
void
ovm_q_trunc2(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
ovm_raise(except_floating_point_error);
case t_word:
if (r->v.w == 0)
ovm_raise(except_floating_point_error);
l->t = t_mpz;
if (r->v.w > 0)
mpz_mul_ui(ozr(r), ozs(l), r->v.w);
else {
mpz_set_si(ozr(r), r->v.w);
mpz_mul(ozr(r), ozs(l), ozr(r));
}
mpz_tdiv_q(ozr(l), ozr(l), ozr(r));
check_mpz(l);
break;
case t_float:
ovm_trunc_d(l, mpq_get_d(oqr(l)) / r->v.d);
break;
case t_mpz:
mpz_tdiv_q(ozr(l), ozr(l), ozr(r));
check_mpz(l);
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
case t_mpq:
l->t = t_mpz;
mpq_div(oqr(l), oqr(l), oqr(r));
mpz_tdiv_q(ozr(l), ozr(l), ozs(l));
check_mpz(l);
break;
case t_mpr:
mpfr_set_q(orr(l), oqr(l), thr_rnd);
ovm_trunc_r(l, orr(r));
break;
default:
ovm_raise(except_not_a_real_number);
}
}
void
ovm_q_eq(oregister_t *l, oregister_t *r)
{
l->t = t_word;
switch (r->t) {
case t_float:
l->v.w = mpq_get_d(oqr(l)) == r->v.d;
break;
case t_mpq:
l->v.w = mpq_cmp(oqr(l), oqr(r)) == 0;
break;
case t_mpr:
mpfr_set_q(orr(l), oqr(l), thr_rnd);
l->v.w = mpfr_equal_p(orr(l), orr(r));
break;
default:
l->v.w = 0;
break;
}
}
void
ovm_q_complex(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
break;
case t_word:
l->t = t_cqq;
mpq_set_si(oqi(l), r->v.w, 1);
check_cqq(l);
break;
case t_float:
l->t = t_cdd;
real(l->v.dd) = mpq_get_d(oqr(l));
imag(l->v.dd) = r->v.d;
check_cdd(l);
break;
case t_mpz:
l->t = t_cqq;
mpq_set_z(oqi(l), ozr(r));
check_cqq(l);
break;
case t_mpq:
l->t = t_cqq;
mpq_set(oqi(l), oqr(r));
check_cqq(l);
break;
case t_mpr:
l->t = t_mpc;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_set(ori(l), orr(r), thr_rnd);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_real_number);
}
}
static void
check_set (void)
{
long int lo;
mpz_t mpz;
mpq_t mpq;
mpf_t mpf;
mpfr_t fr;
mpc_t x, z;
mpfr_prec_t prec;
mpz_init (mpz);
mpq_init (mpq);
mpf_init2 (mpf, 1000);
mpfr_init2 (fr, 1000);
mpc_init2 (x, 1000);
mpc_init2 (z, 1000);
mpz_set_ui (mpz, 0x4217);
mpq_set_si (mpq, -1, 0x4321);
mpf_set_q (mpf, mpq);
for (prec = 2; prec <= 1000; prec++)
{
unsigned long int u = (unsigned long int) prec;
mpc_set_prec (z, prec);
mpfr_set_prec (fr, prec);
lo = -prec;
mpfr_set_d (fr, 1.23456789, GMP_RNDN);
mpc_set_d (z, 1.23456789, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp_si (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_d", prec, z);
#if defined _MPC_H_HAVE_COMPLEX
mpc_set_dc (z, I*1.23456789+1.23456789, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_c", prec, z);
#endif
mpc_set_ui (z, u, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_ui", prec, z);
mpc_set_d_d (z, 1.23456789, 1.23456789, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_d_d", prec, z);
mpc_set_si (z, lo, MPC_RNDNN);
if (mpfr_cmp_si (MPC_RE(z), lo) != 0 || mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_si", prec, z);
mpfr_set_ld (fr, 1.23456789L, GMP_RNDN);
mpc_set_ld_ld (z, 1.23456789L, 1.23456789L, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_ld_ld", prec, z);
#if defined _MPC_H_HAVE_COMPLEX
mpc_set_ldc (z, I*1.23456789L+1.23456789L, MPC_RNDNN);
if (mpfr_cmp (MPC_RE(z), fr) != 0 || mpfr_cmp (MPC_IM(z), fr) != 0)
PRINT_ERROR ("mpc_set_lc", prec, z);
#endif
mpc_set_ui_ui (z, u, u, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), u) != 0)
PRINT_ERROR ("mpc_set_ui_ui", prec, z);
mpc_set_ld (z, 1.23456789L, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_ld", prec, z);
mpc_set_prec (x, prec);
mpfr_set_ui(fr, 1, GMP_RNDN);
mpfr_div_ui(fr, fr, 3, GMP_RNDN);
mpfr_set(MPC_RE(x), fr, GMP_RNDN);
mpfr_set(MPC_IM(x), fr, GMP_RNDN);
mpc_set (z, x, MPC_RNDNN);
mpfr_clear_flags (); /* mpc_cmp set erange flag when an operand is a
NaN */
if (mpc_cmp (z, x) != 0 || mpfr_erangeflag_p())
{
printf ("Error in mpc_set for prec = %lu\n",
(unsigned long int) prec);
MPC_OUT(z);
MPC_OUT(x);
exit (1);
}
mpc_set_si_si (z, lo, lo, MPC_RNDNN);
if (mpfr_cmp_si (MPC_RE(z), lo) != 0
|| mpfr_cmp_si (MPC_IM(z), lo) != 0)
PRINT_ERROR ("mpc_set_si_si", prec, z);
mpc_set_fr (z, fr, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_fr", prec, z);
mpfr_set_z (fr, mpz, GMP_RNDN);
mpc_set_z_z (z, mpz, mpz, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(z), fr) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_z_z", prec, z);
mpc_set_fr_fr (z, fr, fr, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(z), fr) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_fr_fr", prec, z);
mpc_set_z (z, mpz, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_z", prec, z);
mpfr_set_q (fr, mpq, GMP_RNDN);
mpc_set_q_q (z, mpq, mpq, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(z), fr) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_q_q", prec, z);
mpc_set_ui_fr (z, u, fr, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp_ui (MPC_RE (z), u) != 0
|| mpfr_cmp (MPC_IM (z), fr) != 0
|| mpfr_erangeflag_p ())
PRINT_ERROR ("mpc_set_ui_fr", prec, z);
mpc_set_fr_ui (z, fr, u, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE (z), fr) != 0
|| mpfr_cmp_ui (MPC_IM (z), u) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_fr_ui", prec, z);
mpc_set_q (z, mpq, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_q", prec, z);
mpfr_set_f (fr, mpf, GMP_RNDN);
mpc_set_f_f (z, mpf, mpf, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp (MPC_IM(z), fr) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_f_f", prec, z);
mpc_set_f (z, mpf, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE(z), fr) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0
|| mpfr_erangeflag_p())
PRINT_ERROR ("mpc_set_f", prec, z);
mpc_set_f_si (z, mpf, lo, MPC_RNDNN);
mpfr_clear_flags ();
if (mpfr_cmp (MPC_RE (z), fr) != 0
|| mpfr_cmp_si (MPC_IM (z), lo) != 0
|| mpfr_erangeflag_p ())
PRINT_ERROR ("mpc_set_f", prec, z);
mpc_set_nan (z);
if (!mpfr_nan_p (MPC_RE(z)) || !mpfr_nan_p (MPC_IM(z)))
PRINT_ERROR ("mpc_set_nan", prec, z);
#ifdef _MPC_H_HAVE_INTMAX_T
{
uintmax_t uim = (uintmax_t) prec;
intmax_t im = (intmax_t) prec;
mpc_set_uj (z, uim, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_uj", prec, z);
mpc_set_sj (z, im, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_sj (1)", prec, z);
mpc_set_uj_uj (z, uim, uim, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), u) != 0)
PRINT_ERROR ("mpc_set_uj_uj", prec, z);
mpc_set_sj_sj (z, im, im, MPC_RNDNN);
if (mpfr_cmp_ui (MPC_RE(z), u) != 0
|| mpfr_cmp_ui (MPC_IM(z), u) != 0)
PRINT_ERROR ("mpc_set_sj_sj (1)", prec, z);
im = LONG_MAX;
if (sizeof (intmax_t) == 2 * sizeof (unsigned long))
im = 2 * im * im + 4 * im + 1; /* gives 2^(2n-1)-1 from 2^(n-1)-1 */
mpc_set_sj (z, im, MPC_RNDNN);
if (mpfr_get_sj (MPC_RE(z), GMP_RNDN) != im ||
mpfr_cmp_ui (MPC_IM(z), 0) != 0)
PRINT_ERROR ("mpc_set_sj (2)", im, z);
mpc_set_sj_sj (z, im, im, MPC_RNDNN);
if (mpfr_get_sj (MPC_RE(z), GMP_RNDN) != im ||
mpfr_get_sj (MPC_IM(z), GMP_RNDN) != im)
PRINT_ERROR ("mpc_set_sj_sj (2)", im, z);
}
#endif /* _MPC_H_HAVE_INTMAX_T */
#if defined _MPC_H_HAVE_COMPLEX
{
double _Complex c = 1.0 - 2.0*I;
long double _Complex lc = c;
mpc_set_dc (z, c, MPC_RNDNN);
if (mpc_get_dc (z, MPC_RNDNN) != c)
PRINT_ERROR ("mpc_get_c", prec, z);
mpc_set_ldc (z, lc, MPC_RNDNN);
if (mpc_get_ldc (z, MPC_RNDNN) != lc)
PRINT_ERROR ("mpc_get_lc", prec, z);
}
#endif
}
mpz_clear (mpz);
mpq_clear (mpq);
mpf_clear (mpf);
mpfr_clear (fr);
mpc_clear (x);
mpc_clear (z);
}
int sqrt_upper(mpq_t sqrt_x, mpq_t x, int digits)
/***************************************************************\
* USAGE: compute a certified rational upper bound on the sqrt(x)*
* that is within 10^-digits of the true value 0-good,1-error *
\***************************************************************/
{
int rV = 0, sign = mpq_sgn(x);
// verify digits >= 0
if (digits < 0)
{ // error
printf("ERROR: The number of digits must be nonnegative!\n");
errExit(ERROR_CONFIGURATION);
}
// check the sign of x
if (sign == -1)
{ // x is negative - return error
rV = 1;
}
else if (sign == 0)
{ // x is zero - sqrt(x) = 0
mpq_set_ui(sqrt_x, 0, 1);
rV = 0;
}
else
{ // x is positive - compute sqrt(x)
int prec;
mpfr_t sqrt_x_float;
mpf_t tempMPF;
mpq_t sqrt_x_temp, tempMPQ;
// determine the precision to use to get an approximation
if (digits <= 16)
prec = 64;
else
{ // determine the precision needed
prec = (int) ceil((digits + 0.5) / (32 * log10(2.0)));
if (prec <= 2)
prec = 64;
else
prec *= 32;
}
// initialize
mpfr_init2(sqrt_x_float, prec);
mpf_init2(tempMPF, prec);
mpq_init(sqrt_x_temp);
mpq_init(tempMPQ);
// approximate sqrt(x) - round up!
mpfr_set_q(sqrt_x_float, x, GMP_RNDU);
mpfr_sqrt(sqrt_x_float, sqrt_x_float, GMP_RNDU);
// convert to rational
mpfr_get_f(tempMPF, sqrt_x_float, GMP_RNDU);
mpq_set_f(sqrt_x_temp, tempMPF);
// verify that sqrt_x_temp is an upper bound
mpq_mul(tempMPQ, sqrt_x_temp, sqrt_x_temp);
if (mpq_cmp(tempMPQ, x) >= 0)
{ // we have an upper bound - refine & certify it
refine_sqrt_upper(sqrt_x_temp, x, digits);
// copy to sqrt_x
mpq_set(sqrt_x, sqrt_x_temp);
rV = 0;
}
else
{ // try again with 2*x (Newton iterations still converge quadratically!)
mpq_add(tempMPQ, x, x);
mpfr_set_q(sqrt_x_float, tempMPQ, GMP_RNDU);
mpfr_sqrt(sqrt_x_float, sqrt_x_float, GMP_RNDU);
// convert to rational
mpfr_get_f(tempMPF, sqrt_x_float, GMP_RNDU);
mpq_set_f(sqrt_x_temp, tempMPF);
// verify that sqrt_x_temp is an upper bound
mpq_mul(tempMPQ, sqrt_x_temp, sqrt_x_temp);
if (mpq_cmp(tempMPQ, x) >= 0)
{ // we have an upper bound - refine & certify it
refine_sqrt_upper(sqrt_x_temp, x, digits);
// copy to sqrt_x
mpq_set(sqrt_x, sqrt_x_temp);
rV = 0;
}
else
{ // take any upper bound
if (mpq_cmp_ui(x, 1, 1) <= 0)
{ // 1 is an upper bound for sqrt(x)
mpq_set_ui(sqrt_x_temp, 1, 1);
}
else
{ // x is an upper bound for sqrt(x)
mpq_set(sqrt_x_temp, x);
}
// we have an upper bound - refine & certify it
refine_sqrt_upper(sqrt_x_temp, x, digits);
// copy to sqrt_x
mpq_set(sqrt_x, sqrt_x_temp);
rV = 0;
}
}
// clear
mpfr_clear(sqrt_x_float);
mpf_clear(tempMPF);
mpq_clear(sqrt_x_temp);
mpq_clear(tempMPQ);
}
return rV;
}
static void
_assympt_mpfr (gulong l, mpq_t q, mpfr_ptr res, mp_rnd_t rnd)
{
NcmBinSplit **bs_ptr = _ncm_mpsf_sbessel_get_bs ();
NcmBinSplit *bs = *bs_ptr;
_binsplit_spherical_bessel *data = (_binsplit_spherical_bessel *) bs->userdata;
gulong prec = mpfr_get_prec (res);
#define sin_x data->sin
#define cos_x data->cos
mpfr_set_prec (sin_x, prec);
mpfr_set_prec (cos_x, prec);
mpfr_set_q (res, q, rnd);
mpfr_sin_cos (sin_x, cos_x, res, rnd);
switch (l % 4)
{
case 0:
break;
case 1:
mpfr_swap (sin_x, cos_x);
mpfr_neg (sin_x, sin_x, rnd);
break;
case 2:
mpfr_neg (sin_x, sin_x, rnd);
mpfr_neg (cos_x, cos_x, rnd);
break;
case 3:
mpfr_swap (sin_x, cos_x);
mpfr_neg (cos_x, cos_x, rnd);
break;
}
if (l > 0)
{
mpfr_mul_ui (cos_x, cos_x, l * (l + 1), rnd);
mpfr_div (cos_x, cos_x, res, rnd);
mpfr_div (cos_x, cos_x, res, rnd);
mpfr_div_2ui (cos_x, cos_x, 1, rnd);
}
mpfr_div (sin_x, sin_x, res, rnd);
data->l = l;
mpq_inv (data->mq2_2, q);
mpq_mul (data->mq2_2, data->mq2_2, data->mq2_2);
mpq_neg (data->mq2_2, data->mq2_2);
mpq_div_2exp (data->mq2_2, data->mq2_2, 2);
data->sincos = 0;
binsplit_spherical_bessel_assympt (bs, 0, (l + 1) / 2 + (l + 1) % 2);
mpfr_mul_z (sin_x, sin_x, bs->T, rnd);
mpfr_div_z (sin_x, sin_x, bs->Q, rnd);
data->sincos = 1;
if (l > 0)
{
binsplit_spherical_bessel_assympt (bs, 0, l / 2 + l % 2);
mpfr_mul_z (cos_x, cos_x, bs->T, rnd);
mpfr_div_z (cos_x, cos_x, bs->Q, rnd);
mpfr_add (res, sin_x, cos_x, rnd);
}
else
mpfr_set (res, sin_x, rnd);
ncm_memory_pool_return (bs_ptr);
return;
}
void set_from_mpq(ElementType &result, mpq_ptr a) const {
mpfr_set_q(&result, a, GMP_RNDN);
}
void bvisit(const Rational &x) {
mpfr_set_q(result_, x.i.get_mpq_t(), rnd_);
}
static PyObject *
GMPy_Real_DivMod_2(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPFR_Object *tempx = NULL, *tempy = NULL, *quo = NULL, *rem = NULL;
PyObject *result = NULL;
CHECK_CONTEXT(context);
if (!(result = PyTuple_New(2)) ||
!(rem = GMPy_MPFR_New(0, context)) ||
!(quo = GMPy_MPFR_New(0, context))) {
/* LCOV_EXCL_START */
goto error;
/* LCOV_EXCL_STOP */
}
if (IS_REAL(x) && IS_REAL(y)) {
if (!(tempx = GMPy_MPFR_From_Real(x, 1, context)) ||
!(tempy = GMPy_MPFR_From_Real(y, 1, context))) {
/* LCOV_EXCL_START */
goto error;
/* LCOV_EXCL_STOP */
}
if (mpfr_zero_p(tempy->f)) {
context->ctx.divzero = 1;
if (context->ctx.traps & TRAP_DIVZERO) {
GMPY_DIVZERO("divmod() division by zero");
goto error;
}
}
if (mpfr_nan_p(tempx->f) || mpfr_nan_p(tempy->f) || mpfr_inf_p(tempx->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
else {
mpfr_set_nan(quo->f);
mpfr_set_nan(rem->f);
}
}
else if (mpfr_inf_p(tempy->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
if (mpfr_zero_p(tempx->f)) {
mpfr_set_zero(quo->f, mpfr_sgn(tempy->f));
mpfr_set_zero(rem->f, mpfr_sgn(tempy->f));
}
else if ((mpfr_signbit(tempx->f)) != (mpfr_signbit(tempy->f))) {
mpfr_set_si(quo->f, -1, MPFR_RNDN);
mpfr_set_inf(rem->f, mpfr_sgn(tempy->f));
}
else {
mpfr_set_si(quo->f, 0, MPFR_RNDN);
rem->rc = mpfr_set(rem->f, tempx->f, MPFR_RNDN);
}
}
else {
MPQ_Object *mpqx = NULL, *mpqy = NULL, *temp_rem = NULL;
MPZ_Object *temp_quo = NULL;
if (!(mpqx = GMPy_MPQ_From_MPFR(tempx, context)) ||
!(mpqy = GMPy_MPQ_From_MPFR(tempy, context))) {
/* LCOV_EXCL_START */
Py_XDECREF((PyObject*)mpqx);
Py_XDECREF((PyObject*)mpqy);
goto error;
/* LCOV_EXCL_STOP */
}
if (!(temp_rem = GMPy_MPQ_New(context)) ||
!(temp_quo = GMPy_MPZ_New(context))) {
/* LCOV_EXCL_START */
Py_XDECREF((PyObject*)temp_rem);
Py_XDECREF((PyObject*)temp_quo);
Py_XDECREF((PyObject*)mpqx);
Py_XDECREF((PyObject*)mpqy);
goto error;
/* LCOV_EXCL_STOP */
}
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
mpq_div(temp_rem->q, mpqx->q, mpqy->q);
mpz_fdiv_q(temp_quo->z, mpq_numref(temp_rem->q), mpq_denref(temp_rem->q));
/* Need to calculate x - quo * y. */
mpq_set_z(temp_rem->q, temp_quo->z);
mpq_mul(temp_rem->q, temp_rem->q, mpqy->q);
mpq_sub(temp_rem->q, mpqx->q, temp_rem->q);
Py_DECREF((PyObject*)mpqx);
Py_DECREF((PyObject*)mpqy);
quo->rc = mpfr_set_z(quo->f, temp_quo->z, MPFR_RNDD);
rem->rc = mpfr_set_q(rem->f, temp_rem->q, MPFR_RNDN);
Py_DECREF((PyObject*)temp_rem);
Py_DECREF((PyObject*)temp_quo);
GMPY_MPFR_CHECK_RANGE(quo, context);
GMPY_MPFR_CHECK_RANGE(rem, context);
GMPY_MPFR_SUBNORMALIZE(quo, context);
GMPY_MPFR_SUBNORMALIZE(rem, context);
PyTuple_SET_ITEM(result, 0, (PyObject*)quo);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return result;
}
}
/* LCOV_EXCL_START */
SYSTEM_ERROR("Internal error in GMPy_Real_DivMod_2().");
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_XDECREF((PyObject*)rem);
Py_XDECREF((PyObject*)quo);
Py_XDECREF(result);
return NULL;
/* LCOV_EXCL_STOP */
}
/* Function to calculate the expected number of unique codes
within each input success class */
void uniquecodes(mpfr_t *ucodes, int psiz, mpz_t n, unsigned long int mu, mpz_t ncodes ,mpfr_t *pdf,mpfr_prec_t prec)
{
//200 bits precision gives log[2^200] around 60 digits decimal precision
mpfr_t unity;
mpfr_init2(unity,prec);
mpfr_set_ui(unity,(unsigned long int) 1,MPFR_RNDN);
mpfr_t nunity;
mpfr_init2(nunity,prec);
mpfr_set_si(nunity,(signed long int) -1,MPFR_RNDN);
mpz_t bcnum;
mpz_init(bcnum);
mpfr_t bcnumf;
mpfr_init2(bcnumf,prec);
mpq_t cfrac;
mpq_init(cfrac);
mpfr_t cfracf;
mpfr_init2(cfracf,prec);
mpfr_t expargr;
mpfr_init2(expargr,prec);
mpfr_t r1;
mpfr_init2(r1,prec);
mpfr_t r2;
mpfr_init2(r2,prec);
// mpfr_t pdf[mu];
unsigned long int i;
int pdex;
int addr;
// for(i=0;i<=mu;i++)
// mpfr_init2(pdf[i],prec);
// inpdf(pdf,n,pin,mu,bcs,prec);
for(pdex=0;pdex<=psiz-1;pdex++)
{
for(i=0;i<=mu;i++)
{
addr=pdex*(mu+1)+i;
mpz_bin_ui(bcnum,n,i);
mpq_set_num(cfrac,ncodes);
mpq_set_den(cfrac,bcnum);
mpq_canonicalize(cfrac);
mpfr_set_q(cfracf,cfrac,MPFR_RNDN);
mpfr_mul(expargr,cfracf,*(pdf+addr),MPFR_RNDN);
mpfr_mul(expargr,expargr,nunity,MPFR_RNDN);
mpfr_exp(r1,expargr,MPFR_RNDN);
mpfr_sub(r1,unity,r1,MPFR_RNDN);
mpfr_set_z(bcnumf,bcnum,MPFR_RNDN);
mpfr_mul(r2,bcnumf,r1,MPFR_RNDN);
mpfr_set((*ucodes+addr),r2,MPFR_RNDN);
mpfr_round((*ucodes+addr),(*ucodes+addr));
}
}
mpfr_clear(unity);
mpfr_clear(nunity);
mpz_clear(bcnum);
mpfr_clear(bcnumf);
mpq_clear(cfrac);
mpfr_clear(cfracf);
mpfr_clear(expargr);
mpfr_clear(r1);
mpfr_clear(r2);
// for(i=0;i<=mu;i++)
// mpfr_clear(pdf[i]);
}
void
ovm_q_atan2(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), 0.0);
}
else {
mpfr_set_ui(orr(r), 0, thr_rnd);
goto mpr;
}
break;
case t_word:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), r->v.w);
}
else {
mpfr_set_si(orr(r), r->v.w, thr_rnd);
goto mpr;
}
break;
case t_float:
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), r->v.d);
break;
case t_mpz:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), mpz_get_d(ozr(r)));
}
else {
mpfr_set_z(orr(r), ozr(r), thr_rnd);
goto mpr;
}
break;
case t_rat:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), rat_get_d(r->v.r));
}
else {
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
break;
case t_mpq:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = atan2(mpq_get_d(oqr(l)), mpq_get_d(oqr(r)));
}
else {
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
break;
case t_mpr:
mpr:
mpfr_set_q(orr(l), oqr(l), thr_rnd);
l->t = t_mpr;
mpfr_atan2(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
cdd:
l->t = t_cdd;
real(l->v.dd) = mpq_get_d(oqr(l));
imag(l->v.dd) = 0.0;
l->v.dd = catan(l->v.dd / r->v.dd);
check_cdd(l);
break;
case t_cqq:
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = mpq_get_d(oqi(r));
goto cdd;
}
mpc_set_q_q(occ(r), oqr(r), oqi(r), thr_rndc);
case t_mpc:
l->t = t_mpc;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpc_div(occ(l), occ(l), occ(r), thr_rndc);
mpc_atan(occ(l), occ(l), thr_rndc);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_number);
}
}
void
ovm_q_pow(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = 1.0;
}
else {
l->t = t_mpr;
mpfr_set_ui(orr(l), 1, thr_rnd);
}
break;
case t_word:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), r->v.w);
}
else {
mpfr_set_si(orr(r), r->v.w, thr_rnd);
goto mpr;
}
break;
case t_float:
if (mpq_sgn(oqr(l)) < 0 &&
finite(r->v.d) && rint(r->v.d) != r->v.d) {
real(r->v.dd) = r->v.d;
imag(r->v.dd) = 0.0;
goto cdd;
}
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), r->v.d);
break;
case t_mpz:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), mpz_get_d(ozr(r)));
}
else {
mpfr_set_z(orr(r), ozr(r), thr_rnd);
goto mpr;
}
break;
case t_rat:
if (mpq_sgn(oqr(l)) < 0) {
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = 0.0;
goto cdd;
}
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
else {
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), rat_get_d(r->v.r));
}
else {
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
}
break;
case t_mpq:
if (mpq_sgn(oqr(r)) < 0) {
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = 0.0;
goto cdd;
}
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
else {
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), mpq_get_d(oqr(r)));
}
else {
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
}
break;
case t_mpr:
if (mpq_sgn(oqr(l)) < 0 &&
mpfr_number_p(orr(r)) && !mpfr_integer_p(orr(r))) {
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_pow(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
cdd:
l->t = t_cdd;
real(l->v.dd) = mpq_get_d(oqr(l));
imag(l->v.dd) = 0.0;
l->v.dd = cpow(l->v.dd, r->v.dd);
check_cdd(l);
break;
case t_cqq:
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = mpq_get_d(oqi(r));
goto cdd;
}
mpc_set_q_q(occ(r), oqr(r), oqi(r), thr_rndc);
case t_mpc:
mpc:
l->t = t_mpc;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpc_pow(occ(l), occ(l), occ(r), thr_rndc);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_number);
}
}
void
ovm_q_hypot(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = fabs(mpq_get_d(oqr(l)));
}
else {
mpfr_set_ui(orr(r), 0, thr_rnd);
goto mpr;
}
break;
case t_word:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)), r->v.w);
}
else {
mpfr_set_si(orr(r), r->v.w, thr_rnd);
goto mpr;
}
break;
case t_float:
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)), r->v.d);
break;
case t_mpz:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)), mpz_get_d(ozr(r)));
}
else {
mpfr_set_z(orr(r), ozr(r), thr_rnd);
goto mpr;
}
break;
case t_rat:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)), rat_get_d(r->v.r));
}
else {
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
break;
case t_mpq:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)), mpq_get_d(oqr(r)));
}
else {
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
break;
case t_mpr:
mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_hypot(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
cdd:
l->t = t_float;
l->v.d = hypot(mpq_get_d(oqr(l)),
hypot(real(r->v.dd), imag(r->v.dd)));
break;
case t_cqq:
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = mpq_get_d(oqi(r));
goto cdd;
}
mpc_set_q_q(occ(r), oqr(r), oqi(r), thr_rndc);
case t_mpc:
l->t = t_mpr;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpfr_hypot(ori(l), orr(l), ori(l), thr_rnd);
mpfr_hypot(orr(l), orr(r), ori(r), thr_rnd);
mpfr_hypot(orr(l), ori(l), orr(l), thr_rnd);
break;
default:
ovm_raise(except_not_a_number);
}
}
