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; }