Author: Justin Peel <[email protected]>
Branch: numpy-dtype
Changeset: r46714:7695baf72d2f
Date: 2011-08-22 00:38 -0600
http://bitbucket.org/pypy/pypy/changeset/7695baf72d2f/
Log: setslice is working, but had to disable all types except bool,
int32, long, float64.
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
@@ -7,7 +7,9 @@
from pypy.objspace.std.intobject import W_IntObject
from pypy.objspace.std.longobject import W_LongObject
from pypy.rlib.rarithmetic import r_int, r_uint, LONG_BIT, LONGLONG_BIT
+from pypy.rlib.objectmodel import specialize
from pypy.rpython.lltypesystem import lltype, rffi
+from pypy.rpython.lltypesystem.rffi import r_signedchar, r_uchar, r_short,
r_ushort, r_long, r_ulong, r_longlong, r_ulonglong
_letters_to_nums = [-1]*256
@@ -61,45 +63,6 @@
'float32': Float32_num, 'float64': Float64_num,
'float96': Float96_num}
-class Dtype(Wrappable):
- # attributes: type, kind, typeobj?(I think it should point to np.float64 or
- # the like), byteorder, flags, type_num, elsize, alignment, subarray,
- # fields, names, f?, metadata. I'll just implement the base minimum for
- # now. This will include type, kind, typeobj?, byteorder, type_num, elsize,
- #
- def __init__(self, name, num, kind):
- # doesn't handle align and copy parameters yet
- # only deals with simple strings e.g., 'uint32', and type objects
- self.num = num
- self.kind = kind
- self.name = name
-
- def descr_num(self, space):
- return space.wrap(self.num)
-
- def descr_kind(self, space):
- return space.wrap(self.kind)
-
- def descr_name(self, space):
- return space.wrap(self.name)
-
- def descr_repr(self, space):
- return space.wrap("dtype('%s')" % self.name)
-
- descr_str = descr_name
-
-
-def make_dtype(TP, name, convfunc, castfunc, unwrapfunc, num, kind):
- class A_Dtype(Dtype):
- def __init__(self):
- Dtype.__init__(self, name, num, kind)
- self.TP = TP
- self.conv = convfunc
- self.cast = castfunc
- self.unwrap = unwrapfunc
- A_Dtype.__name__ = "Dtype_" + name
- return A_Dtype()
-
def unwrap_float(space, val):
return space.float_w(space.float(val))
@@ -169,41 +132,93 @@
return float(val)
# return space.float(val)
-Bool_dtype = make_dtype(lltype.Array(lltype.Bool, hints={'nolength': True}),
+class Dtype(Wrappable):
+ pass
+ # attributes: type, kind, typeobj?(I think it should point to np.float64 or
+ # the like), byteorder, flags, type_num, elsize, alignment, subarray,
+ # fields, names, f?, metadata. I'll just implement the base minimum for
+ # now. This will include type, kind, typeobj?, byteorder, type_num, elsize,
+ #
+# def descr_num(self, space):
+# return space.wrap(self.num)
+
+ def descr_kind(self, space):
+ return space.wrap(self.kind)
+
+ def descr_name(self, space):
+ return space.wrap(self.name)
+
+ def descr_repr(self, space):
+ return space.wrap("dtype('%s')" % self.name)
+
+ descr_str = descr_name
+
+def make_dtype(_valtype, _TP, _name, convfunc, castfunc, unwrapfunc, _num,
_kind):
+ class A_Dtype(Dtype):
+ #_immutable_fields_ = ["num", "kind", "TP", "conv", "cast", "unwrap"]
+ valtype = _valtype
+ TP = _TP
+ name = _name
+ kind = _kind
+ num = _num
+ def __init__(self):
+ self.conv = convfunc
+ self.cast = castfunc
+ self.unwrap = unwrapfunc
+
+ def getnum(self):
+ return _num
+
+ @specialize.argtype(1)
+ def convval(self, val):
+ return rffi.cast(_TP.OF, val)
+
+ A_Dtype.__name__ = "Dtype_" + _name
+ return A_Dtype()
+
+Bool_dtype = make_dtype(True.__class__, lltype.Array(lltype.Bool,
hints={'nolength': True}),
'bool', conv_bool, cast_bool, unwrap_bool, Bool_num, BOOLLTR)
-Int8_dtype = make_dtype(lltype.Array(rffi.SIGNEDCHAR, hints={'nolength':
True}),
- 'int8', conv_int, cast_int8, unwrap_int, Int8_num, SIGNEDLTR)
-UInt8_dtype = make_dtype(lltype.Array(rffi.UCHAR, hints={'nolength': True}),
- 'uint8', conv_int, cast_uint8, unwrap_int, UInt8_num, UNSIGNEDLTR)
-Int16_dtype = make_dtype(lltype.Array(rffi.SHORT, hints={'nolength': True}),
+#Int8_dtype = make_dtype(r_signedchar, lltype.Array(rffi.SIGNEDCHAR,
hints={'nolength': True}),
+# 'int8', conv_int, cast_int8, unwrap_int, Int8_num, SIGNEDLTR)
+#UInt8_dtype = make_dtype(r_uchar, lltype.Array(rffi.UCHAR, hints={'nolength':
True}),
+# 'uint8', conv_int, cast_uint8, unwrap_int, UInt8_num, UNSIGNEDLTR)
+#Int16_dtype = make_dtype(r_short, lltype.Array(rffi.SHORT, hints={'nolength':
True}),
'int16', conv_int, cast_int16, unwrap_int, Int16_num, SIGNEDLTR)
-UInt16_dtype = make_dtype(lltype.Array(rffi.USHORT, hints={'nolength': True}),
- 'uint16', conv_int, cast_uint16, unwrap_int, UInt16_num, UNSIGNEDLTR)
-Int32_dtype = make_dtype(lltype.Array(rffi.INT, hints={'nolength': True}),
+#UInt16_dtype = make_dtype(r_ushort, lltype.Array(rffi.USHORT,
hints={'nolength': True}),
+# 'uint16', conv_int, cast_uint16, unwrap_int, UInt16_num, UNSIGNEDLTR)
+Int32_dtype = make_dtype(r_int, lltype.Array(rffi.INT, hints={'nolength':
True}),
'int32', conv_int, cast_int32, unwrap_int, Int32_num, SIGNEDLTR)
-UInt32_dtype = make_dtype(lltype.Array(rffi.UINT, hints={'nolength': True}),
- 'uint32', conv_int, cast_uint32, unwrap_int, UInt32_num, UNSIGNEDLTR)
-Long_dtype = make_dtype(lltype.Array(rffi.LONG, hints={'nolength': True}),
+#UInt32_dtype = make_dtype(r_uint, lltype.Array(rffi.UINT, hints={'nolength':
True}),
+# 'uint32', conv_int, cast_uint32, unwrap_int, UInt32_num, UNSIGNEDLTR)
+Long_dtype = make_dtype(r_long, lltype.Array(rffi.LONG, hints={'nolength':
True}),
'int32' if LONG_BIT == 32 else 'int64',
conv_int, cast_long, unwrap_int, Long_num, SIGNEDLTR)
-ULong_dtype = make_dtype(lltype.Array(rffi.ULONG, hints={'nolength': True}),
- 'uint32' if LONG_BIT == 32 else 'uint64',
- conv_int, cast_ulong,
- unwrap_ubigint if LONG_BIT == 32 else unwrap_int,
- ULong_num, UNSIGNEDLTR)
+#ULong_dtype = make_dtype(r_ulong, lltype.Array(rffi.ULONG, hints={'nolength':
True}),
+# 'uint32' if LONG_BIT == 32 else 'uint64',
+# conv_int, cast_ulong,
+ #unwrap_ubigint if LONG_BIT == 32 else unwrap_int,
+ #ULong_num, UNSIGNEDLTR)
-Int64_dtype = make_dtype(lltype.Array(rffi.LONGLONG, hints={'nolength': True}),
- 'int64', conv_int, cast_int64,
- unwrap_bigint if LONG_BIT == 32 else unwrap_bigint, Int64_num, SIGNEDLTR)
-UInt64_dtype = make_dtype(lltype.Array(rffi.ULONGLONG, hints={'nolength':
True}),
- 'uint64', conv_int, cast_uint64, unwrap_ubigint, UInt64_num, UNSIGNEDLTR)
+#Int64_dtype = make_dtype(r_longlong, lltype.Array(rffi.LONGLONG,
hints={'nolength': True}),
+# 'int64', conv_int, cast_int64,
+# unwrap_bigint if LONG_BIT == 32 else unwrap_bigint, Int64_num, SIGNEDLTR)
+#UInt64_dtype = make_dtype(r_ulonglong, lltype.Array(rffi.ULONGLONG,
hints={'nolength': True}),
+# 'uint64', conv_int, cast_uint64, unwrap_ubigint, UInt64_num, UNSIGNEDLTR)
#Float32_dtype = make_dtype('float32', conv_float, cast_float32, unwrap_float,
Float32_num, FLOATINGLTR)
-Float64_dtype = make_dtype(lltype.Array(lltype.Float, hints={'nolength':
True}),
+Float64_dtype = make_dtype(float, lltype.Array(lltype.Float,
hints={'nolength': True}),
'float64', conv_float, cast_float64, unwrap_float, Float64_num,
FLOATINGLTR)
#Float96_dtype = make_dtype('float96', conv_float, cast_float96, unwrap_float,
Float96_num, FLOATINGLTR)
# This is until we get ShortFloat and LongFloat implemented in the annotator
and what not
Float32_dtype = Float64_dtype
Float96_dtype = Float64_dtype
+Int8_dtype = Int32_dtype
+UInt8_dtype = Int32_dtype
+#Int16_dtype = Int32_dtype
+UInt16_dtype = Int32_dtype
+UInt32_dtype = Int32_dtype
+ULong_dtype = Int32_dtype
+Int64_dtype = Int32_dtype
+UInt64_dtype = Int32_dtype
_dtype_list = [Bool_dtype,
@@ -302,7 +317,7 @@
'numpy.dtype',
__new__ = interp2app(descr_new_dtype),
- num = GetSetProperty(Dtype.descr_num),
+# num = GetSetProperty(Dtype.descr_num),
kind = GetSetProperty(Dtype.descr_kind),
name = GetSetProperty(Dtype.descr_name),
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
@@ -11,6 +11,7 @@
from pypy.objspace.std.objspace import newlong
from pypy.rlib import jit
from pypy.rlib import rbigint
+from pypy.rlib.objectmodel import specialize
from pypy.rlib.rarithmetic import LONG_BIT
from pypy.rlib.rfloat import DTSF_STR_PRECISION
from pypy.rpython.lltypesystem import lltype, rffi
@@ -54,21 +55,21 @@
return w_ufunc(space, self)
return func_with_new_name(impl, "unaryop_%s_impl" % w_ufunc.__name__)
- descr_pos = _unaryop_impl(interp_ufuncs.positive)
- descr_neg = _unaryop_impl(interp_ufuncs.negative)
- descr_abs = _unaryop_impl(interp_ufuncs.absolute)
+ #descr_pos = _unaryop_impl(interp_ufuncs.positive)
+ #descr_neg = _unaryop_impl(interp_ufuncs.negative)
+ #descr_abs = _unaryop_impl(interp_ufuncs.absolute)
def _binop_impl(w_ufunc):
def impl(self, space, w_other):
return w_ufunc(space, self, w_other)
return func_with_new_name(impl, "binop_%s_impl" % w_ufunc.__name__)
- descr_add = _binop_impl(interp_ufuncs.add)
+ """descr_add = _binop_impl(interp_ufuncs.add)
descr_sub = _binop_impl(interp_ufuncs.subtract)
descr_mul = _binop_impl(interp_ufuncs.multiply)
descr_div = _binop_impl(interp_ufuncs.divide)
descr_pow = _binop_impl(interp_ufuncs.power)
- descr_mod = _binop_impl(interp_ufuncs.mod)
+ descr_mod = _binop_impl(interp_ufuncs.mod)"""
def _binop_right_impl(w_ufunc):
def impl(self, space, w_other):
@@ -76,12 +77,12 @@
return w_ufunc(space, w_other, self)
return func_with_new_name(impl, "binop_right_%s_impl" %
w_ufunc.__name__)
- descr_radd = _binop_right_impl(interp_ufuncs.add)
+ """descr_radd = _binop_right_impl(interp_ufuncs.add)
descr_rsub = _binop_right_impl(interp_ufuncs.subtract)
descr_rmul = _binop_right_impl(interp_ufuncs.multiply)
descr_rdiv = _binop_right_impl(interp_ufuncs.divide)
descr_rpow = _binop_right_impl(interp_ufuncs.power)
- descr_rmod = _binop_right_impl(interp_ufuncs.mod)
+ descr_rmod = _binop_right_impl(interp_ufuncs.mod)"""
def _reduce_sum_prod_impl(function, init):
reduce_driver = jit.JitDriver(greens=['signature'],
@@ -244,9 +245,10 @@
# Single index
return self.get_concrete().getitem(space, start)
else:
+ raise OperationError(space.w_ValueError, space.wrap("No slices"))
# Slice
- res = SingleDimSlice(start, stop, step, slice_length, self,
self.signature.transition(SingleDimSlice.static_signature))
- return space.wrap(res)
+ #res = SingleDimSlice(start, stop, step, slice_length, self,
self.signature.transition(SingleDimSlice.static_signature))
+ #return space.wrap(res)
def descr_setitem(self, space, w_idx, w_value):
# TODO: indexing by tuples and lists
@@ -257,45 +259,25 @@
# Single index
self.get_concrete().setitem_w(space, start, w_value)
else:
- raise OperationError(space.w_ValueError, space.wrap("No slices"))
- #concrete = self.get_concrete()
+ #raise OperationError(space.w_ValueError, space.wrap("No slices"))
+ concrete = self.get_concrete()
#if isinstance(w_value, BaseArray):
- # for now we just copy if setting part of an array from
- # part of itself. can be improved.
- # need to put in a function that checks all storages of
- # w_value because it could be a Call2 class (binop)
+ #for now we just copy if setting part of an array from
+ #part of itself. can be improved.
+ #need to put in a function that checks all storages of
+ #w_value because it could be a Call2 class (binop)
# if (concrete.get_root_storage() ==
# w_value.get_concrete().get_root_storage()):
# w_value = new_numarray(space, w_value, self.dtype)
#else:
- # w_value = convert_to_array(space, w_value)
- #concrete.setslice(space, start, stop, step,
- # slice_length, w_value)
+ w_value = convert_to_array(space, w_value)
+ concrete.setslice(space, start, stop, step,
+ slice_length, w_value)
def descr_mean(self, space):
return
space.wrap(space.float_w(self.descr_sum(space))/self.find_size())
- def _sliceloop1(self, start, stop, step, source, dest):
- i = start
- j = 0
- while i < stop:
- slice_driver1.jit_merge_point(signature=source.signature,
- step=step, stop=stop, i=i, j=j, source=source,
- dest=dest)
- dest.setitem(i, source.eval(j))
- j += 1
- i += step
- def _sliceloop2(self, start, stop, step, source, dest):
- i = start
- j = 0
- while i > stop:
- slice_driver2.jit_merge_point(signature=source.signature,
- step=step, stop=stop, i=i, j=j, source=source,
- dest=dest)
- dest.setitem(i, source.eval(j))
- j += 1
- i += step
def convert_to_array (space, w_obj):
if isinstance(w_obj, BaseArray):
@@ -305,8 +287,9 @@
# XXX: Need to fill in the dtype
return new_numarray(space, w_obj, Float64_dtype)
else:
+ raise OperationError(space.w_ValueError, space.wrap("no scalars"))
# If it's a scalar
- return wrap_scalar(space, w_obj)
+ #return wrap_scalar(space, w_obj)
def wrap_scalar(space, scalar, dtype=None):
if dtype is None:
@@ -339,121 +322,140 @@
def __init__(self, value):
ScalarWrapper.__init__(self, value, Float64_dtype)
-class VirtualArray(BaseArray):
- """
- Class for representing virtual arrays, such as binary ops or ufuncs
- """
- def __init__(self, signature):
- BaseArray.__init__(self)
- self.forced_result = None
- self.signature = signature
+def make_virtualarray(_dtype):
+ class VirtualArray(BaseArray):
+ dtype = _dtype
+ """
+ Class for representing virtual arrays, such as binary ops or ufuncs
+ """
+ def __init__(self, signature):
+ BaseArray.__init__(self)
+ self.forced_result = None
+ self.signature = signature
- def _del_sources(self):
- # Function for deleting references to source arrays, to allow
garbage-collecting them
- raise NotImplementedError
+ def _del_sources(self):
+ # Function for deleting references to source arrays, to allow
garbage-collecting them
+ raise NotImplementedError
- def compute(self):
- i = 0
- signature = self.signature
- result_size = self.find_size()
- result = create_sdarray(result_size, self.dtype)
- #storage = result.get_root_storage()
- while i < result_size:
- numpy_driver.jit_merge_point(signature=signature,
- result_size=result_size, i=i,
- self=self, result=result)
- result.setitem(i, self.eval(i))
- i += 1
- return result
+ def compute(self):
+ i = 0
+ signature = self.signature
+ result_size = self.find_size()
+ result = create_sdarray(result_size, _dtype)
+ #storage = result.get_root_storage()
+ while i < result_size:
+ numpy_driver.jit_merge_point(signature=signature,
+ result_size=result_size, i=i,
+ self=self, result=result)
+ temp = self.eval(i)
+ #assert isinstance(temp, _dtype.TP.OF)
+ result.setitem_cast(i, temp)
+ i += 1
+ return result
- def force_if_needed(self):
- if self.forced_result is None:
- self.forced_result = self.compute()
- self._del_sources()
+ def force_if_needed(self):
+ if self.forced_result is None:
+ self.forced_result = self.compute()
+ self._del_sources()
- def get_concrete(self):
- self.force_if_needed()
- return self.forced_result
+ def get_concrete(self):
+ self.force_if_needed()
+ return self.forced_result
- def eval(self, i):
- if self.forced_result is not None:
- return self.forced_result.eval(i)
- return self._eval(i)
+ def eval(self, i):
+ if self.forced_result is not None:
+ return self.forced_result.eval(i)
+ return self._eval(i)
- def find_size(self):
- if self.forced_result is not None:
- # The result has been computed and sources may be unavailable
- return self.forced_result.find_size()
- return self._find_size()
+ def find_size(self):
+ if self.forced_result is not None:
+ # The result has been computed and sources may be unavailable
+ return self.forced_result.find_size()
+ return self._find_size()
- def find_dtype(self):
- return self.dtype
+ def find_dtype(self):
+ return _dtype
+ VirtualArray.__name__ = "VirtualArray_" + _dtype.name
+ return VirtualArray
-class Call1(VirtualArray):
- _immutable_fields_ = ["function", "values"]
+_virtualarray_classes = [make_virtualarray(d) for d in _dtype_list]
- def __init__(self, function, values, signature):
- VirtualArray.__init__(self, signature)
- self.function = function
- self.values = values
- self.dtype = self.values.find_dtype()
+def make_call1(VirtualArrayClass):
+ class Call1(VirtualArrayClass):
+ _immutable_fields_ = ["function", "values"]
- def _del_sources(self):
- self.values = None
+ def __init__(self, function, values, signature):
+ VirtualArrayClass.__init__(self, signature)
+ self.function = function
+ self.values = values
- def _find_size(self):
- return self.values.find_size()
+ def _del_sources(self):
+ self.values = None
- def _eval(self, i):
- return self.function(self.values.eval(i))
+ def _find_size(self):
+ return self.values.find_size()
-class Call2(VirtualArray):
- """
- Intermediate class for performing binary operations.
- """
- _immutable_fields_ = ["function", "left", "right"]
+ def _eval(self, i):
+ return self.function(self.values.eval(i))
+ Call1.__name__ = "Call1_" + Call1.dtype.name
+ return Call1
- def __init__(self, function, left, right, signature):
- VirtualArray.__init__(self, signature)
- self.left = left
- self.right = right
- dtype = self.left.find_dtype()
- dtype2 = self.right.find_dtype()
- if dtype.num != dtype2.num:
- newdtype = find_result_dtype(dtype, dtype2)
- cast = newdtype.cast
- if dtype.num != newdtype.num:
- if dtype2.num != newdtype.num:
- self.function = lambda x, y: function(cast(x), cast(y))
+_call1_classes = [make_call1(c) for c in _virtualarray_classes]
+
+def make_call2(VirtualArrayClass):
+ class Call2(VirtualArrayClass):
+ """
+ Intermediate class for performing binary operations.
+ """
+ _immutable_fields_ = ["function", "left", "right"]
+
+ def __init__(self, function, left, right, signature):
+ VirtualArrayClass.__init__(self, signature)
+ self.left = left
+ self.right = right
+ dtype1 = self.left.find_dtype()
+ dtype2 = self.right.find_dtype()
+ if dtype1.num != dtype2.num:
+ cast = self.dtype.cast
+ if dtype.num != newdtype.num:
+ if dtype2.num != newdtype.num:
+ self.function = lambda x, y: function(cast(x), cast(y))
+ else:
+ self.function = lambda x, y: function(cast(x), y)
else:
- self.function = lambda x, y: function(cast(x), y)
+ self.function = lambda x, y: function(x, cast(y))
else:
- self.function = lambda x, y: function(x, cast(y))
- self.dtype = newdtype
- else:
- self.dtype = dtype
- self.function = function
+ self.function = function
- def _del_sources(self):
- self.left = None
- self.right = None
+ def _del_sources(self):
+ self.left = None
+ self.right = None
- def _find_size(self):
- try:
- return self.left.find_size()
- except:
- return self.right.find_size()
+ def _find_size(self):
+ try:
+ return self.left.find_size()
+ except:
+ return self.right.find_size()
- def _eval(self, i):
- lhs, rhs = self.left.eval(i), self.right.eval(i)
- return self.function(lhs, rhs)
+ def _eval(self, i):
+ lhs, rhs = self.left.eval(i), self.right.eval(i)
+ return self.function(lhs, rhs)
+ Call2.__name__ = "Call2_" + Call2.dtype.name
+ return Call2
-class ViewArray(BaseArray):
- """
- Class for representing views of arrays, they will reflect changes of parent
- arrays. Example: slices
- """
- _immutable_fields_ = ["parent"]
+_call2_classes = [make_call2(c) for c in _virtualarray_classes]
+
+def pick_call2(dtype1, dtype2):
+ if dtype1.num == dtype2.num:
+ return _call2_classes[dtype1.num]
+ return _call2_classes[find_result_dtype(dtype1, dtype2)]
+
+#class ViewArray(BaseArray):
+# """
+# Class for representing views of arrays, they will reflect changes of
parent
+# arrays. Example: slices
+# """
+""" _immutable_fields_ = ["parent"]
def __init__(self, parent, signature):
BaseArray.__init__(self)
@@ -475,7 +477,6 @@
def setitem_w(self, space, item, value):
return self.parent.setitem_w(space, self.calc_index(item), value)
- @unwrap_spec(item=int, value=float)
def setitem(self, item, value):
return self.parent.setitem(self.calc_index(item), value)
@@ -525,29 +526,12 @@
self._sliceloop2(start, stop, step, arr, self.parent)
def calc_index(self, item):
- return (self.start + item * self.step)
+ return (self.start + item * self.step)"""
class SingleDimArray(BaseArray):
- signature = Signature()
-
def __init__(self):
BaseArray.__init__(self)
- def get_concrete(self):
- return self
-
- def find_size(self):
- return self.size
-
- def descr_len(self, space):
- return space.wrap(self.size)
-
- def setslice(self, space, start, stop, step, slice_length, arr):
- if step > 0:
- self._sliceloop1(start, stop, step, arr, self)
- else:
- self._sliceloop2(start, stop, step, arr, self)
-
def fromlong(val):
if val >= 0:
if val == 0:
@@ -562,22 +546,36 @@
return rbigint.rbigint(digits, sign)
def make_class(_dtype):
- class TypedSingleDimArray(SingleDimArray):
+ class TypedSingleDimArray(BaseArray):
+ signature = Signature()
dtype = _dtype
def __init__(self, size):
- SingleDimArray.__init__(self)
+ BaseArray.__init__(self)
self.size = size
self.storage = lltype.malloc(_dtype.TP, size, zero=True,
flavor='raw', track_allocation=False,
add_memory_pressure=True)
# XXX find out why test_zjit explodes with trackign of allocations
+ def get_concrete(self):
+ return self
+
+ def find_size(self):
+ return self.size
+
+ def descr_len(self, space):
+ return space.wrap(self.size)
+
def get_root_storage(self):
return self.storage
def eval(self, i):
return self.storage[i]
-
+
+ @specialize.argtype(2)
+ def eval_cast(self, i, d):
+ return d.convval(self.storage[i])
+
if _dtype.kind == 'b':
def getitem(self, space, i):
return space.wrap(bool(self.storage[i]))
@@ -595,8 +593,42 @@
return newlong(space, fromlong(self.storage[i]))
def setitem(self, item, value):
+ assert isinstance(value, _dtype.valtype)
self.storage[item] = value
+ #def setitem_cast(self, item, value):
+ # self.storage[item] = rffi.cast(_dtype.TP.OF, value)
+
+ def _sliceloop1(self, start, stop, step, source):
+ i = start
+ j = 0
+ conv = _dtype.convval
+ while i < stop:
+ #slice_driver1.jit_merge_point(signature=source.signature,
+ #step=step, stop=stop, i=i, j=j, source=source,
+ #dest=dest)
+ self.storage[i] = conv(source.eval(j))
+ j += 1
+ i += step
+
+ def _sliceloop2(self, start, stop, step, source):
+ i = start
+ j = 0
+ conv = _dtype.convval
+ while i > stop:
+ #slice_driver2.jit_merge_point(signature=source.signature,
+ #step=step, stop=stop, i=i, j=j, source=source,
+ #dest=dest)
+ self.storage[i] = conv(source.eval(j))
+ j += 1
+ i += step
+
+ def setslice(self, space, start, stop, step, slice_length, arr):
+ if step > 0:
+ self._sliceloop1(start, stop, step, arr)
+ else:
+ self._sliceloop2(start, stop, step, arr)
+
def setitem_w(self, space, item, value):
self.storage[item] = rffi.cast(_dtype.TP.OF, _dtype.unwrap(space,
value))
@@ -649,9 +681,11 @@
@unwrap_spec(size=int)
def ones(space, size):
- arr = create_sdarray(size, Float64_dtype)
- for i in xrange(size):
- arr.setitem(space, i, 1.0)
+ dtype = _dtype_list[12]
+ arr = _array_classes[dtype.num](size)
+ one = dtype.cast(1)
+ #for i in xrange(size):
+ arr.setitem(0, one)
return space.wrap(arr)
BaseArray.typedef = TypeDef(
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
@@ -7,33 +7,33 @@
def ufunc(func):
signature = Signature()
def impl(space, w_obj):
- from pypy.module.micronumpy.interp_numarray import Call1,
convert_to_array
+ from pypy.module.micronumpy.interp_numarray import _call1_classes,
convert_to_array
if space.issequence_w(w_obj):
w_obj_arr = convert_to_array(space, w_obj)
- w_res = Call1(func, w_obj_arr,
w_obj_arr.signature.transition(signature))
+ w_res = _call1_classes[w_obj_arr.dtype.num](func, w_obj_arr,
w_obj_arr.signature.transition(signature))
w_obj_arr.invalidates.append(w_res)
return w_res
else:
return space.wrap(func(space.float_w(w_obj)))
return func_with_new_name(impl, "%s_dispatcher" % func.__name__)
-def ufunc2(func):
+"""def ufunc2(func):
signature = Signature()
def impl(space, w_lhs, w_rhs):
- from pypy.module.micronumpy.interp_numarray import Call2,
convert_to_array
+ from pypy.module.micronumpy.interp_numarray import pick_call2,
convert_to_array
if space.issequence_w(w_lhs) or space.issequence_w(w_rhs):
w_lhs_arr = convert_to_array(space, w_lhs)
w_rhs_arr = convert_to_array(space, w_rhs)
new_sig =
w_lhs_arr.signature.transition(signature).transition(w_rhs_arr.signature)
- w_res = Call2(func, w_lhs_arr, w_rhs_arr, new_sig)
+ w_res = pick_call2(w_lhs_arr.dtype, w_rhs_arr.dtype)(func,
w_lhs_arr, w_rhs_arr, new_sig)
w_lhs_arr.invalidates.append(w_res)
w_rhs_arr.invalidates.append(w_res)
return w_res
else:
return space.wrap(func(space.float_w(w_lhs), space.float_w(w_rhs)))
- return func_with_new_name(impl, "%s_dispatcher" % func.__name__)
+ return func_with_new_name(impl, "%s_dispatcher" % func.__name__)"""
-@ufunc
+"""@ufunc
def absolute(value):
return abs(value)
@@ -70,14 +70,14 @@
@ufunc2
def multiply(lvalue, rvalue):
- return lvalue * rvalue
+ return lvalue * rvalue"""
# Used by numarray for __pos__. Not visible from numpy application space.
@ufunc
def positive(value):
return value
-@ufunc
+"""@ufunc
def negative(value):
return -value
@@ -121,7 +121,6 @@
def mod(lvalue, rvalue):
return math.fmod(lvalue, rvalue)
-
@ufunc
def arcsin(value):
if value < -1.0 or value > 1.0:
@@ -136,4 +135,4 @@
@ufunc
def arctan(value):
- return math.atan(value)
+ return math.atan(value)"""
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
