Math-MPFR
view release on metacpan or search on metacpan
void _SvCUR_set(SV * pv, UV len){
SvCUR_set(pv, (STRLEN)len);
}
SV * Rmpfr_cmp_str(pTHX_ mpfr_t * a, SV * str) {
#if !defined(MPFR_VERSION) || MPFR_VERSION < 262146 /* ie less than 4.0.2 */
PERL_UNUSED_ARG2(a, str);
croak("Rmpfr_cmp_str is NA: The mpfr library version (%s) needs to be at least 4.0.2", MPFR_VERSION_STRING);
#else
mpfr_t temp;
int inex, cmp;
mpfr_init2(temp, mpfr_get_prec(*a));
inex = mpfr_strtofr(temp, SvPV_nolen(str), NULL, 0, GMP_RNDN);
cmp = mpfr_cmp(*a, temp);
mpfr_clear(temp);
if(cmp == 0) return newSViv(inex);
return newSViv(cmp);
#endif
}
MODULE = Math::MPFR PACKAGE = Math::MPFR
PROTOTYPES: DISABLE
int
NNW_val ()
CODE:
RETVAL = NNW_val (aTHX);
OUTPUT: RETVAL
int
NOK_POK_val ()
CODE:
RETVAL = NOK_POK_val (aTHX);
OUTPUT: RETVAL
int
_win32_infnanstring (s)
char * s
SV *
_fmt_flt (out, k, sign, max_decimal_prec, sf)
char * out
int k
int sign
int max_decimal_prec
int sf
CODE:
RETVAL = _fmt_flt (aTHX_ out, k, sign, max_decimal_prec, sf);
OUTPUT: RETVAL
void
Rmpfr_set_default_rounding_mode (round)
SV * round
PPCODE:
Rmpfr_set_default_rounding_mode(aTHX_ round);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpfr_get_default_rounding_mode ()
SV *
Rmpfr_prec_round (p, prec, round)
mpfr_t * p
SV * prec
SV * round
CODE:
RETVAL = Rmpfr_prec_round (aTHX_ p, prec, round);
OUTPUT: RETVAL
void
DESTROY (p)
mpfr_t * p
PPCODE:
DESTROY(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear (p)
mpfr_t * p
PPCODE:
Rmpfr_clear(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_mpfr (p)
mpfr_t * p
PPCODE:
Rmpfr_clear_mpfr(p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_ptr (p)
mpfr_t * p
PPCODE:
Rmpfr_clear_ptr(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clears (p, ...)
SV * p
PPCODE:
PL_markstack_ptr++;
Rmpfr_clears(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_init ()
CODE:
RETVAL = Rmpfr_init (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_init2 (prec)
SV * prec
CODE:
RETVAL = Rmpfr_init2 (aTHX_ prec);
OUTPUT: RETVAL
SV *
Rmpfr_init_nobless ()
CODE:
RETVAL = Rmpfr_init_nobless (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_init2_nobless (prec)
SV * prec
CODE:
RETVAL = Rmpfr_init2_nobless (aTHX_ prec);
OUTPUT: RETVAL
void
Rmpfr_init_set (q, round)
mpfr_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set(aTHX_ q, round);
return;
void
Rmpfr_init_set_ui (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_ui(aTHX_ q, round);
return;
void
Rmpfr_init_set_si (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_si(aTHX_ q, round);
return;
void
Rmpfr_init_set_d (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_d(aTHX_ q, round);
return;
void
Rmpfr_init_set_ld (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_ld(aTHX_ q, round);
return;
void
Rmpfr_init_set_f (q, round)
mpf_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_f(aTHX_ q, round);
return;
void
Rmpfr_init_set_z (q, round)
mpz_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_z(aTHX_ q, round);
return;
void
Rmpfr_init_set_q (q, round)
mpq_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_q(aTHX_ q, round);
return;
void
Rmpfr_init_set_str (q, base, round)
SV * q
SV * base
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_str(aTHX_ q, base, round);
return;
void
Rmpfr_init_set_nobless (q, round)
mpfr_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_ui_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_ui_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_si_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_si_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_d_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_d_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_ld_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_ld_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_f_nobless (q, round)
mpf_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_f_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_z_nobless (q, round)
mpz_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_z_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_q_nobless (q, round)
mpq_t * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_q_nobless(aTHX_ q, round);
return;
void
Rmpfr_init_set_str_nobless (q, base, round)
SV * q
SV * base
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_str_nobless(aTHX_ q, base, round);
return;
void
Rmpfr_deref2 (p, base, n_digits, round)
mpfr_t * p
SV * base
SV * n_digits
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_deref2(aTHX_ p, base, n_digits, round);
return;
void
Rmpfr_set_default_prec (prec)
SV * prec
PPCODE:
Rmpfr_set_default_prec(aTHX_ prec);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_get_default_prec ()
CODE:
RETVAL = Rmpfr_get_default_prec (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_min_prec (x)
mpfr_t * x
CODE:
RETVAL = Rmpfr_min_prec (aTHX_ x);
OUTPUT: RETVAL
void
Rmpfr_set_prec (p, prec)
mpfr_t * p
SV * prec
PPCODE:
Rmpfr_set_prec(aTHX_ p, prec);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_prec_raw (p, prec)
mpfr_t * p
SV * prec
PPCODE:
Rmpfr_set_prec_raw(aTHX_ p, prec);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_get_prec (p)
mpfr_t * p
CODE:
RETVAL = Rmpfr_get_prec (aTHX_ p);
OUTPUT: RETVAL
SV *
Rmpfr_set (p, q, round)
mpfr_t * p
mpfr_t * q
SV * round
CODE:
RETVAL = Rmpfr_set (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_ui (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_ui (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_si (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_si (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_uj (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_uj (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_sj (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_sj (aTHX_ p, q, round);
OUTPUT: RETVAL
int
Rmpfr_set_NV (p, q, round)
mpfr_t * p
SV * q
unsigned int round
CODE:
RETVAL = Rmpfr_set_NV (aTHX_ p, q, round);
OUTPUT: RETVAL
void
Rmpfr_init_set_NV (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_NV(aTHX_ q, round);
return;
void
Rmpfr_init_set_NV_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_NV_nobless(aTHX_ q, round);
return;
int
Rmpfr_cmp_float128 (a, b)
mpfr_t * a
SV * b
CODE:
RETVAL = Rmpfr_cmp_float128 (aTHX_ a, b);
OUTPUT: RETVAL
int
Rmpfr_cmp_NV (a, b)
mpfr_t * a
SV * b
CODE:
RETVAL = Rmpfr_cmp_NV (aTHX_ a, b);
OUTPUT: RETVAL
SV *
Rmpfr_set_ld (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_ld (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_d (p, q, round)
mpfr_t * p
SV * q
SV * round
CODE:
RETVAL = Rmpfr_set_d (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_z (p, q, round)
mpfr_t * p
mpz_t * q
SV * round
CODE:
RETVAL = Rmpfr_set_z (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_q (p, q, round)
mpfr_t * p
mpq_t * q
SV * round
CODE:
RETVAL = Rmpfr_set_q (aTHX_ p, q, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_f (p, q, round)
mpfr_t * p
mpf_t * q
SV * round
CODE:
RETVAL = Rmpfr_set_f (aTHX_ p, q, round);
OUTPUT: RETVAL
int
Rmpfr_set_str (p, num, base, round)
mpfr_t * p
SV * num
SV * base
SV * round
CODE:
RETVAL = Rmpfr_set_str (aTHX_ p, num, base, round);
OUTPUT: RETVAL
void
Rmpfr_set_inf (p, sign)
mpfr_t * p
int sign
PPCODE:
Rmpfr_set_inf(p, sign);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_nan (p)
mpfr_t * p
PPCODE:
Rmpfr_set_nan(p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_swap (p, q)
mpfr_t * p
mpfr_t * q
PPCODE:
Rmpfr_swap(p, q);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_get_d (p, round)
mpfr_t * p
SV * round
CODE:
RETVAL = Rmpfr_get_d (aTHX_ p, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_d_2exp (exp, p, round)
SV * exp
mpfr_t * p
SV * round
CODE:
RETVAL = Rmpfr_get_d_2exp (aTHX_ exp, p, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_ld_2exp (exp, p, round)
SV * exp
mpfr_t * p
SV * round
CODE:
RETVAL = Rmpfr_get_ld_2exp (aTHX_ exp, p, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_ld (p, round)
mpfr_t * p
SV * round
CODE:
RETVAL = Rmpfr_get_ld (aTHX_ p, round);
OUTPUT: RETVAL
double
Rmpfr_get_d1 (p)
mpfr_t * p
SV *
Rmpfr_get_z_2exp (z, p)
mpz_t * z
mpfr_t * p
CODE:
RETVAL = Rmpfr_get_z_2exp (aTHX_ z, p);
OUTPUT: RETVAL
SV *
Rmpfr_add (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_add (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_add_ui (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_add_ui (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_add_d (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_add_d (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_add_si (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_add_si (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_add_z (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpz_t * c
SV * round
CODE:
RETVAL = Rmpfr_add_z (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
Rmpfr_get_q (a, b)
mpq_t * a
mpfr_t * b
PPCODE:
Rmpfr_get_q(a, b);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_add_q (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpq_t * c
SV * round
CODE:
RETVAL = Rmpfr_add_q (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
q_add_fr (a, b, c)
mpq_t * a
mpq_t * b
mpfr_t * c
PPCODE:
q_add_fr(a, b, c);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_sub (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_sub (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sub_ui (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_sub_ui (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sub_d (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_sub_d (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sub_z (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpz_t * c
SV * round
CODE:
RETVAL = Rmpfr_sub_z (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sub_q (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpq_t * c
SV * round
CODE:
RETVAL = Rmpfr_sub_q (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
q_sub_fr (a, b, c)
mpq_t * a
mpq_t * b
mpfr_t * c
PPCODE:
q_sub_fr(a, b, c);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_ui_sub (a, b, c, round)
mpfr_t * a
SV * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_ui_sub (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_d_sub (a, b, c, round)
mpfr_t * a
SV * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_d_sub (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_mul (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_mul (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_mul_ui (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_mul_ui (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_mul_d (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_mul_d (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_mul_z (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpz_t * c
SV * round
CODE:
RETVAL = Rmpfr_mul_z (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_mul_q (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpq_t * c
SV * round
CODE:
RETVAL = Rmpfr_mul_q (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
q_mul_fr (a, b, c)
mpq_t * a
mpq_t * b
mpfr_t * c
PPCODE:
q_mul_fr(a, b, c);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_dim (rop, op1, op2, round)
mpfr_t * rop
mpfr_t * op1
mpfr_t * op2
SV * round
CODE:
RETVAL = Rmpfr_dim (aTHX_ rop, op1, op2, round);
OUTPUT: RETVAL
SV *
Rmpfr_div (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_div (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_div_ui (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_div_ui (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_div_d (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_div_d (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_div_z (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpz_t * c
SV * round
CODE:
RETVAL = Rmpfr_div_z (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_div_q (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpq_t * c
SV * round
CODE:
RETVAL = Rmpfr_div_q (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
q_div_fr (a, b, c)
mpq_t * a
mpq_t * b
mpfr_t * c
PPCODE:
q_div_fr(a, b, c);
XSRETURN_EMPTY; /* return empty stack */
void
q_fmod_fr (a, b, c)
mpq_t * a
mpq_t * b
mpfr_t * c
PPCODE:
q_fmod_fr(a, b, c);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_ui_div (a, b, c, round)
mpfr_t * a
SV * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_ui_div (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_d_div (a, b, c, round)
mpfr_t * a
SV * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_d_div (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sqrt (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_sqrt (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_rec_sqrt (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_rec_sqrt (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_cbrt (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_cbrt (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_sqrt_ui (a, b, round)
mpfr_t * a
SV * b
SV * round
CODE:
RETVAL = Rmpfr_sqrt_ui (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
SV * b
CODE:
RETVAL = Rmpfr_cmp_IV (aTHX_ a, b);
OUTPUT: RETVAL
int
Rmpfr_cmp_d (a, b)
mpfr_t * a
double b
int
Rmpfr_cmp_ld (a, b)
mpfr_t * a
SV * b
CODE:
RETVAL = Rmpfr_cmp_ld (aTHX_ a, b);
OUTPUT: RETVAL
int
Rmpfr_cmp_ui_2exp (a, b, c)
mpfr_t * a
SV * b
SV * c
CODE:
RETVAL = Rmpfr_cmp_ui_2exp (aTHX_ a, b, c);
OUTPUT: RETVAL
int
Rmpfr_cmp_si_2exp (a, b, c)
mpfr_t * a
SV * b
SV * c
CODE:
RETVAL = Rmpfr_cmp_si_2exp (aTHX_ a, b, c);
OUTPUT: RETVAL
int
Rmpfr_eq (a, b, c)
mpfr_t * a
mpfr_t * b
unsigned long c
int
Rmpfr_nan_p (p)
mpfr_t * p
int
Rmpfr_inf_p (p)
mpfr_t * p
int
Rmpfr_number_p (p)
mpfr_t * p
void
Rmpfr_reldiff (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
PPCODE:
Rmpfr_reldiff(aTHX_ a, b, c, round);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_sgn (p)
mpfr_t * p
int
Rmpfr_greater_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_greaterequal_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_less_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_lessequal_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_lessgreater_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_equal_p (a, b)
mpfr_t * a
mpfr_t * b
int
Rmpfr_unordered_p (a, b)
mpfr_t * a
mpfr_t * b
SV *
Rmpfr_sin_cos (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_sin_cos (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sinh_cosh (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_sinh_cosh (aTHX_ a, b, c, round);
mpfr_t * b
SV *
Rmpfr_can_round (p, err, round1, round2, prec)
mpfr_t * p
SV * err
SV * round1
SV * round2
SV * prec
CODE:
RETVAL = Rmpfr_can_round (aTHX_ p, err, round1, round2, prec);
OUTPUT: RETVAL
SV *
Rmpfr_print_rnd_mode (rnd)
SV * rnd
CODE:
RETVAL = Rmpfr_print_rnd_mode (aTHX_ rnd);
OUTPUT: RETVAL
SV *
Rmpfr_get_emin ()
CODE:
RETVAL = Rmpfr_get_emin (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_emax ()
CODE:
RETVAL = Rmpfr_get_emax (aTHX);
OUTPUT: RETVAL
int
Rmpfr_set_emin (e)
SV * e
CODE:
RETVAL = Rmpfr_set_emin (aTHX_ e);
OUTPUT: RETVAL
int
Rmpfr_set_emax (e)
SV * e
CODE:
RETVAL = Rmpfr_set_emax (aTHX_ e);
OUTPUT: RETVAL
SV *
Rmpfr_check_range (p, t, round)
mpfr_t * p
SV * t
SV * round
CODE:
RETVAL = Rmpfr_check_range (aTHX_ p, t, round);
OUTPUT: RETVAL
void
Rmpfr_clear_underflow ()
PPCODE:
Rmpfr_clear_underflow();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_overflow ()
PPCODE:
Rmpfr_clear_overflow();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_nanflag ()
PPCODE:
Rmpfr_clear_nanflag();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_inexflag ()
PPCODE:
Rmpfr_clear_inexflag();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_clear_flags ()
PPCODE:
Rmpfr_clear_flags();
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_underflow_p ()
int
Rmpfr_overflow_p ()
int
Rmpfr_nanflag_p ()
int
Rmpfr_inexflag_p ()
SV *
Rmpfr_log (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_log (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_exp (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_exp (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_exp2 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_exp2 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_exp10 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_exp10 (aTHX_ a, b, round);
OUTPUT: RETVAL
void
Rmpfr_urandomb (x, ...)
SV * x
PPCODE:
PL_markstack_ptr++;
Rmpfr_urandomb(aTHX_ x);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_random2 (p, s, exp)
mpfr_t * p
SV * s
SV * exp
PPCODE:
Rmpfr_random2(aTHX_ p, s, exp);
XSRETURN_EMPTY; /* return empty stack */
SV *
_TRmpfr_out_str (stream, base, dig, p, round)
FILE * stream
SV * base
SV * dig
mpfr_t * p
SV * round
CODE:
RETVAL = _TRmpfr_out_str (aTHX_ stream, base, dig, p, round);
OUTPUT: RETVAL
SV *
_Rmpfr_out_str (p, base, dig, round)
mpfr_t * p
SV * base
SV * dig
SV * round
CODE:
RETVAL = _Rmpfr_out_str (aTHX_ p, base, dig, round);
OUTPUT: RETVAL
SV *
_TRmpfr_out_strS (stream, base, dig, p, round, suff)
FILE * stream
SV * base
SV * dig
mpfr_t * p
SV * round
SV * suff
CODE:
RETVAL = _TRmpfr_out_strS (aTHX_ stream, base, dig, p, round, suff);
OUTPUT: RETVAL
SV *
_TRmpfr_out_strP (pre, stream, base, dig, p, round)
SV * pre
FILE * stream
SV * base
SV * dig
mpfr_t * p
SV * round
CODE:
RETVAL = _TRmpfr_out_strP (aTHX_ pre, stream, base, dig, p, round);
OUTPUT: RETVAL
SV *
_TRmpfr_out_strPS (pre, stream, base, dig, p, round, suff)
SV * pre
FILE * stream
SV * base
SV * dig
mpfr_t * p
SV * round
SV * suff
CODE:
RETVAL = _TRmpfr_out_strPS (aTHX_ pre, stream, base, dig, p, round, suff);
OUTPUT: RETVAL
SV * round
CODE:
RETVAL = Rmpfr_erf (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_frac (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_frac (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_remainder (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_remainder (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_modf (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_modf (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_fmod (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_fmod (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_fmod_ui (a, b, c, round)
mpfr_t * a
mpfr_t * b
unsigned long c
SV * round
CODE:
RETVAL = Rmpfr_fmod_ui (aTHX_ a, b, c, round);
OUTPUT: RETVAL
void
Rmpfr_remquo (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_remquo(aTHX_ a, b, c, round);
return;
int
Rmpfr_integer_p (p)
mpfr_t * p
void
Rmpfr_nexttoward (a, b)
mpfr_t * a
mpfr_t * b
PPCODE:
Rmpfr_nexttoward(a, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_nextabove (p)
mpfr_t * p
PPCODE:
Rmpfr_nextabove(p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_nextbelow (p)
mpfr_t * p
PPCODE:
Rmpfr_nextbelow(p);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_min (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_min (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_max (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_max (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_exp (p)
mpfr_t * p
CODE:
RETVAL = Rmpfr_get_exp (aTHX_ p);
OUTPUT: RETVAL
SV *
Rmpfr_set_exp (p, exp)
mpfr_t * p
SV * exp
CODE:
RETVAL = Rmpfr_set_exp (aTHX_ p, exp);
OUTPUT: RETVAL
int
Rmpfr_signbit (op)
mpfr_t * op
SV *
Rmpfr_setsign (rop, op, sign, round)
mpfr_t * rop
mpfr_t * op
SV * sign
SV * round
CODE:
RETVAL = Rmpfr_setsign (aTHX_ rop, op, sign, round);
OUTPUT: RETVAL
SV *
Rmpfr_copysign (rop, op1, op2, round)
mpfr_t * rop
mpfr_t * op1
mpfr_t * op2
SV * round
CODE:
RETVAL = Rmpfr_copysign (aTHX_ rop, op1, op2, round);
OUTPUT: RETVAL
SV *
get_refcnt (s)
SV * s
CODE:
RETVAL = get_refcnt (aTHX_ s);
OUTPUT: RETVAL
SV *
get_package_name (x)
SV * x
CODE:
RETVAL = get_package_name (aTHX_ x);
OUTPUT: RETVAL
void
Rmpfr_dump (a)
mpfr_t * a
PPCODE:
Rmpfr_dump(a);
XSRETURN_EMPTY; /* return empty stack */
SV *
gmp_v ()
CODE:
RETVAL = gmp_v (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_set_ui_2exp (a, b, c, round)
mpfr_t * a
SV * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_set_ui_2exp (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_si_2exp (a, b, c, round)
mpfr_t * a
SV * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_set_si_2exp (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_uj_2exp (a, b, c, round)
mpfr_t * a
SV * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_set_uj_2exp (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_sj_2exp (a, b, c, round)
mpfr_t * a
SV * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_set_sj_2exp (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_z (a, b, round)
mpz_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_get_z (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
SV *
Rmpfr_si_div (a, b, c, round)
mpfr_t * a
SV * b
mpfr_t * c
SV * round
CODE:
RETVAL = Rmpfr_si_div (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_div_si (a, b, c, round)
mpfr_t * a
mpfr_t * b
SV * c
SV * round
CODE:
RETVAL = Rmpfr_div_si (aTHX_ a, b, c, round);
OUTPUT: RETVAL
SV *
Rmpfr_sqr (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_sqr (aTHX_ a, b, round);
OUTPUT: RETVAL
int
Rmpfr_cmp_z (a, b)
mpfr_t * a
mpz_t * b
int
Rmpfr_cmp_q (a, b)
mpfr_t * a
mpq_t * b
int
fr_cmp_q_rounded (a, b, round)
mpfr_t * a
mpq_t * b
SV * round
CODE:
RETVAL = fr_cmp_q_rounded (aTHX_ a, b, round);
OUTPUT: RETVAL
int
Rmpfr_cmp_f (a, b)
mpfr_t * a
mpf_t * b
int
Rmpfr_zero_p (a)
mpfr_t * a
void
Rmpfr_free_cache ()
PPCODE:
Rmpfr_free_cache();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_free_cache2 (way)
unsigned int way
PPCODE:
Rmpfr_free_cache2(way);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_free_pool ()
PPCODE:
Rmpfr_free_pool();
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_get_version ()
CODE:
RETVAL = Rmpfr_get_version (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_patches ()
CODE:
RETVAL = Rmpfr_get_patches (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_emin_min ()
CODE:
RETVAL = Rmpfr_get_emin_min (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_emin_max ()
CODE:
RETVAL = Rmpfr_get_emin_max (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_emax_min ()
CODE:
RETVAL = Rmpfr_get_emax_min (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_emax_max ()
CODE:
RETVAL = Rmpfr_get_emax_max (aTHX);
OUTPUT: RETVAL
void
Rmpfr_clear_erangeflag ()
PPCODE:
Rmpfr_clear_erangeflag();
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_erangeflag_p ()
SV *
Rmpfr_rint_round (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_rint_round (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_rint_trunc (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_rint_trunc (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_rint_ceil (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_rint_ceil (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_rint_floor (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_rint_floor (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_ui (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_ui (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_si (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_si (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_uj (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_uj (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_sj (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_sj (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_IV (x, round)
mpfr_t * x
SV * round
CODE:
RETVAL = Rmpfr_get_IV (aTHX_ x, round);
OUTPUT: RETVAL
int
Rmpfr_set_IV (x, sv, rnd)
mpfr_t * x
SV * sv
unsigned int rnd
CODE:
RETVAL = Rmpfr_set_IV (aTHX_ x, sv, rnd);
OUTPUT: RETVAL
void
Rmpfr_init_set_IV (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_IV(aTHX_ q, round);
return;
void
Rmpfr_init_set_IV_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_IV_nobless(aTHX_ q, round);
return;
SV *
Rmpfr_get_NV (x, round)
mpfr_t * x
SV * round
CODE:
RETVAL = Rmpfr_get_NV (aTHX_ x, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_ulong_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_ulong_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_slong_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_slong_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_ushort_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_ushort_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_sshort_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_sshort_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_uint_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_uint_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_sint_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_sint_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_uintmax_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_uintmax_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_intmax_p (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_fits_intmax_p (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_fits_IV_p (x, round)
mpfr_t * x
SV * round
CODE:
RETVAL = Rmpfr_fits_IV_p (aTHX_ x, round);
OUTPUT: RETVAL
SV *
Rmpfr_strtofr (a, str, base, round)
mpfr_t * a
SV * str
SV * base
SV * round
CODE:
RETVAL = Rmpfr_strtofr (aTHX_ a, str, base, round);
OUTPUT: RETVAL
void
Rmpfr_set_erangeflag ()
PPCODE:
Rmpfr_set_erangeflag();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_underflow ()
PPCODE:
Rmpfr_set_underflow();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_overflow ()
PPCODE:
Rmpfr_set_overflow();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_nanflag ()
PPCODE:
Rmpfr_set_nanflag();
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_inexflag ()
PPCODE:
Rmpfr_set_inexflag();
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_erfc (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_erfc (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_j0 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_j0 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_j1 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_j1 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_jn (a, n, b, round)
mpfr_t * a
SV * n
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_jn (aTHX_ a, n, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_y0 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_y0 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_y1 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_y1 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_yn (a, n, b, round)
SV *
Rmpfr_li2 (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_li2 (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_f (a, b, round)
mpf_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_get_f (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_sech (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_sech (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_csch (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_csch (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_coth (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_coth (aTHX_ a, b, round);
OUTPUT: RETVAL
SV *
Rmpfr_lngamma (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
CODE:
RETVAL = Rmpfr_lngamma (aTHX_ a, b, round);
OUTPUT: RETVAL
void
Rmpfr_lgamma (a, b, round)
mpfr_t * a
mpfr_t * b
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_lgamma(aTHX_ a, b, round);
return;
SV *
_MPFR_VERSION ()
CODE:
RETVAL = _MPFR_VERSION (aTHX);
OUTPUT: RETVAL
SV *
_MPFR_VERSION_MAJOR ()
CODE:
RETVAL = _MPFR_VERSION_MAJOR (aTHX);
OUTPUT: RETVAL
SV *
_MPFR_VERSION_MINOR ()
CODE:
RETVAL = _MPFR_VERSION_MINOR (aTHX);
OUTPUT: RETVAL
SV *
_MPFR_VERSION_PATCHLEVEL ()
CODE:
RETVAL = _MPFR_VERSION_PATCHLEVEL (aTHX);
OUTPUT: RETVAL
SV *
_MPFR_VERSION_STRING ()
CODE:
RETVAL = _MPFR_VERSION_STRING (aTHX);
OUTPUT: RETVAL
SV *
RMPFR_VERSION_NUM (a, b, c)
SV * a
SV * b
SV * c
CODE:
RETVAL = RMPFR_VERSION_NUM (aTHX_ a, b, c);
OUTPUT: RETVAL
SV *
Rmpfr_sum (rop, avref, len, round)
mpfr_t * rop
SV * avref
SV * len
SV * round
CODE:
RETVAL = Rmpfr_sum (aTHX_ rop, avref, len, round);
OUTPUT: RETVAL
void
_fr_to_q (q, fr)
mpq_t * q
mpfr_t * fr
PPCODE:
_fr_to_q(q, fr);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_q_div (rop, q, fr, round)
mpfr_t * rop
mpq_t * q
mpfr_t * fr
int round
int
Rmpfr_z_div (rop, z, fr, round)
mpfr_t * rop
mpz_t * z
mpfr_t * fr
int round
SV *
overload_mul (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_mul (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_add (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_add (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_sub (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_sub (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_div (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_div (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_copy (p, b, third)
mpfr_t * p
SV * b
SV * third
CODE:
RETVAL = overload_copy (aTHX_ p, b, third);
OUTPUT: RETVAL
SV *
tand (p)
mpfr_t * p
CODE:
RETVAL = tand (aTHX_ p);
OUTPUT: RETVAL
SV *
overload_int (p, b, third)
mpfr_t * p
SV * b
SV * third
CODE:
RETVAL = overload_int (aTHX_ p, b, third);
OUTPUT: RETVAL
SV *
overload_atan2 (a, b, third)
mpfr_t * a
SV * b
SV * third
CODE:
RETVAL = overload_atan2 (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
Rmpfr_randinit_default_nobless ()
CODE:
RETVAL = Rmpfr_randinit_default_nobless (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_randinit_mt_nobless ()
CODE:
RETVAL = Rmpfr_randinit_mt_nobless (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_randinit_lc_2exp_nobless (a, c, m2exp)
SV * a
SV * c
SV * m2exp
CODE:
RETVAL = Rmpfr_randinit_lc_2exp_nobless (aTHX_ a, c, m2exp);
OUTPUT: RETVAL
SV *
Rmpfr_randinit_lc_2exp_size_nobless (size)
SV * size
CODE:
RETVAL = Rmpfr_randinit_lc_2exp_size_nobless (aTHX_ size);
OUTPUT: RETVAL
void
Rmpfr_randclear (p)
SV * p
PPCODE:
Rmpfr_randclear(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_randseed (state, seed)
SV * state
SV * seed
PPCODE:
Rmpfr_randseed(aTHX_ state, seed);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_randseed_ui (state, seed)
SV * state
SV * seed
PPCODE:
Rmpfr_randseed_ui(aTHX_ state, seed);
XSRETURN_EMPTY; /* return empty stack */
SV *
overload_pow_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_pow_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_div_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_div_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_sub_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_sub_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_add_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_add_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
overload_mul_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = overload_mul_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_itsa (a)
SV * a
CODE:
RETVAL = _itsa (aTHX_ a);
OUTPUT: RETVAL
int
_has_longlong ()
int
SV * b
CODE:
RETVAL = wrap_mpfr_fprintf_rnd (aTHX_ stream, a, round, b);
OUTPUT: RETVAL
SV *
wrap_mpfr_sprintf_rnd (s, a, round, b, buflen)
SV * s
SV * a
SV * round
SV * b
int buflen
CODE:
RETVAL = wrap_mpfr_sprintf_rnd (aTHX_ s, a, round, b, buflen);
OUTPUT: RETVAL
SV *
wrap_mpfr_snprintf_rnd (s, bytes, a, round, b, buflen)
SV * s
SV * bytes
SV * a
SV * round
SV * b
int buflen
CODE:
RETVAL = wrap_mpfr_snprintf_rnd (aTHX_ s, bytes, a, round, b, buflen);
OUTPUT: RETVAL
SV *
Rmpfr_buildopt_tls_p ()
CODE:
RETVAL = Rmpfr_buildopt_tls_p (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_buildopt_float16_p ()
CODE:
RETVAL = Rmpfr_buildopt_float16_p (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_buildopt_decimal_p ()
CODE:
RETVAL = Rmpfr_buildopt_decimal_p (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_regular_p (a)
mpfr_t * a
CODE:
RETVAL = Rmpfr_regular_p (aTHX_ a);
OUTPUT: RETVAL
void
Rmpfr_set_zero (a, sign)
mpfr_t * a
SV * sign
PPCODE:
Rmpfr_set_zero(aTHX_ a, sign);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_digamma (rop, op, round)
mpfr_t * rop
mpfr_t * op
SV * round
CODE:
RETVAL = Rmpfr_digamma (aTHX_ rop, op, round);
OUTPUT: RETVAL
SV *
Rmpfr_trigamma (rop, op, round)
mpfr_t * rop
mpfr_t * op
SV * round
CODE:
RETVAL = Rmpfr_trigamma (aTHX_ rop, op, round);
OUTPUT: RETVAL
SV *
Rmpfr_ai (rop, op, round)
mpfr_t * rop
mpfr_t * op
SV * round
CODE:
RETVAL = Rmpfr_ai (aTHX_ rop, op, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_flt (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_flt (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_float16 (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_float16 (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_get_bfloat16 (a, round)
mpfr_t * a
SV * round
CODE:
RETVAL = Rmpfr_get_bfloat16 (aTHX_ a, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_flt (rop, f, round)
mpfr_t * rop
SV * f
SV * round
CODE:
SV *
Rmpfr_urandom (rop, state, round)
mpfr_t * rop
gmp_randstate_t * state
SV * round
CODE:
RETVAL = Rmpfr_urandom (aTHX_ rop, state, round);
OUTPUT: RETVAL
SV *
Rmpfr_set_z_2exp (rop, op, exp, round)
mpfr_t * rop
mpz_t * op
SV * exp
SV * round
CODE:
RETVAL = Rmpfr_set_z_2exp (aTHX_ rop, op, exp, round);
OUTPUT: RETVAL
SV *
Rmpfr_buildopt_tune_case ()
CODE:
RETVAL = Rmpfr_buildopt_tune_case (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_frexp (exp, rop, op, round)
SV * exp
mpfr_t * rop
mpfr_t * op
SV * round
CODE:
RETVAL = Rmpfr_frexp (aTHX_ exp, rop, op, round);
OUTPUT: RETVAL
SV *
Rmpfr_z_sub (rop, op1, op2, round)
mpfr_t * rop
mpz_t * op1
mpfr_t * op2
SV * round
CODE:
RETVAL = Rmpfr_z_sub (aTHX_ rop, op1, op2, round);
OUTPUT: RETVAL
SV *
Rmpfr_grandom (rop1, rop2, state, round)
mpfr_t * rop1
mpfr_t * rop2
gmp_randstate_t * state
SV * round
CODE:
RETVAL = Rmpfr_grandom (aTHX_ rop1, rop2, state, round);
OUTPUT: RETVAL
void
Rmpfr_clear_divby0 ()
PPCODE:
Rmpfr_clear_divby0(aTHX);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_set_divby0 ()
PPCODE:
Rmpfr_set_divby0(aTHX);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_divby0_p ()
CODE:
RETVAL = Rmpfr_divby0_p (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_buildopt_gmpinternals_p ()
CODE:
RETVAL = Rmpfr_buildopt_gmpinternals_p (aTHX);
OUTPUT: RETVAL
SV *
_get_xs_version ()
CODE:
RETVAL = _get_xs_version (aTHX);
OUTPUT: RETVAL
void
overload_inc (a, b, third)
SV * a
SV * b
SV * third
PPCODE:
overload_inc(aTHX_ a, b, third);
XSRETURN_EMPTY; /* return empty stack */
void
overload_dec (a, b, third)
SV * a
SV * b
SV * third
PPCODE:
overload_dec(aTHX_ a, b, third);
XSRETURN_EMPTY; /* return empty stack */
SV *
_overload_lshift (a, b, third)
mpfr_t * a
SV * b
SV * third
CODE:
RETVAL = _overload_lshift (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_overload_rshift (a, b, third)
mpfr_t * a
SV * b
SV * third
CODE:
RETVAL = _overload_rshift (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_overload_lshift_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = _overload_lshift_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_overload_rshift_eq (a, b, third)
SV * a
SV * b
SV * third
CODE:
RETVAL = _overload_rshift_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_wrap_count ()
CODE:
RETVAL = _wrap_count (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_set_LD (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_LD (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_BFLOAT16 (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_BFLOAT16 (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_FLOAT16 (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_FLOAT16 (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_DECIMAL64 (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_DECIMAL64 (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_DECIMAL128 (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_DECIMAL128 (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
void
Rmpfr_get_LD (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_LD(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_get_BFLOAT16 (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_BFLOAT16(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_get_FLOAT16 (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_FLOAT16(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_get_FLT (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_FLT(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_get_DECIMAL64 (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_DECIMAL64(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_get_DECIMAL128 (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_DECIMAL128(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
int
_MPFR_WANT_DECIMAL_FLOATS ()
int
_MPFR_WANT_DECIMAL64 ()
int
_MPFR_WANT_DECIMAL128 ()
int
_MPFR_WANT_FLOAT128 ()
SV *
_max_base ()
CODE:
RETVAL = _max_base (aTHX);
OUTPUT: RETVAL
SV *
_isobject (x)
SV * x
CODE:
RETVAL = _isobject (aTHX_ x);
OUTPUT: RETVAL
void
_mp_sizes ()
PPCODE:
PL_markstack_ptr++;
_mp_sizes();
return;
SV *
_ivsize ()
CODE:
RETVAL = _ivsize (aTHX);
OUTPUT: RETVAL
SV *
_nvsize ()
CODE:
RETVAL = _nvsize (aTHX);
OUTPUT: RETVAL
SV *
_FLT128_DIG ()
CODE:
RETVAL = _FLT128_DIG (aTHX);
OUTPUT: RETVAL
SV *
_LDBL_DIG ()
CODE:
RETVAL = _LDBL_DIG (aTHX);
OUTPUT: RETVAL
SV *
_DBL_DIG ()
CODE:
RETVAL = _DBL_DIG (aTHX);
OUTPUT: RETVAL
SV *
_FLT128_MANT_DIG ()
CODE:
RETVAL = _FLT128_MANT_DIG (aTHX);
OUTPUT: RETVAL
SV *
_LDBL_MANT_DIG ()
CODE:
RETVAL = _LDBL_MANT_DIG (aTHX);
OUTPUT: RETVAL
SV *
_DBL_MANT_DIG ()
CODE:
RETVAL = _DBL_MANT_DIG (aTHX);
OUTPUT: RETVAL
SV *
Rmpfr_get_float128 (op, rnd)
mpfr_t * op
SV * rnd
CODE:
RETVAL = Rmpfr_get_float128 (aTHX_ op, rnd);
OUTPUT: RETVAL
void
Rmpfr_get_FLOAT128 (rop, op, rnd)
SV * rop
mpfr_t * op
SV * rnd
PPCODE:
Rmpfr_get_FLOAT128(aTHX_ rop, op, rnd);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_set_FLT (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_FLT (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_FLOAT128 (rop, op, rnd)
mpfr_t * rop
SV * op
SV * rnd
CODE:
RETVAL = Rmpfr_set_FLOAT128 (aTHX_ rop, op, rnd);
OUTPUT: RETVAL
SV *
Rmpfr_set_float128 (rop, q, rnd)
mpfr_t * rop
SV * q
SV * rnd
CODE:
RETVAL = Rmpfr_set_float128 (aTHX_ rop, q, rnd);
OUTPUT: RETVAL
void
Rmpfr_init_set_float128 (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_float128(aTHX_ q, round);
return;
void
Rmpfr_init_set_float128_nobless (q, round)
SV * q
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_init_set_float128_nobless(aTHX_ q, round);
return;
SV *
_is_readonly (sv)
SV * sv
CODE:
RETVAL = _is_readonly (aTHX_ sv);
OUTPUT: RETVAL
void
_readonly_on (sv)
SV * sv
PPCODE:
_readonly_on(aTHX_ sv);
XSRETURN_EMPTY; /* return empty stack */
void
_readonly_off (sv)
SV * sv
PPCODE:
_readonly_off(aTHX_ sv);
XSRETURN_EMPTY; /* return empty stack */
int
_can_pass_float128 ()
int
_mpfr_want_float128 ()
int
nnumflag ()
int
nok_pokflag ()
void
clear_nnum ()
PPCODE:
clear_nnum();
XSRETURN_EMPTY; /* return empty stack */
void
clear_nok_pok ()
PPCODE:
clear_nok_pok();
XSRETURN_EMPTY; /* return empty stack */
void
set_nnum (x)
int x
PPCODE:
set_nnum(x);
XSRETURN_EMPTY; /* return empty stack */
void
set_nok_pok (x)
int x
PPCODE:
set_nok_pok(x);
XSRETURN_EMPTY; /* return empty stack */
SV *
_d_bytes (str)
SV * str
CODE:
RETVAL = _d_bytes (aTHX_ str);
OUTPUT: RETVAL
SV *
_bytes_fr (str, bits)
mpfr_t * str
unsigned long bits
CODE:
RETVAL = _bytes_fr (aTHX_ str, bits);
OUTPUT: RETVAL
SV *
_dd_bytes (str)
SV * str
CODE:
RETVAL = _dd_bytes (aTHX_ str);
OUTPUT: RETVAL
SV *
_ld_bytes (str)
SV * str
CODE:
RETVAL = _ld_bytes (aTHX_ str);
OUTPUT: RETVAL
SV *
_f128_bytes (str)
SV * str
CODE:
RETVAL = _f128_bytes (aTHX_ str);
OUTPUT: RETVAL
int
_required_ldbl_mant_dig ()
SV *
_GMP_LIMB_BITS ()
CODE:
RETVAL = _GMP_LIMB_BITS (aTHX);
OUTPUT: RETVAL
SV *
_GMP_NAIL_BITS ()
CODE:
RETVAL = _GMP_NAIL_BITS (aTHX);
OUTPUT: RETVAL
void
Rmpfr_fmodquo (a, b, c, round)
mpfr_t * a
mpfr_t * b
mpfr_t * c
SV * round
PPCODE:
PL_markstack_ptr++;
Rmpfr_fmodquo(aTHX_ a, b, c, round);
return;
int
Rmpfr_fpif_export (stream, op)
FILE * stream
mpfr_t * op
CODE:
RETVAL = Rmpfr_fpif_export (aTHX_ stream, op);
OUTPUT: RETVAL
int
Rmpfr_fpif_import (op, stream)
mpfr_t * op
FILE * stream
CODE:
RETVAL = Rmpfr_fpif_import (aTHX_ op, stream);
OUTPUT: RETVAL
UV
Rmpfr_fpif_size (op)
mpfr_t * op
int
_Rmpfr_fpif_export_mem (str, sizet, op)
unsigned char * str
SV * sizet
mpfr_t * op
CODE:
RETVAL = _Rmpfr_fpif_export_mem (aTHX_ str, sizet, op);
OUTPUT: RETVAL
int
Rmpfr_fpif_import_mem (op, str, sizet)
mpfr_t * op
unsigned char * str
SV * sizet
CODE:
RETVAL = Rmpfr_fpif_import_mem (aTHX_ op, str, sizet);
OUTPUT: RETVAL
void
Rmpfr_flags_clear (mask)
unsigned int mask
PPCODE:
Rmpfr_flags_clear(mask);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpfr_flags_set (mask)
unsigned int mask
PPCODE:
Rmpfr_flags_set(mask);
XSRETURN_EMPTY; /* return empty stack */
unsigned int
Rmpfr_flags_test (mask)
unsigned int mask
unsigned int
Rmpfr_flags_save ()
void
Rmpfr_flags_restore (flags, mask)
unsigned int flags
unsigned int mask
PPCODE:
Rmpfr_flags_restore(flags, mask);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_rint_roundeven (rop, op, round)
mpfr_t * rop
mpfr_t * op
int round
int
Rmpfr_roundeven (rop, op)
mpfr_t * rop
mpfr_t * op
int
Rmpfr_nrandom (rop, state, round)
mpfr_t * rop
gmp_randstate_t * state
int round
int
Rmpfr_erandom (rop, state, round)
mpfr_t * rop
gmp_randstate_t * state
int round
int
Rmpfr_fmma (rop, op1, op2, op3, op4, round)
mpfr_t * rop
mpfr_t * op1
mpfr_t * op2
mpfr_t * op3
mpfr_t * op4
int round
int
Rmpfr_fmms (rop, op1, op2, op3, op4, round)
mpfr_t * rop
mpfr_t * op1
mpfr_t * op2
mpfr_t * op3
mpfr_t * op4
int round
int
Rmpfr_log_ui (rop, op, round)
mpfr_t * rop
unsigned long op
int round
int
Rmpfr_gamma_inc (rop, op1, op2, round)
mpfr_t * rop
mpfr_t * op1
mpfr_t * op2
int round
int
_have_IEEE_754_long_double ()
SV * str
CODE:
RETVAL = atonv (aTHX_ str);
OUTPUT: RETVAL
SV *
Rmpfr_get_str_ndigits_alt (base, prec)
int base
UV prec
CODE:
RETVAL = Rmpfr_get_str_ndigits_alt (aTHX_ base, prec);
OUTPUT: RETVAL
SV *
Rmpfr_get_str_ndigits (base, prec)
int base
SV * prec
CODE:
RETVAL = Rmpfr_get_str_ndigits (aTHX_ base, prec);
OUTPUT: RETVAL
SV *
Rmpfr_dot (rop, avref_A, avref_B, len, round)
mpfr_t * rop
SV * avref_A
SV * avref_B
SV * len
SV * round
CODE:
RETVAL = Rmpfr_dot (aTHX_ rop, avref_A, avref_B, len, round);
OUTPUT: RETVAL
SV *
_nvtoa (pnv)
NV pnv
CODE:
RETVAL = _nvtoa (aTHX_ pnv);
OUTPUT: RETVAL
SV *
_mpfrtoa (pnv, min_normal_prec)
mpfr_t * pnv
int min_normal_prec
CODE:
RETVAL = _mpfrtoa (aTHX_ pnv, min_normal_prec);
OUTPUT: RETVAL
SV *
mpfrtoa_subn (obj, prec, emin, emax)
mpfr_t * obj
SV * prec
SV * emin
SV * emax
CODE:
RETVAL = mpfrtoa_subn (aTHX_ obj, prec, emin, emax);
OUTPUT: RETVAL
void
set_fallback_flag ()
PPCODE:
PL_markstack_ptr++;
set_fallback_flag(aTHX);
XSRETURN_EMPTY; /* return empty stack */
SV *
doubletoa (sv, ...)
SV * sv
CODE:
PL_markstack_ptr++;
RETVAL = doubletoa(aTHX_ sv);
OUTPUT: RETVAL
int
_fallback_notify ()
SV *
_numtoa (in)
SV * in
CODE:
RETVAL = _numtoa (aTHX_ in);
OUTPUT: RETVAL
void
decimalize (a, ...)
SV * a
PPCODE:
PL_markstack_ptr++;
decimalize(aTHX_ a);
return;
int
IOK_flag (sv)
SV * sv
int
POK_flag (sv)
SV * sv
int
NOK_flag (sv)
SV * sv
int
_sis_perl_version ()
int
_has_pv_nv_bug ()
int
_sizeof_exp ()
int
_sizeof_prec ()
int
_has_bizarre_infnan ()
SV *
_gmp_cflags ()
CODE:
RETVAL = _gmp_cflags (aTHX);
OUTPUT: RETVAL
SV *
_gmp_cc ()
CODE:
RETVAL = _gmp_cc (aTHX);
OUTPUT: RETVAL
int
_have_float16 ()
int
_have_bfloat16 ()
SV *
_gmp_printf_nv (a, b)
CODE:
RETVAL = _gmp_fprintf_nv (aTHX_ stream, a, b);
OUTPUT: RETVAL
SV *
_gmp_sprintf_nv (s, a, b, buflen)
SV * s
SV * a
SV * b
int buflen
CODE:
RETVAL = _gmp_sprintf_nv (aTHX_ s, a, b, buflen);
OUTPUT: RETVAL
SV *
_gmp_snprintf_nv (s, bytes, a, b, buflen)
SV * s
SV * bytes
SV * a
SV * b
int buflen
CODE:
RETVAL = _gmp_snprintf_nv (aTHX_ s, bytes, a, b, buflen);
OUTPUT: RETVAL
int
_looks_like_number (in)
SV * in
CODE:
RETVAL = _looks_like_number (aTHX_ in);
OUTPUT: RETVAL
SV *
_overload_fmod (a, b, third)
mpfr_t * a
mpfr_t * b
SV * third
CODE:
RETVAL = _overload_fmod (aTHX_ a, b, third);
OUTPUT: RETVAL
SV *
_overload_fmod_eq (a, b, third)
SV * a
mpfr_t * b
SV * third
CODE:
RETVAL = _overload_fmod_eq (aTHX_ a, b, third);
OUTPUT: RETVAL
int
Rmpfr_buildopt_bfloat16_p ()
CODE:
RETVAL = Rmpfr_buildopt_bfloat16_p (aTHX);
OUTPUT: RETVAL
void
_unpack_float32 (f)
mpfr_t * f
PPCODE:
PL_markstack_ptr++;
_unpack_float32(aTHX_ f);
return;
void
_unpack_float16 (f)
mpfr_t * f
PPCODE:
PL_markstack_ptr++;
_unpack_float16(aTHX_ f);
return;
void
_unpack_bfloat16 (f)
mpfr_t * f
PPCODE:
PL_markstack_ptr++;
_unpack_bfloat16(aTHX_ f);
return;
SV *
_subnormalize_pv (val, emin, emax, prec)
SV * val
int emin
int emax
int prec
CODE:
RETVAL = _subnormalize_pv (aTHX_ val, emin, emax, prec);
OUTPUT: RETVAL
UV
_strlen (pv)
char * pv
UV
_SvCUR (pv)
SV * pv
UV
_SvLEN (pv)
SV * pv
void
_SvCUR_set (pv, len)
SV * pv
UV len
PPCODE:
_SvCUR_set(pv, len);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpfr_cmp_str (a, str)
mpfr_t * a
SV * str
CODE:
RETVAL = Rmpfr_cmp_str (aTHX_ a, str);
OUTPUT: RETVAL
( run in 2.318 seconds using v1.01-cache-2.11-cpan-71847e10f99 )