}
}
+/* Macro and helper that convert PyObject obj to a C double and store
+ the value in dbl; this replaces the functionality of the coercion
+ slot function */
+
+#define CONVERT_TO_DOUBLE(obj, dbl) \
+ if (PyFloat_Check(obj)) \
+ dbl = PyFloat_AS_DOUBLE(obj); \
+ else if (convert_to_double(&(obj), &(dbl)) < 0) \
+ return obj;
+
+static int
+convert_to_double(PyObject **v,
+ double *dbl)
+{
+ register PyObject *obj = *v;
+
+ if (PyInt_Check(obj)) {
+ *dbl = (double)PyInt_AS_LONG(obj);
+ }
+ else if (PyLong_Check(obj)) {
+ PyFPE_START_PROTECT("convert_to_double", {*v=NULL;return -1;})
+ *dbl = PyLong_AsDouble(obj);
+ PyFPE_END_PROTECT(result)
+ }
+ else {
+ Py_INCREF(Py_NotImplemented);
+ *v = Py_NotImplemented;
+ return -1;
+ }
+ return 0;
+}
+
/* Precisions used by repr() and str(), respectively.
The repr() precision (17 significant decimal digits) is the minimal number
return (i < j) ? -1 : (i > j) ? 1 : 0;
}
+/* Needed for the new style number compare slots */
+static PyObject *
+float_cmp(PyObject *v, PyObject *w)
+{
+ double a,b;
+ CONVERT_TO_DOUBLE(v, a);
+ CONVERT_TO_DOUBLE(w, b);
+ return PyInt_FromLong((a < b) ? -1 : (a > b) ? 1 : 0);
+}
static long
float_hash(PyFloatObject *v)
}
static PyObject *
-float_add(PyFloatObject *v, PyFloatObject *w)
+float_add(PyObject *v, PyObject *w)
{
- double result;
+ double a,b;
+ CONVERT_TO_DOUBLE(v, a);
+ CONVERT_TO_DOUBLE(w, b);
PyFPE_START_PROTECT("add", return 0)
- result = v->ob_fval + w->ob_fval;
- PyFPE_END_PROTECT(result)
- return PyFloat_FromDouble(result);
+ a = a + b;
+ PyFPE_END_PROTECT(a)
+ return PyFloat_FromDouble(a);
}
static PyObject *
-float_sub(PyFloatObject *v, PyFloatObject *w)
+float_sub(PyObject *v, PyObject *w)
{
- double result;
+ double a,b;
+ CONVERT_TO_DOUBLE(v, a);
+ CONVERT_TO_DOUBLE(w, b);
PyFPE_START_PROTECT("subtract", return 0)
- result = v->ob_fval - w->ob_fval;
- PyFPE_END_PROTECT(result)
- return PyFloat_FromDouble(result);
+ a = a - b;
+ PyFPE_END_PROTECT(a)
+ return PyFloat_FromDouble(a);
}
static PyObject *
-float_mul(PyFloatObject *v, PyFloatObject *w)
+float_mul(PyObject *v, PyObject *w)
{
- double result;
-
+ double a,b;
+ CONVERT_TO_DOUBLE(v, a);
+ CONVERT_TO_DOUBLE(w, b);
PyFPE_START_PROTECT("multiply", return 0)
- result = v->ob_fval * w->ob_fval;
- PyFPE_END_PROTECT(result)
- return PyFloat_FromDouble(result);
+ a = a * b;
+ PyFPE_END_PROTECT(a)
+ return PyFloat_FromDouble(a);
}
static PyObject *
-float_div(PyFloatObject *v, PyFloatObject *w)
+float_div(PyObject *v, PyObject *w)
{
- double result;
- if (w->ob_fval == 0) {
+ double a,b;
+ CONVERT_TO_DOUBLE(v, a);
+ CONVERT_TO_DOUBLE(w, b);
+ if (b == 0.0) {
PyErr_SetString(PyExc_ZeroDivisionError, "float division");
return NULL;
}
PyFPE_START_PROTECT("divide", return 0)
- result = v->ob_fval / w->ob_fval;
- PyFPE_END_PROTECT(result)
- return PyFloat_FromDouble(result);
+ a = a / b;
+ PyFPE_END_PROTECT(a)
+ return PyFloat_FromDouble(a);
}
static PyObject *
-float_rem(PyFloatObject *v, PyFloatObject *w)
+float_rem(PyObject *v, PyObject *w)
{
double vx, wx;
double mod;
- wx = w->ob_fval;
+ CONVERT_TO_DOUBLE(v, vx);
+ CONVERT_TO_DOUBLE(w, wx);
if (wx == 0.0) {
PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
return NULL;
}
PyFPE_START_PROTECT("modulo", return 0)
- vx = v->ob_fval;
mod = fmod(vx, wx);
/* note: checking mod*wx < 0 is incorrect -- underflows to
0 if wx < sqrt(smallest nonzero double) */
}
static PyObject *
-float_divmod(PyFloatObject *v, PyFloatObject *w)
+float_divmod(PyObject *v, PyObject *w)
{
double vx, wx;
double div, mod, floordiv;
- wx = w->ob_fval;
+ CONVERT_TO_DOUBLE(v, vx);
+ CONVERT_TO_DOUBLE(w, wx);
if (wx == 0.0) {
PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
return NULL;
}
PyFPE_START_PROTECT("divmod", return 0)
- vx = v->ob_fval;
mod = fmod(vx, wx);
/* fmod is typically exact, so vx-mod is *mathematically* an
exact multiple of wx. But this is fp arithmetic, and fp
}
static PyObject *
-float_pow(PyFloatObject *v, PyObject *w, PyFloatObject *z)
+float_pow(PyObject *v, PyObject *w, PyObject *z)
{
double iv, iw, ix;
long intw;
* long integers. Maybe something clever with logarithms could be done.
* [AMK]
*/
- iv = v->ob_fval;
- iw = ((PyFloatObject *)w)->ob_fval;
+ CONVERT_TO_DOUBLE(v, iv);
+ CONVERT_TO_DOUBLE(w, iw);
intw = (long)iw;
/* Sort out special cases here instead of relying on pow() */
if (iw == 0) { /* x**0 is 1, even 0**0 */
PyFPE_START_PROTECT("pow", return NULL)
if ((PyObject *)z != Py_None) {
- ix = fmod(1.0, z->ob_fval);
- if (ix != 0 && z->ob_fval < 0)
- ix += z->ob_fval;
+ double iz;
+ CONVERT_TO_DOUBLE(w, iz);
+ ix=fmod(1.0, iz);
+ if (ix!=0 && iz<0) ix+=iz;
}
else
ix = 1.0;
return NULL;
}
if ((PyObject *)z != Py_None) {
- PyFPE_START_PROTECT("pow", return NULL)
- ix = fmod(ix, z->ob_fval); /* XXX To Be Rewritten */
- if (ix != 0 &&
- ((iv < 0 && z->ob_fval > 0) ||
- (iv > 0 && z->ob_fval < 0)
- )) {
- ix += z->ob_fval;
+ double iz;
+ CONVERT_TO_DOUBLE(z, iz);
+ PyFPE_START_PROTECT("pow", return 0)
+ ix=fmod(ix, iz); /* XXX To Be Rewritten */
+ if (ix!=0 && ((iv<0 && iz>0) || (iv>0 && iz<0) )) {
+ ix+=iz;
}
- PyFPE_END_PROTECT(ix)
+ PyFPE_END_PROTECT(ix)
}
return PyFloat_FromDouble(ix);
}
(unaryfunc)float_float, /*nb_float*/
0, /*nb_oct*/
0, /*nb_hex*/
+ 0, /*nb_inplace_add*/
+ 0, /*nb_inplace_subtract*/
+ 0, /*nb_inplace_multiply*/
+ 0, /*nb_inplace_divide*/
+ 0, /*nb_inplace_remainder*/
+ 0, /*nb_inplace_power*/
+ 0, /*nb_inplace_lshift*/
+ 0, /*nb_inplace_rshift*/
+ 0, /*nb_inplace_and*/
+ 0, /*nb_inplace_xor*/
+ 0, /*nb_inplace_or*/
+
+ /* New style slots: */
+ (binaryfunc)float_cmp, /*nb_cmp*/
};
PyTypeObject PyFloat_Type = {
(hashfunc)float_hash, /*tp_hash*/
0, /*tp_call*/
(reprfunc)float_str, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_NEWSTYLENUMBER /*tp_flags*/
};
void
projects / python / commitdiff