You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2721 lines
83 KiB
Python
2721 lines
83 KiB
Python
"""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.
|
|
"""
|
|
from __future__ import division, absolute_import, print_function
|
|
|
|
|
|
__all__ = ['matrix_power', 'solve', 'tensorsolve', 'tensorinv', 'inv',
|
|
'cholesky', 'eigvals', 'eigvalsh', 'pinv', 'slogdet', 'det',
|
|
'svd', 'eig', 'eigh', 'lstsq', 'norm', 'qr', 'cond', 'matrix_rank',
|
|
'LinAlgError', 'multi_dot']
|
|
|
|
import functools
|
|
import operator
|
|
import warnings
|
|
|
|
from numpy.core import (
|
|
array, asarray, zeros, empty, empty_like, intc, single, double,
|
|
csingle, cdouble, inexact, complexfloating, newaxis, all, Inf, dot,
|
|
add, multiply, sqrt, fastCopyAndTranspose, sum, isfinite,
|
|
finfo, errstate, geterrobj, moveaxis, amin, amax, product, abs,
|
|
atleast_2d, intp, asanyarray, object_, matmul,
|
|
swapaxes, divide, count_nonzero, isnan
|
|
)
|
|
from numpy.core.multiarray import normalize_axis_index
|
|
from numpy.core.overrides import set_module
|
|
from numpy.core import overrides
|
|
from numpy.lib.twodim_base import triu, eye
|
|
from numpy.linalg import lapack_lite, _umath_linalg
|
|
|
|
|
|
array_function_dispatch = functools.partial(
|
|
overrides.array_function_dispatch, module='numpy.linalg')
|
|
|
|
|
|
# For Python2/3 compatibility
|
|
_N = b'N'
|
|
_V = b'V'
|
|
_A = b'A'
|
|
_S = b'S'
|
|
_L = b'L'
|
|
|
|
fortran_int = intc
|
|
|
|
|
|
@set_module('numpy.linalg')
|
|
class LinAlgError(Exception):
|
|
"""
|
|
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 "<stdin>", line 1, in <module>
|
|
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.LinAlgError: Singular matrix
|
|
|
|
"""
|
|
|
|
|
|
def _determine_error_states():
|
|
errobj = geterrobj()
|
|
bufsize = errobj[0]
|
|
|
|
with errstate(invalid='call', over='ignore',
|
|
divide='ignore', under='ignore'):
|
|
invalid_call_errmask = geterrobj()[1]
|
|
|
|
return [bufsize, invalid_call_errmask, None]
|
|
|
|
# Dealing with errors in _umath_linalg
|
|
_linalg_error_extobj = _determine_error_states()
|
|
del _determine_error_states
|
|
|
|
def _raise_linalgerror_singular(err, flag):
|
|
raise LinAlgError("Singular matrix")
|
|
|
|
def _raise_linalgerror_nonposdef(err, flag):
|
|
raise LinAlgError("Matrix is not positive definite")
|
|
|
|
def _raise_linalgerror_eigenvalues_nonconvergence(err, flag):
|
|
raise LinAlgError("Eigenvalues did not converge")
|
|
|
|
def _raise_linalgerror_svd_nonconvergence(err, flag):
|
|
raise LinAlgError("SVD did not converge")
|
|
|
|
def _raise_linalgerror_lstsq(err, flag):
|
|
raise LinAlgError("SVD did not converge in Linear Least Squares")
|
|
|
|
def get_linalg_error_extobj(callback):
|
|
extobj = list(_linalg_error_extobj) # make a copy
|
|
extobj[2] = callback
|
|
return extobj
|
|
|
|
def _makearray(a):
|
|
new = asarray(a)
|
|
wrap = getattr(a, "__array_prepare__", new.__array_wrap__)
|
|
return new, wrap
|
|
|
|
def isComplexType(t):
|
|
return issubclass(t, complexfloating)
|
|
|
|
_real_types_map = {single : single,
|
|
double : double,
|
|
csingle : single,
|
|
cdouble : double}
|
|
|
|
_complex_types_map = {single : csingle,
|
|
double : cdouble,
|
|
csingle : csingle,
|
|
cdouble : cdouble}
|
|
|
|
def _realType(t, default=double):
|
|
return _real_types_map.get(t, default)
|
|
|
|
def _complexType(t, default=cdouble):
|
|
return _complex_types_map.get(t, default)
|
|
|
|
def _linalgRealType(t):
|
|
"""Cast the type t to either double or cdouble."""
|
|
return double
|
|
|
|
def _commonType(*arrays):
|
|
# in lite version, use higher precision (always double or cdouble)
|
|
result_type = single
|
|
is_complex = False
|
|
for a in arrays:
|
|
if issubclass(a.dtype.type, inexact):
|
|
if isComplexType(a.dtype.type):
|
|
is_complex = True
|
|
rt = _realType(a.dtype.type, default=None)
|
|
if rt is None:
|
|
# unsupported inexact scalar
|
|
raise TypeError("array type %s is unsupported in linalg" %
|
|
(a.dtype.name,))
|
|
else:
|
|
rt = double
|
|
if rt is double:
|
|
result_type = double
|
|
if is_complex:
|
|
t = cdouble
|
|
result_type = _complex_types_map[result_type]
|
|
else:
|
|
t = double
|
|
return t, result_type
|
|
|
|
|
|
# _fastCopyAndTranpose assumes the input is 2D (as all the calls in here are).
|
|
|
|
_fastCT = fastCopyAndTranspose
|
|
|
|
def _to_native_byte_order(*arrays):
|
|
ret = []
|
|
for arr in arrays:
|
|
if arr.dtype.byteorder not in ('=', '|'):
|
|
ret.append(asarray(arr, dtype=arr.dtype.newbyteorder('=')))
|
|
else:
|
|
ret.append(arr)
|
|
if len(ret) == 1:
|
|
return ret[0]
|
|
else:
|
|
return ret
|
|
|
|
def _fastCopyAndTranspose(type, *arrays):
|
|
cast_arrays = ()
|
|
for a in arrays:
|
|
if a.dtype.type is type:
|
|
cast_arrays = cast_arrays + (_fastCT(a),)
|
|
else:
|
|
cast_arrays = cast_arrays + (_fastCT(a.astype(type)),)
|
|
if len(cast_arrays) == 1:
|
|
return cast_arrays[0]
|
|
else:
|
|
return cast_arrays
|
|
|
|
def _assertRank2(*arrays):
|
|
for a in arrays:
|
|
if a.ndim != 2:
|
|
raise LinAlgError('%d-dimensional array given. Array must be '
|
|
'two-dimensional' % a.ndim)
|
|
|
|
def _assertRankAtLeast2(*arrays):
|
|
for a in arrays:
|
|
if a.ndim < 2:
|
|
raise LinAlgError('%d-dimensional array given. Array must be '
|
|
'at least two-dimensional' % a.ndim)
|
|
|
|
def _assertNdSquareness(*arrays):
|
|
for a in arrays:
|
|
m, n = a.shape[-2:]
|
|
if m != n:
|
|
raise LinAlgError('Last 2 dimensions of the array must be square')
|
|
|
|
def _assertFinite(*arrays):
|
|
for a in arrays:
|
|
if not (isfinite(a).all()):
|
|
raise LinAlgError("Array must not contain infs or NaNs")
|
|
|
|
def _isEmpty2d(arr):
|
|
# check size first for efficiency
|
|
return arr.size == 0 and product(arr.shape[-2:]) == 0
|
|
|
|
def _assertNoEmpty2d(*arrays):
|
|
for a in arrays:
|
|
if _isEmpty2d(a):
|
|
raise LinAlgError("Arrays cannot be empty")
|
|
|
|
def transpose(a):
|
|
"""
|
|
Transpose each matrix in a stack of matrices.
|
|
|
|
Unlike np.transpose, this only swaps the last two axes, rather than all of
|
|
them
|
|
|
|
Parameters
|
|
----------
|
|
a : (...,M,N) array_like
|
|
|
|
Returns
|
|
-------
|
|
aT : (...,N,M) ndarray
|
|
"""
|
|
return swapaxes(a, -1, -2)
|
|
|
|
# Linear equations
|
|
|
|
def _tensorsolve_dispatcher(a, b, axes=None):
|
|
return (a, b)
|
|
|
|
|
|
@array_function_dispatch(_tensorsolve_dispatcher)
|
|
def 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`, as is done in, for example,
|
|
``tensordot(a, x, axes=b.ndim)``.
|
|
|
|
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
|
|
--------
|
|
numpy.tensordot, tensorinv, numpy.einsum
|
|
|
|
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
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
b = asarray(b)
|
|
an = a.ndim
|
|
|
|
if axes is not None:
|
|
allaxes = list(range(0, an))
|
|
for k in axes:
|
|
allaxes.remove(k)
|
|
allaxes.insert(an, k)
|
|
a = a.transpose(allaxes)
|
|
|
|
oldshape = a.shape[-(an-b.ndim):]
|
|
prod = 1
|
|
for k in oldshape:
|
|
prod *= k
|
|
|
|
a = a.reshape(-1, prod)
|
|
b = b.ravel()
|
|
res = wrap(solve(a, b))
|
|
res.shape = oldshape
|
|
return res
|
|
|
|
|
|
def _solve_dispatcher(a, b):
|
|
return (a, b)
|
|
|
|
|
|
@array_function_dispatch(_solve_dispatcher)
|
|
def solve(a, b):
|
|
"""
|
|
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 : (..., M, M) array_like
|
|
Coefficient matrix.
|
|
b : {(..., M,), (..., M, K)}, array_like
|
|
Ordinate or "dependent variable" values.
|
|
|
|
Returns
|
|
-------
|
|
x : {(..., M,), (..., M, K)} ndarray
|
|
Solution to the system a x = b. Returned shape is identical to `b`.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If `a` is singular or not square.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
The solutions are computed using LAPACK routine _gesv
|
|
|
|
`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.allclose(np.dot(a, x), b)
|
|
True
|
|
|
|
"""
|
|
a, _ = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
b, wrap = _makearray(b)
|
|
t, result_t = _commonType(a, b)
|
|
|
|
# We use the b = (..., M,) logic, only if the number of extra dimensions
|
|
# match exactly
|
|
if b.ndim == a.ndim - 1:
|
|
gufunc = _umath_linalg.solve1
|
|
else:
|
|
gufunc = _umath_linalg.solve
|
|
|
|
signature = 'DD->D' if isComplexType(t) else 'dd->d'
|
|
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
|
|
r = gufunc(a, b, signature=signature, extobj=extobj)
|
|
|
|
return wrap(r.astype(result_t, copy=False))
|
|
|
|
|
|
def _tensorinv_dispatcher(a, ind=None):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_tensorinv_dispatcher)
|
|
def tensorinv(a, ind=2):
|
|
"""
|
|
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
|
|
--------
|
|
numpy.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
|
|
|
|
"""
|
|
a = asarray(a)
|
|
oldshape = a.shape
|
|
prod = 1
|
|
if ind > 0:
|
|
invshape = oldshape[ind:] + oldshape[:ind]
|
|
for k in oldshape[ind:]:
|
|
prod *= k
|
|
else:
|
|
raise ValueError("Invalid ind argument.")
|
|
a = a.reshape(prod, -1)
|
|
ia = inv(a)
|
|
return ia.reshape(*invshape)
|
|
|
|
|
|
# Matrix inversion
|
|
|
|
def _unary_dispatcher(a):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def inv(a):
|
|
"""
|
|
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 : (..., M, M) array_like
|
|
Matrix to be inverted.
|
|
|
|
Returns
|
|
-------
|
|
ainv : (..., M, M) ndarray or matrix
|
|
(Multiplicative) inverse of the matrix `a`.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If `a` is not square or inversion fails.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
Examples
|
|
--------
|
|
>>> from numpy.linalg import inv
|
|
>>> a = np.array([[1., 2.], [3., 4.]])
|
|
>>> ainv = 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 = inv(np.matrix(a))
|
|
>>> ainv
|
|
matrix([[-2. , 1. ],
|
|
[ 1.5, -0.5]])
|
|
|
|
Inverses of several matrices can be computed at once:
|
|
|
|
>>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
|
|
>>> inv(a)
|
|
array([[[-2. , 1. ],
|
|
[ 1.5, -0.5]],
|
|
[[-5. , 2. ],
|
|
[ 3. , -1. ]]])
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
|
|
signature = 'D->D' if isComplexType(t) else 'd->d'
|
|
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
|
|
ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)
|
|
return wrap(ainv.astype(result_t, copy=False))
|
|
|
|
|
|
def _matrix_power_dispatcher(a, n):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_matrix_power_dispatcher)
|
|
def matrix_power(a, n):
|
|
"""
|
|
Raise a square matrix to the (integer) power `n`.
|
|
|
|
For positive integers `n`, the power is computed by repeated matrix
|
|
squarings and matrix multiplications. If ``n == 0``, the identity matrix
|
|
of the same shape as M is returned. If ``n < 0``, the inverse
|
|
is computed and then raised to the ``abs(n)``.
|
|
|
|
.. note:: Stacks of object matrices are not currently supported.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array_like
|
|
Matrix to be "powered."
|
|
n : int
|
|
The exponent can be any integer or long integer, positive,
|
|
negative, or zero.
|
|
|
|
Returns
|
|
-------
|
|
a**n : (..., M, M) ndarray or matrix object
|
|
The return value is the same shape and type as `M`;
|
|
if the exponent is positive or zero then the type of the
|
|
elements is the same as those of `M`. If the exponent is
|
|
negative the elements are floating-point.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
For matrices that are not square or that (for negative powers) cannot
|
|
be inverted numerically.
|
|
|
|
Examples
|
|
--------
|
|
>>> from numpy.linalg import matrix_power
|
|
>>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit
|
|
>>> matrix_power(i, 3) # should = -i
|
|
array([[ 0, -1],
|
|
[ 1, 0]])
|
|
>>> matrix_power(i, 0)
|
|
array([[1, 0],
|
|
[0, 1]])
|
|
>>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
|
|
array([[ 0., 1.],
|
|
[-1., 0.]])
|
|
|
|
Somewhat more sophisticated example
|
|
|
|
>>> q = np.zeros((4, 4))
|
|
>>> q[0:2, 0:2] = -i
|
|
>>> q[2:4, 2:4] = i
|
|
>>> q # one of the three quaternion units not equal to 1
|
|
array([[ 0., -1., 0., 0.],
|
|
[ 1., 0., 0., 0.],
|
|
[ 0., 0., 0., 1.],
|
|
[ 0., 0., -1., 0.]])
|
|
>>> matrix_power(q, 2) # = -np.eye(4)
|
|
array([[-1., 0., 0., 0.],
|
|
[ 0., -1., 0., 0.],
|
|
[ 0., 0., -1., 0.],
|
|
[ 0., 0., 0., -1.]])
|
|
|
|
"""
|
|
a = asanyarray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
|
|
try:
|
|
n = operator.index(n)
|
|
except TypeError:
|
|
raise TypeError("exponent must be an integer")
|
|
|
|
# Fall back on dot for object arrays. Object arrays are not supported by
|
|
# the current implementation of matmul using einsum
|
|
if a.dtype != object:
|
|
fmatmul = matmul
|
|
elif a.ndim == 2:
|
|
fmatmul = dot
|
|
else:
|
|
raise NotImplementedError(
|
|
"matrix_power not supported for stacks of object arrays")
|
|
|
|
if n == 0:
|
|
a = empty_like(a)
|
|
a[...] = eye(a.shape[-2], dtype=a.dtype)
|
|
return a
|
|
|
|
elif n < 0:
|
|
a = inv(a)
|
|
n = abs(n)
|
|
|
|
# short-cuts.
|
|
if n == 1:
|
|
return a
|
|
|
|
elif n == 2:
|
|
return fmatmul(a, a)
|
|
|
|
elif n == 3:
|
|
return fmatmul(fmatmul(a, a), a)
|
|
|
|
# Use binary decomposition to reduce the number of matrix multiplications.
|
|
# Here, we iterate over the bits of n, from LSB to MSB, raise `a` to
|
|
# increasing powers of 2, and multiply into the result as needed.
|
|
z = result = None
|
|
while n > 0:
|
|
z = a if z is None else fmatmul(z, z)
|
|
n, bit = divmod(n, 2)
|
|
if bit:
|
|
result = z if result is None else fmatmul(result, z)
|
|
|
|
return result
|
|
|
|
|
|
# Cholesky decomposition
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def cholesky(a):
|
|
"""
|
|
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 : (..., M, M) array_like
|
|
Hermitian (symmetric if all elements are real), positive-definite
|
|
input matrix.
|
|
|
|
Returns
|
|
-------
|
|
L : (..., M, M) array_like
|
|
Upper or lower-triangular Cholesky factor of `a`. Returns a
|
|
matrix object if `a` is a matrix object.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If the decomposition fails, for example, if `a` is not
|
|
positive-definite.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
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]])
|
|
|
|
"""
|
|
extobj = get_linalg_error_extobj(_raise_linalgerror_nonposdef)
|
|
gufunc = _umath_linalg.cholesky_lo
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
signature = 'D->D' if isComplexType(t) else 'd->d'
|
|
r = gufunc(a, signature=signature, extobj=extobj)
|
|
return wrap(r.astype(result_t, copy=False))
|
|
|
|
|
|
# QR decompostion
|
|
|
|
def _qr_dispatcher(a, mode=None):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_qr_dispatcher)
|
|
def qr(a, mode='reduced'):
|
|
"""
|
|
Compute the qr factorization of a matrix.
|
|
|
|
Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is
|
|
upper-triangular.
|
|
|
|
Parameters
|
|
----------
|
|
a : array_like, shape (M, N)
|
|
Matrix to be factored.
|
|
mode : {'reduced', 'complete', 'r', 'raw', 'full', 'economic'}, optional
|
|
If K = min(M, N), then
|
|
|
|
* 'reduced' : returns q, r with dimensions (M, K), (K, N) (default)
|
|
* 'complete' : returns q, r with dimensions (M, M), (M, N)
|
|
* 'r' : returns r only with dimensions (K, N)
|
|
* 'raw' : returns h, tau with dimensions (N, M), (K,)
|
|
* 'full' : alias of 'reduced', deprecated
|
|
* 'economic' : returns h from 'raw', deprecated.
|
|
|
|
The options 'reduced', 'complete, and 'raw' are new in numpy 1.8,
|
|
see the notes for more information. The default is 'reduced', and to
|
|
maintain backward compatibility with earlier versions of numpy both
|
|
it and the old default 'full' can be omitted. Note that array h
|
|
returned in 'raw' mode is transposed for calling Fortran. The
|
|
'economic' mode is deprecated. The modes 'full' and 'economic' may
|
|
be passed using only the first letter for backwards compatibility,
|
|
but all others must be spelled out. See the Notes for more
|
|
explanation.
|
|
|
|
|
|
Returns
|
|
-------
|
|
q : ndarray of float or complex, optional
|
|
A matrix with orthonormal columns. When mode = 'complete' the
|
|
result is an orthogonal/unitary matrix depending on whether or not
|
|
a is real/complex. The determinant may be either +/- 1 in that
|
|
case.
|
|
r : ndarray of float or complex, optional
|
|
The upper-triangular matrix.
|
|
(h, tau) : ndarrays of np.double or np.cdouble, optional
|
|
The array h contains the Householder reflectors that generate q
|
|
along with r. The tau array contains scaling factors for the
|
|
reflectors. In the deprecated 'economic' mode only h is returned.
|
|
|
|
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:
|
|
https://en.wikipedia.org/wiki/QR_factorization
|
|
|
|
Subclasses of `ndarray` are preserved except for the 'raw' mode. So if
|
|
`a` is of type `matrix`, all the return values will be matrices too.
|
|
|
|
New 'reduced', 'complete', and 'raw' options for mode were added in
|
|
NumPy 1.8.0 and the old option 'full' was made an alias of 'reduced'. In
|
|
addition the options 'full' and 'economic' were deprecated. Because
|
|
'full' was the previous default and 'reduced' is the new default,
|
|
backward compatibility can be maintained by letting `mode` default.
|
|
The 'raw' option was added so that LAPACK routines that can multiply
|
|
arrays by q using the Householder reflectors can be used. Note that in
|
|
this case the returned arrays are of type np.double or np.cdouble and
|
|
the h array is transposed to be FORTRAN compatible. No routines using
|
|
the 'raw' return are currently exposed by numpy, but some are available
|
|
in lapack_lite and just await the necessary work.
|
|
|
|
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])
|
|
|
|
"""
|
|
if mode not in ('reduced', 'complete', 'r', 'raw'):
|
|
if mode in ('f', 'full'):
|
|
# 2013-04-01, 1.8
|
|
msg = "".join((
|
|
"The 'full' option is deprecated in favor of 'reduced'.\n",
|
|
"For backward compatibility let mode default."))
|
|
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
|
mode = 'reduced'
|
|
elif mode in ('e', 'economic'):
|
|
# 2013-04-01, 1.8
|
|
msg = "The 'economic' option is deprecated."
|
|
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
|
mode = 'economic'
|
|
else:
|
|
raise ValueError("Unrecognized mode '%s'" % mode)
|
|
|
|
a, wrap = _makearray(a)
|
|
_assertRank2(a)
|
|
m, n = a.shape
|
|
t, result_t = _commonType(a)
|
|
a = _fastCopyAndTranspose(t, a)
|
|
a = _to_native_byte_order(a)
|
|
mn = min(m, n)
|
|
tau = zeros((mn,), t)
|
|
|
|
if isComplexType(t):
|
|
lapack_routine = lapack_lite.zgeqrf
|
|
routine_name = 'zgeqrf'
|
|
else:
|
|
lapack_routine = lapack_lite.dgeqrf
|
|
routine_name = 'dgeqrf'
|
|
|
|
# calculate optimal size of work data 'work'
|
|
lwork = 1
|
|
work = zeros((lwork,), t)
|
|
results = lapack_routine(m, n, a, max(1, m), tau, work, -1, 0)
|
|
if results['info'] != 0:
|
|
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
|
|
|
|
# do qr decomposition
|
|
lwork = max(1, n, int(abs(work[0])))
|
|
work = zeros((lwork,), t)
|
|
results = lapack_routine(m, n, a, max(1, m), tau, work, lwork, 0)
|
|
if results['info'] != 0:
|
|
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
|
|
|
|
# handle modes that don't return q
|
|
if mode == 'r':
|
|
r = _fastCopyAndTranspose(result_t, a[:, :mn])
|
|
return wrap(triu(r))
|
|
|
|
if mode == 'raw':
|
|
return a, tau
|
|
|
|
if mode == 'economic':
|
|
if t != result_t :
|
|
a = a.astype(result_t, copy=False)
|
|
return wrap(a.T)
|
|
|
|
# generate q from a
|
|
if mode == 'complete' and m > n:
|
|
mc = m
|
|
q = empty((m, m), t)
|
|
else:
|
|
mc = mn
|
|
q = empty((n, m), t)
|
|
q[:n] = a
|
|
|
|
if isComplexType(t):
|
|
lapack_routine = lapack_lite.zungqr
|
|
routine_name = 'zungqr'
|
|
else:
|
|
lapack_routine = lapack_lite.dorgqr
|
|
routine_name = 'dorgqr'
|
|
|
|
# determine optimal lwork
|
|
lwork = 1
|
|
work = zeros((lwork,), t)
|
|
results = lapack_routine(m, mc, mn, q, max(1, m), tau, work, -1, 0)
|
|
if results['info'] != 0:
|
|
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
|
|
|
|
# compute q
|
|
lwork = max(1, n, int(abs(work[0])))
|
|
work = zeros((lwork,), t)
|
|
results = lapack_routine(m, mc, mn, q, max(1, m), tau, work, lwork, 0)
|
|
if results['info'] != 0:
|
|
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
|
|
|
|
q = _fastCopyAndTranspose(result_t, q[:mc])
|
|
r = _fastCopyAndTranspose(result_t, a[:, :mc])
|
|
|
|
return wrap(q), wrap(triu(r))
|
|
|
|
|
|
# Eigenvalues
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def eigvals(a):
|
|
"""
|
|
Compute the eigenvalues of a general matrix.
|
|
|
|
Main difference between `eigvals` and `eig`: the eigenvectors aren't
|
|
returned.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array_like
|
|
A complex- or real-valued matrix whose eigenvalues will be computed.
|
|
|
|
Returns
|
|
-------
|
|
w : (..., M,) ndarray
|
|
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 real symmetric or complex Hermitian
|
|
(conjugate symmetric) arrays.
|
|
eigh : eigenvalues and eigenvectors of real symmetric or complex
|
|
Hermitian (conjugate symmetric) arrays.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
This is implemented using the _geev LAPACK routines which compute
|
|
the eigenvalues and eigenvectors of general square arrays.
|
|
|
|
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.])
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
_assertFinite(a)
|
|
t, result_t = _commonType(a)
|
|
|
|
extobj = get_linalg_error_extobj(
|
|
_raise_linalgerror_eigenvalues_nonconvergence)
|
|
signature = 'D->D' if isComplexType(t) else 'd->D'
|
|
w = _umath_linalg.eigvals(a, signature=signature, extobj=extobj)
|
|
|
|
if not isComplexType(t):
|
|
if all(w.imag == 0):
|
|
w = w.real
|
|
result_t = _realType(result_t)
|
|
else:
|
|
result_t = _complexType(result_t)
|
|
|
|
return w.astype(result_t, copy=False)
|
|
|
|
|
|
def _eigvalsh_dispatcher(a, UPLO=None):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_eigvalsh_dispatcher)
|
|
def eigvalsh(a, UPLO='L'):
|
|
"""
|
|
Compute the eigenvalues of a complex Hermitian or real symmetric matrix.
|
|
|
|
Main difference from eigh: the eigenvectors are not computed.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array_like
|
|
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').
|
|
Irrespective of this value only the real parts of the diagonal will
|
|
be considered in the computation to preserve the notion of a Hermitian
|
|
matrix. It therefore follows that the imaginary part of the diagonal
|
|
will always be treated as zero.
|
|
|
|
Returns
|
|
-------
|
|
w : (..., M,) ndarray
|
|
The eigenvalues in ascending order, each repeated according to
|
|
its multiplicity.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If the eigenvalue computation does not converge.
|
|
|
|
See Also
|
|
--------
|
|
eigh : eigenvalues and eigenvectors of real symmetric or complex Hermitian
|
|
(conjugate symmetric) arrays.
|
|
eigvals : eigenvalues of general real or complex arrays.
|
|
eig : eigenvalues and right eigenvectors of general real or complex
|
|
arrays.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
The eigenvalues are computed using LAPACK routines _syevd, _heevd
|
|
|
|
Examples
|
|
--------
|
|
>>> from numpy import linalg as LA
|
|
>>> a = np.array([[1, -2j], [2j, 5]])
|
|
>>> LA.eigvalsh(a)
|
|
array([ 0.17157288, 5.82842712])
|
|
|
|
>>> # demonstrate the treatment of the imaginary part of the diagonal
|
|
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
|
|
>>> a
|
|
array([[ 5.+2.j, 9.-2.j],
|
|
[ 0.+2.j, 2.-1.j]])
|
|
>>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
|
|
>>> # with:
|
|
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
|
|
>>> b
|
|
array([[ 5.+0.j, 0.-2.j],
|
|
[ 0.+2.j, 2.+0.j]])
|
|
>>> wa = LA.eigvalsh(a)
|
|
>>> wb = LA.eigvals(b)
|
|
>>> wa; wb
|
|
array([ 1., 6.])
|
|
array([ 6.+0.j, 1.+0.j])
|
|
|
|
"""
|
|
UPLO = UPLO.upper()
|
|
if UPLO not in ('L', 'U'):
|
|
raise ValueError("UPLO argument must be 'L' or 'U'")
|
|
|
|
extobj = get_linalg_error_extobj(
|
|
_raise_linalgerror_eigenvalues_nonconvergence)
|
|
if UPLO == 'L':
|
|
gufunc = _umath_linalg.eigvalsh_lo
|
|
else:
|
|
gufunc = _umath_linalg.eigvalsh_up
|
|
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
signature = 'D->d' if isComplexType(t) else 'd->d'
|
|
w = gufunc(a, signature=signature, extobj=extobj)
|
|
return w.astype(_realType(result_t), copy=False)
|
|
|
|
def _convertarray(a):
|
|
t, result_t = _commonType(a)
|
|
a = _fastCT(a.astype(t))
|
|
return a, t, result_t
|
|
|
|
|
|
# Eigenvectors
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def eig(a):
|
|
"""
|
|
Compute the eigenvalues and right eigenvectors of a square array.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array
|
|
Matrices for which the eigenvalues and right eigenvectors will
|
|
be computed
|
|
|
|
Returns
|
|
-------
|
|
w : (..., M) array
|
|
The eigenvalues, each repeated according to its multiplicity.
|
|
The eigenvalues are not necessarily ordered. The resulting
|
|
array will be of complex type, unless the imaginary part is
|
|
zero in which case it will be cast to a real type. When `a`
|
|
is real the resulting eigenvalues will be real (0 imaginary
|
|
part) or occur in conjugate pairs
|
|
|
|
v : (..., M, M) array
|
|
The normalized (unit "length") eigenvectors, such that the
|
|
column ``v[:,i]`` is the eigenvector corresponding to the
|
|
eigenvalue ``w[i]``.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If the eigenvalue computation does not converge.
|
|
|
|
See Also
|
|
--------
|
|
eigvals : eigenvalues of a non-symmetric array.
|
|
|
|
eigh : eigenvalues and eigenvectors of a real symmetric or complex
|
|
Hermitian (conjugate symmetric) array.
|
|
|
|
eigvalsh : eigenvalues of a real symmetric or complex Hermitian
|
|
(conjugate symmetric) array.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
This is implemented using the _geev LAPACK routines which compute
|
|
the eigenvalues and eigenvectors of general square arrays.
|
|
|
|
The number `w` is an eigenvalue of `a` if there exists a vector
|
|
`v` such that ``dot(a,v) = w * v``. Thus, the arrays `a`, `w`, and
|
|
`v` satisfy the equations ``dot(a[:,:], v[:,i]) = w[i] * v[:,i]``
|
|
for :math:`i \\in \\{0,...,M-1\\}`.
|
|
|
|
The array `v` of eigenvectors may not be of maximum rank, that is, some
|
|
of the columns may be linearly dependent, although round-off error may
|
|
obscure that fact. If the eigenvalues are all different, then theoretically
|
|
the eigenvectors are linearly independent. Likewise, the (complex-valued)
|
|
matrix of eigenvectors `v` is unitary if the matrix `a` is normal, i.e.,
|
|
if ``dot(a, a.H) = dot(a.H, a)``, where `a.H` denotes the conjugate
|
|
transpose of `a`.
|
|
|
|
Finally, it is emphasized that `v` consists of the *right* (as in
|
|
right-hand side) eigenvectors of `a`. A vector `y` satisfying
|
|
``dot(y.T, a) = z * y.T`` for some number `z` is called a *left*
|
|
eigenvector of `a`, and, in general, the left and right eigenvectors
|
|
of a matrix are not necessarily the (perhaps conjugate) transposes
|
|
of each other.
|
|
|
|
References
|
|
----------
|
|
G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,
|
|
Academic Press, Inc., 1980, Various pp.
|
|
|
|
Examples
|
|
--------
|
|
>>> 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.]])
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
_assertFinite(a)
|
|
t, result_t = _commonType(a)
|
|
|
|
extobj = get_linalg_error_extobj(
|
|
_raise_linalgerror_eigenvalues_nonconvergence)
|
|
signature = 'D->DD' if isComplexType(t) else 'd->DD'
|
|
w, vt = _umath_linalg.eig(a, signature=signature, extobj=extobj)
|
|
|
|
if not isComplexType(t) and all(w.imag == 0.0):
|
|
w = w.real
|
|
vt = vt.real
|
|
result_t = _realType(result_t)
|
|
else:
|
|
result_t = _complexType(result_t)
|
|
|
|
vt = vt.astype(result_t, copy=False)
|
|
return w.astype(result_t, copy=False), wrap(vt)
|
|
|
|
|
|
@array_function_dispatch(_eigvalsh_dispatcher)
|
|
def eigh(a, UPLO='L'):
|
|
"""
|
|
Return the eigenvalues and eigenvectors of a complex Hermitian
|
|
(conjugate symmetric) or a real 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 : (..., M, M) array
|
|
Hermitian or real symmetric matrices whose eigenvalues and
|
|
eigenvectors 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').
|
|
Irrespective of this value only the real parts of the diagonal will
|
|
be considered in the computation to preserve the notion of a Hermitian
|
|
matrix. It therefore follows that the imaginary part of the diagonal
|
|
will always be treated as zero.
|
|
|
|
Returns
|
|
-------
|
|
w : (..., M) ndarray
|
|
The eigenvalues in ascending order, each repeated according to
|
|
its multiplicity.
|
|
v : {(..., M, M) ndarray, (..., M, M) matrix}
|
|
The column ``v[:, i]`` is the normalized eigenvector corresponding
|
|
to the eigenvalue ``w[i]``. Will return a matrix object if `a` is
|
|
a matrix object.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If the eigenvalue computation does not converge.
|
|
|
|
See Also
|
|
--------
|
|
eigvalsh : eigenvalues of real symmetric or complex Hermitian
|
|
(conjugate symmetric) arrays.
|
|
eig : eigenvalues and right eigenvectors for non-symmetric arrays.
|
|
eigvals : eigenvalues of non-symmetric arrays.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
The eigenvalues/eigenvectors are computed using LAPACK routines _syevd,
|
|
_heevd
|
|
|
|
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]])
|
|
|
|
>>> # demonstrate the treatment of the imaginary part of the diagonal
|
|
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
|
|
>>> a
|
|
array([[ 5.+2.j, 9.-2.j],
|
|
[ 0.+2.j, 2.-1.j]])
|
|
>>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
|
|
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
|
|
>>> b
|
|
array([[ 5.+0.j, 0.-2.j],
|
|
[ 0.+2.j, 2.+0.j]])
|
|
>>> wa, va = LA.eigh(a)
|
|
>>> wb, vb = LA.eig(b)
|
|
>>> wa; wb
|
|
array([ 1., 6.])
|
|
array([ 6.+0.j, 1.+0.j])
|
|
>>> va; vb
|
|
array([[-0.44721360-0.j , -0.89442719+0.j ],
|
|
[ 0.00000000+0.89442719j, 0.00000000-0.4472136j ]])
|
|
array([[ 0.89442719+0.j , 0.00000000-0.4472136j],
|
|
[ 0.00000000-0.4472136j, 0.89442719+0.j ]])
|
|
"""
|
|
UPLO = UPLO.upper()
|
|
if UPLO not in ('L', 'U'):
|
|
raise ValueError("UPLO argument must be 'L' or 'U'")
|
|
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
|
|
extobj = get_linalg_error_extobj(
|
|
_raise_linalgerror_eigenvalues_nonconvergence)
|
|
if UPLO == 'L':
|
|
gufunc = _umath_linalg.eigh_lo
|
|
else:
|
|
gufunc = _umath_linalg.eigh_up
|
|
|
|
signature = 'D->dD' if isComplexType(t) else 'd->dd'
|
|
w, vt = gufunc(a, signature=signature, extobj=extobj)
|
|
w = w.astype(_realType(result_t), copy=False)
|
|
vt = vt.astype(result_t, copy=False)
|
|
return w, wrap(vt)
|
|
|
|
|
|
# Singular value decomposition
|
|
|
|
def _svd_dispatcher(a, full_matrices=None, compute_uv=None):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_svd_dispatcher)
|
|
def svd(a, full_matrices=True, compute_uv=True):
|
|
"""
|
|
Singular Value Decomposition.
|
|
|
|
When `a` is a 2D array, it is factorized as ``u @ np.diag(s) @ vh
|
|
= (u * s) @ vh``, where `u` and `vh` are 2D unitary arrays and `s` is a 1D
|
|
array of `a`'s singular values. When `a` is higher-dimensional, SVD is
|
|
applied in stacked mode as explained below.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, N) array_like
|
|
A real or complex array with ``a.ndim >= 2``.
|
|
full_matrices : bool, optional
|
|
If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and
|
|
``(..., N, N)``, respectively. Otherwise, the shapes are
|
|
``(..., M, K)`` and ``(..., K, N)``, respectively, where
|
|
``K = min(M, N)``.
|
|
compute_uv : bool, optional
|
|
Whether or not to compute `u` and `vh` in addition to `s`. True
|
|
by default.
|
|
|
|
Returns
|
|
-------
|
|
u : { (..., M, M), (..., M, K) } array
|
|
Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
|
|
size as those of the input `a`. The size of the last two dimensions
|
|
depends on the value of `full_matrices`. Only returned when
|
|
`compute_uv` is True.
|
|
s : (..., K) array
|
|
Vector(s) with the singular values, within each vector sorted in
|
|
descending order. The first ``a.ndim - 2`` dimensions have the same
|
|
size as those of the input `a`.
|
|
vh : { (..., N, N), (..., K, N) } array
|
|
Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
|
|
size as those of the input `a`. The size of the last two dimensions
|
|
depends on the value of `full_matrices`. Only returned when
|
|
`compute_uv` is True.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If SVD computation does not converge.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionchanged:: 1.8.0
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
The decomposition is performed using LAPACK routine ``_gesdd``.
|
|
|
|
SVD is usually described for the factorization of a 2D matrix :math:`A`.
|
|
The higher-dimensional case will be discussed below. In the 2D case, SVD is
|
|
written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,
|
|
:math:`S= \\mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`
|
|
contains the singular values of `a` and `u` and `vh` are unitary. The rows
|
|
of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are
|
|
the eigenvectors of :math:`A A^H`. In both cases the corresponding
|
|
(possibly non-zero) eigenvalues are given by ``s**2``.
|
|
|
|
If `a` has more than two dimensions, then broadcasting rules apply, as
|
|
explained in :ref:`routines.linalg-broadcasting`. This means that SVD is
|
|
working in "stacked" mode: it iterates over all indices of the first
|
|
``a.ndim - 2`` dimensions and for each combination SVD is applied to the
|
|
last two indices. The matrix `a` can be reconstructed from the
|
|
decomposition with either ``(u * s[..., None, :]) @ vh`` or
|
|
``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the
|
|
function ``np.matmul`` for python versions below 3.5.)
|
|
|
|
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)
|
|
>>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)
|
|
|
|
Reconstruction based on full SVD, 2D case:
|
|
|
|
>>> u, s, vh = np.linalg.svd(a, full_matrices=True)
|
|
>>> u.shape, s.shape, vh.shape
|
|
((9, 9), (6,), (6, 6))
|
|
>>> np.allclose(a, np.dot(u[:, :6] * s, vh))
|
|
True
|
|
>>> smat = np.zeros((9, 6), dtype=complex)
|
|
>>> smat[:6, :6] = np.diag(s)
|
|
>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
|
|
True
|
|
|
|
Reconstruction based on reduced SVD, 2D case:
|
|
|
|
>>> u, s, vh = np.linalg.svd(a, full_matrices=False)
|
|
>>> u.shape, s.shape, vh.shape
|
|
((9, 6), (6,), (6, 6))
|
|
>>> np.allclose(a, np.dot(u * s, vh))
|
|
True
|
|
>>> smat = np.diag(s)
|
|
>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
|
|
True
|
|
|
|
Reconstruction based on full SVD, 4D case:
|
|
|
|
>>> u, s, vh = np.linalg.svd(b, full_matrices=True)
|
|
>>> u.shape, s.shape, vh.shape
|
|
((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
|
|
>>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
|
|
True
|
|
>>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
|
|
True
|
|
|
|
Reconstruction based on reduced SVD, 4D case:
|
|
|
|
>>> u, s, vh = np.linalg.svd(b, full_matrices=False)
|
|
>>> u.shape, s.shape, vh.shape
|
|
((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
|
|
>>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
|
|
True
|
|
>>> np.allclose(b, np.matmul(u, s[..., None] * vh))
|
|
True
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
_assertRankAtLeast2(a)
|
|
t, result_t = _commonType(a)
|
|
|
|
extobj = get_linalg_error_extobj(_raise_linalgerror_svd_nonconvergence)
|
|
|
|
m, n = a.shape[-2:]
|
|
if compute_uv:
|
|
if full_matrices:
|
|
if m < n:
|
|
gufunc = _umath_linalg.svd_m_f
|
|
else:
|
|
gufunc = _umath_linalg.svd_n_f
|
|
else:
|
|
if m < n:
|
|
gufunc = _umath_linalg.svd_m_s
|
|
else:
|
|
gufunc = _umath_linalg.svd_n_s
|
|
|
|
signature = 'D->DdD' if isComplexType(t) else 'd->ddd'
|
|
u, s, vh = gufunc(a, signature=signature, extobj=extobj)
|
|
u = u.astype(result_t, copy=False)
|
|
s = s.astype(_realType(result_t), copy=False)
|
|
vh = vh.astype(result_t, copy=False)
|
|
return wrap(u), s, wrap(vh)
|
|
else:
|
|
if m < n:
|
|
gufunc = _umath_linalg.svd_m
|
|
else:
|
|
gufunc = _umath_linalg.svd_n
|
|
|
|
signature = 'D->d' if isComplexType(t) else 'd->d'
|
|
s = gufunc(a, signature=signature, extobj=extobj)
|
|
s = s.astype(_realType(result_t), copy=False)
|
|
return s
|
|
|
|
|
|
def _cond_dispatcher(x, p=None):
|
|
return (x,)
|
|
|
|
|
|
@array_function_dispatch(_cond_dispatcher)
|
|
def cond(x, p=None):
|
|
"""
|
|
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 : (..., M, N) array_like
|
|
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.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
|
|
|
|
"""
|
|
x = asarray(x) # in case we have a matrix
|
|
_assertNoEmpty2d(x)
|
|
if p is None or p == 2 or p == -2:
|
|
s = svd(x, compute_uv=False)
|
|
with errstate(all='ignore'):
|
|
if p == -2:
|
|
r = s[..., -1] / s[..., 0]
|
|
else:
|
|
r = s[..., 0] / s[..., -1]
|
|
else:
|
|
# Call inv(x) ignoring errors. The result array will
|
|
# contain nans in the entries where inversion failed.
|
|
_assertRankAtLeast2(x)
|
|
_assertNdSquareness(x)
|
|
t, result_t = _commonType(x)
|
|
signature = 'D->D' if isComplexType(t) else 'd->d'
|
|
with errstate(all='ignore'):
|
|
invx = _umath_linalg.inv(x, signature=signature)
|
|
r = norm(x, p, axis=(-2, -1)) * norm(invx, p, axis=(-2, -1))
|
|
r = r.astype(result_t, copy=False)
|
|
|
|
# Convert nans to infs unless the original array had nan entries
|
|
r = asarray(r)
|
|
nan_mask = isnan(r)
|
|
if nan_mask.any():
|
|
nan_mask &= ~isnan(x).any(axis=(-2, -1))
|
|
if r.ndim > 0:
|
|
r[nan_mask] = Inf
|
|
elif nan_mask:
|
|
r[()] = Inf
|
|
|
|
# Convention is to return scalars instead of 0d arrays
|
|
if r.ndim == 0:
|
|
r = r[()]
|
|
|
|
return r
|
|
|
|
|
|
def _matrix_rank_dispatcher(M, tol=None, hermitian=None):
|
|
return (M,)
|
|
|
|
|
|
@array_function_dispatch(_matrix_rank_dispatcher)
|
|
def matrix_rank(M, tol=None, hermitian=False):
|
|
"""
|
|
Return matrix rank of array using SVD method
|
|
|
|
Rank of the array is the number of singular values of the array that are
|
|
greater than `tol`.
|
|
|
|
.. versionchanged:: 1.14
|
|
Can now operate on stacks of matrices
|
|
|
|
Parameters
|
|
----------
|
|
M : {(M,), (..., M, N)} array_like
|
|
input vector or stack of matrices
|
|
tol : (...) array_like, float, optional
|
|
threshold below which SVD values are considered zero. If `tol` is
|
|
None, and ``S`` is an array with singular values for `M`, and
|
|
``eps`` is the epsilon value for datatype of ``S``, then `tol` is
|
|
set to ``S.max() * max(M.shape) * eps``.
|
|
|
|
.. versionchanged:: 1.14
|
|
Broadcasted against the stack of matrices
|
|
hermitian : bool, optional
|
|
If True, `M` is assumed to be Hermitian (symmetric if real-valued),
|
|
enabling a more efficient method for finding singular values.
|
|
Defaults to False.
|
|
|
|
.. versionadded:: 1.14
|
|
|
|
Notes
|
|
-----
|
|
The default threshold to detect rank deficiency is a test on the magnitude
|
|
of the singular values of `M`. By default, we identify singular values less
|
|
than ``S.max() * max(M.shape) * eps`` as indicating rank deficiency (with
|
|
the symbols defined above). This is the algorithm MATLAB uses [1]. It also
|
|
appears in *Numerical recipes* in the discussion of SVD solutions for linear
|
|
least squares [2].
|
|
|
|
This default threshold is designed to detect rank deficiency accounting for
|
|
the numerical errors of the SVD computation. Imagine that there is a column
|
|
in `M` that is an exact (in floating point) linear combination of other
|
|
columns in `M`. Computing the SVD on `M` will not produce a singular value
|
|
exactly equal to 0 in general: any difference of the smallest SVD value from
|
|
0 will be caused by numerical imprecision in the calculation of the SVD.
|
|
Our threshold for small SVD values takes this numerical imprecision into
|
|
account, and the default threshold will detect such numerical rank
|
|
deficiency. The threshold may declare a matrix `M` rank deficient even if
|
|
the linear combination of some columns of `M` is not exactly equal to
|
|
another column of `M` but only numerically very close to another column of
|
|
`M`.
|
|
|
|
We chose our default threshold because it is in wide use. Other thresholds
|
|
are possible. For example, elsewhere in the 2007 edition of *Numerical
|
|
recipes* there is an alternative threshold of ``S.max() *
|
|
np.finfo(M.dtype).eps / 2. * np.sqrt(m + n + 1.)``. The authors describe
|
|
this threshold as being based on "expected roundoff error" (p 71).
|
|
|
|
The thresholds above deal with floating point roundoff error in the
|
|
calculation of the SVD. However, you may have more information about the
|
|
sources of error in `M` that would make you consider other tolerance values
|
|
to detect *effective* rank deficiency. The most useful measure of the
|
|
tolerance depends on the operations you intend to use on your matrix. For
|
|
example, if your data come from uncertain measurements with uncertainties
|
|
greater than floating point epsilon, choosing a tolerance near that
|
|
uncertainty may be preferable. The tolerance may be absolute if the
|
|
uncertainties are absolute rather than relative.
|
|
|
|
References
|
|
----------
|
|
.. [1] MATLAB reference documention, "Rank"
|
|
https://www.mathworks.com/help/techdoc/ref/rank.html
|
|
.. [2] W. H. Press, S. A. Teukolsky, W. T. Vetterling and B. P. Flannery,
|
|
"Numerical Recipes (3rd edition)", Cambridge University Press, 2007,
|
|
page 795.
|
|
|
|
Examples
|
|
--------
|
|
>>> from numpy.linalg import matrix_rank
|
|
>>> matrix_rank(np.eye(4)) # Full rank matrix
|
|
4
|
|
>>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix
|
|
>>> matrix_rank(I)
|
|
3
|
|
>>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0
|
|
1
|
|
>>> matrix_rank(np.zeros((4,)))
|
|
0
|
|
"""
|
|
M = asarray(M)
|
|
if M.ndim < 2:
|
|
return int(not all(M==0))
|
|
if hermitian:
|
|
S = abs(eigvalsh(M))
|
|
else:
|
|
S = svd(M, compute_uv=False)
|
|
if tol is None:
|
|
tol = S.max(axis=-1, keepdims=True) * max(M.shape[-2:]) * finfo(S.dtype).eps
|
|
else:
|
|
tol = asarray(tol)[..., newaxis]
|
|
return count_nonzero(S > tol, axis=-1)
|
|
|
|
|
|
# Generalized inverse
|
|
|
|
def _pinv_dispatcher(a, rcond=None):
|
|
return (a,)
|
|
|
|
|
|
@array_function_dispatch(_pinv_dispatcher)
|
|
def pinv(a, rcond=1e-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.
|
|
|
|
.. versionchanged:: 1.14
|
|
Can now operate on stacks of matrices
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, N) array_like
|
|
Matrix or stack of matrices to be pseudo-inverted.
|
|
rcond : (...) array_like of float
|
|
Cutoff for small singular values.
|
|
Singular values smaller (in modulus) than
|
|
`rcond` * largest_singular_value (again, in modulus)
|
|
are set to zero. Broadcasts against the stack of matrices
|
|
|
|
Returns
|
|
-------
|
|
B : (..., N, M) ndarray
|
|
The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so
|
|
is `B`.
|
|
|
|
Raises
|
|
------
|
|
LinAlgError
|
|
If the SVD computation does not converge.
|
|
|
|
Notes
|
|
-----
|
|
The pseudo-inverse of a matrix A, denoted :math:`A^+`, is
|
|
defined as: "the matrix that 'solves' [the least-squares problem]
|
|
:math:`Ax = b`," i.e., if :math:`\\bar{x}` is said solution, then
|
|
:math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.
|
|
|
|
It can be shown that if :math:`Q_1 \\Sigma Q_2^T = A` is the singular
|
|
value decomposition of A, then
|
|
:math:`A^+ = Q_2 \\Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are
|
|
orthogonal matrices, :math:`\\Sigma` is a diagonal matrix consisting
|
|
of A's so-called singular values, (followed, typically, by
|
|
zeros), and then :math:`\\Sigma^+` is simply the diagonal matrix
|
|
consisting of the reciprocals of A's singular values
|
|
(again, followed by zeros). [1]_
|
|
|
|
References
|
|
----------
|
|
.. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
|
|
FL, Academic Press, Inc., 1980, pp. 139-142.
|
|
|
|
Examples
|
|
--------
|
|
The following example checks that ``a * a+ * a == a`` and
|
|
``a+ * a * a+ == a+``:
|
|
|
|
>>> 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
|
|
|
|
"""
|
|
a, wrap = _makearray(a)
|
|
rcond = asarray(rcond)
|
|
if _isEmpty2d(a):
|
|
m, n = a.shape[-2:]
|
|
res = empty(a.shape[:-2] + (n, m), dtype=a.dtype)
|
|
return wrap(res)
|
|
a = a.conjugate()
|
|
u, s, vt = svd(a, full_matrices=False)
|
|
|
|
# discard small singular values
|
|
cutoff = rcond[..., newaxis] * amax(s, axis=-1, keepdims=True)
|
|
large = s > cutoff
|
|
s = divide(1, s, where=large, out=s)
|
|
s[~large] = 0
|
|
|
|
res = matmul(transpose(vt), multiply(s[..., newaxis], transpose(u)))
|
|
return wrap(res)
|
|
|
|
|
|
# Determinant
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def slogdet(a):
|
|
"""
|
|
Compute the sign and (natural) logarithm of the determinant of an array.
|
|
|
|
If an array has a very small or very large determinant, then a call to
|
|
`det` may overflow or underflow. This routine is more robust against such
|
|
issues, because it computes the logarithm of the determinant rather than
|
|
the determinant itself.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array_like
|
|
Input array, has to be a square 2-D array.
|
|
|
|
Returns
|
|
-------
|
|
sign : (...) array_like
|
|
A number representing the sign of the determinant. For a real matrix,
|
|
this is 1, 0, or -1. For a complex matrix, this is a complex number
|
|
with absolute value 1 (i.e., it is on the unit circle), or else 0.
|
|
logdet : (...) array_like
|
|
The natural log of the absolute value of the determinant.
|
|
|
|
If the determinant is zero, then `sign` will be 0 and `logdet` will be
|
|
-Inf. In all cases, the determinant is equal to ``sign * np.exp(logdet)``.
|
|
|
|
See Also
|
|
--------
|
|
det
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
.. versionadded:: 1.6.0
|
|
|
|
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]])
|
|
>>> (sign, logdet) = np.linalg.slogdet(a)
|
|
>>> (sign, logdet)
|
|
(-1, 0.69314718055994529)
|
|
>>> sign * np.exp(logdet)
|
|
-2.0
|
|
|
|
Computing log-determinants for a stack of matrices:
|
|
|
|
>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
|
|
>>> a.shape
|
|
(3, 2, 2)
|
|
>>> sign, logdet = np.linalg.slogdet(a)
|
|
>>> (sign, logdet)
|
|
(array([-1., -1., -1.]), array([ 0.69314718, 1.09861229, 2.07944154]))
|
|
>>> sign * np.exp(logdet)
|
|
array([-2., -3., -8.])
|
|
|
|
This routine succeeds where ordinary `det` does not:
|
|
|
|
>>> np.linalg.det(np.eye(500) * 0.1)
|
|
0.0
|
|
>>> np.linalg.slogdet(np.eye(500) * 0.1)
|
|
(1, -1151.2925464970228)
|
|
|
|
"""
|
|
a = asarray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
real_t = _realType(result_t)
|
|
signature = 'D->Dd' if isComplexType(t) else 'd->dd'
|
|
sign, logdet = _umath_linalg.slogdet(a, signature=signature)
|
|
sign = sign.astype(result_t, copy=False)
|
|
logdet = logdet.astype(real_t, copy=False)
|
|
return sign, logdet
|
|
|
|
|
|
@array_function_dispatch(_unary_dispatcher)
|
|
def det(a):
|
|
"""
|
|
Compute the determinant of an array.
|
|
|
|
Parameters
|
|
----------
|
|
a : (..., M, M) array_like
|
|
Input array to compute determinants for.
|
|
|
|
Returns
|
|
-------
|
|
det : (...) array_like
|
|
Determinant of `a`.
|
|
|
|
See Also
|
|
--------
|
|
slogdet : Another way to represent the determinant, more suitable
|
|
for large matrices where underflow/overflow may occur.
|
|
|
|
Notes
|
|
-----
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
Broadcasting rules apply, see the `numpy.linalg` documentation for
|
|
details.
|
|
|
|
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
|
|
|
|
Computing determinants for a stack of matrices:
|
|
|
|
>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
|
|
>>> a.shape
|
|
(3, 2, 2)
|
|
>>> np.linalg.det(a)
|
|
array([-2., -3., -8.])
|
|
|
|
"""
|
|
a = asarray(a)
|
|
_assertRankAtLeast2(a)
|
|
_assertNdSquareness(a)
|
|
t, result_t = _commonType(a)
|
|
signature = 'D->D' if isComplexType(t) else 'd->d'
|
|
r = _umath_linalg.det(a, signature=signature)
|
|
r = r.astype(result_t, copy=False)
|
|
return r
|
|
|
|
|
|
# Linear Least Squares
|
|
|
|
def _lstsq_dispatcher(a, b, rcond=None):
|
|
return (a, b)
|
|
|
|
|
|
@array_function_dispatch(_lstsq_dispatcher)
|
|
def lstsq(a, b, rcond="warn"):
|
|
"""
|
|
Return the least-squares solution to a linear matrix equation.
|
|
|
|
Solves the equation `a x = b` by computing a vector `x` that
|
|
minimizes the Euclidean 2-norm `|| b - a x ||^2`. The equation may
|
|
be under-, well-, or over- determined (i.e., the number of
|
|
linearly independent rows of `a` can be less than, equal to, or
|
|
greater than its number of linearly independent columns). If `a`
|
|
is square and of full rank, then `x` (but for round-off error) is
|
|
the "exact" solution of the equation.
|
|
|
|
Parameters
|
|
----------
|
|
a : (M, N) array_like
|
|
"Coefficient" matrix.
|
|
b : {(M,), (M, K)} array_like
|
|
Ordinate or "dependent variable" values. If `b` is two-dimensional,
|
|
the least-squares solution is calculated for each of the `K` columns
|
|
of `b`.
|
|
rcond : float, optional
|
|
Cut-off ratio for small singular values of `a`.
|
|
For the purposes of rank determination, singular values are treated
|
|
as zero if they are smaller than `rcond` times the largest singular
|
|
value of `a`.
|
|
|
|
.. versionchanged:: 1.14.0
|
|
If not set, a FutureWarning is given. The previous default
|
|
of ``-1`` will use the machine precision as `rcond` parameter,
|
|
the new default will use the machine precision times `max(M, N)`.
|
|
To silence the warning and use the new default, use ``rcond=None``,
|
|
to keep using the old behavior, use ``rcond=-1``.
|
|
|
|
Returns
|
|
-------
|
|
x : {(N,), (N, K)} ndarray
|
|
Least-squares solution. If `b` is two-dimensional,
|
|
the solutions are in the `K` columns of `x`.
|
|
residuals : {(1,), (K,), (0,)} ndarray
|
|
Sums of residuals; squared Euclidean 2-norm for each column in
|
|
``b - a*x``.
|
|
If the rank of `a` is < N or M <= N, 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 : (min(M, N),) ndarray
|
|
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, rcond=None)[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()
|
|
|
|
"""
|
|
a, _ = _makearray(a)
|
|
b, wrap = _makearray(b)
|
|
is_1d = b.ndim == 1
|
|
if is_1d:
|
|
b = b[:, newaxis]
|
|
_assertRank2(a, b)
|
|
m, n = a.shape[-2:]
|
|
m2, n_rhs = b.shape[-2:]
|
|
if m != m2:
|
|
raise LinAlgError('Incompatible dimensions')
|
|
|
|
t, result_t = _commonType(a, b)
|
|
# FIXME: real_t is unused
|
|
real_t = _linalgRealType(t)
|
|
result_real_t = _realType(result_t)
|
|
|
|
# Determine default rcond value
|
|
if rcond == "warn":
|
|
# 2017-08-19, 1.14.0
|
|
warnings.warn("`rcond` parameter will change to the default of "
|
|
"machine precision times ``max(M, N)`` where M and N "
|
|
"are the input matrix dimensions.\n"
|
|
"To use the future default and silence this warning "
|
|
"we advise to pass `rcond=None`, to keep using the old, "
|
|
"explicitly pass `rcond=-1`.",
|
|
FutureWarning, stacklevel=2)
|
|
rcond = -1
|
|
if rcond is None:
|
|
rcond = finfo(t).eps * max(n, m)
|
|
|
|
if m <= n:
|
|
gufunc = _umath_linalg.lstsq_m
|
|
else:
|
|
gufunc = _umath_linalg.lstsq_n
|
|
|
|
signature = 'DDd->Ddid' if isComplexType(t) else 'ddd->ddid'
|
|
extobj = get_linalg_error_extobj(_raise_linalgerror_lstsq)
|
|
if n_rhs == 0:
|
|
# lapack can't handle n_rhs = 0 - so allocate the array one larger in that axis
|
|
b = zeros(b.shape[:-2] + (m, n_rhs + 1), dtype=b.dtype)
|
|
x, resids, rank, s = gufunc(a, b, rcond, signature=signature, extobj=extobj)
|
|
if m == 0:
|
|
x[...] = 0
|
|
if n_rhs == 0:
|
|
# remove the item we added
|
|
x = x[..., :n_rhs]
|
|
resids = resids[..., :n_rhs]
|
|
|
|
# remove the axis we added
|
|
if is_1d:
|
|
x = x.squeeze(axis=-1)
|
|
# we probably should squeeze resids too, but we can't
|
|
# without breaking compatibility.
|
|
|
|
# as documented
|
|
if rank != n or m <= n:
|
|
resids = array([], result_real_t)
|
|
|
|
# coerce output arrays
|
|
s = s.astype(result_real_t, copy=False)
|
|
resids = resids.astype(result_real_t, copy=False)
|
|
x = x.astype(result_t, copy=True) # Copying lets the memory in r_parts be freed
|
|
return wrap(x), wrap(resids), rank, s
|
|
|
|
|
|
def _multi_svd_norm(x, row_axis, col_axis, op):
|
|
"""Compute a function of the singular values of the 2-D matrices in `x`.
|
|
|
|
This is a private utility function used by numpy.linalg.norm().
|
|
|
|
Parameters
|
|
----------
|
|
x : ndarray
|
|
row_axis, col_axis : int
|
|
The axes of `x` that hold the 2-D matrices.
|
|
op : callable
|
|
This should be either numpy.amin or numpy.amax or numpy.sum.
|
|
|
|
Returns
|
|
-------
|
|
result : float or ndarray
|
|
If `x` is 2-D, the return values is a float.
|
|
Otherwise, it is an array with ``x.ndim - 2`` dimensions.
|
|
The return values are either the minimum or maximum or sum of the
|
|
singular values of the matrices, depending on whether `op`
|
|
is `numpy.amin` or `numpy.amax` or `numpy.sum`.
|
|
|
|
"""
|
|
y = moveaxis(x, (row_axis, col_axis), (-2, -1))
|
|
result = op(svd(y, compute_uv=0), axis=-1)
|
|
return result
|
|
|
|
|
|
def _norm_dispatcher(x, ord=None, axis=None, keepdims=None):
|
|
return (x,)
|
|
|
|
|
|
@array_function_dispatch(_norm_dispatcher)
|
|
def norm(x, ord=None, axis=None, keepdims=False):
|
|
"""
|
|
Matrix or vector norm.
|
|
|
|
This function is able to return one of eight 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
|
|
Input array. If `axis` is None, `x` must be 1-D or 2-D.
|
|
ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
|
|
Order of the norm (see table under ``Notes``). inf means numpy's
|
|
`inf` object.
|
|
axis : {int, 2-tuple of ints, None}, optional
|
|
If `axis` is an integer, it specifies the axis of `x` along which to
|
|
compute the vector norms. If `axis` is a 2-tuple, it specifies the
|
|
axes that hold 2-D matrices, and the matrix norms of these matrices
|
|
are computed. If `axis` is None then either a vector norm (when `x`
|
|
is 1-D) or a matrix norm (when `x` is 2-D) is returned.
|
|
|
|
.. versionadded:: 1.8.0
|
|
|
|
keepdims : bool, optional
|
|
If this is set to True, the axes which are normed over are left in the
|
|
result as dimensions with size one. With this option the result will
|
|
broadcast correctly against the original `x`.
|
|
|
|
.. versionadded:: 1.10.0
|
|
|
|
Returns
|
|
-------
|
|
n : float or ndarray
|
|
Norm of the matrix or vector(s).
|
|
|
|
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 --
|
|
'nuc' nuclear 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}`
|
|
|
|
The nuclear norm is the sum of the singular values.
|
|
|
|
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.0
|
|
>>> LA.norm(b, np.inf)
|
|
9.0
|
|
>>> LA.norm(a, -np.inf)
|
|
0.0
|
|
>>> LA.norm(b, -np.inf)
|
|
2.0
|
|
|
|
>>> LA.norm(a, 1)
|
|
20.0
|
|
>>> LA.norm(b, 1)
|
|
7.0
|
|
>>> LA.norm(a, -1)
|
|
-4.6566128774142013e-010
|
|
>>> LA.norm(b, -1)
|
|
6.0
|
|
>>> 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
|
|
|
|
Using the `axis` argument to compute vector norms:
|
|
|
|
>>> c = np.array([[ 1, 2, 3],
|
|
... [-1, 1, 4]])
|
|
>>> LA.norm(c, axis=0)
|
|
array([ 1.41421356, 2.23606798, 5. ])
|
|
>>> LA.norm(c, axis=1)
|
|
array([ 3.74165739, 4.24264069])
|
|
>>> LA.norm(c, ord=1, axis=1)
|
|
array([ 6., 6.])
|
|
|
|
Using the `axis` argument to compute matrix norms:
|
|
|
|
>>> m = np.arange(8).reshape(2,2,2)
|
|
>>> LA.norm(m, axis=(1,2))
|
|
array([ 3.74165739, 11.22497216])
|
|
>>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
|
|
(3.7416573867739413, 11.224972160321824)
|
|
|
|
"""
|
|
x = asarray(x)
|
|
|
|
if not issubclass(x.dtype.type, (inexact, object_)):
|
|
x = x.astype(float)
|
|
|
|
# Immediately handle some default, simple, fast, and common cases.
|
|
if axis is None:
|
|
ndim = x.ndim
|
|
if ((ord is None) or
|
|
(ord in ('f', 'fro') and ndim == 2) or
|
|
(ord == 2 and ndim == 1)):
|
|
|
|
x = x.ravel(order='K')
|
|
if isComplexType(x.dtype.type):
|
|
sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
|
|
else:
|
|
sqnorm = dot(x, x)
|
|
ret = sqrt(sqnorm)
|
|
if keepdims:
|
|
ret = ret.reshape(ndim*[1])
|
|
return ret
|
|
|
|
# Normalize the `axis` argument to a tuple.
|
|
nd = x.ndim
|
|
if axis is None:
|
|
axis = tuple(range(nd))
|
|
elif not isinstance(axis, tuple):
|
|
try:
|
|
axis = int(axis)
|
|
except Exception:
|
|
raise TypeError("'axis' must be None, an integer or a tuple of integers")
|
|
axis = (axis,)
|
|
|
|
if len(axis) == 1:
|
|
if ord == Inf:
|
|
return abs(x).max(axis=axis, keepdims=keepdims)
|
|
elif ord == -Inf:
|
|
return abs(x).min(axis=axis, keepdims=keepdims)
|
|
elif ord == 0:
|
|
# Zero norm
|
|
return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims)
|
|
elif ord == 1:
|
|
# special case for speedup
|
|
return add.reduce(abs(x), axis=axis, keepdims=keepdims)
|
|
elif ord is None or ord == 2:
|
|
# special case for speedup
|
|
s = (x.conj() * x).real
|
|
return sqrt(add.reduce(s, axis=axis, keepdims=keepdims))
|
|
else:
|
|
try:
|
|
ord + 1
|
|
except TypeError:
|
|
raise ValueError("Invalid norm order for vectors.")
|
|
absx = abs(x)
|
|
absx **= ord
|
|
ret = add.reduce(absx, axis=axis, keepdims=keepdims)
|
|
ret **= (1 / ord)
|
|
return ret
|
|
elif len(axis) == 2:
|
|
row_axis, col_axis = axis
|
|
row_axis = normalize_axis_index(row_axis, nd)
|
|
col_axis = normalize_axis_index(col_axis, nd)
|
|
if row_axis == col_axis:
|
|
raise ValueError('Duplicate axes given.')
|
|
if ord == 2:
|
|
ret = _multi_svd_norm(x, row_axis, col_axis, amax)
|
|
elif ord == -2:
|
|
ret = _multi_svd_norm(x, row_axis, col_axis, amin)
|
|
elif ord == 1:
|
|
if col_axis > row_axis:
|
|
col_axis -= 1
|
|
ret = add.reduce(abs(x), axis=row_axis).max(axis=col_axis)
|
|
elif ord == Inf:
|
|
if row_axis > col_axis:
|
|
row_axis -= 1
|
|
ret = add.reduce(abs(x), axis=col_axis).max(axis=row_axis)
|
|
elif ord == -1:
|
|
if col_axis > row_axis:
|
|
col_axis -= 1
|
|
ret = add.reduce(abs(x), axis=row_axis).min(axis=col_axis)
|
|
elif ord == -Inf:
|
|
if row_axis > col_axis:
|
|
row_axis -= 1
|
|
ret = add.reduce(abs(x), axis=col_axis).min(axis=row_axis)
|
|
elif ord in [None, 'fro', 'f']:
|
|
ret = sqrt(add.reduce((x.conj() * x).real, axis=axis))
|
|
elif ord == 'nuc':
|
|
ret = _multi_svd_norm(x, row_axis, col_axis, sum)
|
|
else:
|
|
raise ValueError("Invalid norm order for matrices.")
|
|
if keepdims:
|
|
ret_shape = list(x.shape)
|
|
ret_shape[axis[0]] = 1
|
|
ret_shape[axis[1]] = 1
|
|
ret = ret.reshape(ret_shape)
|
|
return ret
|
|
else:
|
|
raise ValueError("Improper number of dimensions to norm.")
|
|
|
|
|
|
# multi_dot
|
|
|
|
def _multidot_dispatcher(arrays):
|
|
return arrays
|
|
|
|
|
|
@array_function_dispatch(_multidot_dispatcher)
|
|
def multi_dot(arrays):
|
|
"""
|
|
Compute the dot product of two or more arrays in a single function call,
|
|
while automatically selecting the fastest evaluation order.
|
|
|
|
`multi_dot` chains `numpy.dot` and uses optimal parenthesization
|
|
of the matrices [1]_ [2]_. Depending on the shapes of the matrices,
|
|
this can speed up the multiplication a lot.
|
|
|
|
If the first argument is 1-D it is treated as a row vector.
|
|
If the last argument is 1-D it is treated as a column vector.
|
|
The other arguments must be 2-D.
|
|
|
|
Think of `multi_dot` as::
|
|
|
|
def multi_dot(arrays): return functools.reduce(np.dot, arrays)
|
|
|
|
|
|
Parameters
|
|
----------
|
|
arrays : sequence of array_like
|
|
If the first argument is 1-D it is treated as row vector.
|
|
If the last argument is 1-D it is treated as column vector.
|
|
The other arguments must be 2-D.
|
|
|
|
Returns
|
|
-------
|
|
output : ndarray
|
|
Returns the dot product of the supplied arrays.
|
|
|
|
See Also
|
|
--------
|
|
dot : dot multiplication with two arguments.
|
|
|
|
References
|
|
----------
|
|
|
|
.. [1] Cormen, "Introduction to Algorithms", Chapter 15.2, p. 370-378
|
|
.. [2] https://en.wikipedia.org/wiki/Matrix_chain_multiplication
|
|
|
|
Examples
|
|
--------
|
|
`multi_dot` allows you to write::
|
|
|
|
>>> from numpy.linalg import multi_dot
|
|
>>> # Prepare some data
|
|
>>> A = np.random.random(10000, 100)
|
|
>>> B = np.random.random(100, 1000)
|
|
>>> C = np.random.random(1000, 5)
|
|
>>> D = np.random.random(5, 333)
|
|
>>> # the actual dot multiplication
|
|
>>> multi_dot([A, B, C, D])
|
|
|
|
instead of::
|
|
|
|
>>> np.dot(np.dot(np.dot(A, B), C), D)
|
|
>>> # or
|
|
>>> A.dot(B).dot(C).dot(D)
|
|
|
|
Notes
|
|
-----
|
|
The cost for a matrix multiplication can be calculated with the
|
|
following function::
|
|
|
|
def cost(A, B):
|
|
return A.shape[0] * A.shape[1] * B.shape[1]
|
|
|
|
Let's assume we have three matrices
|
|
:math:`A_{10x100}, B_{100x5}, C_{5x50}`.
|
|
|
|
The costs for the two different parenthesizations are as follows::
|
|
|
|
cost((AB)C) = 10*100*5 + 10*5*50 = 5000 + 2500 = 7500
|
|
cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000
|
|
|
|
"""
|
|
n = len(arrays)
|
|
# optimization only makes sense for len(arrays) > 2
|
|
if n < 2:
|
|
raise ValueError("Expecting at least two arrays.")
|
|
elif n == 2:
|
|
return dot(arrays[0], arrays[1])
|
|
|
|
arrays = [asanyarray(a) for a in arrays]
|
|
|
|
# save original ndim to reshape the result array into the proper form later
|
|
ndim_first, ndim_last = arrays[0].ndim, arrays[-1].ndim
|
|
# Explicitly convert vectors to 2D arrays to keep the logic of the internal
|
|
# _multi_dot_* functions as simple as possible.
|
|
if arrays[0].ndim == 1:
|
|
arrays[0] = atleast_2d(arrays[0])
|
|
if arrays[-1].ndim == 1:
|
|
arrays[-1] = atleast_2d(arrays[-1]).T
|
|
_assertRank2(*arrays)
|
|
|
|
# _multi_dot_three is much faster than _multi_dot_matrix_chain_order
|
|
if n == 3:
|
|
result = _multi_dot_three(arrays[0], arrays[1], arrays[2])
|
|
else:
|
|
order = _multi_dot_matrix_chain_order(arrays)
|
|
result = _multi_dot(arrays, order, 0, n - 1)
|
|
|
|
# return proper shape
|
|
if ndim_first == 1 and ndim_last == 1:
|
|
return result[0, 0] # scalar
|
|
elif ndim_first == 1 or ndim_last == 1:
|
|
return result.ravel() # 1-D
|
|
else:
|
|
return result
|
|
|
|
|
|
def _multi_dot_three(A, B, C):
|
|
"""
|
|
Find the best order for three arrays and do the multiplication.
|
|
|
|
For three arguments `_multi_dot_three` is approximately 15 times faster
|
|
than `_multi_dot_matrix_chain_order`
|
|
|
|
"""
|
|
a0, a1b0 = A.shape
|
|
b1c0, c1 = C.shape
|
|
# cost1 = cost((AB)C) = a0*a1b0*b1c0 + a0*b1c0*c1
|
|
cost1 = a0 * b1c0 * (a1b0 + c1)
|
|
# cost2 = cost(A(BC)) = a1b0*b1c0*c1 + a0*a1b0*c1
|
|
cost2 = a1b0 * c1 * (a0 + b1c0)
|
|
|
|
if cost1 < cost2:
|
|
return dot(dot(A, B), C)
|
|
else:
|
|
return dot(A, dot(B, C))
|
|
|
|
|
|
def _multi_dot_matrix_chain_order(arrays, return_costs=False):
|
|
"""
|
|
Return a np.array that encodes the optimal order of mutiplications.
|
|
|
|
The optimal order array is then used by `_multi_dot()` to do the
|
|
multiplication.
|
|
|
|
Also return the cost matrix if `return_costs` is `True`
|
|
|
|
The implementation CLOSELY follows Cormen, "Introduction to Algorithms",
|
|
Chapter 15.2, p. 370-378. Note that Cormen uses 1-based indices.
|
|
|
|
cost[i, j] = min([
|
|
cost[prefix] + cost[suffix] + cost_mult(prefix, suffix)
|
|
for k in range(i, j)])
|
|
|
|
"""
|
|
n = len(arrays)
|
|
# p stores the dimensions of the matrices
|
|
# Example for p: A_{10x100}, B_{100x5}, C_{5x50} --> p = [10, 100, 5, 50]
|
|
p = [a.shape[0] for a in arrays] + [arrays[-1].shape[1]]
|
|
# m is a matrix of costs of the subproblems
|
|
# m[i,j]: min number of scalar multiplications needed to compute A_{i..j}
|
|
m = zeros((n, n), dtype=double)
|
|
# s is the actual ordering
|
|
# s[i, j] is the value of k at which we split the product A_i..A_j
|
|
s = empty((n, n), dtype=intp)
|
|
|
|
for l in range(1, n):
|
|
for i in range(n - l):
|
|
j = i + l
|
|
m[i, j] = Inf
|
|
for k in range(i, j):
|
|
q = m[i, k] + m[k+1, j] + p[i]*p[k+1]*p[j+1]
|
|
if q < m[i, j]:
|
|
m[i, j] = q
|
|
s[i, j] = k # Note that Cormen uses 1-based index
|
|
|
|
return (s, m) if return_costs else s
|
|
|
|
|
|
def _multi_dot(arrays, order, i, j):
|
|
"""Actually do the multiplication with the given order."""
|
|
if i == j:
|
|
return arrays[i]
|
|
else:
|
|
return dot(_multi_dot(arrays, order, i, order[i, j]),
|
|
_multi_dot(arrays, order, order[i, j] + 1, j))
|