def eig(a):
"""
Compute eigenvalues and right eigenvectors of an array.
Parameters
----------
a : array_like, shape (M, M)
A complex or real 2-D array.
Returns
-------
w : ndarray, shape (M,)
The eigenvalues, each repeated according to its multiplicity.
The eigenvalues are not necessarily ordered, nor are they
necessarily real for real matrices.
v : ndarray, shape (M, M)
The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
the column ``v[:,i]``.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
eig : eigenvalues and right eigenvectors for non-symmetric arrays
eigvals : eigenvalues of non-symmetric array.
Notes
-----
This is a simple interface to the LAPACK routines dgeev and zgeev
that compute the eigenvalues and eigenvectors of general real and
complex arrays respectively.
The number `w` is an eigenvalue of a if there exists a vector `v`
satisfying the equation ``dot(a,v) = w*v``. Alternately, if `w` is
a root of the characteristic equation ``det(a - w[i]*I) = 0``, where
`det` is the determinant and `I` is the identity matrix. The arrays
`a`, `w`, and `v` satisfy the equation ``dot(a,v[i]) = w[i]*v[:,i]``.
The array `v` of eigenvectors may not be of maximum rank, that is, some
of the columns may be dependent, although roundoff error may
obscure that fact. If the eigenvalues are all different, then theoretically
the eigenvectors are independent. Likewise, the matrix of eigenvectors
is unitary if the matrix `a` is normal, i.e., if
``dot(a, a.H) = dot(a.H, a)``.
The left and right eigenvectors are not necessarily the (Hermitian)
transposes of each other.
"""
a, wrap = _makearray(a)
_assertRank2(a)
_assertSquareness(a)
_assertFinite(a)
a, t, result_t = _convertarray(a) # convert to double or cdouble type
real_t = _linalgRealType(t)
n = a.shape[0]
dummy = zeros((1,), t)
if isComplexType(t):
# Complex routines take different arguments
lapack_routine = lapack_lite.zgeev
w = zeros((n,), t)
v = zeros((n, n), t)
lwork = 1
work = zeros((lwork,), t)
rwork = zeros((2*n,), real_t)
results = lapack_routine('N', 'V', n, a, n, w,
dummy, 1, v, n, work, -1, rwork, 0)
lwork = int(abs(work[0]))
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, w,
dummy, 1, v, n, work, lwork, rwork, 0)
else:
lapack_routine = lapack_lite.dgeev
wr = zeros((n,), t)
wi = zeros((n,), t)
vr = zeros((n, n), t)
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi,
dummy, 1, vr, n, work, -1, 0)
lwork = int(work[0])
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi,
dummy, 1, vr, n, work, lwork, 0)
if all(wi == 0.0):
w = wr
v = vr
result_t = _realType(result_t)
else:
w = wr+1j*wi
v = array(vr, w.dtype)
ind = flatnonzero(wi != 0.0) # indices of complex e-vals
for i in range(len(ind)/2):
v[ind[2*i]] = vr[ind[2*i]] + 1j*vr[ind[2*i+1]]
v[ind[2*i+1]] = vr[ind[2*i]] - 1j*vr[ind[2*i+1]]
result_t = _complexType(result_t)
if results['info'] > 0:
raise LinAlgError, 'Eigenvalues did not converge'
vt = v.transpose().astype(result_t)
return w.astype(result_t), wrap(vt)
def eig(a):
"""Eigenvalues and right eigenvectors of a general matrix.
A simple interface to the LAPACK routines dgeev and zgeev that compute the
eigenvalues and eigenvectors of general real and complex arrays
respectively.
:Parameters:
a : 2-d array
A complex or real 2-d array whose eigenvalues and eigenvectors
will be computed.
:Returns:
w : 1-d double or complex array
The eigenvalues. The eigenvalues are not necessarily ordered, nor
are they necessarily real for real matrices.
v : 2-d double or complex double array.
The normalized eigenvector corresponding to the eigenvalue w[i] is
the column v[:,i].
:SeeAlso:
- eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
- eig : eigenvalues and right eigenvectors for non-symmetric arrays
- eigvals : eigenvalues of non-symmetric array.
:Notes:
-------
The number w is an eigenvalue of a if there exists a vector v
satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
the characteristic equation det(a - w[i]*I) = 0, where det is the
determinant and I is the identity matrix. The arrays a, w, and v
satisfy the equation dot(a,v[i]) = w[i]*v[:,i].
The array v of eigenvectors may not be of maximum rank, that is, some
of the columns may be dependent, although roundoff error may obscure
that fact. If the eigenvalues are all different, then theoretically the
eigenvectors are independent. Likewise, the matrix of eigenvectors is
unitary if the matrix a is normal, i.e., if dot(a, a.H) = dot(a.H, a).
The left and right eigenvectors are not necessarily the (Hemitian)
transposes of each other.
"""
a, wrap = _makearray(a)
_assertRank2(a)
_assertSquareness(a)
_assertFinite(a)
a, t, result_t = _convertarray(a) # convert to double or cdouble type
real_t = _linalgRealType(t)
n = a.shape[0]
dummy = zeros((1, ), t)
if isComplexType(t):
# Complex routines take different arguments
lapack_routine = lapack_lite.zgeev
w = zeros((n, ), t)
v = zeros((n, n), t)
lwork = 1
work = zeros((lwork, ), t)
rwork = zeros((2 * n, ), real_t)
results = lapack_routine('N', 'V', n, a, n, w, dummy, 1, v, n, work,
-1, rwork, 0)
lwork = int(abs(work[0]))
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, w, dummy, 1, v, n, work,
lwork, rwork, 0)
else:
lapack_routine = lapack_lite.dgeev
wr = zeros((n, ), t)
wi = zeros((n, ), t)
vr = zeros((n, n), t)
lwork = 1
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi, dummy, 1, vr, n,
work, -1, 0)
lwork = int(work[0])
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi, dummy, 1, vr, n,
work, lwork, 0)
if all(wi == 0.0):
w = wr
v = vr
result_t = _realType(result_t)
else:
w = wr + 1j * wi
v = array(vr, w.dtype)
ind = flatnonzero(wi != 0.0) # indices of complex e-vals
for i in range(len(ind) / 2):
v[ind[2 * i]] = vr[ind[2 * i]] + 1j * vr[ind[2 * i + 1]]
v[ind[2 * i + 1]] = vr[ind[2 * i]] - 1j * vr[ind[2 * i + 1]]
result_t = _complexType(result_t)
if results['info'] > 0:
raise LinAlgError, 'Eigenvalues did not converge'
vt = v.transpose().astype(result_t)
return w.astype(result_t), wrap(vt)
def eig(a):
"""
Compute eigenvalues and right eigenvectors of an array.
Parameters
----------
a : array_like, shape (M, M)
A complex or real 2-D array.
Returns
-------
w : ndarray, shape (M,)
The eigenvalues, each repeated according to its multiplicity.
The eigenvalues are not necessarily ordered, nor are they
necessarily real for real matrices.
v : ndarray, shape (M, M)
The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
the column ``v[:,i]``.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
eig : eigenvalues and right eigenvectors for non-symmetric arrays
eigvals : eigenvalues of non-symmetric array.
Notes
-----
This is a simple interface to the LAPACK routines dgeev and zgeev
that compute the eigenvalues and eigenvectors of general real and
complex arrays respectively.
The number `w` is an eigenvalue of a if there exists a vector `v`
satisfying the equation ``dot(a,v) = w*v``. Alternately, if `w` is
a root of the characteristic equation ``det(a - w[i]*I) = 0``, where
`det` is the determinant and `I` is the identity matrix. The arrays
`a`, `w`, and `v` satisfy the equation ``dot(a,v[i]) = w[i]*v[:,i]``.
The array `v` of eigenvectors may not be of maximum rank, that is, some
of the columns may be dependent, although roundoff error may
obscure that fact. If the eigenvalues are all different, then theoretically
the eigenvectors are independent. Likewise, the matrix of eigenvectors
is unitary if the matrix `a` is normal, i.e., if
``dot(a, a.H) = dot(a.H, a)``.
The left and right eigenvectors are not necessarily the (Hermitian)
transposes of each other.
"""
a, wrap = _makearray(a)
_assertRank2(a)
_assertSquareness(a)
_assertFinite(a)
a, t, result_t = _convertarray(a) # convert to double or cdouble type
real_t = _linalgRealType(t)
n = a.shape[0]
dummy = zeros((1, ), t)
if isComplexType(t):
# Complex routines take different arguments
lapack_routine = lapack_lite.zgeev
w = zeros((n, ), t)
v = zeros((n, n), t)
lwork = 1
work = zeros((lwork, ), t)
rwork = zeros((2 * n, ), real_t)
results = lapack_routine('N', 'V', n, a, n, w, dummy, 1, v, n, work,
-1, rwork, 0)
lwork = int(abs(work[0]))
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, w, dummy, 1, v, n, work,
lwork, rwork, 0)
else:
lapack_routine = lapack_lite.dgeev
wr = zeros((n, ), t)
wi = zeros((n, ), t)
vr = zeros((n, n), t)
lwork = 1
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi, dummy, 1, vr, n,
work, -1, 0)
lwork = int(work[0])
work = zeros((lwork, ), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi, dummy, 1, vr, n,
work, lwork, 0)
if all(wi == 0.0):
w = wr
v = vr
result_t = _realType(result_t)
else:
w = wr + 1j * wi
v = array(vr, w.dtype)
ind = flatnonzero(wi != 0.0) # indices of complex e-vals
for i in range(len(ind) / 2):
v[ind[2 * i]] = vr[ind[2 * i]] + 1j * vr[ind[2 * i + 1]]
v[ind[2 * i + 1]] = vr[ind[2 * i]] - 1j * vr[ind[2 * i + 1]]
result_t = _complexType(result_t)
if results['info'] > 0:
raise LinAlgError, 'Eigenvalues did not converge'
vt = v.transpose().astype(result_t)
return w.astype(result_t), wrap(vt)
def eig(a):
"""Eigenvalues and right eigenvectors of a general matrix.
A simple interface to the LAPACK routines dgeev and zgeev that compute the
eigenvalues and eigenvectors of general real and complex arrays
respectively.
:Parameters:
a : 2-d array
A complex or real 2-d array whose eigenvalues and eigenvectors
will be computed.
:Returns:
w : 1-d double or complex array
The eigenvalues. The eigenvalues are not necessarily ordered, nor
are they necessarily real for real matrices.
v : 2-d double or complex double array.
The normalized eigenvector corresponding to the eigenvalue w[i] is
the column v[:,i].
:SeeAlso:
- eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
- eig : eigenvalues and right eigenvectors for non-symmetric arrays
- eigvals : eigenvalues of non-symmetric array.
:Notes:
-------
The number w is an eigenvalue of a if there exists a vector v
satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
the characteristic equation det(a - w[i]*I) = 0, where det is the
determinant and I is the identity matrix. The arrays a, w, and v
satisfy the equation dot(a,v[i]) = w[i]*v[:,i].
The array v of eigenvectors may not be of maximum rank, that is, some
of the columns may be dependent, although roundoff error may obscure
that fact. If the eigenvalues are all different, then theoretically the
eigenvectors are independent. Likewise, the matrix of eigenvectors is
unitary if the matrix a is normal, i.e., if dot(a, a.H) = dot(a.H, a).
The left and right eigenvectors are not necessarily the (Hemitian)
transposes of each other.
"""
a, wrap = _makearray(a)
_assertRank2(a)
_assertSquareness(a)
_assertFinite(a)
a, t, result_t = _convertarray(a) # convert to double or cdouble type
real_t = _linalgRealType(t)
n = a.shape[0]
dummy = zeros((1,), t)
if isComplexType(t):
# Complex routines take different arguments
lapack_routine = lapack_lite.zgeev
w = zeros((n,), t)
v = zeros((n, n), t)
lwork = 1
work = zeros((lwork,), t)
rwork = zeros((2*n,), real_t)
results = lapack_routine('N', 'V', n, a, n, w,
dummy, 1, v, n, work, -1, rwork, 0)
lwork = int(abs(work[0]))
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, w,
dummy, 1, v, n, work, lwork, rwork, 0)
else:
lapack_routine = lapack_lite.dgeev
wr = zeros((n,), t)
wi = zeros((n,), t)
vr = zeros((n, n), t)
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi,
dummy, 1, vr, n, work, -1, 0)
lwork = int(work[0])
work = zeros((lwork,), t)
results = lapack_routine('N', 'V', n, a, n, wr, wi,
dummy, 1, vr, n, work, lwork, 0)
if all(wi == 0.0):
w = wr
v = vr
result_t = _realType(result_t)
else:
w = wr+1j*wi
v = array(vr, w.dtype)
ind = flatnonzero(wi != 0.0) # indices of complex e-vals
for i in range(len(ind)/2):
v[ind[2*i]] = vr[ind[2*i]] + 1j*vr[ind[2*i+1]]
v[ind[2*i+1]] = vr[ind[2*i]] - 1j*vr[ind[2*i+1]]
result_t = _complexType(result_t)
if results['info'] > 0:
raise LinAlgError, 'Eigenvalues did not converge'
vt = v.transpose().astype(result_t)
return w.astype(result_t), wrap(vt)
