def __init__(self, perm, **kwargs): """ Parameters ---------- perm : list or tuple The permutation of coefficients. Returns ------- A PermutationOperator instance. Exemple ------- >>> import numpy as np >>> import linear_operators as lo >>> P = lo.PermutationOperator([3, 1, 0, 2]) >>> P.todense() array([[ 0., 0., 0., 1.], [ 0., 1., 0., 0.], [ 1., 0., 0., 0.], [ 0., 0., 1., 0.]]) """ shape = 2 * (len(perm),) self.perm = perm # reverse permutation self.perm_inv = np.argsort(perm) def matvec(x): return np.asarray([x[pi] for pi in self.perm]) def rmatvec(x): return np.asarray([x[pi] for pi in self.perm_inv]) LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __init__(self, shapein, shapeout, matvec, rmatvec=None, matmat=None, rmatmat=None, dtypein=None, dtypeout=None, dtype=None): sizein = np.prod(shapein) sizeout = np.prod(shapeout) shape = (sizeout, sizein) ndmatvec = lambda x: matvec(x.reshape(shapein)).ravel() if rmatvec is not None: ndrmatvec = lambda x: rmatvec(x.reshape(shapeout)).ravel() else: ndrmatvec = None LinearOperator.__init__(self, shape, ndmatvec, ndrmatvec, dtype=dtype, dtypein=dtypein, dtypeout=dtypeout) self.ndmatvec = matvec self.ndrmatvec = rmatvec self.shapein = shapein self.shapeout = shapeout
def __init__(self, shape, rep_num, **kwargs): """ Parameters ---------- shape : length 2 tuple. The shape of the operator. rep_num : int The number of replications. Returns ------- A ReplicationOperator instance. Exemple ------- >>> import numpy as np >>> import linear_operators as lo >>> R = lo.ReplicationOperator((4, 2), 2) >>> R.todense() array([[ 1., 0.], [ 0., 1.], [ 1., 0.], [ 0., 1.]]) """ self.rep_num = rep_num # ensure coherent input if not shape[0] == shape[1] * rep_num: raise ValueError("Output vector should be n times the size of input vector.") def matvec(x): return np.tile(x, self.rep_num) def rmatvec(x): N = shape[1] return sum([x[i * N:(i + 1) * N] for i in xrange(self.rep_num)]) LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __init__(self, shape, slice, **kwargs): """ Exemple ------- >>> S = lo.SliceOperator((2, 4), slice(None, None, 2)) >>> S.todense() array([[ 1., 0., 0., 0.], [ 0., 0., 1., 0.]]) >>> S.T.todense() array([[ 1., 0.], [ 0., 0.], [ 0., 1.], [ 0., 0.]]) """ def matvec(x): return x[slice] def rmatvec(x): out = np.zeros(shape[1]) out[slice] = x return out LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __init__(self, shape, shift, **kwargs): if shape[0] != shape[1]: raise ValueError("Only square operator is implemented.") if np.round(shift) != shift: raise ValueError("The shift argument should be an integer value.") self.shift = shift ashift = np.abs(shift) # square case matvec = lambda x: np.concatenate((x[ashift:], np.zeros(ashift))) rmatvec = lambda x: np.concatenate((np.zeros(ashift), x[:-ashift])) if self.shift < 0: matvec, rmatvec = rmatvec, matvec LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __init__(self, shape, diag, subdiag, superdiag, **kwargs): """ Parameters ---------- shape : length 2 tuple. The shape of the operator. diag : ndarray of size shape[0] The diagonal of the matrix. subdiag : ndarray of size shape[0] - 1 The subdiagonal of the matrix. superdiag : ndarray of size shape[0] - 1 The superdiagonal of the matrix. Returns ------- A Tridiagonal matrix operator instance. Exemple ------- >>> import numpy as np >>> import linear_operators as lo >>> T = lo.TridiagonalOperator((3, 3), [1, 2, 3], [4, 5], [6, 7]) >>> T.todense() array([[1, 6, 0], [4, 2, 7], [0, 5, 3]]) """ if shape[0] != shape[1]: raise ValueError("Only square operator is implemented.") self.diag = diag self.subdiag = subdiag self.superdiag = superdiag self.kwargs = kwargs def matvec(x): out = self.diag * x out[:-1] += self.superdiag * x[1:] out[1:] += self.subdiag * x[:-1] return out def rmatvec(x): out = self.diag * x out[:-1] += self.subdiag * x[1:] out[1:] += self.superdiag * x[:-1] return out LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def identity(shape, dtype=np.float64): "Returns the identity linear Operator" if shape[0] != shape[1]: raise ValueError('Identity operators must be square') def matvec(x): return x return LinearOperator(shape, matvec=matvec, rmatvec=matvec, dtype=dtype)
def __init__(self, shape, matvec, **kwargs): """Returns a SymmetricOperator of given shape and matvec function. Parameters ---------- shape : length 2 tuple The shape of the operator. Should be square. matvec : function The matrix-vector operation. Returns ------- A SymmetricOperator instance. """ if shape[0] != shape[1]: raise ValueError("Symmetric operators are square operators.") kwargs['rmatvec'] = matvec LinearOperator.__init__(self, shape, matvec, **kwargs)
def diag(d, shape=None, dtype=None): "Returns a diagonal Linear Operator" if shape is None: shape = 2 * (d.size, ) if shape[0] != shape[1]: raise ValueError('Diagonal operators must be square') def matvec(x): return d * x if dtype is None: dtype = d.dtype return LinearOperator(shape, matvec=matvec, rmatvec=matvec, dtype=dtype)
def __init__(self, shape, rep_num, **kwargs): """ Parameters ---------- shape : length 2 tuple. The shape of the operator. rep_num : int The number of replications. Returns ------- A ReplicationOperator instance. Exemple ------- >>> import numpy as np >>> import linear_operators as lo >>> R = lo.ReplicationOperator((4, 2), 2) >>> R.todense() array([[ 1., 0.], [ 0., 1.], [ 1., 0.], [ 0., 1.]]) """ self.rep_num = rep_num # ensure coherent input if not shape[0] == shape[1] * rep_num: raise ValueError( "Output vector should be n times the size of input vector.") def matvec(x): return np.tile(x, self.rep_num) def rmatvec(x): N = shape[1] return sum([x[i * N:(i + 1) * N] for i in xrange(self.rep_num)]) LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __init__(self, shapein, shapeout, matvec, rmatvec=None, matmat=None, rmatmat=None, dtypein=None, dtypeout=None, dtype=np.float64): sizein = np.prod(shapein) sizeout = np.prod(shapeout) shape = (sizeout, sizein) ndmatvec = lambda x: matvec(x.reshape(shapein)).ravel() if rmatvec is not None: ndrmatvec = lambda x: rmatvec(x.reshape(shapeout)).ravel() else: ndrmatvec = None LinearOperator.__init__(self, shape, ndmatvec, ndrmatvec, dtype=dtype, dtypein=dtypein, dtypeout=dtypeout) # rename to keep same interface as LinearOperator self.ndmatvec = matvec self.ndrmatvec = rmatvec self.shapein = shapein self.shapeout = shapeout
def __init__(self, shape, ab, kl, ku, **kwargs): """ Generate a BandOperator instance Arguments --------- shape : 2-tuple The shape of the operator ab : ndarray with ndim == 2 Store the bands of the matrix using LAPACK storage scheme. kl : int Number of subdiagonals ku : int Number of superdiagonals """ if ab.shape[0] != kl + ku + 1 or ab.shape[1] != shape[1]: raise ValueError("Wrong ab shape.") self.ab = ab self.kl = kl self.ku = ku self.kwargs = kwargs def matvec(x): # diag out = self.ab[ku] * x # upper part for i in xrange(ku): j = ku - i out[:-j] += self.ab[i, j:] * x[j:] for i in xrange(ku, kl + ku): # lower part out[i:] += self.ab[i + 1, :-i] * x[:-i] return out def rmatvec(x): rab = self._rab rkl, rku = ku, kl # diag out = rab[ku] * x # upper part for i in xrange(rku): j = rku - i out[:-j] += rab[i, j:] * x[j:] for i in xrange(rku, rkl + rku): # lower part out[i:] += rab[i + 1, :-i] * x[:-i] return out return LinearOperator.__init__(self, shape, matvec, rmatvec, **kwargs)
def __init__(self, perm, **kwargs): """ Parameters ---------- perm : list or tuple The permutation of coefficients. Returns ------- A PermutationOperator instance. Exemple ------- >>> import numpy as np >>> import linear_operators as lo >>> P = lo.PermutationOperator([3, 1, 0, 2]) >>> P.todense() array([[ 0., 0., 0., 1.], [ 0., 1., 0., 0.], [ 1., 0., 0., 0.], [ 0., 0., 1., 0.]]) """ shape = 2 * (len(perm), ) self.perm = perm # reverse permutation self.perm_inv = np.argsort(perm) def matvec(x): return np.asarray([x[pi] for pi in self.perm]) def rmatvec(x): return np.asarray([x[pi] for pi in self.perm_inv]) LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def masubclass(xin=None, xout=None, shapein=None, shapeout=None, classin=None, classout=None, dictin=None, dictout=None, matvec=None, rmatvec=None, dtype=np.float64, dtypein=None, dtypeout=None): "Wrap linear operation working on ndarray subclasses in MaskedArray style" if xin is not None: shapein = xin.shape classin = xin.__class__ dictin = xin.__dict__ dtype = xin.dtype if xout is not None: shapeout = xout.shape classout = xout.__class__ dictout = xout.__dict__ sizein = np.prod(shapein) sizeout = np.prod(shapeout) shape = (sizeout, sizein) if matvec is not None: def ndmatvec(x): xi = classin(x.reshape(shapein)) xi.__dict__ = dictin return matvec(xi).reshape(sizeout) else: raise ValueError('Requires a matvec function') if rmatvec is not None: def ndrmatvec(x): xo = classout(x.reshape(shapeout)) xo.__dict__ = dictout return rmatvec(xo).reshape(sizein) else: ndrmatvec = None return LinearOperator(shape, matvec=ndmatvec, rmatvec=ndrmatvec, dtype=dtype, dtypein=dtypein, dtypeout=dtypeout)
def eye(shape, dtype=np.float64): "Returns the identity linear Operator" if shape[0] == shape[1]: return identity(shape, dtype=dtype) else: def matvec(x): return x[:shape[0]] def rmatvec(x): return np.concatenate(x, np.zeros(shape[0] - shape[1])) return LinearOperator(shape, matvec=matvec, rmatvec=rmatvec, dtype=dtype)
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + " and shift=%d >" % self.shift
def __repr__(self): s = LinearOperator.__repr__(self)[:-1] s += ",\n superdiagonal=" + self.superdiag.__repr__() s += ",\n diagonal=" + self.diag.__repr__() s += ",\n subdiagonal=" + self.subdiag.__repr__() + ">" return s
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + ",\n diagonal=" + self.diag.__repr__() + ">"
def __init__(self, shape, **kwargs): matvec = lambda x: np.fft.fft(x, n=shape[0]) / np.sqrt(shape[0]) rmatvec = lambda x: np.fft.ifft(x, n=shape[1]) * np.sqrt(shape[0]) LinearOperator.__init__(self, shape, matvec, rmatvec=rmatvec, **kwargs)
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + " and coef=%f >" % self.coef
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + "\n and diagonal=" + self.d.__repr__() + ">"
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + ",\n permutation=" + self.perm.__repr__() + ">"
def __repr__(self): s = LinearOperator.__repr__(self) return s[:-1] + ",\n Replicate %i times" % self.n + ">"