Author: Manuel Jacob
Branch: remove-remaining-smm
Changeset: r69300:e8346b7b8d72
Date: 2014-02-23 22:15 +0100
http://bitbucket.org/pypy/pypy/changeset/e8346b7b8d72/
Log: IN-PROGESS: Kill binary SMMs of complex.
diff --git a/pypy/objspace/std/complexobject.py
b/pypy/objspace/std/complexobject.py
--- a/pypy/objspace/std/complexobject.py
+++ b/pypy/objspace/std/complexobject.py
@@ -343,23 +343,95 @@
"""(A+Bj).conjugate() -> A-Bj"""
return space.newcomplex(self.realval, -self.imagval)
+ def descr_add(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ return W_ComplexObject(self.realval + w_rhs.realval,
+ self.imagval + w_rhs.imagval)
+
+ def descr_radd(self, space, w_lhs):
+ w_lhs = to_complex(space, w_lhs)
+ return W_ComplexObject(w_lhs.realval + self.realval,
+ w_lhs.imagval + self.imagval)
+
+ def descr_sub(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ return W_ComplexObject(self.realval - w_rhs.realval,
+ self.imagval - w_rhs.imagval)
+
+ def descr_rsub(self, space, w_lhs):
+ w_lhs = to_complex(space, w_lhs)
+ return W_ComplexObject(w_lhs.realval - self.realval,
+ w_lhs.imagval - self.imagval)
+
+ def descr_mul(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ return self.mul(w_rhs)
+
+ def descr_truediv(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ try:
+ return self.div(w_rhs)
+ except ZeroDivisionError, e:
+ raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
+
+ def descr_floordiv(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ w_rhs = to_complex(space, w_rhs)
+ # don't care about the slight slowdown you get from using divmod
+ try:
+ return self.divmod(space, w_rhs)[0]
+ except ZeroDivisionError, e:
+ raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
+
+ def descr_mod(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ try:
+ return self.divmod(space, w_rhs)[1]
+ except ZeroDivisionError, e:
+ raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
+
+ def descr_divmod(self, space, w_rhs):
+ w_rhs = to_complex(space, w_rhs)
+ try:
+ div, mod = self.divmod(space, w_rhs)
+ except ZeroDivisionError, e:
+ raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
+ return space.newtuple([div, mod])
+
+ @unwrap_spec(w_third_arg=WrappedDefault(None))
+ def descr_pow(self, space, w_exponent, w_third_arg):
+ w_exponent = to_complex(space, w_exponent)
+ if not space.is_w(w_third_arg, space.w_None):
+ raise OperationError(space.w_ValueError, space.wrap('complex
modulo'))
+ try:
+ r = w_exponent.realval
+ if w_exponent.imagval == 0.0 and -100.0 <= r <= 100.0 and r ==
int(r):
+ w_p = self.pow_small_int(int(r))
+ else:
+ w_p = self.pow(w_exponent)
+ except ZeroDivisionError:
+ raise OperationError(space.w_ZeroDivisionError, space.wrap("0.0 to
a negative or complex power"))
+ except OverflowError:
+ raise OperationError(space.w_OverflowError, space.wrap("complex
exponentiation"))
+ return w_p
+
registerimplementation(W_ComplexObject)
w_one = W_ComplexObject(1, 0)
-def delegate_Bool2Complex(space, w_bool):
- return W_ComplexObject(w_bool.intval, 0.0)
-
-def delegate_Int2Complex(space, w_int):
- return W_ComplexObject(w_int.intval, 0.0)
-
-def delegate_Long2Complex(space, w_long):
- dval = w_long.tofloat(space)
- return W_ComplexObject(dval, 0.0)
-
-def delegate_Float2Complex(space, w_float):
- return W_ComplexObject(w_float.floatval, 0.0)
+def to_complex(space, w_obj):
+ if isinstance(w_obj, W_ComplexObject):
+ return w_obj
+ if space.isinstance_w(w_obj, space.w_bool):
+ return W_ComplexObject(w_obj.intval, 0.0)
+ if space.isinstance_w(w_obj, space.w_int):
+ return W_ComplexObject(w_obj.intval, 0.0)
+ if space.isinstance_w(w_obj, space.w_long):
+ dval = w_obj.tofloat(space)
+ return W_ComplexObject(dval, 0.0)
+ if space.isinstance_w(w_obj, space.w_float):
+ return W_ComplexObject(w_obj.floatval, 0.0)
def hash__Complex(space, w_value):
hashreal = _hash_float(space, w_value.realval)
@@ -367,60 +439,6 @@
combined = intmask(hashreal + 1000003 * hashimg)
return space.newint(combined)
-def add__Complex_Complex(space, w_complex1, w_complex2):
- return W_ComplexObject(w_complex1.realval + w_complex2.realval,
- w_complex1.imagval + w_complex2.imagval)
-
-def sub__Complex_Complex(space, w_complex1, w_complex2):
- return W_ComplexObject(w_complex1.realval - w_complex2.realval,
- w_complex1.imagval - w_complex2.imagval)
-
-def mul__Complex_Complex(space, w_complex1, w_complex2):
- return w_complex1.mul(w_complex2)
-
-def div__Complex_Complex(space, w_complex1, w_complex2):
- try:
- return w_complex1.div(w_complex2)
- except ZeroDivisionError, e:
- raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
-
-truediv__Complex_Complex = div__Complex_Complex
-
-def mod__Complex_Complex(space, w_complex1, w_complex2):
- try:
- return w_complex1.divmod(space, w_complex2)[1]
- except ZeroDivisionError, e:
- raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
-
-def divmod__Complex_Complex(space, w_complex1, w_complex2):
- try:
- div, mod = w_complex1.divmod(space, w_complex2)
- except ZeroDivisionError, e:
- raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
- return space.newtuple([div, mod])
-
-def floordiv__Complex_Complex(space, w_complex1, w_complex2):
- # don't care about the slight slowdown you get from using divmod
- try:
- return w_complex1.divmod(space, w_complex2)[0]
- except ZeroDivisionError, e:
- raise OperationError(space.w_ZeroDivisionError, space.wrap(str(e)))
-
-def pow__Complex_Complex_ANY(space, w_complex, w_exponent, thirdArg):
- if not space.is_w(thirdArg, space.w_None):
- raise OperationError(space.w_ValueError, space.wrap('complex modulo'))
- try:
- r = w_exponent.realval
- if w_exponent.imagval == 0.0 and -100.0 <= r <= 100.0 and r == int(r):
- w_p = w_complex.pow_small_int(int(r))
- else:
- w_p = w_complex.pow(w_exponent)
- except ZeroDivisionError:
- raise OperationError(space.w_ZeroDivisionError, space.wrap("0.0 to a
negative or complex power"))
- except OverflowError:
- raise OperationError(space.w_OverflowError, space.wrap("complex
exponentiation"))
- return w_p
-
def neg__Complex(space, w_complex):
return W_ComplexObject(-w_complex.realval, -w_complex.imagval)
@@ -473,6 +491,7 @@
(w_complex.imagval != 0.0))
def coerce__Complex_Complex(space, w_complex1, w_complex2):
+ #w_complex2 = to_complex(w_complex2)
return space.newtuple([w_complex1, w_complex2])
def float__Complex(space, w_complex):
@@ -532,7 +551,19 @@
__getnewargs__ = interp2app(W_ComplexObject.descr___getnewargs__),
real = complexwprop('realval'),
imag = complexwprop('imagval'),
- conjugate = interp2app(W_ComplexObject.descr_conjugate)
+ conjugate = interp2app(W_ComplexObject.descr_conjugate),
+
+ __add__ = interp2app(W_ComplexObject.descr_add),
+ __radd__ = interp2app(W_ComplexObject.descr_radd),
+ __sub__ = interp2app(W_ComplexObject.descr_sub),
+ __rsub__ = interp2app(W_ComplexObject.descr_rsub),
+ __mul__ = interp2app(W_ComplexObject.descr_mul),
+ __div__ = interp2app(W_ComplexObject.descr_truediv),
+ __truediv__ = interp2app(W_ComplexObject.descr_truediv),
+ __floordiv__ = interp2app(W_ComplexObject.descr_floordiv),
+ __mod__ = interp2app(W_ComplexObject.descr_mod),
+ __divmod__ = interp2app(W_ComplexObject.descr_divmod),
+ __pow__ = interp2app(W_ComplexObject.descr_pow),
)
W_ComplexObject.typedef.registermethods(globals())
diff --git a/pypy/objspace/std/model.py b/pypy/objspace/std/model.py
--- a/pypy/objspace/std/model.py
+++ b/pypy/objspace/std/model.py
@@ -136,11 +136,9 @@
self.typeorder[boolobject.W_BoolObject] += [
(floatobject.W_FloatObject, floatobject.delegate_Bool2Float),
- (complexobject.W_ComplexObject,
complexobject.delegate_Bool2Complex),
]
self.typeorder[intobject.W_IntObject] += [
(floatobject.W_FloatObject, floatobject.delegate_Int2Float),
- (complexobject.W_ComplexObject,
complexobject.delegate_Int2Complex),
]
if config.objspace.std.withsmalllong:
from pypy.objspace.std import smalllongobject
@@ -150,12 +148,6 @@
]
self.typeorder[longobject.W_LongObject] += [
(floatobject.W_FloatObject, floatobject.delegate_Long2Float),
- (complexobject.W_ComplexObject,
- complexobject.delegate_Long2Complex),
- ]
- self.typeorder[floatobject.W_FloatObject] += [
- (complexobject.W_ComplexObject,
- complexobject.delegate_Float2Complex),
]
if config.objspace.std.withstrbuf:
diff --git a/pypy/objspace/std/test/test_complexobject.py
b/pypy/objspace/std/test/test_complexobject.py
--- a/pypy/objspace/std/test/test_complexobject.py
+++ b/pypy/objspace/std/test/test_complexobject.py
@@ -1,6 +1,5 @@
import py
-from pypy.objspace.std.complexobject import W_ComplexObject, \
- pow__Complex_Complex_ANY, _split_complex
+from pypy.objspace.std.complexobject import W_ComplexObject, _split_complex
from pypy.objspace.std.multimethod import FailedToImplement
from pypy.objspace.std import StdObjSpace
@@ -75,7 +74,7 @@
assert _powi((0.0,1.0),2) == (-1.0,0.0)
c = W_ComplexObject(0.0,1.0)
p = W_ComplexObject(2.0,0.0)
- r = pow__Complex_Complex_ANY(self.space,c,p,self.space.wrap(None))
+ r = c.descr_pow(self.space, p, self.space.wrap(None))
assert r.realval == -1.0
assert r.imagval == 0.0
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
