Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 1.686 )
Math-ConvexHull-MonotoneChain
view release on metacpan or search on metacpan
MonotoneChain.xs view on Meta::CPAN
point_ptr_t* out_hull;
AV* inner_av;
AV* out_av;
SV** elemptr;
SV* elem;
PPCODE:
npoints = av_len(points)+1;
if (npoints <= 2) {
out_av = newAV();
av_fill(out_av, npoints-1);
for (i = 0; i < npoints; ++i) {
Math-DCT
view release on metacpan or search on metacpan
void
fct8_1d (inbuf)
char * inbuf
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fct8_1d(inbuf);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
void
fct8_2d (inbuf)
char * inbuf
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fct8_2d(inbuf);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
dct_1d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
dct_1d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
idct_1d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
idct_1d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
dct_2d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
dct_2d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
idct_2d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
idct_2d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
fast_dct_1d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fast_dct_1d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
fast_dct_2d (inbuf, size)
char * inbuf
int size
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fast_dct_2d(inbuf, size);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Decimal128
view release on metacpan or search on metacpan
Decimal128.xs view on Meta::CPAN
char * nsd
char * lsd
SV * c
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_assignME(aTHX_ a, msd, nsd, lsd, c);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.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;
Decimal128.xs view on Meta::CPAN
assignIVl (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignIVl(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
assignUVl (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignUVl(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
assignNVl (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignNVl(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
assignPVl (a, s)
SV * a
char * s
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignPVl(aTHX_ a, s);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
assignD128 (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignD128(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
void
assignNaNl (a)
SV * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignNaNl(aTHX_ a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
assignInfl (a, sign)
SV * a
int sign
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignInfl(aTHX_ a, sign);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
void
_d128_bytes (sv)
SV * sv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_d128_bytes(aTHX_ sv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.xs view on Meta::CPAN
_assignDPD (a, in)
SV * a
char * in
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_assignDPD(aTHX_ a, in);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal128.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;
Decimal128.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-Decimal64
view release on metacpan or search on metacpan
Decimal64.xs view on Meta::CPAN
LDtoD64 (d64, ld)
SV * d64
SV * ld
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
LDtoD64(aTHX_ d64, ld);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
D64toLD (ld, d64)
SV * ld
SV * d64
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
D64toLD(aTHX_ ld, d64);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.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;
Decimal64.xs view on Meta::CPAN
SV * a
char * mantissa
SV * c
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_assignME(aTHX_ a, mantissa, c);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignPV (a, s)
SV * a
char * s
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignPV(aTHX_ a, s);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignIV (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignIV(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignUV (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignUV(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignNV (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignNV(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignD64 (a, val)
SV * a
SV * val
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignD64(aTHX_ a, val);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
void
assignNaN (a)
SV * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignNaN(aTHX_ a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
assignInf (a, sign)
SV * a
int sign
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
assignInf(aTHX_ a, sign);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
void
_d64_bytes (sv)
SV * sv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_d64_bytes(aTHX_ sv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
void
_bid_mant (bin)
SV * bin
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_bid_mant(aTHX_ bin);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.xs view on Meta::CPAN
_assignDPD (a, in)
SV * a
char * in
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_assignDPD(aTHX_ a, in);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Decimal64.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;
Decimal64.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-Derivative_XS
view release on metacpan or search on metacpan
Derivative_XS.xs view on Meta::CPAN
Derivative2(x, y, yp1_sv = NULL, ypn_sv = NULL)
AV * x
AV * y
SV * yp1_sv
SV * ypn_sv
PPCODE:
{
int i;
int n = av_len(x);
NV * y2 = calloc(n, sizeof(NV));
NV * u = calloc(n, sizeof(NV));
Math-Factor-XS
view release on metacpan or search on metacpan
unsigned long number
PROTOTYPE: $
INIT:
unsigned long i, square_root;
AV *factors;
PPCODE:
/* range check */
{
double d = SvNV(ST(0));
if (! (d >= 0 && d < double_ulong_max_plus_1)) {
croak ("Cannot factors() on %g", d);
unsigned long *prev_base = NULL;
unsigned int b, c, p = 0;
unsigned int top = items - 1;
bool Skip_multiples = FALSE;
bool skip = FALSE;
PPCODE:
factors = (AV*)SvRV (factors_aref);
if (av_len (factors) == -1)
XSRETURN_EMPTY;
count_prime_factors = 1
INIT:
unsigned long i, limit;
unsigned incr;
unsigned long count = 0;
PPCODE:
/* range check */
{
double d = SvNV(ST(0));
if (! (d >= 0 && d < double_ulong_max_plus_1)) {
croak ("Cannot prime_factors() on %g", d);
Math-FakeBfloat16
view release on metacpan or search on metacpan
FakeBfloat16.xs view on Meta::CPAN
void
_unpack_float (in)
SV * in
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_unpack_float(in);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-FakeDD
view release on metacpan or search on metacpan
void
dd_frexp (nv)
SV * nv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
dd_frexp(aTHX_ nv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-FakeFloat16
view release on metacpan or search on metacpan
FakeFloat16.xs view on Meta::CPAN
void
_unpack_float (in)
SV * in
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_unpack_float(in);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Math-Float128
view release on metacpan or search on metacpan
Float128.xs view on Meta::CPAN
void
flt128_set_prec (x)
int x
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
flt128_set_prec(aTHX_ x);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.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;
Float128.xs view on Meta::CPAN
fromSTR (f, str)
float128 * f
SV * str
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fromSTR(aTHX_ f, str);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
fromNV (f, nv)
float128 * f
SV * nv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fromNV(aTHX_ f, nv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
fromIV (f, iv)
float128 * f
SV * iv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fromIV(aTHX_ f, iv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
fromUV (f, uv)
float128 * f
SV * uv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fromUV(aTHX_ f, uv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
void
F128toSTR (f)
SV * f
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
F128toSTR(aTHX_ f);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
F128toSTRP (f, decimal_prec)
SV * f
int decimal_prec
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
F128toSTRP(aTHX_ f, decimal_prec);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
void
DESTROY (f)
SV * f
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DESTROY(aTHX_ f);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
fromF128 (f, a)
float128 * f
SV * a
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fromF128(aTHX_ f, a);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
void
_f128_bytes (sv)
SV * sv
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_f128_bytes(aTHX_ sv);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
acos_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
acos_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
acosh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
acosh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
asin_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
asin_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
asinh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
asinh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
atan_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atan_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
atanh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atanh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
atan2_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
cbrt_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cbrt_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
ceil_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ceil_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
copysign_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
cosh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cosh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
cos_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
cos_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
erf_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
erf_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
erfc_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
erfc_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
exp_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
exp_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
expm1_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
expm1_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
fabs_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fabs_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fdim_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
floor_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
floor_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * op1
float128 * op2
float128 * op3
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fma_F128(rop, op1, op2, op3);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmax_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmin_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
fmod_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
hypot_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * frac
SV * exp
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
frexp_F128(aTHX_ frac, exp, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op
int pow
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
ldexp_F128(rop, op, pow);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
j0_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
j0_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
j1_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
j1_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
int n
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
jn_F128(rop, n, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
lgamma_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
lgamma_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
log_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
log10_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log10_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
log2_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log2_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
log1p_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
log1p_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * integer
float128 * frac
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
modf_F128(integer, frac, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
nan_F128 (rop, op)
float128 * rop
SV * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nan_F128(aTHX_ rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
nearbyint_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nearbyint_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
nextafter_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
pow_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
remainder_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
SV * rop2
float128 * op1
float128 * op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
remquo_F128(aTHX_ rop1, rop2, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
rint_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
rint_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
round_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
round_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
long op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
scalbln_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
float128 * op1
int op2
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
scalbn_F128(rop, op1, op2);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * sin
float128 * cos
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sincos_F128(sin, cos, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
sinh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sinh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
sin_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sin_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
sqrt_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
sqrt_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
tan_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tan_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
tanh_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tanh_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
tgamma_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
tgamma_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
trunc_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
trunc_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
y0_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
y0_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
y1_F128 (rop, op)
float128 * rop
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
y1_F128(rop, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
float128 * rop
int n
float128 * op
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
yn_F128(rop, n, op);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.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;
Float128.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;
Float128.xs view on Meta::CPAN
void
clear_nok_pok ()
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
clear_nok_pok();
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Float128.xs view on Meta::CPAN
void
set_nok_pok (x)
int x
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
set_nok_pok(x);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
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, strn);
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);
ALIAS:
urandomr = 1
PREINIT:
mpz_t lo, hi, res;
int retundef;
PPCODE:
if (strhi == 0) {
mpz_init_set_ui(lo, 0);
VALIDATE_AND_SET(hi, strlo);
} else {
if (*strlo == '+') strlo++;
ALIAS:
prime_power_count = 1
perfect_power_count = 2
PREINIT:
mpz_t n, lo, hi, res;
PPCODE:
mpz_init(res);
if (strhi == 0) {
VALIDATE_AND_SET(n, strlo);
switch (ix) {
case 0: prime_count(res, n); break;
void nth_perfect_power(IN char* strn)
ALIAS:
nth_perfect_power_approx = 1
PREINIT:
mpz_t n, res;
PPCODE:
mpz_init(res);
VALIDATE_AND_SET(n, strn);
if (ix == 0) nth_perfect_power(res, n);
else nth_perfect_power_approx(res, n);
mpz_clear(n);
void next_perfect_power(IN char* strn)
ALIAS:
prev_perfect_power = 1
PREINIT:
mpz_t n, res;
PPCODE:
mpz_init(res);
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
if (ix == 0) next_perfect_power(res, n);
else prev_perfect_power(res, n);
mpz_clear(n);
urandomm = 13
add1int = 14
sub1int = 15
PREINIT:
mpz_t res, n;
PPCODE:
if (strn != 0 && strn[0] == '-') { /* If input is negative... */
if (ix == 2) XSRETURN_IV(1); /* exp_mangoldt return 1 */
if (ix == 5) strn++; /* znprimroot flip sign */
if (ix == 8) XSRETURN_IV(0); /* is_prime_power return 0 */
}
void absint(IN char* strn)
ALIAS:
negint = 1
PREINIT:
mpz_t res;
PPCODE:
if (strn != 0 && strn[0] == '-') {
VALIDATE_AND_SET(res, strn+1);
} else {
VALIDATE_AND_SET(res, strn);
if (ix == 1) mpz_neg(res, res);
void signint(IN char* strn)
PREINIT:
mpz_t n;
int res;
PPCODE:
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
res = mpz_sgn(n);
mpz_clear(n);
XSRETURN_IV(res);
ALIAS:
cmpabsint = 1
PREINIT:
mpz_t a, b;
int res;
PPCODE:
validate_and_set_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
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_signed(cv, n, "n", strn, VSETNEG_OK);
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_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
switch (ix) {
case 0: mpz_and(a, a, b); break;
case 1: mpz_ior(a, a, b); break;
mpz_clear(b);
void bitnot(IN char* strn)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
mpz_com(n, n);
XPUSH_MPZ(n);
mpz_clear(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, strn);
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) ? VSETNEG_ABS : VSETNEG_OK;
if (ix == 1 || ix == 3) {
mpz_t* list;
New(0, list, items, mpz_t);
void
moebius(IN char* strn, IN char* stro = 0)
PREINIT:
mpz_t n;
PPCODE:
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
if (stro == 0) {
int result = moebius(n);
mpz_clear(n);
XSRETURN_IV(result);
ALIAS:
lucasv = 1
lucasuv = 2
PREINIT:
mpz_t u, v, p, q, k;
PPCODE:
validate_and_set_signed(cv, p, "P", strp, VSETNEG_OK);
validate_and_set_signed(cv, q, "Q", strq, VSETNEG_OK);
VALIDATE_AND_SET(k, strk);
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_signed(cv, p, "P", strp, VSETNEG_OK);
validate_and_set_signed(cv, q, "Q", strq, VSETNEG_OK);
VALIDATE_AND_SET(k, strk);
validate_and_set_signed(cv, n, "N", strn, VSETNEG_ABS);
if (mpz_cmpabs_ui(n,1) <= 0) {
prev_powerfree = 1
nth_powerfree = 2
PREINIT:
mpz_t n;
int retundef;
PPCODE:
VALIDATE_AND_SET(n, strn);
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;
factorialmod = 22
multifactorial = 23
PREINIT:
mpz_t a, b, t;
int retundef;
PPCODE:
validate_and_set_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
retundef = 0;
switch (ix) {
/* 0 if b is 1, else undef if a|b = 0, else mpz_invert */
void
binomialmod(IN char* strn, IN char* strk, IN char* strm)
PREINIT:
mpz_t n, k, m, r;
unsigned long nu, ku;
PPCODE:
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
validate_and_set_signed(cv, k, "k", strk, VSETNEG_OK);
validate_and_set_signed(cv, m, "m", strm, VSETNEG_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_signed(cv, x, "x", strx, VSETNEG_OK);
validate_and_set_signed(cv, n, "n", strn, VSETNEG_ABS);
mpz_init(r);
if (ix == 0) falling_factorial(r, x, n);
else rising_factorial(r, x, n);
void powersum(IN char* stra, IN char* strb)
ALIAS:
faulhaber_sum = 1
PREINIT:
mpz_t a, b;
PPCODE:
validate_and_set_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
if (mpz_sgn(a) < 0 || mpz_sgn(b) < 0) croak("powersum: negative argument");
if (ix == 0 || ix == 1)
faulhaber_sum(a, a, mpz_get_ui(b));
rshiftint = 1
rashiftint = 2
PREINIT:
mpz_t n;
int nix;
PPCODE:
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
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_signed(cv, n, "n", strn, VSETNEG_OK);
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;
mpz_clear(n);
void negmod(IN char* stra, IN char* strn)
PREINIT:
mpz_t a, n;
PPCODE:
validate_and_set_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, n, "n", strn, VSETNEG_OK);
if (mpz_sgn(n) == 0) {
mpz_clear(n); mpz_clear(a);
XSRETURN_UNDEF;
powmod = 3
divmod = 4
PREINIT:
mpz_t a, b, n;
int retundef;
PPCODE:
validate_and_set_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
validate_and_set_signed(cv, n, "n", strn, VSETNEG_ABS);
retundef = (mpz_sgn(n) <= 0);
if (!retundef && ix == 4) {
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_signed(cv, a, "a", stra, VSETNEG_OK);
validate_and_set_signed(cv, b, "b", strb, VSETNEG_OK);
validate_and_set_signed(cv, c, "c", strc, VSETNEG_OK);
validate_and_set_signed(cv, n, "n", strn, VSETNEG_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);
pn_primorial = 14
consecutive_integer_lcm = 15
PREINIT:
mpz_t p;
char* proof;
PPCODE:
if (ix == 8 && n <= BITS_PER_WORD) {
UV v = irand64(n);
ST(0) = sv_2mortal(newSVuv(v));
XSRETURN(1);
}
void
stirling(IN UV n, IN UV m, IN UV type = 1)
PREINIT:
mpz_t r;
PPCODE:
mpz_init(r);
stirling(r, n, m, type);
XPUSH_MPZ( r );
mpz_clear(r);
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_signed(cv, k, "k", strk, VSETNEG_OK);
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, strlow);
VALIDATE_AND_SET(high, strhigh);
mpz_init(seghigh);
mpz_init(t);
void
sieve_range(IN char* strn, IN UV width, IN UV depth)
PREINIT:
mpz_t low, seghigh, high, t;
UV i, nprimes, maxseg, offset, *list;
PPCODE:
if (width == 0) XSRETURN(0);
if (depth == 0) depth = 1;
VALIDATE_AND_SET(low, strn);
mpz_init(high);
void
lucas_sequence(IN char* strn, IN IV P, IN IV Q, IN char* strk)
PREINIT:
mpz_t U, V, Qk, n, k, t;
PPCODE:
VALIDATE_AND_SET(n, strn);
VALIDATE_AND_SET(k, strk);
mpz_init(U); mpz_init(V); mpz_init(Qk); mpz_init(t);
lucas_seq(U, V, n, P, Q, k, Qk, t);
XPUSH_MPZ(U);
mpz_t n;
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, strn);
{
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;
PPCODE:
VALIDATE_AND_SET(n, strn);
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, strn);
if (strk == 0) {
mpz_init_set(k, n);
} else {
VALIDATE_AND_SET(k, strk);
void
sigma(IN char* strn, IN UV k = 1)
PREINIT:
mpz_t n;
PPCODE:
VALIDATE_AND_SET(n, strn);
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);
if (strn[0] == '-' || strn[0] == '+') strn++;
validate_string_number(cv, "n", strn);
if (base == 10) {
uint32_t l = strlen(strn);
PREINIT:
AV *av;
int i, plen;
uint32_t *digits;
mpz_t n;
PPCODE:
if (base < 2 || base > 0xFFFFFFFFU) croak("invalid base: %u\n", base);
mpz_init(n);
if (!SvROK(svp)) { /* string */
fromdigits_str(n, SvPV_nolen(svp), base);
} else {
Math-Prime-Util
view release on metacpan or search on metacpan
void
CLONE(...)
PREINIT:
int i;
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++) {
void csrand(IN SV* seed = 0)
PREINIT:
unsigned char* data;
STRLEN size;
dMY_CXT;
PPCODE:
if (items == 0) {
csprng_init_seed(MY_CXT.randcxt);
} else if (_XS_get_secure()) {
croak("secure option set, manual seeding disabled");
} else {
RETVAL
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) DISPATCH_VOIDPP();
XSRETURN(0);
prime_precalc(IN UV n)
ALIAS:
_XS_set_verbose = 1
_XS_set_callgmp = 2
_end_for_loop = 3
PPCODE:
PUTBACK; /* SP is never used again, the 3 next func calls are tailcall
friendly since this XSUB has nothing to do after the 3 calls return */
switch (ix) {
case 0: prime_precalc(n); break;
case 1: _XS_set_verbose(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_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
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_POS)) {
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;
void sum_primes(IN SV* svlo, IN SV* svhi = 0)
PREINIT:
UV lo = 2, hi;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
UV count = 0;
int retok = 1;
/* 32/64-bit, Legendre or table-accelerated sieving. */
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_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
ret = random_prime(MY_CXT.randcxt,lo,hi);
if (ret) XSRETURN_UV(ret);
else XSRETURN_UNDEF;
XSRETURN(1);
void print_primes(IN SV* svlo, IN SV* svhi = 0, IN int infd = -1)
PREINIT:
UV lo = 2, hi;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_POS)) ||
(items >= 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
if (lo <= hi) {
int fd = (infd == -1) ? fileno(stdout) : infd;
print_primes(lo, hi, fd);
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;
void primes(IN SV* svlo, IN SV* svhi = 0)
PREINIT:
AV* av;
UV lo = 0, hi, i;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
CREATE_RETURN_AV(av);
if ((lo <= 2) && (hi >= 2)) av_push(av, newSVuv( 2 ));
if ((lo <= 3) && (hi >= 3)) av_push(av, newSVuv( 3 ));
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_POS)) ||
(items >= 3 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
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_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
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_POS)) ||
(items == 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
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_POS)) {
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_POS) == 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 UV k = 2)
PREINIT:
AV* av;
UV lo = 1, hi, i, npowerful, *powerful;
PPCODE:
if ((items == 1 && _validate_and_set(&hi, aTHX_ svlo, IFLAG_POS)) ||
(items >= 2 && _validate_and_set(&lo, aTHX_ svlo, IFLAG_POS) && _validate_and_set(&hi, aTHX_ svhi, IFLAG_POS))) {
CREATE_RETURN_AV(av);
powerful = powerful_numbers_range(&npowerful, lo, hi, k);
for (i = 0; i < npowerful; i++)
void
sieve_range(IN SV* svn, IN UV width, IN UV depth)
PREINIT:
int status;
UV i, n;
PPCODE:
/* Return index of every n unless it is a composite with factor > depth */
status = _validate_and_set(&n, aTHX_ svn, IFLAG_POS);
if (status == 1) {
if ((n+width) < n) {
status = 0; /* range will overflow */
sieve_prime_cluster(IN SV* svlo, IN SV* svhi, ...)
PREINIT:
uint32_t nc, cl[100];
UV i, lo, hi, cval, nprimes, *list;
int done;
PPCODE:
nc = items-1;
if (items > 100) croak("sieve_prime_cluster: too many entries");
cl[0] = 0;
for (i = 1; i < nc; i++) {
if (!_validate_and_set(&cval, aTHX_ ST(1+i), IFLAG_POS))
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 == 2 && !(n&1)) {
is_chen_prime = 14
is_mersenne_prime = 15
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 status, ret;
UV n;
PPCODE:
/* k is a UV, so always positive. */
/* ix = 0 k = 0 - 3 n below 2 returns 0 for all k
* ix = 1 k = 0 - 256 n below 2 returns 0 for all k
* ix = 2 k = 0 - 2^32 n below 2 returns 0 for all k
*/
void
is_frobenius_pseudoprime(IN SV* svn, IN IV P = 0, IN IV Q = 0)
PREINIT:
int status;
UV n;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status != 0)
RETURN_NPARITY((status == 1) ? is_frobenius_pseudoprime(n, P, Q) : 0);
DISPATCHPP();
XSRETURN(1);
miller_rabin_random(IN SV* svn, IN IV bases = 1, IN char* seed = 0)
PREINIT:
int status;
UV n;
dMY_CXT;
PPCODE:
if (bases < 0) croak("miller_rabin_random: expected positive number of bases");
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == -1) RETURN_NPARITY(0);
if (seed == 0 && status == 1)
RETURN_NPARITY( is_mr_random(MY_CXT.randcxt, n, bases) );
XSRETURN(1);
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) {
vecsum = 4
vecprod = 5
PREINIT:
int i, status = 1;
UV ret, nullv, n;
PPCODE:
if (ix == 2 || ix == 3) {
UV retindex = 0;
int sign, minmax = (ix == 2);
if (items == 0) XSRETURN_UNDEF;
if (items == 1) XSRETURN(1);
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, index;
DECL_ARREF(mav);
void
vecequal(IN SV* a, IN SV* b)
PREINIT:
int res;
PPCODE:
res = _compare_array_refs(aTHX_ a, b);
if (res == -1)
croak("vecequal: expected scalar or array reference");
RETURN_NPARITY(res);
XSRETURN(1);
PREINIT:
char *setv;
int i, status = 1;
UV min, n;
uint32_t mask;
PPCODE:
if (ix == 0) {
min = 0;
mask = IFLAG_POS;
} 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 | IFLAG_NONZERO)) break;
if (n == 1) { found1 = 1; break; }
PREINIT:
int i, status, astatus, nstatus;
UV ret, lcm, *an;
SV **psva, **psvn;
SV *svfirstmod;
PPCODE:
status = 1;
New(0, an, 2*items, UV);
ret = 0;
svfirstmod = 0;
for (i = 0; i < items; i++) {
XSRETURN(1 + ix);
void cornacchia(IN SV* svd, IN SV* svn)
PREINIT:
UV d, n, x, y;
PPCODE:
if (_validate_and_set(&d, aTHX_ svd, IFLAG_POS) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_POS) ) {
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;
PPCODE:
if (items != 4) croak("lucas_sequence: n, P, Q, k");
if (_validate_and_set(&n, aTHX_ ST(0), IFLAG_POS | IFLAG_NONZERO) &&
_validate_and_set(&P, aTHX_ ST(1), IFLAG_ANY | IFLAG_IV) &&
_validate_and_set(&Q, aTHX_ ST(2), IFLAG_ANY | IFLAG_IV) &&
_validate_and_set(&k, aTHX_ ST(3), IFLAG_POS)) {
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_POS) &&
_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_POS) &&
lucasuv(&U, &V, P, Q, k)) {
if (ix == 1) XSRETURN_IV(U); /* U = lucasu(P,Q,k) */
void is_sum_of_squares(IN SV* svn, IN UV k = 2)
PREINIT:
int status, ret;
UV n;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
if (status != 0) {
switch (k) {
case 0: ret = (n==0); break;
case 1: ret = is_power(n,2); break;
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_power(n,2); 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) );
powerfree_part = 2
powerfree_part_sum = 3
PREINIT:
int status;
UV n, res;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == -1) {
n = neg_iv(n);
if (ix == 2)
XSRETURN_IV( neg_iv(powerfree_part(n,k)) );
ALIAS:
nth_powerfree = 1
PREINIT:
int status;
UV n, res;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, (ix==0) ? IFLAG_ANY : IFLAG_POS);
if (status != 0) {
if (status == -1)
XSRETURN_UV(0);
if (ix == 0) {
is_power(IN SV* svn, IN UV k = 0, IN SV* svroot = 0)
PREINIT:
int status, ret;
UV n;
uint32_t root;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status != 0) {
if (k != 0) {
if (status == -1) {
if (k % 2 == 0) RETURN_NPARITY(0); /* negative n even k return 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 (status != 0) {
ret = (status == 1) ? prime_power(n, &root) : 0;
if (ret && svroot != 0) {
if (!SvROK(svroot))croak("is_prime_power: second argument not a scalar reference");
void
is_polygonal(IN SV* svn, IN UV k, IN SV* svroot = 0)
PREINIT:
UV n;
int status;
PPCODE:
if (svroot != 0 && !SvROK(svroot))
croak("is_polygonal: third argument not a scalar reference");
if (k < 3)
croak("is_polygonal: k must be >= 3");
void inverse_li(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
if (n < MPU_MAX_PRIME_IDX) /* Fall through to Perl if out of range. */
XSRETURN_UV(inverse_li(n));
}
DISPATCHPP();
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_POS) &&
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_POS) &&
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_POS) &&
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_POS) &&
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_POS) &&
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_POS) &&
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_POS) &&
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_POS)
&& !(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);
XSRETURN(1);
void next_chen_prime(IN SV* svn)
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
ret = next_chen_prime(n);
if (ret != 0) XSRETURN_UV(ret);
}
DISPATCHPP();
random_strong_prime = 9
PREINIT:
UV res, minarg;
dMY_CXT;
void* cs;
PPCODE:
switch (ix) {
case 1: minarg = 1; break;
case 2: minarg = 4; break;
case 3: minarg = 3; break;
case 4: minarg = 3; break;
XSRETURN(1);
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);
}
ALIAS:
partitions = 1
consecutive_integer_lcm = 2
PREINIT:
UV n, r = 0;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
switch (ix) {
case 0: r = pisano_period(n); break;
case 1: r = npartitions(n); break;
case 2: r = consecutive_integer_lcm(n); break;
XSRETURN(1);
void random_factored_integer(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS | IFLAG_NONZERO)) {
dMY_CXT;
int f, nf, flip;
UV r, F[MPU_MAX_FACTORS+1];
AV* av = newAV();
void contfrac(IN SV* svnum, IN SV* svden)
PREINIT:
UV num, den;
int nstatus;
PPCODE:
nstatus = _validate_and_set(&num, aTHX_ svnum, IFLAG_ANY);
/* TODO: handle negative numerator */
if (nstatus == 1 && _validate_and_set(&den, aTHX_ svden, IFLAG_POS | IFLAG_NONZERO)) {
UV *cf, rem;
int i, steps = contfrac(&cf, &rem, num, den);
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) {
ALIAS:
next_stern_brocot = 1
PREINIT:
UV num, den;
int status;
PPCODE:
if (_validate_and_set(&num, aTHX_ svnum, IFLAG_POS | IFLAG_NONZERO) && _validate_and_set(&den, aTHX_ svden, IFLAG_POS | IFLAG_NONZERO)) {
switch (ix) {
case 0: status = next_calkin_wilf(&num, &den); break;
case 1: status = next_stern_brocot(&num, &den); break;
default: status = 0; 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 | IFLAG_NONZERO) && _validate_and_set(&den, aTHX_ svden, IFLAG_POS | IFLAG_NONZERO)) {
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 | IFLAG_NONZERO)) {
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;
XSRETURN(2);
void nth_stern_diatomic(IN SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS))
XSRETURN_UV(nth_stern_diatomic(n));
DISPATCHPP();
XSRETURN(1);
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_POS))
k = UV_MAX;
}
SV **psvp, **psvq;
AV* av;
UV n, p64, q64;
uint32_t p, q;
int status;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS | IFLAG_NONZERO) &&
n <= UVCONST(4294967295)) {
CHECK_ARRAYREF(svfrac);
av = (AV*) SvRV(svfrac);
if (av_count(av) != 2) croak("%s: expected 2-element array reference", SUBNAME);
const NV pival = 3.141592653589793238462643383279502884197169L;
#else
const UV mantsize = DBL_DIG;
const NV pival = 3.141592653589793238462643383279502884197169;
#endif
PPCODE:
if (digits == 0) {
XSRETURN_NV( pival );
} else if (digits <= mantsize) {
char* out = pidigits(digits);
NV pi = STRTONV(out);
void bernfrac(IN SV* svn)
ALIAS:
harmfrac = 1
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS) != 0) {
if (ix == 0) {
IV num; UV den;
if (bernfrac(&num, &den, n)) {
XPUSHs(sv_2mortal(newSViv( num )));
void
_pidigits(IN int digits)
PREINIT:
char* out;
PPCODE:
if (digits <= 0) XSRETURN_EMPTY;
out = pidigits(digits);
XPUSHs(sv_2mortal(newSVpvn(out, digits+1)));
Safefree(out);
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_POS);
if (status == 1) {
if (gimme_v == G_SCALAR) {
XSRETURN_UV( inverse_totient_count(n) );
PREINIT:
UV n;
uint32_t i;
U32 gimme_v;
int status;
PPCODE:
gimme_v = GIMME_V;
status = _validate_and_set(&n, aTHX_ svn, IFLAG_POS);
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_POS);
k = n;
if (status == 1 && svk != 0) {
status = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
if (k > n) k = n;
PREINIT:
UV n, arg1, arg2;
static const UV default_arg1[] =
{0, 64000000, 8000000, 4000000, 1, 4000000, 0, 200, 4000000, 1000000};
/* Trial, Fermat, Holf, SQUFOF, Lmn, PRHO, Cheb, P+1, Brent, P-1 */
PPCODE:
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_POS) || ix == 10) {
DISPATCHPP();
return;
}
if (n == 0) XSRETURN_UV(0);
void
divisor_sum(IN SV* svn, ...)
PREINIT:
UV n, k, sigma;
PPCODE:
if (items == 1) {
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
sigma = divisor_sum(n, 1);
if (n <= 1 || sigma != 0)
XSRETURN_UV(sigma);
smooth_count = 4
rough_count = 5
PREINIT:
int astatus, nstatus;
UV a, n, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_POS);
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_POS);
if (astatus != 0 && nstatus != 0) {
switch (ix) {
case 0: ret = jordan_totient(a, n);
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_ABS) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
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_ABS) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
k < BITS_PER_WORD) {
UV ret = 0;
if (n == 0 || (k == 0 && n > 1)) XSRETURN_UNDEF;
XSRETURN(1);
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_ABS) &&
_validate_and_set(&n, aTHX_ svn, IFLAG_ABS) &&
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_POS);
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) XSRETURN_EMPTY;
_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) XSRETURN_EMPTY;
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_POS)) {
RETURN_NPARITY( (ix == 0) ? is_smooth(n,k) : is_rough(n,k) );
}
DISPATCHPP();
ALIAS:
is_almost_prime = 1
PREINIT:
UV n, k;
int nstatus, kstatus;
PPCODE:
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
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) {
XSRETURN(1);
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_POS)) {
if (k <= 1) croak("valuation: k must be > 1");
if (n == 0) XSRETURN_UNDEF;
RETURN_NPARITY(valuation(n, k));
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_POS);
if (nstatus != 0 && (!svk || _validate_and_set(&k, aTHX_ svk, IFLAG_POS))) {
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 astatus, bstatus;
UV a, b;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_ANY);
if (astatus != 0 && bstatus != 0) {
int k;
if (bstatus == 1)
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);
cdivint = 5
powint = 7
PREINIT:
int astatus, bstatus, overflow, postneg, nix, smask;
UV a, b, t, ret;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, (ix == 7) ? IFLAG_POS : IFLAG_ANY);
if (astatus != 0 && bstatus != 0) {
/* We will try to do everything with non-negative integers, with overflow
ALIAS:
sub1int = 1
PREINIT:
int status;
UV n;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 1) {
if (ix == 1 && n == 0) XSRETURN_IV(-1);
if (ix == 1 || (ix == 0 && n < UV_MAX))
XSRETURN_UV( (ix==0) ? n+1 : n-1 );
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);
PREINIT:
int status, sign, isodd;
UV n;
const char* s;
STRLEN len;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY);
if (status == 0) { /* Look at the string input */
s = SvPV(svn, len);
if (len == 0 || s == 0) croak("%s: invalid non-empty input", SUBNAME);
sign = (s[0] == '-') ? -1 : (s[0] == '0') ? 0 : 1;
void cmpint(IN SV* sva, IN SV* svb)
PREINIT:
int astatus, bstatus, ret = 0;
UV a, b;
PPCODE:
astatus = _validate_and_set(&a, aTHX_ sva, IFLAG_ANY);
bstatus = _validate_and_set(&b, aTHX_ svb, IFLAG_ANY);
if (astatus != 0 && bstatus != 0) {
if (astatus > bstatus) ret = 1;
else if (astatus < bstatus) ret = -1;
void logint(IN SV* svn, IN UV k, IN SV* svret = 0)
ALIAS:
rootint = 1
PREINIT:
UV n, root;
PPCODE:
if (ix == 0 && k <= 1) croak("logint: base must be > 1");
if (ix == 1 && k <= 0) croak("rootint: k must be > 0");
if (svret != 0 && !SvROK(svret))
croak("%s: third argument not a scalar reference",SUBNAME);
if (_validate_and_set(&n, aTHX_ svn, ix == 0 ? IFLAG_POS | IFLAG_NONZERO : IFLAG_POS)) {
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)) {
d = gcdext(a, b, &u, &v, 0, 0);
XPUSHs(sv_2mortal(newSViv( u )));
XPUSHs(sv_2mortal(newSViv( v )));
XSRETURN(3);
}
void
stirling(IN UV n, IN UV m, IN UV type = 1)
PPCODE:
if (type != 1 && type != 2 && type != 3)
croak("stirling: type must be 1, 2, or 3");
if (n == m)
XSRETURN_UV(1);
else if (n == 0 || m == 0 || m > n)
moebius = 1
PREINIT:
UV lo, hi;
int lostatus, histatus;
uint32_t mask;
PPCODE:
mask = (ix == 1 && items == 1) ? IFLAG_ABS : IFLAG_ANY;
lostatus = _validate_and_set(&lo, aTHX_ svlo, mask);
if (svhi == 0 && lostatus != 0) {
if (ix == 0) XSRETURN_UV( (lostatus == -1) ? 0 : totient(lo) );
else RETURN_NPARITY( moebius(lo) );
ALIAS:
carmichael_lambda = 1
exp_mangoldt = 2
PREINIT:
UV n, r;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
r = 0;
switch (ix) {
case 0: r = isqrt(n); break;
case 1: r = carmichael_lambda(n); break;
prime_bigomega = 1
hammingweight = 2
is_square_free = 3
PREINIT:
UV n, ret;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_ABS)) {
ret = 0;
switch (ix) {
case 0: ret = prime_omega(n); break;
case 1: ret = prime_bigomega(n); break;
primorial = 3
pn_primorial = 4
sumtotient = 5
PREINIT:
UV n, r;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
r = 0;
switch(ix) {
case 0: r = factorial(n); break;
case 1: r = subfactorial(n); break;
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)) )
ALIAS:
rising_factorial = 1
PREINIT:
int nstatus, kstatus;
UV n, k;
PPCODE:
nstatus = _validate_and_set(&n, aTHX_ svn, IFLAG_ANY | IFLAG_IV);
kstatus = _validate_and_set(&k, aTHX_ svk, IFLAG_POS);
if (nstatus == 1 && kstatus == 1) {
UV ret = (ix==0) ? falling_factorial(n,k) : rising_factorial(n,k);
if (ret != UV_MAX) XSRETURN_UV(ret);
hclassno = 5
ramanujan_tau = 6
PREINIT:
UV n;
int status;
PPCODE:
status = _validate_and_set(&n, aTHX_ svn, (ix < 5) ? IFLAG_POS : IFLAG_ANY);
if (status == -1)
XSRETURN_IV(0);
if (status == 1) {
IV r = 0;
void chebyshev_theta(IN SV* svn)
ALIAS:
chebyshev_psi = 1
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
NV r = (ix==0) ? chebyshev_theta(n) : chebyshev_psi(n);
XSRETURN_NV(r);
}
DISPATCHPP();
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 */
#if PERL_VERSION_GE(5,10,1)
atype = arrayref_to_int_array(aTHX_ &alen, &ra, 1, sva, "setbinop arg 1");
if (svb == 0 || atype == IARR_TYPE_BAD) {
rb = ra;
blen = alen;
setdelta = 3
PREINIT:
int atype, btype;
UV *ra, *rb;
size_t alen, blen;
PPCODE:
/* Fast path: both inputs are arrayrefs of native non-negative sorted
* unique integers. Merge SV* directly with SvREFCNT_inc, skipping
* intermediate UV array allocations and per-element newSVuv calls. */
{
size_t fa, fb;
set_is_proper_intersection = 6
PREINIT:
int atype, btype, ret;
UV *ra, *rb;
size_t alen, blen, inalen, inblen;
PPCODE:
/* If one set is much smaller than the other, it would be faster using
* is_in_set(). We'll keep things simple and slurp in both sets. */
/* THIS ASSUMES THE INPUT LISTS HAVE NO DUPLICATES */
inalen = inblen = 0;
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(1);
if (SvMAGICAL(ava) || !AvREAL(ava)) { /* Punt these to Perl */
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 (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);
PREINIT:
int itype, is_sidon;
size_t len, i, j;
UV *data;
iset_t s;
PPCODE:
itype = arrayref_to_int_array(aTHX_ &len, &data, 1, sva,"is_sidon_set");
if (itype == IARR_TYPE_NEG) { /* All elements must be non-negative. */
Safefree(data);
RETURN_NPARITY(0);
}
PREINIT:
UV *data;
size_t len, i, j;
int itype;
bool is_sumfree;
PPCODE:
itype = arrayref_to_int_array(aTHX_ &len, &data,1,sva,"is_sumfree_set");
if (itype != IARR_TYPE_BAD && len <= 1) { /* Degenerate cases: len 0 or 1 */
is_sumfree = len == 0 || data[0] != 0;
Safefree(data);
RETURN_NPARITY(is_sumfree);
PROTOTYPE: @
PREINIT:
int type;
size_t len;
UV *L;
PPCODE:
if (items == 0) RETURN_EMPTY_SET_REF();
type = array_to_int_array(aTHX_ &len, &L, 1, &ST(0), items);
if (type != IARR_TYPE_BAD)
RETURN_LIST_REF(len, L, type != IARR_TYPE_NEG);
Safefree(L);
PROTOTYPE: @
PREINIT:
int type;
size_t len;
UV *L;
PPCODE:
if (items == 0)
XSRETURN_EMPTY;
if (SvROK(ST(0)) && SvTYPE(SvRV(ST(0))) == SVt_PVAV) {
if (items != 1)
croak("vecsort: expected integer list or single array reference");
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();
void numtoperm(IN UV n, IN SV* svk)
PREINIT:
UV k;
int i, S[32];
PPCODE:
if (n == 0)
XSRETURN_EMPTY;
if (n < 32 && _validate_and_set(&k, aTHX_ svk, IFLAG_ABS) == 1) {
if (num_to_perm(k, n, S)) {
dMY_CXT;
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 UV n, IN UV k = 0)
PREINIT:
UV i, *S;
dMY_CXT;
PPCODE:
if (items == 1) k = n;
if (k > n) k = n;
if (k == 0) XSRETURN_EMPTY;
New(0, S, k, UV);
randperm(MY_CXT.randcxt, n, k, S);
PROTOTYPE: @
PREINIT:
SSize_t i, j;
void* randcxt;
dMY_CXT;
PPCODE:
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 (items == 1)
XSRETURN_EMPTY;
randcxt = MY_CXT.randcxt;
/*
* Fisher-Yates shuffle with first 'k' selections returned.
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("is_happy: invalid base %"UVuf, base);
if (k > 10) croak("is_happy: invalid exponent %"UVuf, k);
status = _validate_and_set(&n, aTHX_ svn, IFLAG_POS);
if (status == 0 && base == 10) { /* String op to reduce into range. */
STRLEN i, len;
sumdigits(SV* svn, UV ibase = 255)
PREINIT:
UV base, sum;
STRLEN i, len;
const char* s;
PPCODE:
base = (ibase == 255) ? 10 : ibase;
if (base < 2 || base > 36) croak("sumdigits: invalid base %"UVuf, base);
sum = 0;
/* faster for integer input in base 10 */
if (base == 10 && SVNUMTEST(svn) && (SvIsUV(svn) || SvIVX(svn) >= 0)) {
fromdigits = 2
PREINIT:
int i, status;
UV n;
char *str;
PPCODE:
if (base < 2) croak("%s: invalid base: %d", SUBNAME, base);
status = 0;
if (ix == 0 || ix == 1) {
status = _validate_and_set(&n, aTHX_ svn, IFLAG_ABS);
}
return;
void tozeckendorf(SV* svn)
PREINIT:
UV n;
PPCODE:
if (_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
char *str = to_zeckendorf(n);
XPUSHs(sv_2mortal(newSVpv(str, 0)));
Safefree(str);
XSRETURN(1);
XSRETURN(1);
void fromzeckendorf(IN char* str)
PREINIT:
int status;
PPCODE:
status = validate_zeckendorf(str);
if (status == 0)
croak("fromzeckendorf: expected binary string");
if (status == -1)
croak("fromzeckendorf: expected binary string in canonical Zeckendorf form");
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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_POS)) {
DISPATCH_VOIDPP();
XSRETURN(0);
int primeq;
CV *subcv;
SV** svals;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_POS)) {
DISPATCH_VOIDPP();
XSRETURN(0);
}
CV *subcv;
SV** svals;
UV* cm;
DECL_FORCOUNT;
dMY_CXT;
PPCODE:
SETSUBREF(subcv, block);
if (ix > 0 && svk != 0)
croak("%s: too many arguments", SUBNAME);
if (!_validate_and_set(&n, aTHX_ svn, IFLAG_POS) ||
SSize_t narrays, i, j, *arlen, *arcnt;
SV ***arsvs;
CV *subcv;
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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_POS) ||
(svend && !_validate_and_set(&end, aTHX_ svend, IFLAG_POS))) {
DISPATCH_VOIDPP();
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];
iset_t s;
int status, retvals;
SSize_t j;
UV n;
unsigned long sz, nret;
PPCODE:
retvals = (GIMME_V != G_SCALAR && GIMME_V != G_VOID);
s = iset_create((size_t)items);
for (status = 1, nret = 0, j = 0; j < items; j++) {
status = _validate_and_set(&n, aTHX_ ST(j), IFLAG_ANY);
if (status == 0) break;
PROTOTYPE: @
PREINIT:
int itype;
size_t len, i, retlen;
UV *L, count;
PPCODE:
if (items == 0) {
if (GIMME_V == G_SCALAR) XSRETURN_UV(0);
else XSRETURN_EMPTY;
}
/* Try to read native integers. Bail to PP if something else. */
PREINIT:
int itype;
size_t len, i, retlen, count;
UV *L;
iset_t seen, dups;
PPCODE:
if (items == 0) {
if (GIMME_V == G_SCALAR) XSRETURN_UV(0);
else XSRETURN_EMPTY;
}
/* Try to read native integers. Bail to PP if something else. */
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
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)));
( run in 1.686 second using v1.01-cache-2.11-cpan-71847e10f99 )