static PyObject *
Pympany_copy(PyObject *self, PyObject *other)
{
if (self && Pympz_Check(self))
return (PyObject*)Pympz2Pympz(self);
else if (self && Pyxmpz_Check(self))
return (PyObject*)Pyxmpz2Pyxmpz(self);
else if (self && Pympq_Check(self))
return (PyObject*)Pympq2Pympq(self);
#ifdef WITHMPFR
else if (self && Pympfr_Check(self))
return (PyObject*)Pympfr2Pympfr(self, 0);
#endif
else if (Pympz_Check(other))
return (PyObject*)Pympz2Pympz(other);
else if (Pyxmpz_Check(other))
return (PyObject*)Pyxmpz2Pyxmpz(other);
else if (Pympq_Check(other))
return (PyObject*)Pympq2Pympq(other);
#ifdef WITHMPFR
else if (Pympfr_Check(other))
return (PyObject*)Pympfr2Pympfr(other, 0);
#endif
TYPE_ERROR("_copy() requires a gmpy2 object as argument");
return NULL;
}
static PyObject *
Pympany_binary(PyObject *self, PyObject *other)
{
if (self && Pympz_Check(self))
return Pympz2binary((PympzObject*)self);
else if(self && Pyxmpz_Check(self))
return Pyxmpz2binary((PyxmpzObject*)self);
else if(self && Pympq_Check(self))
return Pympq2binary((PympqObject*)self);
#ifdef WITHMPFR
else if(self && Pympfr_Check(self))
return Pympfr2binary((PympfrObject*)self);
#endif
else if(Pympz_Check(other))
return Pympz2binary((PympzObject*)other);
else if(Pyxmpz_Check(other))
return Pyxmpz2binary((PyxmpzObject*)other);
else if(Pympq_Check(other))
return Pympq2binary((PympqObject*)other);
#ifdef WITHMPFR
else if(Pympfr_Check(other))
return Pympfr2binary((PympfrObject*)other);
#endif
TYPE_ERROR("binary() requires a gmpy2 object as argument");
return NULL;
}
static PyObject *
Pympq_square(PyObject *self, PyObject *other)
{
PympqObject *tempx, *result;
if (!(result = (PympqObject*)Pympq_new()))
return NULL;
if (self && (Pympq_Check(self))) {
mpq_mul(result->q, Pympq_AS_MPQ(self), Pympq_AS_MPQ(self));
}
else if (Pympq_Check(other)) {
mpq_mul(result->q, Pympq_AS_MPQ(other), Pympq_AS_MPQ(other));
}
else {
if (!(tempx = Pympq_From_Rational(other))) {
TYPE_ERROR("square() requires 'mpq' argument");
Py_DECREF((PyObject*)result);
return NULL;
}
else {
mpq_mul(result->q, Pympq_AS_MPQ(tempx), Pympq_AS_MPQ(tempx));
Py_DECREF((PyObject*)tempx);
}
}
return (PyObject*)result;
}
static PyObject *
Pympany_printf(PyObject *self, PyObject *args)
{
PyObject *result = 0, *x = 0;
char *buffer = 0, *fmtcode = 0;
int buflen;
void *generic;
if (!PyArg_ParseTuple(args, "sO", &fmtcode, &x))
return NULL;
if (CHECK_MPZANY(x) || Pympq_Check(x)) {
if (CHECK_MPZANY(x))
generic = Pympz_AS_MPZ(x);
else
generic = Pympq_AS_MPQ(x);
buflen = gmp_asprintf(&buffer, fmtcode, generic);
result = Py_BuildValue("s", buffer);
PyMem_Free(buffer);
return result;
}
#ifdef WITHMPFR
else if(Pympfr_Check(x)) {
generic = Pympfr_AS_MPFR(x);
buflen = mpfr_asprintf(&buffer, fmtcode, generic);
result = Py_BuildValue("s", buffer);
PyMem_Free(buffer);
return result;
}
#endif
else {
TYPE_ERROR("printf() requires a gmpy2 object as argument");
return NULL;
}
}
static PyObject *
Pympq_denom(PyObject *self, PyObject *args)
{
PympzObject *result;
if (!(result = (PympzObject*)Pympz_new()))
return NULL;
SELF_MPQ_NO_ARG;
assert(Pympq_Check(self));
mpz_set(result->z, mpq_denref(Pympq_AS_MPQ(self)));
Py_DECREF(self);
return (PyObject*)result;
}
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 int isOne(PyObject* obj)
{
int overflow = 0;
long temp;
if (!obj)
return 1;
if (Pympq_Check(obj)) {
return (0==mpz_cmp_ui(mpq_denref(Pympq_AS_MPQ(obj)),1)) &&
(0==mpz_cmp_ui(mpq_numref(Pympq_AS_MPQ(obj)),1));
}
else if (Pympz_Check(obj)) {
return 0==mpz_cmp_ui(Pympz_AS_MPZ(obj),1);
}
else if (Pyxmpz_Check(obj)) {
return 0==mpz_cmp_ui(Pyxmpz_AS_MPZ(obj),1);
#ifdef PY2
}
else if (PyInt_Check(obj)) {
return PyInt_AS_LONG(obj)==1;
#endif
}
#ifdef WITHMPFR
else if (Pympfr_Check(obj)) {
return mpfr_get_d(Pympfr_AS_MPFR(obj), context->ctx.mpfr_round)==1.0;
}
#endif
else if (PyFloat_Check(obj)) {
return PyFloat_AS_DOUBLE(obj)==1.0;
}
else if (PyLong_Check(obj)) {
temp = PyLong_AsLongAndOverflow(obj, &overflow);
if (!overflow && temp == 1)
return 1;
else
return 0;
}
return 0;
}
static PyObject *
Pympq_qdiv(PyObject *self, PyObject *args)
{
PyObject *other = 0;
PyObject *s = 0;
int wasone;
if ( self && Pympq_Check(self)) {
if (!PyArg_ParseTuple(args, "|O", &other))
return NULL;
}
else {
if (!PyArg_ParseTuple(args, "O|O", &self, &other))
return NULL;
}
wasone = isOne(other);
/* optimize if self must be returned unchanged */
if (Pympq_Check(self) && wasone) {
/* optimize if self is mpq and result must==self */
if (mpz_cmp_ui(mpq_denref(Pympq_AS_MPQ(self)), 1) != 0) {
Py_INCREF(self);
return self;
}
else {
/* denominator is 1, optimize returning an mpz */
s = Pympz_new();
mpz_set(Pympz_AS_MPZ(s), mpq_numref(Pympq_AS_MPQ(self)));
return s;
}
}
else if (Pympz_Check(self) && wasone) {
/* optimize if self is mpz and result must==self */
Py_INCREF(self);
return self;
}
/* normal, non-optimized case: must make new object as result */
self = (PyObject*)Pympq_From_Rational(self);
if (!self) {
if (!PyErr_Occurred())
TYPE_ERROR("first argument cannot be converted to 'mpq'");
return NULL;
}
if (wasone) { /* self was mpf, float, int, long... */
s = self;
}
else { /* other explicitly present and !=1... must compute */
other = (PyObject*)Pympq_From_Rational(other);
if (!other) {
Py_DECREF(self);
if (!PyErr_Occurred())
TYPE_ERROR("second argument cannot be converted to 'mpq'");
return NULL;
}
if (mpq_sgn(Pympq_AS_MPQ(other))==0) {
PyObject* result = 0;
ZERO_ERROR("division or modulo by zero in qdiv");
Py_DECREF(self);
Py_DECREF(other);
return result;
}
s = Pympq_new();
mpq_div(Pympq_AS_MPQ(s), Pympq_AS_MPQ(self), Pympq_AS_MPQ(other));
Py_DECREF(self);
Py_DECREF(other);
}
if (mpz_cmp_ui(mpq_denref(Pympq_AS_MPQ(s)), 1) != 0) {
return s;
}
else {
/* denominator is 1, return an mpz */
PyObject* ss = Pympz_new();
if (ss)
mpz_set(Pympz_AS_MPZ(ss), mpq_numref(Pympq_AS_MPQ(s)));
Py_DECREF(s);
return ss;
}
}