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