def __init__(self, conf, **kwargs):
LinearSolver.__init__(self, conf, solve=None, **kwargs)
um = self.sls = None
aux = try_imports(['import scipy.linsolve as sls',
'import scipy.splinalg.dsolve as sls',
'import scipy.sparse.linalg.dsolve as sls'],
'cannot import scipy sparse direct solvers!')
self.sls = aux['sls']
aux = try_imports(['import scipy.linsolve.umfpack as um',
'import scipy.splinalg.dsolve.umfpack as um',
'import scipy.sparse.linalg.dsolve.umfpack as um',
'import scikits.umfpack as um'])
if 'um' in aux:
um = aux['um']
if um is not None:
is_umfpack = hasattr(um, 'UMFPACK_OK')
else:
is_umfpack = False
method = self.conf.method
if method == 'superlu':
self.sls.use_solver(useUmfpack=False)
elif method == 'umfpack':
if not is_umfpack and self.conf.warn:
output('umfpack not available, using superlu!')
elif method != 'auto':
raise ValueError('uknown solution method! (%s)' % method)
if method != 'superlu' and is_umfpack:
self.sls.use_solver(useUmfpack=True,
assumeSortedIndices=True)
def __init__(self, conf, **kwargs):
LinearSolver.__init__(self, conf, solve=None, **kwargs)
um = self.sls = None
aux = try_imports([
'import scipy.linsolve as sls',
'import scipy.splinalg.dsolve as sls',
'import scipy.sparse.linalg.dsolve as sls'
], 'cannot import scipy sparse direct solvers!')
self.sls = aux['sls']
aux = try_imports([
'import scipy.linsolve.umfpack as um',
'import scipy.splinalg.dsolve.umfpack as um',
'import scipy.sparse.linalg.dsolve.umfpack as um',
'import scikits.umfpack as um'
])
if 'um' in aux:
um = aux['um']
if um is not None:
is_umfpack = hasattr(um, 'UMFPACK_OK')
else:
is_umfpack = False
method = self.conf.method
if method == 'superlu':
self.sls.use_solver(useUmfpack=False)
elif method == 'umfpack':
if not is_umfpack and self.conf.warn:
output('umfpack not available, using superlu!')
elif method != 'auto':
raise ValueError('uknown solution method! (%s)' % method)
if method != 'superlu' and is_umfpack:
self.sls.use_solver(useUmfpack=True, assumeSortedIndices=True)
def __init__(self, conf, **kwargs):
EigenvalueSolver.__init__(self, conf, **kwargs)
imp = try_imports(['from pysparse import jdsym, itsolvers, precon',
'from pysparse.eigen import jdsym;'
' from pysparse import itsolvers, precon'],
'cannot import pysparse eigensolvers!')
self.imp = imp
def __init__(self, conf, **kwargs):
EigenvalueSolver.__init__(self, conf, **kwargs)
imp = try_imports(['from pysparse import jdsym, itsolvers, precon',
'from pysparse.eigen import jdsym;'
' from pysparse import itsolvers, precon'],
'cannot import pysparse eigensolvers!')
self.imp = imp
def __init__(self, conf, **kwargs):
LinearSolver.__init__(self, conf, **kwargs)
um = self.sls = None
aux = try_imports(
[
"import scipy.linsolve as sls",
"import scipy.splinalg.dsolve as sls",
"import scipy.sparse.linalg.dsolve as sls",
],
"cannot import scipy sparse direct solvers!",
)
self.sls = aux["sls"]
aux = try_imports(
[
"import scipy.linsolve.umfpack as um",
"import scipy.splinalg.dsolve.umfpack as um",
"import scipy.sparse.linalg.dsolve.umfpack as um",
"import scikits.umfpack as um",
]
)
if "um" in aux:
um = aux["um"]
if um is not None:
is_umfpack = hasattr(um, "UMFPACK_OK")
else:
is_umfpack = False
method = self.conf.method
if method == "superlu":
self.sls.use_solver(useUmfpack=False)
elif method == "umfpack":
if not is_umfpack and self.conf.warn:
output("umfpack not available, using superlu!")
elif method != "auto":
raise ValueError("uknown solution method! (%s)" % method)
if method != "superlu" and is_umfpack:
self.sls.use_solver(useUmfpack=True, assumeSortedIndices=True)
self.solve = None
if self._presolve() and hasattr(self, "mtx"):
if self.mtx is not None:
self.solve = self.sls.factorized(self.mtx)
def __init__(self, conf, **kwargs):
EigenvalueSolver.__init__(self, conf, **kwargs)
import scipy.linalg as sla
self.sla = sla
aux = try_imports(['import scipy.sparse.linalg as ssla'],
'cannot import scipy sparse eigenvalue solvers!')
self.ssla = aux['ssla']
def __init__(self, conf, **kwargs):
EigenvalueSolver.__init__(self, conf, **kwargs)
import scipy.linalg as sla
self.sla = sla
aux = try_imports(['import scipy.sparse.linalg as ssla'],
'cannot import scipy sparse eigenvalue solvers!')
self.ssla = aux['ssla']
def __init__(self, conf, **kwargs):
EigenvalueSolver.__init__(self, conf, **kwargs)
imp = try_imports(
[
"from pysparse import jdsym, itsolvers, precon",
"from pysparse.eigen import jdsym;" " from pysparse import itsolvers, precon",
],
"cannot import pysparse eigensolvers!",
)
self.imp = imp
def __init__(self, conf, method=None, **kwargs):
LinearSolver.__init__(self, conf, solve=None, **kwargs)
um = self.sls = None
if method is None:
method = self.conf.method
aux = try_imports([
'import scipy.linsolve as sls',
'import scipy.splinalg.dsolve as sls',
'import scipy.sparse.linalg.dsolve as sls'
], 'cannot import scipy sparse direct solvers!')
if 'sls' in aux:
self.sls = aux['sls']
else:
raise ValueError('SuperLU not available!')
if method in ['auto', 'umfpack']:
aux = try_imports([
'import scipy.linsolve.umfpack as um',
'import scipy.splinalg.dsolve.umfpack as um',
'import scipy.sparse.linalg.dsolve.umfpack as um',
'import scikits.umfpack as um'
])
is_umfpack = True if 'um' in aux\
and hasattr(aux['um'], 'UMFPACK_OK') else False
if method == 'umfpack' and not is_umfpack:
raise ValueError('UMFPACK not available!')
elif method == 'superlu':
is_umfpack = False
else:
raise ValueError('uknown solution method! (%s)' % method)
if is_umfpack:
self.sls.use_solver(useUmfpack=True, assumeSortedIndices=True)
else:
self.sls.use_solver(useUmfpack=False)
def __init__(self, conf, method=None, **kwargs):
LinearSolver.__init__(self, conf, solve=None, **kwargs)
um = self.sls = None
if method is None:
method = self.conf.method
aux = try_imports(['import scipy.linsolve as sls',
'import scipy.splinalg.dsolve as sls',
'import scipy.sparse.linalg.dsolve as sls'],
'cannot import scipy sparse direct solvers!')
if 'sls' in aux:
self.sls = aux['sls']
else:
raise ValueError('SuperLU not available!')
if method in ['auto', 'umfpack']:
aux = try_imports([
'import scipy.linsolve.umfpack as um',
'import scipy.splinalg.dsolve.umfpack as um',
'import scipy.sparse.linalg.dsolve.umfpack as um',
'import scikits.umfpack as um'])
is_umfpack = True if 'um' in aux\
and hasattr(aux['um'], 'UMFPACK_OK') else False
if method == 'umfpack' and not is_umfpack:
raise ValueError('UMFPACK not available!')
elif method == 'superlu':
is_umfpack = False
else:
raise ValueError('uknown solution method! (%s)' % method)
if is_umfpack:
self.sls.use_solver(useUmfpack=True,
assumeSortedIndices=True)
else:
self.sls.use_solver(useUmfpack=False)
def __call__(self, mtx_a, mtx_b=None, n_eigs=None,
eigenvectors=None, status=None, conf=None):
imp = try_imports(['from pysparse import jdsym, itsolvers, precon',
'from pysparse.eigen import jdsym;'
' from pysparse import itsolvers, precon'],
'cannot import pysparse eigensolvers!')
jdsym = imp['jdsym']
itsolvers = imp['itsolvers']
precon = imp['precon']
output("solving...")
A = self._convert_mat(mtx_a)
Atau = A.copy()
if mtx_b is not None:
M = self._convert_mat(mtx_b)
Atau.shift(-conf.tau, M)
K = precon.jacobi(Atau)
A = A.to_sss()
if mtx_b is not None:
M = M.to_sss()
else:
M = None
method = getattr(itsolvers, conf.method)
kconv, lmbd, Q, it, it_in = jdsym.jdsym(A, M, K, n_eigs, conf.tau,
conf.eps_a, conf.i_max,
method,
clvl=conf.verbosity,
strategy=conf.strategy)
output("number of converged eigenvalues:", kconv)
output("...done")
if status is not None:
status['q'] = Q
status['it'] = it
status['it_in'] = it_in
return lmbd, Q
