def __getitem__(self, index): """Return the element(s) index=(i, j), where j may be a slice. This always returns a copy for consistency, since slices into Python lists return copies. """ try: i, j = index except (AssertionError, TypeError): raise IndexError('invalid index') if np.isscalar(i): if np.isscalar(j): return self._get1(i, j) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(i, jj) for jj in j]]) elif issequence(i) and issequence(j): return self.__class__( [[self._get1(ii, jj) for (ii, jj) in zip(i, j)]]) elif issequence(i) or isinstance(i, slice): if isinstance(i, slice): i = self._slicetoseq(i, self.shape[0]) if np.isscalar(j): return self.__class__([[self._get1(ii, j)] for ii in i]) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(ii, jj) for jj in j] for ii in i]) else: raise IndexError
def __getitem__(self, index): """Return the element(s) index=(i, j), where j may be a slice. This always returns a copy for consistency, since slices into Python lists return copies. """ try: i, j = index except (AssertionError, TypeError): raise IndexError('invalid index') if not np.isscalar(i) and np.isscalar(j): warn('Indexing into a lil_matrix with multiple indices is slow. ' 'Pre-converting to CSC or CSR beforehand is more efficient.', SparseEfficiencyWarning) if np.isscalar(i): if np.isscalar(j): return self._get1(i, j) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(i, jj) for jj in j]]) elif issequence(i) and issequence(j): return self.__class__([[self._get1(ii, jj) for (ii, jj) in zip(i, j)]]) elif issequence(i) or isinstance(i, slice): if isinstance(i, slice): i = self._slicetoseq(i, self.shape[0]) if np.isscalar(j): return self.__class__([[self._get1(ii, j)] for ii in i]) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(ii, jj) for jj in j] for ii in i]) else: raise IndexError
def __getitem__(self, index): """Return the element(s) index=(i, j), where j may be a slice. This always returns a copy for consistency, since slices into Python lists return copies. """ try: i, j = index except (AssertionError, TypeError): raise IndexError('invalid index') if np.isscalar(i): if np.isscalar(j): return self._get1(i, j) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(i, jj) for jj in j]]) elif issequence(i) and issequence(j): return self.__class__([[self._get1(ii, jj) for (ii, jj) in zip(i, j)]]) elif issequence(i) or isinstance(i, slice): if isinstance(i, slice): i = self._slicetoseq(i, self.shape[0]) if np.isscalar(j): return self.__class__([[self._get1(ii, j)] for ii in i]) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(ii, jj) for jj in j] for ii in i]) else: raise IndexError
def _setitem_setrow(self, row, data, j, xrow, xdata, xcols): if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): if xcols == len(j): for jj, xi in zip(j, xrange(xcols)): pos = bisect_left(xrow, xi) if pos != len(xdata) and xrow[pos] == xi: self._insertat2(row, data, jj, xdata[pos]) else: self._insertat2(row, data, jj, 0) elif xcols == 1: # OK, broadcast across row if len(xdata) > 0 and xrow[0] == 0: val = xdata[0] else: val = 0 for jj in j: self._insertat2(row, data, jj, val) else: raise IndexError('invalid index') elif np.isscalar(j): if not xcols == 1: raise ValueError( 'array dimensions are not compatible for copy') if len(xdata) > 0 and xrow[0] == 0: self._insertat2(row, data, j, xdata[0]) else: self._insertat2(row, data, j, 0) else: raise ValueError('invalid column value: %s' % str(j))
def _setitem_setrow(self, row, data, j, xrow, xdata, xcols): if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): if xcols == len(j): for jj, xi in zip(j, xrange(xcols)): pos = bisect_left(xrow, xi) if pos != len(xdata) and xrow[pos] == xi: self._insertat2(row, data, jj, xdata[pos]) else: self._insertat2(row, data, jj, 0) elif xcols == 1: # OK, broadcast across row if len(xdata) > 0 and xrow[0] == 0: val = xdata[0] else: val = 0 for jj in j: self._insertat2(row, data, jj,val) else: raise IndexError('invalid index') elif np.isscalar(j): if not xcols == 1: raise ValueError('array dimensions are not compatible for copy') if len(xdata) > 0 and xrow[0] == 0: self._insertat2(row, data, j, xdata[0]) else: self._insertat2(row, data, j, 0) else: raise ValueError('invalid column value: %s' % str(j))
def __setitem__(self, index, x): if np.isscalar(x): x = self.dtype.type(x) elif not isinstance(x, spmatrix): x = lil_matrix(x) try: i, j = index except (ValueError, TypeError): raise IndexError('invalid index') if isspmatrix(x): if (isinstance(i, slice) and (i == slice(None))) and \ (isinstance(j, slice) and (j == slice(None))): # self[:,:] = other_sparse x = lil_matrix(x) self.rows = x.rows self.data = x.data return if np.isscalar(i): row = self.rows[i] data = self.data[i] self._insertat3(row, data, j, x) elif issequence(i) and issequence(j): if np.isscalar(x): for ii, jj in zip(i, j): self._insertat(ii, jj, x) else: for ii, jj, xx in zip(i, j, x): self._insertat(ii, jj, xx) elif isinstance(i, slice) or issequence(i): rows = self.rows[i] datas = self.data[i] if np.isscalar(x): for row, data in zip(rows, datas): self._insertat3(row, data, j, x) else: for row, data, xx in zip(rows, datas, x): self._insertat3(row, data, j, xx) else: raise ValueError('invalid index value: %s' % str((i, j)))
def __getitem__(self, index): """Return the element(s) index=(i, j), where j may be a slice. This always returns a copy for consistency, since slices into Python lists return copies. """ try: i, j = index except (AssertionError, TypeError): raise IndexError('invalid index') if not np.isscalar(i) and np.isscalar(j): warn( 'Indexing into a lil_matrix with multiple indices is slow. ' 'Pre-converting to CSC or CSR beforehand is more efficient.', SparseEfficiencyWarning) if np.isscalar(i): if np.isscalar(j): return self._get1(i, j) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(i, jj) for jj in j]]) elif issequence(i) and issequence(j): return self.__class__( [[self._get1(ii, jj) for (ii, jj) in zip(i, j)]]) elif issequence(i) or isinstance(i, slice): if isinstance(i, slice): i = self._slicetoseq(i, self.shape[0]) if np.isscalar(j): return self.__class__([[self._get1(ii, j)] for ii in i]) if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): return self.__class__([[self._get1(ii, jj) for jj in j] for ii in i]) else: raise IndexError
def _insertat3(self, row, data, j, x): """ helper for __setitem__ """ if isinstance(j, slice): j = self._slicetoseq(j, self.shape[1]) if issequence(j): if isinstance(x, spmatrix): x = x.todense() x = np.asarray(x).squeeze() if np.isscalar(x) or x.size == 1: for jj in j: self._insertat2(row, data, jj, x) else: # x must be one D. maybe check these things out for jj, xx in zip(j, x): self._insertat2(row, data, jj, xx) elif np.isscalar(j): self._insertat2(row, data, j, x) else: raise ValueError('invalid column value: %s' % str(j))