Ñò
\ÐKc @ sÙ d Z d d d d d d d d d d
d d d
d d d d d g Z d d k l Z l Z l Z l Z l Z l Z l Z l
Z
l Z l Z l
Z
l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z l Z d d k l! Z! d d k" l# Z# d d k$ l% Z% e Z& d e' f d „ ƒ YZ( d „ Z) d „ Z* h e e 6e
e
6e e 6e
e 6Z+ h e e 6e e
6e e 6e e 6Z, e
d „ Z- e d „ Z. d „ Z/ h e e 6e e
6e e 6e e 6Z, d „ Z0 e Z1 d „ Z2 d „ Z3 d! „ Z4 d" „ Z5 d# „ Z6 d: d$ „ Z8 d% „ Z9 d& d' „ Z: d( „ Z; d) „ Z< d* d+ „ Z= d, „ Z> d- d. „ Z? d/ „ Z@ d0 „ ZA d- d1 „ ZB d2 d2 d3 „ ZC d: d4 „ ZD d5 d6 „ ZE d7 „ ZF d d8 „ ZG d: d9 „ ZH d: S(; sx Lite version of scipy.linalg.
Notes
-----
This module is a lite version of the linalg.py module in SciPy which
contains high-level Python interface to the LAPACK library. The lite
version only accesses the following LAPACK functions: dgesv, zgesv,
dgeev, zgeev, dgesdd, zgesdd, dgelsd, zgelsd, dsyevd, zheevd, dgetrf,
zgetrf, dpotrf, zpotrf, dgeqrf, zgeqrf, zungqr, dorgqr.
t matrix_powert solvet tensorsolvet tensorinvt invt choleskyt eigvalst eigvalsht pinvt dett svdt eigt eight lstsqt normt qrt condt LinAlgErroriÿÿÿÿ( t arrayt asarrayt zerost emptyt transposet intct singlet doublet csinglet cdoublet inexactt complexfloatingt newaxist ravelt allt Inft dott addt multiplyt identityt sqrtt maximumt flatnonzerot diagonalt aranget fastCopyAndTransposet sumt isfinitet size( t triu( t lapack_lite( R c B s e Z d Z RS( s
Generic Python-exception-derived object raised by linalg functions.
General purpose exception class, derived from Python's exception.Exception
class, programmatically raised in linalg functions when a Linear
Algebra-related condition would prevent further correct execution of the
function.
Parameters
----------
None
Examples
--------
>>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
File "", line 1, in
File "...linalg.py", line 350,
in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
File "...linalg.py", line 249,
in solve
raise LinAlgError, 'Singular matrix'
numpy.linalg.linalg.LinAlgError: Singular matrix
( t __name__t
__module__t __doc__( ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR s c C s+ t | ƒ } t | d | i ƒ } | | f S( Nt __array_prepare__( R t getattrt __array_wrap__( t at newt wrap( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt
_makearray9 s c C s
t | t ƒ S( N( t
issubclassR ( t t( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt
isComplexType> s c C s t i | | ƒ S( N( t _real_types_mapt get( R< t default( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _realTypeK s c C s t i | | ƒ S( N( t _complex_types_mapR? ( R< R@ ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _complexTypeN s c C s t S( s, Cast the type t to either double or cdouble.( R ( R< ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _linalgRealTypeQ s c G sÞ t } t } x¤ | D]œ } t | i i t ƒ oc t | i i ƒ o
t } n t | i i d d ƒ} | d j o t
d | i i f ƒ ‚ q˜ n t } | t j o
t } q q W| o t
} t | } n t } | | f S( NR@ s& array type %s is unsupported in linalg( R t FalseR; t dtypet typeR R= t TrueRA t Nonet TypeErrort nameR R RB ( t arrayst result_typet
is_complexR7 t rtR< ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _commonTypeZ s&
c G s d } xT | D]L } | i i | j o | t | ƒ f } q
| t | i | ƒ ƒ f } q
Wt | ƒ d j o | d S| Sd S( Ni i ( ( RF RG t _fastCTt astypet len( RG RL t cast_arraysR7 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _fastCopyAndTransposev s c G sE x> | D]6 } t | i ƒ d j o t d t | i ƒ ‚ q q Wd S( Ni sE %d-dimensional array given. Array must be two-dimensional( RS t shapeR ( RL R7 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _assertRank2‚ s
c G sA x: | D]2 } t | i ƒ t | i ƒ j o
t d ‚ q q Wd S( Ns Array must be square( t maxRV t minR ( RL R7 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _assertSquarenessˆ s c G s5 x. | D]& } t | ƒ i ƒ p
t d ‚ q q Wd S( Ns# Array must not contain infs or NaNs( R- R R ( RL R7 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt
_assertFinite s c G s8 x1 | D]) } t | ƒ d j o t d ƒ ‚ q q Wd S( Ni s Arrays cannot be empty( R. R ( RL R7 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt _assertNonEmpty’ s c
C sú t | ƒ \ } } t | ƒ } | i } | d j oP t d | ƒ } x+ | D]# } | i | ƒ | i | | ƒ qJ W| i | ƒ } n | i | | i } d } x | D] } | | 9} q¦ W| i d | ƒ } | i
ƒ } | t | | ƒ ƒ } | | _ | S( s
Solve the tensor equation ``a x = b`` for x.
It is assumed that all indices of `x` are summed over in the product,
together with the rightmost indices of `a`, as is done in, for example,
``tensordot(a, x, axes=len(b.shape))``.
Parameters
----------
a : array_like
Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals
the shape of that sub-tensor of `a` consisting of the appropriate
number of its rightmost indices, and must be such that
``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be
'square').
b : array_like
Right-hand tensor, which can be of any shape.
axes : tuple of ints, optional
Axes in `a` to reorder to the right, before inversion.
If None (default), no reordering is done.
Returns
-------
x : ndarray, shape Q
Raises
------
LinAlgError
If `a` is singular or not 'square' (in the above sense).
See Also
--------
tensordot, tensorinv
Examples
--------
>>> a = np.eye(2*3*4)
>>> a.shape = (2*3, 4, 2, 3, 4)
>>> b = np.random.randn(2*3, 4)
>>> x = np.linalg.tensorsolve(a, b)
>>> x.shape
(2, 3, 4)
>>> np.allclose(np.tensordot(a, x, axes=3), b)
True
i i iÿÿÿÿN( R: R t ndimRI t ranget removet insertR RV t reshapeR R (
R7 t bt axesR9 t ant allaxest kt oldshapet prodt res( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR š s( /
c C sˆ t | ƒ \ } } t | ƒ \ } } t | i ƒ d j } | o | d d … t f } n t | | ƒ t | ƒ | i d } | i d } | | i d j o
t d ‚ n t | | ƒ \ } } t | ƒ o
t i
} n
t i } t | | | ƒ \ } } t
| t ƒ }
| | | | | |
| | d ƒ } | d d j o
t d ‚ n | o | | i ƒ i | ƒ ƒ S| | i ƒ i | ƒ ƒ Sd S( sÇ
Solve a linear matrix equation, or system of linear scalar equations.
Computes the "exact" solution, `x`, of the well-determined, i.e., full
rank, linear matrix equation `ax = b`.
Parameters
----------
a : array_like, shape (M, M)
Coefficient matrix.
b : array_like, shape (M,) or (M, N)
Ordinate or "dependent variable" values.
Returns
-------
x : ndarray, shape (M,) or (M, N) depending on b
Solution to the system a x = b
Raises
------
LinAlgError
If `a` is singular or not square.
Notes
-----
`solve` is a wrapper for the LAPACK routines `dgesv`_ and
`zgesv`_, the former being used if `a` is real-valued, the latter if
it is complex-valued. The solution to the system of linear equations
is computed using an LU decomposition [1]_ with partial pivoting and
row interchanges.
.. _dgesv: http://www.netlib.org/lapack/double/dgesv.f
.. _zgesv: http://www.netlib.org/lapack/complex16/zgesv.f
`a` must be square and of full-rank, i.e., all rows (or, equivalently,
columns) must be linearly independent; if either is not true, use
`lstsq` for the least-squares best "solution" of the
system/equation.
References
----------
.. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
FL, Academic Press, Inc., 1980, pg. 22.
Examples
--------
Solve the system of equations ``3 * x0 + x1 = 9`` and ``x0 + 2 * x1 = 8``:
>>> a = np.array([[3,1], [1,2]])
>>> b = np.array([9,8])
>>> x = np.linalg.solve(a, b)
>>> x
array([ 2., 3.])
Check that the solution is correct:
>>> (np.dot(a, x) == b).all()
True
i Ni s Incompatible dimensionst infos Singular matrix( R: RS RV R RW RZ R RP R= R0 t zgesvt dgesvRU R t fortran_intR RR R ( R7 Rb t _R9 t one_eqt n_eqt n_rhsR< t result_tt lapack_routinet pivotst results( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR ß s. >
!
i c C s‘ t | ƒ } | i } d } | d j o5 | | | | } x) | | D] } | | 9} qE Wn
t d ‚ | i | d ƒ } t | ƒ } | i | Œ S( s„
Compute the 'inverse' of an N-dimensional array.
The result is an inverse for `a` relative to the tensordot operation
``tensordot(a, b, ind)``, i. e., up to floating-point accuracy,
``tensordot(tensorinv(a), a, ind)`` is the "identity" tensor for the
tensordot operation.
Parameters
----------
a : array_like
Tensor to 'invert'. Its shape must be 'square', i. e.,
``prod(a.shape[:ind]) == prod(a.shape[ind:])``.
ind : int, optional
Number of first indices that are involved in the inverse sum.
Must be a positive integer, default is 2.
Returns
-------
b : ndarray
`a`'s tensordot inverse, shape ``a.shape[:ind] + a.shape[ind:]``.
Raises
------
LinAlgError
If `a` is singular or not 'square' (in the above sense).
See Also
--------
tensordot, tensorsolve
Examples
--------
>>> a = np.eye(4*6)
>>> a.shape = (4, 6, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=2)
>>> ainv.shape
(8, 3, 4, 6)
>>> b = np.random.randn(4, 6)
>>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))
True
>>> a = np.eye(4*6)
>>> a.shape = (24, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=1)
>>> ainv.shape
(8, 3, 24)
>>> b = np.random.randn(24)
>>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
True
i i s Invalid ind argument.iÿÿÿÿ( R RV t
ValueErrorRa R ( R7 t indRg Rh t invshapeRf t ia( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR 9 s 5
c C s; t | ƒ \ } } | t | t | i d d | i ƒƒ ƒ S( s‡
Compute the (multiplicative) inverse of a matrix.
Given a square matrix `a`, return the matrix `ainv` satisfying
``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.
Parameters
----------
a : array_like, shape (M, M)
Matrix to be inverted.
Returns
-------
ainv : ndarray or matrix, shape (M, M)
(Multiplicative) inverse of the matrix `a`.
Raises
------
LinAlgError
If `a` is singular or not square.
Examples
--------
>>> from numpy import linalg as LA
>>> a = np.array([[1., 2.], [3., 4.]])
>>> ainv = LA.inv(a)
>>> np.allclose(np.dot(a, ainv), np.eye(2))
True
>>> np.allclose(np.dot(ainv, a), np.eye(2))
True
If a is a matrix object, then the return value is a matrix as well:
>>> ainv = LA.inv(np.matrix(a))
>>> ainv
matrix([[-2. , 1. ],
[ 1.5, -0.5]])
i RF ( R: R R% RV RF ( R7 R9 ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR ~ s (c C sÿ t | ƒ \ } } t | ƒ t | ƒ t | ƒ \ } } t | | ƒ } | i d } | i d } t | ƒ o
t i } n
t i } | d | | | d ƒ } | d d j o
t
d ‚ n t | d d ƒi ƒ } | i
| j o | i | ƒ } n | | ƒ S( sS
Cholesky decomposition.
Return the Cholesky decomposition, `L * L.H`, of the square matrix `a`,
where `L` is lower-triangular and .H is the conjugate transpose operator
(which is the ordinary transpose if `a` is real-valued). `a` must be
Hermitian (symmetric if real-valued) and positive-definite. Only `L` is
actually returned.
Parameters
----------
a : array_like, shape (M, M)
Hermitian (symmetric if all elements are real), positive-definite
input matrix.
Returns
-------
L : ndarray, or matrix object if `a` is, shape (M, M)
Lower-triangular Cholesky factor of a.
Raises
------
LinAlgError
If the decomposition fails, for example, if `a` is not
positive-definite.
Notes
-----
The Cholesky decomposition is often used as a fast way of solving
.. math:: A \mathbf{x} = \mathbf{b}
(when `A` is both Hermitian/symmetric and positive-definite).
First, we solve for :math:`\mathbf{y}` in
.. math:: L \mathbf{y} = \mathbf{b},
and then for :math:`\mathbf{x}` in
.. math:: L.H \mathbf{x} = \mathbf{y}.
Examples
--------
>>> A = np.array([[1,-2j],[2j,5]])
>>> A
array([[ 1.+0.j, 0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> L = np.linalg.cholesky(A)
>>> L
array([[ 1.+0.j, 0.+0.j],
[ 0.+2.j, 1.+0.j]])
>>> np.dot(L, L.T.conj()) # verify that L * L.H = A
array([[ 1.+0.j, 0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
>>> np.linalg.cholesky(A) # an ndarray object is returned
array([[ 1.+0.j, 0.+0.j],
[ 0.+2.j, 1.+0.j]])
>>> # But a matrix object is returned if A is a matrix object
>>> LA.cholesky(np.matrix(A))
matrix([[ 1.+0.j, 0.+0.j],
[ 0.+2.j, 1.+0.j]])
i i t LRj sS Matrix is not positive definite - Cholesky decomposition cannot be computedRf ( R: RW RZ RP RU RV R= R0 t zpotrft dpotrfR R/ R RF RR ( R7 R9 R< Rr t mt nRs Ru t s( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR ¬ s$ B
t fullc C sh t | ƒ \ } } t | ƒ | i \ } } t | ƒ \ } } t | | ƒ } t | | ƒ } t | f | ƒ } t | ƒ o t i } d }
n t i
} d }
d } t | f | ƒ } | | | | | | | d d ƒ }
|
d d j o t d |
|
d f ‚ n t t
| d ƒ ƒ } t | f | ƒ } | | | | | | | | d ƒ }
|
d d j o t d |
|
d f ‚ n | d d j o( | | j o | i | ƒ } n | i St | | d d … d | … f ƒ } x1 t | ƒ D]# } | | d | … f i d
ƒ qáW| d d j o | St | ƒ o t i } d }
n t i } d
}
d } t | f | ƒ } | | | | | | | | d d ƒ }
|
d d j o t d |
|
d f ‚ n t t
| d ƒ ƒ } t | f | ƒ } | | | | | | | | | d ƒ }
|
d d j o t d |
|
d f ‚ n t | | d | … d d … f ƒ } | | ƒ | | ƒ f S( s*
Compute the qr factorization of a matrix.
Factor the matrix `a` as `qr`, where `q` is orthonormal
(:math:`dot( q_{:,i}, q_{:,j}) = \delta_{ij}`, the Kronecker delta) and
`r` is upper-triangular.
Parameters
----------
a : array_like, shape (M, N)
Matrix to be factored.
mode : {'full', 'r', 'economic'}
Specifies the information to be returned. 'full' is the default.
mode='r' returns a "true" `r`, while 'economic' returns a "polluted"
`r` (albeit slightly faster; see Returns below).
Returns
-------
* If mode = 'full':
* q : ndarray of float or complex, shape (M, K)
* r : ndarray of float or complex, shape (K, N)
Size K = min(M, N)
* If mode = 'r':
* r : ndarray of float or complex, shape (K, N)
* If mode = 'economic':
* a2 : ndarray of float or complex, shape (M, N)
The diagonal and the upper triangle of a2 contains r,
while the rest of the matrix is undefined.
Raises
------
LinAlgError
If factoring fails.
Notes
-----
This is an interface to the LAPACK routines dgeqrf, zgeqrf,
dorgqr, and zungqr.
For more information on the qr factorization, see for example:
http://en.wikipedia.org/wiki/QR_factorization
Subclasses of `ndarray` are preserved, so if `a` is of type `matrix`,
all the return values will be matrices too.
Examples
--------
>>> a = np.random.randn(9, 6)
>>> q, r = np.linalg.qr(a)
>>> np.allclose(a, np.dot(q, r)) # a does equal qr
True
>>> r2 = np.linalg.qr(a, mode='r')
>>> r3 = np.linalg.qr(a, mode='economic')
>>> np.allclose(r, r2) # mode='r' returns the same r as mode='full'
True
>>> # But only triu parts are guaranteed equal when mode='economic'
>>> np.allclose(r, np.triu(r3[:6,:6], k=0))
True
Example illustrating a common use of `qr`: solving of least squares
problems
What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for
the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points
and you'll see that it should be y0 = 0, m = 1.) The answer is provided
by solving the over-determined matrix equation ``Ax = b``, where::
A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
x = array([[y0], [m]])
b = array([[1], [0], [2], [1]])
If A = qr such that q is orthonormal (which is always possible via
Gram-Schmidt), then ``x = inv(r) * (q.T) * b``. (In numpy practice,
however, we simply use `lstsq`.)
>>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
array([[0, 1],
[1, 1],
[1, 1],
[2, 1]])
>>> b = np.array([1, 0, 2, 1])
>>> q, r = LA.qr(A)
>>> p = np.dot(q.T, b)
>>> np.dot(LA.inv(r), p)
array([ 1.1e-16, 1.0e+00])
t zgeqrft dgeqrfi iÿÿÿÿi Rj s
%s returns %dt eNg t rt zungqrt dorgqr( R: RW RV RP RU RY R R= R0 R R‚ R t intt absRR t TR^ t fillR… R† ( R7 t modeR9 R} R~ R< Rr t mnt tauRs t routine_namet lworkt workRu R„ t it q( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR sb `
!!
%
!
$$%c C s˜ t | ƒ \ } } t | ƒ t | ƒ t | ƒ t | ƒ \ } } t | ƒ } t | | ƒ } | i d } t d | ƒ } t | ƒ o× t
i } t | f | ƒ } t | f | ƒ } d }
t |
f | ƒ } | d d | | | | | d | d | d | d ƒ } t t
| d ƒ ƒ }
t |
f | ƒ } | d d | | | | | d | d | |
| d ƒ } nt
i } t | f | ƒ }
t | f | ƒ } d }
t |
f | ƒ } | d d | | | |
| | d | d | d d ƒ } t | d ƒ }
t |
f | ƒ } | d d | | | |
| | d | d | |
d ƒ } t | d j ƒ o |
} t | ƒ } n |
d | } t | ƒ } | d d j o
t d ‚ n | i | ƒ S(
s†
Compute the eigenvalues of a general matrix.
Main difference between `eigvals` and `eig`: the eigenvectors aren't
returned.
Parameters
----------
a : array_like, shape (M, M)
A complex- or real-valued matrix whose eigenvalues will be computed.
Returns
-------
w : ndarray, shape (M,)
The eigenvalues, each repeated according to its multiplicity.
They are not necessarily ordered, nor are they necessarily
real for real matrices.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eig : eigenvalues and right eigenvectors of general arrays
eigvalsh : eigenvalues of symmetric or Hermitian arrays.
eigh : eigenvalues and eigenvectors of symmetric/Hermitian arrays.
Notes
-----
This is a simple interface to the LAPACK routines dgeev and zgeev
that sets those routines' flags to return only the eigenvalues of
general real and complex arrays, respectively.
Examples
--------
Illustration, using the fact that the eigenvalues of a diagonal matrix
are its diagonal elements, that multiplying a matrix on the left
by an orthogonal matrix, `Q`, and on the right by `Q.T` (the transpose
of `Q`), preserves the eigenvalues of the "middle" matrix. In other words,
if `Q` is orthogonal, then ``Q * A * Q.T`` has the same eigenvalues as
``A``:
>>> from numpy import linalg as LA
>>> x = np.random.random()
>>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])
>>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])
(1.0, 1.0, 0.0)
Now multiply a diagonal matrix by Q on one side and by Q.T on the other:
>>> D = np.diag((-1,1))
>>> LA.eigvals(D)
array([-1., 1.])
>>> A = np.dot(Q, D)
>>> A = np.dot(A, Q.T)
>>> LA.eigvals(A)
array([ 1., -1.])
i i t Niÿÿÿÿg y ð?Rj s Eigenvalues did not converge( i ( R: RW RZ R[ RP RD RU RV R R= R0 t zgeevR‡ Rˆ t dgeevR RA RC R RR ( R7 R9 R< Rr t real_tR~ t dummyRs t wt rworkR R Ru t wrt wi( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR ¯ sP >
"
Rz c C sZ t | ƒ \ } } t | ƒ t | ƒ t | ƒ \ } } t | ƒ } t | | ƒ } | i d } d | d } t | f t ƒ } t | ƒ où t
i } t | f | ƒ }
d } t | f | ƒ } d }
t |
f | ƒ } | d | | | | |
| d | d | | d ƒ
} t t
| d ƒ ƒ } t | f | ƒ } t | d ƒ }
t |
f | ƒ } | d | | | | |
| | | |
| | d ƒ
} nª t
i } t | f | ƒ }
d } t | f | ƒ } | d | | | | |
| d | | d ƒ } t | d ƒ } t | f | ƒ } | d | | | | |
| | | | d ƒ } | d d j o
t d ‚ n |
i | ƒ S( s`
Compute the eigenvalues of a Hermitian or real symmetric matrix.
Main difference from eigh: the eigenvectors are not computed.
Parameters
----------
a : array_like, shape (M, M)
A complex- or real-valued matrix whose eigenvalues are to be
computed.
UPLO : {'L', 'U'}, optional
Specifies whether the calculation is done with the lower triangular
part of `a` ('L', default) or the upper triangular part ('U').
Returns
-------
w : ndarray, shape (M,)
The eigenvalues, not necessarily ordered, each repeated according to
its multiplicity.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigh : eigenvalues and eigenvectors of symmetric/Hermitian arrays.
eigvals : eigenvalues of general real or complex arrays.
eig : eigenvalues and right eigenvectors of general real or complex
arrays.
Notes
-----
This is a simple interface to the LAPACK routines dsyevd and zheevd
that sets those routines' flags to return only the eigenvalues of
real symmetric and complex Hermitian arrays, respectively.
Examples
--------
>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> LA.eigvalsh(a)
array([ 0.17157288+0.j, 5.82842712+0.j])
i i i i R“ iÿÿÿÿRj s Eigenvalues did not converge( R: RW RZ RP RD RU RV R Rm R= R0 t zheevdR‡ Rˆ t dsyevdR RR ( R7 t UPLOR9 R< Rr R– R~ t liworkt iworkRs R˜ R R t lrworkR™ Ru ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR sJ /
c C s4 t | ƒ \ } } t | i | ƒ ƒ } | | | f S( N( RP RQ RR ( R7 R< Rr ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt
_convertarrayo s c C s– t | ƒ \ } } t | ƒ t | ƒ t | ƒ t | ƒ \ } } } t | ƒ } | i d } t d | ƒ } t | ƒ oð t i
} t | f | ƒ } t | | f | ƒ } d }
t |
f | ƒ } t d | f | ƒ } | d d | | | | | d | | | d | d ƒ }
t t | d ƒ ƒ }
t |
f | ƒ } | d d | | | | | d | | | |
| d ƒ }
nát i
} t | f | ƒ } t | f | ƒ } t | | f | ƒ } d }
t |
f | ƒ } | d d | | | | | | d | | | d d ƒ }
t | d ƒ }
t |
f | ƒ } | d d | | | | | | d | | | |
d ƒ }
t | d j ƒ o | } | } t | ƒ } nÐ | d | } t | | i ƒ } t | d j ƒ } xŽ t t | ƒ d ƒ D]v } | | d | d | | d | d | | d | <| | d | d | | d | d | | d | d >> from numpy import linalg as LA
(Almost) trivial example with real e-values and e-vectors.
>>> w, v = LA.eig(np.diag((1, 2, 3)))
>>> w; v
array([ 1., 2., 3.])
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
Real matrix possessing complex e-values and e-vectors; note that the
e-values are complex conjugates of each other.
>>> w, v = LA.eig(np.array([[1, -1], [1, 1]]))
>>> w; v
array([ 1. + 1.j, 1. - 1.j])
array([[ 0.70710678+0.j , 0.70710678+0.j ],
[ 0.00000000-0.70710678j, 0.00000000+0.70710678j]])
Complex-valued matrix with real e-values (but complex-valued e-vectors);
note that a.conj().T = a, i.e., a is Hermitian.
>>> a = np.array([[1, 1j], [-1j, 1]])
>>> w, v = LA.eig(a)
>>> w; v
array([ 2.00000000e+00+0.j, 5.98651912e-36+0.j]) # i.e., {2, 0}
array([[ 0.00000000+0.70710678j, 0.70710678+0.j ],
[ 0.70710678+0.j , 0.00000000+0.70710678j]])
Be careful about round-off error!
>>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])
>>> # Theor. e-values are 1 +/- 1e-9
>>> w, v = LA.eig(a)
>>> w; v
array([ 1., 1.])
array([[ 1., 0.],
[ 0., 1.]])
i i i R“ t Viÿÿÿÿg y ð?Rj s Eigenvalues did not converge( i ( R: RW RZ R[ R¢ RD RV R R= R0 R” R‡ Rˆ R• R RA R RF R( R^ RS RC R R RR ( R7 R9 R< Rr R– R~ R— Rs R˜ t vR R R™ Ru Rš R› t vrRw R‘ t vt( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR x sb l
" 6>
c C s t | ƒ \ } } t | ƒ t | ƒ t | ƒ \ } } t | ƒ } t | | ƒ } | i d } d | d } t | f t ƒ } t | ƒ où t
i } t | f | ƒ }
d } t | f | ƒ } d }
t |
f | ƒ } | d | | | | |
| d | d | | d ƒ
} t t
| d ƒ ƒ } t | f | ƒ } t | d ƒ }
t |
f | ƒ } | d | | | | |
| | | |
| | d ƒ
} nª t
i } t | f | ƒ }
d } t | f | ƒ } | d | | | | |
| d | | d ƒ } t | d ƒ } t | f | ƒ } | d | | | | |
| | | | d ƒ } | d d j o
t d ‚ n | i ƒ i | ƒ } |
i t | ƒ ƒ | | ƒ f S( s§
Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.
Returns two objects, a 1-D array containing the eigenvalues of `a`, and
a 2-D square array or matrix (depending on the input type) of the
corresponding eigenvectors (in columns).
Parameters
----------
a : array_like, shape (M, M)
A complex Hermitian or real symmetric matrix.
UPLO : {'L', 'U'}, optional
Specifies whether the calculation is done with the lower triangular
part of `a` ('L', default) or the upper triangular part ('U').
Returns
-------
w : ndarray, shape (M,)
The eigenvalues, not necessarily ordered.
v : ndarray, or matrix object if `a` is, shape (M, M)
The column ``v[:, i]`` is the normalized eigenvector corresponding
to the eigenvalue ``w[i]``.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigvalsh : eigenvalues of symmetric or Hermitian arrays.
eig : eigenvalues and right eigenvectors for non-symmetric arrays.
eigvals : eigenvalues of non-symmetric arrays.
Notes
-----
This is a simple interface to the LAPACK routines dsyevd and zheevd,
which compute the eigenvalues and eigenvectors of real symmetric and
complex Hermitian arrays, respectively.
The eigenvalues of real symmetric or complex Hermitian matrices are
always real. [1]_ The array `v` of (column) eigenvectors is unitary
and `a`, `w`, and `v` satisfy the equations
``dot(a, v[:, i]) = w[i] * v[:, i]``.
References
----------
.. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
FL, Academic Press, Inc., 1980, pg. 222.
Examples
--------
>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> a
array([[ 1.+0.j, 0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> w, v = LA.eigh(a)
>>> w; v
array([ 0.17157288, 5.82842712])
array([[-0.92387953+0.j , -0.38268343+0.j ],
[ 0.00000000+0.38268343j, 0.00000000-0.92387953j]])
>>> np.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair
array([2.77555756e-17 + 0.j, 0. + 1.38777878e-16j])
>>> np.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair
array([ 0.+0.j, 0.+0.j])
>>> A = np.matrix(a) # what happens if input is a matrix object
>>> A
matrix([[ 1.+0.j, 0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> w, v = LA.eigh(A)
>>> w; v
array([ 0.17157288, 5.82842712])
matrix([[-0.92387953+0.j , -0.38268343+0.j ],
[ 0.00000000+0.38268343j, 0.00000000-0.92387953j]])
i i i i R£ iÿÿÿÿRj s Eigenvalues did not converge( R: RW RZ RP RD RU RV R Rm R= R0 Rœ R‡ Rˆ R R R RR RA ( R7 Rž R9 R< Rr R– R~ RŸ R Rs R˜ R R R¡ R™ Ru t at( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR sL P
i c C st t | ƒ \ } } t | ƒ t | ƒ | i \ } } t | ƒ \ } } t | ƒ } t | | ƒ } t t | | ƒ f | ƒ } | oo | o | }
| } d } n% t | | ƒ }
t | | ƒ } d } t |
| f | ƒ }
t | | f | ƒ } n1 d } d }
d } t d | ƒ }
t d
| ƒ } t d t | | ƒ f t
ƒ } t | ƒ oö t i
} t d t | | ƒ t | | ƒ d t | | ƒ f | ƒ } d } t | f | ƒ } | | | | | | | |
| | | | d | | d ƒ } t t | d ƒ ƒ } t | f | ƒ } | | | | | | | |
| | | | | | | d ƒ } nª t i } d } t | f | ƒ } | | | | | | | |
| | | | d | d ƒ } t | d ƒ } t | f | ƒ } | | | | | | | |
| | | | | | d ƒ } | d d j o
t d
‚ n | i t | ƒ ƒ } | oD |
i ƒ i | ƒ }
| i ƒ i | ƒ } | |
ƒ | | | ƒ f S| Sd S( sa
Singular Value Decomposition.
Factors the matrix `a` into ``u * np.diag(s) * v.H``, where `u` and `v`
are unitary (i.e., ``u.H = inv(u)`` and similarly for `v`), ``.H`` is the
conjugate transpose operator (which is the ordinary transpose for
real-valued matrices), and `s` is a 1-D array of `a`'s singular values.
Parameters
----------
a : array_like
Matrix of shape ``(M, N)`` to decompose.
full_matrices : bool, optional
If True (default), ``u`` and ``v.H`` have the shapes
``(M, M)`` and ``(N, N)``, respectively. Otherwise, the shapes
are ``(M, K)`` and ``(K, N)``, resp., where ``K = min(M, N)``.
compute_uv : bool, optional
Whether or not to compute ``u`` and ``v.H`` in addition to ``s``.
True by default.
Returns
-------
u : ndarray
Unitary matrix. The shape of `U` is ``(M, M)`` or ``(M, K)``
depending on value of `full_matrices`.
s : ndarray
The singular values, sorted so that ``s[i] >= s[i+1]``.
`S` is a 1-D array of length ``min(M, N)``
v.H : ndarray
Unitary matrix of shape ``(N, N)`` or ``(K, N)``, depending
on `full_matrices`.
Raises
------
LinAlgError
If SVD computation does not converge.
Notes
-----
If `a` is a matrix object (as opposed to an `ndarray`), then so are all
the return values.
Examples
--------
>>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
>>> U, s, Vh = np.linalg.svd(a)
>>> U.shape, Vh.shape, s.shape
((9, 9), (6, 6), (6,))
>>> U, s, Vh = np.linalg.svd(a, full_matrices=False)
>>> U.shape, Vh.shape, s.shape
((9, 6), (6, 6), (6,))
>>> S = np.diag(s)
>>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
True
>>> s2 = np.linalg.svd(a, compute_uv=False)
>>> np.allclose(s, s2)
True
t At SR“ i i i iÿÿÿÿi Rj s SVD did not convergeN( i i ( i i ( R: RW R\ RV RP RD RU R RY R Rm R= R0 t zgesddR‡ Rˆ t dgesddR RR RA R ( R7 t
full_matricest
compute_uvR9 R} R~ R< Rr R– R t nut nvtt optiont uR¦ R Rs R™ R R Ru ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR
• sh >
=!! !!
c C s` t | ƒ } | d j o# t | d t ƒ} | d | d St | | ƒ t t | ƒ | ƒ Sd S( s’
Compute the condition number of a matrix.
This function is capable of returning the condition number using
one of seven different norms, depending on the value of `p` (see
Parameters below).
Parameters
----------
x : array_like, shape (M, N)
The matrix whose condition number is sought.
p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional
Order of the norm:
===== ============================
p norm for matrices
===== ============================
None 2-norm, computed directly using the ``SVD``
'fro' Frobenius norm
inf max(sum(abs(x), axis=1))
-inf min(sum(abs(x), axis=1))
1 max(sum(abs(x), axis=0))
-1 min(sum(abs(x), axis=0))
2 2-norm (largest sing. value)
-2 smallest singular value
===== ============================
inf means the numpy.inf object, and the Frobenius norm is
the root-of-sum-of-squares norm.
Returns
-------
c : {float, inf}
The condition number of the matrix. May be infinite.
See Also
--------
numpy.linalg.linalg.norm
Notes
-----
The condition number of `x` is defined as the norm of `x` times the
norm of the inverse of `x` [1]_; the norm can be the usual L2-norm
(root-of-sum-of-squares) or one of a number of other matrix norms.
References
----------
.. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL,
Academic Press, Inc., 1980, pg. 285.
Examples
--------
>>> from numpy import linalg as LA
>>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
>>> a
array([[ 1, 0, -1],
[ 0, 1, 0],
[ 1, 0, 1]])
>>> LA.cond(a)
1.4142135623730951
>>> LA.cond(a, 'fro')
3.1622776601683795
>>> LA.cond(a, np.inf)
2.0
>>> LA.cond(a, -np.inf)
1.0
>>> LA.cond(a, 1)
2.0
>>> LA.cond(a, -1)
1.0
>>> LA.cond(a, 2)
1.4142135623730951
>>> LA.cond(a, -2)
0.70710678118654746
>>> min(LA.svd(a, compute_uv=0))*min(LA.svd(LA.inv(a), compute_uv=0))
0.70710678118654746
R i iÿÿÿÿN( R RI R
RE R R ( t xt pR ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR
s
O
gV瞯Ò>> a = np.random.randn(9, 6)
>>> B = np.linalg.pinv(a)
>>> np.allclose(a, np.dot(a, np.dot(B, a)))
True
>>> np.allclose(B, np.dot(B, np.dot(a, B)))
True
i i g ð?g N(
R: R\ t conjugateR
RV R' t reduceR^ RY R" R R$ R ( R7 t rcondR9 R± R R¦ R} R~ t cutoffR‘ Ri ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR e s ?
4c C s t | ƒ } t | ƒ t | ƒ t | ƒ \ } } t | | ƒ } | i d } t | ƒ o
t i } n
t i } t
| f t ƒ } | | | | | | d ƒ } | d } | d j o
t d ‚ n | d j o d St
i | t d | d ƒ j ƒ d } d d | t i t | ƒ d d
ƒS( sá
Compute the determinant of an array.
Parameters
----------
a : array_like, shape (M, M)
Input array.
Returns
-------
det : ndarray
Determinant of `a`.
Notes
-----
The determinant is computed via LU factorization using the LAPACK
routine z/dgetrf.
Examples
--------
The determinant of a 2-D array [[a, b], [c, d]] is ad - bc:
>>> a = np.array([[1, 2], [3, 4]])
>>> np.linalg.det(a)
-2.0
i Rj s Illegal input to Fortran routineg i i g ð?g @t axisiÿÿÿÿ( R RW RZ RP RU RV R= R0 t zgetrft dgetrfR Rm RJ R# Rµ R* R$ R) ( R7 R< Rr R~ Rs Rt Ru Rj t sign( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR µ s$
&c C sX d d k } t | ƒ \ } } t | ƒ \ } } t | i ƒ d j } | o | d d … t f } n t | | ƒ | i d } | i d } | i d } t | | ƒ }
| | i d j o
t d ‚ n t | | ƒ \ } } t | ƒ }
t
|
| f | ƒ } | i ƒ | d | i d … d | … f M, this is an empty array.
If `b` is 1-dimensional, this is a (1,) shape array.
Otherwise the shape is (K,).
rank : int
Rank of matrix `a`.
s : ndarray, shape (min(M,N),)
Singular values of `a`.
Raises
------
LinAlgError
If computation does not converge.
Notes
-----
If `b` is a matrix, then all array results are returned as matrices.
Examples
--------
Fit a line, ``y = mx + c``, through some noisy data-points:
>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1])
By examining the coefficients, we see that the line should have a
gradient of roughly 1 and cut the y-axis at, more or less, -1.
We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]``
and ``p = [[m], [c]]``. Now use `lstsq` to solve for `p`:
>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0., 1.],
[ 1., 1.],
[ 2., 1.],
[ 3., 1.]])
>>> m, c = np.linalg.lstsq(A, y)[0]
>>> print m, c
1.0 -0.95
Plot the data along with the fitted line:
>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> plt.legend()
>>> plt.show()
iÿÿÿÿNi i s Incompatible dimensionsg @i i Rj s, SVD did not converge in Linear Least SquaresRF t copyt ranki R¸ ( t mathR: RS RV R RW RX R RP RD R R¼ RU RY R‡ t logt floatRm R= R0 t zgelsdRˆ t dgelsdR R RH R, R RR RA ( R7 Rb R¶ R¾ Rn R9 t is_1dR} R~ Rq t ldbR< Rr R– t bstarR t nlvlR Rs R R™ R Ru t a_realt
bstar_realR¡ t residsR² t st( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR
è sz R
)54
" 14 ?(c C s‘ t | ƒ } | d j o' t t i | i ƒ | i ƒ i ƒ ƒ S| i } | d j oï | t j o t
| ƒ i ƒ S| t j o t
| ƒ i ƒ S| d j o | d j i
ƒ S| d j o t
| ƒ i
ƒ S| d j o t | i ƒ | i i
ƒ ƒ Sy | d Wn t j
o t d ‚ n Xt
| ƒ | i
ƒ d | SnI| d j o2| d j o t | d d ƒi ƒ S| d j o t | d d ƒi ƒ S| d j o t
| ƒ i
d d ƒ i ƒ S| t j o t
| ƒ i
d d ƒ i ƒ S| d j o t
| ƒ i
d d ƒ i ƒ S| t j o t
| ƒ i
d d ƒ i ƒ S| d j o' t t i | i ƒ | i i ƒ ƒ ƒ St d ‚ n
t d
‚ d S( s¹
Matrix or vector norm.
This function is able to return one of seven different matrix norms,
or one of an infinite number of vector norms (described below), depending
on the value of the ``ord`` parameter.
Parameters
----------
x : array_like, shape (M,) or (M, N)
Input array.
ord : {non-zero int, inf, -inf, 'fro'}, optional
Order of the norm (see table under ``Notes``). inf means numpy's
`inf` object.
Returns
-------
n : float
Norm of the matrix or vector.
Notes
-----
For values of ``ord <= 0``, the result is, strictly speaking, not a
mathematical 'norm', but it may still be useful for various numerical
purposes.
The following norms can be calculated:
===== ============================ ==========================
ord norm for matrices norm for vectors
===== ============================ ==========================
None Frobenius norm 2-norm
'fro' Frobenius norm --
inf max(sum(abs(x), axis=1)) max(abs(x))
-inf min(sum(abs(x), axis=1)) min(abs(x))
0 -- sum(x != 0)
1 max(sum(abs(x), axis=0)) as below
-1 min(sum(abs(x), axis=0)) as below
2 2-norm (largest sing. value) as below
-2 smallest singular value as below
other -- sum(abs(x)**ord)**(1./ord)
===== ============================ ==========================
The Frobenius norm is given by [1]_:
:math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
References
----------
.. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
Examples
--------
>>> from numpy import linalg as LA
>>> a = np.arange(9) - 4
>>> a
array([-4, -3, -2, -1, 0, 1, 2, 3, 4])
>>> b = a.reshape((3, 3))
>>> b
array([[-4, -3, -2],
[-1, 0, 1],
[ 2, 3, 4]])
>>> LA.norm(a)
7.745966692414834
>>> LA.norm(b)
7.745966692414834
>>> LA.norm(b, 'fro')
7.745966692414834
>>> LA.norm(a, np.inf)
4
>>> LA.norm(b, np.inf)
9
>>> LA.norm(a, -np.inf)
0
>>> LA.norm(b, -np.inf)
2
>>> LA.norm(a, 1)
20
>>> LA.norm(b, 1)
7
>>> LA.norm(a, -1)
-4.6566128774142013e-010
>>> LA.norm(b, -1)
6
>>> LA.norm(a, 2)
7.745966692414834
>>> LA.norm(b, 2)
7.3484692283495345
>>> LA.norm(a, -2)
nan
>>> LA.norm(b, -2)
1.8570331885190563e-016
>>> LA.norm(a, 3)
5.8480354764257312
>>> LA.norm(a, -3)
nan
i i i s Invalid norm order for vectors.g ð?R iþÿÿÿR¸ iÿÿÿÿt frot fs Invalid norm order for matrices.s& Improper number of dimensions to norm.N( RË RÌ ( R RI R& R# Rµ t conjR t realR] R! Rˆ RX RY R, RJ Rv R
( R² t ordt nd( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyR z sJ g
'
'
N(I R3 t __all__t
numpy.coreR R R R R R R R R R R R R R R R! R" R# R$ R% R& R' R( R) R* R+ R, R- R. t numpy.libR/ t numpy.linalgR0 t numpy.matrixlib.defmatrixR Rm t ExceptionR R: R= R> RB RA RC RD RP RQ RU RW RZ R[ R\ RI R R R R R R R R R¢ R R R
R R R R
R ( ( ( s9 /usr/lib64/python2.6/site-packages/numpy/linalg/linalg.pyt
sd ¸
E Z E . X « j V ¢ {x X P 3 ’