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 _assign_values(self, coords, values): """Assign the `values` to the positions stated in `coords`.""" for nrow, value in zip(coords, values): if nrow >= self.nrows: raise IndexError("First index out of range") if nrow < 0: # To support negative values nrow += self.nrows object_ = value # Prepare the object to convert it into a NumPy object atom = self.atom if not hasattr(atom, 'size'): # it is a pseudo-atom object_ = atom.toarray(object_) statom = atom.base else: statom = atom value = convert_to_np_atom(object_, statom) nobjects = self._getnobjects(value) # Get the previous value nrow = idx2long( nrow) # To convert any possible numpy scalar value nparr = self._read_array(nrow, nrow + 1, 1)[0] nobjects = len(nparr) if len(value) > nobjects: raise ValueError("Length of value (%s) is larger than number " "of elements in row (%s)" % (len(value), nobjects)) try: nparr[:] = value except Exception as exc: # XXX raise ValueError("Value parameter:\n'%r'\n" "cannot be converted into an array object " "compliant vlarray[%s] row: \n'%r'\n" "The error was: <%s>" % (value, nrow, nparr[:], exc)) if nparr.size > 0: self._modify(nrow, nparr, nobjects)
def __setitem__(self, keys, value): """ Set a row in the array. It takes different actions depending on the type of the `key` parameter: if it is an integer, the corresponding array row is set to `value`. If `key` is a tuple, the first element refers to the row to be modified, and the second element to the range within the row to be updated with the `value` (so it can be an integer or a slice). The type and shape of the `value` must be compatible with the type and shape determined by the `key`, otherwise, a ``TypeError`` or a ``ValueError`` will be raised. .. Note:: When updating the rows of a `VLArray` object which uses a pseudo-atom, there is a problem: you can only update values with *exactly* the same size in bytes than the original row. This is very difficult to meet with ``object`` pseudo-atoms, because ``cPickle`` applied on a Python object does not guarantee to return the same number of bytes than over another object, even if they are of the same class. This effectively limits the kinds of objects than can be updated in variable-length arrays. Example of use:: vlarray[0] = vlarray[0] * 2 + 3 vlarray[99, 3:] = arange(96) * 2 + 3 # Negative values for start and stop (but not step) are supported. vlarray[99, -99:-89:2] = vlarray[5] * 2 + 3 """ self._v_file._checkWritable() if not isinstance(keys, tuple): keys = (keys, None) if len(keys) > 2: raise IndexError, "You cannot specify more than two dimensions" nrow, rng = keys # Process the first index if not (type(nrow) in (int,long) or isinstance(nrow, numpy.integer)): raise IndexError, "The first dimension only can be an integer" if nrow >= self.nrows: raise IndexError, "First index out of range" if nrow < 0: # To support negative values nrow += self.nrows # Process the second index if type(rng) in (int,long) or isinstance(rng, numpy.integer): start = rng; stop = start+1; step = 1 elif isinstance(rng, slice): start, stop, step = rng.start, rng.stop, rng.step elif rng is None: start, stop, step = None, None, None else: raise IndexError, "Non-valid second index or slice: %s" % rng object = value # Prepare the object to convert it into a NumPy object atom = self.atom if not hasattr(atom, 'size'): # it is a pseudo-atom object = atom.toarray(object) statom = atom.base else: statom = atom value = convertToNPAtom(object, statom) nobjects = self._getnobjects(value) # Get the previous value nrow = idx2long(nrow) # To convert any possible numpy scalar value nparr = self._readArray(nrow, nrow+1, 1)[0] nobjects = len(nparr) if len(value) > nobjects: raise ValueError, \ "Length of value (%s) is larger than number of elements in row (%s)" % \ (len(value), nobjects) # Assign the value to it # The values can be numpy scalars. Convert them before building the slice. if start is not None: start = idx2long(start) if stop is not None: stop = idx2long(stop) if step is not None: step = idx2long(step) try: nparr[slice(start, stop, step)] = value except Exception, exc: #XXX raise ValueError, \ "Value parameter:\n'%r'\ncannot be converted into an array object compliant vlarray[%s] row: \n'%r'\nThe error was: <%s>" % \ (value, keys, nparr[slice(start, stop, step)], exc)