def test_isshape(self):
assert_equal(sputils.isshape( (1,2) ),True)
assert_equal(sputils.isshape( (5,2) ),True)
assert_equal(sputils.isshape( (1.5,2) ),False)
assert_equal(sputils.isshape( (2,2,2) ),False)
assert_equal(sputils.isshape( ([2],2) ),False)
def test_isshape(self):
assert_equal(sputils.isshape((1, 2)), True)
assert_equal(sputils.isshape((5, 2)), True)
assert_equal(sputils.isshape((1.5, 2)), False)
assert_equal(sputils.isshape((2, 2, 2)), False)
assert_equal(sputils.isshape(([2], 2)), False)
assert_equal(sputils.isshape((-1, 2), nonneg=False),True)
assert_equal(sputils.isshape((2, -1), nonneg=False),True)
assert_equal(sputils.isshape((-1, 2), nonneg=True),False)
assert_equal(sputils.isshape((2, -1), nonneg=True),False)
def __init__(self, shape, matvec, rmatvec=None, matmat=None, dtype=None):
shape = tuple(shape)
if not isshape(shape):
raise ValueError("invalid shape")
self.shape = shape
self._matvec = matvec
if rmatvec is None:
def rmatvec(v):
raise NotImplementedError("rmatvec is not defined")
self.rmatvec = rmatvec
else:
self.rmatvec = rmatvec
if matmat is not None:
# matvec each column of V
self._matmat = matmat
if dtype is not None:
self.dtype = np.dtype(dtype)
def __init__(self, dtype, shape):
"""Initialize this LinearOperator.
To be called by subclasses. ``dtype`` may be None; ``shape`` should
be convertible to a length-2 tuple.
"""
if dtype is not None:
dtype = np.dtype(dtype)
shape = tuple(shape)
if not isshape(shape):
raise ValueError("invalid shape %r (must be 2-d)" % shape)
self.dtype = dtype
self.shape = shape
def __init__(self, dtype, shape):
"""Initialize this LinearOperator.
To be called by subclasses. ``dtype`` may be None; ``shape`` should
be convertible to a length-2 tuple.
"""
if dtype is not None:
dtype = np.dtype(dtype)
shape = tuple(shape)
if not isshape(shape):
raise ValueError("invalid shape %r (must be 2-d)" % (shape, ))
self.dtype = dtype
self.shape = shape
def __init__(self, shape, matvec, rmatvec=None, matmat=None, rmatmat=None,
dtypein=None, dtypeout=None, dtype=None):
shape = tuple(shape)
if not isshape(shape):
raise ValueError('invalid shape')
self.shape = shape
self._matvec = matvec
if rmatvec is None:
def rmatvec(v):
raise NotImplementedError('rmatvec is not defined')
self.rmatvec = rmatvec
else:
self.rmatvec = rmatvec
if matmat is not None:
# matvec each column of V
self._matmat = matmat
if rmatmat is not None:
# matvec each column of V
self._rmatmat = rmatmat
else:
self._rmatmat = None
self.dtype = None
self.dtypein = None
self.dtypeout = None
if dtype is not None:
self.dtype = dtype
self.dtypein = np.dtype(dtype)
self.dtypeout = np.dtype(dtype)
if dtypein is not None and dtypeout is not None:
self.dtype = np.dtype(dtypein)
self.dtypein = np.dtype(dtypein)
self.dtypeout = np.dtype(dtypeout)
elif dtypein is not None:
self.dtype = np.dtype(dtypein)
self.dtypein = np.dtype(dtypein)
elif dtypeout is not None:
self.dtype = np.dtype(dtypeout)
self.dtypeout = np.dtype(dtypeout)
def __init__(self, arg1, shape=None, dtype=None, copy=False):
_data_matrix.__init__(self)
if isspmatrix(arg1):
if arg1.format == self.format and copy:
arg1 = arg1.copy()
else:
arg1 = arg1.asformat(self.format)
self._set_self(arg1)
elif isinstance(arg1, tuple):
if isshape(arg1):
# It's a tuple of matrix dimensions (M, N)
# create empty matrix
self._shape = check_shape(arg1)
M, N = self.shape
# Select index dtype large enough to pass array and
# scalar parameters to sparsetools
idx_dtype = get_index_dtype(maxval=max(M, N))
self.data = np.zeros(0, getdtype(dtype, default=float))
self.indices = np.zeros(0, idx_dtype)
self.indptr = np.zeros(self._swap((M, N))[0] + 1,
dtype=idx_dtype)
else:
if len(arg1) == 2:
# (data, ij) format
from scipy.sparse.coo import coo_matrix
other = self.__class__(coo_matrix(arg1, shape=shape))
self._set_self(other)
elif len(arg1) == 3:
# (data, indices, indptr) format
(data, indices, indptr) = arg1
# Select index dtype large enough to pass array and
# scalar parameters to sparsetools
maxval = None
if shape is not None:
maxval = max(shape)
idx_dtype = get_index_dtype((indices, indptr),
maxval=maxval,
check_contents=True)
self.indices = np.array(indices,
copy=copy,
dtype=idx_dtype)
self.indptr = np.array(indptr, copy=copy, dtype=idx_dtype)
self.data = np.array(data, copy=copy, dtype=dtype)
else:
raise ValueError("unrecognized {}_matrix "
"constructor usage".format(self.format))
else:
# must be dense
try:
arg1 = np.asarray(arg1)
except Exception:
raise ValueError("unrecognized {}_matrix constructor usage"
"".format(self.format))
from scipy.sparse.coo import coo_matrix
self._set_self(self.__class__(coo_matrix(arg1, dtype=dtype)))
# Read matrix dimensions given, if any
if shape is not None:
self._shape = check_shape(shape)
else:
if self.shape is None:
# shape not already set, try to infer dimensions
try:
major_dim = len(self.indptr) - 1
minor_dim = self.indices.max() + 1
except Exception:
raise ValueError('unable to infer matrix dimensions')
else:
self._shape = check_shape(
self._swap((major_dim, minor_dim)))
if dtype is not None:
self.data = self.data.astype(dtype, copy=False)
self.check_format(full_check=False)
def __init__(self, arg1, shape=None, dtype=None, copy=False):
_data_matrix.__init__(self)
if isspmatrix(arg1):
if arg1.format == self.format and copy:
arg1 = arg1.copy()
else:
arg1 = arg1.asformat(self.format)
self._set_self(arg1)
elif isinstance(arg1, tuple):
if isshape(arg1):
# It's a tuple of matrix dimensions (M, N)
# create empty matrix
self.shape = arg1 # spmatrix checks for errors here
M, N = self.shape
idx_dtype = get_index_dtype(maxval=self._swap((M,N))[1])
self.data = da.zeros(0, getdtype(dtype, default=float))
self.indices = da.zeros(0, idx_dtype)
self.indptr = da.zeros(self._swap((M,N))[0] + 1, dtype=idx_dtype)
else:
if len(arg1) == 2:
# (data, ij) format
from .coo import coo_matrix
other = self.__class__(coo_matrix(arg1, shape=shape))
self._set_self(other)
elif len(arg1) == 3:
# (data, indices, indptr) format
(data, indices, indptr) = arg1
idx_dtype = get_index_dtype((indices, indptr), check_contents=True)
chunks = (10,)
self.indices = da.from_array(indices, chunks=chunks)
self.indptr = da.from_array(indptr, chunks=chunks)
self.data = da.from_array(data, chunks=chunks)
else:
raise ValueError("unrecognized %s_matrix constructor usage" %
self.format)
else:
# must be dense
try:
arg1 = np.asarray(arg1)
except:
raise ValueError("unrecognized %s_matrix constructor usage" %
self.format)
from scipy.sparse.coo import coo_matrix
self._set_self(self.__class__(coo_matrix(arg1, dtype=dtype)))
# Read matrix dimensions given, if any
if shape is not None:
self.shape = shape # spmatrix will check for errors
else:
if self.shape is None:
# shape not already set, try to infer dimensions
try:
major_dim = len(self.indptr) - 1
minor_dim = self.indices.max() + 1
except:
raise ValueError('unable to infer matrix dimensions')
else:
self.shape = self._swap((major_dim,minor_dim))
if dtype is not None:
self.data = np.asarray(self.data, dtype=dtype)
self.check_format(full_check=False)
def __init__(self, arg1, shape=None, dtype=None, copy=False):
_data_matrix.__init__(self)
self.chunks = (10, 1)
if isinstance(arg1, tuple):
if isshape(arg1):
M, N = arg1
self.shape = (M, N)
idx_dtype = get_index_dtype(maxval=max(M, N))
self.row = np.array([], dtype=idx_dtype)
self.col = np.array([], dtype=idx_dtype)
self.data = np.array([], getdtype(dtype, default=float))
self.has_canonical_format = True
else:
try:
obj, (row, col) = arg1
except (TypeError, ValueError):
raise TypeError('invalid input format')
if shape is None:
if len(row) == 0 or len(col) == 0:
raise ValueError('cannot infer dimensions from zero '
'sized index arrays')
M = np.max(row) + 1
N = np.max(col) + 1
self.shape = (M, N)
else:
# Use 2 steps to ensure shape has length 2.
M, N = shape
self.shape = (M, N)
idx_dtype = get_index_dtype(maxval=max(self.shape))
if isinstance(row, da.core.Array):
self.row = row
else:
self.row = da.from_array(row, chunks=self.chunks)
if isinstance(col, da.core.Array):
self.col = col
else:
self.col = da.from_array(col, chunks=self.chunks)
if isinstance(obj, da.core.Array):
self.data = obj
else:
self.data = da.from_array(obj, chunks=self.chunks)
self.has_canonical_format = False
else:
if isspmatrix(arg1):
if isspmatrix_coo(arg1) and copy:
self.row = arg1.row.copy()
self.col = arg1.col.copy()
self.data = arg1.data.copy()
self.shape = arg1.shape
else:
coo = arg1.tocoo()
self.row = coo.row
self.col = coo.col
self.data = coo.data
self.shape = coo.shape
self.has_canonical_format = False
else:
#dense argument
M = np.atleast_2d(np.asarray(arg1))
if M.ndim != 2:
raise TypeError('expected dimension <= 2 array or matrix')
else:
self.shape = M.shape
self.row, self.col = M.nonzero()
self.data = M[self.row, self.col]
self.has_canonical_format = True
if dtype is not None:
self.data = self.data.astype(dtype)
self._check()
def __init__(self,
arg1,
block_size=None,
n_samples=None,
n_history=None,
shape=None,
dtype=None,
copy=False):
_data_matrix.__init__(self)
# case 1: instantiate from another sparse matrix
if isspmatrix(arg1):
if arg1.format == self.format:
self._set_self(arg1)
elif arg1.format == "csr":
self._csr_to_delta_csr(arg1, block_size, n_samples, n_history)
else:
raise NotImplementedError(
"Instantiation from sparse matrix not yet ready")
# case 2: instantiate from some kind of raw data
elif isinstance(arg1, tuple):
if isshape(arg1):
# input is size specification (M,N) for empty matrix
# code mostly taken from scipy CSR implementation, other than an
# additional line to instantiate deltas array
self.shape = arg1
M, N = self.shape
idx_dtype = get_index_dtype(maxval=max(M, N))
self.data = np.zeros(0, getdtype(dtype, default='float'))
self.indices = np.zeros(0, idx_dtype)
self.indptr = np.zeros(self._swap((M, N))[0] + 1,
dtype=idx_dtype)
self.deltas = np.zeros(0, dtype=idx_dtype)
else:
if len(arg1) == 2:
# COO data format
raise NotImplementedError(
"Instantiation from COO format not yet ready")
elif len(arg1) == 3 or len(arg1) == 4:
# contents of the tuple are the raw data structures
(self.data, self.indices, self.indptr) = arg1[:3]
# use given shape or automatically infer one
if shape is not None:
self.shape = shape
else:
M = indptr.shape[0] - 1
N = np.max(indices)
self.shape = (M, N)
# a fourth array, for the deltas pointer, should always be
# given in general use, but we also allow for the case where
# it is omitted in order to maintain backwards compatibility
# with superclass methods. In this case we just let each
# deltas[i] = i; in other words treating this matrix as a
# standard CSR matrix with no delta encoding
self.deltas = arg1[3] if len(arg1) > 3 else np.arange(
self.shape[0])
# case 3: instantiate from generator object
elif isinstance(arg1, types.GeneratorType):
self._construct_from_iterable(arg1, getdtype(dtype,
default='float'),
np.int32, block_size, n_samples,
shape)
# case 4: instantiate from dense matrix / array
else:
try:
arg1 = np.asarray(arg1)
except:
raise ValueError(
"unrecognized delta_csr_matrix constructor usage")
# create a generator expression for iterating over rows of arg1
row_gen = (arg1[i, :] for i in range(arg1.shape[0]))
self._construct_from_iterable(
row_gen,
arg1.dtype,
get_index_dtype(maxval=max(*arg1.shape)),
block_size,
n_samples,
shape=arg1.shape)
self.check_format(full_check=False)