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 * Pygmpy_xmpz(PyObject *self, PyObject *args, PyObject *keywds) { PyxmpzObject *result = 0; PyObject *n = 0; long base = 0; Py_ssize_t argc; static char *kwlist[] = {"n", "base", NULL }; /* Optimize the most common use case */ argc = PyTuple_Size(args); if (argc == 1) { n = PyTuple_GetItem(args, 0); #ifdef WITHMPFR if (isReal(n) && !keywds) { #else if ((isRational(n) || PyFloat_Check(n)) && !keywds) { #endif result = Pyxmpz_From_Number(n); if (!result && !PyErr_Occurred()) TYPE_ERROR("xmpz() requires numeric or string argument"); return (PyObject*)result; } } if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|l", kwlist, &n, &base)) return NULL; if ((base!=0) && ((base<2)||(base>62))) { VALUE_ERROR("base for xmpz() must be 0 or in the " "interval 2 ... 62"); return NULL; } if (PyStrOrUnicode_Check(n)) { /* build-from-string (ascii or unicode) */ result = Pyxmpz_From_PyStr(n, base); } else { if (argc==2 || (argc == 1 && keywds)) TYPE_ERROR("xmpz() with non-string argument needs exactly " "1 argument"); else { result = Pyxmpz_From_Number(n); if (!result && !PyErr_Occurred()) TYPE_ERROR("xmpz() requires numeric or string argument"); } } return (PyObject*)result; } /* For many xmpz_functions, the doc-strings are in gmpy_mpz.c. */ static PyObject * Pyxmpz_digits(PyObject *self, PyObject *args) { long base = 10; PyObject *result; PARSE_ONE_MPZ_OPT_CLONG(&base, "digits() requires 'int' argument for base"); result = Pyxmpz_To_PyStr((PyxmpzObject*)self, base, 0); Py_DECREF(self); return result; }
static PyObject * GMPy_MPQ_Factory(PyObject *self, PyObject *args, PyObject *keywds) { MPQ_Object *result, *temp; PyObject *n, *m; int base = 10; Py_ssize_t argc, keywdc = 0; static char *kwlist[] = {"s", "base", NULL }; CTXT_Object *context = NULL; if (self && CTXT_Check(self)) { context = (CTXT_Object*)self; } else { CHECK_CONTEXT(context); } argc = PyTuple_Size(args); if (keywds) { keywdc = PyDict_Size(keywds); } if (argc + keywdc > 2) { TYPE_ERROR("mpq() takes at most 2 arguments"); return NULL; } if (argc + keywdc == 0) { if ((result = GMPy_MPQ_New(context))) { mpq_set_ui(result->q, 0, 1); } return (PyObject*)result; } if (argc == 0) { TYPE_ERROR("mpq() requires at least one non-keyword argument"); return NULL; } n = PyTuple_GetItem(args, 0); /* Handle the case where the first argument is a string. */ if (PyStrOrUnicode_Check(n)) { /* keyword base is legal */ if (keywdc || argc > 1) { if (!(PyArg_ParseTupleAndKeywords(args, keywds, "O|i", kwlist, &n, &base))) { return NULL; } } if ((base != 0) && ((base < 2) || (base > 62))) { VALUE_ERROR("base for mpq() must be 0 or in the interval [2, 62]"); return NULL; } return (PyObject*)GMPy_MPQ_From_PyStr(n, base, context); } /* Handle 1 argument. It must be non-complex number. */ if (argc == 1) { if (IS_REAL(n)) { return (PyObject*)GMPy_MPQ_From_Number(n, context); } } /* Handle 2 arguments. Both arguments must be integer or rational. */ if (argc == 2) { m = PyTuple_GetItem(args, 1); if (IS_RATIONAL(n) && IS_RATIONAL(m)) { result = GMPy_MPQ_From_Rational(n, context); temp = GMPy_MPQ_From_Rational(m, context); if (!result || !temp) { Py_XDECREF((PyObject*)result); Py_XDECREF((PyObject*)temp); return NULL; } if (mpq_sgn(temp->q) == 0) { ZERO_ERROR("zero denominator in mpq()"); Py_DECREF((PyObject*)result); Py_DECREF((PyObject*)temp); return NULL; } mpq_div(result->q, result->q, temp->q); Py_DECREF((PyObject*)temp); return (PyObject*)result; } } TYPE_ERROR("mpq() requires numeric or string argument"); return NULL; }
static PyObject * Pygmpy_mpq(PyObject *self, PyObject *args, PyObject *keywds) { PympqObject *result = 0, *temp; PyObject *n = 0, *m = 0; int base = 10; Py_ssize_t argc; static char *kwlist[] = {"s", "base", NULL }; argc = PyTuple_Size(args); if (argc > 2) { TYPE_ERROR("mpq() requires 0, 1 or 2 arguments"); return NULL; } if (argc == 0) { if ((result = (PympqObject*)Pympq_new())) { mpq_set_ui(result->q, 0, 0); } return (PyObject*)result; } n = PyTuple_GetItem(args, 0); if (PyStrOrUnicode_Check(n)) { /* keyword base is legal */ if (PyArg_ParseTupleAndKeywords(args, keywds, "O|i", kwlist, &n, &base)) { if ((base!=0) && ((base<2)||(base>62))) { VALUE_ERROR("base for mpq() must be 0 or in the " "interval 2 ... 62"); } else { result = Pympq_From_PyStr(n, base); } } return (PyObject*)result; } if (isDecimal(n)) { return (PyObject*)Pympq_From_Decimal(n); } if (argc == 2) m = PyTuple_GetItem(args, 1); #ifdef WITHMPFR if (!isReal(n) || (m && !isReal(m))) { #else if (!(isRational(n) || PyFloat_Check(n)) || (m && !(isRational(m) || PyFloat_Check(m)))) { #endif TYPE_ERROR("mpq() requires numeric or string argument"); return NULL; } /* should now have one or two numeric values */ result = Pympq_From_Number(n); if (!result && !PyErr_Occurred()) { TYPE_ERROR("mpq() requires numeric or string argument"); return NULL; } if (m) { temp = Pympq_From_Number(m); if (!temp && !PyErr_Occurred()) { TYPE_ERROR("mpq() requires numeric or string argument"); Py_DECREF((PyObject*)result); return NULL; } if (mpq_sgn(temp->q) == 0) { ZERO_ERROR("zero denominator in 'mpq'"); Py_DECREF((PyObject*)result); Py_DECREF((PyObject*)temp); return NULL; } mpq_div(result->q, result->q, temp->q); Py_DECREF((PyObject*)temp); } return (PyObject*)result; } /* Functions that operate strictly on mpq. */ /* produce digits for an mpq in requested base, default 10 */ PyDoc_STRVAR(doc_qdigitsm, "x.digits([base=10]) -> string\n\n" "Return a Python string representing x in the given base (2 to 62,\n" "default is 10). A leading '-' is present if x<0, but no leading '+'\n" "is present if x>=0.\n"); static PyObject * Pympq_digits(PyObject *self, PyObject *args) { int base = 10; PyObject *result; SELF_MPQ_ONE_ARG("|i", &base); result = Pympq_To_PyStr((PympqObject*)self, base, 0); Py_DECREF(self); return result; }