def _processRange(self, start, stop, step, dim=None, warn_negstep=True):
if dim is None:
nrows = self.nrows # self.shape[self.maindim]
else:
nrows = self.shape[dim]
if warn_negstep and step and step < 0 :
raise ValueError("slice step cannot be negative")
# (start, stop, step) = slice(start, stop, step).indices(nrows)
# The next function is a substitute for slice().indices in order to
# support full 64-bit integer for slices even in 32-bit machines.
# F. Alted 2005-05-08
(start, stop, step) = utilsExtension.getIndices(
start, stop, step, long(nrows) )
return (start, stop, step)
def _processRange(self, start, stop, step, dim=None, warn_negstep=True):
if dim is None:
nrows = self.nrows # self.shape[self.maindim]
else:
nrows = self.shape[dim]
if warn_negstep and step and step < 0:
raise ValueError("slice step cannot be negative")
# (start, stop, step) = slice(start, stop, step).indices(nrows)
# The next function is a substitute for slice().indices in order to
# support full 64-bit integer for slices even in 32-bit machines.
# F. Alted 2005-05-08
(start, stop,
step) = utilsExtension.getIndices(start, stop, step, long(nrows))
return (start, stop, step)
def _processRange(self, start, stop, step, dim=None, warn_negstep=True):
if dim is None:
nrows = len(self) # self.shape[self.maindim]
else:
nrows = self.shape[dim]
if warn_negstep and step and step < 0 :
raise ValueError("slice step cannot be negative")
# In order to convert possible numpy.integer values to long ones
# F. Alted 2006-05-02
if start is not None: start = idx2long(start)
if stop is not None: stop = idx2long(stop)
if step is not None: step = idx2long(step)
# (start, stop, step) = slice(start, stop, step).indices(nrows)
# The next function is a substitute for slice().indices in order to
# support full 64-bit integer for slices even in 32-bit machines.
# F. Alted 2005-05-08
(start, stop, step) = utilsExtension.getIndices(
slice(start, stop, step), long(nrows) )
return (start, stop, step)
def _processRange(self, start, stop, step, dim=None, warn_negstep=True):
if dim is None:
nrows = len(self) # self.shape[self.maindim]
else:
nrows = self.shape[dim]
if warn_negstep and step and step < 0:
raise ValueError("slice step cannot be negative")
# In order to convert possible numpy.integer values to long ones
# F. Alted 2006-05-02
if start is not None: start = idx2long(start)
if stop is not None: stop = idx2long(stop)
if step is not None: step = idx2long(step)
# (start, stop, step) = slice(start, stop, step).indices(nrows)
# The next function is a substitute for slice().indices in order to
# support full 64-bit integer for slices even in 32-bit machines.
# F. Alted 2005-05-08
(start,
stop, step) = utilsExtension.getIndices(slice(start, stop, step),
long(nrows))
return (start, stop, step)
def _get_info(self, shape, maindim, itermode=False):
"""Return various info needed for evaluating the computation loop."""
# Compute the shape of the resulting container having
# in account new possible values of start, stop and step in
# the inputs range
if maindim is not None:
(start, stop, step) = getIndices(self.start, self.stop, self.step,
shape[maindim])
shape[maindim] = min(shape[maindim],
lrange(start, stop, step).length)
i_nrows = shape[maindim]
else:
start, stop, step = 0, 0, None
i_nrows = 0
if not itermode:
# Create a container for output if not defined yet
o_maindim = 0 # Default maindim
if self.out is None:
out = np.empty(shape, dtype=self._single_row_out.dtype)
# Get the trivial values for start, stop and step
if maindim is not None:
(o_start, o_stop, o_step) = (0, shape[maindim], 1)
else:
(o_start, o_stop, o_step) = (0, 0, 1)
else:
out = self.out
# Out container already provided. Do some sanity checks.
if hasattr(out, "maindim"):
o_maindim = out.maindim
# Refine the shape of the resulting container having in
# account new possible values of start, stop and step in
# the output range
o_shape = list(out.shape)
(o_start, o_stop,
o_step) = getIndices(self.o_start, self.o_stop, self.o_step,
o_shape[o_maindim])
o_shape[o_maindim] = min(
o_shape[o_maindim],
lrange(o_start, o_stop, o_step).length)
# Check that the shape of output is consistent with inputs
tr_oshape = list(o_shape) # this implies a copy
olen_ = tr_oshape.pop(o_maindim)
tr_shape = list(shape) # do a copy
if maindim is not None:
len_ = tr_shape.pop(o_maindim)
else:
len_ = 1
if tr_oshape != tr_shape:
raise ValueError(
"Shape for out container does not match expression")
# Force the input length to fit in `out`
if not self.append_mode and olen_ < len_:
shape[o_maindim] = olen_
stop = start + olen_
# Get the positions of inputs that should be sliced (the others
# will be broadcasted)
ndim = len(shape)
slice_pos = [
i for i, val in enumerate(self.values) if len(val.shape) == ndim
]
# The size of the I/O buffer
nrowsinbuf = 1
for i, val in enumerate(self.values):
# Skip scalar values in variables
if i in slice_pos:
nrows = self._calc_nrowsinbuf(val)
if nrows > nrowsinbuf:
nrowsinbuf = nrows
if not itermode:
return (i_nrows, slice_pos, start, stop, step, nrowsinbuf, out,
o_maindim, o_start, o_stop, o_step)
else:
# For itermode, we don't need the out info
return (i_nrows, slice_pos, start, stop, step, nrowsinbuf)
def _get_info(self, shape, maindim, itermode=False):
"""Return various info needed for evaluating the computation loop."""
# Compute the shape of the resulting container having
# in account new possible values of start, stop and step in
# the inputs range
if maindim is not None:
(start, stop, step) = getIndices(
self.start, self.stop, self.step, shape[maindim])
shape[maindim] = min(
shape[maindim], lrange(start, stop, step).length)
i_nrows = shape[maindim]
else:
start, stop, step = 0, 0, None
i_nrows = 0
if not itermode:
# Create a container for output if not defined yet
o_maindim = 0 # Default maindim
if self.out is None:
out = np.empty(shape, dtype=self._single_row_out.dtype)
# Get the trivial values for start, stop and step
if maindim is not None:
(o_start, o_stop, o_step) = (0, shape[maindim], 1)
else:
(o_start, o_stop, o_step) = (0, 0, 1)
else:
out = self.out
# Out container already provided. Do some sanity checks.
if hasattr(out, "maindim"):
o_maindim = out.maindim
# Refine the shape of the resulting container having in
# account new possible values of start, stop and step in
# the output range
o_shape = list(out.shape)
(o_start, o_stop, o_step) = getIndices(
self.o_start, self.o_stop, self.o_step, o_shape[o_maindim])
o_shape[o_maindim] = min(o_shape[o_maindim],
lrange(o_start, o_stop, o_step).length)
# Check that the shape of output is consistent with inputs
tr_oshape = list(o_shape) # this implies a copy
olen_ = tr_oshape.pop(o_maindim)
tr_shape = list(shape) # do a copy
if maindim is not None:
len_ = tr_shape.pop(o_maindim)
else:
len_ = 1
if tr_oshape != tr_shape:
raise ValueError(
"Shape for out container does not match expression")
# Force the input length to fit in `out`
if not self.append_mode and olen_ < len_:
shape[o_maindim] = olen_
stop = start + olen_
# Get the positions of inputs that should be sliced (the others
# will be broadcasted)
ndim = len(shape)
slice_pos = [i for i, val in enumerate(self.values)
if len(val.shape) == ndim]
# The size of the I/O buffer
nrowsinbuf = 1
for i, val in enumerate(self.values):
# Skip scalar values in variables
if i in slice_pos:
nrows = self._calc_nrowsinbuf(val)
if nrows > nrowsinbuf:
nrowsinbuf = nrows
if not itermode:
return (i_nrows, slice_pos, start, stop, step, nrowsinbuf,
out, o_maindim, o_start, o_stop, o_step)
else:
# For itermode, we don't need the out info
return (i_nrows, slice_pos, start, stop, step, nrowsinbuf)