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)