def __sub__(self, rhs: 'RealAVector') -> 'RealAVector':
verify_type(rhs, [RealAVector])
v = RealAVector.new(self.dim)
v.clear()
v.add(self)
v.add(rhs, -1)
return v
def mvm(self, alpha: float, trans: bool, a: mvm_union, src: 'AVector'):
mvm_types = [
mat.AMatrix, mat.SparseMatrix, mat.HMatrix, mat.H2Matrix,
mat.DH2Matrix, mat.RkMatrix, misc.Uniform, misc.ClusterBasis
]
verify_type(a, mvm_types)
if isinstance(a, mat.AMatrix):
mvm_func = libamatrix.mvm_amatrix_avector
elif isinstance(a, mat.SparseMatrix):
mvm_func = libsparsematrix.mvm_sparsematrix_avector
elif isinstance(a, mat.HMatrix):
mvm_func = libhmatrix.mvm_hmatrix_avector
elif isinstance(a, mat.H2Matrix):
mvm_func = libh2matrix.mvm_h2matrix_avector
elif isinstance(a, mat.RkMatrix):
mvm_func = librkmatrix.mvm_rkmatrix_avector
elif isinstance(a, mat.DH2Matrix):
raise ValueError('MVM for DH2-matrizes not yet implemented.')
elif isinstance(a, misc.Uniform):
mvm_func = libuniform.mvm_uniform_avector
elif isinstance(a, misc.ClusterBasis):
def mvm_cb(alpha, trans, cb, src, tgt):
if trans:
func = libclusterbasis.addeval_clusterbasis_avector
else:
func = libclusterbasis.addevaltrans_clusterbasis_avector
func(alpha, cb, src, self)
mvm_func = mvm_cb
mvm_func(alpha, trans, a, src, self)
def solve_gmres(a: matrix_union, b: 'vec.AVector', x: 'vec.AVector',
eps: float, maxiter: int, kmax: int) -> int:
verify_type(a, matrix_types)
if isinstance(a, mat.AMatrix):
solve_func = libkrylovsolvers.solve_gmres_amatrix_avector
elif isinstance(a, mat.SparseMatrix):
solve_func = libkrylovsolvers.solve_gmres_sparsematrix_avector
elif isinstance(a, mat.HMatrix):
solve_func = libkrylovsolvers.solve_gmres_hmatrix_avector
elif isinstance(a, mat.H2Matrix):
solve_func = libkrylovsolvers.solve_gmres_h2matrix_avector
elif isinstance(a, mat.DH2Matrix):
solve_func = libkrylovsolvers.solve_gmres_dh2matrix_avector
return solve_func(a, b, x, eps, maxiter, kmax)
def fast_addeval(self, alpha: float, trans: bool,
h: Union['mat.HMatrix', 'mat.H2Matrix'], src: 'AVector'):
verify_type(h, [mat.HMatrix, mat.H2Matrix])
if isinstance(h, mat.HMatrix):
if trans:
func = libhmatrix.fastaddevaltrans_hmatrix_avector
else:
func = libhmatrix.fastaddeval_hmatrix_avector
elif isinstance(h, mat.H2Matrix):
if trans:
func = libh2matrix.fastaddevaltrans_h2matrix_avector
else:
func = libh2matrix.fastaddeval_h2matrix_avector
func(alpha, h, src, self)
def solve_pcg(a: matrix_union, prcd, pdata, b: 'vec.AVector', x: 'vec.AVector',
eps: float, maxiter: int) -> int:
verify_type(a, matrix_types)
cprcd = libkrylov.CFuncPrcdT(prcd)
cpdata = cast(pdata, c_void_p)
if isinstance(a, mat.AMatrix):
solve_func = libkrylovsolvers.solve_pcg_amatrix_avector
elif isinstance(a, mat.SparseMatrix):
solve_func = libkrylovsolvers.solve_pcg_sparsematrix_avector
elif isinstance(a, mat.HMatrix):
solve_func = libkrylovsolvers.solve_pcg_hmatrix_avector
elif isinstance(a, mat.H2Matrix):
solve_func = libkrylovsolvers.solve_pcg_h2matrix_avector
elif isinstance(a, mat.DH2Matrix):
solve_func = libkrylovsolvers.solve_pcg_dh2matrix_avector
return solve_func(a, cprcd, cpdata, b, x, eps, maxiter)
def __imul__(self, rhs: Union[int, float]) -> 'AVector':
verify_type(rhs, [int, float])
self.scale(rhs)
return self
def __isub__(self, rhs: 'AVector') -> 'AVector':
verify_type(rhs, [AVector])
self.add(rhs, -1)
return self
def __mul__(self, rhs: Union[int, float]) -> 'AVector':
verify_type(rhs, [int, float])
v = AVector.new(self.dim, zeros=True)
v.add(self, rhs)
return v
def __sub__(self, rhs: 'AVector') -> 'AVector':
verify_type(rhs, [AVector])
v = AVector.new(self.dim, zeros=True)
v.add(self)
v.add(rhs, -1)
return v
def project(self, src: Union['mat.AMatrix', 'mat.HMatrix']) -> None:
verify_type(src, [mat.AMatrix, mat.HMatrix])
if isinstance(src, mat.AMatrix):
libh2matrix.project_amatrix_h2matrix(self, src)
elif isinstance(src, mat.HMatrix):
libh2matrix.project_hmatrix_h2matrix(self, src)
def __isub__(self, rhs: Union['AMatrix', 'mat.SparseMatrix']) -> 'AMatrix':
verify_type(rhs, [AMatrix, mat.SparseMatrix])
self.add(rhs, -1)
return self
def __matmul__(self, rhs: 'AMatrix') -> 'AMatrix':
verify_type(rhs, [AMatrix])
a = AMatrix.new(self.rows, self.cols, fill=mat.FillType.Zeros)
a.addmul(1.0, self, rhs, False, False)
return a
def __mul__(self, rhs: Union[int, float]) -> 'AMatrix':
verify_type(rhs, [int, float])
a = self.clone()
a.scale(rhs)
return a
def __sub__(self, rhs: Union['AMatrix', 'mat.SparseMatrix']) -> 'AMatrix':
verify_type(rhs, [AMatrix, mat.SparseMatrix])
a = self.clone()
a.add(rhs, -1)
return a
def __iadd__(self, rhs: 'RealAVector') -> 'RealAVector':
verify_type(rhs, [RealAVector])
self.add(rhs)
return self
def __mul__(self, rhs: Union[int, float]) -> 'RealAVector':
verify_type(rhs, [RealAVector, int, float])
v = RealAVector.new(self.dim)
v.clear()
v.add(self, rhs)
return v
