PyCFrameObject *
slp_cframe_newfunc(PyObject *func, PyObject *args, PyObject *kwds, unsigned int linked)
{
PyCFrameObject *cf;
if (func == NULL || !PyCallable_Check(func))
TYPE_ERROR("cframe function must be a callable", NULL);
cf = slp_cframe_new(run_cframe, linked);
if (cf == NULL)
return NULL;
Py_INCREF(func);
cf->ob1 = func;
Py_INCREF(args);
cf->ob2 = args;
Py_XINCREF(kwds);
cf->ob3 = kwds;
return cf;
}
static PyObject *
GMPy_Number_Abs(PyObject *x, CTXT_Object *context)
{
if (IS_INTEGER(x))
return GMPy_Integer_Abs(x, context);
if (IS_RATIONAL_ONLY(x))
return GMPy_Rational_Abs(x, context);
if (IS_REAL_ONLY(x))
return GMPy_Real_Abs(x, context);
if (IS_COMPLEX_ONLY(x))
return GMPy_Complex_Abs(x, context);
TYPE_ERROR("abs() argument type not supported");
return NULL;
}
static PyObject *
Pympany_square(PyObject *self, PyObject *other)
{
if (isInteger(other)) {
return Pympz_square(self, other);
}
else if (isRational(other)) {
return Pympq_square(self, other);
}
#ifdef WITHMPFR
else if (isReal(other)) {
return Pympfr_sqr(self, other);
}
#endif
TYPE_ERROR("square() not supported");
return NULL;
}
static PyObject *
GMPy_Number_Add(PyObject *x, PyObject *y, CTXT_Object *context)
{
if (IS_INTEGER(x) && IS_INTEGER(y))
return GMPy_Integer_Add(x, y, context);
if (IS_RATIONAL(x) && IS_RATIONAL(y))
return GMPy_Rational_Add(x, y, context);
if (IS_REAL(x) && IS_REAL(y))
return GMPy_Real_Add(x, y, context);
if (IS_COMPLEX(x) && IS_COMPLEX(y))
return GMPy_Complex_Add(x, y, context);
TYPE_ERROR("add() argument type not supported");
return NULL;
}
inline PyObject*
wsgi_iterable_get_next_chunk(Request* request)
{
/* Get the next item out of ``request->iterable``, skipping empty ones. */
PyObject* next;
while(true) {
next = PyIter_Next(request->iterator);
if(next == NULL)
return NULL;
if(!PyString_Check(next)) {
TYPE_ERROR("wsgi iterable items", "strings", next);
Py_DECREF(next);
return NULL;
}
if(PyString_GET_SIZE(next))
return next;
Py_DECREF(next);
}
}
PyChannelObject *
PyChannel_New(PyTypeObject *type)
{
PyChannelObject *c;
if (type == NULL)
type = &PyChannel_Type;
if (!PyType_IsSubtype(type, &PyChannel_Type))
TYPE_ERROR("channel_new: type must be subtype of channel", NULL);
c = (PyChannelObject *) type->tp_alloc(type, 0);
if (c != NULL) {
c->head = c->tail = (PyTaskletObject *) c;
c->balance = 0;
c->chan_weakreflist = NULL;
*(int*)&c->flags = 0;
c->flags.preference = -1; /* default fast receive */
}
return c;
}
static PyObject *
GMPy_MPZ_popcount(PyObject *self, PyObject *other)
{
mp_bitcnt_t n;
MPZ_Object *tempx;
if ((tempx = GMPy_MPZ_From_Integer(other, NULL))) {
n = mpz_popcount(tempx->z);
Py_DECREF((PyObject*)tempx);
if (n == (mp_bitcnt_t)(-1))
return PyLong_FromLong(-1);
else
return PyIntOrLong_FromMpBitCnt(n);
}
else {
TYPE_ERROR("popcount() requires 'mpz' argument");
return NULL;
}
}
static PyObject *
GMPy_Context_Add(PyObject *self, PyObject *args)
{
CTXT_Object *context = NULL;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("add() requires 2 arguments.");
return NULL;
}
if (self && CTXT_Check(self)) {
context = (CTXT_Object*)self;
}
else {
CHECK_CONTEXT(context);
}
return GMPy_Number_Add(PyTuple_GET_ITEM(args, 0), PyTuple_GET_ITEM(args, 1), context);
}
static PyObject *
Pympq_sign(PyObject *self, PyObject *other)
{
long res;
PympqObject* tempx;
if (Pympq_Check(other)) {
res = mpq_sgn(Pympq_AS_MPQ(other));
}
else {
if (!(tempx = Pympq_From_Number(other))) {
TYPE_ERROR("sign() requires 'mpq' argument");
return NULL;
}
else {
res = mpq_sgn(tempx->q);
Py_DECREF((PyObject*)tempx);
}
}
return PyIntOrLong_FromLong(res);
}
static PyObject *
GMPy_MPZ_Function_IsqrtRem(PyObject *self, PyObject *other)
{
MPZ_Object *root = NULL, *rem = NULL, *temp = NULL;
PyObject *result;
if (!(temp = GMPy_MPZ_From_Integer(other, NULL))) {
TYPE_ERROR("isqrt_rem() requires 'mpz' argument");
return NULL;
}
if (mpz_sgn(temp->z) < 0) {
VALUE_ERROR("isqrt_rem() of negative number");
Py_DECREF((PyObject*)temp);
return NULL;
}
if (!(result = PyTuple_New(2)) ||
!(root = GMPy_MPZ_New(NULL)) ||
!(rem = GMPy_MPZ_New(NULL))) {
/* LCOV_EXCL_START */
Py_DECREF((PyObject*)temp);
Py_XDECREF(result);
Py_XDECREF((PyObject*)root);
Py_XDECREF((PyObject*)rem);
return NULL;
/* LCOV_EXCL_STOP */
}
mpz_sqrtrem(root->z, rem->z, temp->z);
Py_DECREF((PyObject*)temp);
PyTuple_SET_ITEM(result, 0, (PyObject*)root);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return result;
}
size_t size_of(af_dtype type) {
try {
switch (type) {
case f32: return sizeof(float);
case f64: return sizeof(double);
case s32: return sizeof(int);
case u32: return sizeof(unsigned);
case u8: return sizeof(unsigned char);
case b8: return sizeof(unsigned char);
case c32: return sizeof(float) * 2;
case c64: return sizeof(double) * 2;
case s16: return sizeof(short);
case u16: return sizeof(unsigned short);
case s64: return sizeof(long long);
case u64: return sizeof(unsigned long long);
default: TYPE_ERROR(1, type);
}
}
CATCHALL;
return AF_SUCCESS;
}
static PyObject *
GMPy_MPZ_Function_Bincoef(PyObject *self, PyObject *args)
{
MPZ_Object *result = NULL, *tempx;
unsigned long n, k;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("bincoef() requires two integer arguments");
return NULL;
}
if (!(result = GMPy_MPZ_New(NULL))) {
/* LCOV_EXCL_START */
return NULL;
/* LCOV_EXCL_STOP */
}
k = c_ulong_From_Integer(PyTuple_GET_ITEM(args, 1));
if (k == (unsigned long)(-1) && PyErr_Occurred()) {
Py_DECREF((PyObject*)result);
return NULL;
}
n = c_ulong_From_Integer(PyTuple_GET_ITEM(args, 0));
if (!(n == (unsigned long)(-1) && PyErr_Occurred())) {
/* Use mpz_bin_uiui which should be faster. */
mpz_bin_uiui(result->z, n, k);
return (PyObject*)result;
}
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL))) {
Py_DECREF((PyObject*)result);
return NULL;
}
mpz_bin_ui(result->z, tempx->z, k);
Py_DECREF((PyObject*)tempx);
return (PyObject*)result;
}
static PyObject *
GMPy_MPZ_Function_IsPrime(PyObject *self, PyObject *args)
{
int i;
unsigned long reps = 25;
MPZ_Object* tempx;
Py_ssize_t argc;
argc = PyTuple_GET_SIZE(args);
if (argc == 0 || argc > 2) {
TYPE_ERROR("is_prime() requires 'mpz'[,'int'] arguments");
return NULL;
}
if (PyTuple_GET_SIZE(args) == 2) {
reps = c_ulong_From_Integer(PyTuple_GET_ITEM(args, 1));
if (reps == -1 && PyErr_Occurred()) {
return NULL;
}
/* Silently limit n to a reasonable value. */
if (reps > 1000) {
reps = 1000;
}
}
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL))) {
return NULL;
}
i = mpz_probab_prime_p(tempx->z, (int)reps);
Py_DECREF((PyObject*)tempx);
if (i)
Py_RETURN_TRUE;
else
Py_RETURN_FALSE;
}
PyTaskletObject *
PyTasklet_New(PyTypeObject *type, PyObject *func)
{
PyThreadState *ts = PyThreadState_GET();
PyTaskletObject *t;
/* we always need a cstate, so be sure to initialize */
if (ts->st.initial_stub == NULL) return PyTasklet_New_M(type, func);
if (func != NULL && !PyCallable_Check(func))
TYPE_ERROR("tasklet function must be a callable", NULL);
if (type == NULL) type = &PyTasklet_Type;
assert(PyType_IsSubtype(type, &PyTasklet_Type));
t = (PyTaskletObject *) type->tp_alloc(type, 0);
if (t != NULL) {
*(int*)&t->flags = 0;
t->next = NULL;
t->prev = NULL;
t->f.frame = NULL;
if (func == NULL)
func = Py_None;
Py_INCREF(func);
t->tempval = func;
t->tsk_weakreflist = NULL;
Py_INCREF(ts->st.initial_stub);
t->cstate = ts->st.initial_stub;
t->def_globals = PyEval_GetGlobals();
Py_XINCREF(t->def_globals);
if (ts != slp_initial_tstate) {
/* make sure to kill tasklets with their thread */
if (slp_ensure_linkage(t)) {
Py_DECREF(t);
return NULL;
}
}
}
return t;
}
static PyObject *
GMPy_MPZ_bit_scan1_function(PyObject *self, PyObject *args)
{
mp_bitcnt_t index, starting_bit = 0;
MPZ_Object *tempx = NULL;
if (PyTuple_GET_SIZE(args) == 0 || PyTuple_GET_SIZE(args) > 2) {
goto err;
}
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL))) {
goto err;
}
if (PyTuple_GET_SIZE(args) == 2) {
starting_bit = mp_bitcnt_t_From_Integer(PyTuple_GET_ITEM(args, 1));
if (starting_bit == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
goto err_index;
}
}
index = mpz_scan1(tempx->z, starting_bit);
Py_DECREF((PyObject*)tempx);
if (index == (mp_bitcnt_t)(-1)) {
Py_RETURN_NONE;
}
else {
return PyIntOrLong_FromMpBitCnt(index);
}
err:
TYPE_ERROR("bit_scan0() requires 'mpz',['int'] arguments");
err_index:
Py_DECREF((PyObject*)tempx);
return NULL;
}
static PyObject *
GMPy_MPZ_c_divmod_2exp(PyObject *self, PyObject *args)
{
mp_bitcnt_t nbits;
PyObject *result;
MPZ_Object *q, *r, *tempx;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("c_divmod_2exp() requires 'mpz','int' arguments");
return NULL;
}
nbits = mp_bitcnt_t_From_Integer(PyTuple_GET_ITEM(args, 1));
if (nbits == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
return NULL;
}
tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
q = GMPy_MPZ_New(NULL);
r = GMPy_MPZ_New(NULL);
result = PyTuple_New(2);
if (!tempx || !q || !r || !result) {
Py_XDECREF(result);
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)q);
Py_XDECREF((PyObject*)r);
return NULL;
}
mpz_cdiv_q_2exp(q->z, tempx->z, nbits);
mpz_cdiv_r_2exp(r->z, tempx->z, nbits);
Py_DECREF((PyObject*)tempx);
PyTuple_SET_ITEM(result, 0, (PyObject*)q);
PyTuple_SET_ITEM(result, 1, (PyObject*)r);
return result;
}
static PyObject *
GMPy_MPZ_Function_NextPrime(PyObject *self, PyObject *other)
{
MPZ_Object *result;
if(MPZ_Check(other)) {
if(!(result = GMPy_MPZ_New(NULL))) {
/* LCOV_EXCL_START */
return NULL;
/* LCOV_EXCL_STOP */
}
mpz_nextprime(result->z, MPZ(other));
}
else {
if (!(result = GMPy_MPZ_From_Integer(other, NULL))) {
TYPE_ERROR("next_prime() requires 'mpz' argument");
return NULL;
}
else {
mpz_nextprime(result->z, result->z);
}
}
return (PyObject*)result;
}
static PyObject *
GMPy_Context_Round2(PyObject *self, PyObject *args)
{
CTXT_Object *context = NULL;
if (PyTuple_GET_SIZE(args) < 1 || PyTuple_GET_SIZE(args) > 2) {
TYPE_ERROR("round2() requires 1 or 2 arguments");
return NULL;
}
if (self && CTXT_Check(self)) {
context = (CTXT_Object*)self;
}
else {
CHECK_CONTEXT(context);
}
if (PyTuple_GET_SIZE(args) == 1) {
return GMPy_Number_Round2(PyTuple_GET_ITEM(args, 0), NULL, context);
}
else {
return GMPy_Number_Round2(PyTuple_GET_ITEM(args, 0), PyTuple_GET_ITEM(args, 1), context);
}
}
static PyObject *
GMPy_MPZ_Function_Kronecker(PyObject *self, PyObject *args)
{
MPZ_Object *tempx = NULL, *tempy = NULL;
long res;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("kronecker() requires 'mpz','mpz' arguments");
return NULL;
}
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL)) ||
!(tempy = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL))) {
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
return NULL;
}
res = (long)(mpz_kronecker(tempx->z, tempy->z));
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
return PyIntOrLong_FromLong(res);
}
static MPC_Object *
GMPy_MPC_From_Complex(PyObject* obj, mp_prec_t rprec, mp_prec_t iprec,
CTXT_Object *context)
{
CHECK_CONTEXT(context);
if (MPC_Check(obj))
return GMPy_MPC_From_MPC((MPC_Object*)obj, rprec, iprec, context);
if (MPFR_Check(obj))
return GMPy_MPC_From_MPFR((MPFR_Object*)obj, rprec, iprec, context);
if (PyFloat_Check(obj))
return GMPy_MPC_From_PyFloat(obj, rprec, iprec, context);
if (PyComplex_Check(obj))
return GMPy_MPC_From_PyComplex(obj, rprec, iprec, context);
if (MPQ_Check(obj))
return GMPy_MPC_From_MPQ((MPQ_Object*)obj, rprec, iprec, context);
if (MPZ_Check(obj) || XMPZ_Check(obj))
return GMPy_MPC_From_MPZ((MPZ_Object*)obj, rprec, iprec, context);
if (PyIntOrLong_Check(obj))
return GMPy_MPC_From_PyIntOrLong(obj, rprec, iprec, context);
if (IS_DECIMAL(obj))
return GMPy_MPC_From_Decimal(obj, rprec, iprec, context);
if (IS_FRACTION(obj))
return GMPy_MPC_From_Fraction(obj, rprec, iprec, context);
TYPE_ERROR("object could not be converted to 'mpc'");
return NULL;
}
static PyObject *
GMPY_mpz_is_lucas_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p, *q;
PyObject *result = 0;
mpz_t zD, res, index;
/* used for calculating the Lucas U sequence */
mpz_t uh, vl, vh, ql, qh, tmp;
mp_bitcnt_t s = 0, j = 0;
int ret;
if (PyTuple_Size(args) != 3) {
TYPE_ERROR("is_lucas_prp() requires 3 integer arguments");
return NULL;
}
mpz_init(zD);
mpz_init(res);
mpz_init(index);
mpz_init(uh);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
q = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 2), NULL);
if (!n || !p || !q) {
TYPE_ERROR("is_lucas_prp() requires 3 integer arguments");
goto cleanup;
}
/* Check if p*p - 4*q == 0. */
mpz_mul(zD, p->z, p->z);
mpz_mul_ui(tmp, q->z, 4);
mpz_sub(zD, zD, tmp);
if (mpz_sgn(zD) == 0) {
VALUE_ERROR("invalid values for p,q in is_lucas_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_lucas_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check GCD */
mpz_mul(res, zD, q->z);
mpz_mul_ui(res, res, 2);
mpz_gcd(res, res, n->z);
if ((mpz_cmp(res, n->z) != 0) && (mpz_cmp_ui(res, 1) > 0)) {
VALUE_ERROR("is_lucas_prp() requires gcd(n,2*q*D) == 1");
goto cleanup;
}
/* index = n-(D/n), where (D/n) is the Jacobi symbol */
mpz_set(index, n->z);
ret = mpz_jacobi(zD, n->z);
if (ret == -1)
mpz_add_ui(index, index, 1);
else if (ret == 1)
mpz_sub_ui(index, index, 1);
/* mpz_lucasumod(res, p, q, index, n); */
mpz_set_si(uh, 1);
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
s = mpz_scan1(index, 0);
for (j = mpz_sizeinbase(index,2)-1; j >= s+1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(index,j) == 1) {
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n->z);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++) {
/* uh = uh*vl (mod n) */
mpz_mul(uh, uh, vl);
mpz_mod(uh, uh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
}
/* uh contains our return value */
mpz_mod(res, uh, n->z);
if (mpz_cmp_ui(res, 0) == 0)
result = Py_True;
else
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(zD);
mpz_clear(res);
mpz_clear(index);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)q);
Py_XDECREF((PyObject*)n);
return result;
}
static PyObject *
GMPy_Context_Fsum(PyObject *self, PyObject *other)
{
MPFR_Object *temp, *result;
mpfr_ptr *tab;
int errcode;
Py_ssize_t i, seq_length = 0;
CTXT_Object *context = NULL;
if (self && CTXT_Check(self)) {
context = (CTXT_Object*)self;
}
else {
CHECK_CONTEXT(context);
}
if (!(result = GMPy_MPFR_New(0, context))) {
return NULL;
}
if (!(other = PySequence_List(other))) {
Py_DECREF((PyObject*)result);
TYPE_ERROR("argument must be an iterable");
return NULL;
}
/* other contains a new list containing all the values from the
* iterable. Now make sure each item in the list is an mpfr.
*/
seq_length = PyList_GET_SIZE(other);
for (i=0; i < seq_length; i++) {
if (!(temp = GMPy_MPFR_From_Real(PyList_GET_ITEM(other, i), 1, context))) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
TYPE_ERROR("all items in iterable must be real numbers");
return NULL;
}
errcode = PyList_SetItem(other, i,(PyObject*)temp);
if (errcode < 0) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
TYPE_ERROR("all items in iterable must be real numbers");
return NULL;
}
}
/* create an array of pointers to the mpfr_t field of a Pympfr object */
if (!(tab = (mpfr_ptr *)GMPY_MALLOC((sizeof(mpfr_srcptr) * seq_length)))) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
return PyErr_NoMemory();
}
for (i=0; i < seq_length; i++) {
temp = (MPFR_Object*)PyList_GET_ITEM(other, i);
tab[i] = temp->f;
}
mpfr_clear_flags();
result->rc = mpfr_sum(result->f, tab, seq_length, GET_MPFR_ROUND(context));
Py_DECREF(other);
GMPY_FREE(tab);
_GMPy_MPFR_Cleanup(&result, context);
return (PyObject*)result;
}
static PyObject*
start_response(PyObject* self, PyObject* args, PyObject* kwargs)
{
Request* request = ((StartResponse*)self)->request;
if(request->state.start_response_called) {
/* not the first call of start_response --
* throw away any previous status and headers. */
Py_CLEAR(request->status);
Py_CLEAR(request->headers);
request->state.response_length_unknown = false;
}
PyObject* status = NULL;
PyObject* headers = NULL;
PyObject* exc_info = NULL;
if(!PyArg_UnpackTuple(args, "start_response", 2, 3, &status, &headers, &exc_info))
return NULL;
if(exc_info && exc_info != Py_None) {
if(!PyTuple_Check(exc_info) || PyTuple_GET_SIZE(exc_info) != 3) {
TYPE_ERROR("start_response argument 3", "a 3-tuple", exc_info);
return NULL;
}
restore_exception_tuple(exc_info, /* incref items? */ true);
if(request->state.wsgi_call_done) {
/* Too late to change headers. According to PEP 333, we should let
* the exception propagate in this case. */
return NULL;
}
/* Headers not yet sent; handle this start_response call as if 'exc_info'
* would not have been passed, but print and clear the exception. */
PyErr_Print();
}
else if(request->state.start_response_called) {
PyErr_SetString(PyExc_TypeError, "'start_response' called twice without "
"passing 'exc_info' the second time");
return NULL;
}
if(!PyString_Check(status)) {
TYPE_ERROR("start_response argument 1", "a 'status reason' string", status);
return NULL;
}
if(!PyList_Check(headers)) {
TYPE_ERROR("start response argument 2", "a list of 2-tuples", headers);
return NULL;
}
request->headers = headers;
if(!inspect_headers(request)) {
request->headers = NULL;
return NULL;
}
request->status = status;
Py_INCREF(request->status);
Py_INCREF(request->headers);
request->state.start_response_called = true;
Py_RETURN_NONE;
}
static int
mpz_set_PyStr(mpz_ptr z, PyObject *s, int base)
{
char *cp;
Py_ssize_t len;
size_t i;
PyObject *ascii_str = NULL;
if (PyBytes_Check(s)) {
len = PyBytes_Size(s);
cp = PyBytes_AsString(s);
}
else if (PyUnicode_Check(s)) {
ascii_str = PyUnicode_AsASCIIString(s);
if (!ascii_str) {
VALUE_ERROR("string contains non-ASCII characters");
return -1;
}
len = PyBytes_Size(ascii_str);
cp = PyBytes_AsString(ascii_str);
}
else {
TYPE_ERROR("object is not string or Unicode");
return -1;
}
/* Don't allow NULL characters */
for (i = 0; i < len; i++) {
if (cp[i] == '\0') {
VALUE_ERROR("string contains NULL characters");
Py_XDECREF(ascii_str);
return -1;
}
}
/* Check for leading base indicators. */
if (base == 0) {
if (cp[0] == '0') {
if (cp[1] == 'b') { base = 2; cp += 2; }
else if (cp[1] == 'o') { base = 8; cp += 2; }
else if (cp[1] == 'x') { base = 16; cp += 2; }
else { base = 10; }
}
else {
base = 10;
}
}
else if (cp[0] == '0') {
/* If the specified base matches the leading base indicators, then
* we need to skip the base indicators.
*/
if (cp[1] =='b' && base == 2) { cp += 2; }
else if (cp[1] =='o' && base == 8) { cp += 2; }
else if (cp[1] =='x' && base == 16) { cp += 2; }
}
/* delegate rest to GMP's _set_str function */
if (-1 == mpz_set_str(z, cp, base)) {
VALUE_ERROR("invalid digits");
Py_XDECREF(ascii_str);
return -1;
}
Py_XDECREF(ascii_str);
return 1;
}
static PyObject *
GMPy_Complex_Mod(PyObject *x, PyObject *y, CTXT_Object *context)
{
TYPE_ERROR("can't take mod of complex number");
return NULL;
}
static PyObject *
GMPY_mpz_is_fermat_prp(PyObject *self, PyObject *args)
{
MPZ_Object *a, *n;
PyObject *result = 0;
mpz_t res, nm1;
if (PyTuple_Size(args) != 2) {
TYPE_ERROR("is_fermat_prp() requires 2 integer arguments");
return NULL;
}
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
a = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
if (!a || !n) {
TYPE_ERROR("is_fermat_prp() requires 2 integer arguments");
goto cleanup;
}
mpz_init(res);
mpz_init(nm1);
/* Require a >= 2. */
if (mpz_cmp_ui(a->z, 2) < 0) {
VALUE_ERROR("is_fermat_prp() requires 'a' greater than or equal to 2");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_fermat_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
/* Should n even raise an exception? */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check gcd(a,n) */
mpz_gcd(res, n->z, a->z);
if (mpz_cmp_ui(res, 1) > 0) {
VALUE_ERROR("is_fermat_prp() requires gcd(n,a) == 1");
goto cleanup;
}
mpz_set(nm1, n->z);
mpz_sub_ui(nm1, nm1, 1);
mpz_powm(res, a->z, nm1, n->z);
if (mpz_cmp_ui(res, 1) == 0)
result = Py_True;
else
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(res);
mpz_clear(nm1);
Py_XDECREF((PyObject*)a);
Py_XDECREF((PyObject*)n);
return result;
}
static PyObject *
GMPY_mpz_is_fibonacci_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p, *q;
PyObject *result = 0;
mpz_t pmodn, zP;
/* used for calculating the Lucas V sequence */
mpz_t vl, vh, ql, qh, tmp;
mp_bitcnt_t s = 0, j = 0;
if (PyTuple_Size(args) != 3) {
TYPE_ERROR("is_fibonacci_prp() requires 3 integer arguments");
return NULL;
}
mpz_init(pmodn);
mpz_init(zP);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
q = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 2), NULL);
if (!n || !p || !q) {
TYPE_ERROR("is_fibonacci_prp() requires 3 integer arguments");
goto cleanup;
}
/* Check if p*p - 4*q == 0. */
mpz_mul(tmp, p->z, p->z);
mpz_mul_ui(qh, q->z, 4);
mpz_sub(tmp, tmp, qh);
if (mpz_sgn(tmp) == 0) {
VALUE_ERROR("invalid values for p,q in is_fibonacci_prp()");
goto cleanup;
}
/* Verify q = +/-1 */
if ((mpz_cmp_si(q->z, 1) && mpz_cmp_si(q->z, -1)) || (mpz_sgn(p->z) <= 0)) {
VALUE_ERROR("invalid values for p,q in is_fibonacci_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_fibonacci_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
mpz_set(zP, p->z);
mpz_mod(pmodn, zP, n->z);
/* mpz_lucasvmod(res, p, q, n, n); */
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
s = mpz_scan1(n->z, 0);
for (j = mpz_sizeinbase(n->z,2)-1; j >= s+1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(n->z,j) == 1) {
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++) {
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
}
/* vl contains our return value */
mpz_mod(vl, vl, n->z);
if (mpz_cmp(vl, pmodn) == 0)
result = Py_True;
else
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(pmodn);
mpz_clear(zP);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)q);
Py_XDECREF((PyObject*)n);
return result;
}
static PyObject *
GMPY_mpz_is_strongbpsw_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n;
PyObject *result = 0, *temp = 0;
if (PyTuple_Size(args) != 1) {
TYPE_ERROR("is_strong_bpsw_prp() requires 1 integer argument");
return NULL;
}
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
if (!n) {
TYPE_ERROR("is_strong_bpsw_prp() requires 1 integer argument");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_strong_bpsw_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* "O" is used to increment the reference to n so deleting temp won't
* delete n.
*/
temp = Py_BuildValue("Oi", n, 2);
if (!temp)
goto cleanup;
result = GMPY_mpz_is_strong_prp(NULL, temp);
Py_DECREF(temp);
if (result == Py_False)
goto return_result;
/* Remember to ignore the preceding result */
Py_DECREF(result);
temp = Py_BuildValue("O", n);
if (!temp)
goto cleanup;
result = GMPY_mpz_is_selfridge_prp(NULL, temp);
Py_DECREF(temp);
goto return_result;
cleanup:
Py_XINCREF(result);
return_result:
Py_DECREF((PyObject*)n);
return result;
}
static PyObject *
GMPY_mpz_is_strong_prp(PyObject *self, PyObject *args)
{
MPZ_Object *a, *n;
PyObject *result = 0;
mpz_t s, nm1, mpz_test;
mp_bitcnt_t r = 0;
if (PyTuple_Size(args) != 2) {
TYPE_ERROR("is_strong_prp() requires 2 integer arguments");
return NULL;
}
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
a = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
if (!a || !n) {
TYPE_ERROR("is_strong_prp() requires 2 integer arguments");
goto cleanup;
}
mpz_init(s);
mpz_init(nm1);
mpz_init(mpz_test);
/* Require a >= 2. */
if (mpz_cmp_ui(a->z, 2) < 0) {
VALUE_ERROR("is_strong_prp() requires 'a' greater than or equal to 2");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_strong_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check gcd(a,b) */
mpz_gcd(s, n->z, a->z);
if (mpz_cmp_ui(s, 1) > 0) {
VALUE_ERROR("is_strong_prp() requires gcd(n,a) == 1");
goto cleanup;
}
mpz_set(nm1, n->z);
mpz_sub_ui(nm1, nm1, 1);
/* Find s and r satisfying: n-1=(2^r)*s, s odd */
r = mpz_scan1(nm1, 0);
mpz_fdiv_q_2exp(s, nm1, r);
/* Check a^((2^t)*s) mod n for 0 <= t < r */
mpz_powm(mpz_test, a->z, s, n->z);
if ((mpz_cmp_ui(mpz_test, 1) == 0) || (mpz_cmp(mpz_test, nm1) == 0)) {
result = Py_True;
goto cleanup;
}
while (--r) {
/* mpz_test = mpz_test^2%n */
mpz_mul(mpz_test, mpz_test, mpz_test);
mpz_mod(mpz_test, mpz_test, n->z);
if (mpz_cmp(mpz_test, nm1) == 0) {
result = Py_True;
goto cleanup;
}
}
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(s);
mpz_clear(nm1);
mpz_clear(mpz_test);
Py_XDECREF((PyObject*)a);
Py_XDECREF((PyObject*)n);
return result;
}
static PyObject *
GMPY_mpz_is_extrastronglucas_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p;
PyObject *result = 0;
mpz_t zD, s, nmj, nm2, res;
/* these are needed for the LucasU and LucasV part of this function */
mpz_t uh, vl, vh, ql, qh, tmp;
mp_bitcnt_t r = 0, j = 0;
int ret = 0;
if (PyTuple_Size(args) != 2) {
TYPE_ERROR("is_extra_strong_lucas_prp() requires 2 integer arguments");
return NULL;
}
mpz_init(zD);
mpz_init(s);
mpz_init(nmj);
mpz_init(nm2);
mpz_init(res);
mpz_init(uh);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
if (!n || !p) {
TYPE_ERROR("is_extra_strong_lucas_prp() requires 2 integer arguments");
goto cleanup;
}
/* Check if p*p - 4 == 0. */
mpz_mul(zD, p->z, p->z);
mpz_sub_ui(zD, zD, 4);
if (mpz_sgn(zD) == 0) {
VALUE_ERROR("invalid value for p in is_extra_strong_lucas_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_extra_strong_lucas_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check GCD */
mpz_mul_ui(res, zD, 2);
mpz_gcd(res, res, n->z);
if ((mpz_cmp(res, n->z) != 0) && (mpz_cmp_ui(res, 1) > 0)) {
VALUE_ERROR("is_extra_strong_lucas_prp() requires gcd(n,2*D) == 1");
goto cleanup;
}
/* nmj = n - (D/n), where (D/n) is the Jacobi symbol */
mpz_set(nmj, n->z);
ret = mpz_jacobi(zD, n->z);
if (ret == -1)
mpz_add_ui(nmj, nmj, 1);
else if (ret == 1)
mpz_sub_ui(nmj, nmj, 1);
r = mpz_scan1(nmj, 0);
mpz_fdiv_q_2exp(s, nmj, r);
mpz_set(nm2, n->z);
mpz_sub_ui(nm2, nm2, 2);
/* make sure that either U_s == 0 mod n or V_s == +/-2 mod n, or */
/* V_((2^t)*s) == 0 mod n for some t with 0 <= t < r-1 */
mpz_set_si(uh, 1);
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
for (j = mpz_sizeinbase(s,2)-1; j >= 1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(s,j) == 1) {
/* qh = ql*q */
mpz_set(qh, ql);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n->z);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_set(qh, ql);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
mpz_mod(uh, uh, n->z);
mpz_mod(vl, vl, n->z);
/* uh contains LucasU_s and vl contains LucasV_s */
if ((mpz_cmp_ui(uh, 0) == 0) || (mpz_cmp_ui(vl, 0) == 0) ||
(mpz_cmp(vl, nm2) == 0) || (mpz_cmp_si(vl, 2) == 0)) {
result = Py_True;
goto cleanup;
}
for (j = 1; j < r-1; j++) {
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
if (mpz_cmp_ui(vl, 0) == 0) {
result = Py_True;
goto cleanup;
}
}
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(zD);
mpz_clear(s);
mpz_clear(nmj);
mpz_clear(nm2);
mpz_clear(res);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)n);
return result;
}
