def test_binops(self, space): bool_dtype = get_dtype_cache(space).w_booldtype int8_dtype = get_dtype_cache(space).w_int8dtype int32_dtype = get_dtype_cache(space).w_int32dtype float64_dtype = get_dtype_cache(space).w_float64dtype # Basic pairing assert find_binop_result_dtype(space, bool_dtype, bool_dtype) is bool_dtype assert find_binop_result_dtype(space, bool_dtype, float64_dtype) is float64_dtype assert find_binop_result_dtype(space, float64_dtype, bool_dtype) is float64_dtype assert find_binop_result_dtype(space, int32_dtype, int8_dtype) is int32_dtype assert find_binop_result_dtype(space, int32_dtype, bool_dtype) is int32_dtype # With promote bool (happens on div), the result is that the op should # promote bools to int8 assert find_binop_result_dtype( space, bool_dtype, bool_dtype, promote_bools=True) is int8_dtype assert find_binop_result_dtype( space, bool_dtype, float64_dtype, promote_bools=True) is float64_dtype # Coerce to floats assert find_binop_result_dtype( space, bool_dtype, float64_dtype, promote_to_float=True) is float64_dtype
def concatenate(space, w_args, axis=0): args_w = space.listview(w_args) if len(args_w) == 0: raise OperationError( space.w_ValueError, space.wrap("need at least one array to concatenate")) args_w = [convert_to_array(space, w_arg) for w_arg in args_w] dtype = args_w[0].get_dtype() shape = args_w[0].get_shape()[:] _axis = axis if axis < 0: _axis = len(shape) + axis for arr in args_w[1:]: for i, axis_size in enumerate(arr.get_shape()): if len(arr.get_shape()) != len(shape) or (i != _axis and axis_size != shape[i]): raise OperationError( space.w_ValueError, space.wrap( "all the input arrays must have same number of dimensions" )) elif i == _axis: shape[i] += axis_size a_dt = arr.get_dtype() if dtype.is_record_type() and a_dt.is_record_type(): # 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(): raise OperationError(space.w_TypeError, space.wrap("invalid type promotion")) dtype = interp_ufuncs.find_binop_result_dtype(space, dtype, arr.get_dtype()) if _axis < 0 or len(arr.get_shape()) <= _axis: raise operationerrfmt(space.w_IndexError, "axis %d out of bounds [0, %d)", axis, len(shape)) # concatenate does not handle ndarray subtypes, it always returns a ndarray res = W_NDimArray.from_shape(space, shape, dtype, 'C') chunks = [Chunk(0, i, 1, i) for i in shape] axis_start = 0 for arr in args_w: if arr.get_shape()[_axis] == 0: continue chunks[_axis] = Chunk(axis_start, axis_start + arr.get_shape()[_axis], 1, arr.get_shape()[_axis]) Chunks(chunks).apply(space, res).implementation.setslice(space, arr) axis_start += arr.get_shape()[_axis] return res
def dtype_agreement(space, w_arr_list, shape, out=None): """ agree on dtype from a list of arrays. if out is allocated, use it's dtype, otherwise allocate a new one with agreed dtype """ from pypy.module.micronumpy.interp_ufuncs import find_binop_result_dtype if not space.is_none(out): return out dtype = w_arr_list[0].get_dtype() for w_arr in w_arr_list[1:]: dtype = find_binop_result_dtype(space, dtype, w_arr.get_dtype()) out = base.W_NDimArray.from_shape(space, shape, dtype) return out
def concatenate(space, w_args, axis=0): args_w = space.listview(w_args) if len(args_w) == 0: raise OperationError(space.w_ValueError, space.wrap("need at least one array to concatenate")) args_w = [convert_to_array(space, w_arg) for w_arg in args_w] dtype = args_w[0].get_dtype() shape = args_w[0].get_shape()[:] _axis = axis if axis < 0: _axis = len(shape) + axis for arr in args_w[1:]: for i, axis_size in enumerate(arr.get_shape()): if len(arr.get_shape()) != len(shape) or (i != _axis and axis_size != shape[i]): raise OperationError(space.w_ValueError, space.wrap( "all the input arrays must have same number of dimensions")) elif i == _axis: shape[i] += axis_size a_dt = arr.get_dtype() if dtype.is_record_type() and a_dt.is_record_type(): #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("record type mismatch")) elif dtype.is_record_type() or a_dt.is_record_type(): raise OperationError(space.w_TypeError, space.wrap("invalid type promotion")) dtype = interp_ufuncs.find_binop_result_dtype(space, dtype, arr.get_dtype()) if _axis < 0 or len(arr.get_shape()) <= _axis: raise operationerrfmt(space.w_IndexError, "axis %d out of bounds [0, %d)", axis, len(shape)) # concatenate does not handle ndarray subtypes, it always returns a ndarray res = W_NDimArray.from_shape(space, shape, dtype, 'C') chunks = [Chunk(0, i, 1, i) for i in shape] axis_start = 0 for arr in args_w: if arr.get_shape()[_axis] == 0: continue chunks[_axis] = Chunk(axis_start, axis_start + arr.get_shape()[_axis], 1, arr.get_shape()[_axis]) Chunks(chunks).apply(space, res).implementation.setslice(space, arr) axis_start += arr.get_shape()[_axis] return res
def test_binops(self, space): bool_dtype = get_dtype_cache(space).w_booldtype int8_dtype = get_dtype_cache(space).w_int8dtype int32_dtype = get_dtype_cache(space).w_int32dtype float64_dtype = get_dtype_cache(space).w_float64dtype # Basic pairing assert find_binop_result_dtype(space, bool_dtype, bool_dtype) is bool_dtype assert find_binop_result_dtype(space, bool_dtype, float64_dtype) is float64_dtype assert find_binop_result_dtype(space, float64_dtype, bool_dtype) is float64_dtype assert find_binop_result_dtype(space, int32_dtype, int8_dtype) is int32_dtype assert find_binop_result_dtype(space, int32_dtype, bool_dtype) is int32_dtype # With promote bool (happens on div), the result is that the op should # promote bools to int8 assert find_binop_result_dtype(space, bool_dtype, bool_dtype, promote_bools=True) is int8_dtype assert find_binop_result_dtype(space, bool_dtype, float64_dtype, promote_bools=True) is float64_dtype # Coerce to floats assert find_binop_result_dtype(space, bool_dtype, float64_dtype, promote_to_float=True) is float64_dtype
def test_binops(self, space): bool_dtype = space.fromcache(interp_dtype.W_BoolDtype) int8_dtype = space.fromcache(interp_dtype.W_Int8Dtype) int32_dtype = space.fromcache(interp_dtype.W_Int32Dtype) float64_dtype = space.fromcache(interp_dtype.W_Float64Dtype) # Basic pairing assert find_binop_result_dtype(space, bool_dtype, bool_dtype) is bool_dtype assert find_binop_result_dtype(space, bool_dtype, float64_dtype) is float64_dtype assert find_binop_result_dtype(space, float64_dtype, bool_dtype) is float64_dtype assert find_binop_result_dtype(space, int32_dtype, int8_dtype) is int32_dtype assert find_binop_result_dtype(space, int32_dtype, bool_dtype) is int32_dtype # With promote bool (happens on div), the result is that the op should # promote bools to int8 assert find_binop_result_dtype(space, bool_dtype, bool_dtype, promote_bools=True) is int8_dtype assert find_binop_result_dtype(space, bool_dtype, float64_dtype, promote_bools=True) is float64_dtype # Coerce to floats assert find_binop_result_dtype(space, bool_dtype, float64_dtype, promote_to_float=True) is float64_dtype
def where(space, w_arr, w_x=None, w_y=None): """where(condition, [x, y]) Return elements, either from `x` or `y`, depending on `condition`. If only `condition` is given, return ``condition.nonzero()``. Parameters ---------- condition : array_like, bool When True, yield `x`, otherwise yield `y`. x, y : array_like, optional Values from which to choose. `x` and `y` need to have the same shape as `condition`. Returns ------- out : ndarray or tuple of ndarrays If both `x` and `y` are specified, the output array contains elements of `x` where `condition` is True, and elements from `y` elsewhere. If only `condition` is given, return the tuple ``condition.nonzero()``, the indices where `condition` is True. See Also -------- nonzero, choose Notes ----- If `x` and `y` are given and input arrays are 1-D, `where` is equivalent to:: [xv if c else yv for (c,xv,yv) in zip(condition,x,y)] Examples -------- >>> np.where([[True, False], [True, True]], ... [[1, 2], [3, 4]], ... [[9, 8], [7, 6]]) array([[1, 8], [3, 4]]) >>> np.where([[0, 1], [1, 0]]) (array([0, 1]), array([1, 0])) >>> x = np.arange(9.).reshape(3, 3) >>> np.where( x > 5 ) (array([2, 2, 2]), array([0, 1, 2])) >>> x[np.where( x > 3.0 )] # Note: result is 1D. array([ 4., 5., 6., 7., 8.]) >>> np.where(x < 5, x, -1) # Note: broadcasting. array([[ 0., 1., 2.], [ 3., 4., -1.], [-1., -1., -1.]]) NOTE: support for not passing x and y is unsupported """ if space.is_none(w_y): if space.is_none(w_x): raise OperationError(space.w_NotImplementedError, space.wrap("1-arg where unsupported right now")) raise OperationError(space.w_ValueError, space.wrap("Where should be called with either 1 or 3 arguments")) if space.is_none(w_x): raise OperationError(space.w_ValueError, space.wrap("Where should be called with either 1 or 3 arguments")) arr = convert_to_array(space, w_arr) x = convert_to_array(space, w_x) y = convert_to_array(space, w_y) if x.is_scalar() and y.is_scalar() and arr.is_scalar(): if arr.get_dtype().itemtype.bool(arr.get_scalar_value()): return x return y dtype = interp_ufuncs.find_binop_result_dtype(space, x.get_dtype(), y.get_dtype()) shape = shape_agreement(space, arr.get_shape(), x) shape = shape_agreement(space, shape, y) out = W_NDimArray.from_shape(space, shape, dtype) return loop.where(out, shape, arr, x, y, dtype)
def where(space, w_arr, w_x=None, w_y=None): """where(condition, [x, y]) Return elements, either from `x` or `y`, depending on `condition`. If only `condition` is given, return ``condition.nonzero()``. Parameters ---------- condition : array_like, bool When True, yield `x`, otherwise yield `y`. x, y : array_like, optional Values from which to choose. `x` and `y` need to have the same shape as `condition`. Returns ------- out : ndarray or tuple of ndarrays If both `x` and `y` are specified, the output array contains elements of `x` where `condition` is True, and elements from `y` elsewhere. If only `condition` is given, return the tuple ``condition.nonzero()``, the indices where `condition` is True. See Also -------- nonzero, choose Notes ----- If `x` and `y` are given and input arrays are 1-D, `where` is equivalent to:: [xv if c else yv for (c,xv,yv) in zip(condition,x,y)] Examples -------- >>> np.where([[True, False], [True, True]], ... [[1, 2], [3, 4]], ... [[9, 8], [7, 6]]) array([[1, 8], [3, 4]]) >>> np.where([[0, 1], [1, 0]]) (array([0, 1]), array([1, 0])) >>> x = np.arange(9.).reshape(3, 3) >>> np.where( x > 5 ) (array([2, 2, 2]), array([0, 1, 2])) >>> x[np.where( x > 3.0 )] # Note: result is 1D. array([ 4., 5., 6., 7., 8.]) >>> np.where(x < 5, x, -1) # Note: broadcasting. array([[ 0., 1., 2.], [ 3., 4., -1.], [-1., -1., -1.]]) NOTE: support for not passing x and y is unsupported """ if space.is_none(w_y): if space.is_none(w_x): raise OperationError( space.w_NotImplementedError, space.wrap("1-arg where unsupported right now")) raise OperationError( space.w_ValueError, space.wrap("Where should be called with either 1 or 3 arguments")) if space.is_none(w_x): raise OperationError( space.w_ValueError, space.wrap("Where should be called with either 1 or 3 arguments")) arr = convert_to_array(space, w_arr) x = convert_to_array(space, w_x) y = convert_to_array(space, w_y) if x.is_scalar() and y.is_scalar() and arr.is_scalar(): if arr.get_dtype().itemtype.bool(arr.get_scalar_value()): return x return y dtype = interp_ufuncs.find_binop_result_dtype(space, x.get_dtype(), y.get_dtype()) shape = shape_agreement(space, arr.get_shape(), x) shape = shape_agreement(space, shape, y) out = W_NDimArray.from_shape(space, shape, dtype) return loop.where(out, shape, arr, x, y, dtype)