def eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False):
"""
Solve an ordinary or generalized eigenvalue problem of a square matrix.
Find eigenvalues w and right or left eigenvectors of a general matrix::
a vr[:,i] = w[i] b vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]
where ``.H`` is the Hermitian conjugation.
Parameters
----------
a : array_like, shape (M, M)
A complex or real matrix whose eigenvalues and eigenvectors
will be computed.
b : array_like, shape (M, M), optional
Right-hand side matrix in a generalized eigenvalue problem.
Default is None, identity matrix is assumed.
left : bool, optional
Whether to calculate and return left eigenvectors. Default is False.
right : bool, optional
Whether to calculate and return right eigenvectors. Default is True.
overwrite_a : bool, optional
Whether to overwrite `a`; may improve performance. Default is False.
overwrite_b : bool, optional
Whether to overwrite `b`; may improve performance. Default is False.
Returns
-------
w : double or complex ndarray
The eigenvalues, each repeated according to its multiplicity.
Of shape (M,).
vl : double or complex ndarray
The normalized left eigenvector corresponding to the eigenvalue
``w[i]`` is the column v[:,i]. Only returned if ``left=True``.
Of shape ``(M, M)``.
vr : double or complex array
The normalized right eigenvector corresponding to the eigenvalue
``w[i]`` is the column ``vr[:,i]``. Only returned if ``right=True``.
Of shape ``(M, M)``.
Raises
------
LinAlgError
If eigenvalue computation does not converge.
See Also
--------
eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
if b is not None:
b1 = asarray_chkfinite(b)
overwrite_b = overwrite_b or _datacopied(b1, b)
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError('expected square matrix')
if b1.shape != a1.shape:
raise ValueError('a and b must have the same shape')
return _geneig(a1, b1, left, right, overwrite_a, overwrite_b)
geev, = get_lapack_funcs(('geev',), (a1,))
compute_vl, compute_vr = left, right
if geev.module_name[:7] == 'flapack':
lwork = calc_lwork.geev(geev.prefix, a1.shape[0],
compute_vl, compute_vr)[1]
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1, lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1, lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr + _I * wi
else: # 'clapack'
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr + _I * wi
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geev'
% -info)
if info > 0:
raise LinAlgError("eig algorithm did not converge (only eigenvalues "
"with order >= %d have converged)" % info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (geev.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def eig(a,b=None, left=False, right=True, overwrite_a=False, overwrite_b=False):
""" Solve ordinary and generalized eigenvalue problem
of a square matrix.
Inputs:
a -- An N x N matrix.
b -- An N x N matrix [default is identity(N)].
left -- Return left eigenvectors [disabled].
right -- Return right eigenvectors [enabled].
overwrite_a, overwrite_b -- save space by overwriting the a and/or
b matrices (both False by default)
Outputs:
w -- eigenvalues [left==right==False].
w,vr -- w and right eigenvectors [left==False,right=True].
w,vl -- w and left eigenvectors [left==True,right==False].
w,vl,vr -- [left==right==True].
Definitions:
a * vr[:,i] = w[i] * b * vr[:,i]
a^H * vl[:,i] = conjugate(w[i]) * b^H * vl[:,i]
where a^H denotes transpose(conjugate(a)).
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
if b is not None:
b = asarray_chkfinite(b)
return _geneig(a1,b,left,right,overwrite_a,overwrite_b)
geev, = get_lapack_funcs(('geev',),(a1,))
compute_vl,compute_vr=left,right
if geev.module_name[:7] == 'flapack':
lwork = calc_lwork.geev(geev.prefix,a1.shape[0],
compute_vl,compute_vr)[1]
if geev.prefix in 'cz':
w,vl,vr,info = geev(a1,lwork = lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr,wi,vl,vr,info = geev(a1,lwork = lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr+_I*wi
else: # 'clapack'
if geev.prefix in 'cz':
w,vl,vr,info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr,wi,vl,vr,info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr+_I*wi
if info<0: raise ValueError,\
'illegal value in %-th argument of internal geev'%(-info)
if info>0: raise LinAlgError,"eig algorithm did not converge"
only_real = numpy.logical_and.reduce(numpy.equal(w.imag,0.0))
if not (geev.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False):
"""Solve an ordinary or generalized eigenvalue problem of a square matrix.
Find eigenvalues w and right or left eigenvectors of a general matrix::
a vr[:,i] = w[i] b vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]
where .H is the Hermitean conjugation.
Parameters
----------
a : array, shape (M, M)
A complex or real matrix whose eigenvalues and eigenvectors
will be computed.
b : array, shape (M, M)
Right-hand side matrix in a generalized eigenvalue problem.
If omitted, identity matrix is assumed.
left : boolean
Whether to calculate and return left eigenvectors
right : boolean
Whether to calculate and return right eigenvectors
overwrite_a : boolean
Whether to overwrite data in a (may improve performance)
overwrite_b : boolean
Whether to overwrite data in b (may improve performance)
Returns
-------
w : double or complex array, shape (M,)
The eigenvalues, each repeated according to its multiplicity.
(if left == True)
vl : double or complex array, shape (M, M)
The normalized left eigenvector corresponding to the eigenvalue w[i]
is the column v[:,i].
(if right == True)
vr : double or complex array, shape (M, M)
The normalized right eigenvector corresponding to the eigenvalue w[i]
is the column vr[:,i].
Raises LinAlgError if eigenvalue computation does not converge
See Also
--------
eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError("expected square matrix")
overwrite_a = overwrite_a or (_datacopied(a1, a))
if b is not None:
b = asarray_chkfinite(b)
if b.shape != a1.shape:
raise ValueError("a and b must have the same shape")
return _geneig(a1, b, left, right, overwrite_a, overwrite_b)
geev, = get_lapack_funcs(("geev",), (a1,))
compute_vl, compute_vr = left, right
if geev.module_name[:7] == "flapack":
lwork = calc_lwork.geev(geev.prefix, a1.shape[0], compute_vl, compute_vr)[1]
if geev.prefix in "cz":
w, vl, vr, info = geev(
a1, lwork=lwork, compute_vl=compute_vl, compute_vr=compute_vr, overwrite_a=overwrite_a
)
else:
wr, wi, vl, vr, info = geev(
a1, lwork=lwork, compute_vl=compute_vl, compute_vr=compute_vr, overwrite_a=overwrite_a
)
t = {"f": "F", "d": "D"}[wr.dtype.char]
w = wr + _I * wi
else: # 'clapack'
if geev.prefix in "cz":
w, vl, vr, info = geev(a1, compute_vl=compute_vl, compute_vr=compute_vr, overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1, compute_vl=compute_vl, compute_vr=compute_vr, overwrite_a=overwrite_a)
t = {"f": "F", "d": "D"}[wr.dtype.char]
w = wr + _I * wi
if info < 0:
raise ValueError("illegal value in %d-th argument of internal geev" % -info)
if info > 0:
raise LinAlgError("eig algorithm did not converge (only eigenvalues " "with order >= %d have converged)" % info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (geev.prefix in "cz" or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def eig(a,
b=None,
left=False,
right=True,
overwrite_a=False,
overwrite_b=False):
"""Solve an ordinary or generalized eigenvalue problem of a square matrix.
Find eigenvalues w and right or left eigenvectors of a general matrix::
a vr[:,i] = w[i] b vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]
where .H is the Hermitean conjugation.
Parameters
----------
a : array, shape (M, M)
A complex or real matrix whose eigenvalues and eigenvectors
will be computed.
b : array, shape (M, M)
Right-hand side matrix in a generalized eigenvalue problem.
If omitted, identity matrix is assumed.
left : boolean
Whether to calculate and return left eigenvectors
right : boolean
Whether to calculate and return right eigenvectors
overwrite_a : boolean
Whether to overwrite data in a (may improve performance)
overwrite_b : boolean
Whether to overwrite data in b (may improve performance)
Returns
-------
w : double or complex array, shape (M,)
The eigenvalues, each repeated according to its multiplicity.
(if left == True)
vl : double or complex array, shape (M, M)
The normalized left eigenvector corresponding to the eigenvalue w[i]
is the column v[:,i].
(if right == True)
vr : double or complex array, shape (M, M)
The normalized right eigenvector corresponding to the eigenvalue w[i]
is the column vr[:,i].
Raises LinAlgError if eigenvalue computation does not converge
See Also
--------
eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datanotshared(a1, a))
if b is not None:
b = asarray_chkfinite(b)
if b.shape != a1.shape:
raise ValueError('a and b must have the same shape')
return _geneig(a1, b, left, right, overwrite_a, overwrite_b)
geev, = get_lapack_funcs(('geev', ), (a1, ))
compute_vl, compute_vr = left, right
if geev.module_name[:7] == 'flapack':
lwork = calc_lwork.geev(geev.prefix, a1.shape[0], compute_vl,
compute_vr)[1]
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1,
lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1,
lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f': 'F', 'd': 'D'}[wr.dtype.char]
w = wr + _I * wi
else: # 'clapack'
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f': 'F', 'd': 'D'}[wr.dtype.char]
w = wr + _I * wi
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geev' %
-info)
if info > 0:
raise LinAlgError("eig algorithm did not converge (only eigenvalues "
"with order >= %d have converged)" % info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (geev.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr