def __init__(self,
npc_matvec,
leg,
dtype,
charge_sector=0,
vec_label=None,
compact_flat=None):
self.npc_matvec = npc_matvec
self.leg = leg
self.possible_charge_sectors = leg.charge_sectors()
self.shape = (leg.ind_len, leg.ind_len)
self.dtype = dtype
if compact_flat is None:
compact_flat = charge_sector is not None and leg.is_blocked()
elif compact_flat:
if not leg.is_blocked():
raise ValueError(
"FlatLinearOperator with `compact_flat` works only "
"for blocked `leg`.")
self.compact_flat = compact_flat
self.vec_label = vec_label
self.matvec_count = 0
self._charge_sector = None
self._mask = None
self.charge_sector = charge_sector # uses the setter
self._npc_matvec_multileg = None
self._labels_split = None
ScipyLinearOperator.__init__(self, self.dtype, self.shape)
def __init__(self,
adjacency: Union[sparse.csr_matrix, np.ndarray],
regularization: float = 0.):
LinearOperator.__init__(self, dtype=float, shape=adjacency.shape)
self.regularization = regularization
self.weights = adjacency.dot(np.ones(adjacency.shape[1]))
self.laplacian = sparse.diags(self.weights, format='csr') - adjacency
def __init__(self, n, c):
"""n is dimension, c is a constant to be multiplied by the identity matrix."""
self.c = c
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = (n, n))
else:
LinearOperator.__init__(self, dtype = float, shape = (n, n), matvec = lambda x : type(self)._matvec(self, x))
def __init__(self, D):
"""D is a 1D array containing the diagonal entries."""
self.D = D
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = (len(D), len(D)))
else:
LinearOperator.__init__(self, dtype = float, shape = (len(D), len(D)), matvec = lambda x : type(self)._matvec(self, x))
def __init__(self, F, Delta, u):
n = F.shape[0]
assert (F.shape[1] == n) and (u.shape == (n,))
self.F, self.Delta, self.u = F, Delta, u
self.u_prime = self.Delta - self.u
self.ones = np.ones(n, dtype=float)
LinearOperator.__init__(self, dtype=float, shape=self.F.shape)
def __init__(self, u, v):
assert (len(u) == len(v))
self.u, self.v = u, v
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = (len(u), len(v)))
else:
LinearOperator.__init__(self, dtype = float, shape = (len(u), len(v)), matvec = lambda x : type(self)._matvec(self, x))
def __init__(self, block_grid):
"""Input is a 2D list of SparseLinearOperators. The resulting operator is the corresponding operator comprised of these operator blocks. The dimensions must match correctly. This assumes the number of blocks in each row and column is the same."""
self.block_grid_shape = (len(block_grid), len(block_grid[0]))
# validate block dimensions
assert all(
[len(row) == self.block_grid_shape[1] for row in block_grid]
), "Must be same number of blocks in each row."
assert all(
[
len(set([block_grid[i][j].shape[0] for j in range(self.block_grid_shape[1])])) == 1
for i in range(self.block_grid_shape[0])
]
), "dimension mismatch"
assert all(
[
len(set([block_grid[i][j].shape[1] for i in range(self.block_grid_shape[0])])) == 1
for j in range(self.block_grid_shape[1])
]
), "dimension mismatch"
shape = (
sum([block_grid[i][0].shape[0] for i in range(len(block_grid))]),
sum([block_grid[0][j].shape[1] for j in range(len(block_grid[0]))]),
)
# compute transition indices between blocks
self.row_indices = [0] + list(np.cumsum([row[0].shape[0] for row in block_grid]))
self.column_indices = [0] + list(np.cumsum([block.shape[1] for block in block_grid[0]]))
self.block_grid = block_grid
LinearOperator.__init__(self, dtype=float, shape=shape)
def __init__(self,
A,
coarsening=pyamgcl_ext.coarsening.smoothed_aggregation,
relaxation=pyamgcl_ext.relaxation.spai0,
prm={}
):
"""
Class constructor.
Creates algebraic multigrid hierarchy.
Parameters
----------
A : the system matrix in scipy.sparse format
coarsening : {ruge_stuben, aggregation, *smoothed_aggregation*, smoothed_aggr_emin}
The coarsening type to use for construction of the multigrid
hierarchy.
relaxation : {damped_jacobi, gauss_seidel, chebyshev, *spai0*, ilu0}
The relaxation scheme to use for multigrid cycles.
prm : dictionary with amgcl parameters
"""
Acsr = A.tocsr()
self.P = pyamgcl_ext.make_preconditioner(
coarsening, relaxation, prm,
Acsr.indptr.astype(numpy.int32),
Acsr.indices.astype(numpy.int32),
Acsr.data.astype(numpy.float64)
)
LinearOperator.__init__(self, A.shape, self.P)
def __init__(self,
adjacency: sparse.csr_matrix,
damping_factor: float = 0.85,
personalization=None,
fb_mode: bool = False,
verbose: bool = False):
VerboseMixin.__init__(self, verbose)
n1, n2 = adjacency.shape
restart_prob: np.ndarray = restart_probability(n1, personalization)
if fb_mode:
restart_prob = np.hstack((restart_prob, np.zeros(n2)))
adjacency = bipartite2undirected(adjacency)
LinearOperator.__init__(self, shape=adjacency.shape, dtype=float)
n = adjacency.shape[0]
out_degrees = adjacency.dot(np.ones(n))
damping_matrix = damping_factor * sparse.eye(n, format='csr')
if fb_mode:
damping_matrix.data[n1:] = 1
self.a = (damping_matrix.dot(transition_matrix(adjacency))).T.tocsr()
self.b = (np.ones(n) -
damping_factor * out_degrees.astype(bool)) * restart_prob
def __init__(self, A):
assert isinstance(A, SymmetricSparseLinearOperator)
self.A = A
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = A.shape)
else:
LinearOperator.__init__(self, dtype = float, shape = A.shape, matvec = lambda x : type(self)._matvec(self, x))
self.D_ratio = self.A._matvec(np.ones(self.A.shape[1], dtype = float)) / self.shape[0]
def __init__(self, shape, matvec):
self._shape = shape
self._action = matvec
LinearOperator.__init__(self,
shape=self._shape,
matvec=self.parallelDot,
dtype=np.complex128)
def __init__(self, shape, matvec):
self._shape = shape
self._action = matvec
LinearOperator.__init__(self,
shape=self._shape,
matvec=self.parallelDot,
dtype=np.complex128)
def __init__(self, u):
self.u = u
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=(len(u), len(u)))
else:
LinearOperator.__init__(
self,
dtype=float,
shape=(len(u), len(u)),
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, K, quad, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
ck = ones(K.shape)
if quad == "GC": ck[N-1] = 2
self.dd = -4*pi*(K[:N]+1)/(K[:N]+3)*(K[:N]+2)**2
self.ud = [2*pi*(K[:N-2]+1)*(K[:N-2]+2)]
self.ld = [2*pi*(K[2:N]-1)*(K[2:N]+2)]
def __init__(self,
adjacency: Union[sparse.csr_matrix, np.ndarray],
regularization: float = 0.):
LinearOperator.__init__(self, dtype=float, shape=adjacency.shape)
self.adjacency = adjacency
self.regularization = regularization
n = self.adjacency.shape[0]
self.sqrt_weights = np.sqrt(
self.adjacency.dot(np.ones(n)) + self.regularization * n)
def __init__(self, F, Delta, u):
n = F.shape[0]
assert ((F.shape[1] == n) and (u.shape == (n,)))
self.F, self.Delta, self.u = F, Delta, u
self.u_prime = self.Delta - self.u
self.ones = np.ones(n, dtype = float)
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = self.F.shape)
else:
LinearOperator.__init__(self, dtype = float, shape = self.F.shape, matvec = lambda x : type(self)._matvec(self, x))
def __init__(self, K, quad, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
ck = ones(K.shape)
if quad == "GC": ck[N-1] = 2
self.dd = -4*pi*(K[:N]+1)/(K[:N]+3)*(K[:N]+2)**2
self.ud = [2*pi*(K[:N-2]+1)*(K[:N-2]+2)]
self.ld = [2*pi*(K[2:N]-1)*(K[2:N]+2)]
def __init__(self, D):
"""D is a 1D array containing the diagonal entries."""
self.D = D
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=(len(D), len(D)))
else:
LinearOperator.__init__(
self,
dtype=float,
shape=(len(D), len(D)),
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, K, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
self.dd = 8*pi*(K[:N]+1)**2*(K[:N]+2)*(K[:N]+4)
self.ud = []
for i in range(2, N, 2):
self.ud.append(8*pi*(K[:-(i+4)]+1)*(K[:-(i+4)]+2)*(K[:-(i+4)]*(K[:-(i+4)]+4)+3*(arange(i, N)+2)**2)/((arange(i, N)+3)))
self.ld = None
def __init__(self, u, v):
assert (len(u) == len(v))
self.u, self.v = u, v
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=(len(u), len(v)))
else:
LinearOperator.__init__(
self,
dtype=float,
shape=(len(u), len(v)),
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, n, c):
"""n is dimension, c is a constant to be multiplied by the identity matrix."""
self.c = c
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=(n, n))
else:
LinearOperator.__init__(
self,
dtype=float,
shape=(n, n),
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, K, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
self.dd = 8*pi*(K[:N]+1)**2*(K[:N]+2)*(K[:N]+4)
self.ud = []
for i in range(2, N, 2):
self.ud.append(8*pi*(K[:-(i+4)]+1)*(K[:-(i+4)]+2)*(K[:-(i+4)]*(K[:-(i+4)]+4)+3*(arange(i, N)+2)**2)/((arange(i, N)+3)))
self.ld = None
def __init__(self, A):
assert isinstance(A, SymmetricSparseLinearOperator)
self.A = A
self.D = self.A.matvec(np.ones(self.A.shape[1], dtype=float))
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=A.shape)
else:
LinearOperator.__init__(
self,
dtype=float,
shape=A.shape,
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, K, quad, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
ck = ones(K.shape)
if quad == "GC": ck[N-1] = 2
self.dd = pi/2*(ck[:-4] + 4*(K[:N]+2)**2/(K[:N]+3)**2 + (K[:N]+1)**2/(K[:N]+3)**2)
self.ud = [-pi*((K[:N-2]+2)/(K[:N-2]+3) + (K[:N-2]+4)/(K[:N-2]+5)*(K[:N-2]+1)/(K[:N-2]+3)),
pi/2*(K[:N-4]+1)/(K[:N-4]+3)]
self.ld = [pi/2*(K[:N-4]+1)/(K[:N-4]+3),
-pi*((K[:N-2]+2)/(K[:N-2]+3) + (K[:N-2]+4)/(K[:N-2]+5)*(K[:N-2]+1)/(K[:N-2]+3))]
def __init__(self, K, quad, **kwargs):
assert len(K.shape) == 1
shape = (K.shape[0]-4, K.shape[0]-4)
N = shape[0]
LinearOperator.__init__(self, shape, None, **kwargs)
ck = ones(K.shape)
if quad == "GC": ck[N-1] = 2
self.dd = pi/2*(ck[:-4] + 4*(K[:N]+2)**2/(K[:N]+3)**2 + (K[:N]+1)**2/(K[:N]+3)**2)
self.ud = [-pi*((K[:N-2]+2)/(K[:N-2]+3) + (K[:N-2]+4)/(K[:N-2]+5)*(K[:N-2]+1)/(K[:N-2]+3)),
pi/2*(K[:N-4]+1)/(K[:N-4]+3)]
self.ld = [pi/2*(K[:N-4]+1)/(K[:N-4]+3),
-pi*((K[:N-2]+2)/(K[:N-2]+3) + (K[:N-2]+4)/(K[:N-2]+5)*(K[:N-2]+1)/(K[:N-2]+3))]
def __init__(self, npc_matvec, leg, dtype, charge_sector=0, vec_label=None):
self.npc_matvec = npc_matvec
self.leg = leg
self.possible_charge_sectors = leg.charge_sectors()
self.shape = (leg.ind_len, leg.ind_len)
self.dtype = dtype
self.vec_label = vec_label
self.matvec_count = 0
self._charge_sector = None
self._mask = None
self.charge_sector = charge_sector # uses the setter
self._npc_matvec_multileg = None
self._labels_split = None
ScipyLinearOperator.__init__(self, self.dtype, self.shape)
def __init__(self, F, Delta, u):
n = F.shape[0]
assert ((F.shape[1] == n) and (u.shape == (n, )))
self.F, self.Delta, self.u = F, Delta, u
self.u_prime = self.Delta - self.u
self.ones = np.ones(n, dtype=float)
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=self.F.shape)
else:
LinearOperator.__init__(
self,
dtype=float,
shape=self.F.shape,
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, mat, r=10, leaf_side=16):
LinearOperator.__init__(self, dtype=mat.dtype, shape=mat.shape,
matvec=self._matvec,
rmatvec=self._rmatvec)
self.mat = BlackBox(mat)
self.r = r
self.leaf_side = leaf_side
self.leaf_size = leaf_side**2
N = int(np.sqrt(self.mat.shape[0]))
self.pattern = distance_matrix(N, format='coo')
perm = hilbert_traverse(N)
conjugate_sparse(self.pattern, perm)
self.pattern = self.pattern.tocsr()
self.mat.permutate(perm)
self.root = hmat_node(self, tuple(zip((0, 0), self.mat.shape)))
return
def __init__(self, A, prm={}):
"""
Class constructor.
Creates algebraic multigrid hierarchy.
Parameters
----------
A : the system matrix in scipy.sparse format
prm : dictionary with amgcl parameters
"""
Acsr = A.tocsr()
self.P = pyamgcl_ext.make_preconditioner(
Acsr.indptr, Acsr.indices, Acsr.data, prm)
if [int(v) for v in scipy.__version__.split('.')] < [0, 16, 0]:
LinearOperator.__init__(self, A.shape, self.P)
else:
LinearOperator.__init__(self, dtype=numpy.float64, shape=A.shape)
def __init__(self, mat, r=10, leaf_side=16):
LinearOperator.__init__(self,
dtype=mat.dtype,
shape=mat.shape,
matvec=self._matvec,
rmatvec=self._rmatvec)
self.mat = BlackBox(mat)
self.r = r
self.leaf_side = leaf_side
self.leaf_size = leaf_side**2
N = int(np.sqrt(self.mat.shape[0]))
self.pattern = distance_matrix(N, format='coo')
perm = hilbert_traverse(N)
conjugate_sparse(self.pattern, perm)
self.pattern = self.pattern.tocsr()
self.mat.permutate(perm)
self.root = hmat_node(self, tuple(zip((0, 0), self.mat.shape)))
return
def __init__(self, A, pmask, prm={}):
"""
Class constructor.
Parameters
----------
A : the system matrix in scipy.sparse format
prm : dictionary with amgcl parameters
"""
Acsr = A.tocsr()
self.P = pyamgcl_ext.make_simple(prm, Acsr.indptr.astype(numpy.int32),
Acsr.indices.astype(numpy.int32),
Acsr.data.astype(numpy.float64),
pmask.astype(numpy.int32))
if [int(v) for v in scipy.__version__.split('.')] < [0, 16, 0]:
LinearOperator.__init__(self, A.shape, self.P)
else:
LinearOperator.__init__(self, dtype=numpy.float64, shape=A.shape)
def __init__(self,shape,n_blk):
self.n_iter = 0
self.shape = shape
LinearOperator.__init__(self,self.shape,self.mult)
self.pc = []
self.size_blk = []
self.n_blk = n_blk
assert shape[0] == shape[1], \
"Prec Shape Must be squared, %r rows not equal to %r cols" % (shape[0],shape[1])
for i in range(0,n_blk):
row = (i+1)*[False]
#for j in range(0,i+1):
# row.append([])
self.pc.append(row)
for i in range(0,n_blk):
self.size_blk.append([])
return
def __init__(self, block_grid):
"""Input is a 2D list of SparseLinearOperators. The resulting operator is the corresponding operator comprised of these operator blocks. The dimensions must match correctly. This assumes the number of blocks in each row and column is the same."""
self.block_grid_shape = (len(block_grid), len(block_grid[0]))
# validate block dimensions
assert all([
len(row) == self.block_grid_shape[1] for row in block_grid
]), "Must be same number of blocks in each row."
assert all([
len(
set([
block_grid[i][j].shape[0]
for j in range(self.block_grid_shape[1])
])) == 1 for i in range(self.block_grid_shape[0])
]), "dimension mismatch"
assert all([
len(
set([
block_grid[i][j].shape[1]
for i in range(self.block_grid_shape[0])
])) == 1 for j in range(self.block_grid_shape[1])
]), "dimension mismatch"
shape = (sum([
block_grid[i][0].shape[0] for i in range(len(block_grid))
]), sum([block_grid[0][j].shape[1]
for j in range(len(block_grid[0]))]))
# compute transition indices between blocks
self.row_indices = [0] + list(
np.cumsum([row[0].shape[0] for row in block_grid]))
self.column_indices = [0] + list(
np.cumsum([block.shape[1] for block in block_grid[0]]))
self.block_grid = block_grid
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype=float, shape=shape)
else:
LinearOperator.__init__(
self,
dtype=float,
shape=shape,
matvec=lambda x: type(self)._matvec(self, x))
def __init__(self, A, pmask, prm={}):
"""
Class constructor.
Parameters
----------
A : the system matrix in scipy.sparse format
prm : dictionary with amgcl parameters
"""
Acsr = A.tocsr()
self.P = pyamgcl_ext.make_simple(
prm,
Acsr.indptr.astype(numpy.int32),
Acsr.indices.astype(numpy.int32),
Acsr.data.astype(numpy.float64),
pmask.astype(numpy.int32)
)
if [int(v) for v in scipy.__version__.split('.')] < [0, 16, 0]:
LinearOperator.__init__(self, A.shape, self.P)
else:
LinearOperator.__init__(self, dtype=numpy.float64, shape=A.shape)
def __init__(self,shape):
LinearOperator.__init__(self,shape,self.full)
self.n_iter = 0
def __init__(self, A):
assert isinstance(A, SymmetricSparseLinearOperator)
self.A = A
LinearOperator.__init__(self, dtype=float, shape=A.shape)
self.D_ratio = self.A._matvec(np.ones(self.A.shape[1], dtype=float)) / self.shape[0]
def __init__(self, u, v):
assert len(u) == len(v)
self.u, self.v = u, v
LinearOperator.__init__(self, dtype=float, shape=(len(u), len(v)))
def __init__(self, u):
self.u = u
LinearOperator.__init__(self, dtype=float, shape=(len(u), len(u)))
def __init__(self, D):
"""D is a 1D array containing the diagonal entries."""
self.D = D
LinearOperator.__init__(self, dtype=float, shape=(len(D), len(D)))
def __init__(self, n, c):
"""n is dimension, c is a constant to be multiplied by the identity matrix."""
self.c = c
LinearOperator.__init__(self, dtype=float, shape=(n, n))
def __init__(self,shape):
LinearOperator.__init__(self,shape,self.mult)
return
def __init__(self,A):
LinearOperator.__init__(self,A.shape,self.mult)
self.A = A
return
def __init__(self, u):
self.u = u
if LINOP_SUBCLASSING:
LinearOperator.__init__(self, dtype = float, shape = (len(u), len(u)))
else:
LinearOperator.__init__(self, dtype = float, shape = (len(u), len(u)), matvec = lambda x : type(self)._matvec(self, x))
def __init__(self,shape):
LinearOperator.__init__(self,shape,self.block_diagonal)
self.n_iter = 0
def __init__(self,shape):
LinearOperator.__init__(self,shape,self.upper_tri)
self.n_iter = 0