PPCODE results from the CPAN

PPCODE

Math-MPC

view release on metacpan or search on metacpan

	mpc_ptr	rop
	mpc_ptr	op
	double	i
	mpc_rnd_t	rnd

int
Rmpc_div_sj (rop, op, i, rnd)
	mpc_ptr	rop
	mpc_ptr	op
	intmax_t	i
	mpc_rnd_t	rnd

int
Rmpc_sj_div (rop, i, op, rnd)
	mpc_ptr	rop
	intmax_t	i
	mpc_ptr	op
	mpc_rnd_t	rnd

int
Rmpc_div_ld (rop, op, i, rnd)
	mpc_ptr	rop
	mpc_ptr	op
	long double	i
	mpc_rnd_t	rnd

int
Rmpc_ld_div (rop, i, op, rnd)
	mpc_ptr	rop
	long double	i
	mpc_ptr	op
	mpc_rnd_t	rnd

int
Rmpc_div_d (rop, op, i, rnd)
	mpc_ptr	rop
	mpc_ptr	op
	double	i
	mpc_rnd_t	rnd

int
Rmpc_d_div (rop, i, op, rnd)
	mpc_ptr	rop
	double	i
	mpc_ptr	op
	mpc_rnd_t	rnd

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

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

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

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

SV *
Rmpc_get_prec (x)
	mpc_t *	x
CODE:
  RETVAL = Rmpc_get_prec (aTHX_ x);
OUTPUT:  RETVAL

void
Rmpc_get_prec2 (x)
	mpc_t *	x
        PPCODE:
        PL_markstack_ptr++;
        Rmpc_get_prec2(aTHX_ x);
        return;

SV *
Rmpc_get_im_prec (x)
	mpc_t *	x
CODE:
  RETVAL = Rmpc_get_im_prec (aTHX_ x);
OUTPUT:  RETVAL

SV *
Rmpc_get_re_prec (x)
	mpc_t *	x
CODE:
  RETVAL = Rmpc_get_re_prec (aTHX_ x);
OUTPUT:  RETVAL

void
RMPC_RE (fr, x)
	mpfr_t *	fr
	mpc_t *	x
        PPCODE:
        RMPC_RE(fr, x);
        XSRETURN_EMPTY; /* return empty stack */

void
RMPC_IM (fr, x)
	mpfr_t *	fr
	mpc_t *	x
        PPCODE:
        RMPC_IM(fr, x);
        XSRETURN_EMPTY; /* return empty stack */

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

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

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

void
Rmpc_clear (p)
	mpc_t *	p
        PPCODE:
        Rmpc_clear(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpc_clear_mpc (p)
	mpc_t *	p
        PPCODE:
        Rmpc_clear_mpc(p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpc_clear_ptr (p)
	mpc_t *	p
        PPCODE:
        Rmpc_clear_ptr(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

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

SV *
Rmpc_init3 (prec_r, prec_i)
	SV *	prec_r
	SV *	prec_i
CODE:
  RETVAL = Rmpc_init3 (aTHX_ prec_r, prec_i);
OUTPUT:  RETVAL

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

SV *
Rmpc_init3_nobless (prec_r, prec_i)
	SV *	prec_r
	SV *	prec_i
CODE:
  RETVAL = Rmpc_init3_nobless (aTHX_ prec_r, prec_i);
OUTPUT:  RETVAL

SV *
Rmpc_set (p, q, round)
	mpc_t *	p
	mpc_t *	q
	SV *	round
CODE:
  RETVAL = Rmpc_set (aTHX_ p, q, round);
OUTPUT:  RETVAL

SV *
Rmpc_set_ui (p, q, round)
	mpc_t *	p
	SV *	q
	SV *	round
CODE:
  RETVAL = Rmpc_set_ui (aTHX_ p, q, round);
OUTPUT:  RETVAL

SV *
Rmpc_set_si (p, q, round)
	mpc_t *	p
	SV *	q
	SV *	round
CODE:
  RETVAL = Rmpc_set_si (aTHX_ p, q, round);
OUTPUT:  RETVAL

MPC.xs view on Meta::CPAN


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_pow (a, b, third)
	mpc_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_pow (aTHX_ a, b, third);
OUTPUT:  RETVAL

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_equiv (a, b, third)
	mpc_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_equiv (aTHX_ a, b, third);
OUTPUT:  RETVAL

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

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

void
overload_copy (p, second, third)
	mpc_t *	p
	SV *	second
	SV *	third
        PPCODE:
        PL_markstack_ptr++;
        overload_copy(aTHX_ p, second, third);
        return;

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

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

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

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

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

void
_get_r_string (p, base, n_digits, round)
	mpc_t *	p
	SV *	base
	SV *	n_digits
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        _get_r_string(aTHX_ p, base, n_digits, round);
        return;

void
_get_i_string (p, base, n_digits, round)
	mpc_t *	p
	SV *	base
	SV *	n_digits
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        _get_i_string(aTHX_ p, base, n_digits, round);
        return;

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

SV *
_new_real_im (b, d)
	SV *	b
	SV *	d
CODE:
  RETVAL = _new_real_im (aTHX_ b, d);
OUTPUT:  RETVAL

int
_has_longlong ()


int
_has_longdouble ()


int
_has_inttypes ()

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


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


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


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


SV *
_MPC_VERSION_PATCHLEVEL ()

MPC.xs view on Meta::CPAN

SV *
Rmpc_imag (rop, op, round)
	mpfr_t *	rop
	mpc_t *	op
	SV *	round
CODE:
  RETVAL = Rmpc_imag (aTHX_ rop, op, round);
OUTPUT:  RETVAL

SV *
Rmpc_arg (rop, op, round)
	mpfr_t *	rop
	mpc_t *	op
	SV *	round
CODE:
  RETVAL = Rmpc_arg (aTHX_ rop, op, round);
OUTPUT:  RETVAL

SV *
Rmpc_proj (rop, op, round)
	mpc_t *	rop
	mpc_t *	op
	SV *	round
CODE:
  RETVAL = Rmpc_proj (aTHX_ rop, op, round);
OUTPUT:  RETVAL

SV *
Rmpc_get_str (base, dig, op, round)
	SV *	base
	SV *	dig
	mpc_t *	op
	SV *	round
CODE:
  RETVAL = Rmpc_get_str (aTHX_ base, dig, op, round);
OUTPUT:  RETVAL

int
Rmpc_set_str (rop, str, base, round)
	mpc_t *	rop
	SV *	str
	SV *	base
	SV *	round
CODE:
  RETVAL = Rmpc_set_str (aTHX_ rop, str, base, round);
OUTPUT:  RETVAL

int
Rmpc_strtoc (rop, str, base, round)
	mpc_t *	rop
	SV *	str
	SV *	base
	SV *	round
CODE:
  RETVAL = Rmpc_strtoc (aTHX_ rop, str, base, round);
OUTPUT:  RETVAL

void
Rmpc_set_nan (a)
	mpc_t *	a
        PPCODE:
        Rmpc_set_nan(a);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpc_swap (a, b)
	mpc_t *	a
	mpc_t *	b
        PPCODE:
        Rmpc_swap(a, b);
        XSRETURN_EMPTY; /* return empty stack */

SV *
overload_atan2 (p, q, third)
	mpc_t *	p
	mpc_t *	q
	SV *	third
CODE:
  RETVAL = overload_atan2 (aTHX_ p, q, third);
OUTPUT:  RETVAL

SV *
Rmpc_sin_cos (rop_sin, rop_cos, op, rnd_sin, rnd_cos)
	mpc_t *	rop_sin
	mpc_t *	rop_cos
	mpc_t *	op
	SV *	rnd_sin
	SV *	rnd_cos
CODE:
  RETVAL = Rmpc_sin_cos (aTHX_ rop_sin, rop_cos, op, rnd_sin, rnd_cos);
OUTPUT:  RETVAL

void
Rmpc_get_dc (crop, op, round)
	SV *	crop
	mpc_t *	op
	SV *	round
        PPCODE:
        Rmpc_get_dc(aTHX_ crop, op, round);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpc_get_ldc (crop, op, round)
	SV *	crop
	mpc_t *	op
	SV *	round
        PPCODE:
        Rmpc_get_ldc(aTHX_ crop, op, round);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpc_set_dc (op, crop, round)
	mpc_t *	op
	SV *	crop
	SV *	round
CODE:
  RETVAL = Rmpc_set_dc (aTHX_ op, crop, round);
OUTPUT:  RETVAL

SV *
Rmpc_set_ldc (op, crop, round)
	mpc_t *	op
	SV *	crop
	SV *	round
CODE:
  RETVAL = Rmpc_set_ldc (aTHX_ op, crop, round);
OUTPUT:  RETVAL

void
Rmpc_get_DC (crop, op, round)
	SV *	crop
	mpc_t *	op
	SV *	round
        PPCODE:
        Rmpc_get_DC(aTHX_ crop, op, round);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpc_get_LDC (crop, op, round)
	SV *	crop
	mpc_t *	op
	SV *	round
        PPCODE:
        Rmpc_get_LDC(aTHX_ crop, op, round);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpc_set_DC (op, crop, round)
	mpc_t *	op
	SV *	crop
	SV *	round
CODE:
  RETVAL = Rmpc_set_DC (aTHX_ op, crop, round);
OUTPUT:  RETVAL

SV *
Rmpc_set_LDC (op, crop, round)
	mpc_t *	op
	SV *	crop
	SV *	round
CODE:
  RETVAL = Rmpc_set_LDC (aTHX_ op, crop, round);
OUTPUT:  RETVAL

int
_have_Complex_h ()


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


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


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


SV *
Rmpc_mul_2si (a, b, c, round)
	mpc_t *	a
	mpc_t *	b
	SV *	c
	SV *	round
CODE:
  RETVAL = Rmpc_mul_2si (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

SV *
Rmpc_div_2si (a, b, c, round)
	mpc_t *	a
	mpc_t *	b
	SV *	c
	SV *	round
CODE:
  RETVAL = Rmpc_div_2si (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

SV *
Rmpc_log10 (rop, op, round)
	mpc_t *	rop
	mpc_t *	op
	SV *	round
CODE:
  RETVAL = Rmpc_log10 (aTHX_ rop, op, round);
OUTPUT:  RETVAL

SV *
Rmpc_log2 (a, b, round)
	mpc_t *	a
	mpc_t *	b
	SV *	round
CODE:
  RETVAL = Rmpc_log2 (aTHX_ a, b, round);
OUTPUT:  RETVAL

int
Rmpc_cmp_abs (op1, op2)
	mpc_t *	op1
	mpc_t *	op2

int
Rmpc_rootofunity (rop, n, k, round)
	mpc_t *	rop
	unsigned long	n
	unsigned long	k
	SV *	round
CODE:
  RETVAL = Rmpc_rootofunity (aTHX_ rop, n, k, round);
OUTPUT:  RETVAL

int
_can_pass_float128 ()


int
_get_nv_precision ()


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
_SvNOK (in)
	SV *	in
CODE:
  RETVAL = _SvNOK (aTHX_ in);
OUTPUT:  RETVAL

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

SV *
Rmpc_fma (a, b, c, d, round)
	mpc_t *	a
	mpc_t *	b
	mpc_t *	c
	mpc_t *	d
	SV *	round
CODE:
  RETVAL = Rmpc_fma (aTHX_ a, b, c, d, round);
OUTPUT:  RETVAL

SV *
Rmpc_dot (rop, avref_A, avref_B, len, round)
	mpc_t *	rop
	SV *	avref_A
	SV *	avref_B
	SV *	len
	SV *	round
CODE:
  RETVAL = Rmpc_dot (aTHX_ rop, avref_A, avref_B, len, round);
OUTPUT:  RETVAL

SV *
Rmpc_sum (rop, avref, len, round)
	mpc_t *	rop
	SV *	avref
	SV *	len
	SV *	round
CODE:
  RETVAL = Rmpc_sum (aTHX_ rop, avref, len, round);
OUTPUT:  RETVAL

int
_has_pv_nv_bug ()


int
Rmpc_agm (rop, op1, op2, rnd)
	mpc_t *	rop
	mpc_t *	op1
	mpc_t *	op2
	SV *	rnd
CODE:

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