Example #1
0
    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
Example #2
0
    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
Example #3
0
    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
Example #4
0
 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))
Example #5
0
 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))
Example #6
0
    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)))
Example #7
0
    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)))
Example #8
0
    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
Example #9
0
 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))
Example #10
0
 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))