PPCODE results from the CPAN

PPCODE

Math-GMPf

view release on metacpan or search on metacpan

     if(mpf_fits_ulong_p(*n)) return 1;
     return 0;
#else
     mpf_t _uv_max;
     mpf_t copy;
     if(mpf_fits_ulong_p(*n)) return 1;
     if(mpf_sgn(*n) < 0) return 0;
     mpf_init_set_str(_uv_max, SvPV_nolen(MATH_GMPf_UV_MAX(aTHX)), 10);
     mpf_init2(copy, mpf_get_prec(*n));
     mpf_trunc(copy, *n);
     if(mpf_cmp(copy, _uv_max) > 0) {
       mpf_clear(_uv_max);
       mpf_clear(copy);
       return 0;
     }
     mpf_clear(_uv_max);
     mpf_clear(copy);
     return 1;

#endif
}
*/

int _has_pv_nv_bug(void) {
#if defined(GMPF_PV_NV_BUG)
     return 1;
#else
     return 0;
#endif
}



MODULE = Math::GMPf  PACKAGE = Math::GMPf

PROTOTYPES: DISABLE


int
NOK_POK_val ()
CODE:
  RETVAL = NOK_POK_val (aTHX);
OUTPUT:  RETVAL


int
_is_infstring (s)
	char *	s

int
_is_nanstring (s)
	char *	s

unsigned long
Rmpf_get_default_prec ()


void
Rmpf_set_default_prec (prec)
	SV *	prec
        PPCODE:
        Rmpf_set_default_prec(aTHX_ prec);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpf_init_set_str_nobless (str, base)
	SV *	str
	SV *	base
CODE:
  RETVAL = Rmpf_init_set_str_nobless (aTHX_ str, base);
OUTPUT:  RETVAL

SV *
Rmpf_init2_nobless (prec)
	SV *	prec
CODE:
  RETVAL = Rmpf_init2_nobless (aTHX_ prec);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_str (str, base)
	SV *	str
	SV *	base
CODE:
  RETVAL = Rmpf_init_set_str (aTHX_ str, base);
OUTPUT:  RETVAL

SV *
Rmpf_init2 (prec)
	SV *	prec
CODE:
  RETVAL = Rmpf_init2 (aTHX_ prec);
OUTPUT:  RETVAL

SV *
Rmpf_init_nobless ()
CODE:
  RETVAL = Rmpf_init_nobless (aTHX);
OUTPUT:  RETVAL


SV *
Rmpf_init ()
CODE:
  RETVAL = Rmpf_init (aTHX);
OUTPUT:  RETVAL


SV *
Rmpf_init_set (a)
	mpf_t *	a
CODE:
  RETVAL = Rmpf_init_set (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_ui (a)
	unsigned long	a
CODE:
  RETVAL = Rmpf_init_set_ui (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_si (a)
	long	a
CODE:
  RETVAL = Rmpf_init_set_si (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_d (a)
	double	a
CODE:
  RETVAL = Rmpf_init_set_d (aTHX_ a);
OUTPUT:  RETVAL

void
_Rmpf_set_ld (q, p)
	mpf_t *	q
	SV *	p
        PPCODE:
        _Rmpf_set_ld(aTHX_ q, p);
        XSRETURN_EMPTY; /* return empty stack */

void
_Rmpf_set_float128 (q, p)
	mpf_t *	q
	SV *	p
        PPCODE:
        _Rmpf_set_float128(aTHX_ q, p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_d (p, d)
	mpf_t *	p
	double	d
        PPCODE:
        Rmpf_set_d(p, d);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_NV (q, p)
	mpf_t *	q
	SV *	p
        PPCODE:
        Rmpf_set_NV(aTHX_ q, p);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpf_init_set_NV (p)
	SV *	p
CODE:
  RETVAL = Rmpf_init_set_NV (aTHX_ p);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_NV_nobless (p)
	SV *	p
CODE:
  RETVAL = Rmpf_init_set_NV_nobless (aTHX_ p);
OUTPUT:  RETVAL

void
Rmpf_set_IV (a, my_iv)
	mpf_t *	a
	SV *	my_iv
        PPCODE:
        Rmpf_set_IV(aTHX_ a, my_iv);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpf_init_set_IV (p)
	SV *	p
CODE:
  RETVAL = Rmpf_init_set_IV (aTHX_ p);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_IV_nobless (p)
	SV *	p
CODE:
  RETVAL = Rmpf_init_set_IV_nobless (aTHX_ p);
OUTPUT:  RETVAL

int
Rmpf_cmp_IV (f, iv)
	mpf_t *	f
	SV *	iv
CODE:
  RETVAL = Rmpf_cmp_IV (aTHX_ f, iv);
OUTPUT:  RETVAL

int
Rmpf_cmp_NV (f, nv)
	mpf_t *	f
	SV *	nv
CODE:
  RETVAL = Rmpf_cmp_NV (aTHX_ f, nv);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_nobless (a)
	mpf_t *	a
CODE:
  RETVAL = Rmpf_init_set_nobless (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_ui_nobless (a)
	unsigned long	a
CODE:
  RETVAL = Rmpf_init_set_ui_nobless (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_si_nobless (a)
	long	a
CODE:
  RETVAL = Rmpf_init_set_si_nobless (aTHX_ a);
OUTPUT:  RETVAL

SV *
Rmpf_init_set_d_nobless (a)
	double	a
CODE:
  RETVAL = Rmpf_init_set_d_nobless (aTHX_ a);
OUTPUT:  RETVAL

void
Rmpf_deref2 (p, base, n_digits)
	mpf_t *	p
	SV *	base
	SV *	n_digits
        PPCODE:
        PL_markstack_ptr++;
        Rmpf_deref2(aTHX_ p, base, n_digits);
        return;

void
DESTROY (p)
	mpf_t *	p
        PPCODE:
        DESTROY(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_clear (p)
	mpf_t *	p
        PPCODE:
        Rmpf_clear(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_clear_mpf (p)
	mpf_t *	p
        PPCODE:
        Rmpf_clear_mpf(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_clear_ptr (p)
	mpf_t *	p
        PPCODE:
        Rmpf_clear_ptr(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpf_get_prec (p)
	mpf_t *	p
CODE:
  RETVAL = Rmpf_get_prec (aTHX_ p);
OUTPUT:  RETVAL

void
Rmpf_set_prec (p, prec)
	mpf_t *	p
	SV *	prec
        PPCODE:
        Rmpf_set_prec(aTHX_ p, prec);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_prec_raw (p, prec)
	mpf_t *	p
	SV *	prec
        PPCODE:
        Rmpf_set_prec_raw(aTHX_ p, prec);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set (p1, p2)
	mpf_t *	p1
	mpf_t *	p2
        PPCODE:
        Rmpf_set(p1, p2);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_ui (p, ul)
	mpf_t *	p
	unsigned long	ul
        PPCODE:
        Rmpf_set_ui(p, ul);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_si (p, l)
	mpf_t *	p
	long	l
        PPCODE:
        Rmpf_set_si(p, l);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_z (p, z)
	mpf_t *	p
	mpz_t *	z
        PPCODE:
        Rmpf_set_z(p, z);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_q (p, q)
	mpf_t *	p
	mpq_t *	q
        PPCODE:
        Rmpf_set_q(p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_set_str (p, str, base)
	mpf_t *	p
	SV *	str
	int	base
        PPCODE:
        Rmpf_set_str(aTHX_ p, str, base);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_swap (p1, p2)
	mpf_t *	p1
	mpf_t *	p2
        PPCODE:
        Rmpf_swap(p1, p2);
        XSRETURN_EMPTY; /* return empty stack */

SV *
_TRmpf_out_str (stream, base, dig, p)
	FILE *	stream
	int	base
	SV *	dig
	mpf_t *	p
CODE:
  RETVAL = _TRmpf_out_str (aTHX_ stream, base, dig, p);
OUTPUT:  RETVAL

SV *
_Rmpf_out_str (p, base, dig)
	mpf_t *	p
	int	base
	SV *	dig
CODE:
  RETVAL = _Rmpf_out_str (aTHX_ p, base, dig);
OUTPUT:  RETVAL

SV *
_TRmpf_out_strS (stream, base, dig, p, suff)
	FILE *	stream
	int	base
	SV *	dig
	mpf_t *	p
	SV *	suff
CODE:
  RETVAL = _TRmpf_out_strS (aTHX_ stream, base, dig, p, suff);
OUTPUT:  RETVAL

SV *
_TRmpf_out_strP (pre, stream, base, dig, p)
	SV *	pre
	FILE *	stream
	int	base
	SV *	dig
	mpf_t *	p
CODE:
  RETVAL = _TRmpf_out_strP (aTHX_ pre, stream, base, dig, p);
OUTPUT:  RETVAL

SV *
_TRmpf_out_strPS (pre, stream, base, dig, p, suff)
	SV *	pre
	FILE *	stream
	int	base
	SV *	dig
	mpf_t *	p
	SV *	suff
CODE:
  RETVAL = _TRmpf_out_strPS (aTHX_ pre, stream, base, dig, p, suff);
OUTPUT:  RETVAL

SV *
_Rmpf_out_strS (p, base, dig, suff)
	mpf_t *	p
	int	base

GMPf.xs view on Meta::CPAN

Rmpf_get_d (p)
	mpf_t *	p

double
Rmpf_get_d_rndn (p)
	mpf_t *	p

SV *
_Rmpf_get_ld (x)
	mpf_t *	x
CODE:
  RETVAL = _Rmpf_get_ld (aTHX_ x);
OUTPUT:  RETVAL

SV *
_Rmpf_get_ld_rndn (x)
	mpf_t *	x
CODE:
  RETVAL = _Rmpf_get_ld_rndn (aTHX_ x);
OUTPUT:  RETVAL

SV *
_Rmpf_get_float128 (x)
	mpf_t *	x
CODE:
  RETVAL = _Rmpf_get_float128 (aTHX_ x);
OUTPUT:  RETVAL

SV *
_Rmpf_get_float128_rndn (x)
	mpf_t *	x
CODE:
  RETVAL = _Rmpf_get_float128_rndn (aTHX_ x);
OUTPUT:  RETVAL

SV *
Rmpf_get_NV (x)
	mpf_t *	x
CODE:
  RETVAL = Rmpf_get_NV (aTHX_ x);
OUTPUT:  RETVAL

SV *
Rmpf_get_NV_rndn (x)
	mpf_t *	x
CODE:
  RETVAL = Rmpf_get_NV_rndn (aTHX_ x);
OUTPUT:  RETVAL

long
Rmpf_get_si (p)
	mpf_t *	p

unsigned long
Rmpf_get_ui (p)
	mpf_t *	p

void
Rmpf_get_d_2exp (n)
	mpf_t *	n
        PPCODE:
        PL_markstack_ptr++;
        Rmpf_get_d_2exp(aTHX_ n);
        return;

void
Rmpf_add (dest, src1, src2)
	mpf_t *	dest
	mpf_t *	src1
	mpf_t *	src2
        PPCODE:
        Rmpf_add(dest, src1, src2);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_add_ui (dest, src, num)
	mpf_t *	dest
	mpf_t *	src
	unsigned long	num
        PPCODE:
        Rmpf_add_ui(dest, src, num);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_sub (dest, src1, src2)
	mpf_t *	dest
	mpf_t *	src1
	mpf_t *	src2
        PPCODE:
        Rmpf_sub(dest, src1, src2);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_sub_ui (dest, src, num)
	mpf_t *	dest
	mpf_t *	src
	unsigned long	num
        PPCODE:
        Rmpf_sub_ui(dest, src, num);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_ui_sub (dest, num, src)
	mpf_t *	dest
	unsigned long	num
	mpf_t *	src
        PPCODE:
        Rmpf_ui_sub(dest, num, src);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_mul (dest, src1, src2)
	mpf_t *	dest
	mpf_t *	src1
	mpf_t *	src2
        PPCODE:
        Rmpf_mul(dest, src1, src2);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_mul_ui (dest, src, num)
	mpf_t *	dest
	mpf_t *	src
	unsigned long	num
        PPCODE:
        Rmpf_mul_ui(dest, src, num);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_div (d, p, q)
	mpf_t *	d
	mpf_t *	p
	mpf_t *	q
        PPCODE:
        Rmpf_div(d, p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_ui_div (d, p, q)
	mpf_t *	d
	unsigned long	p
	mpf_t *	q
        PPCODE:
        Rmpf_ui_div(d, p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_div_ui (d, p, q)
	mpf_t *	d
	mpf_t *	p
	unsigned long	q
        PPCODE:
        Rmpf_div_ui(d, p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_sqrt (r, x)
	mpf_t *	r
	mpf_t *	x
        PPCODE:
        Rmpf_sqrt(r, x);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_sqrt_ui (r, x)
	mpf_t *	r
	unsigned long	x
        PPCODE:
        Rmpf_sqrt_ui(r, x);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_pow_ui (r, num, pow)
	mpf_t *	r
	mpf_t *	num
	unsigned long	pow
        PPCODE:
        Rmpf_pow_ui(r, num, pow);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_neg (r, x)
	mpf_t *	r
	mpf_t *	x
        PPCODE:
        Rmpf_neg(r, x);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_abs (r, x)
	mpf_t *	r
	mpf_t *	x
        PPCODE:
        Rmpf_abs(r, x);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_mul_2exp (r, x, s)
	mpf_t *	r
	mpf_t *	x
	SV *	s
        PPCODE:
        Rmpf_mul_2exp(aTHX_ r, x, s);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_div_2exp (r, x, s)
	mpf_t *	r
	mpf_t *	x
	SV *	s
        PPCODE:
        Rmpf_div_2exp(aTHX_ r, x, s);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpf_eq (a, b, bits)
	mpf_t *	a
	mpf_t *	b
	unsigned long	bits

void
Rmpf_reldiff (d, p, q)
	mpf_t *	d
	mpf_t *	p
	mpf_t *	q
        PPCODE:
        Rmpf_reldiff(d, p, q);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpf_sgn (p)
	mpf_t *	p

void
Rmpf_ceil (p, q)
	mpf_t *	p
	mpf_t *	q
        PPCODE:
        Rmpf_ceil(p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_floor (p, q)
	mpf_t *	p
	mpf_t *	q
        PPCODE:
        Rmpf_floor(p, q);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_trunc (p, q)
	mpf_t *	p
	mpf_t *	q
        PPCODE:
        Rmpf_trunc(p, q);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpf_integer_p (p)
	mpf_t *	p

int
Rmpf_fits_ulong_p (p)
	mpf_t *	p

int
Rmpf_fits_slong_p (p)
	mpf_t *	p

int
Rmpf_fits_uint_p (p)
	mpf_t *	p

int
Rmpf_fits_sint_p (p)
	mpf_t *	p

int
Rmpf_fits_ushort_p (p)
	mpf_t *	p

int
Rmpf_fits_sshort_p (p)
	mpf_t *	p

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)

GMPf.xs view on Meta::CPAN

  RETVAL = overload_spaceship (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_equiv (a, b, third)
	mpf_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_equiv (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_not_equiv (a, b, third)
	mpf_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_not_equiv (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_not (a, second, third)
	mpf_t *	a
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_not (aTHX_ a, second, third);
OUTPUT:  RETVAL

SV *
overload_sqrt (p, second, third)
	mpf_t *	p
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_sqrt (aTHX_ p, second, third);
OUTPUT:  RETVAL

SV *
overload_pow (p, second, third)
	SV *	p
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_pow (aTHX_ p, second, third);
OUTPUT:  RETVAL

SV *
overload_int (p, second, third)
	mpf_t *	p
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_int (aTHX_ p, second, third);
OUTPUT:  RETVAL

void
Rmpf_urandomb (p, ...)
	SV *	p
        PPCODE:
        PL_markstack_ptr++;
        Rmpf_urandomb(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpf_random2 (x, ...)
	SV *	x
        PPCODE:
        PL_markstack_ptr++;
        Rmpf_random2(aTHX_ x);
        XSRETURN_EMPTY; /* return empty stack */

SV *
get_refcnt (s)
	SV *	s
CODE:
  RETVAL = get_refcnt (aTHX_ s);
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 *
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_sub_eq (a, b, third)
	SV *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_sub_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_pow_eq (p, second, third)
	SV *	p
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_pow_eq (aTHX_ p, second, third);
OUTPUT:  RETVAL

SV *
gmp_v ()
CODE:
  RETVAL = gmp_v (aTHX);

GMPf.xs view on Meta::CPAN


int
_has_longlong ()


int
_has_longdouble ()


int
_has_inttypes ()


SV *
___GNU_MP_VERSION ()
CODE:
  RETVAL = ___GNU_MP_VERSION (aTHX);
OUTPUT:  RETVAL


SV *
___GNU_MP_VERSION_MINOR ()
CODE:
  RETVAL = ___GNU_MP_VERSION_MINOR (aTHX);
OUTPUT:  RETVAL


SV *
___GNU_MP_VERSION_PATCHLEVEL ()
CODE:
  RETVAL = ___GNU_MP_VERSION_PATCHLEVEL (aTHX);
OUTPUT:  RETVAL


SV *
___GNU_MP_RELEASE ()
CODE:
  RETVAL = ___GNU_MP_RELEASE (aTHX);
OUTPUT:  RETVAL


SV *
___GMP_CC ()
CODE:
  RETVAL = ___GMP_CC (aTHX);
OUTPUT:  RETVAL


SV *
___GMP_CFLAGS ()
CODE:
  RETVAL = ___GMP_CFLAGS (aTHX);
OUTPUT:  RETVAL


void
overload_inc (p, second, third)
	SV *	p
	SV *	second
	SV *	third
        PPCODE:
        overload_inc(aTHX_ p, second, third);
        XSRETURN_EMPTY; /* return empty stack */

void
overload_dec (p, second, third)
	SV *	p
	SV *	second
	SV *	third
        PPCODE:
        overload_dec(aTHX_ p, second, third);
        XSRETURN_EMPTY; /* return empty stack */

SV *
_wrap_count ()
CODE:
  RETVAL = _wrap_count (aTHX);
OUTPUT:  RETVAL


SV *
_get_xs_version ()
CODE:
  RETVAL = _get_xs_version (aTHX);
OUTPUT:  RETVAL


SV *
_GMP_LIMB_BITS ()
CODE:
  RETVAL = _GMP_LIMB_BITS (aTHX);
OUTPUT:  RETVAL


SV *
_GMP_NAIL_BITS ()
CODE:
  RETVAL = _GMP_NAIL_BITS (aTHX);
OUTPUT:  RETVAL


int
_nv_is_float128 ()


int
_SvNOK (in)
	SV *	in
CODE:
  RETVAL = _SvNOK (aTHX_ in);
OUTPUT:  RETVAL

int
_SvIOK (in)
	SV *	in
CODE:
  RETVAL = _SvIOK (aTHX_ in);
OUTPUT:  RETVAL

int
_SvPOK (in)
	SV *	in
CODE:
  RETVAL = _SvPOK (aTHX_ in);
OUTPUT:  RETVAL

int
IOK_flag (sv)
	SV *	sv

int
POK_flag (sv)
	SV *	sv

int
NOK_flag (sv)
	SV *	sv

int
nok_pokflag ()


void
clear_nok_pok ()

        PPCODE:
        clear_nok_pok();
        XSRETURN_EMPTY; /* return empty stack */

void
set_nok_pok (x)
	int	x
        PPCODE:
        set_nok_pok(x);
        XSRETURN_EMPTY; /* return empty stack */

int
_required_ldbl_mant_dig ()


SV *
MATH_GMPf_IV_MAX ()
CODE:
  RETVAL = MATH_GMPf_IV_MAX (aTHX);
OUTPUT:  RETVAL


SV *
MATH_GMPf_IV_MIN ()
CODE:
  RETVAL = MATH_GMPf_IV_MIN (aTHX);
OUTPUT:  RETVAL


SV *
MATH_GMPf_UV_MAX ()
CODE:
  RETVAL = MATH_GMPf_UV_MAX (aTHX);
OUTPUT:  RETVAL


SV *
_Rmpf_get_IV (n)
	mpf_t *	n
CODE:
  RETVAL = _Rmpf_get_IV (aTHX_ n);
OUTPUT:  RETVAL

int
Rmpf_fits_IV_p (n)
	mpf_t *	n
CODE:
  RETVAL = Rmpf_fits_IV_p (aTHX_ n);
OUTPUT:  RETVAL

int
_has_pv_nv_bug ()

( run in 1.109 second using v1.01-cache-2.11-cpan-5511b514fd6 )