[pypy-commit] pypy default: simplify dtype methods/attributes
bdkearns
noreply at buildbot.pypy.org
Tue Feb 25 03:59:27 CET 2014
Author: Brian Kearns <bdkearns at gmail.com>
Branch:
Changeset: r69383:1e1e64b26713
Date: 2014-02-24 13:22 -0500
http://bitbucket.org/pypy/pypy/changeset/1e1e64b26713/
Log: simplify dtype methods/attributes
diff --git a/pypy/module/micronumpy/arrayimpl/concrete.py b/pypy/module/micronumpy/arrayimpl/concrete.py
--- a/pypy/module/micronumpy/arrayimpl/concrete.py
+++ b/pypy/module/micronumpy/arrayimpl/concrete.py
@@ -89,7 +89,7 @@
def get_real(self, space, orig_array):
strides = self.get_strides()
backstrides = self.get_backstrides()
- if self.dtype.is_complex_type():
+ if self.dtype.is_complex():
dtype = self.dtype.get_float_dtype(space)
return SliceArray(self.start, strides, backstrides,
self.get_shape(), self, orig_array, dtype=dtype)
@@ -103,13 +103,13 @@
def get_imag(self, space, orig_array):
strides = self.get_strides()
backstrides = self.get_backstrides()
- if self.dtype.is_complex_type():
+ if self.dtype.is_complex():
dtype = self.dtype.get_float_dtype(space)
return SliceArray(self.start + dtype.elsize, strides,
backstrides, self.get_shape(), self, orig_array, dtype=dtype)
impl = NonWritableArray(self.get_shape(), self.dtype, self.order, strides,
backstrides)
- if not self.dtype.is_flexible_type():
+ if not self.dtype.is_flexible():
impl.fill(space, self.dtype.box(0))
return impl
@@ -204,7 +204,7 @@
if space.isinstance_w(w_idx, space.w_str):
idx = space.str_w(w_idx)
dtype = self.dtype
- if not dtype.is_record_type() or idx not in dtype.fields:
+ if not dtype.is_record() or idx not in dtype.fields:
raise OperationError(space.w_ValueError, space.wrap(
"field named %s not found" % idx))
return RecordChunk(idx)
diff --git a/pypy/module/micronumpy/arrayimpl/scalar.py b/pypy/module/micronumpy/arrayimpl/scalar.py
--- a/pypy/module/micronumpy/arrayimpl/scalar.py
+++ b/pypy/module/micronumpy/arrayimpl/scalar.py
@@ -70,7 +70,7 @@
scalar = Scalar(dtype)
if dtype.is_str_or_unicode():
scalar.value = dtype.coerce(space, space.wrap(self.value.raw_str()))
- elif dtype.is_record_type():
+ elif dtype.is_record():
raise OperationError(space.w_NotImplementedError, space.wrap(
"viewing scalar as record not implemented"))
else:
@@ -78,7 +78,7 @@
return scalar
def get_real(self, space, orig_array):
- if self.dtype.is_complex_type():
+ if self.dtype.is_complex():
scalar = Scalar(self.dtype.get_float_dtype(space))
scalar.value = self.value.convert_real_to(scalar.dtype)
return scalar
@@ -91,7 +91,7 @@
"could not broadcast input array from shape " +
"(%s) into shape ()" % (
','.join([str(x) for x in w_arr.get_shape()],))))
- if self.dtype.is_complex_type():
+ if self.dtype.is_complex():
dtype = self.dtype.get_float_dtype(space)
self.value = self.dtype.itemtype.composite(
w_arr.get_scalar_value().convert_to(space, dtype),
@@ -100,7 +100,7 @@
self.value = w_arr.get_scalar_value()
def get_imag(self, space, orig_array):
- if self.dtype.is_complex_type():
+ if self.dtype.is_complex():
scalar = Scalar(self.dtype.get_float_dtype(space))
scalar.value = self.value.convert_imag_to(scalar.dtype)
return scalar
@@ -110,7 +110,7 @@
def set_imag(self, space, orig_array, w_val):
#Only called on complex dtype
- assert self.dtype.is_complex_type()
+ assert self.dtype.is_complex()
w_arr = convert_to_array(space, w_val)
if len(w_arr.get_shape()) > 0:
raise OperationError(space.w_ValueError, space.wrap(
@@ -127,7 +127,7 @@
if space.len_w(w_idx) == 0:
return self.get_scalar_value()
elif space.isinstance_w(w_idx, space.w_str):
- if self.dtype.is_record_type():
+ if self.dtype.is_record():
w_val = self.value.descr_getitem(space, w_idx)
return convert_to_array(space, w_val)
elif space.is_none(w_idx):
@@ -148,7 +148,7 @@
if space.len_w(w_idx) == 0:
return self.set_scalar_value(self.dtype.coerce(space, w_val))
elif space.isinstance_w(w_idx, space.w_str):
- if self.dtype.is_record_type():
+ if self.dtype.is_record():
return self.value.descr_setitem(space, w_idx, w_val)
raise OperationError(space.w_IndexError,
space.wrap("0-d arrays can't be indexed"))
diff --git a/pypy/module/micronumpy/interp_arrayops.py b/pypy/module/micronumpy/interp_arrayops.py
--- a/pypy/module/micronumpy/interp_arrayops.py
+++ b/pypy/module/micronumpy/interp_arrayops.py
@@ -137,14 +137,14 @@
"all the input array dimensions except for the "
"concatenation axis must match exactly"))
a_dt = arr.get_dtype()
- if dtype.is_record_type() and a_dt.is_record_type():
+ if dtype.is_record() and a_dt.is_record():
# Record types must match
for f in dtype.fields:
if f not in a_dt.fields or \
dtype.fields[f] != a_dt.fields[f]:
raise OperationError(space.w_TypeError,
space.wrap("invalid type promotion"))
- elif dtype.is_record_type() or a_dt.is_record_type():
+ elif dtype.is_record() or a_dt.is_record():
raise OperationError(space.w_TypeError,
space.wrap("invalid type promotion"))
dtype = interp_ufuncs.find_binop_result_dtype(space, dtype,
diff --git a/pypy/module/micronumpy/interp_boxes.py b/pypy/module/micronumpy/interp_boxes.py
--- a/pypy/module/micronumpy/interp_boxes.py
+++ b/pypy/module/micronumpy/interp_boxes.py
@@ -311,7 +311,7 @@
"new type not compatible with array."))
if dtype.is_str_or_unicode():
return dtype.coerce(space, space.wrap(self.raw_str()))
- elif dtype.is_record_type():
+ elif dtype.is_record():
raise OperationError(space.w_NotImplementedError, space.wrap(
"viewing scalar as record not implemented"))
else:
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -39,7 +39,7 @@
class W_Dtype(W_Root):
_immutable_fields_ = [
"num", "kind", "char", "w_box_type", "float_type",
- "itemtype?", "byteorder?", "names?", "fields?", "elsize?",
+ "itemtype?", "byteorder?", "names?", "fields?", "elsize?", "alignment?",
"shape?", "subdtype?", "base?",
"alternate_constructors", "aliases",
]
@@ -65,6 +65,7 @@
if elsize is None:
elsize = itemtype.get_element_size()
self.elsize = elsize
+ self.alignment = itemtype.alignment
self.shape = shape
self.subdtype = subdtype
if not subdtype:
@@ -87,40 +88,40 @@
def box_complex(self, real, imag):
return self.itemtype.box_complex(real, imag)
- def build_and_convert(self, space, box):
- return self.itemtype.build_and_convert(space, self, box)
-
def coerce(self, space, w_item):
return self.itemtype.coerce(space, self, w_item)
- def is_int_type(self):
- return (self.kind == NPY.SIGNEDLTR or self.kind == NPY.UNSIGNEDLTR or
- self.kind == NPY.GENBOOLLTR)
+ def is_bool(self):
+ return self.kind == NPY.GENBOOLLTR
def is_signed(self):
return self.kind == NPY.SIGNEDLTR
- def is_complex_type(self):
+ def is_unsigned(self):
+ return self.kind == NPY.UNSIGNEDLTR
+
+ def is_int(self):
+ return (self.kind == NPY.SIGNEDLTR or self.kind == NPY.UNSIGNEDLTR or
+ self.kind == NPY.GENBOOLLTR)
+
+ def is_float(self):
+ return self.kind == NPY.FLOATINGLTR
+
+ def is_complex(self):
return self.kind == NPY.COMPLEXLTR
- def is_float_type(self):
- return self.kind == NPY.FLOATINGLTR or self.kind == NPY.COMPLEXLTR
-
- def is_bool_type(self):
- return self.kind == NPY.GENBOOLLTR
-
- def is_record_type(self):
- return bool(self.fields)
-
- def is_str_type(self):
+ def is_str(self):
return self.num == NPY.STRING
def is_str_or_unicode(self):
return self.num == NPY.STRING or self.num == NPY.UNICODE
- def is_flexible_type(self):
+ def is_flexible(self):
return self.is_str_or_unicode() or self.num == NPY.VOID
+ def is_record(self):
+ return bool(self.fields)
+
def is_native(self):
return self.byteorder in (NPY.NATIVE, NPY.NATBYTE)
@@ -132,53 +133,6 @@
dtype = dtype.descr_newbyteorder(space)
return dtype
- def descr_str(self, space):
- if self.fields:
- return space.str(self.descr_get_descr(space))
- elif self.subdtype is not None:
- return space.str(space.newtuple([
- self.subdtype.descr_get_str(space),
- self.descr_get_shape(space)]))
- else:
- if self.is_flexible_type():
- return self.descr_get_str(space)
- else:
- return self.descr_get_name(space)
-
- def descr_repr(self, space):
- if self.fields:
- r = self.descr_get_descr(space)
- elif self.subdtype is not None:
- r = space.newtuple([self.subdtype.descr_get_str(space),
- self.descr_get_shape(space)])
- else:
- if self.is_flexible_type():
- if self.byteorder != NPY.IGNORE:
- byteorder = NPY.NATBYTE if self.is_native() else NPY.OPPBYTE
- else:
- byteorder = ''
- size = self.elsize
- if self.num == NPY.UNICODE:
- size >>= 2
- r = space.wrap(byteorder + self.char + str(size))
- else:
- r = self.descr_get_name(space)
- return space.wrap("dtype(%s)" % space.str_w(space.repr(r)))
-
- def descr_get_alignment(self, space):
- return space.wrap(self.itemtype.alignment)
-
- def descr_get_isbuiltin(self, space):
- if self.fields is None:
- return space.wrap(1)
- return space.wrap(0)
-
- def descr_get_subdtype(self, space):
- if self.subdtype is None:
- return space.w_None
- return space.newtuple([space.wrap(self.subdtype),
- self.descr_get_shape(space)])
-
def get_name(self):
return self.w_box_type.name
@@ -186,7 +140,7 @@
name = self.get_name()
if name[-1] == '_':
name = name[:-1]
- if self.is_flexible_type() and self.elsize != 0:
+ if self.is_flexible() and self.elsize != 0:
return space.wrap(name + str(self.elsize * 8))
return space.wrap(name)
@@ -201,7 +155,7 @@
return space.wrap("%s%s%s" % (endian, basic, size))
def descr_get_descr(self, space):
- if not self.is_record_type():
+ if not self.is_record():
return space.newlist([space.newtuple([space.wrap(""),
self.descr_get_str(space)])])
else:
@@ -209,7 +163,7 @@
for name in self.names:
subdtype = self.fields[name][1]
subdescr = [space.wrap(name)]
- if subdtype.is_record_type():
+ if subdtype.is_record():
subdescr.append(subdtype.descr_get_descr(space))
elif subdtype.subdtype is not None:
subdescr.append(subdtype.subdtype.descr_get_str(space))
@@ -220,30 +174,28 @@
descr.append(space.newtuple(subdescr[:]))
return space.newlist(descr)
- def descr_get_base(self, space):
- return space.wrap(self.base)
+ def descr_get_hasobject(self, space):
+ return space.w_False
+
+ def descr_get_isbuiltin(self, space):
+ if self.fields is None:
+ return space.wrap(1)
+ return space.wrap(0)
def descr_get_isnative(self, space):
return space.wrap(self.is_native())
+ def descr_get_base(self, space):
+ return space.wrap(self.base)
+
+ def descr_get_subdtype(self, space):
+ if self.subdtype is None:
+ return space.w_None
+ return space.newtuple([space.wrap(self.subdtype),
+ self.descr_get_shape(space)])
+
def descr_get_shape(self, space):
- w_shape = [space.wrap(dim) for dim in self.shape]
- return space.newtuple(w_shape)
-
- def eq(self, space, w_other):
- w_other = space.call_function(space.gettypefor(W_Dtype), w_other)
- if space.is_w(self, w_other):
- return True
- if isinstance(w_other, W_Dtype):
- return space.eq_w(self.descr_reduce(space),
- w_other.descr_reduce(space))
- return False
-
- def descr_eq(self, space, w_other):
- return space.wrap(self.eq(space, w_other))
-
- def descr_ne(self, space, w_other):
- return space.wrap(not self.eq(space, w_other))
+ return space.newtuple([space.wrap(dim) for dim in self.shape])
def descr_get_fields(self, space):
if not self.fields:
@@ -287,8 +239,56 @@
raise OperationError(space.w_AttributeError, space.wrap(
"Cannot delete dtype names attribute"))
- def descr_get_hasobject(self, space):
- return space.w_False
+ def eq(self, space, w_other):
+ w_other = space.call_function(space.gettypefor(W_Dtype), w_other)
+ if space.is_w(self, w_other):
+ return True
+ if isinstance(w_other, W_Dtype):
+ return space.eq_w(self.descr_reduce(space),
+ w_other.descr_reduce(space))
+ return False
+
+ def descr_eq(self, space, w_other):
+ return space.wrap(self.eq(space, w_other))
+
+ def descr_ne(self, space, w_other):
+ return space.wrap(not self.eq(space, w_other))
+
+ def descr_hash(self, space):
+ return space.hash(self.descr_reduce(space))
+
+ def descr_str(self, space):
+ if self.fields:
+ return space.str(self.descr_get_descr(space))
+ elif self.subdtype is not None:
+ return space.str(space.newtuple([
+ self.subdtype.descr_get_str(space),
+ self.descr_get_shape(space)]))
+ else:
+ if self.is_flexible():
+ return self.descr_get_str(space)
+ else:
+ return self.descr_get_name(space)
+
+ def descr_repr(self, space):
+ if self.fields:
+ r = self.descr_get_descr(space)
+ elif self.subdtype is not None:
+ r = space.newtuple([self.subdtype.descr_get_str(space),
+ self.descr_get_shape(space)])
+ else:
+ if self.is_flexible():
+ if self.byteorder != NPY.IGNORE:
+ byteorder = NPY.NATBYTE if self.is_native() else NPY.OPPBYTE
+ else:
+ byteorder = ''
+ size = self.elsize
+ if self.num == NPY.UNICODE:
+ size >>= 2
+ r = space.wrap(byteorder + self.char + str(size))
+ else:
+ r = self.descr_get_name(space)
+ return space.wrap("dtype(%s)" % space.str_w(space.repr(r)))
def descr_getitem(self, space, w_item):
if not self.fields:
@@ -317,9 +317,6 @@
return space.wrap(0)
return space.wrap(len(self.fields))
- def descr_hash(self, space):
- return space.hash(self.descr_reduce(space))
-
def descr_reduce(self, space):
w_class = space.type(self)
builder_args = space.newtuple([
@@ -333,9 +330,9 @@
subdescr = self.descr_get_subdtype(space)
names = self.descr_get_names(space)
values = self.descr_get_fields(space)
- if self.is_flexible_type():
+ if self.is_flexible():
w_size = space.wrap(self.elsize)
- alignment = space.wrap(self.itemtype.alignment)
+ alignment = space.wrap(self.alignment)
else:
w_size = space.wrap(-1)
alignment = space.wrap(-1)
@@ -363,6 +360,7 @@
w_names = space.getitem(w_data, space.wrap(3))
w_fields = space.getitem(w_data, space.wrap(4))
size = space.int_w(space.getitem(w_data, space.wrap(5)))
+ alignment = space.int_w(space.getitem(w_data, space.wrap(6)))
if (w_names == space.w_None) != (w_fields == space.w_None):
raise oefmt(space.w_ValueError, "inconsistent fields and names")
@@ -401,8 +399,9 @@
self.fields[name] = offset, dtype
self.itemtype = types.RecordType()
- if self.is_flexible_type():
+ if self.is_flexible():
self.elsize = size
+ self.alignment = alignment
@unwrap_spec(new_order=str)
def descr_newbyteorder(self, space, new_order=NPY.SWAP):
@@ -540,39 +539,38 @@
__module__ = "numpy",
__new__ = interp2app(descr__new__),
- __str__= interp2app(W_Dtype.descr_str),
- __repr__ = interp2app(W_Dtype.descr_repr),
- __eq__ = interp2app(W_Dtype.descr_eq),
- __ne__ = interp2app(W_Dtype.descr_ne),
- __getitem__ = interp2app(W_Dtype.descr_getitem),
- __len__ = interp2app(W_Dtype.descr_len),
-
- __hash__ = interp2app(W_Dtype.descr_hash),
- __reduce__ = interp2app(W_Dtype.descr_reduce),
- __setstate__ = interp2app(W_Dtype.descr_setstate),
- newbyteorder = interp2app(W_Dtype.descr_newbyteorder),
-
type = interp_attrproperty_w("w_box_type", cls=W_Dtype),
kind = interp_attrproperty("kind", cls=W_Dtype),
char = interp_attrproperty("char", cls=W_Dtype),
num = interp_attrproperty("num", cls=W_Dtype),
byteorder = interp_attrproperty("byteorder", cls=W_Dtype),
itemsize = interp_attrproperty("elsize", cls=W_Dtype),
- alignment = GetSetProperty(W_Dtype.descr_get_alignment),
+ alignment = interp_attrproperty("alignment", cls=W_Dtype),
- subdtype = GetSetProperty(W_Dtype.descr_get_subdtype),
+ name = GetSetProperty(W_Dtype.descr_get_name),
+ str = GetSetProperty(W_Dtype.descr_get_str),
descr = GetSetProperty(W_Dtype.descr_get_descr),
- str = GetSetProperty(W_Dtype.descr_get_str),
- name = GetSetProperty(W_Dtype.descr_get_name),
- base = GetSetProperty(W_Dtype.descr_get_base),
- shape = GetSetProperty(W_Dtype.descr_get_shape),
+ hasobject = GetSetProperty(W_Dtype.descr_get_hasobject),
isbuiltin = GetSetProperty(W_Dtype.descr_get_isbuiltin),
isnative = GetSetProperty(W_Dtype.descr_get_isnative),
+ base = GetSetProperty(W_Dtype.descr_get_base),
+ subdtype = GetSetProperty(W_Dtype.descr_get_subdtype),
+ shape = GetSetProperty(W_Dtype.descr_get_shape),
fields = GetSetProperty(W_Dtype.descr_get_fields),
names = GetSetProperty(W_Dtype.descr_get_names,
W_Dtype.descr_set_names,
W_Dtype.descr_del_names),
- hasobject = GetSetProperty(W_Dtype.descr_get_hasobject),
+
+ __eq__ = interp2app(W_Dtype.descr_eq),
+ __ne__ = interp2app(W_Dtype.descr_ne),
+ __hash__ = interp2app(W_Dtype.descr_hash),
+ __str__= interp2app(W_Dtype.descr_str),
+ __repr__ = interp2app(W_Dtype.descr_repr),
+ __getitem__ = interp2app(W_Dtype.descr_getitem),
+ __len__ = interp2app(W_Dtype.descr_len),
+ __reduce__ = interp2app(W_Dtype.descr_reduce),
+ __setstate__ = interp2app(W_Dtype.descr_setstate),
+ newbyteorder = interp2app(W_Dtype.descr_newbyteorder),
)
W_Dtype.typedef.acceptable_as_base_class = False
@@ -929,8 +927,8 @@
space.wrap(dtype.num),
space.wrap(itembits),
space.wrap(dtype.itemtype.get_element_size())]
- if dtype.is_int_type():
- if dtype.kind == NPY.GENBOOLLTR:
+ if dtype.is_int():
+ if dtype.is_bool():
w_maxobj = space.wrap(1)
w_minobj = space.wrap(0)
elif dtype.is_signed():
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -88,7 +88,7 @@
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
if (dtype.elsize != self.get_dtype().elsize or
- dtype.is_flexible_type() or self.get_dtype().is_flexible_type()):
+ dtype.is_flexible() or self.get_dtype().is_flexible()):
raise OperationError(space.w_ValueError, space.wrap(
"new type not compatible with array."))
self.implementation.set_dtype(space, dtype)
@@ -220,7 +220,7 @@
def descr_getitem(self, space, w_idx):
if space.is_w(w_idx, space.w_Ellipsis):
return self
- elif isinstance(w_idx, W_NDimArray) and w_idx.get_dtype().is_bool_type() \
+ elif isinstance(w_idx, W_NDimArray) and w_idx.get_dtype().is_bool() \
and len(w_idx.get_shape()) > 0:
return self.getitem_filter(space, w_idx)
try:
@@ -235,7 +235,7 @@
self.implementation.setitem_index(space, index_list, w_value)
def descr_setitem(self, space, w_idx, w_value):
- if isinstance(w_idx, W_NDimArray) and w_idx.get_dtype().is_bool_type() \
+ if isinstance(w_idx, W_NDimArray) and w_idx.get_dtype().is_bool() \
and len(w_idx.get_shape()) > 0:
self.setitem_filter(space, w_idx, convert_to_array(space, w_value))
return
@@ -281,7 +281,7 @@
else:
s.append(separator)
s.append(' ')
- if self.is_scalar() and dtype.is_str_type():
+ if self.is_scalar() and dtype.is_str():
s.append(dtype.itemtype.to_str(i.getitem()))
else:
s.append(dtype.itemtype.str_format(i.getitem()))
@@ -344,7 +344,7 @@
def descr_set_imag(self, space, w_value):
# if possible, copy (broadcast) values into self
- if not self.get_dtype().is_complex_type():
+ if not self.get_dtype().is_complex():
raise OperationError(space.w_TypeError,
space.wrap('array does not have imaginary part to set'))
self.implementation.set_imag(space, self, w_value)
@@ -689,7 +689,7 @@
@unwrap_spec(decimals=int)
def descr_round(self, space, decimals=0, w_out=None):
if space.is_none(w_out):
- if self.get_dtype().is_bool_type():
+ if self.get_dtype().is_bool():
#numpy promotes bool.round() to float16. Go figure.
w_out = W_NDimArray.from_shape(space, self.get_shape(),
interp_dtype.get_dtype_cache(space).w_float16dtype)
@@ -700,7 +700,7 @@
"return arrays must be of ArrayType"))
out = interp_dtype.dtype_agreement(space, [self], self.get_shape(),
w_out)
- if out.get_dtype().is_bool_type() and self.get_dtype().is_bool_type():
+ if out.get_dtype().is_bool() and self.get_dtype().is_bool():
calc_dtype = interp_dtype.get_dtype_cache(space).w_longdtype
else:
calc_dtype = out.get_dtype()
@@ -1093,7 +1093,7 @@
raise OperationError(space.w_TypeError, space.wrap(
"only integer arrays with one element "
"can be converted to an index"))
- if not self.get_dtype().is_int_type() or self.get_dtype().is_bool_type():
+ if not self.get_dtype().is_int() or self.get_dtype().is_bool():
raise OperationError(space.w_TypeError, space.wrap(
"only integer arrays with one element "
"can be converted to an index"))
diff --git a/pypy/module/micronumpy/interp_ufuncs.py b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -168,7 +168,7 @@
"supported for binary functions"))
assert isinstance(self, W_Ufunc2)
obj = convert_to_array(space, w_obj)
- if obj.get_dtype().is_flexible_type():
+ if obj.get_dtype().is_flexible():
raise OperationError(space.w_TypeError,
space.wrap('cannot perform reduce with flexible type'))
obj_shape = obj.get_shape()
@@ -287,12 +287,12 @@
out = None
w_obj = convert_to_array(space, w_obj)
dtype = w_obj.get_dtype()
- if dtype.is_flexible_type():
+ if dtype.is_flexible():
raise OperationError(space.w_TypeError,
space.wrap('Not implemented for this type'))
- if (self.int_only and not dtype.is_int_type() or
- not self.allow_bool and dtype.is_bool_type() or
- not self.allow_complex and dtype.is_complex_type()):
+ if (self.int_only and not dtype.is_int() or
+ not self.allow_bool and dtype.is_bool() or
+ not self.allow_complex and dtype.is_complex()):
raise OperationError(space.w_TypeError, space.wrap(
"ufunc %s not supported for the input type" % self.name))
calc_dtype = find_unaryop_result_dtype(space,
@@ -311,7 +311,7 @@
res_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
else:
res_dtype = calc_dtype
- if self.complex_to_float and calc_dtype.is_complex_type():
+ if self.complex_to_float and calc_dtype.is_complex():
if calc_dtype.num == NPY.CFLOAT:
res_dtype = interp_dtype.get_dtype_cache(space).w_float32dtype
else:
@@ -351,11 +351,11 @@
self.done_func = None
def are_common_types(self, dtype1, dtype2):
- if dtype1.is_complex_type() and dtype2.is_complex_type():
- return True
- elif not (dtype1.is_complex_type() or dtype2.is_complex_type()) and \
- (dtype1.is_int_type() and dtype2.is_int_type() or dtype1.is_float_type() and dtype2.is_float_type()) and \
- not (dtype1.is_bool_type() or dtype2.is_bool_type()):
+ if dtype1.is_bool() or dtype2.is_bool():
+ return False
+ if (dtype1.is_int() and dtype2.is_int() or
+ dtype1.is_float() and dtype2.is_float() or
+ dtype1.is_complex() and dtype2.is_complex()):
return True
return False
@@ -370,13 +370,13 @@
w_rhs = convert_to_array(space, w_rhs)
w_ldtype = w_lhs.get_dtype()
w_rdtype = w_rhs.get_dtype()
- if w_ldtype.is_str_type() and w_rdtype.is_str_type() and \
+ if w_ldtype.is_str() and w_rdtype.is_str() and \
self.comparison_func:
pass
- elif (w_ldtype.is_str_type() or w_rdtype.is_str_type()) and \
+ elif (w_ldtype.is_str() or w_rdtype.is_str()) and \
self.comparison_func and w_out is None:
return space.wrap(False)
- elif w_ldtype.is_flexible_type() or w_rdtype.is_flexible_type():
+ elif w_ldtype.is_flexible() or w_rdtype.is_flexible():
if self.comparison_func:
if self.name == 'equal' or self.name == 'not_equal':
res = w_ldtype.eq(space, w_rdtype)
@@ -399,13 +399,13 @@
w_ldtype, w_rdtype,
promote_to_float=self.promote_to_float,
promote_bools=self.promote_bools)
- if (self.int_only and (not w_ldtype.is_int_type() or
- not w_rdtype.is_int_type() or
- not calc_dtype.is_int_type()) or
- not self.allow_bool and (w_ldtype.is_bool_type() or
- w_rdtype.is_bool_type()) or
- not self.allow_complex and (w_ldtype.is_complex_type() or
- w_rdtype.is_complex_type())):
+ if (self.int_only and (not w_ldtype.is_int() or
+ not w_rdtype.is_int() or
+ not calc_dtype.is_int()) or
+ not self.allow_bool and (w_ldtype.is_bool() or
+ w_rdtype.is_bool()) or
+ not self.allow_complex and (w_ldtype.is_complex() or
+ w_rdtype.is_complex())):
raise OperationError(space.w_TypeError, space.wrap(
"ufunc '%s' not supported for the input types" % self.name))
if space.is_none(w_out):
@@ -467,7 +467,7 @@
return interp_dtype.get_dtype_cache(space).w_int8dtype
# Everything numeric promotes to complex
- if dt2.is_complex_type() or dt1.is_complex_type():
+ if dt2.is_complex() or dt1.is_complex():
if dt2.num == NPY.HALF:
dt1, dt2 = dt2, dt1
if dt2.num == NPY.CFLOAT:
@@ -488,7 +488,7 @@
if promote_to_float:
return find_unaryop_result_dtype(space, dt2, promote_to_float=True)
# If they're the same kind, choose the greater one.
- if dt1.kind == dt2.kind and not dt2.is_flexible_type():
+ if dt1.kind == dt2.kind and not dt2.is_flexible():
if dt2.num == NPY.HALF:
return dt1
return dt2
@@ -513,10 +513,10 @@
elif dt2.num == NPY.ULONGLONG or (LONG_BIT == 64 and dt2.num == NPY.ULONG):
# UInt64 + signed = Float64
dtypenum = NPY.DOUBLE
- elif dt2.is_flexible_type():
+ elif dt2.is_flexible():
# For those operations that get here (concatenate, stack),
# flexible types take precedence over numeric type
- if dt2.is_record_type():
+ if dt2.is_record():
return dt2
if dt1.is_str_or_unicode():
if dt2.elsize >= dt1.elsize:
diff --git a/pypy/module/micronumpy/strides.py b/pypy/module/micronumpy/strides.py
--- a/pypy/module/micronumpy/strides.py
+++ b/pypy/module/micronumpy/strides.py
@@ -69,7 +69,7 @@
return True
def find_shape_and_elems(space, w_iterable, dtype):
- is_rec_type = dtype is not None and dtype.is_record_type()
+ is_rec_type = dtype is not None and dtype.is_record()
if is_rec_type and is_single_elem(space, w_iterable, is_rec_type):
return [], [w_iterable]
if isinstance(w_iterable, W_NDimArray) and w_iterable.is_scalar():
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -1623,6 +1623,12 @@
def test_realimag_views(self):
from numpypy import arange, array
+ a = array(1.5)
+ assert a.real == 1.5
+ assert a.imag == 0.0
+ a = array([1.5, 2.5])
+ assert (a.real == [1.5, 2.5]).all()
+ assert (a.imag == [0.0, 0.0]).all()
a = arange(15)
b = a.real
b[5]=50
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -1961,7 +1961,7 @@
# compute alignment
for tp in globals().values():
if isinstance(tp, type) and hasattr(tp, 'T'):
- tp.alignment = clibffi.cast_type_to_ffitype(tp.T).c_alignment
+ tp.alignment = widen(clibffi.cast_type_to_ffitype(tp.T).c_alignment)
if issubclass(tp, Float):
all_float_types.append((tp, 'float'))
if issubclass(tp, Integer):
More information about the pypy-commit
mailing list