def __call__( self, mtx_a, mtx_b = None, n_eigs = None,
eigenvectors = None, status = None, conf = None ):
"""eigenvectors arg ignored, computes them always"""
import scipy.lib.lapack as ll
conf = get_default( conf, self.conf )
mtx_a = get_default( mtx_a, self.mtx_a )
mtx_b = get_default( mtx_b, self.mtx_b )
n_eigs = get_default( n_eigs, self.n_eigs )
eigenvectors = get_default( eigenvectors, self.eigenvectors )
status = get_default( status, self.status )
tt = time.clock()
if (n_eigs is None) or (conf.force_n_eigs):
mtx_a, mtx_b = self._to_array( mtx_a, mtx_b )
if nm.iscomplexobj( mtx_a ):
if mtx_b is None:
fun = ll.get_lapack_funcs( ['heev'], arrays = (mtx_a,) )[0]
else:
fun = ll.get_lapack_funcs( ['hegv'], arrays = (mtx_a,) )[0]
else:
if mtx_b is None:
fun = ll.get_lapack_funcs( ['syev'], arrays = (mtx_a,) )[0]
else:
fun = ll.get_lapack_funcs( ['sygv'], arrays = (mtx_a,) )[0]
## print fun
if mtx_b is None:
out = fun( mtx_a )
else:
out = fun( mtx_a, mtx_b )
if not eigenvectors:
if n_eigs is None:
out = out[0]
else:
out = out[0][:n_eigs]
else:
if n_eigs is None:
out = out[:-1]
else:
out = (out[0][:n_eigs], out[1][:,:n_eigs])
else:
out = ScipyEigenvalueSolver.__call__( self, mtx_a, mtx_b, n_eigs,
eigenvectors, status = None )
if status is not None:
status['time'] = time.clock() - tt
return out
def __call__(self, mtx_a, mtx_b=None, n_eigs=None, eigenvectors=None,
status=None, conf=None):
"""
Notes
-----
Eigenvectors argument is ignored, as they are computed always.
"""
import scipy.lib.lapack as ll
if (n_eigs is None) or (conf.force_n_eigs):
mtx_a, mtx_b = self._to_array(mtx_a, mtx_b)
if nm.iscomplexobj(mtx_a):
if mtx_b is None:
fun = ll.get_lapack_funcs(['heev'], arrays=(mtx_a,))[0]
else:
fun = ll.get_lapack_funcs(['hegv'], arrays=(mtx_a,))[0]
else:
if mtx_b is None:
fun = ll.get_lapack_funcs(['syev'], arrays=(mtx_a,))[0]
else:
fun = ll.get_lapack_funcs(['sygv'], arrays=(mtx_a,))[0]
if mtx_b is None:
out = fun(mtx_a)
else:
out = fun(mtx_a, mtx_b)
if not eigenvectors:
if n_eigs is None:
out = out[0]
else:
out = out[0][:n_eigs]
else:
if n_eigs is None:
out = out[:-1]
else:
out = (out[0][:n_eigs], out[1][:, :n_eigs])
else:
out = ScipyEigenvalueSolver.call(self, mtx_a, mtx_b, n_eigs,
eigenvectors, status=status)
return out
def __call__(self, mtx_a, mtx_b=None, n_eigs=None, eigenvectors=None,
status=None, conf=None):
"""
Notes
-----
Eigenvectors argument is ignored, as they are computed always.
"""
import scipy.lib.lapack as ll
if (n_eigs is None) or (conf.force_n_eigs):
mtx_a, mtx_b = self._to_array(mtx_a, mtx_b)
if nm.iscomplexobj(mtx_a):
if mtx_b is None:
fun = ll.get_lapack_funcs(['heev'], arrays=(mtx_a,))[0]
else:
fun = ll.get_lapack_funcs(['hegv'], arrays=(mtx_a,))[0]
else:
if mtx_b is None:
fun = ll.get_lapack_funcs(['syev'], arrays=(mtx_a,))[0]
else:
fun = ll.get_lapack_funcs(['sygv'], arrays=(mtx_a,))[0]
if mtx_b is None:
out = fun(mtx_a)
else:
out = fun(mtx_a, mtx_b)
if not eigenvectors:
if n_eigs is None:
out = out[0]
else:
out = out[0][:n_eigs]
else:
if n_eigs is None:
out = out[:-1]
else:
out = (out[0][:n_eigs], out[1][:, :n_eigs])
else:
out = ScipyEigenvalueSolver.call(self, mtx_a, mtx_b, n_eigs,
eigenvectors, status=status)
return out
def _symeig( mtxA, mtxB = None, eigenvectors = True, select = None ):
'''
Solves a symmetric eigenvalue problem as similarly as MATLAB(R) does.
'''
import scipy.linalg as sla
import scipy.lib.lapack as ll
if select is None:
if np.iscomplexobj( mtxA ):
if mtxB is None:
fun = ll.get_lapack_funcs( ['heev'], arrays = (mtxA,) )[0]
else:
fun = ll.get_lapack_funcs( ['hegv'], arrays = (mtxA,) )[0]
else:
if mtxB is None:
fun = ll.get_lapack_funcs( ['syev'], arrays = (mtxA,) )[0]
else:
fun = ll.get_lapack_funcs( ['sygv'], arrays = (mtxA,) )[0]
## print fun
if mtxB is None:
out = fun( mtxA )
else:
out = fun( mtxA, mtxB )
## print w
## print v
## print info
## from _symeig import _symeig
## print _symeig( mtxA, mtxB )
else:
out = sla.eig( mtxA, mtxB, right = eigenvectors )
w = out[0]
ii = np.argsort( w )
w = w[slice( *select )]
if eigenvectors:
v = out[1][:,ii]
v = v[:,slice( *select )]
out = w, v, 0
else:
out = w, 0
return out[:-1]
# ==============================================================================
def symeig(mtxA, mtxB=None, eigenvectors=True, select=None):
import scipy.linalg as sla
import scipy.lib.lapack as ll
if select is None:
if np.iscomplexobj(mtxA):
if mtxB is None:
fun = ll.get_lapack_funcs(['heev'], arrays=(mtxA, ))[0]
else:
fun = ll.get_lapack_funcs(['hegv'], arrays=(mtxA, ))[0]
else:
if mtxB is None:
fun = ll.get_lapack_funcs(['syev'], arrays=(mtxA, ))[0]
else:
fun = ll.get_lapack_funcs(['sygv'], arrays=(mtxA, ))[0]
## print fun
if mtxB is None:
out = fun(mtxA)
else:
out = fun(mtxA, mtxB)
## print w
## print v
## print info
## from symeig import symeig
## print symeig( mtxA, mtxB )
else:
out = sla.eig(mtxA, mtxB, right=eigenvectors)
w = out[0]
ii = np.argsort(w)
w = w[slice(*select)]
if eigenvectors:
v = out[1][:, ii]
v = v[:, slice(*select)]
out = w, v, 0
else:
out = w, 0
return out[:-1]
def symeig( mtxA, mtxB = None, eigenvectors = True, select = None ):
import scipy.linalg as sla
import scipy.lib.lapack as ll
if select is None:
if np.iscomplexobj( mtxA ):
if mtxB is None:
fun = ll.get_lapack_funcs( ['heev'], arrays = (mtxA,) )[0]
else:
fun = ll.get_lapack_funcs( ['hegv'], arrays = (mtxA,) )[0]
else:
if mtxB is None:
fun = ll.get_lapack_funcs( ['syev'], arrays = (mtxA,) )[0]
else:
fun = ll.get_lapack_funcs( ['sygv'], arrays = (mtxA,) )[0]
## print fun
if mtxB is None:
out = fun( mtxA )
else:
out = fun( mtxA, mtxB )
## print w
## print v
## print info
## from symeig import symeig
## print symeig( mtxA, mtxB )
else:
out = sla.eig( mtxA, mtxB, right = eigenvectors )
w = out[0]
ii = np.argsort( w )
w = w[slice( *select )]
if eigenvectors:
v = out[1][:,ii]
v = v[:,slice( *select )]
out = w, v, 0
else:
out = w, 0
return out[:-1]
