numpy.linalg.linalg
index
/usr/lib/python2.6/dist-packages/numpy/linalg/linalg.py

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.

 
Modules
       
numpy.linalg.lapack_lite

 
Classes
       
Exception(BaseException)
LinAlgError

 
class LinAlgError(Exception)
    # Error object
 
 
Method resolution order:
LinAlgError
Exception
BaseException
object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from Exception:
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Data and other attributes inherited from Exception:
__new__ = <built-in method __new__ of type object at 0x8108c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from BaseException:
__dict__
args
message

 
Functions
       
_assertFinite(*arrays)
_assertNonEmpty(*arrays)
_assertRank2(*arrays)
_assertSquareness(*arrays)
_commonType(*arrays)
_complexType(t, default=<type 'numpy.complex128'>)
_convertarray(a)
_fastCT = _fastCopyAndTranspose(...)
_fastCopyAndTranspose(a)
_fastCopyAndTranspose(type, *arrays)
_linalgRealType(t)
Cast the type t to either double or cdouble.
_makearray(a)
_realType(t, default=<type 'numpy.float64'>)
cholesky(a)
Cholesky decomposition.
 
Return the Cholesky decomposition, :math:`A = L L^*` of a Hermitian
positive-definite matrix :math:`A`.
 
Parameters
----------
a : array_like, shape (M, M)
    Hermitian (symmetric, if it is real) and positive definite
    input matrix.
 
Returns
-------
L : array_like, shape (M, M)
    Lower-triangular Cholesky factor of A.
 
Raises
------
LinAlgError
   If the decomposition fails.
 
Notes
-----
The Cholesky decomposition is often used as a fast way of solving
 
.. math:: A \mathbf{x} = \mathbf{b}.
 
First, we solve for :math:`\mathbf{y}` in
 
.. math:: L \mathbf{y} = \mathbf{b},
 
and then for :math:`\mathbf{x}` in
 
.. math:: L^* \mathbf{x} = \mathbf{y}.
 
Examples
--------
>>> A = np.array([[1,-2j],[2j,5]])
>>> 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())
array([[ 1.+0.j,  0.-2.j],
       [ 0.+2.j,  5.+0.j]])
cond(x, p=None)
Compute the condition number of a matrix.
 
The condition number of `x` is the norm of `x` times the norm
of the inverse of `x`.  The norm can be the usual L2
(root-of-sum-of-squares) norm or a number of other matrix norms.
 
Parameters
----------
x : array_like, shape (M, N)
    The matrix whose condition number is sought.
p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}
    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
    =====  ============================
 
Returns
-------
c : float
    The condition number of the matrix. May be infinite.
det(a)
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
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.
eigh(a, UPLO='L')
Eigenvalues and eigenvectors of a Hermitian or real symmetric matrix.
 
Parameters
----------
a : array_like, shape (M, M)
    A complex Hermitian or symmetric real matrix.
UPLO : {'L', 'U'}, optional
    Specifies whether the calculation is done with data from the
    lower triangular part of `a` ('L', default) or the upper triangular
    part ('U').
 
Returns
-------
w : ndarray, shape (M,)
    The eigenvalues. The eigenvalues are not necessarily ordered.
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
-----
A simple interface to the LAPACK routines dsyevd and zheevd that compute
the eigenvalues and eigenvectors of real symmetric and complex Hermitian
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 eigenvalues of real
symmetric or complex Hermitean matrices are always real. The array v
of eigenvectors is unitary and a, w, and v satisfy the equation
dot(a,v[i]) = w[i]*v[:,i].
eigvals(a)
Compute the eigenvalues of a general matrix.
 
Parameters
----------
a : array_like, shape (M, M)
    A complex or real matrix whose eigenvalues and eigenvectors
    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 Hemitiean arrays.
eigh : eigenvalues and eigenvectors of symmetric/Hermitean arrays.
 
Notes
-----
This is a simple interface to the LAPACK routines dgeev and zgeev
that sets the flags to return only the eigenvalues 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.
eigvalsh(a, UPLO='L')
Compute the eigenvalues of a Hermitean or real symmetric matrix.
 
Parameters
----------
a : array_like, shape (M, M)
    A complex or real matrix whose eigenvalues and eigenvectors
    will be computed.
UPLO : {'L', 'U'}, optional
    Specifies whether the calculation is done with data from the
    lower triangular part of `a` ('L', default) or the upper triangular
    part ('U').
 
Returns
-------
w : ndarray, shape (M,)
    The eigenvalues, each repeated according to its multiplicity.
    They are not necessarily ordered.
 
Raises
------
LinAlgError
    If the eigenvalue computation does not converge.
 
See Also
--------
eigh : eigenvalues and eigenvectors of symmetric/Hermitean arrays.
eigvals : eigenvalues of general real or complex arrays.
eig : eigenvalues and eigenvectors of general real or complex arrays.
 
Notes
-----
This is a simple interface to the LAPACK routines dsyevd and
zheevd that sets the flags to return only the eigenvalues of real
symmetric and complex Hermetian 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.
inv(a)
Compute the inverse of a matrix.
 
Parameters
----------
a : array_like, shape (M, M)
    Matrix to be inverted
 
Returns
-------
ainv : ndarray, shape (M, M)
    Inverse of the matrix `a`
 
Raises
------
LinAlgError
    If `a` is singular or not square.
 
Examples
--------
>>> a = np.array([[1., 2.], [3., 4.]])
>>> np.linalg.inv(a)
array([[-2. ,  1. ],
       [ 1.5, -0.5]])
>>> np.dot(a, np.linalg.inv(a))
array([[ 1.,  0.],
       [ 0.,  1.]])
isComplexType(t)
lstsq(a, b, rcond=-1)
Return the least-squares solution to an equation.
 
Solves the equation `a x = b` by computing a vector `x` that minimizes
the norm `|| b - a x ||`.
 
Parameters
----------
a : array_like, shape (M, N)
    Input equation coefficients.
b : array_like, shape (M,) or (M, K)
    Equation target values.  If `b` is two-dimensional, the least
    squares solution is calculated for each of the `K` target sets.
rcond : float, optional
    Cutoff for ``small`` singular values of `a`.
    Singular values smaller than `rcond` times the largest singular
    value are  considered zero.
 
Returns
-------
x : ndarray, shape(N,) or (N, K)
     Least squares solution.  The shape of `x` depends on the shape of
     `b`.
residues : ndarray, shape(), (1,), or (K,)
    Sums of residues; squared Euclidian norm for each column in
    `b - a x`.
    If the rank of `a` is < N or > M, this is an empty array.
    If `b` is 1-dimensional, this is a (1,) shape array.
    Otherwise the shape is (K,).
rank : integer
    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 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 cuts 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()
norm(x, ord=None)
Matrix or vector norm.
 
Parameters
----------
x : array_like, shape (M,) or (M, N)
    Input array.
ord : {2, int, inf, -inf, 'fro'}
    Order of the norm (see table under ``Notes``).
 
Returns
-------
n : float
    Norm of the matrix or vector
 
Notes
-----
For values ord < 0, the result is, strictly speaking, not a
mathematical 'norm', but it may still be useful for 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))
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)
=====  ============================  ==========================
pinv(a, rcond=1.0000000000000001e-15)
Compute the (Moore-Penrose) pseudo-inverse of a matrix.
 
Calculate the generalized inverse of a matrix using its
singular-value decomposition (SVD) and including all
`large` singular values.
 
Parameters
----------
a : array_like (M, N)
  Matrix to be pseudo-inverted.
rcond : float
  Cutoff for `small` singular values.
  Singular values smaller than rcond*largest_singular_value are
  considered zero.
 
Returns
-------
B : ndarray (N, M)
  The pseudo-inverse of `a`. If `a` is an np.matrix instance, then so
  is `B`.
 
 
Raises
------
LinAlgError
  In case SVD computation does not converge.
 
Examples
--------
>>> 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
qr(a, mode='full')
Compute QR decomposition of a matrix.
 
Calculate the decomposition :math:`A = Q R` where Q is orthonormal
and R upper triangular.
 
Parameters
----------
a : array_like, shape (M, N)
    Matrix to be decomposed
mode : {'full', 'r', 'economic'}
    Determines what information is to be returned. 'full' is the default.
    Economic mode is slightly faster if only R is needed.
 
Returns
-------
mode = 'full'
Q : double or complex array, shape (M, K)
R : double or complex array, shape (K, N)
    Size K = min(M, N)
 
mode = 'r'
R : double or complex array, shape (K, N)
 
mode = 'economic'
A2 : double or complex array, shape (M, N)
    The diagonal and the upper triangle of A2 contains R,
    while the rest of the matrix is undefined.
 
If a is a matrix, so are all the return values.
 
Raises LinAlgError if decomposition fails
 
Notes
-----
This is an interface to the LAPACK routines dgeqrf, zgeqrf,
dorgqr, and zungqr.
 
Examples
--------
>>> a = np.random.randn(9, 6)
>>> q, r = np.linalg.qr(a)
>>> np.allclose(a, np.dot(q, r))
True
>>> r2 = np.linalg.qr(a, mode='r')
>>> r3 = np.linalg.qr(a, mode='economic')
>>> np.allclose(r, r2)
True
>>> np.allclose(r, np.triu(r3[:6,:6], k=0))
True
solve(a, b)
Solve the equation ``a x = b`` for ``x``.
 
Parameters
----------
a : array_like, shape (M, M)
    Input equation coefficients.
b : array_like, shape (M,)
    Equation target values.
 
Returns
-------
x : array, shape (M,)
 
Raises
------
LinAlgError
    If `a` is singular or not square.
 
Notes
-----
 
``linalg.solve`` is a wrapper to the LAPACK http://www.netlib.org/lapack
routines `dgesv`_ and `zgesv`_.  The solution to the system of linear
equations is computed using an LU decomposition with partial pivoting and
row interchanges.
 
.. _dgesv: http://www.netlib.org/lapack/double/dgesv.f
 
.. _zgesv: http://www.netlib.org/lapack/complex16/zgesv.f
 
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
svd(a, full_matrices=1, compute_uv=1)
Singular Value Decomposition.
 
Factorizes the matrix `a` into two unitary matrices, ``U`` and ``Vh``,
and a 1-dimensional array of singular values, ``s`` (real, non-negative),
such that ``a == U S Vh``, where ``S`` is the diagonal
matrix ``np.diag(s)``.
 
Parameters
----------
a : array_like, shape (M, N)
    Matrix to decompose
full_matrices : boolean, optional
    If True (default), ``U`` and ``Vh`` are shaped
    ``(M,M)`` and ``(N,N)``.  Otherwise, the shapes are
    ``(M,K)`` and ``(K,N)``, where ``K = min(M,N)``.
compute_uv : boolean
    Whether to compute ``U`` and ``Vh`` in addition to ``s``.
    True by default.
 
Returns
-------
U : ndarray, shape (M, M) or (M, K) depending on `full_matrices`
    Unitary matrix.
s :  ndarray, shape (K,) where ``K = min(M, N)``
    The singular values, sorted so that ``s[i] >= s[i+1]``.
Vh : ndarray, shape (N,N) or (K,N) depending on `full_matrices`
    Unitary matrix.
 
Raises
------
LinAlgError
    If SVD computation does not converge.
 
Notes
-----
If `a` is a matrix (in contrast 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
tensorinv(a, ind=2)
Find the 'inverse' of a N-d array
 
The result is an inverse corresponding to the operation
tensordot(a, b, ind), ie.,
 
    x == tensordot(tensordot(tensorinv(a), a, ind), x, ind)
      == tensordot(tensordot(a, tensorinv(a), ind), x, ind)
 
for all x (up to floating-point accuracy).
 
Parameters
----------
a : array_like
    Tensor to 'invert'. Its shape must 'square', ie.,
    prod(a.shape[:ind]) == prod(a.shape[ind:])
ind : integer > 0
    How many of the first indices are involved in the inverse sum.
 
Returns
-------
b : array, shape a.shape[:ind]+a.shape[ind:]
 
Raises LinAlgError if a is singular or not square
 
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
tensorsolve(a, b, axes=None)
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, similarly as in
tensordot(a, x, axes=len(b.shape)).
 
Parameters
----------
a : array_like, shape b.shape+Q
    Coefficient tensor. Shape Q of the rightmost indices of a must
    be such that a is 'square', ie., prod(Q) == prod(b.shape).
b : array_like, any shape
    Right-hand tensor.
axes : tuple of integers
    Axes in a to reorder to the right, before inversion.
    If None (default), no reordering is done.
 
Returns
-------
x : array, shape Q
 
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

 
Data
        __all__ = ['matrix_power', 'solve', 'tensorsolve', 'tensorinv', 'inv', 'cholesky', 'eigvals', 'eigvalsh', 'pinv', 'det', 'svd', 'eig', 'eigh', 'lstsq', 'norm', 'qr', 'cond', 'LinAlgError']
__file__ = '/usr/lib/python2.6/dist-packages/numpy/linalg/linalg.pyc'
__name__ = 'numpy.linalg.linalg'
__package__ = 'numpy.linalg'
_complex_types_map = {<type 'numpy.float32'>: <type 'numpy.complex64'>, <type 'numpy.float64'>: <type 'numpy.complex128'>, <type 'numpy.complex64'>: <type 'numpy.complex64'>, <type 'numpy.complex128'>: <type 'numpy.complex128'>}
_real_types_map = {<type 'numpy.float32'>: <type 'numpy.float32'>, <type 'numpy.float64'>: <type 'numpy.float64'>, <type 'numpy.complex64'>: <type 'numpy.float32'>, <type 'numpy.complex128'>: <type 'numpy.float64'>}