def get_iter(self, space, i):
arr = self.seq[i]
imp = arr.implementation
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self)
shape = self.shape
if self.external_loop and len(self.seq) < 2 and self.buffered:
# Special case, always return a memory-ordered iterator
stride = imp.dtype.elsize
backstride = imp.size * stride - stride
return ConcreteIter(
imp, imp.get_size(), [support.product(shape)], [stride], [backstride], self.op_flags[i], self
)
backward = imp.order != self.order
# XXX cleanup needed
strides = imp.strides
backstrides = imp.backstrides
if self.allow_backward:
if (abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or (
abs(imp.strides[0]) > abs(imp.strides[-1]) and backward
):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
r = calculate_broadcast_strides(strides, backstrides, imp.shape, shape, backward)
iter_shape = shape
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
iter_shape = imp.shape
return ConcreteIter(imp, imp.get_size(), iter_shape, r[0], r[1], self.op_flags[i], self)
def get_iter(self, space, i):
arr = self.seq[i]
imp = arr.implementation
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self)
shape = self.shape
if (self.external_loop and len(self.seq) < 2 and self.buffered):
# Special case, always return a memory-ordered iterator
stride = imp.dtype.elsize
backstride = imp.size * stride - stride
return ConcreteIter(imp, imp.get_size(), [support.product(shape)],
[stride], [backstride], self.op_flags[i], self)
backward = imp.order != self.order
# XXX cleanup needed
strides = imp.strides
backstrides = imp.backstrides
if self.allow_backward:
if ((abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or \
(abs(imp.strides[0]) > abs(imp.strides[-1]) and backward)):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
r = calculate_broadcast_strides(strides, backstrides, imp.shape, shape,
backward)
iter_shape = shape
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
iter_shape = imp.shape
return ConcreteIter(imp, imp.get_size(), iter_shape, r[0], r[1],
self.op_flags[i], self)
def get_iter(self, space, i):
arr = self.seq[i]
dtype = self.dtypes[i]
shape = self.shape
imp = arr.implementation
backward = is_backward(imp, self.order)
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self)
if (abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or \
(abs(imp.strides[0]) > abs(imp.strides[-1]) and backward):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
else:
strides = imp.strides
backstrides = imp.backstrides
r = calculate_broadcast_strides(strides, backstrides, imp.shape,
shape, backward)
iter_shape = shape
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
iter_shape = imp.shape
return ConcreteIter(imp, imp.get_size(), iter_shape, r[0], r[1],
self.op_flags[i], self)
def get_iter(self, space, i):
arr = self.seq[i]
dtype = self.dtypes[i]
shape = self.shape
imp = arr.implementation
backward = is_backward(imp, self.order)
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self)
if (abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or \
(abs(imp.strides[0]) > abs(imp.strides[-1]) and backward):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
else:
strides = imp.strides
backstrides = imp.backstrides
r = calculate_broadcast_strides(strides, backstrides, imp.shape, shape,
backward)
iter_shape = shape
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
iter_shape = imp.shape
return ConcreteIter(imp, imp.get_size(), iter_shape, r[0], r[1],
self.op_flags[i], self)
def create_iter(self,
shape=None,
backward_broadcast=False,
require_index=False):
if shape is not None and \
support.product(shape) > support.product(self.get_shape()):
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape,
backward_broadcast)
return iter.MultiDimViewIterator(self, self.dtype, self.start,
r[0], r[1], shape)
if not require_index:
return iter.ConcreteArrayIterator(self)
else:
if len(self.get_shape()) == 1:
return iter.OneDimViewIterator(self, self.dtype, self.start,
self.get_strides(),
self.get_shape())
else:
return iter.MultiDimViewIterator(self, self.dtype, self.start,
self.get_strides(),
self.get_backstrides(),
self.get_shape())
def create_iter(self, shape=None, backward_broadcast=False):
if shape is None or shape == self.get_shape():
return iter.ConcreteArrayIterator(self)
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape, backward_broadcast)
return iter.MultiDimViewIterator(self, self.dtype, 0, r[0], r[1], shape)
def transform(self, arr, t):
if isinstance(t, BroadcastTransform):
r = calculate_broadcast_strides(self.strides, self.backstrides,
self.res_shape, t.res_shape)
return ViewIterator(self.offset, r[0], r[1], t.res_shape)
elif isinstance(t, ViewTransform):
r = calculate_slice_strides(self.res_shape, self.offset,
self.strides,
self.backstrides, t.chunks.l)
return ViewIterator(r[1], r[2], r[3], r[0])
def transform(self, arr, t):
if isinstance(t, BroadcastTransform):
r = calculate_broadcast_strides(self.strides, self.backstrides,
self.res_shape, t.res_shape)
return ViewIterator(self.offset, r[0], r[1], t.res_shape)
elif isinstance(t, ViewTransform):
r = calculate_slice_strides(self.res_shape, self.offset,
self.strides, self.backstrides,
t.chunks.l)
return ViewIterator(r[1], r[2], r[3], r[0])
def create_iter(self, shape=None, backward_broadcast=False):
if shape is not None and \
support.product(shape) > support.product(self.get_shape()):
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape,
backward_broadcast)
i = ArrayIter(self, support.product(shape), shape, r[0], r[1])
else:
i = ArrayIter(self, self.get_size(), self.shape, self.strides,
self.backstrides)
return i, i.reset()
def create_iter(self, shape=None, backward_broadcast=False):
if shape is not None and \
support.product(shape) > support.product(self.get_shape()):
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape,
backward_broadcast)
i = ArrayIter(self, support.product(shape), shape, r[0], r[1])
else:
i = ArrayIter(self, self.get_size(), self.shape,
self.strides, self.backstrides)
return i, i.reset()
def create_iter(self, shape=None, backward_broadcast=False):
if shape is not None and shape != self.get_shape():
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape,
backward_broadcast)
return iter.MultiDimViewIterator(self.parent, self.dtype,
self.start, r[0], r[1], shape)
if len(self.get_shape()) == 1:
return iter.OneDimViewIterator(self.parent, self.dtype, self.start,
self.get_strides(), self.get_shape())
return iter.MultiDimViewIterator(self.parent, self.dtype, self.start,
self.get_strides(),
self.get_backstrides(), self.get_shape())
def create_iter(self, shape=None, backward_broadcast=False, require_index=False):
if shape is not None and \
support.product(shape) > support.product(self.get_shape()):
r = calculate_broadcast_strides(self.get_strides(),
self.get_backstrides(),
self.get_shape(), shape, backward_broadcast)
return iter.MultiDimViewIterator(self, self.dtype, self.start, r[0], r[1], shape)
if not require_index:
return iter.ConcreteArrayIterator(self)
else:
if len(self.get_shape()) == 1:
return iter.OneDimViewIterator(self, self.dtype, self.start,
self.get_strides(), self.get_shape())
else:
return iter.MultiDimViewIterator(self, self.dtype, self.start,
self.get_strides(), self.get_backstrides(), self.get_shape())
def get_iter(space, order, arr, shape, dtype):
imp = arr.implementation
backward = is_backward(imp, order)
if arr.is_scalar():
return ArrayIter(imp, 1, [], [], [])
if (imp.strides[0] < imp.strides[-1] and not backward) or \
(imp.strides[0] > imp.strides[-1] and backward):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
else:
strides = imp.strides
backstrides = imp.backstrides
r = calculate_broadcast_strides(strides, backstrides, imp.shape,
shape, backward)
return ArrayIter(imp, imp.get_size(), shape, r[0], r[1])
def get_iter(space, order, arr, shape, dtype, op_flags, base):
imp = arr.implementation
backward = is_backward(imp, order)
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], op_flags, base)
if (imp.strides[0] < imp.strides[-1] and not backward) or \
(imp.strides[0] > imp.strides[-1] and backward):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
else:
strides = imp.strides
backstrides = imp.backstrides
r = calculate_broadcast_strides(strides, backstrides, imp.shape,
shape, backward)
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
return ConcreteIter(imp, imp.get_size(), imp.shape, r[0], r[1], op_flags, base)
return ConcreteIter(imp, imp.get_size(), shape, r[0], r[1], op_flags, base)
def get_iter(space, order, arr, shape, dtype, op_flags, base):
imp = arr.implementation
backward = is_backward(imp, order)
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], op_flags, base)
if (imp.strides[0] < imp.strides[-1] and not backward) or \
(imp.strides[0] > imp.strides[-1] and backward):
# flip the strides. Is this always true for multidimension?
strides = imp.strides[:]
backstrides = imp.backstrides[:]
shape = imp.shape[:]
strides.reverse()
backstrides.reverse()
shape.reverse()
else:
strides = imp.strides
backstrides = imp.backstrides
r = calculate_broadcast_strides(strides, backstrides, imp.shape, shape,
backward)
if len(shape) != len(r[0]):
# shape can be shorter when using an external loop, just return a view
return ConcreteIter(imp, imp.get_size(), imp.shape, r[0], r[1],
op_flags, base)
return ConcreteIter(imp, imp.get_size(), shape, r[0], r[1], op_flags, base)
