def numpify(space, w_object): """Convert the object to a W_NumpyObject""" # XXX: code duplication with _array() from pypy.module.micronumpy import strides if isinstance(w_object, W_NumpyObject): return w_object # for anything that isn't already an array, try __array__ method first w_array = try_array_method(space, w_object) if w_array is not None: return w_array shape, elems_w = strides.find_shape_and_elems(space, w_object, None) dtype = find_dtype_for_seq(space, elems_w, None) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') if len(elems_w) == 1: return dtype.coerce(space, elems_w[0]) else: w_arr = W_NDimArray.from_shape(space, shape, dtype) loop.assign(space, w_arr, elems_w) return w_arr
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True): w_a = convert_to_array(space, w_a) npy_order = order_converter(space, w_order, w_a.get_order()) if space.is_none(w_dtype): dtype = w_a.get_dtype() else: dtype = space.interp_w( descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') if npy_order in (NPY.KEEPORDER, NPY.ANYORDER): # Try to copy the stride pattern impl = w_a.implementation.astype(space, dtype, NPY.KEEPORDER) if subok: w_type = space.type(w_a) else: w_type = None return wrap_impl(space, w_type, w_a, impl) return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype, order=npy_order, w_instance=w_a if subok else None, zero=False)
def numpify(space, w_object): """Convert the object to a W_NumpyObject""" # XXX: code duplication with _array() from pypy.module.micronumpy import strides if isinstance(w_object, W_NumpyObject): return w_object # for anything that isn't already an array, try __array__ method first w_array = try_array_method(space, w_object) if w_array is not None: return w_array shape, elems_w = strides.find_shape_and_elems(space, w_object, None) dtype = strides.find_dtype_for_seq(space, elems_w, None) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') if len(elems_w) == 1: return dtype.coerce(space, elems_w[0]) else: w_arr = W_NDimArray.from_shape(space, shape, dtype) loop.assign(space, w_arr, elems_w) return w_arr
def zeros(space, w_shape, w_dtype=None, w_order=None): dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') shape = shape_converter(space, w_shape, dtype) return W_NDimArray.from_shape(space, shape, dtype=dtype)
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True): w_a = convert_to_array(space, w_a) if space.is_none(w_dtype): dtype = w_a.get_dtype() else: dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype, w_instance=w_a if subok else None)
def find_dtype_for_seq(space, elems_w, dtype): if len(elems_w) == 1: w_elem = elems_w[0] return _dtype_guess(space, dtype, w_elem) for w_elem in elems_w: dtype = _dtype_guess(space, dtype, w_elem) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') return dtype
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True): w_a = convert_to_array(space, w_a) if space.is_none(w_dtype): dtype = w_a.get_dtype() else: dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype, w_instance=w_a if subok else None, zero=False)
def find_dtype_for_seq(space, elems_w, dtype): if len(elems_w) == 1: w_elem = elems_w[0] return _dtype_guess(space, dtype, w_elem) for w_elem in elems_w: dtype = _dtype_guess(space, dtype, w_elem) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') return dtype
def _zeros_or_empty(space, w_shape, w_dtype, w_order, zero): dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') shape = shape_converter(space, w_shape, dtype) for dim in shape: if dim < 0: raise OperationError(space.w_ValueError, space.wrap( "negative dimensions are not allowed")) try: support.product_check(shape) except OverflowError: raise oefmt(space.w_ValueError, "array is too big.") return W_NDimArray.from_shape(space, shape, dtype=dtype, zero=zero)
def _zeros_or_empty(space, w_shape, w_dtype, w_order, zero): dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') shape = shape_converter(space, w_shape, dtype) for dim in shape: if dim < 0: raise OperationError(space.w_ValueError, space.wrap( "negative dimensions are not allowed")) try: support.product(shape) except OverflowError: raise OperationError(space.w_ValueError, space.wrap( "array is too big.")) return W_NDimArray.from_shape(space, shape, dtype=dtype, zero=zero)
def _zeros_or_empty(space, w_shape, w_dtype, w_order, zero): # w_order can be None, str, or boolean order = order_converter(space, w_order, NPY.CORDER) dtype = space.interp_w( descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') shape = shape_converter(space, w_shape, dtype) for dim in shape: if dim < 0: raise oefmt(space.w_ValueError, "negative dimensions are not allowed") try: support.product_check(shape) except OverflowError: raise oefmt(space.w_ValueError, "array is too big.") return W_NDimArray.from_shape(space, shape, dtype, order, zero=zero)
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True): w_a = convert_to_array(space, w_a) npy_order = order_converter(space, w_order, w_a.get_order()) if space.is_none(w_dtype): dtype = w_a.get_dtype() else: dtype = space.interp_w(descriptor.W_Dtype, space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype)) if dtype.is_str_or_unicode() and dtype.elsize < 1: dtype = descriptor.variable_dtype(space, dtype.char + '1') if npy_order in (NPY.KEEPORDER, NPY.ANYORDER): # Try to copy the stride pattern impl = w_a.implementation.astype(space, dtype, NPY.KEEPORDER) if subok: w_type = space.type(w_a) else: w_type = None return wrap_impl(space, w_type, w_a, impl) return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype, order=npy_order, w_instance=w_a if subok else None, zero=False)
def numpify(space, w_object): """Convert the object to a W_NumpyObject""" # XXX: code duplication with _array() if isinstance(w_object, W_NumpyObject): return w_object # for anything that isn't already an array, try __array__ method first w_array = try_array_method(space, w_object) if w_array is not None: return w_array if is_scalar_like(space, w_object, dtype=None): dtype = scalar2dtype(space, w_object) if dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') return dtype.coerce(space, w_object) shape, elems_w = _find_shape_and_elems(space, w_object) dtype = find_dtype_for_seq(space, elems_w, None) w_arr = W_NDimArray.from_shape(space, shape, dtype) loop.assign(space, w_arr, elems_w) return w_arr
def numpify(space, w_object): """Convert the object to a W_NumpyObject""" # XXX: code duplication with _array() if isinstance(w_object, W_NumpyObject): return w_object # for anything that isn't already an array, try __array__ method first w_array = try_array_method(space, w_object) if w_array is not None: return w_array if is_scalar_like(space, w_object, dtype=None): dtype = scalar2dtype(space, w_object) if dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') return dtype.coerce(space, w_object) shape, elems_w = _find_shape_and_elems(space, w_object) dtype = find_dtype_for_seq(space, elems_w, None) w_arr = W_NDimArray.from_shape(space, shape, dtype) loop.assign(space, w_arr, elems_w) return w_arr
def _array(space, w_object, w_dtype=None, copy=True, w_order=None, subok=False): from pypy.module.micronumpy import strides # for anything that isn't already an array, try __array__ method first if not isinstance(w_object, W_NDimArray): w_array = try_array_method(space, w_object, w_dtype) if w_array is not None: # continue with w_array, but do further operations in place w_object = w_array copy = False dtype = descriptor.decode_w_dtype(space, w_dtype) if space.is_none(w_order): order = 'C' else: order = space.str_w(w_order) if order == 'K': order = 'C' if order != 'C': # or order != 'F': raise oefmt(space.w_ValueError, "Unknown order: %s", order) if isinstance(w_object, W_NDimArray): if (dtype is None or w_object.get_dtype() is dtype): if copy and (subok or type(w_object) is W_NDimArray): return w_object.descr_copy(space, w_order) elif not copy and (subok or type(w_object) is W_NDimArray): return w_object # we have a ndarray, but need to copy or change dtype or create W_NDimArray if dtype is None: dtype = w_object.get_dtype() if dtype != w_object.get_dtype(): # silently reject the copy value copy = True if copy: shape = w_object.get_shape() _elems_w = w_object.reshape(space, space.wrap(-1)) elems_w = [None] * w_object.get_size() for i in range(len(elems_w)): elems_w[i] = _elems_w.descr_getitem(space, space.wrap(i)) elif subok: raise oefmt(space.w_NotImplementedError, "array(...copy=False, subok=True) not implemented yet") else: sz = support.product(w_object.get_shape()) * dtype.elsize return W_NDimArray.from_shape_and_storage(space, w_object.get_shape(),w_object.implementation.storage, dtype, storage_bytes=sz, w_base=w_object) else: # not an array shape, elems_w = strides.find_shape_and_elems(space, w_object, dtype) if dtype is None or (dtype.is_str_or_unicode() and dtype.elsize < 1): dtype = strides.find_dtype_for_seq(space, elems_w, dtype) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order) if len(elems_w) == 1: w_arr.set_scalar_value(dtype.coerce(space, elems_w[0])) else: loop.assign(space, w_arr, elems_w) return w_arr
def array(space, w_object, w_dtype=None, copy=True, w_order=None, subok=False, ndmin=0): from pypy.module.micronumpy import strides # for anything that isn't already an array, try __array__ method first if not isinstance(w_object, W_NDimArray): w___array__ = space.lookup(w_object, "__array__") if w___array__ is not None: if space.is_none(w_dtype): w_dtype = space.w_None w_array = space.get_and_call_function(w___array__, w_object, w_dtype) if isinstance(w_array, W_NDimArray): # feed w_array back into array() for other properties return array(space, w_array, w_dtype, False, w_order, subok, ndmin) else: raise oefmt(space.w_ValueError, "object __array__ method not producing an array") dtype = descriptor.decode_w_dtype(space, w_dtype) if space.is_none(w_order): order = 'C' else: order = space.str_w(w_order) if order == 'K': order = 'C' if order != 'C': # or order != 'F': raise oefmt(space.w_ValueError, "Unknown order: %s", order) # arrays with correct dtype if isinstance(w_object, W_NDimArray) and \ (space.is_none(w_dtype) or w_object.get_dtype() is dtype): shape = w_object.get_shape() if copy: w_ret = w_object.descr_copy(space) else: if ndmin <= len(shape): return w_object new_impl = w_object.implementation.set_shape(space, w_object, shape) w_ret = W_NDimArray(new_impl) if ndmin > len(shape): shape = [1] * (ndmin - len(shape)) + shape w_ret.implementation = w_ret.implementation.set_shape(space, w_ret, shape) return w_ret # not an array or incorrect dtype shape, elems_w = strides.find_shape_and_elems(space, w_object, dtype) if dtype is None or (dtype.is_str_or_unicode() and dtype.elsize < 1): dtype = strides.find_dtype_for_seq(space, elems_w, dtype) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') if ndmin > len(shape): shape = [1] * (ndmin - len(shape)) + shape w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order) if len(elems_w) == 1: w_arr.set_scalar_value(dtype.coerce(space, elems_w[0])) else: loop.assign(space, w_arr, elems_w) return w_arr
def _array(space, w_object, w_dtype=None, copy=True, w_order=None, subok=False): from pypy.module.micronumpy import strides # for anything that isn't already an array, try __array__ method first if not isinstance(w_object, W_NDimArray): w_array = try_array_method(space, w_object, w_dtype) if w_array is not None: # continue with w_array, but do further operations in place w_object = w_array copy = False if not isinstance(w_object, W_NDimArray): w_array = try_interface_method(space, w_object) if w_array is not None: w_object = w_array copy = False dtype = descriptor.decode_w_dtype(space, w_dtype) if space.is_none(w_order): order = 'C' else: order = space.str_w(w_order) if order == 'K': order = 'C' if order != 'C': # or order != 'F': raise oefmt(space.w_ValueError, "Unknown order: %s", order) if isinstance(w_object, W_NDimArray): if (dtype is None or w_object.get_dtype() is dtype): if copy and (subok or type(w_object) is W_NDimArray): return w_object.descr_copy(space, w_order) elif not copy and (subok or type(w_object) is W_NDimArray): return w_object if subok and not type(w_object) is W_NDimArray: raise oefmt(space.w_NotImplementedError, "array(..., subok=True) only partially implemented") # we have a ndarray, but need to copy or change dtype if dtype is None: dtype = w_object.get_dtype() if dtype != w_object.get_dtype(): # silently reject the copy value copy = True if copy: shape = w_object.get_shape() elems_w = [None] * w_object.get_size() elsize = w_object.get_dtype().elsize # TODO - use w_object.implementation without copying to a list # unfortunately that causes a union error in translation for i in range(w_object.get_size()): elems_w[i] = w_object.implementation.getitem(i * elsize) else: imp = w_object.implementation with imp as storage: sz = support.product(w_object.get_shape()) * dtype.elsize return W_NDimArray.from_shape_and_storage(space, w_object.get_shape(), storage, dtype, storage_bytes=sz, w_base=w_object, start=imp.start) else: # not an array shape, elems_w = strides.find_shape_and_elems(space, w_object, dtype) if dtype is None or (dtype.is_str_or_unicode() and dtype.elsize < 1): dtype = strides.find_dtype_for_seq(space, elems_w, dtype) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order) if support.product(shape) == 1: w_arr.set_scalar_value(dtype.coerce(space, elems_w[0])) else: loop.assign(space, w_arr, elems_w) return w_arr
elif space.isinstance_w(w_obj, space.w_long): try: space.int_w(w_obj) except OperationError, e: if e.match(space, space.w_OverflowError): return find_binop_result_dtype(space, uint64_dtype, current_guess) raise return find_binop_result_dtype(space, int64_dtype, current_guess) elif space.isinstance_w(w_obj, space.w_float): return find_binop_result_dtype(space, float_dtype, current_guess) elif space.isinstance_w(w_obj, space.w_complex): return complex_dtype elif space.isinstance_w(w_obj, space.w_str): if current_guess is None: return descriptor.variable_dtype(space, 'S%d' % space.len_w(w_obj)) elif current_guess.num == NPY.STRING: if current_guess.elsize < space.len_w(w_obj): return descriptor.variable_dtype(space, 'S%d' % space.len_w(w_obj)) return current_guess raise oefmt(space.w_NotImplementedError, 'unable to create dtype from objects, "%T" instance not ' 'supported', w_obj) def ufunc_dtype_caller(space, ufunc_name, op_name, argcount, comparison_func, bool_result): def get_op(dtype): try: return getattr(dtype.itemtype, op_name)
def _array(space, w_object, w_dtype=None, copy=True, w_order=None, subok=False): from pypy.module.micronumpy import strides # for anything that isn't already an array, try __array__ method first if not isinstance(w_object, W_NDimArray): w_array = try_array_method(space, w_object, w_dtype) if w_array is not None: # continue with w_array, but do further operations in place w_object = w_array copy = False if not isinstance(w_object, W_NDimArray): w_array = try_interface_method(space, w_object) if w_array is not None: w_object = w_array copy = False dtype = descriptor.decode_w_dtype(space, w_dtype) if space.is_none(w_order): order = 'C' else: order = space.str_w(w_order) if order == 'K': order = 'C' if order != 'C': # or order != 'F': raise oefmt(space.w_ValueError, "Unknown order: %s", order) if isinstance(w_object, W_NDimArray): if (dtype is None or w_object.get_dtype() is dtype): if copy and (subok or type(w_object) is W_NDimArray): return w_object.descr_copy(space, w_order) elif not copy and (subok or type(w_object) is W_NDimArray): return w_object if subok and not type(w_object) is W_NDimArray: raise oefmt(space.w_NotImplementedError, "array(..., subok=True) only partially implemented") # we have a ndarray, but need to copy or change dtype if dtype is None: dtype = w_object.get_dtype() if dtype != w_object.get_dtype(): # silently reject the copy value copy = True if copy: shape = w_object.get_shape() w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order) if support.product(shape) == 1: w_arr.set_scalar_value(dtype.coerce(space, w_object.implementation.getitem(0))) else: loop.setslice(space, shape, w_arr.implementation, w_object.implementation) return w_arr else: imp = w_object.implementation w_base = w_object if imp.base() is not None: w_base = imp.base() with imp as storage: sz = support.product(w_object.get_shape()) * dtype.elsize return W_NDimArray.from_shape_and_storage(space, w_object.get_shape(), storage, dtype, storage_bytes=sz, w_base=w_base, start=imp.start) else: # not an array shape, elems_w = strides.find_shape_and_elems(space, w_object, dtype) if dtype is None and space.isinstance_w(w_object, space.w_buffer): dtype = descriptor.get_dtype_cache(space).w_uint8dtype if dtype is None or (dtype.is_str_or_unicode() and dtype.elsize < 1): dtype = find_dtype_for_seq(space, elems_w, dtype) if dtype is None: dtype = descriptor.get_dtype_cache(space).w_float64dtype elif dtype.is_str_or_unicode() and dtype.elsize < 1: # promote S0 -> S1, U0 -> U1 dtype = descriptor.variable_dtype(space, dtype.char + '1') w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order) if support.product(shape) == 1: # safe from overflow since from_shape checks w_arr.set_scalar_value(dtype.coerce(space, elems_w[0])) else: loop.assign(space, w_arr, elems_w) return w_arr