static PyObject * GMPy_Real_Div_2exp(PyObject *x, PyObject *y, CTXT_Object *context) { MPFR_Object *result, *tempx; unsigned long exp = 0; CHECK_CONTEXT(context); exp = c_ulong_From_Integer(y); if (exp == (unsigned long)(-1) && PyErr_Occurred()) { return NULL; } result = GMPy_MPFR_New(0, context); tempx = GMPy_MPFR_From_Real(x, 1, context); if (!result || !tempx) { Py_XDECREF((PyObject*)result); Py_XDECREF((PyObject*)tempx); return NULL; } mpfr_clear_flags(); result->rc = mpfr_div_2ui(result->f, tempx->f, exp, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); GMPY_MPFR_CLEANUP(result, context, "div_2exp()"); return (PyObject*)result; }
static PyObject * GMPy_Complex_Is_NAN(PyObject *x, CTXT_Object *context) { MPC_Object *tempx; int res; if (MPC_Check(x)) { res = MPC_IS_NAN_P(x); } else { CHECK_CONTEXT(context); if (!(tempx = GMPy_MPC_From_Complex(x, 1, 1, context))) { return NULL; } res = MPC_IS_NAN_P(tempx); Py_DECREF((PyObject*)tempx); } if (res) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } }
static PyObject * GMPy_Complex_Mul_2exp(PyObject *x, PyObject *y, CTXT_Object *context) { MPC_Object *result, *tempx; unsigned long exp = 0; CHECK_CONTEXT(context); exp = c_ulong_From_Integer(y); if (exp == (unsigned long)(-1) && PyErr_Occurred()) { return NULL; } result = GMPy_MPC_New(0, 0, context); tempx = GMPy_MPC_From_Complex(x, 1, 1, context); if (!result || !tempx) { Py_XDECREF((PyObject*)result); Py_XDECREF((PyObject*)tempx); return NULL; } result->rc = mpc_mul_2ui(result->c, tempx->c, exp, GET_MPC_ROUND(context)); Py_DECREF((PyObject*)tempx); GMPY_MPC_CLEANUP(result, context, "mul_2exp()"); return (PyObject*)result; }
static PyObject * GMPy_Real_Is_Integer(PyObject *x, CTXT_Object *context) { MPFR_Object *tempx; int res; if (MPFR_Check(x)) { res = mpfr_integer_p(MPFR(x)); } else { CHECK_CONTEXT(context); if (!(tempx = GMPy_MPFR_From_Real(x, 1, context))) { return NULL; } res = mpfr_integer_p(tempx->f); Py_DECREF((PyObject*)tempx); } if (res) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } }
static PyObject * GMPy_XMPZ_Function_XbitMask(PyObject *self, PyObject *other) { Py_ssize_t i = 0; XMPZ_Object* result; CTXT_Object *context = NULL; CHECK_CONTEXT(context); i = ssize_t_From_Integer(other); if (i == -1 && PyErr_Occurred()) { TYPE_ERROR("xbit_mask() requires 'int' argument"); return NULL; } if (i < 0) { VALUE_ERROR("mask length must be >= 0"); return NULL; } if (!(result = GMPy_XMPZ_New(context))) { return NULL; } mpz_set_ui(result->z, 1); mpz_mul_2exp(result->z, result->z, i); mpz_sub_ui(result->z, result->z, 1); return (PyObject*)result; }
static PyObject * GMPy_Context_Radians(PyObject *self, PyObject *other) { MPFR_Object *result, *tempx, *temp; CTXT_Object *context = NULL; if (self && CTXT_Check(self)) { context = (CTXT_Object*)self; } else { CHECK_CONTEXT(context); } result = GMPy_MPFR_New(0, context); temp = GMPy_MPFR_New(context->ctx.mpfr_prec + 100, context); tempx = GMPy_MPFR_From_Real(other, 1, context); if (!result || !temp || !tempx) { Py_XDECREF((PyObject*)temp); Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)result); return NULL; } mpfr_const_pi(temp->f, MPFR_RNDN); mpfr_div_ui(temp->f, temp->f, 180, MPFR_RNDN); mpfr_mul(result->f, MPFR(self), temp->f, MPFR_RNDN); Py_DECREF((PyObject*)temp); Py_DECREF((PyObject*)tempx); _GMPy_MPFR_Cleanup(&result, context); return (PyObject*)result; }
static PyObject * GMPy_Rational_FloorDiv(PyObject *x, PyObject *y, CTXT_Object *context) { MPZ_Object *result; MPQ_Object *tempq; CHECK_CONTEXT(context); result = GMPy_MPZ_New(context); tempq = GMPy_MPQ_New(context); if (!result || !tempq) { Py_XDECREF((PyObject*)result); Py_XDECREF((PyObject*)tempq); return NULL; } if (MPQ_Check(x) && MPQ_Check(y)) { if (mpq_sgn(MPQ(y)) == 0) { ZERO_ERROR("division or modulo by zero"); goto error; } mpq_div(tempq->q, MPQ(x), MPQ(y)); mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q)); Py_DECREF((PyObject*)tempq); return (PyObject*)result; } if (IS_RATIONAL(x) && IS_RATIONAL(y)) { MPQ_Object *tempx, *tempy; tempx = GMPy_MPQ_From_Number(x, context); tempy = GMPy_MPQ_From_Number(y, context); if (!tempx || !tempy) { Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)tempy); goto error; } if (mpq_sgn(tempy->q) == 0) { ZERO_ERROR("division or modulo by zero"); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); goto error; } mpq_div(tempq->q, tempx->q, tempy->q); mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q)); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); Py_DECREF((PyObject*)tempq); return (PyObject*)result; } Py_DECREF((PyObject*)result); Py_RETURN_NOTIMPLEMENTED; error: Py_DECREF((PyObject*)result); Py_DECREF((PyObject*)tempq); return NULL; }
static PyObject * GMPy_Real_RemQuo(PyObject *x, PyObject *y, CTXT_Object *context) { PyObject *result; MPFR_Object *value, *tempx, *tempy; long quobits = 0; CHECK_CONTEXT(context); value = GMPy_MPFR_New(0, context); tempx = GMPy_MPFR_From_Real(x, 1, context); tempy = GMPy_MPFR_From_Real(y, 1, context); result = PyTuple_New(2); if (!value || !tempx || !tempx || !result) { Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)tempy); Py_XDECREF((PyObject*)value); Py_XDECREF(result); return NULL; } mpfr_clear_flags(); value->rc = mpfr_remquo(value->f, &quobits, tempx->f, tempy->f, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); _GMPy_MPFR_Cleanup(&value, context); PyTuple_SET_ITEM(result, 0, (PyObject*)value); PyTuple_SET_ITEM(result, 1, PyIntOrLong_FromLong(quobits)); return result; }
rc_ReturnCode_t PointerList_PushLast(PointerList* list, void* pointer) { CHECK_CONTEXT(list); // Check if we need to grow the buffer if (list->nbOfElements == list->allocatedSize-1) { // Allocate the new buffer void** buffer = malloc(list->allocatedSize*2*sizeof(*list->buffer)); if (!buffer) return RC_NO_MEMORY; // Copy the data from the previous buffer if (list->readIdx < list->writeIdx) memcpy(buffer, list->buffer + list->readIdx, (list->writeIdx - list->readIdx)*sizeof(*list->buffer)); else { memcpy(buffer, list->buffer + list->readIdx, (list->allocatedSize - list->readIdx)*sizeof(*list->buffer)); memcpy(buffer+(list->allocatedSize - list->readIdx), list->buffer, list->writeIdx*sizeof(*list->buffer)); } free(list->buffer); list->readIdx = 0; list->writeIdx = list->nbOfElements; list->buffer = buffer; list->allocatedSize *= 2; } list->buffer[list->writeIdx] = pointer; list->writeIdx = (list->writeIdx+1) % list->allocatedSize; list->nbOfElements++; return RC_OK; }
rc_ReturnCode_t PointerList_Remove(PointerList* list, unsigned int index, void** pointer) { CHECK_CONTEXT(list); if (index >= list->nbOfElements) { *pointer = NULL; return RC_OUT_OF_RANGE; } unsigned int i = (index+list->readIdx) % list->allocatedSize; *pointer = list->buffer[i]; list->nbOfElements--; unsigned int n; for (n = list->nbOfElements - index; n>0; n--, i++) { if (i == list->allocatedSize-1) { list->buffer[i] = list->buffer[0]; i = 0; } else list->buffer[i] = list->buffer[i+1]; } list->writeIdx = (list->writeIdx - 1 + list->allocatedSize) % list->allocatedSize; return RC_OK; }
static PyObject * GMPy_Real_Frexp(PyObject *x, CTXT_Object *context) { PyObject *result; MPFR_Object *value, *tempx; mpfr_exp_t exp = 0; CHECK_CONTEXT(context); value = GMPy_MPFR_New(0, context); tempx = GMPy_MPFR_From_Real(x, 1, context); result = PyTuple_New(2); if (!value || !result || !tempx) { Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)value); Py_XDECREF(result); return NULL; } mpfr_clear_flags(); value->rc = mpfr_frexp(&exp, value->f, tempx->f, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); _GMPy_MPFR_Cleanup(&value, context); PyTuple_SET_ITEM(result, 0, PyIntOrLong_FromSsize_t((Py_ssize_t)exp)); PyTuple_SET_ITEM(result, 1, (PyObject*)value); return result; }
static PyObject * GMPy_Real_Lgamma(PyObject *x, CTXT_Object *context) { PyObject *result; MPFR_Object *value, *tempx; int signp = 0; CHECK_CONTEXT(context) tempx = GMPy_MPFR_From_Real(x, 1, context); value = GMPy_MPFR_New(0, context); result = PyTuple_New(2); if (!tempx || !value || !result) { Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)value); Py_XDECREF(result); return NULL; } mpfr_clear_flags(); value->rc = mpfr_lgamma(value->f, &signp, tempx->f, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); _GMPy_MPFR_Cleanup(&value, context); if (!value) { Py_DECREF(result); return NULL; } PyTuple_SET_ITEM(result, 0, (PyObject*)value); PyTuple_SET_ITEM(result, 1, PyIntOrLong_FromLong((long)signp)); return result; }
static PyObject * GMPy_Context_NextBelow(PyObject *self, PyObject *other) { MPFR_Object *result, *tempx; CTXT_Object *context = NULL; mpfr_rnd_t temp_round; if (self && CTXT_Check(self)) { context = (CTXT_Object*)self; } else { CHECK_CONTEXT(context); } if (!(tempx = GMPy_MPFR_From_Real(other, 1, context))) { TYPE_ERROR("next_below() argument type not supported"); return NULL; } if (!(result = GMPy_MPFR_New(mpfr_get_prec(tempx->f), context))) { Py_DECREF((PyObject*)tempx); return NULL; } mpfr_clear_flags(); mpfr_set(result->f, tempx->f, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); mpfr_nextbelow(result->f); result->rc = 0; temp_round = GET_MPFR_ROUND(context); context->ctx.mpfr_round = MPFR_RNDD; _GMPy_MPFR_Cleanup(&result, context); context->ctx.mpfr_round = temp_round; return (PyObject*)result; }
static PyObject * GMPy_Complex_Rect(PyObject *x, PyObject *y, CTXT_Object *context) { MPFR_Object *tempx, *tempy; MPC_Object *result; CHECK_CONTEXT(context); tempx = GMPy_MPFR_From_Real(x, 1, context); tempy = GMPy_MPFR_From_Real(y, 1, context); result = GMPy_MPC_New(0, 0, context); if (!tempx || !tempy || !result) { Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)tempy); Py_XDECREF((PyObject*)result); return NULL; } mpfr_cos(mpc_realref(result->c), tempy->f, GET_REAL_ROUND(context)); mpfr_mul(mpc_realref(result->c), mpc_realref(result->c), tempx->f, GET_REAL_ROUND(context)); mpfr_sin(mpc_imagref(result->c), tempy->f, GET_IMAG_ROUND(context)); mpfr_mul(mpc_imagref(result->c), mpc_imagref(result->c), tempx->f, GET_IMAG_ROUND(context)); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); GMPY_MPC_CLEANUP(result, context, "rect()"); return (PyObject*)result; }
static PyObject * GMPy_Context_Factorial(PyObject *self, PyObject *other) { MPFR_Object *result; long n; CTXT_Object *context = NULL; if (self && CTXT_Check(self)) { context = (CTXT_Object*)self; } else { CHECK_CONTEXT(context); } n = PyLong_AsLong(other); if ((n == -1) && PyErr_Occurred()) { TYPE_ERROR("factorial() requires 'int' argument"); return NULL; } if (n < 0) { VALUE_ERROR("factorial() of negative number"); return NULL; } if (!(result = GMPy_MPFR_New(0, context))) { return NULL; } mpfr_clear_flags(); mpfr_fac_ui(result->f, n, GET_MPFR_ROUND(context)); _GMPy_MPFR_Cleanup(&result, context); return (PyObject*)result; }
static MPC_Object * GMPy_MPC_From_PyComplex(PyObject *obj, mpfr_prec_t rprec, mpfr_prec_t iprec, CTXT_Object *context) { MPC_Object *result; assert(PyComplex_Check(obj)); CHECK_CONTEXT(context); if (rprec == 0) rprec = GET_REAL_PREC(context); else if (rprec == 1) rprec = DBL_MANT_DIG; if (iprec == 0) iprec = GET_IMAG_PREC(context); else if (iprec == 1) rprec = DBL_MANT_DIG; if ((result = GMPy_MPC_New(rprec, iprec, context))) { result->rc = mpc_set_d_d(result->c, PyComplex_RealAsDouble(obj), PyComplex_ImagAsDouble(obj), GET_MPC_ROUND(context)); if (rprec != 1 || iprec != 1) { GMPY_MPC_CHECK_RANGE(result, context); } GMPY_MPC_SUBNORMALIZE(result, context); GMPY_MPC_EXCEPTIONS(result, context); } return result; }
static PyObject * GMPy_Complex_Polar(PyObject *x, CTXT_Object *context) { PyObject *tempx, *abs, *phase, *result; CHECK_CONTEXT(context); if (!(tempx = (PyObject*)GMPy_MPC_From_Complex(x, 1, 1, context))) { return NULL; } abs = GMPy_Complex_Abs(tempx, context); phase = GMPy_Complex_Phase(tempx, context); Py_DECREF(tempx); result = PyTuple_New(2); if (!abs || !phase || !result) { Py_XDECREF(abs); Py_XDECREF(phase); Py_XDECREF(result); return NULL; } PyTuple_SET_ITEM(result, 0, abs); PyTuple_SET_ITEM(result, 1, phase); return result; }
static PyObject * GMPy_PyStr_From_MPC(MPC_Object *self, int base, int digits, CTXT_Object *context) { PyObject *tempreal = 0, *tempimag = 0, *result; CHECK_CONTEXT(context); if (!((base >= 2) && (base <= 62))) { VALUE_ERROR("base must be in the interval [2,62]"); return NULL; } if ((digits < 0) || (digits == 1)) { VALUE_ERROR("digits must be 0 or >= 2"); return NULL; } tempreal = mpfr_ascii(mpc_realref(self->c), base, digits, MPC_RND_RE(GET_MPC_ROUND(context))); tempimag = mpfr_ascii(mpc_imagref(self->c), base, digits, MPC_RND_IM(GET_MPC_ROUND(context))); if (!tempreal || !tempimag) { Py_XDECREF(tempreal); Py_XDECREF(tempimag); return NULL; } result = Py_BuildValue("(NN)", tempreal, tempimag); if (!result) { Py_DECREF(tempreal); Py_DECREF(tempimag); } return result; }
static MPC_Object * GMPy_MPC_From_MPQ(MPQ_Object *obj, mpfr_prec_t rprec, mpfr_prec_t iprec, CTXT_Object *context) { MPC_Object *result = NULL; assert(MPQ_Check(obj)); CHECK_CONTEXT(context); if (rprec == 0 || rprec == 1) rprec = GET_REAL_PREC(context) + rprec * GET_GUARD_BITS(context); if (iprec == 0 || iprec == 1) iprec = GET_IMAG_PREC(context) + iprec * GET_GUARD_BITS(context); if ((result = GMPy_MPC_New(rprec, iprec, context))) { result->rc = mpc_set_q(result->c, obj->q, GET_MPC_ROUND(context)); if (rprec != 1) { GMPY_MPC_CHECK_RANGE(result, context); } GMPY_MPC_SUBNORMALIZE(result, context); GMPY_MPC_EXCEPTIONS(result, context); } return result; }
static MPC_Object * GMPy_MPC_From_MPFR(MPFR_Object *obj, mpfr_prec_t rprec, mpfr_prec_t iprec, CTXT_Object *context) { MPC_Object *result; assert(MPFR_Check(obj)); CHECK_CONTEXT(context); if (rprec == 0) rprec = GET_REAL_PREC(context); else if (rprec == 1) rprec = mpfr_get_prec(obj->f); if (iprec == 0) iprec = GET_IMAG_PREC(context); else if (iprec == 1) rprec = mpfr_get_prec(obj->f); if ((result = GMPy_MPC_New(rprec, iprec, context))) { result->rc = mpc_set_fr(result->c, obj->f, GET_MPC_ROUND(context)); if (rprec != 1) { GMPY_MPC_CHECK_RANGE(result, context); } GMPY_MPC_SUBNORMALIZE(result, context); GMPY_MPC_EXCEPTIONS(result, context); } return result; }
static PyObject * GMPy_Real_Round2(PyObject *x, PyObject *y, CTXT_Object *context) { MPFR_Object *result, *tempx; long n = 0; CHECK_CONTEXT(context); if (y) { n = PyIntOrLong_AsLong(y); if ( (n == -1 && PyErr_Occurred()) || n < MPFR_PREC_MIN || n > MPFR_PREC_MAX) { VALUE_ERROR("invalid precision"); return NULL; } } if (!(tempx = GMPy_MPFR_From_Real(x, 1, context))) { return NULL; } if (!(result = GMPy_MPFR_New(mpfr_get_prec(tempx->f), context))) { Py_DECREF((PyObject*)tempx); return NULL; } mpfr_set(result->f, tempx->f, GET_MPFR_ROUND(context)); Py_DECREF((PyObject*)tempx); mpfr_clear_flags(); result->rc = mpfr_prec_round(result->f, n, GET_MPFR_ROUND(context)); _GMPy_MPFR_Cleanup(&result, context); return (PyObject*)result; }
static PyObject * GMPy_Complex_Abs(PyObject *x, CTXT_Object *context) { MPFR_Object *result = NULL; MPC_Object *tempx = NULL; CHECK_CONTEXT(context); if (!(tempx = GMPy_MPC_From_Complex(x, 1, 1, context)) || !(result = GMPy_MPFR_New(0, context))) { /* LCOV_EXCL_START */ Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)result); return NULL; /* LCOV_EXCL_STOP */ } mpfr_clear_flags(); SET_MPC_WAS_NAN(context, tempx); result->rc = mpc_abs(result->f, tempx->c, GET_MPC_ROUND(context)); Py_DECREF((PyObject*)tempx); _GMPy_MPFR_Cleanup(&result, context); return (PyObject*)result; }
static PyObject * GMPy_Real_RelDiff(PyObject *x, PyObject *y, CTXT_Object *context) { MPFR_Object *tempx, *tempy, *result; CHECK_CONTEXT(context); result = GMPy_MPFR_New(0, context); tempx = GMPy_MPFR_From_Real(x, 1, context); tempy = GMPy_MPFR_From_Real(y, 1, context); if (!result || !tempx || !tempy) { Py_XDECREF((PyObject*)result); Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)tempy); return NULL; } mpfr_clear_flags(); mpfr_reldiff(result->f, tempx->f, tempy->f, GET_MPFR_ROUND(context)); result->rc = 0; _GMPy_MPFR_Cleanup(&result, context); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); return (PyObject*)result; }
static PyObject * GMPy_MPFR_Add_Slot(PyObject *x, PyObject *y) { if (MPFR_Check(x) && MPFR_Check(y)) { MPFR_Object *result; CTXT_Object *context = NULL; CHECK_CONTEXT(context); if ((result = GMPy_MPFR_New(0, context))) { mpfr_clear_flags(); SET_MPFR_MPFR_WAS_NAN(context, x, y); result->rc = mpfr_add(result->f, MPFR(x), MPFR(y), GET_MPFR_ROUND(context)); _GMPy_MPFR_Cleanup(&result, context); } return (PyObject*)result; } if (IS_REAL(x) && IS_REAL(y)) return GMPy_Real_Add(x, y, NULL); if (IS_COMPLEX(x) && IS_COMPLEX(y)) return GMPy_Complex_Add(x, y, NULL); Py_RETURN_NOTIMPLEMENTED; }
rc_ReturnCode_t PointerList_Destroy(PointerList* list) { CHECK_CONTEXT(list); list->magic = ~list->magic; free(list->buffer); free(list); return RC_OK; }
static PyObject * GMPy_MPZ_Factory(PyObject *self, PyObject *args, PyObject *keywds) { MPZ_Object *result = NULL; PyObject *n; int base = 0; Py_ssize_t argc; static char *kwlist[] = {"s", "base", NULL }; CTXT_Object *context = NULL; CHECK_CONTEXT(context) /* Optimize the most common use cases first; either 0 or 1 argument */ argc = PyTuple_GET_SIZE(args); if (argc == 0) { if ((result = GMPy_MPZ_New(context))) { mpz_set_ui(result->z, 0); } return (PyObject*)result; } if (argc == 1 && !keywds) { n = PyTuple_GET_ITEM(args, 0); if (IS_REAL(n)) { result = GMPy_MPZ_From_Number(n, context); } else if (PyStrOrUnicode_Check(n)) { result = GMPy_MPZ_From_PyStr(n, base, context); } else { TYPE_ERROR("mpz() requires numeric or string argument"); } return (PyObject*)result; } if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|i", kwlist, &n, &base)) { return NULL; } if ((base != 0) && ((base < 2)|| (base > 62))) { VALUE_ERROR("base for mpz() must be 0 or in the interval [2, 62]"); return NULL; } if (PyStrOrUnicode_Check(n)) { result = GMPy_MPZ_From_PyStr(n, base, context); } else if (IS_REAL(n)) { TYPE_ERROR("mpz() with number argument only takes 1 argument"); } else { TYPE_ERROR("mpz() requires numeric or string (and optional base) arguments"); } return (PyObject*)result; }
static PyObject * GMPy_XMPZ_Method_Copy(PyObject *self, PyObject *other) { CTXT_Object *context = NULL; CHECK_CONTEXT(context); return (PyObject*)GMPy_XMPZ_From_XMPZ((XMPZ_Object*)self, context); }
/* hex/oct formatting (mpz-only) */ static PyObject * GMPy_XMPZ_Oct_Slot(XMPZ_Object *self) { CTXT_Object *context = NULL; CHECK_CONTEXT(context); return GMPy_PyStr_From_XMPZ(self, 8, 0, context); }
static PyObject * GMPy_Real_DivMod(PyObject *x, PyObject *y, CTXT_Object *context) { CHECK_CONTEXT(context); if (GET_DIVMOD_EXACT(context)) return GMPy_Real_DivMod_2(x, y, context); else return GMPy_Real_DivMod_1(x, y, context); }
rc_ReturnCode_t PointerList_GetSize(PointerList* list, unsigned int* nbOfElements, unsigned int* allocatedSize) { CHECK_CONTEXT(list); if (nbOfElements) *nbOfElements = list->nbOfElements; if (allocatedSize) *allocatedSize = list->allocatedSize; return RC_OK; }