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 _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 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
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 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 (_datacopied(a1, a)) gesdd, = get_lapack_funcs(('gesdd', ), (a1, )) gesdd_info = get_func_info(gesdd) if gesdd_info.module_name[:7] == 'flapack': lwork = calc_lwork.gesdd(gesdd_info.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_info.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 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 (_datacopied(a1, a)) gesdd, = get_lapack_funcs(('gesdd',), (a1,)) gesdd_info = get_func_info(gesdd) if gesdd_info.module_name[:7] == 'flapack': lwork = calc_lwork.gesdd(gesdd_info.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_info.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 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
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
The solution to the system a x = b """ 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 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:
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 Hermitean conjugation. Parameters ---------- a : array, shape (M, M) A complex or real matrix whose eigenvalues and eigenvectors will be computed. b : array, shape (M, M) Right-hand side matrix in a generalized eigenvalue problem. If omitted, identity matrix is assumed. left : boolean Whether to calculate and return left eigenvectors right : boolean Whether to calculate and return right eigenvectors 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 : double or complex array, shape (M,) The eigenvalues, each repeated according to its multiplicity. (if left == True) vl : double or complex array, shape (M, M) The normalized left eigenvector corresponding to the eigenvalue w[i] is the column v[:,i]. (if right == True) vr : double or complex array, shape (M, M) The normalized right eigenvector corresponding to the eigenvalue w[i] is the column vr[:,i]. 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: b = asarray_chkfinite(b) if b.shape != a1.shape: raise ValueError('a and b must have the same shape') return _geneig(a1, b, left, right, overwrite_a, overwrite_b) geev, = get_lapack_funcs(('geev', ), (a1, )) geev_info = get_func_info(geev) compute_vl, compute_vr = left, right if geev_info.module_name[:7] == 'flapack': lwork = calc_lwork.geev(geev_info.prefix, a1.shape[0], compute_vl, compute_vr)[1] if geev_info.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_info.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_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 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 subdiagonal. Parameters ---------- a : array, shape (M,M) Matrix to bring into Hessenberg form calc_q : boolean Whether to compute the transformation matrix overwrite_a : boolean Whether to ovewrite data in a (may improve performance) Returns ------- H : array, shape (M,M) Hessenberg form of A (If calc_q == True) Q : array, shape (M,M) Unitary/orthogonal similarity transformation matrix s.t. A = Q H Q^H """ 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(get_func_info(gehrd).prefix, n, lo, hi)[0] 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. 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 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 Hermitean conjugation. Parameters ---------- a : array, shape (M, M) A complex or real matrix whose eigenvalues and eigenvectors will be computed. b : array, shape (M, M) Right-hand side matrix in a generalized eigenvalue problem. If omitted, identity matrix is assumed. left : boolean Whether to calculate and return left eigenvectors right : boolean Whether to calculate and return right eigenvectors 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 : double or complex array, shape (M,) The eigenvalues, each repeated according to its multiplicity. (if left == True) vl : double or complex array, shape (M, M) The normalized left eigenvector corresponding to the eigenvalue w[i] is the column v[:,i]. (if right == True) vr : double or complex array, shape (M, M) The normalized right eigenvector corresponding to the eigenvalue w[i] is the column vr[:,i]. 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: b = asarray_chkfinite(b) if b.shape != a1.shape: raise ValueError('a and b must have the same shape') return _geneig(a1, b, left, right, overwrite_a, overwrite_b) geev, = get_lapack_funcs(('geev',), (a1,)) geev_info = get_func_info(geev) compute_vl, compute_vr = left, right if geev_info.module_name[:7] == 'flapack': lwork = calc_lwork.geev(geev_info.prefix, a1.shape[0], compute_vl, compute_vr)[1] if geev_info.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_info.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_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 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 subdiagonal. Parameters ---------- a : array, shape (M,M) Matrix to bring into Hessenberg form calc_q : boolean Whether to compute the transformation matrix overwrite_a : boolean Whether to ovewrite data in a (may improve performance) Returns ------- H : array, shape (M,M) Hessenberg form of A (If calc_q == True) Q : array, shape (M,M) Unitary/orthogonal similarity transformation matrix s.t. A = Q H Q^H """ 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(get_func_info(gehrd).prefix, n, lo, hi)[0] 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. 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