def descr__new__(space, w_complextype, w_real, w_imag=None): from pypy.objspace.std.complexobject import W_ComplexObject # if w_real is already a complex number and there is no second # argument, return it. Note that we cannot return w_real if # it is an instance of a *subclass* of complex, or if w_complextype # is itself a subclass of complex. noarg2 = w_imag is None if (noarg2 and space.is_w(w_complextype, space.w_complex) and space.is_w(space.type(w_real), space.w_complex)): return w_real if space.isinstance_w(w_real, space.w_str) or \ space.isinstance_w(w_real, space.w_unicode): # a string argument if not noarg2: raise OperationError( space.w_TypeError, space.wrap("complex() can't take second arg" " if first is a string")) try: realstr, imagstr = _split_complex(space.str_w(w_real)) except ValueError: raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED)) try: realval = string_to_float(realstr) imagval = string_to_float(imagstr) except ParseStringError: raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED)) else: # non-string arguments realval, imagval = unpackcomplex(space, w_real, strict_typing=False) # now take w_imag into account if not noarg2: # complex(x, y) == x+y*j, even if 'y' is already a complex. realval2, imagval2 = unpackcomplex(space, w_imag, strict_typing=False) # try to preserve the signs of zeroes of realval and realval2 if imagval2 != 0.0: realval -= imagval2 if imagval != 0.0: imagval += realval2 else: imagval = realval2 # done w_obj = space.allocate_instance(W_ComplexObject, w_complextype) W_ComplexObject.__init__(w_obj, realval, imagval) return w_obj
def descr__new__(space, w_complextype, w_real, w_imag=None): from pypy.objspace.std.complexobject import W_ComplexObject # if w_real is already a complex number and there is no second # argument, return it. Note that we cannot return w_real if # it is an instance of a *subclass* of complex, or if w_complextype # is itself a subclass of complex. noarg2 = w_imag is None if (noarg2 and space.is_w(w_complextype, space.w_complex) and space.is_w(space.type(w_real), space.w_complex)): return w_real if space.isinstance_w(w_real, space.w_str) or \ space.isinstance_w(w_real, space.w_unicode): # a string argument if not noarg2: raise OperationError(space.w_TypeError, space.wrap("complex() can't take second arg" " if first is a string")) try: realstr, imagstr = _split_complex(space.str_w(w_real)) except ValueError: raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED)) try: realval = string_to_float(realstr) imagval = string_to_float(imagstr) except ParseStringError: raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED)) else: # non-string arguments realval, imagval = unpackcomplex(space, w_real, strict_typing=False) # now take w_imag into account if not noarg2: # complex(x, y) == x+y*j, even if 'y' is already a complex. realval2, imagval2 = unpackcomplex(space, w_imag, strict_typing=False) # try to preserve the signs of zeroes of realval and realval2 if imagval2 != 0.0: realval -= imagval2 if imagval != 0.0: imagval += realval2 else: imagval = realval2 # done w_obj = space.allocate_instance(W_ComplexObject, w_complextype) W_ComplexObject.__init__(w_obj, realval, imagval) return w_obj
class TestW_ComplexObject: def test_instantiation(self): def _t_complex(r=0.0, i=0.0): c = W_ComplexObject(r, i) assert c.realval == float(r) and c.imagval == float(i) pairs = ( (1, 1), (1.0, 2.0), (2L, 3L), ) for r, i in pairs: _t_complex(r, i) def test_parse_complex(self): f = cobjtype._split_complex def test_cparse(cnum, realnum, imagnum): result = f(cnum) assert len(result) == 2 r, i = result assert r == realnum assert i == imagnum test_cparse('3', '3', '0.0') test_cparse('3+3j', '3', '3') test_cparse('3.0+3j', '3.0', '3') test_cparse('3L+3j', '3L', '3') test_cparse('3j', '0.0', '3') test_cparse('.e+5', '.e+5', '0.0') test_cparse('(1+2j)', '1', '2') test_cparse('(1-6j)', '1', '-6') test_cparse(' ( +3.14-6J )', '+3.14', '-6') test_cparse(' +J', '0.0', '1.0') test_cparse(' -J', '0.0', '-1.0') def test_unpackcomplex(self): space = self.space w_z = W_ComplexObject(2.0, 3.5) assert space.unpackcomplex(w_z) == (2.0, 3.5) space.raises_w(space.w_TypeError, space.unpackcomplex, space.w_None) w_f = space.newfloat(42.5) assert space.unpackcomplex(w_f) == (42.5, 0.0) w_l = space.wrap(-42L) assert space.unpackcomplex(w_l) == (-42.0, 0.0) def test_pow(self): def _pow((r1, i1), (r2, i2)): w_res = W_ComplexObject(r1, i1).pow(W_ComplexObject(r2, i2)) return w_res.realval, w_res.imagval assert _pow((0.0, 2.0), (0.0, 0.0)) == (1.0, 0.0) assert _pow((0.0, 0.0), (2.0, 0.0)) == (0.0, 0.0) rr, ir = _pow((0.0, 1.0), (2.0, 0.0)) assert abs(-1.0 - rr) < EPS assert abs(0.0 - ir) < EPS def _powu((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_positive_int(n) return w_res.realval, w_res.imagval
def _wrap_not_rpython(self, x): "NOT_RPYTHON" # _____ this code is here to support testing only _____ # we might get there in non-translated versions if 'x' is # a long that fits the correct range. if is_valid_int(x): return self.newint(x) # wrap() of a container works on CPython, but the code is # not RPython. Don't use -- it is kept around mostly for tests. # Use instead newdict(), newlist(), newtuple(). if isinstance(x, dict): items_w = [(self.wrap(k), self.wrap(v)) for (k, v) in x.iteritems()] r = self.newdict() r.initialize_content(items_w) return r if isinstance(x, tuple): wrappeditems = [self.wrap(item) for item in list(x)] return self.newtuple(wrappeditems) if isinstance(x, list): wrappeditems = [self.wrap(item) for item in x] return self.newlist(wrappeditems) # The following cases are even stranger. # Really really only for tests. if type(x) is long: return self.wraplong(x) if isinstance(x, slice): return W_SliceObject(self.wrap(x.start), self.wrap(x.stop), self.wrap(x.step)) if isinstance(x, complex): return W_ComplexObject(x.real, x.imag) if isinstance(x, set): res = W_SetObject(self, self.newlist([self.wrap(item) for item in x])) return res if isinstance(x, frozenset): wrappeditems = [self.wrap(item) for item in x] return W_FrozensetObject(self, wrappeditems) if x is __builtin__.Ellipsis: # '__builtin__.Ellipsis' avoids confusion with special.Ellipsis return self.w_Ellipsis if self.config.objspace.nofaking: raise OperationError( self.w_RuntimeError, self.wrap("nofaking enabled: refusing " "to wrap cpython value %r" % (x, ))) if isinstance(x, type(Exception)) and issubclass(x, Exception): w_result = self.wrap_exception_cls(x) if w_result is not None: return w_result from pypy.objspace.std.fake import fake_object return fake_object(self, x)
def test_unpackcomplex(self): space = self.space w_z = W_ComplexObject(2.0, 3.5) assert space.unpackcomplex(w_z) == (2.0, 3.5) space.raises_w(space.w_TypeError, space.unpackcomplex, space.w_None) w_f = space.newfloat(42.5) assert space.unpackcomplex(w_f) == (42.5, 0.0) w_l = space.wrap(-42L) assert space.unpackcomplex(w_l) == (-42.0, 0.0)
def _wrap_not_rpython(self, x): "NOT_RPYTHON" # _____ this code is here to support testing only _____ # wrap() of a container works on CPython, but the code is # not RPython. Don't use -- it is kept around mostly for tests. # Use instead newdict(), newlist(), newtuple(). if isinstance(x, dict): items_w = [(self.wrap(k), self.wrap(v)) for (k, v) in x.iteritems()] r = self.newdict() r.initialize_content(items_w) return r if isinstance(x, tuple): wrappeditems = [self.wrap(item) for item in list(x)] return self.newtuple(wrappeditems) if isinstance(x, list): wrappeditems = [self.wrap(item) for item in x] return self.newlist(wrappeditems) # The following cases are even stranger. # Really really only for tests. if type(x) is long: return self.wraplong(x) if isinstance(x, slice): return W_SliceObject(self.wrap(x.start), self.wrap(x.stop), self.wrap(x.step)) if isinstance(x, complex): return W_ComplexObject(x.real, x.imag) if isinstance(x, set): res = W_SetObject(self, self.newlist([self.wrap(item) for item in x])) return res if isinstance(x, frozenset): wrappeditems = [self.wrap(item) for item in x] return W_FrozensetObject(self, wrappeditems) if x is __builtin__.Ellipsis: # '__builtin__.Ellipsis' avoids confusion with special.Ellipsis return self.w_Ellipsis raise OperationError( self.w_RuntimeError, self.wrap("refusing to wrap cpython value %r" % (x, )))
def newcomplex(self, realval, imagval): return W_ComplexObject(realval, imagval)
a = space.float_w(space.getattr(w_imag, space.wrap('real'))) b = space.float_w(space.getattr(w_imag, space.wrap('imag'))) realval -= b imagval += a elif space.is_true(space.isinstance(w_imag, space.w_str)) or \ space.is_true(space.isinstance(w_imag, space.w_unicode)): # prevent space.float(w_imag) from succeeding raise OperationError( space.w_TypeError, space.wrap("complex() second arg" " can't be a string")) else: imagval += space.float_w(space.float(w_imag)) # done w_obj = space.allocate_instance(W_ComplexObject, w_complextype) W_ComplexObject.__init__(w_obj, realval, imagval) return w_obj def complexwprop(name): def fget(space, w_obj): from pypy.objspace.std.complexobject import W_ComplexObject if not isinstance(w_obj, W_ComplexObject): raise OperationError(space.w_TypeError, space.wrap("descriptor is for 'complex'")) return space.newfloat(getattr(w_obj, name)) return GetSetProperty(fget) def descr___getnewargs__(space, w_self):
assert abs(0.0 - ir) < EPS def _powu((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_positive_int(n) return w_res.realval, w_res.imagval assert _powu((0.0,2.0),0) == (1.0,0.0) assert _powu((0.0,0.0),2) == (0.0,0.0) assert _powu((0.0,1.0),2) == (-1.0,0.0) def _powi((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_small_int(n) return w_res.realval, w_res.imagval assert _powi((0.0,2.0),0) == (1.0,0.0) assert _powi((0.0,0.0),2) == (0.0,0.0) 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 = c.descr_pow(self.space, p, self.space.wrap(None)) assert r.realval == -1.0 assert r.imagval == 0.0 class AppTestAppComplexTest: spaceconfig = {'usemodules': ['binascii', 'time', 'struct']} def w_check_div(self, x, y): """Compute complex z=x*y, and check that z/x==y and z/y==x.""" z = x * y if x != 0: q = z / x assert self.close(q, y)
def unmarshal_Complex_bin(space, u, tc): real = unpack_float(u.get(8)) imag = unpack_float(u.get(8)) return W_ComplexObject(real, imag)
def test_pow(self): def _pow((r1, i1), (r2, i2)): w_res = W_ComplexObject(r1, i1).pow(W_ComplexObject(r2, i2)) return w_res.realval, w_res.imagval
def _t_complex(r=0.0, i=0.0): c = W_ComplexObject(r, i) assert c.realval == float(r) and c.imagval == float(i)
assert _pow((0.0, 2.0), (0.0, 0.0)) == (1.0, 0.0) assert _pow((0.0, 0.0), (2.0, 0.0)) == (0.0, 0.0) rr, ir = _pow((0.0, 1.0), (2.0, 0.0)) assert abs(-1.0 - rr) < EPS assert abs(0.0 - ir) < EPS def _powu((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_positive_int(n) return w_res.realval, w_res.imagval assert _powu((0.0, 2.0), 0) == (1.0, 0.0) assert _powu((0.0, 0.0), 2) == (0.0, 0.0) assert _powu((0.0, 1.0), 2) == (-1.0, 0.0) def _powi((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_small_int(n) return w_res.realval, w_res.imagval assert _powi((0.0, 2.0), 0) == (1.0, 0.0) assert _powi((0.0, 0.0), 2) == (0.0, 0.0) 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)) assert r.realval == -1.0 assert r.imagval == 0.0 class AppTestAppComplexTest: def w_check_div(self, x, y): """Compute complex z=x*y, and check that z/x==y and z/y==x."""
return w_res.realval, w_res.imagval assert _pow((0.0,2.0),(0.0,0.0)) == (1.0,0.0) assert _pow((0.0,0.0),(2.0,0.0)) == (0.0,0.0) rr, ir = _pow((0.0,1.0),(2.0,0.0)) assert abs(-1.0 - rr) < EPS assert abs(0.0 - ir) < EPS def _powu((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_positive_int(n) return w_res.realval, w_res.imagval assert _powu((0.0,2.0),0) == (1.0,0.0) assert _powu((0.0,0.0),2) == (0.0,0.0) assert _powu((0.0,1.0),2) == (-1.0,0.0) def _powi((r1, i1), n): w_res = W_ComplexObject(r1, i1).pow_small_int(n) return w_res.realval, w_res.imagval assert _powi((0.0,2.0),0) == (1.0,0.0) assert _powi((0.0,0.0),2) == (0.0,0.0) 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 = c.descr_pow(self.space, p, self.space.wrap(None)) assert r.realval == -1.0 assert r.imagval == 0.0 class AppTestAppComplexTest: spaceconfig = {'usemodules': ['binascii', 'time', 'struct', 'unicodedata']} def w_check_div(self, x, y):
# say y == a+b*j: a = space.float_w(space.getattr(w_imag, space.wrap('real'))) b = space.float_w(space.getattr(w_imag, space.wrap('imag'))) realval -= b imagval += a elif space.is_true(space.isinstance(w_imag, space.w_str)) or \ space.is_true(space.isinstance(w_imag, space.w_unicode)): # prevent space.float(w_imag) from succeeding raise OperationError(space.w_TypeError, space.wrap("complex() second arg" " can't be a string")) else: imagval += space.float_w(space.float(w_imag)) # done w_obj = space.allocate_instance(W_ComplexObject, w_complextype) W_ComplexObject.__init__(w_obj, realval, imagval) return w_obj def complexwprop(name): def fget(space, w_obj): from pypy.objspace.std.complexobject import W_ComplexObject if not isinstance(w_obj, W_ComplexObject): raise OperationError(space.w_TypeError, space.wrap("descriptor is for 'complex'")) return space.newfloat(getattr(w_obj, name)) return GetSetProperty(fget) def descr___getnewargs__(space, w_self): from pypy.objspace.std.complexobject import W_ComplexObject assert isinstance(w_self, W_ComplexObject) return space.newtuple([space.newcomplex(w_self.realval,w_self.imagval)])
def _wrap_not_rpython(self, x): "NOT_RPYTHON" # _____ this code is here to support testing only _____ # wrap() of a container works on CPython, but the code is # not RPython. Don't use -- it is kept around mostly for tests. # Use instead newdict(), newlist(), newtuple(). if isinstance(x, dict): items_w = [(self.wrap(k), self.wrap(v)) for (k, v) in x.iteritems()] r = self.newdict() r.initialize_content(items_w) return r if isinstance(x, tuple): wrappeditems = [self.wrap(item) for item in list(x)] return self.newtuple(wrappeditems) if isinstance(x, list): wrappeditems = [self.wrap(item) for item in x] return self.newlist(wrappeditems) # The following cases are even stranger. # Really really only for tests. if type(x) is long: if self.config.objspace.std.withsmalllong: from pypy.rlib.rarithmetic import r_longlong try: rx = r_longlong(x) except OverflowError: pass else: from pypy.objspace.std.smalllongobject import \ W_SmallLongObject return W_SmallLongObject(rx) return W_LongObject.fromlong(x) if isinstance(x, slice): return W_SliceObject(self.wrap(x.start), self.wrap(x.stop), self.wrap(x.step)) if isinstance(x, complex): return W_ComplexObject(x.real, x.imag) if isinstance(x, set): rdict_w = r_dict(self.eq_w, self.hash_w) for item in x: rdict_w[self.wrap(item)] = None res = W_SetObject(self, rdict_w) return res if isinstance(x, frozenset): wrappeditems = [self.wrap(item) for item in x] return W_FrozensetObject(self, wrappeditems) if x is __builtin__.Ellipsis: # '__builtin__.Ellipsis' avoids confusion with special.Ellipsis return self.w_Ellipsis if self.config.objspace.nofaking: raise OperationError(self.w_RuntimeError, self.wrap("nofaking enabled: refusing " "to wrap cpython value %r" %(x,))) if isinstance(x, type(Exception)) and issubclass(x, Exception): w_result = self.wrap_exception_cls(x) if w_result is not None: return w_result from pypy.objspace.std.fake import fake_object return fake_object(self, x)