PPCODE results from the CPAN

Math-MPFI

view release on metacpan or search on metacpan

int
_has_longlong ()


int
_has_longdouble ()


int
_nv_is_float128 ()


int
_required_ldbl_mant_dig ()


int
_ivsize_bits ()


SV *
_my_mpfr_set_float128 (p, q, round)
	mpfr_t *	p
	SV *	q
	unsigned int	round
CODE:
  RETVAL = _my_mpfr_set_float128 (aTHX_ p, q, round);
OUTPUT:  RETVAL

SV *
RMPFI_BOTH_ARE_EXACT (ret)
	int	ret
CODE:
  RETVAL = RMPFI_BOTH_ARE_EXACT (aTHX_ ret);
OUTPUT:  RETVAL

SV *
RMPFI_LEFT_IS_INEXACT (ret)
	int	ret
CODE:
  RETVAL = RMPFI_LEFT_IS_INEXACT (aTHX_ ret);
OUTPUT:  RETVAL

SV *
RMPFI_RIGHT_IS_INEXACT (ret)
	int	ret
CODE:
  RETVAL = RMPFI_RIGHT_IS_INEXACT (aTHX_ ret);
OUTPUT:  RETVAL

SV *
RMPFI_BOTH_ARE_INEXACT (ret)
	int	ret
CODE:
  RETVAL = RMPFI_BOTH_ARE_INEXACT (aTHX_ ret);
OUTPUT:  RETVAL

void
_Rmpfi_set_default_prec (p)
	SV *	p
        PPCODE:
        _Rmpfi_set_default_prec(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

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


void
Rmpfi_set_prec (op, prec)
	mpfi_t *	op
	SV *	prec
        PPCODE:
        Rmpfi_set_prec(aTHX_ op, prec);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfi_get_prec (op)
	mpfi_t *	op
CODE:
  RETVAL = Rmpfi_get_prec (aTHX_ op);
OUTPUT:  RETVAL

SV *
Rmpfi_round_prec (op, prec)
	mpfi_t *	op
	SV *	prec
CODE:
  RETVAL = Rmpfi_round_prec (aTHX_ op, prec);
OUTPUT:  RETVAL

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


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


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

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

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

void
Rmpfi_clear (p)
	mpfi_t *	p
        PPCODE:
        Rmpfi_clear(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfi_set (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_set_ui (rop, op)
	mpfi_t *	rop
	unsigned long	op

int
Rmpfi_set_si (rop, op)
	mpfi_t *	rop
	long	op

int
Rmpfi_set_d (rop, op)
	mpfi_t *	rop
	SV *	op
CODE:
  RETVAL = Rmpfi_set_d (aTHX_ rop, op);
OUTPUT:  RETVAL

int
Rmpfi_set_NV (rop, op)
	mpfi_t *	rop
	SV *	op
CODE:
  RETVAL = Rmpfi_set_NV (aTHX_ rop, op);
OUTPUT:  RETVAL

int
Rmpfi_set_z (rop, op)
	mpfi_t *	rop
	mpz_t *	op

int
Rmpfi_set_q (rop, op)
	mpfi_t *	rop
	mpq_t *	op

int
Rmpfi_set_fr (rop, op)
	mpfi_t *	rop
	mpfr_t *	op

int
Rmpfi_set_str (rop, s, base)
	mpfi_t *	rop
	SV *	s
	SV *	base
CODE:
  RETVAL = Rmpfi_set_str (aTHX_ rop, s, base);
OUTPUT:  RETVAL

void
Rmpfi_swap (x, y)
	mpfi_t *	x
	mpfi_t *	y
        PPCODE:
        Rmpfi_swap(x, y);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfi_init_set (q)
	mpfi_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set(aTHX_ q);
        return;

void
Rmpfi_init_set_ui (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_ui(aTHX_ q);
        return;

void
Rmpfi_init_set_si (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_si(aTHX_ q);
        return;

void
Rmpfi_init_set_d (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_d(aTHX_ q);
        return;

void
Rmpfi_init_set_z (q)
	mpz_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_z(aTHX_ q);
        return;

void
Rmpfi_init_set_q (q)
	mpq_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_q(aTHX_ q);
        return;

void
Rmpfi_init_set_fr (q)
	mpfr_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_fr(aTHX_ q);
        return;

void
Rmpfi_init_set_str (q, base)
	SV *	q
	SV *	base
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_str(aTHX_ q, base);
        return;

void
Rmpfi_init_set_nobless (q)
	mpfi_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_ui_nobless (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_ui_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_si_nobless (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_si_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_d_nobless (q)
	SV *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_d_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_z_nobless (q)
	mpz_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_z_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_q_nobless (q)
	mpq_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_q_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_fr_nobless (q)
	mpfr_t *	q
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_fr_nobless(aTHX_ q);
        return;

void
Rmpfi_init_set_str_nobless (q, base)
	SV *	q
	SV *	base
        PPCODE:
        PL_markstack_ptr++;
        Rmpfi_init_set_str_nobless(aTHX_ q, base);
        return;

int
Rmpfi_diam_abs (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_diam_rel (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_diam (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_mag (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_mig (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_mid (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

void
Rmpfi_alea (rop, op)
	mpfr_t *	rop
	mpfi_t *	op
        PPCODE:
        Rmpfi_alea(rop, op);
        XSRETURN_EMPTY; /* return empty stack */

double
Rmpfi_get_d (op)
	mpfi_t *	op

void
Rmpfi_get_fr (rop, op)
	mpfr_t *	rop
	mpfi_t *	op
        PPCODE:
        Rmpfi_get_fr(rop, op);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfi_get_NV (op)
	mpfi_t *	op
CODE:
  RETVAL = Rmpfi_get_NV (aTHX_ op);
OUTPUT:  RETVAL

int
Rmpfi_add (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

int
Rmpfi_add_d (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	SV *	op2
CODE:
  RETVAL = Rmpfi_add_d (aTHX_ rop, op1, op2);
OUTPUT:  RETVAL

int
Rmpfi_add_ui (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	unsigned long	op2

int
Rmpfi_add_si (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	long	op2

int
Rmpfi_add_z (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpz_t *	op2

int
Rmpfi_add_q (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpq_t *	op2

int
Rmpfi_add_fr (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfr_t *	op2

int
Rmpfi_sub (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

MPFI.xs view on Meta::CPAN

int
Rmpfi_bounded_p (op)
	mpfi_t *	op

SV *
_Rmpfi_out_str (stream, base, dig, p)
	FILE *	stream
	SV *	base
	SV *	dig
	mpfi_t *	p
CODE:
  RETVAL = _Rmpfi_out_str (aTHX_ stream, base, dig, p);
OUTPUT:  RETVAL

SV *
_Rmpfi_out_strS (stream, base, dig, p, suff)
	FILE *	stream
	SV *	base
	SV *	dig
	mpfi_t *	p
	SV *	suff
CODE:
  RETVAL = _Rmpfi_out_strS (aTHX_ stream, base, dig, p, suff);
OUTPUT:  RETVAL

SV *
_Rmpfi_out_strP (pre, stream, base, dig, p)
	SV *	pre
	FILE *	stream
	SV *	base
	SV *	dig
	mpfi_t *	p
CODE:
  RETVAL = _Rmpfi_out_strP (aTHX_ pre, stream, base, dig, p);
OUTPUT:  RETVAL

SV *
_Rmpfi_out_strPS (pre, stream, base, dig, p, suff)
	SV *	pre
	FILE *	stream
	SV *	base
	SV *	dig
	mpfi_t *	p
	SV *	suff
CODE:
  RETVAL = _Rmpfi_out_strPS (aTHX_ pre, stream, base, dig, p, suff);
OUTPUT:  RETVAL

SV *
Rmpfi_inp_str (p, stream, base)
	mpfi_t *	p
	FILE *	stream
	SV *	base
CODE:
  RETVAL = Rmpfi_inp_str (aTHX_ p, stream, base);
OUTPUT:  RETVAL

void
Rmpfi_print_binary (op)
	mpfi_t *	op
        PPCODE:
        Rmpfi_print_binary(op);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfi_get_left (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_get_right (rop, op)
	mpfr_t *	rop
	mpfi_t *	op

int
Rmpfi_revert_if_needed (op)
	mpfi_t *	op

int
Rmpfi_put (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_put_d (rop, op)
	mpfi_t *	rop
	SV *	op
CODE:
  RETVAL = Rmpfi_put_d (aTHX_ rop, op);
OUTPUT:  RETVAL

int
Rmpfi_put_ui (rop, op)
	mpfi_t *	rop
	unsigned long	op

int
Rmpfi_put_si (rop, op)
	mpfi_t *	rop
	long	op

int
Rmpfi_put_z (rop, op)
	mpfi_t *	rop
	mpz_t *	op

int
Rmpfi_put_q (rop, op)
	mpfi_t *	rop
	mpq_t *	op

int
Rmpfi_put_fr (rop, op)
	mpfi_t *	rop
	mpfr_t *	op

int
Rmpfi_interv_d (rop, op1, op2)
	mpfi_t *	rop
	SV *	op1
	SV *	op2

MPFI.xs view on Meta::CPAN


int
Rmpfi_is_inside_si (op2, op1)
	long	op2
	mpfi_t *	op1

int
Rmpfi_is_inside_z (op2, op1)
	mpz_t *	op2
	mpfi_t *	op1

int
Rmpfi_is_inside_q (op2, op1)
	mpq_t *	op2
	mpfi_t *	op1

int
Rmpfi_is_inside_fr (op2, op1)
	mpfr_t *	op2
	mpfi_t *	op1

int
Rmpfi_is_empty (op)
	mpfi_t *	op

int
Rmpfi_intersect (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

int
Rmpfi_union (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

int
Rmpfi_increase (rop, op)
	mpfi_t *	rop
	mpfr_t *	op

int
Rmpfi_blow (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	SV *	op2
CODE:
  RETVAL = Rmpfi_blow (aTHX_ rop, op1, op2);
OUTPUT:  RETVAL

int
Rmpfi_bisect (rop1, rop2, op)
	mpfi_t *	rop1
	mpfi_t *	rop2
	mpfi_t *	op

void
RMPFI_ERROR (msg)
	SV *	msg
        PPCODE:
        RMPFI_ERROR(aTHX_ msg);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfi_is_error ()


void
Rmpfi_set_error (op)
	int	op
        PPCODE:
        Rmpfi_set_error(op);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfi_reset_error ()

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

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

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


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


SV *
overload_spaceship (a, b, third)
	mpfi_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_spaceship (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_gte (a, b, third)
	mpfi_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_gte (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_lte (a, b, third)
	mpfi_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_lte (aTHX_ a, b, third);
OUTPUT:  RETVAL

SV *
overload_gt (a, b, third)
	mpfi_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_gt (aTHX_ a, b, third);
OUTPUT:  RETVAL

MPFI.xs view on Meta::CPAN

  RETVAL = Rmpfi_get_version (aTHX);
OUTPUT:  RETVAL


int
Rmpfi_const_catalan (rop)
	mpfi_t *	rop

int
Rmpfi_cbrt (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_sec (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_csc (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_cot (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_sech (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_csch (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_coth (rop, op)
	mpfi_t *	rop
	mpfi_t *	op

int
Rmpfi_atan2 (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

int
Rmpfi_hypot (rop, op1, op2)
	mpfi_t *	rop
	mpfi_t *	op1
	mpfi_t *	op2

void
Rmpfi_urandom (rop, op, state)
	mpfr_t *	rop
	mpfi_t *	op
	gmp_randstate_t *	state
        PPCODE:
        Rmpfi_urandom(rop, op, state);
        XSRETURN_EMPTY; /* return empty stack */

SV *
overload_true (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_true (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_not (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_not (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_abs (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_abs (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_sin (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_sin (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_cos (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_cos (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_log (op, second, third)
	mpfi_t *	op
	SV *	second
	SV *	third
CODE:
  RETVAL = overload_log (aTHX_ op, second, third);
OUTPUT:  RETVAL

SV *
overload_exp (op, second, third)
	mpfi_t *	op

MPFI.xs view on Meta::CPAN

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


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


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


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


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


int
_can_pass_float128 ()


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

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

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
_has_pv_nv_bug ()


int
_msc_ver_defined ()

( run in 1.601 second using v1.01-cache-2.11-cpan-71847e10f99 )