static PyObject * complex_divmod(PyObject *v, PyObject *w) { Py_complex div, mod; PyObject *d, *m, *z; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); if (PyErr_Warn(PyExc_DeprecationWarning, "complex divmod(), // and % are deprecated") < 0) return NULL; errno = 0; div = c_quot(a, b); /* The raw divisor value. */ if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()"); return NULL; } div.real = floor(div.real); /* Use the floor of the real part. */ div.imag = 0.0; mod = c_diff(a, c_prod(b, div)); d = PyComplex_FromCComplex(div); m = PyComplex_FromCComplex(mod); z = PyTuple_Pack(2, d, m); Py_XDECREF(d); Py_XDECREF(m); return z; }
static PyObject * complex_richcompare(PyObject *v, PyObject *w, int op) { PyObject *res; Py_complex i; int equal; if (op != Py_EQ && op != Py_NE) { goto Unimplemented; } assert(PyComplex_Check(v)); TO_COMPLEX(v, i); if (PyLong_Check(w)) { /* Check for 0.0 imaginary part first to avoid the rich * comparison when possible. */ if (i.imag == 0.0) { PyObject *j, *sub_res; j = PyFloat_FromDouble(i.real); if (j == NULL) return NULL; sub_res = PyObject_RichCompare(j, w, op); Py_DECREF(j); return sub_res; } else { equal = 0; } } else if (PyFloat_Check(w)) { equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0); } else if (PyComplex_Check(w)) { Py_complex j; TO_COMPLEX(w, j); equal = (i.real == j.real && i.imag == j.imag); } else { goto Unimplemented; } if (equal == (op == Py_EQ)) res = Py_True; else res = Py_False; Py_INCREF(res); return res; Unimplemented: Py_RETURN_NOTIMPLEMENTED; }
static PyObject * complex_mul(PyObject *v, PyObject *w) { Py_complex result; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); PyFPE_START_PROTECT("complex_mul", return 0) result = _Py_c_prod(a, b); PyFPE_END_PROTECT(result) return PyComplex_FromCComplex(result); }
static PyObject * complex_sub(PyObject *v, PyObject *w) { Py_complex result; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b);; PyFPE_START_PROTECT("complex_sub", return 0) result = c_diff(a, b); PyFPE_END_PROTECT(result) return PyComplex_FromCComplex(result); }
static PyObject * complex_div(PyObject *v, PyObject *w) { Py_complex quot; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); PyFPE_START_PROTECT("complex_div", return 0) errno = 0; quot = _Py_c_quot(a, b); PyFPE_END_PROTECT(quot) if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero"); return NULL; } return PyComplex_FromCComplex(quot); }
static PyObject * complex_int_div(PyObject *v, PyObject *w) { PyObject *t, *r; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); if (PyErr_Warn(PyExc_DeprecationWarning, "complex divmod(), // and % are deprecated") < 0) return NULL; t = complex_divmod(v, w); if (t != NULL) { r = PyTuple_GET_ITEM(t, 0); Py_INCREF(r); Py_DECREF(t); return r; } return NULL; }
static PyObject * complex_classic_div(PyObject *v, PyObject *w) { Py_complex quot; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); if (Py_DivisionWarningFlag >= 2 && PyErr_Warn(PyExc_DeprecationWarning, "classic complex division") < 0) return NULL; PyFPE_START_PROTECT("complex_classic_div", return 0) errno = 0; quot = c_quot(a, b); PyFPE_END_PROTECT(quot) if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero"); return NULL; } return PyComplex_FromCComplex(quot); }
static PyObject * complex_richcompare(PyObject *v, PyObject *w, int op) { PyObject *res; Py_complex i, j; TO_COMPLEX(v, i); TO_COMPLEX(w, j); if (op != Py_EQ && op != Py_NE) { /* XXX Should eventually return NotImplemented */ PyErr_SetString(PyExc_TypeError, "no ordering relation is defined for complex numbers"); return NULL; } if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ)) res = Py_True; else res = Py_False; Py_INCREF(res); return res; }
static PyObject * complex_pow(PyObject *v, PyObject *w, PyObject *z) { Py_complex p; Py_complex exponent; long int_exponent; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); if (z!=Py_None) { PyErr_SetString(PyExc_ValueError, "complex modulo"); return NULL; } PyFPE_START_PROTECT("complex_pow", return 0) errno = 0; exponent = b; int_exponent = (long)exponent.real; if (exponent.imag == 0. && exponent.real == int_exponent) p = c_powi(a,int_exponent); else p = c_pow(a,exponent); PyFPE_END_PROTECT(p) Py_ADJUST_ERANGE2(p.real, p.imag); if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "0.0 to a negative or complex power"); return NULL; } else if (errno == ERANGE) { PyErr_SetString(PyExc_OverflowError, "complex exponentiation"); return NULL; } return PyComplex_FromCComplex(p); }
static PyObject * complex_richcompare(PyObject *v, PyObject *w, int op) { PyObject *res; Py_complex i; int equal; if (op != Py_EQ && op != Py_NE) { /* for backwards compatibility, comparisons with non-numbers return * NotImplemented. Only comparisons with core numeric types raise * TypeError. */ if (PyInt_Check(w) || PyLong_Check(w) || PyFloat_Check(w) || PyComplex_Check(w)) { PyErr_SetString(PyExc_TypeError, "no ordering relation is defined " "for complex numbers"); return NULL; } goto Unimplemented; } assert(PyComplex_Check(v)); TO_COMPLEX(v, i); if (PyInt_Check(w) || PyLong_Check(w)) { /* Check for 0.0 imaginary part first to avoid the rich * comparison when possible. */ if (i.imag == 0.0) { PyObject *j, *sub_res; j = PyFloat_FromDouble(i.real); if (j == NULL) return NULL; sub_res = PyObject_RichCompare(j, w, op); Py_DECREF(j); return sub_res; } else { equal = 0; } } else if (PyFloat_Check(w)) { equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0); } else if (PyComplex_Check(w)) { Py_complex j; TO_COMPLEX(w, j); equal = (i.real == j.real && i.imag == j.imag); } else { goto Unimplemented; } if (equal == (op == Py_EQ)) res = Py_True; else res = Py_False; Py_INCREF(res); return res; Unimplemented: Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }