def solve(a, b, sym_pos=0, lower=0, overwrite_a=0, overwrite_b=0, debug=0):
"""Solve the equation a x = b for x
Parameters
----------
a : array, shape (M, M)
b : array, shape (M,) or (M, N)
sym_pos : boolean
Assume a is symmetric and positive definite
lower : boolean
Use only data contained in the lower triangle of a, if sym_pos is true.
Default is to use upper triangle.
overwrite_a : boolean
Allow overwriting data in a (may enhance performance)
overwrite_b : boolean
Allow overwriting data in b (may enhance performance)
Returns
-------
x : array, shape (M,) or (M, N) depending on b
Solution to the system a x = b
Raises LinAlgError if a is singular
"""
a1, b1 = map(asarray_chkfinite, (a, b))
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
if a1.shape[0] != b1.shape[0]:
raise ValueError, 'incompatible dimensions'
overwrite_a = overwrite_a or (a1 is not a and not hasattr(a, '__array__'))
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b, '__array__'))
if debug:
print 'solve:overwrite_a=', overwrite_a
print 'solve:overwrite_b=', overwrite_b
if sym_pos:
posv, = get_lapack_funcs(('posv', ), (a1, b1))
c, x, info = posv(a1,
b1,
lower=lower,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
else:
gesv, = get_lapack_funcs(('gesv', ), (a1, b1))
lu, piv, x, info = gesv(a1,
b1,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
if info == 0:
return x
if info > 0:
raise LinAlgError, "singular matrix"
raise ValueError,\
'illegal value in %-th argument of internal gesv|posv'%(-info)
def solve(a, b, sym_pos=0, lower=0, overwrite_a=0, overwrite_b=0,
debug = 0):
"""Solve the equation a x = b for x
Parameters
----------
a : array, shape (M, M)
b : array, shape (M,) or (M, N)
sym_pos : boolean
Assume a is symmetric and positive definite
lower : boolean
Use only data contained in the lower triangle of a, if sym_pos is true.
Default is to use upper triangle.
overwrite_a : boolean
Allow overwriting data in a (may enhance performance)
overwrite_b : boolean
Allow overwriting data in b (may enhance performance)
Returns
-------
x : array, shape (M,) or (M, N) depending on b
Solution to the system a x = b
Raises LinAlgError if a is singular
"""
a1, b1 = map(asarray_chkfinite,(a,b))
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
if a1.shape[0] != b1.shape[0]:
raise ValueError, 'incompatible dimensions'
overwrite_a = overwrite_a or (a1 is not a and not hasattr(a,'__array__'))
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b,'__array__'))
if debug:
print 'solve:overwrite_a=',overwrite_a
print 'solve:overwrite_b=',overwrite_b
if sym_pos:
posv, = get_lapack_funcs(('posv',),(a1,b1))
c,x,info = posv(a1,b1,
lower = lower,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
else:
gesv, = get_lapack_funcs(('gesv',),(a1,b1))
lu,piv,x,info = gesv(a1,b1,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
if info==0:
return x
if info>0:
raise LinAlgError, "singular matrix"
raise ValueError,\
'illegal value in %-th argument of internal gesv|posv'%(-info)
def _geneig(a1, b1, left, right, overwrite_a, overwrite_b):
ggev, = get_lapack_funcs(('ggev',), (a1, b1))
cvl, cvr = left, right
res = ggev(a1, b1, lwork=-1)
lwork = res[-2][0].real.astype(numpy.int)
if ggev.typecode in 'cz':
alpha, beta, vl, vr, work, info = ggev(a1, b1, cvl, cvr, lwork,
overwrite_a, overwrite_b)
w = alpha / beta
else:
alphar, alphai, beta, vl, vr, work, info = ggev(a1, b1, cvl, cvr, lwork,
overwrite_a,overwrite_b)
w = (alphar + _I * alphai) / beta
if info < 0:
raise ValueError('illegal value in %d-th argument of internal ggev'
% -info)
if info > 0:
raise LinAlgError("generalized eig algorithm did not converge (info=%d)"
% info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (ggev.typecode in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def rq(a, overwrite_a=False, lwork=None):
"""Compute RQ decomposition of a square real matrix.
Calculate the decomposition :lm:`A = R Q` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, M)
Square real matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
econ : boolean
Returns
-------
R : double array, shape (M, N) or (K, N) for econ==True
Size K = min(M, N)
Q : double or complex array, shape (M, M) or (M, K) for econ==True
Raises LinAlgError if decomposition fails
"""
# TODO: implement support for non-square and complex arrays
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M,N = a1.shape
if M != N:
raise ValueError('expected square matrix')
if issubclass(a1.dtype.type, complexfloating):
raise ValueError('expected real (non-complex) matrix')
overwrite_a = overwrite_a or (_datanotshared(a1, a))
gerqf, = get_lapack_funcs(('gerqf',), (a1,))
if lwork is None or lwork == -1:
# get optimal work array
rq, tau, work, info = gerqf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
rq, tau, work, info = gerqf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf'
% -info)
gemm, = get_blas_funcs(('gemm',), (rq,))
t = rq.dtype.char
R = special_matrices.triu(rq)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
k = min(M, N)
for i in range(k):
v = zeros((M,), t)
v[N-k+i] = 1
v[0:N-k+i] = rq[M-k+i, 0:N-k+i]
H = gemm(-tau[i], v, v, 1+0j, ident, trans_b=2)
Q = gemm(1, Q, H)
return R, Q
def rq(a, overwrite_a=False, lwork=None):
"""Compute RQ decomposition of a square real matrix.
Calculate the decomposition :lm:`A = R Q` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, M)
Square real matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
econ : boolean
Returns
-------
R : double array, shape (M, N) or (K, N) for econ==True
Size K = min(M, N)
Q : double or complex array, shape (M, M) or (M, K) for econ==True
Raises LinAlgError if decomposition fails
"""
# TODO: implement support for non-square and complex arrays
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M, N = a1.shape
if M != N:
raise ValueError('expected square matrix')
if issubclass(a1.dtype.type, complexfloating):
raise ValueError('expected real (non-complex) matrix')
overwrite_a = overwrite_a or (_datanotshared(a1, a))
gerqf, = get_lapack_funcs(('gerqf', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
rq, tau, work, info = gerqf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
rq, tau, work, info = gerqf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf' %
-info)
gemm, = get_blas_funcs(('gemm', ), (rq, ))
t = rq.dtype.char
R = special_matrices.triu(rq)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
k = min(M, N)
for i in range(k):
v = zeros((M, ), t)
v[N - k + i] = 1
v[0:N - k + i] = rq[M - k + i, 0:N - k + i]
H = gemm(-tau[i], v, v, 1 + 0j, ident, trans_b=2)
Q = gemm(1, Q, H)
return R, Q
def schur(a,output='real',lwork=None,overwrite_a=0):
"""Compute Schur decomposition of matrix a.
Description:
Return T, Z such that a = Z * T * (Z**H) where Z is a
unitary matrix and T is either upper-triangular or quasi-upper
triangular for output='real'
"""
if not output in ['real','complex','r','c']:
raise ValueError, "argument must be 'real', or 'complex'"
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError, 'expected square matrix'
typ = a1.dtype.char
if output in ['complex','c'] and typ not in ['F','D']:
if typ in _double_precision:
a1 = a1.astype('D')
typ = 'D'
else:
a1 = a1.astype('F')
typ = 'F'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
gees, = get_lapack_funcs(('gees',),(a1,))
if lwork is None or lwork == -1:
# get optimal work array
result = gees(lambda x: None,a,lwork=-1)
lwork = result[-2][0]
result = gees(lambda x: None,a,lwork=result[-2][0],overwrite_a=overwrite_a)
info = result[-1]
if info<0: raise ValueError,\
'illegal value in %-th argument of internal gees'%(-info)
elif info>0: raise LinAlgError, "Schur form not found. Possibly ill-conditioned."
return result[0], result[-3]
def solve_sylvester(a, b, q):
"""Computes a solution (X) to the Sylvester equation (AX + XB = Q).
.. versionadded:: 0.11.0
Parameters
----------
a : array, shape (M, M)
Leading matrix of the Sylvester equation
b : array, shape (N, N)
Trailing matrix of the Sylvester equation
q : array, shape (M, N)
Right-hand side
Returns
-------
x : array, shape (M, N)
The solution to the Sylvester equation.
Raises
------
LinAlgError
If solution was not found
Notes
-----
Computes a solution to the Sylvester matrix equation via the Bartels-
Stewart algorithm. The A and B matrices first undergo Schur
decompositions. The resulting matrices are used to construct an
alternative Sylvester equation (``RY + YS^T = F``) where the R and S
matrices are in quasi-triangular form (or, when R, S or F are complex,
triangular form). The simplified equation is then solved using
``*TRSYL`` from LAPACK directly.
"""
# Compute the Schur decomp form of a
r, u = schur(a, output='real')
# Compute the Schur decomp of b
s, v = schur(b.conj().transpose(), output='real')
# Construct f = u'*q*v
f = np.dot(np.dot(u.conj().transpose(), q), v)
# Call the Sylvester equation solver
trsyl, = get_lapack_funcs(('trsyl', ), (r, s, f))
if trsyl == None:
raise RuntimeError(
'LAPACK implementation does not contain a proper Sylvester equation solver (TRSYL)'
)
y, scale, info = trsyl(r, s, f, tranb='C')
y = scale * y
if info < 0:
raise LinAlgError("Illegal value encountered in the %d term" %
(-info, ))
return np.dot(np.dot(u, y), v.conj().transpose())
def solve(a, b, sym_pos=0, lower=0, overwrite_a=0, overwrite_b=0,
debug = 0):
""" solve(a, b, sym_pos=0, lower=0, overwrite_a=0, overwrite_b=0) -> x
Solve a linear system of equations a * x = b for x.
Inputs:
a -- An N x N matrix.
b -- An N x nrhs matrix or N vector.
sym_pos -- Assume a is symmetric and positive definite.
lower -- Assume a is lower triangular, otherwise upper one.
Only used if sym_pos is true.
overwrite_y - Discard data in y, where y is a or b.
Outputs:
x -- The solution to the system a * x = b
"""
a1, b1 = map(asarray_chkfinite,(a,b))
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
if a1.shape[0] != b1.shape[0]:
raise ValueError, 'incompatible dimensions'
overwrite_a = overwrite_a or (a1 is not a and not hasattr(a,'__array__'))
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b,'__array__'))
if debug:
print 'solve:overwrite_a=',overwrite_a
print 'solve:overwrite_b=',overwrite_b
if sym_pos:
posv, = get_lapack_funcs(('posv',),(a1,b1),debug=debug)
c,x,info = posv(a1,b1,
lower = lower,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
else:
gesv, = get_lapack_funcs(('gesv',),(a1,b1))
lu,piv,x,info = gesv(a1,b1,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
if info==0:
return x
if info>0:
raise LinAlgError, "singular matrix"
raise ValueError,\
'illegal value in %-th argument of internal gesv|posv'%(-info)
def qr_old(a, overwrite_a=False, lwork=None, check_finite=True):
"""Compute QR decomposition of a matrix.
Calculate the decomposition :lm:`A = Q R` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
Q : float or complex array, shape (M, M)
R : float or complex array, shape (M, N)
Size K = min(M, N)
Raises LinAlgError if decomposition fails
"""
if check_finite:
a1 = numpy.asarray_chkfinite(a)
else:
a1 = numpy.asarray(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M,N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
geqrf, = get_lapack_funcs(('geqrf',), (a1,))
if lwork is None or lwork == -1:
# get optimal work array
qr, tau, work, info = geqrf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
qr, tau, work, info = geqrf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf'
% -info)
gemm, = get_blas_funcs(('gemm',), (qr,))
t = qr.dtype.char
R = numpy.triu(qr)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
for i in range(min(M, N)):
v = zeros((M,), t)
v[i] = 1
v[i+1:M] = qr[i+1:M, i]
H = gemm(-tau[i], v, v, 1+0j, ident, trans_b=2)
Q = gemm(1, Q, H)
return Q, R
def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,
overwrite_b=False, debug=False):
"""Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
Parameters
----------
a : array, shape (M, M)
b : array, shape (M,) or (M, N)
lower : boolean
Use only data contained in the lower triangle of a.
Default is to use upper triangle.
trans : {0, 1, 2, 'N', 'T', 'C'}
Type of system to solve:
======== =========
trans system
======== =========
0 or 'N' a x = b
1 or 'T' a^T x = b
2 or 'C' a^H x = b
======== =========
unit_diagonal : boolean
If True, diagonal elements of A are assumed to be 1 and
will not be referenced.
overwrite_b : boolean
Allow overwriting data in b (may enhance performance)
Returns
-------
x : array, shape (M,) or (M, N) depending on b
Solution to the system a x = b
Raises
------
LinAlgError
If a is singular
"""
a1, b1 = map(asarray_chkfinite,(a,b))
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
if a1.shape[0] != b1.shape[0]:
raise ValueError('incompatible dimensions')
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b,'__array__'))
if debug:
print 'solve:overwrite_b=',overwrite_b
trans = {'N': 0, 'T': 1, 'C': 2}.get(trans, trans)
trtrs, = get_lapack_funcs(('trtrs',), (a1,b1))
x, info = trtrs(a1, b1, overwrite_b=overwrite_b, lower=lower,
trans=trans, unitdiag=unit_diagonal)
if info == 0:
return x
if info > 0:
raise LinAlgError("singular matrix: resolution failed at diagonal %s" % (info-1))
raise ValueError('illegal value in %d-th argument of internal trtrs')
def qr_old(a, overwrite_a=False, lwork=None, check_finite=True):
"""Compute QR decomposition of a matrix.
Calculate the decomposition :lm:`A = Q R` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
Q : float or complex array, shape (M, M)
R : float or complex array, shape (M, N)
Size K = min(M, N)
Raises LinAlgError if decomposition fails
"""
if check_finite:
a1 = numpy.asarray_chkfinite(a)
else:
a1 = numpy.asarray(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M, N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
geqrf, = get_lapack_funcs(('geqrf', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
qr, tau, work, info = geqrf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
qr, tau, work, info = geqrf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf' %
-info)
gemm, = get_blas_funcs(('gemm', ), (qr, ))
t = qr.dtype.char
R = numpy.triu(qr)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
for i in range(min(M, N)):
v = zeros((M, ), t)
v[i] = 1
v[i + 1:M] = qr[i + 1:M, i]
H = gemm(-tau[i], v, v, 1 + 0j, ident, trans_b=2)
Q = gemm(1, Q, H)
return Q, R
def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,
overwrite_b=False, debug=False):
"""Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
Parameters
----------
a : array, shape (M, M)
b : array, shape (M,) or (M, N)
lower : boolean
Use only data contained in the lower triangle of a.
Default is to use upper triangle.
trans : {0, 1, 2, 'N', 'T', 'C'}
Type of system to solve:
======== =========
trans system
======== =========
0 or 'N' a x = b
1 or 'T' a^T x = b
2 or 'C' a^H x = b
======== =========
unit_diagonal : boolean
If True, diagonal elements of A are assumed to be 1 and
will not be referenced.
overwrite_b : boolean
Allow overwriting data in b (may enhance performance)
Returns
-------
x : array, shape (M,) or (M, N) depending on b
Solution to the system a x = b
Raises
------
LinAlgError
If a is singular
"""
a1, b1 = map(np.asarray_chkfinite,(a,b))
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
if a1.shape[0] != b1.shape[0]:
raise ValueError('incompatible dimensions')
overwrite_b = overwrite_b or _datacopied(b1, b)
if debug:
print 'solve:overwrite_b=',overwrite_b
trans = {'N': 0, 'T': 1, 'C': 2}.get(trans, trans)
trtrs, = get_lapack_funcs(('trtrs',), (a1,b1))
x, info = trtrs(a1, b1, overwrite_b=overwrite_b, lower=lower,
trans=trans, unitdiag=unit_diagonal)
if info == 0:
return x
if info > 0:
raise LinAlgError("singular matrix: resolution failed at diagonal %s" % (info-1))
raise ValueError('illegal value in %d-th argument of internal trtrs')
def solveh_banded(ab, b, overwrite_ab=0, overwrite_b=0, lower=0):
"""Solve equation a x = b. a is Hermitian positive-definite banded matrix.
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Cells marked with * are not used.
Parameters
----------
ab : array, shape (M, u + 1)
Banded matrix
b : array, shape (M,) or (M, K)
Right-hand side
overwrite_ab : boolean
Discard data in ab (may enhance performance)
overwrite_b : boolean
Discard data in b (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
Returns
-------
c : array, shape (M, u+1)
Cholesky factorization of a, in the same banded format as ab
x : array, shape (M,) or (M, K)
The solution to the system a x = b
"""
ab, b = map(asarray_chkfinite, (ab, b))
pbsv, = get_lapack_funcs(('pbsv', ), (ab, b))
c, x, info = pbsv(ab,
b,
lower=lower,
overwrite_ab=overwrite_ab,
overwrite_b=overwrite_b)
if info == 0:
return c, x
if info > 0:
raise LinAlgError, "%d-th leading minor not positive definite" % info
raise ValueError,\
'illegal value in %d-th argument of internal pbsv'%(-info)
def solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False):
"""Solve equation a x = b. a is Hermitian positive-definite banded matrix.
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Cells marked with * are not used.
Parameters
----------
ab : array, shape (u + 1, M)
Banded matrix
b : array, shape (M,) or (M, K)
Right-hand side
overwrite_ab : boolean
Discard data in ab (may enhance performance)
overwrite_b : boolean
Discard data in b (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
Returns
-------
x : array, shape (M,) or (M, K)
The solution to the system a x = b
"""
ab, b = map(asarray_chkfinite, (ab, b))
# Validate shapes.
if ab.shape[-1] != b.shape[0]:
raise ValueError("shapes of ab and b are not compatible.")
pbsv, = get_lapack_funcs(('pbsv',), (ab, b))
c, x, info = pbsv(ab, b, lower=lower, overwrite_ab=overwrite_ab,
overwrite_b=overwrite_b)
if info > 0:
raise LinAlgError("%d-th leading minor not positive definite" % info)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal pbsv'
% -info)
return x
def solve_sylvester(a,b,q):
"""Computes a solution (X) to the Sylvester equation (AX + XB = Q).
.. versionadded:: 0.11.0
Parameters
----------
a : array, shape (M, M)
Leading matrix of the Sylvester equation
b : array, shape (N, N)
Trailing matrix of the Sylvester equation
q : array, shape (M, N)
Right-hand side
Returns
-------
x : array, shape (M, N)
The solution to the Sylvester equation.
Raises
------
LinAlgError
If solution was not found
Notes
-----
Computes a solution to the Sylvester matrix equation via the Bartels-
Stewart algorithm. The A and B matrices first undergo Schur
decompositions. The resulting matrices are used to construct an
alternative Sylvester equation (``RY + YS^T = F``) where the R and S
matrices are in quasi-triangular form (or, when R, S or F are complex,
triangular form). The simplified equation is then solved using
``*TRSYL`` from LAPACK directly.
"""
# Compute the Schur decomp form of a
r,u = schur(a, output='real')
# Compute the Schur decomp of b
s,v = schur(b.conj().transpose(), output='real')
# Construct f = u'*q*v
f = np.dot(np.dot(u.conj().transpose(), q), v)
# Call the Sylvester equation solver
trsyl, = get_lapack_funcs(('trsyl',), (r,s,f))
if trsyl == None:
raise RuntimeError('LAPACK implementation does not contain a proper Sylvester equation solver (TRSYL)')
y, scale, info = trsyl(r, s, f, tranb='C')
y = scale*y
if info < 0:
raise LinAlgError("Illegal value encountered in the %d term" % (-info,))
return np.dot(np.dot(u, y), v.conj().transpose())
def lstsq(a, b, cond=None, overwrite_a=0, overwrite_b=0):
""" lstsq(a, b, cond=None, overwrite_a=0, overwrite_b=0) -> x,resids,rank,s
Return least-squares solution of a * x = b.
Inputs:
a -- An M x N matrix.
b -- An M x nrhs matrix or M vector.
cond -- Used to determine effective rank of a.
Outputs:
x -- The solution (N x nrhs matrix) to the minimization problem:
2-norm(| b - a * x |) -> min
resids -- The residual sum-of-squares for the solution matrix x
(only if M>N and rank==N).
rank -- The effective rank of a.
s -- Singular values of a in decreasing order. The condition number
of a is abs(s[0]/s[-1]).
"""
a1, b1 = map(asarray_chkfinite,(a,b))
if len(a1.shape) != 2:
raise ValueError, 'expected matrix'
m,n = a1.shape
if len(b1.shape)==2: nrhs = b1.shape[1]
else: nrhs = 1
if m != b1.shape[0]:
raise ValueError, 'incompatible dimensions'
gelss, = get_lapack_funcs(('gelss',),(a1,b1))
if n>m:
# need to extend b matrix as it will be filled with
# a larger solution matrix
b2 = zeros((n,nrhs),gelss.typecode)
if len(b1.shape)==2: b2[:m,:] = b1
else: b2[:m,0] = b1
b1 = b2
overwrite_a = overwrite_a or (a1 is not a and not hasattr(a,'__array__'))
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b,'__array__'))
if gelss.module_name[:7] == 'flapack':
lwork = calc_lwork.gelss(gelss.prefix,m,n,nrhs)[1]
v,x,s,rank,info = gelss(a1,b1,cond = cond,
lwork = lwork,
overwrite_a = overwrite_a,
overwrite_b = overwrite_b)
else:
raise NotImplementedError,'calling gelss from %s' % (gelss.module_name)
if info>0: raise LinAlgError, "SVD did not converge in Linear Least Squares"
if info<0: raise ValueError,\
'illegal value in %-th argument of internal gelss'%(-info)
resids = asarray([],x.typecode())
if n<m:
x1 = x[:n]
if rank==n: resids = sum(x[n:]**2)
x = x1
return x,resids,rank,s
def lu_factor(a, overwrite_a=False, check_finite=True):
"""Compute pivoted LU decomposition of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
diagonal elements, and U upper triangular.
Parameters
----------
a : array, shape (M, M)
Matrix to decompose
overwrite_a : boolean
Whether to overwrite data in A (may increase performance)
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
lu : array, shape (N, N)
Matrix containing U in its upper triangle, and L in its lower triangle.
The unit diagonal elements of L are not stored.
piv : array, shape (N,)
Pivot indices representing the permutation matrix P:
row i of matrix was interchanged with row piv[i].
See also
--------
lu_solve : solve an equation system using the LU factorization of a matrix
Notes
-----
This is a wrapper to the ``*GETRF`` routines from LAPACK.
"""
if check_finite:
a1 = asarray_chkfinite(a)
else:
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
getrf, = get_lapack_funcs(('getrf',), (a1,))
lu, piv, info = getrf(a1, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of '
'internal getrf (lu_factor)' % -info)
if info > 0:
warn("Diagonal number %d is exactly zero. Singular matrix." % info,
RuntimeWarning)
return lu, piv
def rq(a,overwrite_a=0,lwork=None):
"""RQ decomposition of an M x N matrix a.
Description:
Find an upper-triangular matrix r and a unitary (orthogonal)
matrix q such that r * q = a
Inputs:
a -- the matrix
overwrite_a=0 -- if non-zero then discard the contents of a,
i.e. a is used as a work array if possible.
lwork=None -- >= shape(a)[1]. If None (or -1) compute optimal
work array size.
Outputs:
r, q -- matrices such that r * q = a
"""
# TODO: implement support for non-square and complex arrays
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError, 'expected matrix'
M,N = a1.shape
if M != N:
raise ValueError, 'expected square matrix'
if issubclass(a1.dtype.type,complexfloating):
raise ValueError, 'expected real (non-complex) matrix'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
gerqf, = get_lapack_funcs(('gerqf',),(a1,))
if lwork is None or lwork == -1:
# get optimal work array
rq,tau,work,info = gerqf(a1,lwork=-1,overwrite_a=1)
lwork = work[0]
rq,tau,work,info = gerqf(a1,lwork=lwork,overwrite_a=overwrite_a)
if info<0: raise ValueError, \
'illegal value in %-th argument of internal geqrf'%(-info)
gemm, = get_blas_funcs(('gemm',),(rq,))
t = rq.dtype.char
R = basic.triu(rq)
Q = numpy.identity(M,dtype=t)
ident = numpy.identity(M,dtype=t)
zeros = numpy.zeros
k = min(M,N)
for i in range(k):
v = zeros((M,),t)
v[N-k+i] = 1
v[0:N-k+i] = rq[M-k+i,0:N-k+i]
H = gemm(-tau[i],v,v,1+0j,ident,trans_b=2)
Q = gemm(1,Q,H)
return R, Q
def lu_factor(a, overwrite_a=False, check_finite=True):
"""Compute pivoted LU decomposition of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
diagonal elements, and U upper triangular.
Parameters
----------
a : array, shape (M, M)
Matrix to decompose
overwrite_a : boolean
Whether to overwrite data in A (may increase performance)
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
lu : array, shape (N, N)
Matrix containing U in its upper triangle, and L in its lower triangle.
The unit diagonal elements of L are not stored.
piv : array, shape (N,)
Pivot indices representing the permutation matrix P:
row i of matrix was interchanged with row piv[i].
See also
--------
lu_solve : solve an equation system using the LU factorization of a matrix
Notes
-----
This is a wrapper to the ``*GETRF`` routines from LAPACK.
"""
if check_finite:
a1 = asarray_chkfinite(a)
else:
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
getrf, = get_lapack_funcs(('getrf', ), (a1, ))
lu, piv, info = getrf(a1, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of '
'internal getrf (lu_factor)' % -info)
if info > 0:
warn("Diagonal number %d is exactly zero. Singular matrix." % info,
RuntimeWarning)
return lu, piv
def hessenberg(a,calc_q=0,overwrite_a=0):
""" Compute Hessenberg form of a matrix.
Inputs:
a -- the matrix
calc_q -- if non-zero then calculate unitary similarity
transformation matrix q.
overwrite_a=0 -- if non-zero then discard the contents of a,
i.e. a is used as a work array if possible.
Outputs:
h -- Hessenberg form of a [calc_q=0]
h, q -- matrices such that a = q * h * q^T [calc_q=1]
"""
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
gehrd,gebal = get_lapack_funcs(('gehrd','gebal'),(a1,))
ba,lo,hi,pivscale,info = gebal(a,permute=1,overwrite_a = overwrite_a)
if info<0: raise ValueError,\
'illegal value in %-th argument of internal gebal (hessenberg)'%(-info)
n = len(a1)
lwork = calc_lwork.gehrd(gehrd.prefix,n,lo,hi)
hq,tau,info = gehrd(ba,lo=lo,hi=hi,lwork=lwork,overwrite_a=1)
if info<0: raise ValueError,\
'illegal value in %-th argument of internal gehrd (hessenberg)'%(-info)
if not calc_q:
for i in range(lo,hi):
hq[i+2:hi+1,i] = 0.0
return hq
# XXX: Use ORGHR routines to compute q.
ger,gemm = get_blas_funcs(('ger','gemm'),(hq,))
typecode = hq.dtype.char
q = None
for i in range(lo,hi):
if tau[i]==0.0:
continue
v = zeros(n,dtype=typecode)
v[i+1] = 1.0
v[i+2:hi+1] = hq[i+2:hi+1,i]
hq[i+2:hi+1,i] = 0.0
h = ger(-tau[i],v,v,a=diag(ones(n,dtype=typecode)),overwrite_a=1)
if q is None:
q = h
else:
q = gemm(1.0,q,h)
if q is None:
q = diag(ones(n,dtype=typecode))
return hq,q
def cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True):
"""Cholesky decompose a banded Hermitian positive-definite matrix
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Parameters
----------
ab : array, shape (u + 1, M)
Banded matrix
overwrite_ab : boolean
Discard data in ab (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
c : array, shape (u+1, M)
Cholesky factorization of a, in the same banded format as ab
"""
if check_finite:
ab = asarray_chkfinite(ab)
else:
ab = asarray(ab)
pbtrf, = get_lapack_funcs(('pbtrf', ), (ab, ))
c, info = pbtrf(ab, lower=lower, overwrite_ab=overwrite_ab)
if info > 0:
raise LinAlgError("%d-th leading minor not positive definite" % info)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal pbtrf' %
-info)
return c
def cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True):
"""Cholesky decompose a banded Hermitian positive-definite matrix
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Parameters
----------
ab : array, shape (u + 1, M)
Banded matrix
overwrite_ab : boolean
Discard data in ab (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
check_finite : boolean, optional
Whether to check the input matrixes contain only finite numbers.
Disabling may give a performance gain, but may result to problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
c : array, shape (u+1, M)
Cholesky factorization of a, in the same banded format as ab
"""
if check_finite:
ab = asarray_chkfinite(ab)
else:
ab = asarray(ab)
pbtrf, = get_lapack_funcs(('pbtrf',), (ab,))
c, info = pbtrf(ab, lower=lower, overwrite_ab=overwrite_ab)
if info > 0:
raise LinAlgError("%d-th leading minor not positive definite" % info)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal pbtrf'
% -info)
return c
def qr_old(a, overwrite_a=False, lwork=None):
"""Compute QR decomposition of a matrix.
Calculate the decomposition :lm:`A = Q R` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
Returns
-------
Q : double or complex array, shape (M, M)
R : double or complex array, shape (M, N)
Size K = min(M, N)
Raises LinAlgError if decomposition fails
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M,N = a1.shape
overwrite_a = overwrite_a or (_datanotshared(a1, a))
geqrf, = get_lapack_funcs(('geqrf',), (a1,))
if lwork is None or lwork == -1:
# get optimal work array
qr, tau, work, info = geqrf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
qr, tau, work, info = geqrf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf'
% -info)
gemm, = get_blas_funcs(('gemm',), (qr,))
t = qr.dtype.char
R = special_matrices.triu(qr)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
for i in range(min(M, N)):
v = zeros((M,), t)
v[i] = 1
v[i+1:M] = qr[i+1:M, i]
H = gemm(-tau[i], v, v, 1+0j, ident, trans_b=2)
Q = gemm(1, Q, H)
return Q, R
def qr_old(a, overwrite_a=False, lwork=None):
"""Compute QR decomposition of a matrix.
Calculate the decomposition :lm:`A = Q R` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
Returns
-------
Q : double or complex array, shape (M, M)
R : double or complex array, shape (M, N)
Size K = min(M, N)
Raises LinAlgError if decomposition fails
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M,N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
geqrf, = get_lapack_funcs(('geqrf',), (a1,))
if lwork is None or lwork == -1:
# get optimal work array
qr, tau, work, info = geqrf(a1, lwork=-1, overwrite_a=1)
lwork = work[0]
qr, tau, work, info = geqrf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geqrf'
% -info)
gemm, = get_blas_funcs(('gemm',), (qr,))
t = qr.dtype.char
R = special_matrices.triu(qr)
Q = numpy.identity(M, dtype=t)
ident = numpy.identity(M, dtype=t)
zeros = numpy.zeros
for i in range(min(M, N)):
v = zeros((M,), t)
v[i] = 1
v[i+1:M] = qr[i+1:M, i]
H = gemm(-tau[i], v, v, 1, ident, trans_b=2)
Q = gemm(1, Q, H)
return Q, R
def cho_factor(a, lower=0, overwrite_a=0):
""" Compute Cholesky decomposition of matrix and return an object
to be used for solving a linear system using cho_solve.
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
potrf, = get_lapack_funcs(('potrf',),(a1,))
c,info = potrf(a1,lower=lower,overwrite_a=overwrite_a,clean=0)
if info>0: raise LinAlgError, "matrix not positive definite"
if info<0: raise ValueError,\
'illegal value in %-th argument of internal potrf'%(-info)
return c, lower
def cholesky_banded(ab, overwrite_ab=0, lower=0):
"""Cholesky decompose a banded Hermitian positive-definite matrix
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Parameters
----------
ab : array, shape (M, u + 1)
Banded matrix
overwrite_ab : boolean
Discard data in ab (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
Returns
-------
c : array, shape (M, u+1)
Cholesky factorization of a, in the same banded format as ab
"""
ab = asarray_chkfinite(ab)
pbtrf, = get_lapack_funcs(('pbtrf',),(ab,))
c,info = pbtrf(ab,
lower=lower,
overwrite_ab=overwrite_ab)
if info==0:
return c
if info>0:
raise LinAlgError, "%d-th leading minor not positive definite" % info
raise ValueError,\
'illegal value in %d-th argument of internal pbtrf'%(-info)
def cholesky_banded(ab, overwrite_ab=0, lower=0):
"""Cholesky decompose a banded Hermitian positive-definite matrix
The matrix a is stored in ab either in lower diagonal or upper
diagonal ordered form:
ab[u + i - j, j] == a[i,j] (if upper form; i <= j)
ab[ i - j, j] == a[i,j] (if lower form; i >= j)
Example of ab (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Parameters
----------
ab : array, shape (M, u + 1)
Banded matrix
overwrite_ab : boolean
Discard data in ab (may enhance performance)
lower : boolean
Is the matrix in the lower form. (Default is upper form)
Returns
-------
c : array, shape (M, u+1)
Cholesky factorization of a, in the same banded format as ab
"""
ab = asarray_chkfinite(ab)
pbtrf, = get_lapack_funcs(('pbtrf',),(ab,))
c,info = pbtrf(ab,
lower=lower,
overwrite_ab=overwrite_ab)
if info==0:
return c
if info>0:
raise LinAlgError, "%d-th leading minor not positive definite" % info
raise ValueError,\
'illegal value in %d-th argument of internal pbtrf'%(-info)
def inv(a, overwrite_a=0):
""" inv(a, overwrite_a=0) -> a_inv
Return inverse of square matrix a.
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (a1 is not a and not hasattr(a,'__array__'))
#XXX: I found no advantage or disadvantage of using finv.
## finv, = get_flinalg_funcs(('inv',),(a1,))
## if finv is not None:
## a_inv,info = finv(a1,overwrite_a=overwrite_a)
## if info==0:
## return a_inv
## if info>0: raise LinAlgError, "singular matrix"
## if info<0: raise ValueError,\
## 'illegal value in %-th argument of internal inv.getrf|getri'%(-info)
getrf,getri = get_lapack_funcs(('getrf','getri'),(a1,))
#XXX: C ATLAS versions of getrf/i have rowmajor=1, this could be
# exploited for further optimization. But it will be probably
# a mess. So, a good testing site is required before trying
# to do that.
if getrf.module_name[:7]=='clapack'!=getri.module_name[:7]:
# ATLAS 3.2.1 has getrf but not getri.
lu,piv,info = getrf(transpose(a1),
rowmajor=0,overwrite_a=overwrite_a)
lu = transpose(lu)
else:
lu,piv,info = getrf(a1,overwrite_a=overwrite_a)
if info==0:
if getri.module_name[:7] == 'flapack':
lwork = calc_lwork.getri(getri.prefix,a1.shape[0])
lwork = lwork[1]
# XXX: the following line fixes curious SEGFAULT when
# benchmarking 500x500 matrix inverse. This seems to
# be a bug in LAPACK ?getri routine because if lwork is
# minimal (when using lwork[0] instead of lwork[1]) then
# all tests pass. Further investigation is required if
# more such SEGFAULTs occur.
lwork = int(1.01*lwork)
inv_a,info = getri(lu,piv,
lwork=lwork,overwrite_lu=1)
else: # clapack
inv_a,info = getri(lu,piv,overwrite_lu=1)
if info>0: raise LinAlgError, "singular matrix"
if info<0: raise ValueError,\
'illegal value in %-th argument of internal getrf|getri'%(-info)
return inv_a
def _cholesky(a, lower=False, overwrite_a=False, clean=True):
"""Common code for cholesky() and cho_factor()."""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError("expected square matrix")
overwrite_a = overwrite_a or _datanotshared(a1, a)
potrf, = get_lapack_funcs(("potrf",), (a1,))
c, info = potrf(a1, lower=lower, overwrite_a=overwrite_a, clean=clean)
if info > 0:
raise LinAlgError("%d-th leading minor not positive definite" % info)
if info < 0:
raise ValueError("illegal value in %d-th argument of internal potrf" % -info)
return c, lower
def qr_old(a,overwrite_a=0,lwork=None):
"""QR decomposition of an M x N matrix a.
Description:
Find a unitary (orthogonal) matrix, q, and an upper-triangular
matrix r such that q * r = a
Inputs:
a -- the matrix
overwrite_a=0 -- if non-zero then discard the contents of a,
i.e. a is used as a work array if possible.
lwork=None -- >= shape(a)[1]. If None (or -1) compute optimal
work array size.
Outputs:
q, r -- matrices such that q * r = a
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError, 'expected matrix'
M,N = a1.shape
overwrite_a = overwrite_a or (_datanotshared(a1,a))
geqrf, = get_lapack_funcs(('geqrf',),(a1,))
if lwork is None or lwork == -1:
# get optimal work array
qr,tau,work,info = geqrf(a1,lwork=-1,overwrite_a=1)
lwork = work[0]
qr,tau,work,info = geqrf(a1,lwork=lwork,overwrite_a=overwrite_a)
if info<0: raise ValueError,\
'illegal value in %-th argument of internal geqrf'%(-info)
gemm, = get_blas_funcs(('gemm',),(qr,))
t = qr.dtype.char
R = basic.triu(qr)
Q = numpy.identity(M,dtype=t)
ident = numpy.identity(M,dtype=t)
zeros = numpy.zeros
for i in range(min(M,N)):
v = zeros((M,),t)
v[i] = 1
v[i+1:M] = qr[i+1:M,i]
H = gemm(-tau[i],v,v,1+0j,ident,trans_b=2)
Q = gemm(1,Q,H)
return Q, R
def lu_factor(a, overwrite_a=False):
"""Compute pivoted LU decomposition of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
diagonal elements, and U upper triangular.
Parameters
----------
a : array, shape (M, M)
Matrix to decompose
overwrite_a : boolean
Whether to overwrite data in A (may increase performance)
Returns
-------
lu : array, shape (N, N)
Matrix containing U in its upper triangle, and L in its lower triangle.
The unit diagonal elements of L are not stored.
piv : array, shape (N,)
Pivot indices representing the permutation matrix P:
row i of matrix was interchanged with row piv[i].
See also
--------
lu_solve : solve an equation system using the LU factorization of a matrix
Notes
-----
This is a wrapper to the *GETRF routines from LAPACK.
"""
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1, a))
getrf, = get_lapack_funcs(('getrf', ), (a1, ))
lu, piv, info = getrf(a, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of '
'internal getrf (lu_factor)' % -info)
if info > 0:
warn("Diagonal number %d is exactly zero. Singular matrix." % info,
RuntimeWarning)
return lu, piv
def svd(a,full_matrices=1,compute_uv=1,overwrite_a=0):
"""Compute singular value decomposition (SVD) of matrix a.
Description:
Singular value decomposition of a matrix a is
a = u * sigma * v^H,
where v^H denotes conjugate(transpose(v)), u,v are unitary
matrices, sigma is zero matrix with a main diagonal containing
real non-negative singular values of the matrix a.
Inputs:
a -- An M x N matrix.
compute_uv -- If zero, then only the vector of singular values
is returned.
Outputs:
u -- An M x M unitary matrix [compute_uv=1].
s -- An min(M,N) vector of singular values in descending order,
sigma = diagsvd(s).
vh -- An N x N unitary matrix [compute_uv=1], vh = v^H.
"""
# A hack until full_matrices == 0 support is fixed here.
if full_matrices == 0:
import numpy.linalg
return numpy.linalg.svd(a, full_matrices=0, compute_uv=compute_uv)
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError, 'expected matrix'
m,n = a1.shape
overwrite_a = overwrite_a or (_datanotshared(a1,a))
gesdd, = get_lapack_funcs(('gesdd',),(a1,))
if gesdd.module_name[:7] == 'flapack':
lwork = calc_lwork.gesdd(gesdd.prefix,m,n,compute_uv)[1]
u,s,v,info = gesdd(a1,compute_uv = compute_uv, lwork = lwork,
overwrite_a = overwrite_a)
else: # 'clapack'
raise NotImplementedError,'calling gesdd from %s' % (gesdd.module_name)
if info>0: raise LinAlgError, "SVD did not converge"
if info<0: raise ValueError,\
'illegal value in %-th argument of internal gesdd'%(-info)
if compute_uv:
return u,s,v
else:
return s
def lu_factor(a, overwrite_a=False):
"""Compute pivoted LU decomposition of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
diagonal elements, and U upper triangular.
Parameters
----------
a : array, shape (M, M)
Matrix to decompose
overwrite_a : boolean
Whether to overwrite data in A (may increase performance)
Returns
-------
lu : array, shape (N, N)
Matrix containing U in its upper triangle, and L in its lower triangle.
The unit diagonal elements of L are not stored.
piv : array, shape (N,)
Pivot indices representing the permutation matrix P:
row i of matrix was interchanged with row piv[i].
See also
--------
lu_solve : solve an equation system using the LU factorization of a matrix
Notes
-----
This is a wrapper to the *GETRF routines from LAPACK.
"""
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1, a))
getrf, = get_lapack_funcs(('getrf',), (a1,))
lu, piv, info = getrf(a, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of '
'internal getrf (lu_factor)' % -info)
if info > 0:
warn("Diagonal number %d is exactly zero. Singular matrix." % info,
RuntimeWarning)
return lu, piv
def _cholesky(a, lower=False, overwrite_a=False, clean=True):
"""Common code for cholesky() and cho_factor()."""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or _datacopied(a1, a)
potrf, = get_lapack_funcs(('potrf',), (a1,))
c, info = potrf(a1, lower=lower, overwrite_a=overwrite_a, clean=clean)
if info > 0:
raise LinAlgError("%d-th leading minor not positive definite" % info)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal potrf'
% -info)
return c, lower
def cho_solve(clow, b):
"""Solve a previously factored symmetric system of equations.
First input is a tuple (LorU, lower) which is the output to cho_factor.
Second input is the right-hand side.
"""
c, lower = clow
c = asarray_chkfinite(c)
_assert_squareness(c)
b = asarray_chkfinite(b)
potrs, = get_lapack_funcs(('potrs',),(c,))
b, info = potrs(c,b,lower)
if info < 0:
msg = "Argument %d to lapack's ?potrs() has an illegal value." % info
raise TypeError, msg
if info > 0:
msg = "Unknown error occured int ?potrs(): error code = %d" % info
raise TypeError, msg
return b
def solveh_banded(ab, b, overwrite_ab=0, overwrite_b=0,
lower=0):
""" solveh_banded(ab, b, overwrite_ab=0, overwrite_b=0) -> c, x
Solve a linear system of equations a * x = b for x where
a is a banded symmetric or Hermitian positive definite
matrix stored in lower diagonal ordered form (lower=1)
a11 a22 a33 a44 a55 a66
a21 a32 a43 a54 a65 *
a31 a42 a53 a64 * *
or upper diagonal ordered form
* * a31 a42 a53 a64
* a21 a32 a43 a54 a65
a11 a22 a33 a44 a55 a66
Inputs:
ab -- An N x l
b -- An N x nrhs matrix or N vector.
overwrite_y - Discard data in y, where y is ab or b.
lower - is ab in lower or upper form?
Outputs:
c: the Cholesky factorization of ab
x: the solution to ab * x = b
"""
ab, b = map(asarray_chkfinite,(ab,b))
pbsv, = get_lapack_funcs(('pbsv',),(ab,b))
c,x,info = pbsv(ab,b,
lower=lower,
overwrite_ab=overwrite_ab,
overwrite_b=overwrite_b)
if info==0:
return c, x
if info>0:
raise LinAlgError, "%d-th leading minor not positive definite" % info
raise ValueError,\
'illegal value in %d-th argument of internal pbsv'%(-info)
def lu_solve(a_lu_pivots,b):
"""Solve a previously factored system. First input is a tuple (lu, pivots)
which is the output to lu_factor. Second input is the right hand side.
"""
a_lu, pivots = a_lu_pivots
a_lu = asarray_chkfinite(a_lu)
pivots = asarray_chkfinite(pivots)
b = asarray_chkfinite(b)
_assert_squareness(a_lu)
getrs, = get_lapack_funcs(('getrs',),(a_lu,))
b, info = getrs(a_lu,pivots,b)
if info < 0:
msg = "Argument %d to lapack's ?getrs() has an illegal value." % info
raise TypeError, msg
if info > 0:
msg = "Unknown error occured int ?getrs(): error code = %d" % info
raise TypeError, msg
return b
def _geneig(a1, b, left, right, overwrite_a, overwrite_b):
b1 = asarray(b)
overwrite_b = overwrite_b or _datacopied(b1, b)
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError('expected square matrix')
ggev, = get_lapack_funcs(('ggev', ), (a1, b1))
cvl, cvr = left, right
ggev_info = get_func_info(ggev)
if ggev_info.module_name[:7] == 'clapack':
raise NotImplementedError('calling ggev from %s' %
get_func_info(ggev).module_name)
res = ggev(a1, b1, lwork=-1)
lwork = res[-2][0]
if ggev_info.prefix in 'cz':
alpha, beta, vl, vr, work, info = ggev(a1, b1, cvl, cvr, lwork,
overwrite_a, overwrite_b)
w = alpha / beta
else:
alphar, alphai, beta, vl, vr, work, info = ggev(
a1, b1, cvl, cvr, lwork, overwrite_a, overwrite_b)
w = (alphar + _I * alphai) / beta
if info < 0:
raise ValueError('illegal value in %d-th argument of internal ggev' %
-info)
if info > 0:
raise LinAlgError(
"generalized eig algorithm did not converge (info=%d)" % info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (ggev_info.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def cholesky(a,lower=0,overwrite_a=0):
"""Compute Cholesky decomposition of matrix.
Description:
For a hermitian positive-definite matrix a return the
upper-triangular (or lower-triangular if lower==1) matrix,
u such that u^H * u = a (or l * l^H = a).
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or _datanotshared(a1,a)
potrf, = get_lapack_funcs(('potrf',),(a1,))
c,info = potrf(a1,lower=lower,overwrite_a=overwrite_a,clean=1)
if info>0: raise LinAlgError, "matrix not positive definite"
if info<0: raise ValueError,\
'illegal value in %-th argument of internal potrf'%(-info)
return c
def cholesky_banded(ab, overwrite_ab=0, lower=0):
""" cholesky_banded(ab, overwrite_ab=0, lower=0) -> c
Compute the Cholesky decomposition of a
banded symmetric or Hermitian positive definite
matrix stored in lower diagonal ordered form (lower=1)
a11 a22 a33 a44 a55 a66
a21 a32 a43 a54 a65 *
a31 a42 a53 a64 * *
or upper diagonal ordered form
* * a31 a42 a53 a64
* a21 a32 a43 a54 a65
a11 a22 a33 a44 a55 a66
Inputs:
ab -- An N x l
overwrite_ab - Discard data in ab
lower - is ab in lower or upper form?
Outputs:
c: the Cholesky factorization of ab
"""
ab = asarray_chkfinite(ab)
pbtrf, = get_lapack_funcs(('pbtrf',),(ab,))
c,info = pbtrf(ab,
lower=lower,
overwrite_ab=overwrite_ab)
if info==0:
return c
if info>0:
raise LinAlgError, "%d-th leading minor not positive definite" % info
raise ValueError,\
'illegal value in %d-th argument of internal pbtrf'%(-info)
def _geneig(a1, b, left, right, overwrite_a, overwrite_b):
b1 = asarray(b)
overwrite_b = overwrite_b or _datacopied(b1, b)
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError('expected square matrix')
ggev, = get_lapack_funcs(('ggev',), (a1, b1))
cvl, cvr = left, right
ggev_info = get_func_info(ggev)
if ggev_info.module_name[:7] == 'clapack':
raise NotImplementedError('calling ggev from %s' % get_func_info(ggev).module_name)
res = ggev(a1, b1, lwork=-1)
lwork = res[-2][0]
if ggev_info.prefix in 'cz':
alpha, beta, vl, vr, work, info = ggev(a1, b1, cvl, cvr, lwork,
overwrite_a, overwrite_b)
w = alpha / beta
else:
alphar, alphai, beta, vl, vr, work, info = ggev(a1, b1, cvl, cvr, lwork,
overwrite_a,overwrite_b)
w = (alphar + _I * alphai) / beta
if info < 0:
raise ValueError('illegal value in %d-th argument of internal ggev'
% -info)
if info > 0:
raise LinAlgError("generalized eig algorithm did not converge (info=%d)"
% info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (ggev_info.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def _geneig(a1,b,left,right,overwrite_a,overwrite_b):
b1 = asarray(b)
overwrite_b = overwrite_b or (b1 is not b and not hasattry(b,'__array__'))
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError, 'expected square matrix'
ggev, = get_lapack_funcs(('ggev',),(a1,b1))
cvl,cvr = left,right
if ggev.module_name[:7] == 'clapack':
raise NotImplementedError,'calling ggev from %s' % (ggev.module_name)
res = ggev(a1,b1,lwork=-1)
lwork = res[-2][0]
if ggev.prefix in 'cz':
alpha,beta,vl,vr,work,info = ggev(a1,b1,cvl,cvr,lwork,
overwrite_a,overwrite_b)
w = alpha / beta
else:
alphar,alphai,beta,vl,vr,work,info = ggev(a1,b1,cvl,cvr,lwork,
overwrite_a,overwrite_b)
w = (alphar+_I*alphai)/beta
if info<0: raise ValueError,\
'illegal value in %-th argument of internal ggev'%(-info)
if info>0: raise LinAlgError,"generalized eig algorithm did not converge"
only_real = scipy_base.logical_and.reduce(scipy_base.equal(w.imag,0.0))
if not (ggev.prefix in 'cz' or only_real):
t = w.typecode()
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def lu_factor(a, overwrite_a=0):
"""Return raw LU decomposition of a matrix and pivots, for use in solving
a system of linear equations.
Inputs:
a --- an NxN matrix
Outputs:
lu --- the lu factorization matrix
piv --- an array of pivots
"""
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError, 'expected square matrix'
overwrite_a = overwrite_a or (_datanotshared(a1,a))
getrf, = get_lapack_funcs(('getrf',),(a1,))
lu, piv, info = getrf(a,overwrite_a=overwrite_a)
if info<0: raise ValueError,\
'illegal value in %-th argument of internal getrf (lu_factor)'%(-info)
if info>0: warn("Diagonal number %d is exactly zero. Singular matrix." % info,
RuntimeWarning)
return lu, piv
def hessenberg(a, calc_q=False, overwrite_a=False):
"""
Compute Hessenberg form of a matrix.
The Hessenberg decomposition is::
A = Q H Q^H
where `Q` is unitary/orthogonal and `H` has only zero elements below
the first sub-diagonal.
Parameters
----------
a : ndarray
Matrix to bring into Hessenberg form, of shape ``(M,M)``.
calc_q : bool, optional
Whether to compute the transformation matrix. Default is False.
overwrite_a : bool, optional
Whether to overwrite `a`; may improve performance.
Default is False.
Returns
-------
H : ndarray
Hessenberg form of `a`, of shape (M,M).
Q : ndarray
Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``.
Only returned if ``calc_q=True``. Of shape (M,M).
"""
a1 = asarray(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
gehrd,gebal = get_lapack_funcs(('gehrd','gebal'), (a1,))
ba, lo, hi, pivscale, info = gebal(a1, permute=1, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gebal '
'(hessenberg)' % -info)
n = len(a1)
lwork = calc_lwork.gehrd(gehrd.prefix, n, lo, hi)
hq, tau, info = gehrd(ba, lo=lo, hi=hi, lwork=lwork, overwrite_a=1)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gehrd '
'(hessenberg)' % -info)
if not calc_q:
for i in range(lo, hi):
hq[i+2:hi+1, i] = 0.0
return hq
# XXX: Use ORGHR routines to compute q.
typecode = hq.dtype
ger,gemm = get_blas_funcs(('ger','gemm'), dtype=typecode)
q = None
for i in range(lo, hi):
if tau[i]==0.0:
continue
v = zeros(n, dtype=typecode)
v[i+1] = 1.0
v[i+2:hi+1] = hq[i+2:hi+1, i]
hq[i+2:hi+1, i] = 0.0
h = ger(-tau[i], v, v,a=diag(ones(n, dtype=typecode)), overwrite_a=1)
if q is None:
q = h
else:
q = gemm(1.0, q, h)
if q is None:
q = diag(ones(n, dtype=typecode))
return hq, q
def eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False,
select='a', select_range=None, max_ev = 0):
"""Solve real symmetric or complex hermitian band matrix eigenvalue problem.
Find eigenvalues w and optionally right eigenvectors v of a::
a v[:,i] = w[i] v[:,i]
v.H v = identity
The matrix a is stored in a_band either in lower diagonal or upper
diagonal ordered form:
a_band[u + i - j, j] == a[i,j] (if upper form; i <= j)
a_band[ i - j, j] == a[i,j] (if lower form; i >= j)
where u is the number of bands above the diagonal.
Example of a_band (shape of a is (6,6), u=2)::
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
Cells marked with * are not used.
Parameters
----------
a_band : array, shape (u+1, M)
The bands of the M by M matrix a.
lower : boolean
Is the matrix in the lower form. (Default is upper form)
eigvals_only : boolean
Compute only the eigenvalues and no eigenvectors.
(Default: calculate also eigenvectors)
overwrite_a_band:
Discard data in a_band (may enhance performance)
select: {'a', 'v', 'i'}
Which eigenvalues to calculate
====== ========================================
select calculated
====== ========================================
'a' All eigenvalues
'v' Eigenvalues in the interval (min, max]
'i' Eigenvalues with indices min <= i <= max
====== ========================================
select_range : (min, max)
Range of selected eigenvalues
max_ev : integer
For select=='v', maximum number of eigenvalues expected.
For other values of select, has no meaning.
In doubt, leave this parameter untouched.
Returns
-------
w : array, shape (M,)
The eigenvalues, in ascending order, each repeated according to its
multiplicity.
v : double or complex double array, shape (M, M)
The normalized eigenvector corresponding to the eigenvalue w[i] is
the column v[:,i].
Raises LinAlgError if eigenvalue computation does not converge
"""
if eigvals_only or overwrite_a_band:
a1 = asarray_chkfinite(a_band)
overwrite_a_band = overwrite_a_band or (_datacopied(a1, a_band))
else:
a1 = array(a_band)
if issubclass(a1.dtype.type, inexact) and not isfinite(a1).all():
raise ValueError("array must not contain infs or NaNs")
overwrite_a_band = 1
if len(a1.shape) != 2:
raise ValueError('expected two-dimensional array')
if select.lower() not in [0, 1, 2, 'a', 'v', 'i', 'all', 'value', 'index']:
raise ValueError('invalid argument for select')
if select.lower() in [0, 'a', 'all']:
if a1.dtype.char in 'GFD':
bevd, = get_lapack_funcs(('hbevd',), (a1,))
# FIXME: implement this somewhen, for now go with builtin values
# FIXME: calc optimal lwork by calling ?hbevd(lwork=-1)
# or by using calc_lwork.f ???
# lwork = calc_lwork.hbevd(bevd.prefix, a1.shape[0], lower)
internal_name = 'hbevd'
else: # a1.dtype.char in 'fd':
bevd, = get_lapack_funcs(('sbevd',), (a1,))
# FIXME: implement this somewhen, for now go with builtin values
# see above
# lwork = calc_lwork.sbevd(bevd.prefix, a1.shape[0], lower)
internal_name = 'sbevd'
w,v,info = bevd(a1, compute_v=not eigvals_only,
lower=lower,
overwrite_ab=overwrite_a_band)
if select.lower() in [1, 2, 'i', 'v', 'index', 'value']:
# calculate certain range only
if select.lower() in [2, 'i', 'index']:
select = 2
vl, vu, il, iu = 0.0, 0.0, min(select_range), max(select_range)
if min(il, iu) < 0 or max(il, iu) >= a1.shape[1]:
raise ValueError('select_range out of bounds')
max_ev = iu - il + 1
else: # 1, 'v', 'value'
select = 1
vl, vu, il, iu = min(select_range), max(select_range), 0, 0
if max_ev == 0:
max_ev = a_band.shape[1]
if eigvals_only:
max_ev = 1
# calculate optimal abstol for dsbevx (see manpage)
if a1.dtype.char in 'fF': # single precision
lamch, = get_lapack_funcs(('lamch',), (array(0, dtype='f'),))
else:
lamch, = get_lapack_funcs(('lamch',), (array(0, dtype='d'),))
abstol = 2 * lamch('s')
if a1.dtype.char in 'GFD':
bevx, = get_lapack_funcs(('hbevx',), (a1,))
internal_name = 'hbevx'
else: # a1.dtype.char in 'gfd'
bevx, = get_lapack_funcs(('sbevx',), (a1,))
internal_name = 'sbevx'
# il+1, iu+1: translate python indexing (0 ... N-1) into Fortran
# indexing (1 ... N)
w, v, m, ifail, info = bevx(a1, vl, vu, il+1, iu+1,
compute_v=not eigvals_only,
mmax=max_ev,
range=select, lower=lower,
overwrite_ab=overwrite_a_band,
abstol=abstol)
# crop off w and v
w = w[:m]
if not eigvals_only:
v = v[:, :m]
if info < 0:
raise ValueError('illegal value in %d-th argument of internal %s'
% (-info, internal_name))
if info > 0:
raise LinAlgError("eig algorithm did not converge")
if eigvals_only:
return w
return w, v
def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
overwrite_b=False, turbo=True, eigvals=None, type=1):
"""Solve an ordinary or generalized eigenvalue problem for a complex
Hermitian or real symmetric matrix.
Find eigenvalues w and optionally eigenvectors v of matrix a, where
b is positive definite::
a v[:,i] = w[i] b v[:,i]
v[i,:].conj() a v[:,i] = w[i]
v[i,:].conj() b v[:,i] = 1
Parameters
----------
a : array, shape (M, M)
A complex Hermitian or real symmetric matrix whose eigenvalues and
eigenvectors will be computed.
b : array, shape (M, M)
A complex Hermitian or real symmetric definite positive matrix in.
If omitted, identity matrix is assumed.
lower : boolean
Whether the pertinent array data is taken from the lower or upper
triangle of a. (Default: lower)
eigvals_only : boolean
Whether to calculate only eigenvalues and no eigenvectors.
(Default: both are calculated)
turbo : boolean
Use divide and conquer algorithm (faster but expensive in memory,
only for generalized eigenvalue problem and if eigvals=None)
eigvals : tuple (lo, hi)
Indexes of the smallest and largest (in ascending order) eigenvalues
and corresponding eigenvectors to be returned: 0 <= lo < hi <= M-1.
If omitted, all eigenvalues and eigenvectors are returned.
type: integer
Specifies the problem type to be solved:
type = 1: a v[:,i] = w[i] b v[:,i]
type = 2: a b v[:,i] = w[i] v[:,i]
type = 3: b a v[:,i] = w[i] v[:,i]
overwrite_a : boolean
Whether to overwrite data in a (may improve performance)
overwrite_b : boolean
Whether to overwrite data in b (may improve performance)
Returns
-------
w : real array, shape (N,)
The N (1<=N<=M) selected eigenvalues, in ascending order, each
repeated according to its multiplicity.
(if eigvals_only == False)
v : complex array, shape (M, N)
The normalized selected eigenvector corresponding to the
eigenvalue w[i] is the column v[:,i]. Normalization:
type 1 and 3: v.conj() a v = w
type 2: inv(v).conj() a inv(v) = w
type = 1 or 2: v.conj() b v = I
type = 3 : v.conj() inv(b) v = I
Raises LinAlgError if eigenvalue computation does not converge,
an error occurred, or b matrix is not definite positive. Note that
if input matrices are not symmetric or hermitian, no error is reported
but results will be wrong.
See Also
--------
eig : eigenvalues and right eigenvectors for non-symmetric arrays
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
if iscomplexobj(a1):
cplx = True
else:
cplx = False
if b is not None:
b1 = asarray_chkfinite(b)
overwrite_b = overwrite_b or _datacopied(b1, b)
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError('expected square matrix')
if b1.shape != a1.shape:
raise ValueError("wrong b dimensions %s, should "
"be %s" % (str(b1.shape), str(a1.shape)))
if iscomplexobj(b1):
cplx = True
else:
cplx = cplx or False
else:
b1 = None
# Set job for fortran routines
_job = (eigvals_only and 'N') or 'V'
# port eigenvalue range from python to fortran convention
if eigvals is not None:
lo, hi = eigvals
if lo < 0 or hi >= a1.shape[0]:
raise ValueError('The eigenvalue range specified is not valid.\n'
'Valid range is [%s,%s]' % (0, a1.shape[0]-1))
lo += 1
hi += 1
eigvals = (lo, hi)
# set lower
if lower:
uplo = 'L'
else:
uplo = 'U'
# fix prefix for lapack routines
if cplx:
pfx = 'he'
else:
pfx = 'sy'
# Standard Eigenvalue Problem
# Use '*evr' routines
# FIXME: implement calculation of optimal lwork
# for all lapack routines
if b1 is None:
(evr,) = get_lapack_funcs((pfx+'evr',), (a1,))
if eigvals is None:
w, v, info = evr(a1, uplo=uplo, jobz=_job, range="A", il=1,
iu=a1.shape[0], overwrite_a=overwrite_a)
else:
(lo, hi)= eigvals
w_tot, v, info = evr(a1, uplo=uplo, jobz=_job, range="I",
il=lo, iu=hi, overwrite_a=overwrite_a)
w = w_tot[0:hi-lo+1]
# Generalized Eigenvalue Problem
else:
# Use '*gvx' routines if range is specified
if eigvals is not None:
(gvx,) = get_lapack_funcs((pfx+'gvx',), (a1,b1))
(lo, hi) = eigvals
w_tot, v, ifail, info = gvx(a1, b1, uplo=uplo, iu=hi,
itype=type,jobz=_job, il=lo,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
w = w_tot[0:hi-lo+1]
# Use '*gvd' routine if turbo is on and no eigvals are specified
elif turbo:
(gvd,) = get_lapack_funcs((pfx+'gvd',), (a1,b1))
v, w, info = gvd(a1, b1, uplo=uplo, itype=type, jobz=_job,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
# Use '*gv' routine if turbo is off and no eigvals are specified
else:
(gv,) = get_lapack_funcs((pfx+'gv',), (a1,b1))
v, w, info = gv(a1, b1, uplo=uplo, itype= type, jobz=_job,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
# Check if we had a successful exit
if info == 0:
if eigvals_only:
return w
else:
return w, v
elif info < 0:
raise LinAlgError("illegal value in %i-th argument of internal"
" fortran routine." % (-info))
elif info > 0 and b1 is None:
raise LinAlgError("unrecoverable internal error.")
# The algorithm failed to converge.
elif info > 0 and info <= b1.shape[0]:
if eigvals is not None:
raise LinAlgError("the eigenvectors %s failed to"
" converge." % nonzero(ifail)-1)
else:
raise LinAlgError("internal fortran routine failed to converge: "
"%i off-diagonal elements of an "
"intermediate tridiagonal form did not converge"
" to zero." % info)
# This occurs when b is not positive definite
else:
raise LinAlgError("the leading minor of order %i"
" of 'b' is not positive definite. The"
" factorization of 'b' could not be completed"
" and no eigenvalues or eigenvectors were"
" computed." % (info-b1.shape[0]))
def rq(a, overwrite_a=False, lwork=None, mode='full'):
"""Compute RQ decomposition of a square real matrix.
Calculate the decomposition :lm:`A = R Q` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, M)
Matrix to be decomposed
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
lwork : integer
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
mode : {'full', 'r', 'economic'}
Determines what information is to be returned: either both Q and R
('full', default), only R ('r') or both Q and R but computed in
economy-size ('economic', see Notes).
Returns
-------
R : double array, shape (M, N)
Q : double or complex array, shape (M, M)
Raises LinAlgError if decomposition fails
Examples
--------
>>> from scipy import linalg
>>> from numpy import random, dot, allclose
>>> a = random.randn(6, 9)
>>> r, q = linalg.rq(a)
>>> allclose(a, dot(r, q))
True
>>> r.shape, q.shape
((6, 9), (9, 9))
>>> r2 = linalg.rq(a, mode='r')
>>> allclose(r, r2)
True
>>> r3, q3 = linalg.rq(a, mode='economic')
>>> r3.shape, q3.shape
((6, 6), (6, 9))
"""
if not mode in ['full', 'r', 'economic']:
raise ValueError(\
"Mode argument should be one of ['full', 'r', 'economic']")
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
M, N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
gerqf, = get_lapack_funcs(('gerqf', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
rq, tau, work, info = gerqf(a1, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
rq, tau, work, info = gerqf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gerqf' %
-info)
if not mode == 'economic' or N < M:
R = special_matrices.triu(rq, N - M)
else:
R = special_matrices.triu(rq[-M:, -M:])
if mode == 'r':
return R
if find_best_lapack_type((a1, ))[0] in ('s', 'd'):
gor_un_grq, = get_lapack_funcs(('orgrq', ), (rq, ))
else:
gor_un_grq, = get_lapack_funcs(('ungrq', ), (rq, ))
if N < M:
# get optimal work array
Q, work, info = gor_un_grq(rq[-N:], tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_grq(rq[-N:], tau, lwork=lwork, overwrite_a=1)
elif mode == 'economic':
# get optimal work array
Q, work, info = gor_un_grq(rq, tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_grq(rq, tau, lwork=lwork, overwrite_a=1)
else:
rq1 = numpy.empty((N, N), dtype=rq.dtype)
rq1[-M:] = rq
# get optimal work array
Q, work, info = gor_un_grq(rq1, tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_grq(rq1, tau, lwork=lwork, overwrite_a=1)
if info < 0:
raise ValueError("illegal value in %d-th argument of internal orgrq" %
-info)
return R, Q
def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False):
"""Compute QR decomposition of a matrix.
Calculate the decomposition :lm:`A = Q R` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
lwork : int, optional
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
mode : {'full', 'r', 'economic'}
Determines what information is to be returned: either both Q and R
('full', default), only R ('r') or both Q and R but computed in
economy-size ('economic', see Notes).
pivoting : bool, optional
Whether or not factorization should include pivoting for rank-revealing
qr decomposition. If pivoting, compute the decomposition
:lm:`A P = Q R` as above, but where P is chosen such that the diagonal
of R is non-increasing.
Returns
-------
Q : double or complex ndarray
Of shape (M, M), or (M, K) for ``mode='economic'``. Not returned if
``mode='r'``.
R : double or complex ndarray
Of shape (M, N), or (K, N) for ``mode='economic'``. ``K = min(M, N)``.
P : integer ndarray
Of shape (N,) for ``pivoting=True``. Not returned if ``pivoting=False``.
Raises
------
LinAlgError
Raised if decomposition fails
Notes
-----
This is an interface to the LAPACK routines dgeqrf, zgeqrf,
dorgqr, zungqr, dgeqp3, and zgeqp3.
If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
of (M,M) and (M,N), with ``K=min(M,N)``.
Examples
--------
>>> from scipy import random, linalg, dot, diag, all, allclose
>>> a = random.randn(9, 6)
>>> q, r = linalg.qr(a)
>>> allclose(a, dot(q, r))
True
>>> q.shape, r.shape
((9, 9), (9, 6))
>>> r2 = linalg.qr(a, mode='r')
>>> allclose(r, r2)
True
>>> q3, r3 = linalg.qr(a, mode='economic')
>>> q3.shape, r3.shape
((9, 6), (6, 6))
>>> q4, r4, p4 = linalg.qr(a, pivoting=True)
>>> d = abs(diag(r4))
>>> all(d[1:] <= d[:-1])
True
>>> allclose(a[:, p4], dot(q4, r4))
True
>>> q4.shape, r4.shape, p4.shape
((9, 9), (9, 6), (6,))
>>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
>>> q5.shape, r5.shape, p5.shape
((9, 6), (6, 6), (6,))
"""
if mode == 'qr':
# 'qr' was the old default, equivalent to 'full'. Neither 'full' nor
# 'qr' are used below, but set to 'full' anyway to be sure
mode = 'full'
if not mode in ['full', 'qr', 'r', 'economic']:
raise ValueError(\
"Mode argument should be one of ['full', 'r', 'economic']")
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError("expected 2D array")
M, N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
if pivoting:
geqp3, = get_lapack_funcs(('geqp3', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
qr, jpvt, tau, work, info = geqp3(a1, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
qr, jpvt, tau, work, info = geqp3(a1,
lwork=lwork,
overwrite_a=overwrite_a)
jpvt -= 1 # geqp3 returns a 1-based index array, so subtract 1
if info < 0:
raise ValueError(
"illegal value in %d-th argument of internal geqp3" % -info)
else:
geqrf, = get_lapack_funcs(('geqrf', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
qr, tau, work, info = geqrf(a1, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
qr, tau, work, info = geqrf(a1, lwork=lwork, overwrite_a=overwrite_a)
if info < 0:
raise ValueError(
"illegal value in %d-th argument of internal geqrf" % -info)
if not mode == 'economic' or M < N:
R = special_matrices.triu(qr)
else:
R = special_matrices.triu(qr[0:N, 0:N])
if mode == 'r':
if pivoting:
return R, jpvt
else:
return R
if find_best_lapack_type((a1, ))[0] in ('s', 'd'):
gor_un_gqr, = get_lapack_funcs(('orgqr', ), (qr, ))
else:
gor_un_gqr, = get_lapack_funcs(('ungqr', ), (qr, ))
if M < N:
# get optimal work array
Q, work, info = gor_un_gqr(qr[:, 0:M], tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_gqr(qr[:, 0:M], tau, lwork=lwork, overwrite_a=1)
elif mode == 'economic':
# get optimal work array
Q, work, info = gor_un_gqr(qr, tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_gqr(qr, tau, lwork=lwork, overwrite_a=1)
else:
t = qr.dtype.char
qqr = numpy.empty((M, M), dtype=t)
qqr[:, 0:N] = qr
# get optimal work array
Q, work, info = gor_un_gqr(qqr, tau, lwork=-1, overwrite_a=1)
lwork = work[0].real.astype(numpy.int)
Q, work, info = gor_un_gqr(qqr, tau, lwork=lwork, overwrite_a=1)
if info < 0:
raise ValueError("illegal value in %d-th argument of internal gorgqr" %
-info)
if pivoting:
return Q, R, jpvt
return Q, R
def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False):
"""Singular Value Decomposition.
Factorizes the matrix a into two unitary matrices U and Vh and
an 1d-array s of singular values (real, non-negative) such that
a == U S Vh if S is an suitably shaped matrix of zeros whose
main diagonal is s.
Parameters
----------
a : array, shape (M, N)
Matrix to decompose
full_matrices : boolean
If true, U, Vh are shaped (M,M), (N,N)
If false, the shapes are (M,K), (K,N) where K = min(M,N)
compute_uv : boolean
Whether to compute also U, Vh in addition to s (Default: true)
overwrite_a : boolean
Whether data in a is overwritten (may improve performance)
Returns
-------
U: array, shape (M,M) or (M,K) depending on full_matrices
s: array, shape (K,)
The singular values, sorted so that s[i] >= s[i+1]. K = min(M, N)
Vh: array, shape (N,N) or (K,N) depending on full_matrices
For compute_uv = False, only s is returned.
Raises LinAlgError if SVD computation does not converge
Examples
--------
>>> from scipy import random, linalg, allclose, dot
>>> a = random.randn(9, 6) + 1j*random.randn(9, 6)
>>> U, s, Vh = linalg.svd(a)
>>> U.shape, Vh.shape, s.shape
((9, 9), (6, 6), (6,))
>>> U, s, Vh = linalg.svd(a, full_matrices=False)
>>> U.shape, Vh.shape, s.shape
((9, 6), (6, 6), (6,))
>>> S = linalg.diagsvd(s, 6, 6)
>>> allclose(a, dot(U, dot(S, Vh)))
True
>>> s2 = linalg.svd(a, compute_uv=False)
>>> allclose(s, s2)
True
See also
--------
svdvals : return singular values of a matrix
diagsvd : return the Sigma matrix, given the vector s
"""
# A hack until full_matrices == 0 support is fixed here.
if full_matrices == 0:
import numpy.linalg
return numpy.linalg.svd(a, full_matrices=0, compute_uv=compute_uv)
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
m, n = a1.shape
overwrite_a = overwrite_a or (_datanotshared(a1, a))
gesdd, = get_lapack_funcs(('gesdd', ), (a1, ))
if gesdd.module_name[:7] == 'flapack':
lwork = calc_lwork.gesdd(gesdd.prefix, m, n, compute_uv)[1]
u, s, v, info = gesdd(a1,
compute_uv=compute_uv,
lwork=lwork,
overwrite_a=overwrite_a)
else: # 'clapack'
raise NotImplementedError('calling gesdd from %s' % gesdd.module_name)
if info > 0:
raise LinAlgError("SVD did not converge")
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gesdd' %
-info)
if compute_uv:
return u, s, v
else:
return s
def qr_multiply(a, c, mode='right', pivoting=False, conjugate=False,
overwrite_a=False, overwrite_c=False):
"""Calculate the QR decomposition and multiply Q with a matrix.
Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
and R upper triangular. Multiply Q with a vector or a matrix c.
.. versionadded:: 0.11
Parameters
----------
a : ndarray, shape (M, N)
Matrix to be decomposed
c : ndarray, one- or two-dimensional
calculate the product of c and q, depending on the mode:
mode : {'left', 'right'}
``dot(Q, c)`` is returned if mode is 'left',
``dot(c, Q)`` is returned if mode is 'right'.
The shape of c must be appropriate for the matrix multiplications,
if mode is 'left', ``min(a.shape) == c.shape[0]``,
if mode is 'right', ``a.shape[0] == c.shape[1]``.
pivoting : bool, optional
Whether or not factorization should include pivoting for rank-revealing
qr decomposition, see the documentation of qr.
conjugate : bool, optional
Whether Q should be complex-conjugated. This might be faster
than explicit conjugation.
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
overwrite_c: bool, optional
Whether data in c is overwritten (may improve performance).
If this is used, c must be big enough to keep the result,
i.e. c.shape[0] = a.shape[0] if mode is 'left'.
Returns
-------
CQ : float or complex ndarray
the product of Q and c, as defined in mode
R : float or complex ndarray
Of shape (K, N), ``K = min(M, N)``.
P : ndarray of ints
Of shape (N,) for ``pivoting=True``. Not returned if ``pivoting=False``.
Raises
------
LinAlgError
Raised if decomposition fails
Notes
-----
This is an interface to the LAPACK routines dgeqrf, zgeqrf,
dormqr, zunmqr, dgeqp3, and zgeqp3.
"""
if not mode in ['left', 'right']:
raise ValueError("Mode argument should be one of ['left', 'right']")
c = numpy.asarray_chkfinite(c)
onedim = c.ndim == 1
if onedim:
c = c.reshape(1, len(c))
if mode == "left":
c = c.T
a = numpy.asarray(a) # chkfinite done in qr
M, N = a.shape
if not (mode == "left" and
(not overwrite_c and min(M, N) == c.shape[0] or
overwrite_c and M == c.shape[0]) or
mode == "right" and M == c.shape[1]):
raise ValueError("objects are not aligned")
raw = qr(a, overwrite_a, None, "raw", pivoting)
Q, tau = raw[0]
if find_best_lapack_type((Q,))[0] in ('s', 'd'):
gor_un_mqr, = get_lapack_funcs(('ormqr',), (Q,))
trans = "T"
else:
gor_un_mqr, = get_lapack_funcs(('unmqr',), (Q,))
trans = "C"
Q = Q[:, :min(M, N)]
if M > N and mode == "left" and not overwrite_c:
if conjugate:
cc = numpy.zeros((c.shape[1], M), dtype=c.dtype, order="F")
cc[:, :N] = c.T
else:
cc = numpy.zeros((M, c.shape[1]), dtype=c.dtype, order="F")
cc[:N, :] = c
trans = "N"
if conjugate:
lr = "R"
else:
lr = "L"
overwrite_c = True
elif c.flags["C_CONTIGUOUS"] and trans == "T" or conjugate:
cc = c.T
if mode == "left":
lr = "R"
else:
lr = "L"
else:
trans = "N"
cc = c
if mode == "left":
lr = "L"
else:
lr = "R"
cQ, = safecall(gor_un_mqr, "gormqr/gunmqr", lr, trans, Q, tau, cc,
overwrite_c=overwrite_c)
if trans != "N":
cQ = cQ.T
if mode == "right":
cQ = cQ[:, :min(M, N)]
if onedim:
cQ = cQ.ravel()
return (cQ,) + raw[1:]
def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False):
"""
Compute least-squares solution to equation Ax = b.
Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
Parameters
----------
a : array, shape (M, N)
Left hand side matrix (2-D array).
b : array, shape (M,) or (M, K)
Right hand side matrix or vector (1-D or 2-D array).
cond : float, optional
Cutoff for 'small' singular values; used to determine effective
rank of a. Singular values smaller than
``rcond * largest_singular_value`` are considered zero.
overwrite_a : bool, optional
Discard data in `a` (may enhance performance). Default is False.
overwrite_b : bool, optional
Discard data in `b` (may enhance performance). Default is False.
Returns
-------
x : array, shape (N,) or (N, K) depending on shape of b
Least-squares solution.
residues : ndarray, shape () or (1,) or (K,)
Sums of residues, squared 2-norm for each column in ``b - a x``.
If rank of matrix a is < N or > M this is an empty array.
If b was 1-D, this is an (1,) shape array, otherwise the shape is (K,).
rank : int
Effective rank of matrix `a`.
s : array, shape (min(M,N),)
Singular values of `a`. The condition number of a is
``abs(s[0]/s[-1])``.
Raises
------
LinAlgError :
If computation does not converge.
See Also
--------
optimize.nnls : linear least squares with non-negativity constraint
"""
a1, b1 = map(asarray_chkfinite, (a, b))
if len(a1.shape) != 2:
raise ValueError('expected matrix')
m, n = a1.shape
if len(b1.shape) == 2:
nrhs = b1.shape[1]
else:
nrhs = 1
if m != b1.shape[0]:
raise ValueError('incompatible dimensions')
gelss, = get_lapack_funcs(('gelss', ), (a1, b1))
gelss_info = get_func_info(gelss)
if n > m:
# need to extend b matrix as it will be filled with
# a larger solution matrix
b2 = zeros((n, nrhs), dtype=gelss_info.dtype)
if len(b1.shape) == 2:
b2[:m, :] = b1
else:
b2[:m, 0] = b1
b1 = b2
overwrite_a = overwrite_a or _datacopied(a1, a)
overwrite_b = overwrite_b or _datacopied(b1, b)
if gelss_info.module_name[:7] == 'flapack':
lwork = calc_lwork.gelss(gelss_info.prefix, m, n, nrhs)[1]
v, x, s, rank, info = gelss(a1,
b1,
cond=cond,
lwork=lwork,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b)
else:
raise NotImplementedError('calling gelss from %s' %
get_func_info(gelss).module_name)
if info > 0:
raise LinAlgError("SVD did not converge in Linear Least Squares")
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gelss' %
-info)
resids = asarray([], dtype=x.dtype)
if n < m:
x1 = x[:n]
if rank == n:
resids = sum(abs(x[n:])**2, axis=0)
x = x1
return x, resids, rank, s
Returns
-------
x : array
Solution to the system
See also
--------
lu_factor : LU factorize a matrix
"""
b1 = asarray_chkfinite(b)
overwrite_b = overwrite_b or (b1 is not b and not hasattr(b, '__array__'))
if lu.shape[0] != b1.shape[0]:
raise ValueError("incompatible dimensions.")
getrs, = get_lapack_funcs(('getrs', ), (lu, b1))
x, info = getrs(lu, piv, b1, trans=trans, overwrite_b=overwrite_b)
if info == 0:
return x
raise ValueError('illegal value in %d-th argument of internal gesv|posv' %
-info)
def lu(a, permute_l=False, overwrite_a=False):
"""Compute pivoted LU decompostion of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
def inv(a, overwrite_a=False):
"""
Compute the inverse of a matrix.
Parameters
----------
a : array_like
Square matrix to be inverted.
overwrite_a : bool, optional
Discard data in `a` (may improve performance). Default is False.
Returns
-------
ainv : ndarray
Inverse of the matrix `a`.
Raises
------
LinAlgError :
If `a` is singular.
ValueError :
If `a` is not square, or not 2-dimensional.
Examples
--------
>>> a = np.array([[1., 2.], [3., 4.]])
>>> sp.linalg.inv(a)
array([[-2. , 1. ],
[ 1.5, -0.5]])
>>> np.dot(a, sp.linalg.inv(a))
array([[ 1., 0.],
[ 0., 1.]])
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or _datacopied(a1, a)
#XXX: I found no advantage or disadvantage of using finv.
## finv, = get_flinalg_funcs(('inv',),(a1,))
## if finv is not None:
## a_inv,info = finv(a1,overwrite_a=overwrite_a)
## if info==0:
## return a_inv
## if info>0: raise LinAlgError, "singular matrix"
## if info<0: raise ValueError,\
## 'illegal value in %d-th argument of internal inv.getrf|getri'%(-info)
getrf, getri = get_lapack_funcs(('getrf', 'getri'), (a1, ))
getrf_info = get_func_info(getrf)
getri_info = get_func_info(getri)
#XXX: C ATLAS versions of getrf/i have rowmajor=1, this could be
# exploited for further optimization. But it will be probably
# a mess. So, a good testing site is required before trying
# to do that.
if (getrf_info.module_name[:7] == 'clapack' != getri_info.module_name[:7]):
# ATLAS 3.2.1 has getrf but not getri.
lu, piv, info = getrf(transpose(a1),
rowmajor=0,
overwrite_a=overwrite_a)
lu = transpose(lu)
else:
lu, piv, info = getrf(a1, overwrite_a=overwrite_a)
if info == 0:
if getri_info.module_name[:7] == 'flapack':
lwork = calc_lwork.getri(getri_info.prefix, a1.shape[0])
lwork = lwork[1]
# XXX: the following line fixes curious SEGFAULT when
# benchmarking 500x500 matrix inverse. This seems to
# be a bug in LAPACK ?getri routine because if lwork is
# minimal (when using lwork[0] instead of lwork[1]) then
# all tests pass. Further investigation is required if
# more such SEGFAULTs occur.
lwork = int(1.01 * lwork)
inv_a, info = getri(lu, piv, lwork=lwork, overwrite_lu=1)
else: # clapack
inv_a, info = getri(lu, piv, overwrite_lu=1)
if info > 0:
raise LinAlgError("singular matrix")
if info < 0:
raise ValueError('illegal value in %d-th argument of internal '
'getrf|getri' % -info)
return inv_a
"""
a1, b1 = map(asarray_chkfinite, (ab, b))
# Validate shapes.
if a1.shape[-1] != b1.shape[0]:
raise ValueError("shapes of ab and b are not compatible.")
if l + u + 1 != a1.shape[0]:
raise ValueError(
"invalid values for the number of lower and upper diagonals:"
" l+u+1 (%d) does not equal ab.shape[0] (%d)" %
(l + u + 1, ab.shape[0]))
overwrite_b = overwrite_b or _datacopied(b1, b)
gbsv, = get_lapack_funcs(('gbsv', ), (a1, b1))
a2 = zeros((2 * l + u + 1, a1.shape[1]), dtype=get_func_info(gbsv).dtype)
a2[l:, :] = a1
lu, piv, x, info = gbsv(l,
u,
a2,
b1,
overwrite_ab=True,
overwrite_b=overwrite_b)
if info == 0:
return x
if info > 0:
raise LinAlgError("singular matrix")
raise ValueError('illegal value in %d-th argument of internal gbsv' %
-info)
def qz(A,
B,
output='real',
lwork=None,
sort=None,
overwrite_a=False,
overwrite_b=False):
"""
QZ decompostion for generalized eigenvalues of a pair of matrices.
The QZ, or generalized Schur, decomposition for a pair of N x N
nonsymmetric matrices (A,B) is
(A,B) = (Q*AA*Z', Q*BB*Z')
where AA, BB is in generalized Schur form if BB is upper-triangular
with non-negative diagonal and AA is upper-triangular, or for real QZ
decomposition (output='real') block upper triangular with 1x1
and 2x2 blocks. In this case, the 1x1 blocks correpsond to real
generalized eigenvalues and 2x2 blocks are 'standardized' by making
the correpsonding elements of BB have the form::
[ a 0 ]
[ 0 b ]
and the pair of correpsonding 2x2 blocks in AA and BB will have a complex
conjugate pair of generalized eigenvalues. If (output='complex') or A
and B are complex matrices, Z' denotes the conjugate-transpose of Z.
Q and Z are unitary matrices.
Parameters
----------
A : array-like, shape (N,N)
2d array to decompose
B : array-like, shape (N,N)
2d array to decompose
output : str {'real','complex'}
Construct the real or complex QZ decomposition for real matrices.
lwork : integer, optional
Work array size. If None or -1, it is automatically computed.
sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}
Specifies whether the upper eigenvalues should be sorted. A callable
may be passed that, given a eigenvalue, returns a boolean denoting
whether the eigenvalue should be sorted to the top-left (True). For
real matrix pairs, the sort function takes three real arguments
(alphar, alphai, beta). The eigenvalue x = (alphar + alphai*1j)/beta.
For complex matrix pairs or output='complex', the sort function
takes two complex arguments (alpha, beta). The eigenvalue
x = (alpha/beta).
Alternatively, string parameters may be used:
'lhp' Left-hand plane (x.real < 0.0)
'rhp' Right-hand plane (x.real > 0.0)
'iuc' Inside the unit circle (x*x.conjugate() <= 1.0)
'ouc' Outside the unit circle (x*x.conjugate() > 1.0)
Defaults to None (no sorting).
Returns
-------
AA : array, shape (N,N)
Generalized Schur form of A.
BB : array, shape (N,N)
Generalized Schur form of B.
Q : array, shape (N,N)
The left Schur vectors.
Z : array, shape (N,N)
The right Schur vectors.
sdim : int
If sorting was requested, a fifth return value will contain the
number of eigenvalues for which the sort condition was True.
Notes
-----
Q is transposed versus the equivalent function in Matlab.
.. versionadded:: 0.11.0
"""
if not output in ['real', 'complex', 'r', 'c']:
raise ValueError("argument must be 'real', or 'complex'")
a1 = asarray_chkfinite(A)
b1 = asarray_chkfinite(B)
a_m, a_n = a1.shape
b_m, b_n = b1.shape
try:
assert a_m == a_n == b_m == b_n
except AssertionError:
raise ValueError("Array dimensions must be square and agree")
typa = a1.dtype.char
if output in ['complex', 'c'] and typa not in ['F', 'D']:
if typa in _double_precision:
a1 = a1.astype('D')
typa = 'D'
else:
a1 = a1.astype('F')
typa = 'F'
typb = b1.dtype.char
if output in ['complex', 'c'] and typb not in ['F', 'D']:
if typb in _double_precision:
b1 = b1.astype('D')
typb = 'D'
else:
b1 = b1.astype('F')
typb = 'F'
overwrite_a = overwrite_a or (_datacopied(a1, A))
overwrite_b = overwrite_b or (_datacopied(b1, B))
gges, = get_lapack_funcs(('gges', ), (a1, b1))
if lwork is None or lwork == -1:
# get optimal work array size
result = gges(lambda x: None, a1, b1, lwork=-1)
lwork = result[-2][0].real.astype(np.int)
if sort is None:
sort_t = 0
sfunction = lambda x: None
else:
sort_t = 1
sfunction = _select_function(sort, typa)
result = gges(sfunction,
a1,
b1,
lwork=lwork,
overwrite_a=overwrite_a,
overwrite_b=overwrite_b,
sort_t=sort_t)
info = result[-1]
if info < 0:
raise ValueError("Illegal value in argument %d of gges" % -info)
elif info > 0 and info <= a_n:
warnings.warn(
"The QZ iteration failed. (a,b) are not in Schur "
"form, but ALPHAR(j), ALPHAI(j), and BETA(j) should be correct"
"for J=%d,...,N" % info - 1, UserWarning)
elif info == a_n + 1:
raise LinAlgError("Something other than QZ iteration failed")
elif info == a_n + 2:
raise LinAlgError(
"After reordering, roundoff changed values of some"
"complex eigenvalues so that leading eigenvalues in the"
"Generalized Schur form no longer satisfy sort=True."
"This could also be caused due to scaling.")
elif info == a_n + 3:
raise LinAlgError("Reordering failed in <s,d,c,z>tgsen")
# output for real
#AA, BB, sdim, alphar, alphai, beta, vsl, vsr, work, info
# output for complex
#AA, BB, sdim, alphai, beta, vsl, vsr, work, info
if sort_t == 0:
return result[0], result[1], result[-4], result[-3]
else:
return result[0], result[1], result[-4], result[-3], result[2]
def eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False):
"""
Solve an ordinary or generalized eigenvalue problem of a square matrix.
Find eigenvalues w and right or left eigenvectors of a general matrix::
a vr[:,i] = w[i] b vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]
where ``.H`` is the Hermitian conjugation.
Parameters
----------
a : array_like, shape (M, M)
A complex or real matrix whose eigenvalues and eigenvectors
will be computed.
b : array_like, shape (M, M), optional
Right-hand side matrix in a generalized eigenvalue problem.
Default is None, identity matrix is assumed.
left : bool, optional
Whether to calculate and return left eigenvectors. Default is False.
right : bool, optional
Whether to calculate and return right eigenvectors. Default is True.
overwrite_a : bool, optional
Whether to overwrite `a`; may improve performance. Default is False.
overwrite_b : bool, optional
Whether to overwrite `b`; may improve performance. Default is False.
Returns
-------
w : double or complex ndarray
The eigenvalues, each repeated according to its multiplicity.
Of shape (M,).
vl : double or complex ndarray
The normalized left eigenvector corresponding to the eigenvalue
``w[i]`` is the column v[:,i]. Only returned if ``left=True``.
Of shape ``(M, M)``.
vr : double or complex array
The normalized right eigenvector corresponding to the eigenvalue
``w[i]`` is the column ``vr[:,i]``. Only returned if ``right=True``.
Of shape ``(M, M)``.
Raises
------
LinAlgError
If eigenvalue computation does not converge.
See Also
--------
eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
raise ValueError('expected square matrix')
overwrite_a = overwrite_a or (_datacopied(a1, a))
if b is not None:
b1 = asarray_chkfinite(b)
overwrite_b = overwrite_b or _datacopied(b1, b)
if len(b1.shape) != 2 or b1.shape[0] != b1.shape[1]:
raise ValueError('expected square matrix')
if b1.shape != a1.shape:
raise ValueError('a and b must have the same shape')
return _geneig(a1, b1, left, right, overwrite_a, overwrite_b)
geev, = get_lapack_funcs(('geev',), (a1,))
compute_vl, compute_vr = left, right
if geev.module_name[:7] == 'flapack':
lwork = calc_lwork.geev(geev.prefix, a1.shape[0],
compute_vl, compute_vr)[1]
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1, lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1, lwork=lwork,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr + _I * wi
else: # 'clapack'
if geev.prefix in 'cz':
w, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
else:
wr, wi, vl, vr, info = geev(a1,
compute_vl=compute_vl,
compute_vr=compute_vr,
overwrite_a=overwrite_a)
t = {'f':'F','d':'D'}[wr.dtype.char]
w = wr + _I * wi
if info < 0:
raise ValueError('illegal value in %d-th argument of internal geev'
% -info)
if info > 0:
raise LinAlgError("eig algorithm did not converge (only eigenvalues "
"with order >= %d have converged)" % info)
only_real = numpy.logical_and.reduce(numpy.equal(w.imag, 0.0))
if not (geev.prefix in 'cz' or only_real):
t = w.dtype.char
if left:
vl = _make_complex_eigvecs(w, vl, t)
if right:
vr = _make_complex_eigvecs(w, vr, t)
if not (left or right):
return w
if left:
if right:
return w, vl, vr
return w, vl
return w, vr
def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False):
"""
Compute QR decomposition of a matrix.
Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
and R upper triangular.
Parameters
----------
a : array, shape (M, N)
Matrix to be decomposed
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
lwork : int, optional
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
is computed.
mode : {'full', 'r', 'economic', 'raw'}
Determines what information is to be returned: either both Q and R
('full', default), only R ('r') or both Q and R but computed in
economy-size ('economic', see Notes). The final option 'raw'
(added in Scipy 0.11) makes the function return two matrixes
(Q, TAU) in the internal format used by LAPACK.
pivoting : bool, optional
Whether or not factorization should include pivoting for rank-revealing
qr decomposition. If pivoting, compute the decomposition
``A P = Q R`` as above, but where P is chosen such that the diagonal
of R is non-increasing.
Returns
-------
Q : float or complex ndarray
Of shape (M, M), or (M, K) for ``mode='economic'``. Not returned
if ``mode='r'``.
R : float or complex ndarray
Of shape (M, N), or (K, N) for ``mode='economic'``. ``K = min(M, N)``.
P : integer ndarray
Of shape (N,) for ``pivoting=True``. Not returned if
``pivoting=False``.
Raises
------
LinAlgError
Raised if decomposition fails
Notes
-----
This is an interface to the LAPACK routines dgeqrf, zgeqrf,
dorgqr, zungqr, dgeqp3, and zgeqp3.
If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
of (M,M) and (M,N), with ``K=min(M,N)``.
Examples
--------
>>> from scipy import random, linalg, dot, diag, all, allclose
>>> a = random.randn(9, 6)
>>> q, r = linalg.qr(a)
>>> allclose(a, np.dot(q, r))
True
>>> q.shape, r.shape
((9, 9), (9, 6))
>>> r2 = linalg.qr(a, mode='r')
>>> allclose(r, r2)
True
>>> q3, r3 = linalg.qr(a, mode='economic')
>>> q3.shape, r3.shape
((9, 6), (6, 6))
>>> q4, r4, p4 = linalg.qr(a, pivoting=True)
>>> d = abs(diag(r4))
>>> all(d[1:] <= d[:-1])
True
>>> allclose(a[:, p4], dot(q4, r4))
True
>>> q4.shape, r4.shape, p4.shape
((9, 9), (9, 6), (6,))
>>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
>>> q5.shape, r5.shape, p5.shape
((9, 6), (6, 6), (6,))
"""
# 'qr' was the old default, equivalent to 'full'. Neither 'full' nor
# 'qr' are used below.
# 'raw' is used internally by qr_multiply
if mode not in ['full', 'qr', 'r', 'economic', 'raw']:
raise ValueError(
"Mode argument should be one of ['full', 'r', 'economic', 'raw']")
a1 = numpy.asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError("expected 2D array")
M, N = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
if pivoting:
geqp3, = get_lapack_funcs(('geqp3',), (a1,))
qr, jpvt, tau = safecall(geqp3, "geqp3", a1, overwrite_a=overwrite_a)
jpvt -= 1 # geqp3 returns a 1-based index array, so subtract 1
else:
geqrf, = get_lapack_funcs(('geqrf',), (a1,))
qr, tau = safecall(geqrf, "geqrf", a1, lwork=lwork,
overwrite_a=overwrite_a)
if mode not in ['economic', 'raw'] or M < N:
R = numpy.triu(qr)
else:
R = numpy.triu(qr[:N, :])
if pivoting:
Rj = R, jpvt
else:
Rj = R,
if mode == 'r':
return Rj
elif mode == 'raw':
return ((qr, tau),) + Rj
if find_best_lapack_type((a1,))[0] in ('s', 'd'):
gor_un_gqr, = get_lapack_funcs(('orgqr',), (qr,))
else:
gor_un_gqr, = get_lapack_funcs(('ungqr',), (qr,))
if M < N:
Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr[:, :M], tau,
lwork=lwork, overwrite_a=1)
elif mode == 'economic':
Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr, tau, lwork=lwork,
overwrite_a=1)
else:
t = qr.dtype.char
qqr = numpy.empty((M, M), dtype=t)
qqr[:, :N] = qr
Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qqr, tau, lwork=lwork,
overwrite_a=1)
return (Q,) + Rj
def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False):
"""
Singular Value Decomposition.
Factorizes the matrix a into two unitary matrices U and Vh, and
a 1-D array s of singular values (real, non-negative) such that
``a == U*S*Vh``, where S is a suitably shaped matrix of zeros with
main diagonal s.
Parameters
----------
a : ndarray
Matrix to decompose, of shape ``(M,N)``.
full_matrices : bool, optional
If True, `U` and `Vh` are of shape ``(M,M)``, ``(N,N)``.
If False, the shapes are ``(M,K)`` and ``(K,N)``, where
``K = min(M,N)``.
compute_uv : bool, optional
Whether to compute also `U` and `Vh` in addition to `s`.
Default is True.
overwrite_a : bool, optional
Whether to overwrite `a`; may improve performance.
Default is False.
Returns
-------
U : ndarray
Unitary matrix having left singular vectors as columns.
Of shape ``(M,M)`` or ``(M,K)``, depending on `full_matrices`.
s : ndarray
The singular values, sorted in non-increasing order.
Of shape (K,), with ``K = min(M, N)``.
Vh : ndarray
Unitary matrix having right singular vectors as rows.
Of shape ``(N,N)`` or ``(K,N)`` depending on `full_matrices`.
For ``compute_uv = False``, only `s` is returned.
Raises
------
LinAlgError
If SVD computation does not converge.
See also
--------
svdvals : Compute singular values of a matrix.
diagsvd : Construct the Sigma matrix, given the vector s.
Examples
--------
>>> from scipy import linalg
>>> a = np.random.randn(9, 6) + 1.j*np.random.randn(9, 6)
>>> U, s, Vh = linalg.svd(a)
>>> U.shape, Vh.shape, s.shape
((9, 9), (6, 6), (6,))
>>> U, s, Vh = linalg.svd(a, full_matrices=False)
>>> U.shape, Vh.shape, s.shape
((9, 6), (6, 6), (6,))
>>> S = linalg.diagsvd(s, 6, 6)
>>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
True
>>> s2 = linalg.svd(a, compute_uv=False)
>>> np.allclose(s, s2)
True
"""
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2:
raise ValueError('expected matrix')
m, n = a1.shape
overwrite_a = overwrite_a or (_datacopied(a1, a))
gesdd, = get_lapack_funcs(('gesdd', ), (a1, ))
if gesdd.module_name[:7] == 'flapack':
lwork = calc_lwork.gesdd(gesdd.prefix, m, n, compute_uv)[1]
u, s, v, info = gesdd(a1,
compute_uv=compute_uv,
lwork=lwork,
full_matrices=full_matrices,
overwrite_a=overwrite_a)
else: # 'clapack'
raise NotImplementedError('calling gesdd from %s' % gesdd.module_name)
if info > 0:
raise LinAlgError("SVD did not converge")
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gesdd' %
-info)
if compute_uv:
return u, s, v
else:
return s
def schur(a, output='real', lwork=None, overwrite_a=False):
"""Compute Schur decomposition of a matrix.
The Schur decomposition is
A = Z T Z^H
where Z is unitary and T is either upper-triangular, or for real
Schur decomposition (output='real'), quasi-upper triangular. In
the quasi-triangular form, 2x2 blocks describing complex-valued
eigenvalue pairs may extrude from the diagonal.
Parameters
----------
a : array, shape (M, M)
Matrix to decompose
output : {'real', 'complex'}
Construct the real or complex Schur decomposition (for real matrices).
lwork : integer
Work array size. If None or -1, it is automatically computed.
overwrite_a : boolean
Whether to overwrite data in a (may improve performance)
Returns
-------
T : array, shape (M, M)
Schur form of A. It is real-valued for the real Schur decomposition.
Z : array, shape (M, M)
An unitary Schur transformation matrix for A.
It is real-valued for the real Schur decomposition.
See also
--------
rsf2csf : Convert real Schur form to complex Schur form
"""
if not output in ['real', 'complex', 'r', 'c']:
raise ValueError("argument must be 'real', or 'complex'")
a1 = asarray_chkfinite(a)
if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
raise ValueError('expected square matrix')
typ = a1.dtype.char
if output in ['complex', 'c'] and typ not in ['F', 'D']:
if typ in _double_precision:
a1 = a1.astype('D')
typ = 'D'
else:
a1 = a1.astype('F')
typ = 'F'
overwrite_a = overwrite_a or (_datacopied(a1, a))
gees, = get_lapack_funcs(('gees', ), (a1, ))
if lwork is None or lwork == -1:
# get optimal work array
result = gees(lambda x: None, a1, lwork=-1)
lwork = result[-2][0].real.astype(numpy.int)
result = gees(lambda x: None, a1, lwork=lwork, overwrite_a=overwrite_a)
info = result[-1]
if info < 0:
raise ValueError('illegal value in %d-th argument of internal gees' %
-info)
elif info > 0:
raise LinAlgError("Schur form not found. Possibly ill-conditioned.")
return result[0], result[-3]
