Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.847 )
Math-Float32
view release on metacpan or search on metacpan
_flt_set (a, b)
float * a
float * b
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_flt_set(a, b);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
flt_set_nan (a)
float * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt_set_nan(a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
flt_set_inf (a, is_pos)
float * a
int is_pos
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt_set_inf(a, is_pos);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
flt_set_zero (a, is_pos)
float * a
int is_pos
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt_set_zero(a, is_pos);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
_unpack_flt_hex (f)
float * f
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_unpack_flt_hex(aTHX_ f);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
float * rop
float * op1
float * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nextafter_flt(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
flt_nextabove (a)
float * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt_nextabove(a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
flt_nextbelow (a)
float * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt_nextbelow(a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
DESTROY (obj)
SV * obj
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DESTROY(obj);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-GMP
view release on metacpan or search on metacpan
mpz_t * n
PREINIT:
mpz_t * quo;
mpz_t * rem;
PPCODE:
quo = malloc (sizeof(mpz_t));
rem = malloc (sizeof(mpz_t));
mpz_init(*quo);
mpz_init(*rem);
mpz_tdiv_qr(*quo, *rem, *m, *n);
unsigned long n
PREINIT:
mpz_t * root;
mpz_t * remainder;
PPCODE:
root = malloc (sizeof(mpz_t));
remainder = malloc (sizeof(mpz_t));
mpz_init(*root);
mpz_init(*remainder);
if (need_rootrem_workaround(m, n)) {
mpz_t * m
PREINIT:
mpz_t * sqrt;
mpz_t * remainder;
PPCODE:
sqrt = malloc (sizeof(mpz_t));
remainder = malloc (sizeof(mpz_t));
mpz_init(*sqrt);
mpz_init(*remainder);
mpz_sqrtrem(*sqrt, *remainder, *m);
Math-GMPf
view release on metacpan or search on metacpan
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)
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)
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)
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)
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)
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)
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)
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)
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 *
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 ()
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 ()
Math-GMPq
view release on metacpan or search on metacpan
char * s
void
Rmpq_canonicalize (p)
mpq_t * p
PPCODE:
Rmpq_canonicalize(p);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpq_init ()
void
DESTROY (p)
mpq_t * p
PPCODE:
DESTROY(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_clear (p)
mpq_t * p
PPCODE:
Rmpq_clear(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_clear_mpq (p)
mpq_t * p
PPCODE:
Rmpq_clear_mpq(p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_clear_ptr (p)
mpq_t * p
PPCODE:
Rmpq_clear_ptr(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set (p1, p2)
mpq_t * p1
mpq_t * p2
PPCODE:
Rmpq_set(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_swap (p1, p2)
mpq_t * p1
mpq_t * p2
PPCODE:
Rmpq_swap(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_z (p1, p2)
mpq_t * p1
mpz_t * p2
PPCODE:
Rmpq_set_z(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_ui (p1, p2, p3)
mpq_t * p1
unsigned long p2
unsigned long p3
PPCODE:
Rmpq_set_ui(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_si (p1, p2, p3)
mpq_t * p1
long p2
long p3
PPCODE:
Rmpq_set_si(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
_Rmpq_set_str (p1, p2, base)
mpq_t * p1
SV * p2
int base
PPCODE:
_Rmpq_set_str(aTHX_ p1, p2, base);
XSRETURN_EMPTY; /* return empty stack */
double
Rmpq_get_d (p)
void
Rmpq_set_d (p, d)
mpq_t * p
double d
PPCODE:
Rmpq_set_d(p, d);
XSRETURN_EMPTY; /* return empty stack */
void
_mpf_set_doubledouble (q, p)
mpf_t * q
SV * p
PPCODE:
_mpf_set_doubledouble(q, p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_NV (copy, original)
mpq_t * copy
SV * original
PPCODE:
Rmpq_set_NV(aTHX_ copy, original);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpq_cmp_NV (a, b)
void
Rmpq_set_f (p, f)
mpq_t * p
mpf_t * f
PPCODE:
Rmpq_set_f(p, f);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpq_get_str (p, base)
void
Rmpq_add (p1, p2, p3)
mpq_t * p1
mpq_t * p2
mpq_t * p3
PPCODE:
Rmpq_add(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_sub (p1, p2, p3)
mpq_t * p1
mpq_t * p2
mpq_t * p3
PPCODE:
Rmpq_sub(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_mul (p1, p2, p3)
mpq_t * p1
mpq_t * p2
mpq_t * p3
PPCODE:
Rmpq_mul(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_div (p1, p2, p3)
mpq_t * p1
mpq_t * p2
mpq_t * p3
PPCODE:
Rmpq_div(p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_mul_2exp (p1, p2, p3)
mpq_t * p1
mpq_t * p2
SV * p3
PPCODE:
Rmpq_mul_2exp(aTHX_ p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_div_2exp (p1, p2, p3)
mpq_t * p1
mpq_t * p2
SV * p3
PPCODE:
Rmpq_div_2exp(aTHX_ p1, p2, p3);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_neg (p1, p2)
mpq_t * p1
mpq_t * p2
PPCODE:
Rmpq_neg(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_abs (p1, p2)
mpq_t * p1
mpq_t * p2
PPCODE:
Rmpq_abs(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_inv (p1, p2)
mpq_t * p1
mpq_t * p2
PPCODE:
Rmpq_inv(p1, p2);
XSRETURN_EMPTY; /* return empty stack */
SV *
_Rmpq_out_str (p, base)
void
Rmpq_numref (z, r)
mpz_t * z
mpq_t * r
PPCODE:
Rmpq_numref(z, r);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_denref (z, r)
mpz_t * z
mpq_t * r
PPCODE:
Rmpq_denref(z, r);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_get_num (z, r)
mpz_t * z
mpq_t * r
PPCODE:
Rmpq_get_num(z, r);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_get_den (z, r)
mpz_t * z
mpq_t * r
PPCODE:
Rmpq_get_den(z, r);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_num (r, z)
mpq_t * r
mpz_t * z
PPCODE:
Rmpq_set_num(r, z);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_den (r, z)
mpq_t * r
mpz_t * z
PPCODE:
Rmpq_set_den(r, z);
XSRETURN_EMPTY; /* return empty stack */
SV *
get_refcnt (s)
void
Rmpq_add_z (rop, op, z)
mpq_t * rop
mpq_t * op
mpz_t * z
PPCODE:
Rmpq_add_z(rop, op, z);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_sub_z (rop, op, z)
mpq_t * rop
mpq_t * op
mpz_t * z
PPCODE:
Rmpq_sub_z(rop, op, z);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_z_sub (rop, z, op)
mpq_t * rop
mpz_t * z
mpq_t * op
PPCODE:
Rmpq_z_sub(rop, z, op);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_mul_z (rop, op, z)
mpq_t * rop
mpq_t * op
mpz_t * z
PPCODE:
Rmpq_mul_z(rop, op, z);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_div_z (rop, op, z)
mpq_t * rop
mpq_t * op
mpz_t * z
PPCODE:
Rmpq_div_z(rop, op, z);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_z_div (rop, z, op)
mpq_t * rop
mpz_t * z
mpq_t * op
PPCODE:
Rmpq_z_div(rop, z, op);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpq_fits_uint_p (op)
void
Rmpq_pow_ui (rop, op, ui)
mpq_t * rop
mpq_t * op
unsigned long ui
PPCODE:
Rmpq_pow_ui(rop, op, ui);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_set_IV (a, my_iv1, my_iv2)
mpq_t * a
SV * my_iv1
SV * my_iv2
PPCODE:
Rmpq_set_IV(aTHX_ a, my_iv1, my_iv2);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpq_cmp_IV (q, iv1, iv2)
void
Rmpq_and (rop, a, b)
mpq_t * rop
mpq_t * a
mpq_t * b
PPCODE:
Rmpq_and(rop, a, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_ior (rop, a, b)
mpq_t * rop
mpq_t * a
mpq_t * b
PPCODE:
Rmpq_ior(rop, a, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_xor (rop, a, b)
mpq_t * rop
mpq_t * a
mpq_t * b
PPCODE:
Rmpq_xor(rop, a, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpq_com (rop, a)
mpq_t * rop
mpq_t * a
PPCODE:
Rmpq_com(rop, a);
XSRETURN_EMPTY; /* return empty stack */
SV *
_overload_add (a, b, third)
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 ()
Math-GMPz
view release on metacpan or search on metacpan
void
Rmpz_set_uj (copy, original)
mpz_t * copy
UV original
PPCODE:
Rmpz_set_uj(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_sj (copy, original)
mpz_t * copy
IV original
PPCODE:
Rmpz_set_sj(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_IV (copy, original)
mpz_t * copy
SV * original
PPCODE:
Rmpz_set_IV(aTHX_ copy, original);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpz_init_set_IV (p)
void
_mpf_set_dd (q, p)
mpf_t * q
SV * p
PPCODE:
_mpf_set_dd(q, p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_NV (copy, original)
mpz_t * copy
SV * original
PPCODE:
Rmpz_set_NV(aTHX_ copy, original);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpz_init_set_NV (p)
OUTPUT: RETVAL
void
DESTROY (p)
mpz_t * p
PPCODE:
DESTROY(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_clear (p)
mpz_t * p
PPCODE:
Rmpz_clear(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_clear_mpz (p)
mpz_t * p
PPCODE:
Rmpz_clear_mpz(p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_clear_ptr (p)
mpz_t * p
PPCODE:
Rmpz_clear_ptr(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_realloc2 (integer, bits)
mpz_t * integer
SV * bits
PPCODE:
Rmpz_realloc2(aTHX_ integer, bits);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set (copy, original)
mpz_t * copy
mpz_t * original
PPCODE:
Rmpz_set(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_q (copy, original)
mpz_t * copy
mpq_t * original
PPCODE:
Rmpz_set_q(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_f (copy, original)
mpz_t * copy
mpf_t * original
PPCODE:
Rmpz_set_f(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_si (copy, original)
mpz_t * copy
long original
PPCODE:
Rmpz_set_si(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_ui (copy, original)
mpz_t * copy
unsigned long original
PPCODE:
Rmpz_set_ui(copy, original);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_d (copy, d)
mpz_t * copy
double d
PPCODE:
Rmpz_set_d(copy, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_set_str (copy, original, base)
mpz_t * copy
SV * original
int base
PPCODE:
Rmpz_set_str(aTHX_ copy, original, base);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_swap (a, b)
mpz_t * a
mpz_t * b
PPCODE:
Rmpz_swap(a, b);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_get_ui (n)
mpz_t * n
void
Rmpz_get_d_2exp (n)
mpz_t * n
PPCODE:
PL_markstack_ptr++;
Rmpz_get_d_2exp(aTHX_ n);
return;
SV *
void
Rmpz_add (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_add(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_add_ui (dest, src, num)
mpz_t * dest
mpz_t * src
unsigned long num
PPCODE:
Rmpz_add_ui(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_sub (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_sub(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_sub_ui (dest, src, num)
mpz_t * dest
mpz_t * src
unsigned long num
PPCODE:
Rmpz_sub_ui(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_ui_sub (dest, num, src)
mpz_t * dest
unsigned long num
mpz_t * src
PPCODE:
Rmpz_ui_sub(dest, num, src);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mul (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_mul(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mul_si (dest, src, num)
mpz_t * dest
mpz_t * src
long num
PPCODE:
Rmpz_mul_si(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mul_ui (dest, src, num)
mpz_t * dest
mpz_t * src
unsigned long num
PPCODE:
Rmpz_mul_ui(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_addmul (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_addmul(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_addmul_ui (dest, src, num)
mpz_t * dest
mpz_t * src
unsigned long num
PPCODE:
Rmpz_addmul_ui(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_submul (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_submul(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_submul_ui (dest, src, num)
mpz_t * dest
mpz_t * src
unsigned long num
PPCODE:
Rmpz_submul_ui(dest, src, num);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mul_2exp (dest, src1, b)
mpz_t * dest
mpz_t * src1
SV * b
PPCODE:
Rmpz_mul_2exp(aTHX_ dest, src1, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_div_2exp (dest, src1, b)
mpz_t * dest
mpz_t * src1
SV * b
PPCODE:
Rmpz_div_2exp(aTHX_ dest, src1, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_neg (dest, src)
mpz_t * dest
mpz_t * src
PPCODE:
Rmpz_neg(dest, src);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_abs (dest, src)
mpz_t * dest
mpz_t * src
PPCODE:
Rmpz_abs(dest, src);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_cdiv_q (q, n, d)
mpz_t * q
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_cdiv_q(q, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_cdiv_r (mod, n, d)
mpz_t * mod
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_cdiv_r(mod, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_cdiv_qr (q, r, n, d)
mpz_t * q
mpz_t * r
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_cdiv_qr(q, r, n, d);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_cdiv_q_ui (q, n, d)
void
Rmpz_cdiv_q_2exp (q, n, b)
mpz_t * q
mpz_t * n
SV * b
PPCODE:
Rmpz_cdiv_q_2exp(aTHX_ q, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_cdiv_r_2exp (r, n, b)
mpz_t * r
mpz_t * n
SV * b
PPCODE:
Rmpz_cdiv_r_2exp(aTHX_ r, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fdiv_q (q, n, d)
mpz_t * q
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_fdiv_q(q, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_div (q, n, d)
mpz_t * q
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_div(q, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fdiv_r (mod, n, d)
mpz_t * mod
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_fdiv_r(mod, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fdiv_qr (q, r, n, d)
mpz_t * q
mpz_t * r
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_fdiv_qr(q, r, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_divmod (q, r, n, d)
mpz_t * q
mpz_t * r
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_divmod(q, r, n, d);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_fdiv_q_ui (q, n, d)
void
Rmpz_fdiv_q_2exp (q, n, b)
mpz_t * q
mpz_t * n
SV * b
PPCODE:
Rmpz_fdiv_q_2exp(aTHX_ q, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fdiv_r_2exp (r, n, b)
mpz_t * r
mpz_t * n
SV * b
PPCODE:
Rmpz_fdiv_r_2exp(aTHX_ r, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mod_2exp (r, n, b)
mpz_t * r
mpz_t * n
SV * b
PPCODE:
Rmpz_mod_2exp(aTHX_ r, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_tdiv_q (q, n, d)
mpz_t * q
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_tdiv_q(q, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_tdiv_r (mod, n, d)
mpz_t * mod
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_tdiv_r(mod, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_tdiv_qr (q, r, n, d)
mpz_t * q
mpz_t * r
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_tdiv_qr(q, r, n, d);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_tdiv_q_ui (q, n, d)
void
Rmpz_tdiv_q_2exp (q, n, b)
mpz_t * q
mpz_t * n
SV * b
PPCODE:
Rmpz_tdiv_q_2exp(aTHX_ q, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_tdiv_r_2exp (r, n, b)
mpz_t * r
mpz_t * n
SV * b
PPCODE:
Rmpz_tdiv_r_2exp(aTHX_ r, n, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mod (r, n, d)
mpz_t * r
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_mod(r, n, d);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_mod_ui (r, n, d)
void
Rmpz_divexact (dest, n, d)
mpz_t * dest
mpz_t * n
mpz_t * d
PPCODE:
Rmpz_divexact(dest, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_divexact_ui (dest, n, d)
mpz_t * dest
mpz_t * n
unsigned long d
PPCODE:
Rmpz_divexact_ui(dest, n, d);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpz_divisible_p (n, d)
Rmpz_powm (dest, base, exp, mod)
mpz_t * dest
mpz_t * base
mpz_t * exp
mpz_t * mod
PPCODE:
Rmpz_powm(dest, base, exp, mod);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_powm_ui (dest, base, exp, mod)
mpz_t * dest
mpz_t * base
unsigned long exp
mpz_t * mod
PPCODE:
Rmpz_powm_ui(dest, base, exp, mod);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_pow_ui (dest, base, exp)
mpz_t * dest
mpz_t * base
unsigned long exp
PPCODE:
Rmpz_pow_ui(dest, base, exp);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_ui_pow_ui (dest, base, exp)
mpz_t * dest
unsigned long base
unsigned long exp
PPCODE:
Rmpz_ui_pow_ui(dest, base, exp);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpz_root (r, n, d)
void
Rmpz_sqrt (r, n)
mpz_t * r
mpz_t * n
PPCODE:
Rmpz_sqrt(r, n);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_sqrtrem (root, rem, src)
mpz_t * root
mpz_t * rem
mpz_t * src
PPCODE:
Rmpz_sqrtrem(root, rem, src);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpz_perfect_power_p (in)
void
Rmpz_nextprime (prime, init)
mpz_t * prime
mpz_t * init
PPCODE:
Rmpz_nextprime(prime, init);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_prevprime (prime, init)
void
Rmpz_gcd (gcd, src1, src2)
mpz_t * gcd
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_gcd(gcd, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
unsigned long
Rmpz_gcd_ui (gcd, n, d)
mpz_t * g
mpz_t * s
mpz_t * t
mpz_t * a
mpz_t * b
PPCODE:
Rmpz_gcdext(g, s, t, a, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_lcm (lcm, src1, src2)
mpz_t * lcm
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_lcm(lcm, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_lcm_ui (lcm, src1, src2)
mpz_t * lcm
mpz_t * src1
unsigned long src2
PPCODE:
Rmpz_lcm_ui(lcm, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpz_invert (inv, src1, src2)
void
Rmpz_fac_ui (fac, b)
mpz_t * fac
unsigned long b
PPCODE:
Rmpz_fac_ui(fac, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_2fac_ui (fac, b)
mpz_t * fac
unsigned long b
PPCODE:
Rmpz_2fac_ui(fac, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_mfac_uiui (fac, b, c)
mpz_t * fac
unsigned long b
unsigned long c
PPCODE:
Rmpz_mfac_uiui(fac, b, c);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_primorial_ui (fac, b)
mpz_t * fac
unsigned long b
PPCODE:
Rmpz_primorial_ui(fac, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_bin_ui (dest, n, d)
mpz_t * dest
mpz_t * n
unsigned long d
PPCODE:
Rmpz_bin_ui(dest, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_bin_si (dest, n, d)
mpz_t * dest
mpz_t * n
long d
PPCODE:
Rmpz_bin_si(dest, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_bin_uiui (dest, n, d)
mpz_t * dest
unsigned long n
unsigned long d
PPCODE:
Rmpz_bin_uiui(dest, n, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fib_ui (dest, b)
mpz_t * dest
unsigned long b
PPCODE:
Rmpz_fib_ui(dest, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_fib2_ui (fn, fnsub1, b)
mpz_t * fn
mpz_t * fnsub1
unsigned long b
PPCODE:
Rmpz_fib2_ui(fn, fnsub1, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_lucnum_ui (dest, b)
mpz_t * dest
unsigned long b
PPCODE:
Rmpz_lucnum_ui(dest, b);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_lucnum2_ui (ln, lnsub1, b)
mpz_t * ln
mpz_t * lnsub1
unsigned long b
PPCODE:
Rmpz_lucnum2_ui(ln, lnsub1, b);
XSRETURN_EMPTY; /* return empty stack */
int
Rmpz_cmp (n, d)
void
Rmpz_and (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_and(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_ior (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_ior(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_xor (dest, src1, src2)
mpz_t * dest
mpz_t * src1
mpz_t * src2
PPCODE:
Rmpz_xor(dest, src1, src2);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_com (dest, src)
mpz_t * dest
mpz_t * src
PPCODE:
Rmpz_com(dest, src);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpz_popcount (in)
void
Rmpz_setbit (num, bit_index)
mpz_t * num
SV * bit_index
PPCODE:
Rmpz_setbit(aTHX_ num, bit_index);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_clrbit (num, bit_index)
mpz_t * num
SV * bit_index
PPCODE:
Rmpz_clrbit(aTHX_ num, bit_index);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpz_tstbit (num, bit_index)
SV * order
SV * size
SV * endian
SV * nails
SV * op
PPCODE:
Rmpz_import(aTHX_ rop, count, order, size, endian, nails, op);
XSRETURN_EMPTY; /* return empty stack */
SV *
Rmpz_export (order, size, endian, nails, op)
SV * order
SV * size
SV * endian
SV * nails
AV * op
PPCODE:
Rmpz_import_UV(aTHX_ rop, count, order, size, endian, nails, op);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_export_UV (order, size, endian, nails, op)
SV * order
SV * size
SV * endian
SV * nails
mpz_t * op
PPCODE:
PL_markstack_ptr++;
Rmpz_export_UV(aTHX_ order, size, endian, nails, op);
return;
int
void
Rsieve_gmp (x_arg, a, number)
int x_arg
int a
mpz_t * number
PPCODE:
PL_markstack_ptr++;
Rsieve_gmp(aTHX_ x_arg, a, number);
return;
SV *
OUTPUT: RETVAL
void
eratosthenes (x_arg)
SV * x_arg
PPCODE:
PL_markstack_ptr++;
eratosthenes(aTHX_ x_arg);
return;
SV *
Rmpz_rootrem (root, rem, u, d)
mpz_t * root
mpz_t * rem
mpz_t * u
unsigned long d
PPCODE:
Rmpz_rootrem(root, rem, u, d);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_combit (num, bitpos)
mpz_t * num
SV * bitpos
PPCODE:
Rmpz_combit(aTHX_ num, bitpos);
XSRETURN_EMPTY; /* return empty stack */
SV *
overload_mul (a, b, third)
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 *
_overload_mod_eq (a, b, third)
OUTPUT: RETVAL
void
Rmpz_urandomb (p, ...)
SV * p
PPCODE:
PL_markstack_ptr++;
Rmpz_urandomb(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_urandomm (x, ...)
SV * x
PPCODE:
PL_markstack_ptr++;
Rmpz_urandomm(aTHX_ x);
XSRETURN_EMPTY; /* return empty stack */
void
Rmpz_rrandomb (x, ...)
SV * x
PPCODE:
PL_markstack_ptr++;
Rmpz_rrandomb(aTHX_ x);
XSRETURN_EMPTY; /* return empty stack */
SV *
OUTPUT: RETVAL
void
rand_clear (p)
SV * p
PPCODE:
rand_clear(aTHX_ p);
XSRETURN_EMPTY; /* return empty stack */
int
_has_longlong ()
Rmpz_powm_sec (dest, base, exp, mod)
mpz_t * dest
mpz_t * base
mpz_t * exp
mpz_t * mod
PPCODE:
Rmpz_powm_sec(dest, base, exp, mod);
XSRETURN_EMPTY; /* return empty stack */
int
_using_mpir ()
mpz_t * outref
mpz_t * p
mpz_t * q
mpz_t * seed
unsigned long bits_required
PPCODE:
Rprbg_ms(aTHX_ outref, p, q, seed, bits_required);
XSRETURN_EMPTY; /* return empty stack */
void
Rprbg_bbs (outref, p, q, seed, bits_required)
mpz_t * outref
mpz_t * p
mpz_t * q
mpz_t * seed
unsigned long bits_required
PPCODE:
Rprbg_bbs(aTHX_ outref, p, q, seed, bits_required);
XSRETURN_EMPTY; /* return empty stack */
int
Rmonobit (bitstream)
void
autocorrelation (bitstream, offset)
mpz_t * bitstream
int offset
PPCODE:
PL_markstack_ptr++;
autocorrelation(aTHX_ bitstream, offset);
return;
int
void
_dump_mbi_gmp (b)
SV * b
PPCODE:
_dump_mbi_gmp(aTHX_ b);
XSRETURN_EMPTY; /* return empty stack */
int
_SvIOK (sv)
Math-Geometry-Planar-GPC-PolygonXS
view release on metacpan or search on metacpan
PolygonXS.xs view on Meta::CPAN
SV* obj
INIT:
int c;
gpc_polygon* p;
PPCODE:
p = (gpc_polygon*) SvIV(SvRV(obj));
PUSHMARK(SP);
if(p->num_contours < 1) {
PUTBACK;
return;
Math-Histogram
view release on metacpan or search on metacpan
void
mh_axis_t::_as_hash()
PREINIT:
SV *rv;
PPCODE:
rv = sv_2mortal(axis_to_hashref(aTHX_ THIS));
XPUSHs(rv);
XSRETURN(1);
Math-LongDouble
view release on metacpan or search on metacpan
LongDouble.xs view on Meta::CPAN
_print_bytes (p, n)
void * p
int n
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_print_bytes(p, n);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
ld_set_prec (x)
int x
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ld_set_prec(aTHX_ x);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
_nnum_inc (p)
char * p
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_nnum_inc(p);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
LDtoSTR (ld)
SV * ld
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
LDtoSTR(aTHX_ ld);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
LDtoSTRP (ld, decimal_prec)
SV * ld
int decimal_prec
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
LDtoSTRP(aTHX_ ld, decimal_prec);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
SV * a
SV * b
SV * third
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
broken_overload_add_eq(aTHX_ a, b, third);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
DESTROY (rop)
SV * rop
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DESTROY(aTHX_ rop);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
SV * a
SV * b
SV * third
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_overload_inc(aTHX_ a, b, third);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
SV * a
SV * b
SV * third
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_overload_dec(aTHX_ a, b, third);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
acos_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
acos_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
acosh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
acosh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
asin_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
asin_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
asinh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
asinh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
atan_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atan_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
atanh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atanh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atan2_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
cbrt_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cbrt_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ceil_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ceil_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
copysign_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
cosh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cosh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
cos_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cos_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
erf_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
erf_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
erfc_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
erfc_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
exp_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
exp_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
expm1_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
expm1_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
fabs_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fabs_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fdim_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
floor_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
floor_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * op1
ldbl * op2
ldbl * op3
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fma_LD(rop, op1, op2, op3);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmax_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmin_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmod_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
hypot_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * frac
SV * exp
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
frexp_LD(aTHX_ frac, exp, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op
int pow
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ldexp_LD(rop, op, pow);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
lgamma_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
lgamma_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
log_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
log10_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log10_LD(aTHX_ rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
log2_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log2_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
log1p_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log1p_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * integer
ldbl * frac
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
modf_LD(integer, frac, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
nan_LD (rop, op)
ldbl * rop
SV * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nan_LD(aTHX_ rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
nearbyint_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nearbyint_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nextafter_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
pow_LD(aTHX_ rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
remainder_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
SV * rop2
ldbl * op1
ldbl * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
remquo_LD(aTHX_ rop1, rop2, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
rint_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
rint_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
round_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
round_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
long op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
scalbln_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * rop
ldbl * op1
int op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
scalbn_LD(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
ldbl * sin
ldbl * cos
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sincos_LD(sin, cos, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
sinh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sinh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
sin_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sin_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
sqrt_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sqrt_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
tan_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tan_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
tanh_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tanh_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
tgamma_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tgamma_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
trunc_LD (rop, op)
ldbl * rop
ldbl * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
trunc_LD(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
clear_nnum ()
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
clear_nnum();
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
LongDouble.xs view on Meta::CPAN
void
set_nnum (x)
int x
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
set_nnum(x);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-MPC
view release on metacpan or search on metacpan
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)
OUTPUT: RETVAL
void
Rmpc_get_prec2 (x)
mpc_t * x
PPCODE:
PL_markstack_ptr++;
Rmpc_get_prec2(aTHX_ x);
return;
SV *
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)
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)
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 *
_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 *
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)
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)
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)
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)
Math-MPFI
view release on metacpan or search on metacpan
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 ()
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)
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)
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
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)
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)
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)
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)
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)
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 ()
Math-MPFR
view release on metacpan or search on metacpan
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 ()
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 *
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 ()
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)
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
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)
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)
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)
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)
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)
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)
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)
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 ()
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)
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
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)
OUTPUT: RETVAL
void
Rmpfr_dump (a)
mpfr_t * a
PPCODE:
Rmpfr_dump(a);
XSRETURN_EMPTY; /* return empty stack */
SV *
gmp_v ()
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 ()
void
Rmpfr_clear_erangeflag ()
PPCODE:
Rmpfr_clear_erangeflag();
XSRETURN_EMPTY; /* return empty stack */
int
Rmpfr_erangeflag_p ()
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 *
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)
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 *
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)
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)
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)
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 ()
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)
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 ()
OUTPUT: RETVAL
void
_mp_sizes ()
PPCODE:
PL_markstack_ptr++;
_mp_sizes();
return;
SV *
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)
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 *
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 ()
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)
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
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)
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)
OUTPUT: RETVAL
void
set_fallback_flag ()
PPCODE:
PL_markstack_ptr++;
set_fallback_flag(aTHX);
XSRETURN_EMPTY; /* return empty stack */
SV *
OUTPUT: RETVAL
void
decimalize (a, ...)
SV * a
PPCODE:
PL_markstack_ptr++;
decimalize(aTHX_ a);
return;
int
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 *
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)
Math-Matlab-Engine
view release on metacpan or search on metacpan
AV *
engGetArrayList(ep, name)
Engine * ep
const char * name
PPCODE:
{
mxArray *matrix;
int nrdim, *dims, i, nelem;
double *vals;
Math-NLopt
view release on metacpan or search on metacpan
lib/Math/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Math-NV
view release on metacpan or search on metacpan
void
nv (str)
SV * str
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nv(aTHX_ str);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
_ld2binary (ld)
SV * ld
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_ld2binary(aTHX_ ld);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
_ld_str2binary (ld)
char * ld
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_ld_str2binary(aTHX_ ld);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Cprintf (fmt, nv)
char * fmt
SV * nv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
Cprintf(aTHX_ fmt, nv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
char * fmt
SV * nv
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
Csprintf(aTHX_ fmt, nv, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Pari
view release on metacpan or search on metacpan
# Tag is menu entry, or -1 for all.
void
_listPari(tag)
int tag
PPCODE:
{
long valence;
entree *ep, *table = functions_basic;
int i=-1;
#endif
}
void
memUsage()
PPCODE:
#ifdef DEBUG_PARI
EXTEND(sp, 4); /* Got cv + 0, - but on newer Perls, this does not count. Return 4. */
PUSHs(sv_2mortal(newSViv(SVnumtotal)));
PUSHs(sv_2mortal(newSViv(SVnum)));
PUSHs(sv_2mortal(newSViv(onStack)));
#endif
void
dumpStack()
PPCODE:
long i = 0, ssize, oursize = 0;
SV *ret, *sv1, *nextsv;
const char *pref = "";
switch(GIMME_V) {
}
}
void
__dumpStack()
PPCODE:
GEN x = (GEN)avma; /* If this works, it is accidental only: it assumes the entry point to “the region on stack” is at its smallest address. */
long ssize, i = 0;
SV* ret;
switch(GIMME_V) {
XPUSHs(sv_2mortal(pari_print(x)));
}
void
dumpHeap()
PPCODE:
heap_dumper_t hd;
int context = GIMME_V, m;
SV* ret = Nullsv; /* Avoid unit warning */
Math-Preference-SVD
view release on metacpan or search on metacpan
int movieId
int count
int sum
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
set_Movies(movieId, count, sum);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
int movieId
int custId
int rating
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
set_Ratings(movieId, custId, rating);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
int x_num_customers
int x_num_ratings
int x_num_movies
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
Engine(x_num_customers, x_num_ratings, x_num_movies);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
DestroyEngine ()
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DestroyEngine();
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
CalcMetrics ()
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
CalcMetrics();
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
CalcFeatures ()
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
CalcFeatures();
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Prime-Util-GMP
view release on metacpan or search on metacpan
void _GMP_destroy()
void _GMP_memfree()
void _GMP_set_verbose(IN int v)
PPCODE:
set_verbose_level(v);
void seed_csprng(IN UV bytes, IN unsigned char* seed)
PPCODE:
isaac_init(bytes, seed);
UV irand()
ALIAS:
irand64 = 1
void
_is_provable_prime(IN char* strn, IN int wantproof = 0)
PREINIT:
int result;
mpz_t n;
PPCODE:
PRIMALITY_START("is_provable_prime", 2, 1);
if (wantproof == 0) {
result = _GMP_is_provable_prime(n, 0);
XPUSH_INT(result);
} else {
ALIAS:
prev_prime = 1
next_twin_prime = 2
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (ix == 1 && mpz_cmp_ui(n,3) < 0) { mpz_clear(n); XSRETURN_UNDEF; }
if (ix == 0) _GMP_next_prime(n);
else if (ix == 1) _GMP_prev_prime(n);
else next_twin_prime(n, n);
void
random_prime(IN char* strlo, IN char* strhi = 0)
PREINIT:
mpz_t lo, hi, res;
int retundef;
PPCODE:
if (items == 1) {
validate_and_set(lo, IFLAG_NONNEG);
mpz_init_set(hi, lo);
mpz_set_ui(lo,0);
} else {
void
urandomr(IN char* strlo, IN char* strhi)
PREINIT:
mpz_t lo, hi, res;
PPCODE:
validate_and_set(lo, IFLAG_ANY);
validate_and_set(hi, IFLAG_ANY);
if (mpz_cmp(lo,hi) > 0) {
mpz_clear(lo); mpz_clear(hi);
XSRETURN_UNDEF;
ALIAS:
prime_power_count = 1
perfect_power_count = 2
PREINIT:
mpz_t lo, hi, res;
PPCODE:
mpz_init(res);
if (items == 1) {
validate_and_set(lo, IFLAG_NONNEG);
switch (ix) {
case 0: prime_count(res, lo); break;
mpz_clear(res);
void legendre_phi(IN char* strn, IN char* stra)
PREINIT:
mpz_t n, a, res;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
validate_and_set(a, IFLAG_NONNEG);
mpz_init(res);
legendre_phi(res, n, a);
XPUSH_MPZ(res);
void nth_perfect_power(IN char* strn)
ALIAS:
nth_perfect_power_approx = 1
PREINIT:
mpz_t n, res;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
mpz_init(res);
if (ix == 0) nth_perfect_power(res, n);
else nth_perfect_power_approx(res, n);
XPUSH_MPZ(res);
void next_perfect_power(IN char* strn)
ALIAS:
prev_perfect_power = 1
PREINIT:
mpz_t n, res;
PPCODE:
validate_and_set(n, IFLAG_ANY);
mpz_init(res);
if (ix == 0) next_perfect_power(res, n);
else prev_perfect_power(res, n);
XPUSH_MPZ(res);
sqrtint = 3
prime_count_lower = 4
prime_count_upper = 5
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
switch (ix) {
case 0: totient(n, n); break;
case 1: carmichael_lambda(n, n); break;
case 2: rtau(n, n); break;
mpz_clear(n);
void absint(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_ABS);
XPUSH_MPZ(n);
mpz_clear(n);
void urandomm(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
mpz_isaac_urandomm(n, n);
XPUSH_MPZ(n);
mpz_clear(n);
void is_prime_power(IN char* strn)
PREINIT:
mpz_t n;
UV R;
PPCODE:
validate_and_set(n, IFLAG_ANY);
R = (mpz_sgn(n) <= 0) ? 0 : prime_power(n, n);
mpz_clear(n);
XSRETURN_UV(R);
void signint(IN char* strn)
PREINIT:
mpz_t n;
int res;
PPCODE:
validate_and_set(n, IFLAG_ANY);
res = mpz_sgn(n);
mpz_clear(n);
XSRETURN_IV(res);
ALIAS:
cmpabsint = 1
PREINIT:
mpz_t a, b;
int res;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
res = (ix == 0) ? mpz_cmp(a, b) : mpz_cmpabs(a, b);
/* GMP 6.2 changed to only return -1,0,1 */
/* Enforce -1, 0, 1 as our only return values. */
notbit = 2
tstbit = 3
PREINIT:
mpz_t n;
int res;
PPCODE:
validate_and_set(n, IFLAG_ANY);
switch (ix) {
case 0: mpz_setbit(n, k); break;
case 1: mpz_clrbit(n, k); break;
case 2: mpz_combit(n, k); break;
ALIAS:
bitor = 1
bitxor = 2
PREINIT:
mpz_t a, b;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
switch (ix) {
case 0: mpz_and(a, a, b); break;
case 1: mpz_ior(a, a, b); break;
add1int = 2
sub1int = 3
exp_mangoldt = 4
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_ANY);
switch (ix) {
case 0: mpz_com(n, n); break;
case 1: mpz_neg(n, n); break;
case 2: mpz_add_ui(n, n, 1); break;
void bernfrac(IN char* strn)
ALIAS:
harmfrac = 1
PREINIT:
mpz_t n, d;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
mpz_init(d);
if (ix == 0) bernfrac(n,d,n);
else harmfrac(n,d,n);
XPUSH_MPZ(n);
surround_primes = 9
PREINIT:
mpz_t n;
mpf_t f;
char* res;
PPCODE:
if (ix == 9) { /* surround_primes */
UV prev, next;
validate_and_set(n, IFLAG_NONNEG);
next = 1 + (mpz_sgn(n)==0);
if (mpz_cmp_ui(n,2) > 0) {
divreal = 6
PREINIT:
mpf_t n, x;
char* res;
unsigned long bits, bits2, bits3;
PPCODE:
bits = 64 + (unsigned long)(3.32193 * prec);
bits2 = 64 + (unsigned long)(3.32193 * strlen(strn));
bits3 = 64 + (unsigned long)(3.32193 * strlen(strx));
if (bits2 > bits) bits = bits2;
if (bits3 > bits) bits = bits3;
void bernvec(IN UV n)
PREINIT:
const mpz_t *N, *D;
UV i;
PPCODE:
bernvec(&N, &D, n); /* Cached array, do not destroy */
if (GIMME_V != G_VOID) {
EXTEND(SP, (long)(n+1));
for (i = 0; i <= n; i++) {
AV* av = newAV();
vecsum = 2
vecprod = 3
PREINIT:
int i, negflag;
mpz_t ret, n;
PPCODE:
if (items == 0) XSRETURN_IV( (ix == 1 || ix == 3) ? 1 : 0);
negflag = (ix <= 1) ? IFLAG_ABS : IFLAG_ANY;
if (ix == 1 || ix == 3) {
mpz_t* list;
New(0, list, items, mpz_t);
SV *sv;
SV **svp;
int plen;
size_t i, len;
mpz_t sum, n;
PPCODE:
av = 0;
plen = -1;
if (items > 0 && SvROK(ST(0)) && SvTYPE(SvRV(ST(0))) == SVt_PVAV) {
if (items != 1)
croak("vecprefixsum: expected integer list or single array reference");
void remove_factors(IN char* strn, IN char* strk)
ALIAS:
remove_factors_exp = 1
PREINIT:
mpz_t n, k;
PPCODE:
validate_and_set(n, IFLAG_ANY);
validate_and_set(k, IFLAG_NONNEG);
if (mpz_cmp_ui(k,2) < 0) {
mpz_clear(k); mpz_clear(n);
croak("%s: k must be > 1", SUBNAME);
mpz_clear(n);
void moebius(IN char* strn, IN char* strnhi = 0)
PREINIT:
mpz_t n, nhi;
PPCODE:
validate_and_set(n, IFLAG_ANY);
if (items == 1) {
XPUSH_INT(moebius(n));
} else {
validate_and_set(nhi, IFLAG_ANY);
mpz_clear(n);
void euler_phi(IN char* strn, IN char* strnhi = 0)
PREINIT:
mpz_t n, nhi, r;
PPCODE:
validate_and_set(n, IFLAG_ANY);
if (items == 1) {
totient(n, n);
XPUSH_MPZ(n);
} else {
ALIAS:
lucasv = 1
lucasuv = 2
PREINIT:
mpz_t u, v, p, q, k;
PPCODE:
validate_and_set(p, IFLAG_ANY);
validate_and_set(q, IFLAG_ANY);
validate_and_set(k, IFLAG_NONNEG);
mpz_init(u); mpz_init(v);
lucasuv(u, v, p, q, k);
ALIAS:
lucasvmod = 1
lucasuvmod = 2
PREINIT:
mpz_t u, v, t, p, q, k, n;
PPCODE:
validate_and_set(p, IFLAG_ANY);
validate_and_set(q, IFLAG_ANY);
validate_and_set(k, IFLAG_NONNEG);
validate_and_set(n, IFLAG_ABS);
if (mpz_cmpabs_ui(n,1) <= 0) {
void catalan_number(IN char* strn)
PREINIT:
mpz_t n;
unsigned long un;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (!mpz_fits_ulong_p(n))
croak("catalan_number: argument too large");
un = mpz_get_ui(n);
if (un <= 1) {
mpz_clear(n);
void bell_number(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (!mpz_fits_ulong_p(n))
croak("bell_number: argument too large");
bell_number(n, mpz_get_ui(n));
XPUSH_MPZ(n);
mpz_clear(n);
void fubini(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (!mpz_fits_ulong_p(n))
croak("fubini: argument too large");
fubini(n, mpz_get_ui(n));
XPUSH_MPZ(n);
lucas_number = 1
PREINIT:
mpz_t k;
unsigned long uk;
int isneg;
PPCODE:
isneg = validate_and_set(k, IFLAG_ABS);
if (!mpz_fits_ulong_p(k))
croak("%s: argument too large", GvNAME(CvGV(cv)));
uk = mpz_get_ui(k);
if (ix == 0) {
dedekind_psi = 2
aliquot_sum = 3
abundance = 4
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, ix == 2 ? IFLAG_ANY : IFLAG_NONNEG);
switch (ix) {
case 0: sopf(n, n); break;
case 1: sopfr(n, n); break;
case 2: dedekind_psi(n, n); break;
prime_signature(IN char* strn)
PREINIT:
mpz_t n, r;
uint32_t *signature;
int i, nsig;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (GIMME_V == G_ARRAY) {
nsig = prime_signature(0, &signature, n);
EXTEND(SP, nsig);
for (i = 0; i < nsig; i++)
prev_powerfree = 1
nth_powerfree = 2
PREINIT:
mpz_t n;
int retundef;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
switch (ix) {
case 0: next_powerfree(n,n,k); break;
case 1: prev_powerfree(n,n,k); break;
case 2: nth_powerfree(n,n,k); break;
tdivrem = 8
fdivrem = 9
cdivrem = 10
PREINIT:
mpz_t a, b;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
if (ix >= 4 && mpz_sgn(b) == 0)
croak("%s: divide by zero", SUBNAME);
switch (ix) {
mpz_clear(b); mpz_clear(a);
void rootint(IN char* strn, IN char* strk)
PREINIT:
mpz_t n, k;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
validate_and_set(k, IFLAG_POS);
mpz_rootint(n, n, k);
XPUSH_MPZ(n);
mpz_clear(n); mpz_clear(k);
void logint(IN char* strn, IN char* strb)
PREINIT:
mpz_t n, b;
PPCODE:
validate_and_set(n, IFLAG_POS);
validate_and_set(b, IFLAG_POS);
if (mpz_cmp_ui(b,2) < 0) croak("logint: base must be at least 2");
mpz_logint(n, n, b);
XPUSH_MPZ(n);
is_qr = 5
is_primitive_root = 6
PREINIT:
mpz_t a, n;
int retundef;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
if (mpz_sgn(n) == 0) {
mpz_clear(n); mpz_clear(a);
XSRETURN_UNDEF;
mpz_clear(n); mpz_clear(a);
void znprimroot(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_ABS);
znprimroot(n, n);
if (mpz_sgn(n) < 0)
{ mpz_clear(n); XSRETURN_UNDEF; }
XPUSH_MPZ(n);
void znlog(IN char* stra, IN char* strg, IN char* strn)
PREINIT:
mpz_t a, g, n, r;
int ok;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(g, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
mpz_init(r);
ok = _GMP_znlog(r, a, g, n);
if (!ok) XSRETURN_UNDEF;
void multifactorial(IN char* strn, IN char* strm)
PREINIT:
mpz_t n, m;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
validate_and_set(m, IFLAG_POS);
mpz_mfac(n, n, m);
XPUSH_MPZ(n);
mpz_clear(m); mpz_clear(n);
void is_polygonal(IN char* stra, IN char* strb)
ALIAS:
polygonal_nth = 1
PREINIT:
mpz_t a, b;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_NONNEG);
if (mpz_cmp_ui(b,3) < 0) croak("%s: k must be >= 3",SUBNAME);
polygonal_nth(a, a, b);
if (ix == 0) {
void binomial(IN char* stra, IN char* strb)
PREINIT:
mpz_t a, b;
unsigned long n, k;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
if (mpz_sgn(a) >= 0) {
int reflect = 0;
if (mpz_sgn(b) < 0 || mpz_cmp(b,a) > 0)
mpz_clear(b); mpz_clear(a);
void gcdext(IN char* stra, IN char* strb)
PREINIT:
mpz_t a, b, t;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
mpz_init(t);
if (mpz_sgn(a) == 0 && mpz_sgn(b) == 0) {
mpz_set_ui(t, 0); /* This changed in GMP 5.1.2. Enforce new result. */
mulsubint = 1
addmulint = 2
submulint = 3
PREINIT:
mpz_t a, b, c;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
validate_and_set(c, IFLAG_ANY);
if (ix == 0) { mpz_mul(a, a, b); mpz_add(a, a, c); } /* a * b + c */
else if (ix == 1) { mpz_mul(a, a, b); mpz_sub(a, a, c); } /* a * b - c */
void
binomialmod(IN char* strn, IN char* strk, IN char* strm)
PREINIT:
mpz_t n, k, m;
PPCODE:
validate_and_set(n, IFLAG_ANY);
validate_and_set(k, IFLAG_ANY);
validate_and_set(m, IFLAG_ABS);
if (mpz_sgn(m) == 0) {
mpz_clear(n); mpz_clear(k); mpz_clear(m);
falling_factorial(IN char* strx, IN char* strn)
ALIAS:
rising_factorial = 1
PREINIT:
mpz_t x, n, r;
PPCODE:
validate_and_set(x, IFLAG_ANY);
validate_and_set(n, IFLAG_NONNEG);
mpz_init(r);
if (ix == 0) falling_factorial(r, x, n);
else rising_factorial(r, x, n);
ALIAS:
faulhaber_sum = 1
jordan_totient = 2
PREINIT:
mpz_t a, b;
PPCODE:
validate_and_set(a, IFLAG_NONNEG);
validate_and_set(b, IFLAG_NONNEG);
if (ix == 0 || ix == 1) {
if (!mpz_fits_ulong_p(b)) croak("%s: power too large", SUBNAME);
faulhaber_sum(a, a, mpz_get_ui(b));
rshiftint = 1
rashiftint = 2
PREINIT:
mpz_t n;
int nix;
PPCODE:
validate_and_set(n, IFLAG_ANY);
nix = ix;
if (k < 0) {
k = -k;
nix = !nix; /* left => right, right or arith_right => left */
powerful_count(IN char* strn, IN int k = 2)
ALIAS:
powerfree_count = 1
PREINIT:
mpz_t n, r;
PPCODE:
validate_and_set(n, IFLAG_ANY);
mpz_init(r);
switch (ix) {
case 0: powerful_count(r, n, (unsigned long) k); break;
case 1: powerfree_count(r, n, (uint32_t) k); break;
divmod = 4
rootmod = 5
PREINIT:
mpz_t a, b, n;
int retundef;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
retundef = (mpz_sgn(n) <= 0);
if (!retundef && ix == 4) {
void allsqrtmod(IN char* stra, IN char* strn)
PREINIT:
mpz_t a, n;
mpz_t *roots;
UV i, nroots;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
if (mpz_sgn(n) == 0) {
mpz_clear(n); mpz_clear(a);
if (GIMME_V == G_ARRAY) XSRETURN_EMPTY;
void allrootmod(IN char* stra, IN char* strk, IN char* strn)
PREINIT:
mpz_t a, k, n;
mpz_t *roots;
UV i, nroots;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(k, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
if (mpz_sgn(n) == 0) {
mpz_clear(n); mpz_clear(k); mpz_clear(a);
void muladdmod(IN char* stra, IN char* strb, IN char* strc, IN char* strn)
ALIAS:
mulsubmod = 1
PREINIT:
mpz_t a, b, c, n;
PPCODE:
validate_and_set(a, IFLAG_ANY);
validate_and_set(b, IFLAG_ANY);
validate_and_set(c, IFLAG_ANY);
validate_and_set(n, IFLAG_ABS);
if (mpz_sgn(n) <= 0) {
ALIAS:
Euler = 1
random_bytes = 2
PREINIT:
UV prec;
PPCODE:
if (ix == 2) { /* random_bytes */
char* sptr;
SV* sv = newSV(n == 0 ? 1 : n);
SvPOK_only(sv);
SvCUR_set(sv, n);
consecutive_integer_lcm = 16
PREINIT:
mpz_t p, N;
UV n;
char* proof;
PPCODE:
validate_and_set(N, IFLAG_NONNEG);
if (!mpz_fits_uv_p(N))
{ mpz_clear(N); croak("%s: argument too large",SUBNAME); }
n = mpz_get_uv(N);
mpz_clear(N);
void
stirling(IN char* strn, IN char* strm, IN char* strtype = 0)
PREINIT:
mpz_t n, m, type;
int stype = 1;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
validate_and_set(m, IFLAG_NONNEG);
if (items > 2) {
validate_and_set(type, IFLAG_ANY);
stype = mpz_fits_sint_p(type) ? (int)mpz_get_si(type) : 0;
PROTOTYPE: @
PREINIT:
int i, doretval;
mpz_t* an;
mpz_t ret, lcm;
PPCODE:
if (items == 0) {
if (ix == 0) XSRETURN_IV(0);
XPUSH_UINT(0);
XPUSH_UINT(0);
XSRETURN(2);
AV *av;
char* seen;
UV val, *V;
int plen, n, i, j, k;
mpz_t f, t, num;
PPCODE:
if ((!SvROK(svp)) || (SvTYPE(SvRV(svp)) != SVt_PVAV))
croak("permtonum argument must be an array reference");
av = (AV*) SvRV(svp);
plen = av_len(av);
if (plen < 0) XSRETURN_IV(0);
void numtoperm(IN UV n, IN char* strk)
PREINIT:
mpz_t k, f, p;
UV i, j, tv, *perm;
PPCODE:
if (n == 0)
XSRETURN_EMPTY;
validate_and_set(k, IFLAG_ANY);
mpz_init(f); mpz_init(p);
New(0, perm, n, UV);
sieve_primes = 1
sieve_twin_primes = 2
PREINIT:
mpz_t low, seghigh, high, t;
UV i, nc, nprimes, maxseg, *list;
PPCODE:
validate_and_set(low, IFLAG_NONNEG);
validate_and_set(high, IFLAG_NONNEG);
mpz_init(seghigh);
mpz_init_set_ui(t,0);
twin_primes = 1
PREINIT:
AV* av;
mpz_t low, seghigh, high, t;
UV i, nprimes, maxseg, *list;
PPCODE:
if (!SvOK(svlo) || (items >= 2 && !SvOK(svhi)))
croak("Parameter must be defined");
if (items == 1) {
set_integer_string(high, "hi", SvPV_nolen(svlo), IFLAG_NONNEG);
void
sieve_range(IN char* strlow, IN char* strwidth, IN char* strdepth)
PREINIT:
mpz_t low, width, depth, high, seghigh;
UV udepth, uwidth, i, nprimes, *list, offset = 0;
PPCODE:
validate_and_set(low, IFLAG_NONNEG);
validate_and_set(width, IFLAG_NONNEG);
validate_and_set(depth, IFLAG_NONNEG);
if (mpz_sgn(width) == 0) {
void
lucas_sequence(IN char* strn, IN char* strP, IN char* strQ, IN char* strk)
PREINIT:
mpz_t U, V, Qk, n, P, Q, k, t;
PPCODE:
validate_and_set(n, IFLAG_POS);
validate_and_set(P, IFLAG_ANY);
validate_and_set(Q, IFLAG_ANY);
validate_and_set(k, IFLAG_NONNEG);
mpz_init(U); mpz_init(V); mpz_init(Qk); mpz_init(t);
mpz_t n, t;
UV arg1, arg2, uf;
static const UV default_arg1[] =
{0, 64000000,64000000,5000000,5000000,0,256000000,100000000,0, 0 };
/*Trial,Rho, Brent, P-1, P+1, Cheb, HOLF, SQUFOF, ECM,QS */
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
{
int cmpr = mpz_cmp_ui(n,1);
if (cmpr <= 0) {
mpz_clear(n);
PREINIT:
mpz_t n;
mpz_t* factors;
int* exponents;
int nfactors, i, j, isneg;
PPCODE:
isneg = validate_and_set(n, IFLAG_ABS);
if (GIMME_V != G_VOID) {
nfactors = factor(n, &factors, &exponents);
if (GIMME_V == G_SCALAR) {
for (i = 0, j = 0; i < nfactors; i++)
void divisors(IN char* strn, IN char* strk = 0)
PREINIT:
mpz_t n, k;
mpz_t* divs;
int ndivisors, i;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
if (strk == 0) {
mpz_init_set(k, n);
} else {
validate_and_set(k, IFLAG_NONNEG);
void
sigma(IN char* strn, IN UV k = 1)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set(n, IFLAG_NONNEG);
sigma(n, n, k);
XPUSH_MPZ(n);
mpz_clear(n);
void
todigits(IN char* strn, unsigned int base=10, int length=-1)
PREINIT:
mpz_t n;
uint32_t d, *digits;
PPCODE:
if (base < 2 || base > 0xFFFFFFFFU) croak("invalid base: %u\n", base);
validate_integer_string("n", strn, IFLAG_ANY);
if (strn[0] == '-' || strn[0] == '+') strn++;
if (base == 10) {
uint32_t l = strlen(strn);
AV *av;
const char *ds;
int i, plen;
size_t j, len;
mpz_t n, base, *digits;
PPCODE:
if (!SvOK(svp)) croak("Parameter must be defined");
if (items > 1 && SvOK(svbase)) {
set_integer_string(base, "base", SvPV_nolen(svbase), IFLAG_NONNEG);
} else {
mpz_init_set_ui(base, 10);
Math-Prime-Util
view release on metacpan or search on metacpan
void
CLONE(...)
PREINIT:
int i;
SV* bigintclass;
PPCODE:
{
MY_CXT_CLONE; /* possible declaration */
MY_CXT.MPUroot = gv_stashpv("Math::Prime::Util", TRUE);
MY_CXT.MPUGMP = gv_stashpv("Math::Prime::Util::GMP", TRUE);
MY_CXT.MPUPP = gv_stashpv("Math::Prime::Util::PP", TRUE);
void
END(...)
PREINIT:
dMY_CXT;
int i;
PPCODE:
_prime_memfreeall();
MY_CXT.MPUroot = NULL;
MY_CXT.MPUGMP = NULL;
MY_CXT.MPUPP = NULL;
for (i = 0; i <= CINTS; i++) {
STRLEN size;
unsigned char* data;
unsigned char gmpseed[64];
volatile unsigned char* p;
uint32_t size32, n, i;
PPCODE:
if (items == 0 || !SvOK(seed)) {
csprng_init_seed(MY_CXT.randcxt);
if (_XS_get_callgmp() >= 42) {
n = (uint32_t) sizeof(gmpseed);
if (get_entropy_bytes(n, gmpseed) != n)
ALIAS:
irand32 = 1
irand64 = 2
PREINIT:
dMY_CXT;
PPCODE:
if (ix == 0 || ix == 1) {
XSRETURN_UV( irand32(MY_CXT.randcxt) );
} else {
#if BITS_PER_WORD == 64
XSRETURN_UV( irand64(MY_CXT.randcxt) );
ALIAS:
entropy_bytes = 1
PREINIT:
int nstatus;
UV n;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (nstatus != 1 || n > MAX_RANDOM_BYTES)
croak("%s: input must be an integer between 0 and %"UVuf, SUBNAME, MAX_RANDOM_BYTES);
if (n == 0)
RETURN_SV(sv_2mortal(newSVpvs("")));
RETVAL = xs_validate_integer_inplace(aTHX_ svn, mask);
OUTPUT:
RETVAL
void _canonicalized_integer(SV* svn)
PPCODE:
RETURN_SV(xs_to_canonical(aTHX_ svn));
void _canonicalize_integers(SV* svr)
PREINIT:
SV *target, *out;
PPCODE:
if (!SvROK(svr))
croak("_canonicalize_integers: expected scalar or array reference");
target = SvRV(svr);
if (SvTYPE(target) == SVt_PVAV) {
xs_aref_to_canonical(aTHX_ svr, "_canonicalize_integers");
XSRETURN(0);
void prime_memfree()
PREINIT:
dMY_CXT;
PPCODE:
prime_memfree();
/* (void) _vcallgmpsubn(aTHX_ G_VOID|G_DISCARD, "_GMP_memfree", 0, 49); */
if (MY_CXT.MPUPP != NULL) DISPATCHPP_RETURN_VOID();
XSRETURN(0);
void prime_precalc(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) != 1)
croak("prime_precalc: n must fit in native unsigned integer");
prime_precalc(n);
XSRETURN(0);
_XS_set_callgmp = 1
_XS_set_nobigint = 2
_end_for_loop = 3
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) != 1)
croak("%s: n must fit in native unsigned integer", SUBNAME);
switch (ix) {
case 0: _XS_set_verbose(n); break;
case 1: _XS_set_callgmp(n); break;
perfect_power_count = 4
prime_power_count = 5
lucky_count = 6
PREINIT:
UV lo = 0, hi, count = 0;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
if (lo <= hi) {
switch (ix) {
case 0: count = prime_count_range(lo, hi); break;
lucky_count_upper = 14
lucky_count_lower = 15
lucky_count_approx = 16
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
switch (ix) {
case 0: ret = prime_count_upper(n); break;
case 1: ret = prime_count_lower(n); break;
case 2: ret = prime_count_approx(n); break;
PREINIT:
UV lo = 2, hi;
#if HAVE_FACTOR128 && HAVE_SUM_PRIMES128
uint64_t lo64 = 2, hi64;
#endif
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
UV count = 0;
/* 32/64-bit, Legendre or table-accelerated sieving. */
if (sum_primes(lo, hi, &count))
void random_prime(IN SV* svlo, IN SV* svhi = 0)
PREINIT:
UV lo = 2, hi, ret;
dMY_CXT;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
ret = random_prime(MY_CXT.randcxt,lo,hi);
if (ret) XSRETURN_UV(ret);
else XSRETURN_UNDEF;
void print_primes(IN SV* svlo, IN SV* svhi = 0, IN SV* svfd = 0)
PREINIT:
UV lo, hi, fd;
int status = 1, ifd, tfd, close_status, print_status = 1, saved_errno = 0;
PPCODE:
status &= _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG);
if (items > 1) status &= _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG);
if (items > 2) status &= _validate_and_set(&fd, aTHX_ svfd, IFLAG_NONNEG);
if (items == 1)
trial_primes = 1
erat_primes = 2
segment_primes = 3
PREINIT:
AV* av;
PPCODE:
CREATE_RETURN_AV(av);
if ((low <= 2) && (high >= 2)) av_push(av, newSVuv( 2 ));
if ((low <= 3) && (high >= 3)) av_push(av, newSVuv( 3 ));
if ((low <= 5) && (high >= 5)) av_push(av, newSVuv( 5 ));
if (low < 7) low = 7;
PREINIT:
AV* av;
UV lo = 0, hi, i;
int lostatus = 1, histatus = 0;
bool native_ok = FALSE;
PPCODE:
if (items == 1) {
histatus = _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG);
native_ok = histatus != 0;
} else if (items == 2) {
lostatus = _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG);
ALIAS:
omega_primes = 1
PREINIT:
AV* av;
UV lo = 1, hi, i, n, *S;
PPCODE:
if ((items == 2 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items >= 3 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
CREATE_RETURN_AV(av);
S = 0;
if (ix == 0) n = generate_almost_primes(&S, k, lo, hi);
semi_primes = 2
ramanujan_primes = 3
PREINIT:
AV* av;
UV lo = 0, hi, i, num, *L;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
CREATE_RETURN_AV(av);
if (ix == 0) { /* Prime power */
if ((lo <= 2) && (hi >= 2)) av_push(av, newSVuv( 2 ));
void
lucky_numbers(IN SV* svlo, IN SV* svhi = 0)
PREINIT:
AV* av;
UV lo = 0, hi, i, nlucky = 0;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
CREATE_RETURN_AV(av);
if (lo == 0 && hi <= UVCONST(4000000000)) {
uint32_t* lucky = lucky_sieve32(&nlucky, hi);
void minimal_goldbach_pair(IN SV* svn)
ALIAS:
goldbach_pair_count = 1
PREINIT:
UV n, res;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
if (ix == 0) {
res = minimal_goldbach_pair(n);
if (res == 0) XSRETURN_UNDEF;
} else {
void goldbach_pairs(IN SV* svn)
PREINIT:
size_t npairs, i;
UV n, *L;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) == 1) {
if (GIMME_V != G_ARRAY)
XSRETURN_UV(goldbach_pair_count(n));
L = goldbach_pairs(&npairs, n);
if (L == 0) XSRETURN_EMPTY;
void powerful_numbers(IN SV* svlo, IN SV* svhi = 0, IN SV* svk = 0)
PREINIT:
int kstatus = 1;
AV* av;
UV lo = 1, hi, i, k = 2, npowerful, *powerful;
PPCODE:
if (items >= 3)
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus == 1 &&
((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items >= 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) &&
void sieve_range(IN SV* svn, IN SV* svwidth, IN SV* svdepth)
PREINIT:
int status;
UV n, width, depth, lo, hi, *P, np, i;
PPCODE:
/* Return index of every n unless it is a composite with factor > depth */
if (_validate_and_set(&width, aTHX_ svwidth, IFLAG_NONNEG) != 1)
croak("sieve_range: width must fit in native unsigned integer");
if (_validate_and_set(&depth, aTHX_ svdepth, IFLAG_NONNEG) != 1)
croak("sieve_range: depth must fit in native unsigned integer");
sieve_prime_cluster(IN SV* svlo, IN SV* svhi, ...)
PREINIT:
uint32_t nc, cl[100];
UV i, lo, hi, cval, nprimes, *list;
int done, leading_zero;
PPCODE:
nc = 1;
leading_zero = 0;
if (items > 100) croak("sieve_prime_cluster: too many entries");
cl[0] = 0;
for (i = 2; i < (UV)items; i++) {
is_euler_pseudoprime = 1
is_strong_pseudoprime = 2
PREINIT:
int i, status, ret = 0;
UV n, base;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
if (n < 3) {
ret = (n >= 2);
} else if (ix >= 1 && !(n&1)) {
is_safe_prime = 15
is_mersenne_prime = 16
PREINIT:
int status, ret;
UV n;
PPCODE:
ret = 0;
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
switch (ix) {
case 0: ret = 2*is_prime(n); break;
is_almost_extra_strong_lucas_pseudoprime = 1
is_delicate_prime = 2
PREINIT:
int nstatus, kstatus, ret = -1;
UV n, k;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items == 1) {
kstatus = 1;
k = (ix == 0) ? 0 : (ix == 1) ? 1 : 10;
} else {
is_frobenius_pseudoprime(IN SV* svn, IN SV* svp = 0, IN SV* svq = 0)
PREINIT:
int nstatus, pstatus, qstatus;
UV n;
IV P, Q, maxparam;
PPCODE:
if (items == 1) {
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (nstatus == -1) RETURN_NPARITY(0);
if (nstatus == 1) RETURN_NPARITY(is_frobenius_pseudoprime(n));
} else if (items == 3) {
void
miller_rabin_random(IN SV* svn, IN SV* svnbases = 0)
PREINIT:
int nstatus, bstatus;
UV n, nbases;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items < 2) { bstatus = 1; nbases = 1; }
else bstatus=_validate_and_set(&nbases,aTHX_ svnbases,IFLAG_POS);
if (nstatus != 0 && bstatus != 0) {
dMY_CXT;
DISPATCHPP_RETURN();
void is_gaussian_prime(IN SV* sva, IN SV* svb)
PREINIT:
UV a, b;
PPCODE:
if (_validate_and_set(&a, aTHX_ sva, IFLAG_ABS) &&
_validate_and_set(&b, aTHX_ svb, IFLAG_ABS)) {
if (a == 0) RETURN_NPARITY( ((b % 4) == 3) ? 2*is_prime(b) : 0 );
if (b == 0) RETURN_NPARITY( ((a % 4) == 3) ? 2*is_prime(a) : 0 );
if (a < HALF_WORD && b < HALF_WORD) {
ALIAS:
lcm = 1
PREINIT:
int i, status = 1;
UV ret, nullv, n;
PPCODE:
/* For each arg, while valid input, validate+gcd/lcm. Shortcut stop. */
if (ix == 0) { ret = 0; nullv = 1; }
else { ret = 1; nullv = 0; }
for (i = 0; i < items && ret != nullv && status != 0; i++) {
status = _validate_and_set(&n, aTHX_ ST(i), IFLAG_ABS);
ALIAS:
vecmax = 1
PREINIT:
int i, status;
UV ret, n, retindex;
PPCODE:
if (items == 0) XSRETURN_UNDEF;
if (items == 1) RETURN_SV_CANONICAL(ST(0));
retindex = 0;
if ((status = _validate_and_set(&ret, aTHX_ ST(0), IFLAG_ANY)) != 0) {
int sign = status, minmax = (ix == 0);
ALIAS:
vecprod = 1
PREINIT:
int i, status;
UV ret, n;
PPCODE:
if (items == 0)
XSRETURN_UV(ix == 0 ? 0 : 1);
status = 1;
if (ix == 0) {
UV lo = 0;
PROTOTYPE: @
PREINIT:
int type;
size_t i, len;
UV *L;
PPCODE:
if (items == 0)
RETURN_NOTHING();
if (SvROK(ST(0)) && SvTYPE(SvRV(ST(0))) == SVt_PVAV) {
if (items != 1)
croak("vecprefixsum: expected integer list or single array reference");
void
vecextract(IN SV* x, IN SV* svm)
PREINIT:
AV* av;
UV mask, i = 0;
PPCODE:
CHECK_ARRAYREF(x);
av = (AV*) SvRV(x);
if (SvROK(svm) && SvTYPE(SvRV(svm)) == SVt_PVAV) {
SSize_t j;
DECL_ARREF(mav);
void
vecequal(IN SV* a, IN SV* b)
PREINIT:
int res;
PPCODE:
res = _compare_array_refs(aTHX_ a, b);
if (res == AREF_CMP_DISPATCH)
DISPATCHPP_RETURN();
if (res == AREF_CMP_INVALID)
croak("vecequal: expected scalar or array reference");
PREINIT:
char *setv;
int i, status = 1;
UV min, n;
uint32_t mask;
PPCODE:
if (ix == 0) {
min = 0;
mask = IFLAG_NONNEG;
} else {
min = 1;
frobenius_number(...)
PROTOTYPE: @
PREINIT:
int i, found1 = 0;
UV fn, n, *A;
PPCODE:
if (items == 0) XSRETURN_UNDEF;
Newz(0, A, items, UV);
for (i = 0; i < items; i++) {
if (!_validate_and_set(&n, aTHX_ ST(i), IFLAG_POS)) break;
if (n == 1) found1 = 1;
PROTOTYPE: @
PREINIT:
int i, status, astatus, nstatus;
UV ret, lcm, *an;
SV **psva, **psvn;
PPCODE:
status = 1;
New(0, an, 2*items, UV);
ret = 0;
for (i = 0; i < items; i++) {
AV* av;
DISPATCHPP_RETURN();
void cornacchia(IN SV* svd, IN SV* svn)
PREINIT:
UV d, n, x, y;
PPCODE:
if (_validate_and_set(&d, aTHX_ svd, IFLAG_NONNEG) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) ) {
if (!cornacchia(&x, &y, d, n)) XSRETURN_UNDEF;
PUSHs(sv_2mortal(newSVuv( x )));
PUSHs(sv_2mortal(newSVuv( y )));
void lucas_sequence(...)
PREINIT:
UV U, V, Qk, n, P, Q, k;
int nstatus, pstatus, qstatus, kstatus;
PPCODE:
if (items != 4) croak("lucas_sequence: n, P, Q, k");
nstatus = _validate_and_set(&n, aTHX_ ST(0), IFLAG_POS);
pstatus = _validate_and_set(&P, aTHX_ ST(1), IFLAG_IV);
qstatus = _validate_and_set(&Q, aTHX_ ST(2), IFLAG_IV);
kstatus = _validate_and_set(&k, aTHX_ ST(3), IFLAG_NONNEG);
lucasumod = 1
lucasvmod = 2
PREINIT:
int pstatus, qstatus;
UV P, Q, k, n, U, V;
PPCODE:
pstatus = _validate_and_set(&P, aTHX_ svp, IFLAG_ANY);
qstatus = _validate_and_set(&Q, aTHX_ svq, IFLAG_ANY);
if ((pstatus != 0) && (qstatus != 0) &&
_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_ABS)
lucasu = 1
lucasv = 2
PREINIT:
UV k;
IV P, Q, U, V;
PPCODE:
if (_validate_and_set((UV*)&P, aTHX_ svp, IFLAG_IV) &&
_validate_and_set((UV*)&Q, aTHX_ svq, IFLAG_IV) &&
_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) &&
lucasuv(&U, &V, P, Q, k)) {
if (ix == 1) XSRETURN_IV(U); /* U = lucasu(P,Q,k) */
ALIAS:
lucas_number = 1
PREINIT:
UV k, N;
int kstatus;
PPCODE:
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_ANY);
if (kstatus != 0) {
if (kstatus == -1) k = neg_iv(k);
N = ix == 0 ? fibonacci_number(k) : lucas_number(k);
if (k == 0 || N > 0) {
void is_sum_of_squares(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus, ret;
UV n, k;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (items < 2) { kstatus = 1; k = 2; }
else { kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG); }
if (nstatus != 0 && kstatus != 0) {
switch (k) {
is_cyclic = 8
is_totient = 9
PREINIT:
int status, ret;
UV n;
PPCODE:
ret = 0;
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
switch (ix) {
case 0: ret = is_perfect_square(n); break;
void squarefree_kernel(IN SV* svn)
PREINIT:
int status;
UV n;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == -1)
XSRETURN_IV( neg_iv(squarefree_kernel(neg_iv(n))) );
if (status == 1)
XSRETURN_UV( squarefree_kernel(n) );
void is_powerfree(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus != 0)
RETURN_NPARITY( is_powerfree(n,k) );
void powerfree_count(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus == -1)
XSRETURN_UV(0);
void powerfree_sum(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2, res;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus == -1)
XSRETURN_UV(0);
void powerfree_part(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus != 0) {
if (nstatus == -1)
void powerfree_part_sum(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2, res;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus == -1)
XSRETURN_UV(0);
void nth_powerfree(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus = 1;
UV n, k = 2, res;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (items >= 2) kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1 || k > UINT32_MAX) croak("%s: k must be <= 4294967295", SUBNAME);
if (nstatus == 1) {
if (n == 0 || k < 2)
is_power(IN SV* svn, IN SV* svk = 0, IN SV* svroot = 0)
PREINIT:
int nstatus, kstatus, ret;
UV n, k;
uint32_t root;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items == 2 && xs_is_sv_scalar_ref(svk)) {
svroot = svk;
svk = 0;
}
void
is_prime_power(IN SV* svn, IN SV* svroot = 0)
PREINIT:
int status, ret;
UV n, root;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (items >= 2 && !xs_is_sv_scalar_ref(svroot))
croak("is_prime_power: second argument not a scalar reference");
if (status != 0) {
ret = (status == 1) ? prime_power(n, &root) : 0;
void
is_polygonal(IN SV* svn, IN UV k, IN SV* svroot = 0)
PREINIT:
UV n;
int status;
PPCODE:
if (k < 3) croak("is_polygonal: k must be >= 3");
if (items >= 3 && !xs_is_sv_scalar_ref(svroot))
croak("is_polygonal: third argument not a scalar reference");
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
void inverse_li(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
#if BITS_PER_WORD == 64
/* Larger values need more precision to identify the exact integer. */
if (n <= UVCONST(1000000000000) && n < MPU_MAX_PRIME_IDX)
#else
PREINIT:
const char *xstr;
STRLEN xlen;
int xtype;
NV x, ret;
PPCODE:
SvGETMAGIC(svx);
if (SvOK(svx)) {
xstr = SvPV(svx, xlen);
xtype = grok_number(xstr, xlen, 0);
if (xtype && !(xtype & (IS_NUMBER_INFINITY | IS_NUMBER_NAN))) {
nth_prime_upper = 1
nth_prime_lower = 2
nth_prime_approx = 3
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_PRIME_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_prime(n); break;
nth_prime_power_upper = 1
nth_prime_power_lower = 2
nth_prime_power_approx = 3
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_PRIME_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_prime_power(n); break;
nth_perfect_power_upper = 1
nth_perfect_power_lower = 2
nth_perfect_power_approx = 3
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_PERFECT_POW_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_perfect_power(n); break;
nth_ramanujan_prime_upper = 1
nth_ramanujan_prime_lower = 2
nth_ramanujan_prime_approx = 3
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_RMJN_PRIME_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_ramanujan_prime(n); break;
void nth_twin_prime(IN SV* svn)
ALIAS:
nth_twin_prime_approx = 1
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_TWIN_PRIME_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_twin_prime(n); break;
void nth_semiprime(IN SV* svn)
ALIAS:
nth_semiprime_approx = 1
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_SEMI_PRIME_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_semiprime(n); break;
nth_lucky_upper = 1
nth_lucky_lower = 2
nth_lucky_approx = 3
PREINIT:
UV n, ret;
PPCODE:
if ( _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
n <= MPU_MAX_LUCKY_IDX ) {
if (n == 0) XSRETURN_UNDEF;
switch (ix) {
case 0: ret = nth_lucky(n); break;
void next_prime(IN SV* svn)
ALIAS:
prev_prime = 1
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)
&& !(ix == 0 && n >= MPU_MAX_PRIME)) {
ret = 0;
switch (ix) {
case 0: ret = next_prime(n); break;
void next_prime_power(IN SV* svn)
ALIAS:
prev_prime_power = 1
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS)
&& !(ix == 0 && n >= MPU_MAX_PRIME)) {
ret = 0;
switch (ix) {
case 0: ret = next_prime_power(n); break;
void next_perfect_power(IN SV* svn)
PREINIT:
UV n;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
n = next_perfect_power(n);
if (n != 0) XSRETURN_UV(n);
} else if (status == -1) { /* next perfect power: negative n */
void prev_perfect_power(IN SV* svn)
PREINIT:
UV n;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
if (n == 0) XSRETURN_IV(-1);
n = prev_perfect_power(n);
XSRETURN_UV(n);
DISPATCHPP_RETURN();
void next_chen_prime(IN SV* svn)
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
ret = next_chen_prime(n);
if (ret != 0) XSRETURN_UV(ret);
}
DISPATCHPP_RETURN();
void urandomb(IN SV* svbits)
PREINIT:
UV bits;
int bstatus;
PPCODE:
bstatus = _validate_and_set(&bits, aTHX_ svbits, IFLAG_NONNEG);
if (bstatus != 1 || bits > MAX_RANDOM_BITS)
croak("%s: bits must be between 0 and %"UVuf, SUBNAME, MAX_RANDOM_BITS);
if (bits <= BITS_PER_WORD) {
dMY_CXT;
void random_ndigit_prime(IN SV* svdigits)
PREINIT:
int dstatus;
UV digits;
PPCODE:
dstatus = _validate_and_set(&digits, aTHX_ svdigits, IFLAG_POS);
if (dstatus != 1 || digits < 1 || digits > MAX_RANDOM_DIGITS)
croak("%s: digits must be between 1 and %"UVuf, SUBNAME, MAX_RANDOM_DIGITS);
if (digits <= uvmax_maxlen) {
dMY_CXT;
random_unrestricted_semiprime = 7
PREINIT:
UV bits, res;
static const unsigned int minbits[] = { 2, 2, 2, 2, 128, 3, 4, 3 };
int bstatus;
PPCODE:
bstatus = _validate_and_set(&bits, aTHX_ svbits, IFLAG_POS);
if (bstatus != 1 || bits < minbits[ix] || bits > MAX_RANDOM_BITS)
croak("%s: bits must be between %u and %"UVuf, SUBNAME, minbits[ix], MAX_RANDOM_BITS);
if (bits <= BITS_PER_WORD) {
dMY_CXT;
DISPATCHPP_RETURN();
void urandomm(IN SV* svn)
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
dMY_CXT;
ret = urandomm64(MY_CXT.randcxt, n);
XSRETURN_UV(ret);
}
void urandomr(IN SV* svlo, IN SV* svhi)
PREINIT:
UV lo, hi;
int lo_s, hi_s;
PPCODE:
lo_s = _validate_and_set(&lo, aTHX_ svlo, IFLAG_ANY);
hi_s = _validate_and_set(&hi, aTHX_ svhi, IFLAG_ANY);
if (lo_s == 1 && hi_s == 1) {
dMY_CXT;
if (lo > hi) XSRETURN_UNDEF;
PREINIT:
const char *s;
STRLEN len;
uint32_t stype;
SV *numsv;
PPCODE:
SvGETMAGIC(svn);
if (!SvOK(svn)) XSRETURN_UV(0); /* undef returns 0 without warning */
/* Fastest path: if it is already a native int then we're done. */
/* TODO: verify 5.6.2 */
if (SVNUMTEST(svn)) {
void random_factored_integer(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
dMY_CXT;
int f, nf;
UV r, F[MPU_MAX_FACTORS+1];
AV* av = newAV();
void contfrac(IN SV* svnum, IN SV* svden)
PREINIT:
UV num, den, *cf, rem;
int nstatus, dstatus, i, steps;
PPCODE:
nstatus = _validate_and_set(&num, aTHX_ svnum, IFLAG_ANY);
dstatus = _validate_and_set(&den, aTHX_ svden, IFLAG_POS);
if (nstatus == 0 || dstatus == 0)
DISPATCHPP_RETURN();
if (nstatus == -1) num = neg_iv(num);
PROTOTYPE: @
PREINIT:
size_t i;
UV n, cfA0, cfA1, cfB0, cfB1, cfAn, cfBn;
int nstatus, overflow;
PPCODE:
nstatus = 1;
overflow = 0;
cfA0 = 1; cfA1 = 0;
cfB0 = 0; cfB1 = 1;
if (items > 0) {
PROTOTYPE: @
PREINIT:
size_t len;
UV *L, *P, *Q;
int type;
PPCODE:
if (items == 0)
RETURN_NOTHING();
type = array_to_int_array(aTHX_ &len, &L, 0, &ST(0), items);
/* We punt negative cases to PP */
if (!(type == IARR_TYPE_BAD || type == IARR_TYPE_NEG)) {
PREINIT:
UV dbound, P, Q;
STRLEN xlen;
const char *xstr;
int xtype;
PPCODE:
SvGETMAGIC(svx);
if (_validate_and_set(&dbound, aTHX_ svdbound, IFLAG_POS) &&
SvOK(svx) &&
!sv_isobject(svx)) {
xstr = SvPV_nomg(svx, xlen);
ALIAS:
next_stern_brocot = 1
PREINIT:
UV num, den;
int status;
PPCODE:
if (_validate_and_set(&num, aTHX_ svnum, IFLAG_POS) && _validate_and_set(&den, aTHX_ svden, IFLAG_POS)) {
if (gcd_ui(num, den) != 1)
croak("%s: rational must be reduced", SUBNAME);
switch (ix) {
case 0: status = next_calkin_wilf(&num, &den); break;
void calkin_wilf_n(IN SV* svnum, IN SV* svden)
ALIAS:
stern_brocot_n = 1
PREINIT:
UV num, den, n;
PPCODE:
if (_validate_and_set(&num, aTHX_ svnum, IFLAG_POS) && _validate_and_set(&den, aTHX_ svden, IFLAG_POS)) {
switch (ix) {
case 0: n = calkin_wilf_n(num, den); break;
case 1: n = stern_brocot_n(num, den); break;
default: n = 0; break;
ALIAS:
nth_stern_brocot = 1
PREINIT:
UV n, num, den;
int status;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
switch (ix) {
case 0: status = nth_calkin_wilf(&num, &den, n); break;
case 1: status = nth_stern_brocot(&num, &den, n); break;
default: status = 0; break;
DISPATCHPP_RETURN();
void nth_stern_diatomic(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG))
XSRETURN_UV(nth_stern_diatomic(n));
DISPATCHPP_RETURN();
void farey(IN SV* svn, IN SV* svk = 0)
PREINIT:
UV n, k;
int wantsingle, kresult;
PPCODE:
wantsingle = svk != 0;
if (wantsingle) {
if (!_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG))
k = UV_MAX;
}
PREINIT:
SV **psvp, **psvq;
AV* av;
UV n, p64, q64;
int status;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS) && n <= UINT32_MAX) {
uint32_t n32 = (uint32_t) n;
CHECK_ARRAYREF(svfrac);
av = (AV*) SvRV(svfrac);
if (av_count(av) != 2) croak("%s: expected 2-element array reference", SUBNAME);
const UV mantsize = DBL_DIG;
const NV pival = 3.141592653589793238462643383279502884197169;
#endif
UV digits;
int status;
PPCODE:
status = 1;
digits = 0;
if (items > 0)
status = _validate_and_set(&digits, aTHX_ svdigits, IFLAG_NONNEG);
if (status != 1 || digits > mantsize)
void bernfrac(IN SV* svn)
ALIAS:
harmfrac = 1
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) != 0) {
if (ix == 0) {
IV num; UV den;
if (bernfrac(&num, &den, n)) {
XPUSHs(sv_2mortal(newSViv( num )));
void
_pidigits(IN SV* svdigits)
PREINIT:
UV digits;
char* out;
PPCODE:
if (!_validate_and_set(&digits, aTHX_ svdigits, IFLAG_NONNEG) ||
digits > UINT32_MAX)
croak("_pidigits: input digits exceeds 32-bit limit");
if (digits == 0)
XSRETURN_PV("");
void inverse_totient(IN SV* svn)
PREINIT:
U32 gimme_v;
int status;
UV i, n, ntotients;
PPCODE:
gimme_v = GIMME_V;
status = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (status == 1) {
if (gimme_v == G_SCALAR) {
XSRETURN_UV( inverse_totient_count(n) );
inverse_sigma0_count = 1
PREINIT:
AV* av;
UV k, lo = 1, hi, i, count, *list;
int kstatus, lostatus, histatus;
PPCODE:
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (items == 2) {
histatus = _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG);
lostatus = 1;
} else {
PREINIT:
UV n;
uint32_t i;
U32 gimme_v;
int status;
PPCODE:
gimme_v = GIMME_V;
status = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (status == 1) {
if (ix == 0) {
UV factors[MPU_MAX_FACTORS];
void divisors(IN SV* svn, IN SV* svk = 0)
PREINIT:
int status;
UV n, k, i, ndivisors, *divs;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
k = n;
if (status == 1 && svk != 0) {
status = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (k > n) k = n;
int nstatus, a1status, a2status, a3status;
UV n, arg1, arg2, arg3;
static const UV default_arg1[] =
{0, 64000000, 8000000, 4000000, 1, 4000000, 0, 200, 4000000, 1000000, 4000};
/* Trial, Fermat, Holf, SQUFOF, Lmn, PRHO, Cheb, P+1, Brent, P-1, ECM64 */
PPCODE:
if (ix == 10 && items > 2 && !SvOK(ST(1)) && SvOK(ST(2)))
croak("ecm_factor: B1 must be specified if B2 is specified");
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (items > 1) a1status=_validate_and_set(&arg1, aTHX_ ST(1), IFLAG_NONNEG);
else { a1status = 1; arg1 = default_arg1[ix]; }
void
divisor_sum(IN SV* svn, ...)
PREINIT:
UV n, k, sigma;
PPCODE:
if (items == 1) {
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
sigma = divisor_sum(n, 1);
if (n <= 1 || sigma != 0)
XSRETURN_UV(sigma);
DISPATCHPP_RETURN();
void aliquot_sum(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
UV sum = aliquot_sum(n);
if (n <= 1 || sum != 0)
XSRETURN_UV(sum);
}
DISPATCHPP_RETURN();
void abundance(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
UV sum = aliquot_sum(n);
if (n <= 1 || sum != 0)
XSRETURN_IV((IV)(sum-n));
}
void sopf(IN SV* svn)
ALIAS:
sopfr = 1
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
UV sum = ix ? sopfr(n) : sopf(n);
XSRETURN_UV(sum);
}
DISPATCHPP_RETURN();
void prime_signature(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
factored_t nf = factorint(n);
uint32_t i, j, nfactors = nf.nfactors;
/* Insertion sort the exponents in descending order */
for (i = 1; i < nfactors; i++) {
void jordan_totient(IN SV* svk, IN SV* svn)
PREINIT:
int kstatus, nstatus;
UV k, n;
PPCODE:
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (kstatus != 1)
croak("jordan_totient: k must fit in a UV");
if (nstatus == 1) {
void powersum(IN SV* svn, IN SV* svk)
PREINIT:
int kstatus, nstatus;
UV k, n;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (kstatus != 1)
croak("powersum: k must fit in a UV");
if (nstatus == 1) {
smooth_count = 2
rough_count = 3
PREINIT:
int astatus, nstatus;
UV a, n, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_NONNEG);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (astatus != 0 && nstatus != 0) {
switch (ix) {
case 0: if (a < 1 || n < 1) XSRETURN_IV(0);
almost_prime_count_lower = 2
almost_prime_count_upper = 3
omega_prime_count = 4
PREINIT:
UV k, n, ret;
PPCODE:
if (_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
k < BITS_PER_WORD) {
ret = 0;
switch (ix) {
nth_almost_prime_approx = 1
nth_almost_prime_lower = 2
nth_almost_prime_upper = 3
PREINIT:
UV k, n, max;
PPCODE:
if (_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
k < BITS_PER_WORD) {
UV ret = 0;
if (n == 0 || (k == 0 && n > 1)) XSRETURN_UNDEF;
DISPATCHPP_RETURN();
void nth_omega_prime(IN SV* svk, IN SV* svn)
PREINIT:
UV k, n, max, ret;
PPCODE:
if (_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) &&
k < 16) {
if (n == 0 || (k == 0 && n > 1)) XSRETURN_UNDEF;
max = max_omega_prime_count(k);
ALIAS:
rootmod = 1
PREINIT:
int astatus, gstatus, nstatus, retundef;
UV a, g, n, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
gstatus = _validate_and_set(&g, aTHX_ svg, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && gstatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
divmod = 3
znlog = 4
PREINIT:
int astatus, bstatus, nstatus, retundef;
UV a, b, n, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && bstatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
ALIAS:
mulsubmod = 1
PREINIT:
int astatus, bstatus, cstatus, nstatus;
UV a, b, c, n, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_ANY);
cstatus = _validate_and_set(&c, aTHX_ svc, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && bstatus != 0 && cstatus != 0 && nstatus != 0) {
void binomialmod(IN SV* svn, IN SV* svk, IN SV* svm)
PREINIT:
int nstatus, kstatus, mstatus;
UV ret, n, k, m;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_ANY);
mstatus = _validate_and_set(&m, aTHX_ svm, IFLAG_ABS);
if (nstatus != 0 && kstatus != 0 && mstatus != 0) {
if (m == 0) XSRETURN_UNDEF;
void factorialmod(IN SV* sva, IN SV* svn)
PREINIT:
int astatus, nstatus;
UV a, n;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_NONNEG);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
if (n == 1) XSRETURN_UV(0);
sqrtmod = 2
negmod = 3
PREINIT:
int astatus, nstatus;
UV a, n, r, retok;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
if (n == 1) XSRETURN_UV((ix==1) ? 1 : 0); /* znorder different */
void allsqrtmod(IN SV* sva, IN SV* svn)
PREINIT:
int astatus, nstatus;
UV a, n, i, numr, *roots;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && nstatus != 0) {
if (n == 0) RETURN_NOTHING();
_mod_with(&a, astatus, n);
void allrootmod(IN SV* sva, IN SV* svg, IN SV* svn)
PREINIT:
int astatus, gstatus, nstatus;
UV a, g, n, i, numr, *roots;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
gstatus = _validate_and_set(&g, aTHX_ svg, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && gstatus != 0 && nstatus != 0) {
if (n == 0) RETURN_NOTHING();
void is_primitive_root(IN SV* sva, IN SV* svn)
PREINIT:
int astatus, nstatus;
UV a, n;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
_mod_with(&a, astatus, n);
void qnr(IN SV* svn)
ALIAS:
znprimroot = 1
PREINIT:
UV n, r;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS)) {
if (n == 0) XSRETURN_UNDEF;
if (ix == 0) {
r = qnr(n);
} else {
is_smooth(IN SV* svn, IN SV* svk)
ALIAS:
is_rough = 1
PREINIT:
UV n, k;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG)) {
RETURN_NPARITY( (ix == 0) ? is_smooth(n,k) : is_rough(n,k) );
}
DISPATCHPP_RETURN();
ALIAS:
is_almost_prime = 1
PREINIT:
UV n, k;
int nstatus, kstatus;
PPCODE:
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (kstatus != 0 && nstatus != 0) {
int res = (nstatus != 1) ? 0
: (ix == 0) ? is_omega_prime(k, n)
void is_divisible(IN SV* svn, IN SV* svd, ...)
PREINIT:
UV n, d, ret;
size_t i;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
_validate_and_set(&d, aTHX_ svd, IFLAG_ABS)) {
int status = 1;
ret = d==0 ? (n==0) : n % d == 0;
for (i = 2; i < (size_t)items && !ret; i++) {
void is_congruent(IN SV* svn, IN SV* svc, IN SV* svd)
PREINIT:
UV n, c, d;
int nstatus, cstatus, dstatus;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
cstatus = _validate_and_set(&c, aTHX_ svc, IFLAG_ANY);
dstatus = _validate_and_set(&d, aTHX_ svd, IFLAG_ABS);
if (nstatus != 0 && cstatus != 0 && dstatus != 0) {
if (d != 0) {
DISPATCHPP_RETURN();
void valuation(IN SV* svn, IN SV* svk)
PREINIT:
UV n, k;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG)) {
if (k <= 1) croak("valuation: k must be > 1");
if (n == 0) XSRETURN_UNDEF;
RETURN_NPARITY(valuation(n, k));
ALIAS:
remove_factors_exp = 1
PREINIT:
UV n, k, e;
int nstatus, kstatus;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (nstatus != 0 && kstatus != 0) {
if (k <= 1) croak("%s: k must be > 1", SUBNAME);
if (n == 0) {
sumpowerful = 2
nth_powerful = 3
PREINIT:
int nstatus;
UV n, ret, k = 2;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, (ix < 3) ? IFLAG_ANY: IFLAG_NONNEG);
if (nstatus != 0 && (!svk || _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG))) {
if (nstatus == -1) RETURN_NPARITY(0);
if (ix == 0) RETURN_NPARITY( is_powerful(n, k) );
if (ix == 1) XSRETURN_UV( powerful_count(n, k) );
void kronecker(IN SV* sva, IN SV* svb)
PREINIT:
int k;
PPCODE:
if (xs_kronecker_result(aTHX_ sva, svb, &k))
RETURN_NPARITY( k );
DISPATCHPP_RETURN();
void is_qr(IN SV* sva, IN SV* svn)
PREINIT:
int astatus, nstatus;
UV a, n;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (astatus != 0 && nstatus != 0) {
if (n == 0) XSRETURN_UNDEF;
if (n == 1) RETURN_NPARITY(1);
PREINIT:
SV* slowret;
int astatus, bstatus, is_uv;
UV uvret;
IV ivret;
PPCODE:
if (addint_try_native_result(aTHX_ ix, sva, svb, SUBNAME,
&astatus, &bstatus, &is_uv, &uvret, &ivret)) {
if (is_uv) XSRETURN_UV(uvret);
XSRETURN_IV(ivret);
}
ALIAS:
mulsubint = 1
PREINIT:
int astatus, bstatus, cstatus;
UV a, b, c;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_ANY);
cstatus = _validate_and_set(&c, aTHX_ svc, IFLAG_ANY);
if (astatus != 0 && bstatus != 0 && cstatus != 0) {
if (astatus == -1) a = neg_iv(a);
PREINIT:
SV* slowret;
int status, is_uv;
UV uvret;
IV ivret;
PPCODE:
if (add1_try_native_result(aTHX_ ix, svn, &status, &is_uv, &uvret, &ivret)) {
if (is_uv) XSRETURN_UV(uvret);
XSRETURN_IV(ivret);
}
slowret = add1_try_slow_result(aTHX_ ix, svn);
void absint(IN SV* svn)
ALIAS:
negint = 1
PREINIT:
UV n;
PPCODE:
if (ix == 0) {
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS))
XSRETURN_UV(n);
} else {
int status = _validate_and_set(&n, aTHX_ svn, IFLAG_IV);
void signint(IN SV* svn)
ALIAS:
is_odd = 1
is_even = 2
PPCODE:
RETURN_NPARITY(xs_sign_parity_result(aTHX_ svn, SUBNAME, ix));
void cmpint(IN SV* sva, IN SV* svb)
PREINIT:
int ret;
PPCODE:
ret = xs_cmpint_result(aTHX_ sva, svb);
RETURN_NPARITY(ret);
void logint(IN SV* svn, IN SV* svb, IN SV* svret = 0)
PREINIT:
UV n, b;
int nstatus, bstatus;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_POS);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_POS);
if (bstatus != 0 && b < 2) croak("logint: base must be > 1");
if (items >= 3 && !xs_is_sv_scalar_ref(svret))
croak("logint: third argument not a scalar reference");
void rootint(IN SV* svn, IN SV* svk, IN SV* svret = 0)
PREINIT:
UV n, k;
int nstatus, kstatus;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
if (items >= 3 && !xs_is_sv_scalar_ref(svret))
croak("rootint: third argument not a scalar reference");
if (nstatus != 0 && kstatus != 0) {
void crootint(IN SV* svn, IN SV* svk)
PREINIT:
UV n, k;
int nstatus, kstatus;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
if (nstatus != 0 && kstatus != 0)
XSRETURN_UV(crootint(n, k));
DISPATCHPP_RETURN();
tdivrem = 3
PREINIT:
int astatus, bstatus;
UV D, d;
IV iD, id;
PPCODE:
astatus = _validate_and_set(&D, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&d, aTHX_ svb, IFLAG_ANY);
if (astatus != 0 && bstatus != 0 && d == 0)
croak("%s: divide by zero", SUBNAME);
if (astatus == 1 && bstatus == 1 && (ix != 2 || D % d == 0)) {
rshiftint = 1
rashiftint = 2
PREINIT:
int nstatus, kstatus, nix;
UV n, k, nk;
PPCODE:
nix = ix;
if (items == 1) {
kstatus = 1;
k = 1;
} else {
void
gcdext(IN SV* sva, IN SV* svb)
PREINIT:
IV u, v, d, a, b;
PPCODE:
if (_validate_and_set((UV*)&a, aTHX_ sva, IFLAG_IV) &&
_validate_and_set((UV*)&b, aTHX_ svb, IFLAG_IV) &&
a != IV_MIN && b != IV_MIN) {
d = gcdext(a, b, &u, &v, 0, 0);
XPUSHs(sv_2mortal(newSViv( u )));
void
stirling(IN SV* svn, IN SV* svm, IN UV type = 1)
PREINIT:
UV n, m;
int nstatus, mstatus;
PPCODE:
if (type != 1 && type != 2 && type != 3)
croak("stirling: type must be 1, 2, or 3");
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
mstatus = _validate_and_set(&m, aTHX_ svm, IFLAG_NONNEG);
if (nstatus == 1 && mstatus == 1) {
ALIAS:
moebius = 1
PREINIT:
UV lo, hi;
int lostatus, histatus;
PPCODE:
lostatus = _validate_and_set(&lo, aTHX_ svlo, IFLAG_ANY);
if (items == 1) {
if (lostatus != 0 && ix == 0)
XSRETURN_UV(lostatus == -1 ? 0 : totient(lo));
void
dedekind_psi(IN SV* svn)
PREINIT:
int nstatus;
UV n, r;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (nstatus != 0) {
if (nstatus == -1) XSRETURN_UV(0);
r = dedekind_psi(n);
if (n == 0 || r > 0) XSRETURN_UV(r);
ALIAS:
carmichael_lambda = 1
exp_mangoldt = 2
PREINIT:
UV n, r;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
r = 0;
switch (ix) {
case 0: r = isqrt(n); break;
case 1: r = carmichael_lambda(n); break;
DISPATCHPP_RETURN();
void hammingweight(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS))
XSRETURN_UV(popcnt(n));
if (_XS_get_callgmp() < 47) {
char* ptr; STRLEN len; ptr = SvPV(svn, len);
XSRETURN_UV(mpu_popcount_string(ptr, len));
prime_bigomega = 1
is_square_free = 2
PREINIT:
UV n, ret;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (status != 0) {
ret = 0;
switch (ix) {
case 0: ret = prime_omega(n); break;
DISPATCHPP_RETURN();
void pisano_period(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
UV r = pisano_period(n);
if (r != UV_MAX)
XSRETURN_UV(r);
}
partitions = 7
partitionsq = 8
consecutive_integer_lcm = 9
PREINIT:
UV n, r = 0;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG) != 1)
croak("%s: n must fit in native unsigned integer", SUBNAME);
switch(ix) {
case 0: r = factorial(n); break;
case 1: r = subfactorial(n); break;
void integer_complexity(IN SV* svn)
PREINIT:
int nstatus;
UV n, r;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (nstatus == 0 || n > (UV)IV_MAX)
croak("integer_complexity: n must fit in native signed integer");
r = integer_complexity(n); /* Make sure to call it even if n=0 */
if (n == 0) XSRETURN_UNDEF;
UV n, r;
#if HAVE_FACTOR128 && HAVE_SUMTOTIENT128
uint64_t n64;
uint128_t sum128;
#endif
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
r = sumtotient(n);
if (n == 0 || r > 0) XSRETURN_UV(r);
#if HAVE_FACTOR128 && HAVE_SUMTOTIENT128
if (sumtotient128(n, &sum128)) /* 64-bit overflowed, try 128-bit. */
void binomial(IN SV* svn, IN SV* svk)
PREINIT:
int nstatus, kstatus;
UV n, k, ret;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_ANY);
if (nstatus != 0 && kstatus != 0) {
if ( (nstatus == 1 && (kstatus == -1 || k > n)) ||
(nstatus ==-1 && (kstatus == -1 && k > n)) )
void multifactorial(IN SV* svn, IN SV* svk)
PREINIT:
int nstatus, kstatus;
UV n, k, r;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
if (nstatus == 1 && kstatus == 1) {
r = multifactorial(n, k);
if (n == 0 || r > 0) XSRETURN_UV(r);
ALIAS:
rising_factorial = 1
PREINIT:
int nstatus, kstatus;
UV n, k;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_IV);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);
if (nstatus == 1 && kstatus == 1) {
UV ret = (ix==0) ? falling_factorial(n,k) : rising_factorial(n,k);
if (ret != UV_MAX) XSRETURN_UV(ret);
void floor_sum(IN SV* svn, IN SV* svm, IN SV* sva, IN SV* svb)
PREINIT:
int nstatus, mstatus, astatus, bstatus;
UV n, m, a, b;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
mstatus = _validate_and_set(&m, aTHX_ svm, IFLAG_POS);
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_NONNEG);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_NONNEG);
if (nstatus == 1 && mstatus == 1 && astatus == 1 && bstatus == 1) {
DISPATCHPP_RETURN();
void mertens(IN SV* svlo, IN SV* svhi = 0)
PREINIT:
UV lo = 1, hi;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_NONNEG)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_NONNEG) &&
_validate_and_set(&hi, aTHX_ svhi, IFLAG_NONNEG))) {
RETURN_NPARITY(mertens_range(lo, hi));
}
sumliouville = 1
is_pillai = 2
is_congruent_number = 3
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
IV r = 0;
switch(ix) {
case 0: r = liouville(n); break;
case 1: r = sumliouville(n); break;
void hclassno(IN SV* svn)
PREINIT:
UV n, r;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == -1)
XSRETURN_IV(0);
if (status == 1) {
if (n == 0)
void ramanujan_tau(IN SV* svn)
PREINIT:
UV n;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == -1)
XSRETURN_IV(0);
if (status == 1) {
IV r = ramanujan_tau(n);
void chebyshev_theta(IN SV* svn)
ALIAS:
chebyshev_psi = 1
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
NV r = (ix==0) ? chebyshev_theta(n) : chebyshev_psi(n);
XSRETURN_NV(r);
}
DISPATCHPP_RETURN(); /* Result is FP */
PREINIT:
int atype, btype, stype, sign;
UV *ra, *rb;
size_t alen, blen, i, j;
iset_t s;
PPCODE:
atype = arrayref_to_int_array(aTHX_ &alen, &ra, 1, sva, "sumset arg 1");
if (svb == 0 || atype == IARR_TYPE_BAD) {
rb = ra;
blen = alen;
btype = atype;
PREINIT:
int atype, btype;
UV *ra, *rb;
Size_t alen, blen;
CODE:
/* Must be CODE and not PPCODE */
atype = arrayref_to_int_array(aTHX_ &alen, &ra, 1, sva, "setbinop arg 1");
if (svb == 0 || atype == IARR_TYPE_BAD) {
rb = ra;
blen = alen;
btype = atype;
setintersect = 1
setminus = 2
setdelta = 3
PREINIT:
SV *ret;
PPCODE:
/* Alias ix values intentionally match set_op_t. */
if (xs_set_op(aTHX_ sva, svb, (set_op_t)ix, &ret, SUBNAME)) {
ST(0) = sv_2mortal(ret);
XSRETURN(1);
}
set_is_superset = 4
set_is_proper_superset = 5
set_is_proper_intersection = 6
PREINIT:
int ret;
PPCODE:
/* Alias ix values intentionally match set_relation_op_t. */
if (xs_set_relation(aTHX_ sva, svb, (set_relation_op_t)ix, &ret, SUBNAME))
RETURN_NPARITY(ret);
DISPATCHPP_RETURN();
UV b;
AV *ava;
int bstatus, subset, findall;
Size_t alen, blen, i;
DECL_ARREF(arb);
PPCODE:
CHECK_ARRAYREF(sva); /* First argument is a set as array ref */
ava = (AV*) SvRV(sva);
alen = av_count(ava);
if (items < 2)
RETURN_NPARITY(ix == 0 ? 1 : 0);
PREINIT:
AV *ava;
Size_t alen, blen, i, j;
UV *rb;
int btype, bstatus;
PPCODE:
CHECK_ARRAYREF(sva); /* First argument is a set as array ref */
ava = (AV*) SvRV(sva);
alen = av_count(ava);
if (items < 2)
RETURN_NPARITY(0);
PREINIT:
AV *ava;
Size_t alen, blen, i;
UV *rb;
int btype, bstatus;
PPCODE:
CHECK_ARRAYREF(sva); /* First argument is a set as array ref */
ava = (AV*) SvRV(sva);
alen = av_count(ava);
if (alen == 0 || items < 2)
RETURN_NPARITY(0);
PREINIT:
AV *ava;
Size_t alen, blen, i;
UV *rb;
int btype, bstatus;
PPCODE:
CHECK_ARRAYREF(sva);
ava = (AV*) SvRV(sva);
alen = av_count(ava);
if (items < 2)
RETURN_NPARITY(0);
void is_sidon_set(IN SV* sva)
PROTOTYPE: $
PREINIT:
int ret;
PPCODE:
if (xs_is_sidon_set(aTHX_ sva, &ret))
RETURN_NPARITY(ret);
DISPATCHPP_RETURN();
void is_sumfree_set(IN SV* sva)
PROTOTYPE: $
PREINIT:
int ret;
PPCODE:
if (xs_is_sumfree_set(aTHX_ sva, &ret))
RETURN_NPARITY(ret);
DISPATCHPP_RETURN();
void toset(...)
PROTOTYPE: @
PREINIT:
int type;
size_t len;
UV *L;
PPCODE:
if (items == 0) RETURN_EMPTY_SET_REF();
if (items == 1 && SvROK(ST(0)) && SvTYPE(SvRV(ST(0))) == SVt_PVAV)
croak("toset: expected integer list, not array reference");
type = array_to_int_array(aTHX_ &len, &L, 1, &ST(0), items);
if (type != IARR_TYPE_BAD)
vecrsort = 1
PREINIT:
int type;
size_t len;
UV *L;
PPCODE:
if (items == 0)
RETURN_NOTHING();
if (SvROK(ST(0)) && SvTYPE(SvRV(ST(0))) == SVt_PVAV) {
if (items != 1)
croak("%s: expected integer list or single array reference", SUBNAME);
int type;
size_t i, len;
UV *L;
SV **arr;
AV *ava;
PPCODE:
CHECK_ARRAYREF(sva);
ava = (AV*) SvRV(sva);
CHECK_AV_NOT_READONLY(ava); /* We intend to modify it */
if (SvMAGICAL(ava) || !AvREAL(ava)) /* Punt these to Perl */
DISPATCHPP_RETURN();
void numtoperm(IN SV* svn, IN SV* svk)
PREINIT:
UV k, n, fn;
int nstatus, kstatus;
int i, S[32];
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_ANY);
if (nstatus != 0 && kstatus != 0 && n < 32) {
if (n == 0)
RETURN_NOTHING();
void permtonum(IN SV* svp)
PREINIT:
UV val, num;
Size_t i, plen;
DECL_ARREF(avp);
PPCODE:
USE_ARREF(avp, svp, SUBNAME, AR_READ);
plen = len_avp;
if (plen <= 20) {
int V[21], A[21] = {0};
for (i = 0; i < plen; i++) {
void randperm(IN SV* svn, IN SV* svk = 0)
PREINIT:
int nstatus, kstatus;
UV n, k, i, *S;
dMY_CXT;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (items == 1) { kstatus = nstatus; k = nstatus ? n : 0; }
else { kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG);}
if (nstatus == 0)
DISPATCHPP_RETURN();
PROTOTYPE: @
PREINIT:
SSize_t i, j;
void* randcxt;
dMY_CXT;
PPCODE:
if (GIMME_V != G_ARRAY) XSRETURN_IV(items);
if (items == 0) XSRETURN_EMPTY;
for (i = 0, randcxt = MY_CXT.randcxt; i < items-1; i++) {
j = urandomm64(randcxt, items-i);
{ SV* t = ST(i); ST(i) = ST(i+j); ST(i+j) = t; }
PREINIT:
void *randcxt;
UV k;
Size_t nitems, i;
dMY_CXT;
PPCODE:
if (_validate_and_set(&k, aTHX_ svk, IFLAG_NONNEG) != 1)
DISPATCHPP_RETURN();
if (items == 1 || k == 0)
RETURN_NOTHING();
randcxt = MY_CXT.randcxt;
void is_happy(SV* svn, UV base = 10, UV k = 2)
PREINIT:
UV n, sum;
int h, status;
PPCODE:
if (base < 2 || base > 36) croak("%s: invalid base: %"UVuf, SUBNAME, base);
if (k > 10) croak("%s: invalid exponent %"UVuf, SUBNAME, k);
status = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
if (status == 0 && base == 10) { /* String op to reduce into range. */
STRLEN i, len;
sumdigits(SV* svn, SV* svbase = 0)
PREINIT:
UV sum, base = 10;
STRLEN i, len;
const char* s;
PPCODE:
SvGETMAGIC(svn);
if (!SvOK(svn)) croak("Parameter must be defined");
if (items > 1 && !_validate_and_set(&base, aTHX_ svbase, IFLAG_NONNEG))
DISPATCHPP_RETURN();
if (base < 2 || base > 36) croak("%s: invalid base: %"UVuf, SUBNAME, base);
void reverse_digits(SV* svn, SV* svbase = 0)
PREINIT:
int nstatus, bstatus = 1;
UV n, base = 10, r = 0;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (items > 1)
bstatus = _validate_and_set(&base, aTHX_ svbase, IFLAG_NONNEG);
if (base < 2) croak("%s: invalid base: %"UVuf, SUBNAME, base);
if (nstatus == 1 && bstatus == 1) {
ALIAS:
todigitstring = 1
PREINIT:
int nstatus, bstatus, lstatus, tlen, i;
UV n, base;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
bstatus = lstatus = 1;
base = 10;
tlen = -1;
if (items > 1) {
int bstatus;
UV n, base;
STRLEN slen, rlen;
char *s, *str;
int status;
PPCODE:
SvGETMAGIC(svn);
if (!SvOK(svn)) croak("Parameter must be defined");
bstatus = 1;
base = 10;
if (items > 1)
void is_harshad(SV* svn, SV* svbase = 0)
PREINIT:
int nstatus, bstatus;
UV n, base;
PPCODE:
if (items == 1) { bstatus = 1; base = 10; }
else { bstatus = _validate_and_set(&base, aTHX_ svbase, IFLAG_NONNEG); }
if (bstatus == 1) {
if (base < 2) croak("%s: invalid base: %"UVuf, SUBNAME, base);
if (base <= UINT32_MAX) {
void is_palindrome(SV* svn, SV* svbase = 0)
PREINIT:
int bstatus;
UV n, base;
PPCODE:
if (items == 1) { bstatus = 1; base = 10; }
else { bstatus = _validate_and_set(&base, aTHX_ svbase, IFLAG_NONNEG); }
if (bstatus == 1) {
if (base < 2) croak("%s: invalid base: %"UVuf, SUBNAME, base);
if (base <= UINT32_MAX &&
ALIAS:
mult_digital_root = 1
PREINIT:
UV n, dr, base;
int bstatus;
PPCODE:
if (items==1){bstatus = 1; base = 10;}
else {bstatus = _validate_and_set(&base,aTHX_ svbase,IFLAG_NONNEG);}
if (bstatus == 1 && _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
if (base < 2) croak("%s: invalid base: %"UVuf, SUBNAME, base);
if (n == 0) {
DISPATCHPP_RETURN();
void tozeckendorf(SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG)) {
char *str = to_zeckendorf(n);
XPUSHs(sv_2mortal(newSVpv(str, 0)));
Safefree(str);
XSRETURN(1);
void fromzeckendorf(IN SV* svstr)
PREINIT:
int status;
STRLEN len;
const char* str;
PPCODE:
SvGETMAGIC(svstr);
if (!SvOK(svstr)) croak("Parameter must be defined");
str = SvPV_nomg(svstr, len);
status = validate_zeckendorf(str, len);
if (status == 0)
void
lastfor()
PREINIT:
dMY_CXT;
PPCODE:
/* printf("last for with count = %u\n", MY_CXT.forcount); */
if (MY_CXT.forcount == 0) croak("lastfor called outside a loop");
MY_CXT.forexit = 1;
/* In some ideal world this would also act like a last */
return;
CV *subcv;
unsigned char* segment;
UV beg, end, seg_base, seg_low, seg_high;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
UV beg, end;
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
UV beg, end;
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
UV c, beg, end, shiftres;
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
UV *divs;
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG))
DISPATCHPP_RETURN_VOID();
bool doloop0, doloopn;
CV *subcv;
SV** svals;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG))
DISPATCHPP_RETURN_VOID();
if (n > (UV_MAX-2)) croak("%s: argument overflow", SUBNAME);
CV *subcv;
SV** svals;
UV* cm;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG);
kstatus = 1;
if (nstatus != 0) {
CV *subcv;
SV** svals;
UV* cm;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_NONNEG))
DISPATCHPP_RETURN_VOID();
SV ***arsvs;
CV *subcv;
forsetproduct_guard_t *fsguard;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
narrays = items-1;
if (narrays < 1) XSRETURN(0);
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
SV* svals[64];
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
unsigned char* isf;
SV* svarg; /* We use svarg to prevent clobbering $_ outside the block */
CV *subcv;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&beg, aTHX_ svbeg, IFLAG_NONNEG) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_NONNEG)))
DISPATCHPP_RETURN_VOID();
SSize_t i, j, nlist, step, size, numret;
UV ustep, usize;
CV *subcv;
SV **list;
AV *list_av, *result_av;
PPCODE:
{ /* Generalized sliding window: block, step, size, list.
Each window of 'size' elements is passed as @_ to block;
all return values are collected and returned (like map). */
SETSUBREF(subcv, block);
AV *result_av;
GV *agv, *bgv;
SV *atmp, *btmp;
DECL_ARREF(arr1);
DECL_ARREF(arr2);
PPCODE:
{ /* Similar to pairwise from List::MoreUtils, but block values do not alias inputs. */
SETSUBREF(subcv, block);
if (!SvROK(sva) || SvTYPE(SvRV(sva)) != SVt_PVAV ||
!SvROK(svb) || SvTYPE(SvRV(svb)) != SVt_PVAV)
vecany = 2
vecnotall = 3
vecfirst = 4
vecfirstidx = 6
PROTOTYPE: &@
PPCODE:
{ /* This is very similar to List::Util. Try to maintain compat. */
int ret_true = !(ix & 2); /* return true at end of loop for none/all; false for any/notall */
int invert = (ix & 1); /* invert block test for all/notall */
SSize_t index;
SV **args = &PL_stack_base[ax];
void vecuniq(...)
PROTOTYPE: @
PREINIT:
int typemask, retvals;
SSize_t j;
PPCODE:
retvals = (GIMME_V != G_SCALAR && GIMME_V != G_VOID);
/* Check all inputs to see if we can quickly process as an iset. */
for (j = 0, typemask = 0; j < items; j++) {
SV *sv = ST(j);
PROTOTYPE: @
PREINIT:
int itype;
size_t len, i, retlen;
UV *L, count;
PPCODE:
if (items == 0)
RETURN_NOTHING();
/* Try to read native integers. Bail to PP if something else. */
len = (size_t) items;
New(0, L, len, UV);
PREINIT:
int itype;
size_t len, i, retlen, count;
UV *L;
iset_t seen, dups;
PPCODE:
if (items == 0)
RETURN_NOTHING();
/* Try to read native integers. Bail to PP if something else. */
len = (size_t) items;
New(0, L, len, UV);
Math-Prime-XS
view release on metacpan or search on metacpan
unsigned long number
unsigned long base
PROTOTYPE: $$
INIT:
unsigned long i, n;
PPCODE:
/* For the sqrt(), casting double->ulong probably follows the fpu
rounding mode, so might round either up or down. If up then the
last trial division may be unnecessary, but not harmful.
*/
xs_sieve_count_primes = 1
INIT:
unsigned long *composite = NULL;
unsigned long i, n;
unsigned long count = 0;
PPCODE:
const unsigned long square_root = sqrt (number); /* truncates */
const unsigned int size_bits = sizeof (unsigned long) * BYTE_BITS;
Newxz (composite, (BIT_VECTOR (number) / size_bits) + 1, unsigned long);
PROTOTYPE: $$
INIT:
unsigned long *primes = NULL, *sums = NULL;
unsigned int pos = 0;
unsigned long n;
PPCODE:
for (n = 2; n <= number; n++)
{
bool is_prime = TRUE;
const unsigned long square_root = sqrt (n); /* truncates */
unsigned int c;
INIT:
unsigned long *primes = NULL;
unsigned int pos = 0;
unsigned long start = 1;
unsigned long i, n;
PPCODE:
for (n = 2; n <= number; n++)
{
bool is_prime = TRUE;
unsigned long square_root; /* calculate later for efficiency */
if (n > 2 && EVEN_NUM (n))
Math-Random-BlumBlumShub
view release on metacpan or search on metacpan
BlumBlumShub.xs view on Meta::CPAN
mpz_t * q
mpz_t * seed
int bits_required
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
bbs(outref, p, q, seed, bits_required);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
BlumBlumShub.xs view on Meta::CPAN
mpz_t * seed
mpz_t * p
mpz_t * q
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
bbs_seedgen(seed, p, q);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
BlumBlumShub.xs view on Meta::CPAN
autocorrelation (bitstream, offset)
mpz_t * bitstream
int offset
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
autocorrelation(aTHX_ bitstream, offset);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Random-Brownian
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Math-Random-MTwist
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
void
DESTROY(mt_state* state)
PPCODE:
Safefree(state);
UV
seed32(mt_state* state, uint32_t seed)
CODE:
void
bestseed(mt_state* state)
void
_bestseed()
PPCODE:
bestseed(NULL);
void
seedfull(mt_state* state, AV* seeds)
PPCODE:
seedfull(state, seeds);
void
_seedfull(AV* seeds)
PPCODE:
seedfull(NULL, seeds);
SV*
irand32(mt_state* state);
ALIAS:
void
rd_double(mt_state* state, int index = 0)
PREINIT:
int2dbl i2d;
PPCODE:
i2d = rd_double(state);
RETURN_I2D(items > 1);
void
_rd_double(int index = 0)
PREINIT:
int2dbl i2d;
PPCODE:
i2d = rd_double(NULL);
RETURN_I2D(items != 0);
IV
rd_iuniform32(mt_state* state, IV lower, IV upper);
OUTPUT:
RETVAL
void
setstate(mt_state* state, SV* sv_state)
PPCODE:
set_state_from_sv(sv_state, state);
void
_setstate(SV* sv_state)
PPCODE:
set_state_from_sv(sv_state, &mt_default_state);
BOOT:
{
HV *stash;
Math-Random-MicaliSchnorr
view release on metacpan or search on metacpan
MicaliSchnorr.xs view on Meta::CPAN
SV * exp
mpz_t * p
mpz_t * q
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ms_seedgen(aTHX_ seed, exp, p, q);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
MicaliSchnorr.xs view on Meta::CPAN
mpz_t * seed
SV * exp
int bits_required
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ms(aTHX_ outref, p, q, seed, exp, bits_required);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
MicaliSchnorr.xs view on Meta::CPAN
autocorrelation (bitstream, offset)
mpz_t * bitstream
int offset
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
autocorrelation(aTHX_ bitstream, offset);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Random-PCG32
view release on metacpan or search on metacpan
lib/Math/Random/PCG32.xs view on Meta::CPAN
void
irand_way(pcg32_random_t *rng, int32_t x1, int32_t y1, int32_t x2, int32_t y2)
PREINIT:
int32_t dx, dy, magx;
PPCODE:
if (x1 == x2 && y1 == y2) XSRETURN_UNDEF;
EXTEND(SP, 2);
dx = x2 - x1;
dy = y2 - y1;
if (dx == 0) goto MOVE_Y;
lib/Math/Random/PCG32.xs view on Meta::CPAN
AV *avref;
PREINIT:
AV* smpl;
SSize_t len, i;
uint32_t total;
PPCODE:
smpl = newAV();
len = av_len(avref) + 1;
if (len == 0 || count == 0) goto DONE;
if (count >= len) {
av_extend(smpl, len - 1);
lib/Math/Random/PCG32.xs view on Meta::CPAN
ST(0) = sv_2mortal( newRV_inc((SV *) smpl) );
XSRETURN(1);
void
DESTROY(pcg32_random_t *rng)
PPCODE:
Safefree(rng);
Math-Random
view release on metacpan or search on metacpan
char * phrase
PROTOTYPE: $
PREINIT:
long newseed1;
long newseed2;
PPCODE:
phrtsd(phrase,&newseed1,&newseed2);
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSViv(newseed1)));
PUSHs(sv_2mortal(newSViv(newseed2)));
random_get_seed ()
PROTOTYPE:
PREINIT:
long newseed1;
long newseed2;
PPCODE:
getsd(&newseed1,&newseed2);
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSViv(newseed1)));
PUSHs(sv_2mortal(newSViv(newseed2)));
Math-RngStream
view release on metacpan or search on metacpan
RngStream.xs view on Meta::CPAN
void
get_state(RngStream G)
PREINIT:
unsigned long seed[6];
int i;
PPCODE:
RngStream_GetState(G, seed);
EXTEND(SP, 6);
for (i = 0; i++; i < 6)
PUSHs(sv_2mortal(newSVuv(seed[i])));
XSRETURN(6);
Math-SO3
view release on metacpan or search on metacpan
# XXX have to put a bit more thought into this. Does it really work that way,
# or did I still miss a point?
void
turning_angle_and_dir(...)
PPCODE:
{
double angle, *dir, v2[3], v3[3], norm;
char *cdir;
if( (items!=1 && items != 2)
# otherwise use [2][0] and [2][1] elements.
void
euler_angles_zxz(...)
PPCODE:
{
if( (items!=1 && items!=2)
|| SvTYPE(SvRV(ST(0)))!=SVt_PVMG)
{
croak(croak_euler_angles_zxz);
#
# => heading=0, roll=atan2(sin_roll, cos_roll)
void
euler_angles_yxz(...)
PPCODE:
{
int i;
double heading, pitch, roll, cos_heading, cos_pitch, cos_roll, sin_heading, sin_pitch, sin_roll;
Math__SO3 so3;
Math-SimpleHisto-XS
view release on metacpan or search on metacpan
void
all_bin_contents(self)
simple_histo_1d* self
PREINIT:
SV* rv;
PPCODE:
rv = histo_data_av(aTHX_ self);
XPUSHs(sv_2mortal(rv));
void
set_all_bin_contents(self, new_data)
void
set_bin_content(self, ibin, content)
simple_histo_1d* self
unsigned int ibin
double content
PPCODE:
/* Would be nicer in the API, but again, this is faster. */
HS_ASSERT_BIN_RANGE(self, ibin);
HS_INVALIDATE_CUMULATIVE(self);
self->total += content - self->data[ibin];
self->data[ibin] = content;
void
set_underflow(self, content)
simple_histo_1d* self
double content
PPCODE:
/* This doesn't invalidate the INTERNAL cumulative histo */
self->underflow = content;
void
set_overflow(self, content)
simple_histo_1d* self
double content
PPCODE:
/* This doesn't invalidate the INTERNAL cumulative histo */
self->overflow = content;
void
set_nfills(self, nfills)
simple_histo_1d* self
unsigned int nfills
PPCODE:
/* This doesn't invalidate the INTERNAL cumulative histo */
self->nfills = nfills;
#void
# PREINIT:
# char* out;
# SV* outSv;
# double* tmp;
# unsigned int size;
# PPCODE:
# size = sizeof(simple_histo_1d) + sizeof(double)*self->nbins;
# outSv = newSVpvs("");
# SvGROW(outSv, size+1);
# printf(" %u\n", SvLEN(outSv));
# out = SvPVX(outSv);
SV* rngsv;
Math__SimpleHisto__XS__RNG rng;
unsigned int ibin;
PREINIT:
simple_histo_1d* cum_hist;
PPCODE:
if (items > 1) {
rngsv = ST(1);
}
else {
rngsv = get_sv("Math::SimpleHisto::XS::RNG::Gen", 0);
_get_info(self)
simple_histo_1d* self
PREINIT:
SV* data_ary;
SV* bins_ary;
PPCODE:
/* min, max, nbins, nfills, overflow, underflow, dataref, binsref*/
EXTEND(SP, 8);
mPUSHn(self->min);
mPUSHn(self->max);
mPUSHu(self->nbins);
Math-String-Charset-Wordlist
view release on metacpan or search on metacpan
Wordlist.xs view on Meta::CPAN
long buffer[BUFFER_SIZE];
unsigned char read_buffer[READ_BUFFER_SIZE];
long buffered, idx, base, ofs;
size_t read;
PPCODE:
name = SvPVX(n); /* get ptr to storage */
len = sizeof (struct Offsets);
ST(0) = newSV(len); /* alloc enough to store one ptr */
SvPOK_on(ST(0));
Wordlist.xs view on Meta::CPAN
_records(ptr)
SV* ptr
INIT:
struct Offsets* offset;
PPCODE:
offset = (struct Offsets*) SvPVX(ptr); /* get ptr to storage */
ST(0) = sv_2mortal( newSVnv( offset->max_offsets ));
XSRETURN(1);
##############################################################################
Wordlist.xs view on Meta::CPAN
SV* ptr
SV* n
INIT:
long N;
struct Offsets* offset;
PPCODE:
N = SvNV(n);
offset = (struct Offsets*) SvPVX(ptr); /* get ptr to storage */
/* offset exists? */
Wordlist.xs view on Meta::CPAN
unsigned int N;
unsigned int ofs,len;
char* buf;
struct Offsets* offset;
PPCODE:
N = (int)SvNV(n);
offset = (struct Offsets*) SvPVX(ptr); /* get ptr to storage */
if (offset == NULL)
Math-TamuAnova
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
( run in 2.847 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )