def __init__(self, dtype, shape=None, strides=None, offset=0, nbytes=None):
self.shape = tuple() if shape is None else wrap_in_tuple(shape)
self.size = product(self.shape)
self.dtype = dtypes.normalize_type(dtype)
self.ctype = dtypes.ctype_module(self.dtype)
default_strides = helpers.default_strides(self.shape,
self.dtype.itemsize)
if strides is None:
strides = default_strides
else:
strides = tuple(strides)
self._default_strides = strides == default_strides
self.strides = strides
default_nbytes = helpers.min_buffer_size(self.shape,
self.dtype.itemsize,
self.strides)
if nbytes is None:
nbytes = default_nbytes
self._default_nbytes = nbytes == default_nbytes
self.nbytes = nbytes
self.offset = offset
self._cast = dtypes.cast(self.dtype)
def __init__(
self, arr_t, predicate, axes=None, exclusive=False, max_work_group_size=None,
seq_size=None):
self._max_work_group_size = max_work_group_size
self._seq_size = seq_size
self._exclusive = exclusive
ndim = len(arr_t.shape)
self._axes = helpers.normalize_axes(ndim, axes)
if not helpers.are_axes_innermost(ndim, self._axes):
self._transpose_to, self._transpose_from = (
helpers.make_axes_innermost(ndim, self._axes))
self._axes = tuple(range(ndim - len(self._axes), ndim))
else:
self._transpose_to = None
self._transpose_from = None
if len(set(self._axes)) != len(self._axes):
raise ValueError("Cannot scan twice over the same axis")
if hasattr(predicate.empty, 'dtype'):
if arr_t.dtype != predicate.empty.dtype:
raise ValueError("The predicate and the array must use the same data type")
empty = predicate.empty
else:
empty = dtypes.cast(arr_t.dtype)(predicate.empty)
self._predicate = predicate
Computation.__init__(self, [
Parameter('output', Annotation(arr_t, 'o')),
Parameter('input', Annotation(arr_t, 'i'))])
def reference(self, idx):
"""
Reference function that returns the key given the thread identifier.
Uses the same algorithm as the module.
"""
key = self._base_key.copy()
key['v'][-1] += dtypes.cast(key.dtype.fields['v'][0].base)(idx)
return key
def reference(self, idx):
"""
Reference function that returns the key given the thread identifier.
Uses the same algorithm as the module.
"""
key = self._base_key.copy()
key['v'][-1] += dtypes.cast(key.dtype.fields['v'][0].base)(idx)
return key
def __init__(self, dtype, shape=None, strides=None):
self.shape = tuple() if shape is None else wrap_in_tuple(shape)
self.size = product(self.shape)
self.dtype = dtypes.normalize_type(dtype)
self.ctype = dtypes.ctype_module(self.dtype)
if strides is None:
self.strides = tuple([
self.dtype.itemsize * product(self.shape[i+1:]) for i in range(len(self.shape))])
else:
self.strides = strides
self._cast = dtypes.cast(self.dtype)
def __init__(self, dtype, shape=None, strides=None):
self.shape = tuple() if shape is None else wrap_in_tuple(shape)
self.size = product(self.shape)
self.dtype = dtypes.normalize_type(dtype)
self.ctype = dtypes.ctype_module(self.dtype)
if strides is None:
self.strides = tuple([
self.dtype.itemsize * product(self.shape[i + 1:])
for i in range(len(self.shape))
])
else:
self.strides = strides
self._cast = dtypes.cast(self.dtype)
def __init__(self, arr_t, predicate, axes=None, output_arr_t=None):
dims = len(arr_t.shape)
if axes is None:
axes = tuple(range(dims))
else:
axes = tuple(sorted(helpers.wrap_in_tuple(axes)))
if len(set(axes)) != len(axes):
raise ValueError("Cannot reduce twice over the same axis")
if min(axes) < 0 or max(axes) >= dims:
raise ValueError("Axes numbers are out of bounds")
if hasattr(predicate.empty, 'dtype'):
if arr_t.dtype != predicate.empty.dtype:
raise ValueError(
"The predicate and the array must use the same data type")
empty = predicate.empty
else:
empty = dtypes.cast(arr_t.dtype)(predicate.empty)
remaining_axes = tuple(a for a in range(dims) if a not in axes)
output_shape = tuple(arr_t.shape[a] for a in remaining_axes)
if axes == tuple(range(dims - len(axes), dims)):
self._transpose_axes = None
else:
self._transpose_axes = remaining_axes + axes
self._operation = predicate.operation
self._empty = empty
if output_arr_t is None:
output_arr_t = Type(arr_t.dtype, shape=output_shape)
else:
if output_arr_t.dtype != arr_t.dtype:
raise ValueError(
"The dtype of the output array must be the same as that of the input array"
)
if output_arr_t.shape != output_shape:
raise ValueError("Expected the output array shape " +
str(output_shape) + ", got " +
str(output_arr_t.shape))
Computation.__init__(self, [
Parameter('output', Annotation(output_arr_t, 'o')),
Parameter('input', Annotation(arr_t, 'i'))
])
def broadcast_const(arr_t, val):
"""
Returns a transformation that broadcasts the given constant to the array output
(1 output): ``output = val``.
"""
val = dtypes.cast(arr_t.dtype)(val)
if len(val.shape) != 0:
raise ValueError("The constant must be a scalar")
return Transformation([Parameter('output', Annotation(arr_t, 'o'))],
"""
const ${output.ctype} val = ${dtypes.c_constant(val)};
${output.store_same}(val);
""",
render_kwds=dict(val=val))
def broadcast_const(arr_t, val):
"""
Returns a transformation that broadcasts the given constant to the array output
(1 output): ``output = val``.
"""
val = dtypes.cast(arr_t.dtype)(val)
if len(val.shape) != 0:
raise ValueError("The constant must be a scalar")
return Transformation(
[
Parameter('output', Annotation(arr_t, 'o'))],
"""
const ${output.ctype} val = ${dtypes.c_constant(val)};
${output.store_same}(val);
""",
render_kwds=dict(val=val))
def __init__(self, arr_t, predicate, axes=None, output_arr_t=None):
dims = len(arr_t.shape)
if axes is None:
axes = tuple(range(dims))
else:
axes = tuple(sorted(helpers.wrap_in_tuple(axes)))
if len(set(axes)) != len(axes):
raise ValueError("Cannot reduce twice over the same axis")
if min(axes) < 0 or max(axes) >= dims:
raise ValueError("Axes numbers are out of bounds")
if hasattr(predicate.empty, 'dtype'):
if arr_t.dtype != predicate.empty.dtype:
raise ValueError("The predicate and the array must use the same data type")
empty = predicate.empty
else:
empty = dtypes.cast(arr_t.dtype)(predicate.empty)
remaining_axes = tuple(a for a in range(dims) if a not in axes)
output_shape = tuple(arr_t.shape[a] for a in remaining_axes)
if axes == tuple(range(dims - len(axes), dims)):
self._transpose_axes = None
else:
self._transpose_axes = remaining_axes + axes
self._operation = predicate.operation
self._empty = empty
if output_arr_t is None:
output_arr_t = Type(arr_t.dtype, shape=output_shape)
else:
if output_arr_t.dtype != arr_t.dtype:
raise ValueError(
"The dtype of the output array must be the same as that of the input array")
if output_arr_t.shape != output_shape:
raise ValueError(
"Expected the output array shape " + str(output_shape) +
", got " + str(output_arr_t.shape))
Computation.__init__(self, [
Parameter('output', Annotation(output_arr_t, 'o')),
Parameter('input', Annotation(arr_t, 'i'))])
def __init__(self, dtype, shape=None, strides=None, offset=0, nbytes=None):
self.shape = tuple() if shape is None else wrap_in_tuple(shape)
self.size = product(self.shape)
self.dtype = dtypes.normalize_type(dtype)
self.ctype = dtypes.ctype_module(self.dtype)
default_strides = helpers.default_strides(self.shape, self.dtype.itemsize)
if strides is None:
strides = default_strides
else:
strides = tuple(strides)
self._default_strides = strides == default_strides
self.strides = strides
default_nbytes = helpers.min_buffer_size(self.shape, self.dtype.itemsize, self.strides)
if nbytes is None:
nbytes = default_nbytes
self._default_nbytes = nbytes == default_nbytes
self.nbytes = nbytes
self.offset = offset
self._cast = dtypes.cast(self.dtype)
def __init__(self,
arr_t,
predicate,
axes=None,
exclusive=False,
max_work_group_size=None,
seq_size=None):
self._max_work_group_size = max_work_group_size
self._seq_size = seq_size
self._exclusive = exclusive
ndim = len(arr_t.shape)
self._axes = helpers.normalize_axes(ndim, axes)
if not helpers.are_axes_innermost(ndim, self._axes):
self._transpose_to, self._transpose_from = (
helpers.make_axes_innermost(ndim, self._axes))
self._axes = tuple(range(ndim - len(self._axes), ndim))
else:
self._transpose_to = None
self._transpose_from = None
if len(set(self._axes)) != len(self._axes):
raise ValueError("Cannot scan twice over the same axis")
if hasattr(predicate.empty, 'dtype'):
if arr_t.dtype != predicate.empty.dtype:
raise ValueError(
"The predicate and the array must use the same data type")
empty = predicate.empty
else:
empty = dtypes.cast(arr_t.dtype)(predicate.empty)
self._predicate = predicate
Computation.__init__(self, [
Parameter('output', Annotation(arr_t, 'o')),
Parameter('input', Annotation(arr_t, 'i'))
])
def test_div(thr, out_code, in_codes):
out_dtype, in_dtypes = generate_dtypes(out_code, in_codes)
check_func(thr, functions.div(*in_dtypes, out_dtype=out_dtype),
lambda x, y: dtypes.cast(out_dtype)(x / y), out_dtype,
in_dtypes)
def test_cast(thr, out_code, in_codes):
out_dtype, in_dtypes = generate_dtypes(out_code, in_codes)
check_func(thr, functions.cast(out_dtype, in_dtypes[0]),
dtypes.cast(out_dtype), out_dtype, in_dtypes)
def test_div(thr, out_code, in_codes):
out_dtype, in_dtypes = generate_dtypes(out_code, in_codes)
check_func(
thr, functions.div(*in_dtypes, out_dtype=out_dtype),
lambda x, y: dtypes.cast(out_dtype)(x / y), out_dtype, in_dtypes)
def test_cast(thr, out_code, in_codes):
out_dtype, in_dtypes = generate_dtypes(out_code, in_codes)
check_func(
thr, functions.cast(out_dtype, in_dtypes[0]),
dtypes.cast(out_dtype), out_dtype, in_dtypes)
