B &]\~ @s|ddlmZmZmZdddddddd d d g Zdd lZdd lmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZmZmZddl m!Z!m"Z"e ddZ#ddZ$ddZ%ddZ&d2ddZ'd3ddZ(ddd ddd ddd d! Z)d"d#Z*d4d%dZ+d5d&dZ,d6d'dZ-d7d(dZ.d8d+d Z/d9d,dZ0d:d.d/Z1d;d0d Z2d1d Z3d S)<)divisionprint_functionabsolute_importeigeigvalseigheigvalsh eig_bandedeigvals_bandedeigh_tridiagonaleigvalsh_tridiagonal hessenbergcdf2rdfN)arrayisfiniteinexactnonzero iscomplexobjcast flatnonzeroconjasarrayargsortemptynewaxisargwhere iscomplexeyezeroseinsum)xrange)_asarray_validated) string_types) LinAlgError _datacopiednorm)get_lapack_funcs_compute_lworkFy?cCstj||d}|jdk}|dd|jdddkO<xXt|D]L}|dd|df|jdd|f<t|dd|f|dd|dfqDW|S)zR Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output )dtyperNr#)numpyrimagrr)wZvinr*vmir22lib/python3.7/site-packages/scipy/linalg/decomp.py_make_complex_eigvecs$s ""*r4cCs|r0|dkr t|t|fSt||fSn|dkr<|St|}|dk}|dk}|}||||||<tj|||@<t|jdkrtj|||@<nttjtj|||@<|SdS)Nr) r,ZvstackZ ones_likeZ empty_likeinfallr-nancomplex)alphabetahomogeneous_eigvalsr.Z alpha_zeroZ beta_zeroZ beta_nonzeror2r2r3 _make_eigvals2s  r<cCstd||f\}||}} |||dd} | ddjtj} |jdkrv||||| | ||\} } }}}}t| | |}n:||||| | ||\}}} }}}}|t|} t| | |}t|dt |j dk}|jdks|s|j j }|rt |||}|rt |||}xtt|jdD]b}|rH|dd|ft|dd|f<|r|dd|ft|dd|f<qW|s|s|S|r|r|||fS||fS||fS) N)ggevr+)lworkrczz generalized eig algorithm (ggev)g)r'realZastyper,inttypecoder<_I _check_infor6r-r*charr4r shaper&)a1b1leftright overwrite_a overwrite_br;r=ZcvlZcvrZresr>r9r:vlvrZworkinfor.ZalpharZalphai only_realtr1r2r2r3_geneigLsB         (.  rSFTcCst||d}t|jdks.|jd|jdkr6td|pBt||}|dk rt||d} |pdt| |}t| jdks| jd| jdkrtd| j|jkrtdt|| |||||Std|f\} } ||} } t| |jd| | d }| jd kr| ||| | |d \}}}}t |d|}nF| ||| | |d \}}}}}d d d|j j }|t |}t |d|}t |dddt|jdk}| jd ks|s|j j }|rt|||}|rt|||}|s|s|S|r|r|||fS||fS||fS)a 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 : (M, M) array_like A complex or real matrix whose eigenvalues and eigenvectors will be computed. b : (M, M) array_like, 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. check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. homogeneous_eigvals : bool, optional If True, return the eigenvalues in homogeneous coordinates. In this case ``w`` is a (2, M) array so that:: w[1,i] a vr[:,i] = w[0,i] b vr[:,i] Default is False. Returns ------- w : (M,) or (2, M) double or complex ndarray The eigenvalues, each repeated according to its multiplicity. The shape is (M,) unless ``homogeneous_eigvals=True``. vl : (M, M) double or complex ndarray The normalized left eigenvector corresponding to the eigenvalue ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``. vr : (M, M) double or complex ndarray The normalized right eigenvector corresponding to the eigenvalue ``w[i]`` is the column ``vr[:,i]``. Only returned if ``right=True``. Raises ------ LinAlgError If eigenvalue computation does not converge. See Also -------- eigvals : eigenvalues of general arrays eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays. eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian band matrices eigh_tridiagonal : eigenvalues and right eiegenvectors for symmetric/Hermitian tridiagonal matrices Examples -------- >>> from scipy import linalg >>> a = np.array([[0., -1.], [1., 0.]]) >>> linalg.eigvals(a) array([0.+1.j, 0.-1.j]) >>> b = np.array([[0., 1.], [1., 1.]]) >>> linalg.eigvals(a, b) array([ 1.+0.j, -1.+0.j]) >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]]) >>> linalg.eigvals(a, homogeneous_eigvals=True) array([[3.+0.j, 8.+0.j, 7.+0.j], [1.+0.j, 1.+0.j, 1.+0.j]]) >>> a = np.array([[0., -1.], [1., 0.]]) >>> linalg.eigvals(a) == linalg.eig(a)[0] array([ True, True]) >>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector array([[-0.70710678+0.j , -0.70710678-0.j ], [-0. +0.70710678j, -0. -0.70710678j]]) >>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector array([[0.70710678+0.j , 0.70710678-0.j ], [0. -0.70710678j, 0. +0.70710678j]]) ) check_finiterr#zexpected square matrixNz a and b must have the same shape)geev geev_lwork) compute_vl compute_vrr@)r>rXrYrLr)D)fdzeig algorithm (geev)zCdid not converge (only eigenvalues with order >= %d have converged))positiveg)r!lenrG ValueErrorr%rSr'r(rCr<r*rFrDrEr,r6r-r4)abrJrKrLrMrTr;rHrIrVrWrXrYr>r.rNrOrPwrZwirRrQr2r2r3rvs^` " "          c  Cst|| d} t| jdks.| jd| jdkr6td|pBt| |}t| rRd} nd} |dk rt|| d} |pvt| |}t| jdks| jd| jdkrtd| j| jkrtd t| jt| jft| rd} q| pd} nd} |rd pd } |dk rP|\}}|dks|| jdkr8td d| jddf|d7}|d7}||f}|r\d }nd}| rld}nd}| dkr|d}t|f| f\}|dkr|| || dd| jd|d\}}}n8|\}}|| || d|||d\}}}|d||d}n|dk r^|d}t|f| | f\}|\}}|| | |||| |||d \}}}}|d||d}nt|r|d}t|f| | f\}|| | ||| ||d\}}}n6|d}t|f| | f\}|| | ||| ||d\}}}|dkr|r|S||fSt||dd|dkr| dkrt dnfd|kr8| jdkrjnn.|dk r\t dt |dn t d|nt d|| jddS)aw 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 : (M, M) array_like A complex Hermitian or real symmetric matrix whose eigenvalues and eigenvectors will be computed. b : (M, M) array_like, optional A complex Hermitian or real symmetric definite positive matrix in. If omitted, identity matrix is assumed. lower : bool, optional Whether the pertinent array data is taken from the lower or upper triangle of `a`. (Default: lower) eigvals_only : bool, optional Whether to calculate only eigenvalues and no eigenvectors. (Default: both are calculated) turbo : bool, optional Use divide and conquer algorithm (faster but expensive in memory, only for generalized eigenvalue problem and if eigvals=None) eigvals : tuple (lo, hi), optional 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 : int, optional 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 : bool, optional Whether to overwrite data in `a` (may improve performance) overwrite_b : bool, optional Whether to overwrite data in `b` (may improve performance) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- w : (N,) float ndarray The N (1<=N<=M) selected eigenvalues, in ascending order, each repeated according to its multiplicity. v : (M, N) complex ndarray (if eigvals_only == False) 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 -------- eigvalsh : eigenvalues of symmetric or Hermitian arrays eig : eigenvalues and right eigenvectors for non-symmetric arrays eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays eigh_tridiagonal : eigenvalues and right eiegenvectors for symmetric/Hermitian tridiagonal matrices Notes ----- This function does not check the input array for being hermitian/symmetric in order to allow for representing arrays with only their upper/lower triangular parts. Examples -------- >>> from scipy.linalg import eigh >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]]) >>> w, v = eigh(A) >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4))) True )rTrUrr#zexpected square matrixTFNz#wrong b dimensions %s, should be %sNVzCThe eigenvalue range specified is not valid. Valid range is [%s,%s]LUZheZsyevrA)uplojobzrangeiliurLIgvx)rirmityperjrlrLrMgvd)rirprjrLrMgv)r]zunrecoverable internal error.z'the eigenvectors %s failed to converge.zinternal fortran routine failed to converge: %i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.zthe 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.) r!r^rGr_r%rstrr'rEr$r)r`ralower eigvals_onlyrLrMturbortyperTrHZcplxrIZ_joblohiriZpfxdriverrgr.r/rPZw_totroifailrqrrr2r2r3rsh " "              "  rU) rr#rUr6valueindexr`r/r1c Cst|tr|}y t|}Wntk r:tdYnXd\}}d}}|dkr t|}|jdks|jdks|d|dkrtd|dkr|\}}|dkr|}nb|j j dkrtd|j |j j f|d\}}t ||dkst |||krtd ||d}||||||fS) z5Check that select is valid, convert to Fortran style.zinvalid argument for select)gg?r#rrUzBselect_range must be a 2-element array-like in nondecreasing orderZhilqpzLwhen using select="i", select_range must contain integers, got dtype %s (%s)zselect_range out of bounds) isinstancer"rt _conv_dictKeyErrorr_rndimsizer*rFminmax) select select_rangemax_evZmax_lenrNvurlrmsrr2r2r3 _check_selects0   $  rr`c Cs|s|r$t||d}|p t||}n.t|}t|jjtrNt|sNt dd}t |j dkrht dt ||||j d\}} } } } }~|dkr|jj dkrd} nd } t| f|f\}||| ||d \}}}n|rd}|jj d krtd tdd df\}ntd tdddf\}d|d}|jj dkr4d} nd} t| f|f\}||| | | | | |||||d \}}}}}|d|}|s|ddd|f}t|| |r|S||fS)a 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 : (u+1, M) array_like The bands of the M by M matrix a. lower : bool, optional Is the matrix in the lower form. (Default is upper form) eigvals_only : bool, optional Compute only the eigenvalues and no eigenvectors. (Default: calculate also eigenvectors) overwrite_a_band : bool, optional Discard data in a_band (may enhance performance) select : {'a', 'v', 'i'}, optional 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), optional Range of selected eigenvalues max_ev : int, optional For select=='v', maximum number of eigenvalues expected. For other values of select, has no meaning. In doubt, leave this parameter untouched. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- w : (M,) ndarray The eigenvalues, in ascending order, each repeated according to its multiplicity. v : (M, M) float or complex ndarray The normalized eigenvector corresponding to the eigenvalue w[i] is the column v[:,i]. Raises ------ LinAlgError If eigenvalue computation does not converge. See Also -------- eigvals_banded : eigenvalues for symmetric/Hermitian band matrices eig : eigenvalues and right eigenvectors of general arrays. eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays eigh_tridiagonal : eigenvalues and right eiegenvectors for symmetric/Hermitian tridiagonal matrices Examples -------- >>> from scipy.linalg import eig_banded >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]]) >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]]) >>> w, v = eig_banded(Ab, lower=True) >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4))) True >>> w = eig_banded(Ab, lower=True, eigvals_only=True) >>> w array([-4.26200532, -2.22987175, 3.95222349, 12.53965359]) Request only the eigenvalues between ``[-3, 4]`` >>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4]) >>> w array([-2.22987175, 3.95222349]) )rTz#array must not contain infs or NaNsr#rUzexpected two-dimensional arrayrGFDZhbevdZsbevd) compute_vrt overwrite_abZfF)lamchr[)r*r\sZhbevxZsbevx)rZmmaxrkrtrabstolN)r!r%r issubclassr*rwrrr6r_r^rGrrFr'rE)a_bandrtruoverwrite_a_bandrrrrTrHrNrrlrm internal_nameZbevdr.r/rPrrZbevxr0r{r2r2r3r sPk      c Cst||dd|||dS)a Compute eigenvalues from an ordinary or generalized eigenvalue problem. Find eigenvalues of a general matrix:: a vr[:,i] = w[i] b vr[:,i] Parameters ---------- a : (M, M) array_like A complex or real matrix whose eigenvalues and eigenvectors will be computed. b : (M, M) array_like, optional Right-hand side matrix in a generalized eigenvalue problem. If omitted, identity matrix is assumed. overwrite_a : bool, optional Whether to overwrite data in a (may improve performance) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. homogeneous_eigvals : bool, optional If True, return the eigenvalues in homogeneous coordinates. In this case ``w`` is a (2, M) array so that:: w[1,i] a vr[:,i] = w[0,i] b vr[:,i] Default is False. Returns ------- w : (M,) or (2, M) double or complex ndarray The eigenvalues, each repeated according to its multiplicity but not in any specific order. The shape is (M,) unless ``homogeneous_eigvals=True``. Raises ------ LinAlgError If eigenvalue computation does not converge See Also -------- eig : eigenvalues and right eigenvectors of general arrays. eigvalsh : eigenvalues of symmetric or Hermitian arrays eigvals_banded : eigenvalues for symmetric/Hermitian band matrices eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal matrices Examples -------- >>> from scipy import linalg >>> a = np.array([[0., -1.], [1., 0.]]) >>> linalg.eigvals(a) array([0.+1.j, 0.-1.j]) >>> b = np.array([[0., 1.], [1., 1.]]) >>> linalg.eigvals(a, b) array([ 1.+0.j, -1.+0.j]) >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]]) >>> linalg.eigvals(a, homogeneous_eigvals=True) array([[3.+0.j, 8.+0.j, 7.+0.j], [1.+0.j, 1.+0.j, 1.+0.j]]) r)rarJrKrLrTr;)r)r`rarLrTr;r2r2r3rsE c Cst|||d||||||d S)a Solve an ordinary or generalized eigenvalue problem for a complex Hermitian or real symmetric matrix. Find eigenvalues w 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 : (M, M) array_like A complex Hermitian or real symmetric matrix whose eigenvalues and eigenvectors will be computed. b : (M, M) array_like, optional A complex Hermitian or real symmetric definite positive matrix in. If omitted, identity matrix is assumed. lower : bool, optional Whether the pertinent array data is taken from the lower or upper triangle of `a`. (Default: lower) turbo : bool, optional Use divide and conquer algorithm (faster but expensive in memory, only for generalized eigenvalue problem and if eigvals=None) eigvals : tuple (lo, hi), optional 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 : int, optional 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 : bool, optional Whether to overwrite data in `a` (may improve performance) overwrite_b : bool, optional Whether to overwrite data in `b` (may improve performance) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- w : (N,) float ndarray The N (1<=N<=M) selected eigenvalues, in ascending order, each repeated according to its multiplicity. 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 -------- eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays eigvals : eigenvalues of general arrays eigvals_banded : eigenvalues for symmetric/Hermitian band matrices eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal matrices Notes ----- This function does not check the input array for being hermitian/symmetric in order to allow for representing arrays with only their upper/lower triangular parts. Examples -------- >>> from scipy.linalg import eigvalsh >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]]) >>> w = eigvalsh(A) >>> w array([-3.74637491, -0.76263923, 6.08502336, 12.42399079]) T) rartrurLrMrvrrwrT)r) r`rartrLrMrvrrwrTr2r2r3rsV c Cst||d||||dS)a Solve real symmetric or complex hermitian band matrix eigenvalue problem. Find eigenvalues w 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 : (u+1, M) array_like The bands of the M by M matrix a. lower : bool, optional Is the matrix in the lower form. (Default is upper form) overwrite_a_band : bool, optional Discard data in a_band (may enhance performance) select : {'a', 'v', 'i'}, optional 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), optional Range of selected eigenvalues check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- w : (M,) ndarray The eigenvalues, in ascending order, each repeated according to its multiplicity. Raises ------ LinAlgError If eigenvalue computation does not converge. See Also -------- eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian band matrices eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal matrices eigvals : eigenvalues of general arrays eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays eig : eigenvalues and right eigenvectors for non-symmetric arrays Examples -------- >>> from scipy.linalg import eigvals_banded >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]]) >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]]) >>> w = eigvals_banded(Ab, lower=True) >>> w array([-4.26200532, -2.22987175, 3.95222349, 12.53965359]) r#)rtrurrrrT)r )rrtrrrrTr2r2r3r `sWautoc Cst||d|||||dS)aH Solve eigenvalue problem for a real symmetric tridiagonal matrix. Find eigenvalues `w` of ``a``:: a v[:,i] = w[i] v[:,i] v.H v = identity For a real symmetric matrix ``a`` with diagonal elements `d` and off-diagonal elements `e`. Parameters ---------- d : ndarray, shape (ndim,) The diagonal elements of the array. e : ndarray, shape (ndim-1,) The off-diagonal elements of the array. select : {'a', 'v', 'i'}, optional 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), optional Range of selected eigenvalues check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. tol : float The absolute tolerance to which each eigenvalue is required (only used when ``lapack_driver='stebz'``). An eigenvalue (or cluster) is considered to have converged if it lies in an interval of this width. If <= 0. (default), the value ``eps*|a|`` is used where eps is the machine precision, and ``|a|`` is the 1-norm of the matrix ``a``. lapack_driver : str LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf', or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'`` and 'stebz' otherwise. 'sterf' and 'stev' can only be used when ``select='a'``. Returns ------- w : (M,) ndarray The eigenvalues, in ascending order, each repeated according to its multiplicity. Raises ------ LinAlgError If eigenvalue computation does not converge. See Also -------- eigh_tridiagonal : eigenvalues and right eiegenvectors for symmetric/Hermitian tridiagonal matrices Examples -------- >>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh >>> d = 3*np.ones(4) >>> e = -1*np.ones(3) >>> w = eigvalsh_tridiagonal(d, e) >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1) >>> w2 = eigvalsh(A) # Verify with other eigenvalue routines >>> np.allclose(w - w2, np.zeros(4)) True T)rurrrTtol lapack_driver)r )r\errrTrrr2r2r3r sK c Cst||d}t||d}x6||fD]*}|jdkr8td|jjdkr"tdq"W|j|jdkrttd|j|jft||d|j\}} } } } } t|t stdd }||krtd ||f|d kr|dkrd nd }t |f||f\}| }|dkr2|dkr td|std|||\}}t |}n|dkrl|dkrNtd||||d\}}}t |}n|d krt |}d }t |f||f\}|rdnd}||||| | | | || \}}}}}nzt |jd|j}||dd<t d||f\}||||| | | | |d\}}}t|d||||| | | | |||d \}}}}t||d|d|}|rd|S|d krt d||f\}||||||\}}t|dddt|}|||dd|f}}n|ddd|f}||fSdS) a Solve eigenvalue problem for a real symmetric tridiagonal matrix. Find eigenvalues `w` and optionally right eigenvectors `v` of ``a``:: a v[:,i] = w[i] v[:,i] v.H v = identity For a real symmetric matrix ``a`` with diagonal elements `d` and off-diagonal elements `e`. Parameters ---------- d : ndarray, shape (ndim,) The diagonal elements of the array. e : ndarray, shape (ndim-1,) The off-diagonal elements of the array. select : {'a', 'v', 'i'}, optional 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), optional Range of selected eigenvalues check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. tol : float The absolute tolerance to which each eigenvalue is required (only used when 'stebz' is the `lapack_driver`). An eigenvalue (or cluster) is considered to have converged if it lies in an interval of this width. If <= 0. (default), the value ``eps*|a|`` is used where eps is the machine precision, and ``|a|`` is the 1-norm of the matrix ``a``. lapack_driver : str LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf', or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'`` and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is used to find the corresponding eigenvectors. 'sterf' can only be used when ``eigvals_only=True`` and ``select='a'``. 'stev' can only be used when ``select='a'``. Returns ------- w : (M,) ndarray The eigenvalues, in ascending order, each repeated according to its multiplicity. v : (M, M) ndarray The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is the column ``v[:,i]``. Raises ------ LinAlgError If eigenvalue computation does not converge. See Also -------- eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal matrices eig : eigenvalues and right eigenvectors for non-symmetric arrays eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian band matrices Notes ----- This function makes use of LAPACK ``S/DSTEMR`` routines. Examples -------- >>> from scipy.linalg import eigh_tridiagonal >>> d = 3*np.ones(4) >>> e = -1*np.ones(3) >>> w, v = eigh_tridiagonal(d, e) >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1) >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4))) True )rTr#zexpected one-dimensional arrayrz$Only real arrays currently supportedz-d (%s) must have one more element than e (%s)rzlapack_driver must be str)rstemrsterfstebzstevz'lapack_driver must be one of %s, got %srrrrz)sterf can only be used when select == "a"z0sterf can only be used when eigvals_only is Truerz(stev can only be used when select == "a")rEBNr+) stemr_lworkr)rr>liworkz (eigh_tridiagonal))Zsteinzstein (eigh_tridiagonal)z"%d eigenvectors failed to converge)r])r!rr_r*rF TypeErrorrrr~r"r'r^floatrrEr)r\rrurrrTrrZcheckrNrrlrm_Zdriversfuncrr.rPr0r/rrorderZiblockZisplitZe_rr>rr2r2r3r s|X                  !did not converge (LAPACK info=%d)cCs>|dkrtd| |f|dkr:|r:td|||fdS)zCheck info return value.rz+illegal value in argument %d of internal %sz%s N)r_r$)rPrzr]r2r2r3rEs  rEcCsLt||d}t|jdks.|jd|jdkr6td|pBt||}|jddkrn|rj|t|jdfS|Std|f\}}}||d|d\}} } } } t| dd d t|} t ||jd| | d }||| | |dd \}}} t| d d d t |d}|s|Std|f\}}t || | | d }|||| | |dd\}} t| dd d ||fS)a 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 : (M, M) array_like Matrix to bring into Hessenberg form. 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. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- H : (M, M) ndarray Hessenberg form of `a`. Q : (M, M) ndarray Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``. Only returned if ``calc_q=True``. Examples -------- >>> from scipy.linalg import hessenberg >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]) >>> H, Q = hessenberg(A, calc_q=True) >>> H array([[ 2. , -11.65843866, 1.42005301, 0.25349066], [ -9.94987437, 14.53535354, -5.31022304, 2.43081618], [ 0. , -1.83299243, 0.38969961, -0.51527034], [ 0. , 0. , -3.83189513, 1.07494686]]) >>> np.allclose(Q @ H @ Q.conj().T - A, np.zeros((4, 4))) True )rTrUrr#zexpected square matrix)gehrdgebal gehrd_lwork)ZpermuterLzgebal (hessenberg)F)r])rxry)rxryr>rLzgehrd (hessenberg)r+)orghr orghr_lwork)r`taurxryr>rLzorghr (hessenberg)) r!r^rGr_r%r,rr'rEr(Ztriu)r`Zcalc_qrLrTrHrrrZbarxryZpivscalerPnr>Zhqrhrrqr2r2r3r s0. " cCs0t|t|}}|jdkr$td|jdkr6td|j|jdkrNtd|jd}|jdd}|jd|jdkrtd |jd|krtd t|}|jdd }|dd kstd t|}|dd}|d}|d dd} |ddd} d} xL|D]D} | d dd| dddks4td| | d ddf7} qWt |||f|j j d} t |}|j | d||f<|| | fj | | | | f<|| | fj | | | | f<t |||ftjd}d|d||f<d|| | | f<d|| | | f<d|| | | f<d|| | | f<td||j }| |fS)a Converts complex eigenvalues ``w`` and eigenvectors ``v`` to real eigenvalues in a block diagonal form ``wr`` and the associated real eigenvectors ``vr``, such that:: vr @ wr = X @ vr continues to hold, where ``X`` is the original array for which ``w`` and ``v`` are the eigenvalues and eigenvectors. .. versionadded:: 1.1.0 Parameters ---------- w : (..., M) array_like Complex or real eigenvalues, an array or stack of arrays Conjugate pairs must not be interleaved, else the wrong result will be produced. So ``[1+1j, 1, 1-1j]`` will give a correct result, but ``[1+1j, 2+1j, 1-1j, 2-1j]`` will not. v : (..., M, M) array_like Complex or real eigenvectors, a square array or stack of square arrays. Returns ------- wr : (..., M, M) ndarray Real diagonal block form of eigenvalues vr : (..., M, M) ndarray Real eigenvectors associated with ``wr`` See Also -------- eig : Eigenvalues and right eigenvectors for non-symmetric arrays rsf2csf : Convert real Schur form to complex Schur form Notes ----- ``w``, ``v`` must be the eigenstructure for some *real* matrix ``X``. For example, obtained by ``w, v = scipy.linalg.eig(X)`` or ``w, v = numpy.linalg.eig(X)`` in which case ``X`` can also represent stacked arrays. .. versionadded:: 1.1.0 Examples -------- >>> X = np.array([[1, 2, 3], [0, 4, 5], [0, -5, 4]]) >>> X array([[ 1, 2, 3], [ 0, 4, 5], [ 0, -5, 4]]) >>> from scipy import linalg >>> w, v = linalg.eig(X) >>> w array([ 1.+0.j, 4.+5.j, 4.-5.j]) >>> v array([[ 1.00000+0.j , -0.01906-0.40016j, -0.01906+0.40016j], [ 0.00000+0.j , 0.00000-0.64788j, 0.00000+0.64788j], [ 0.00000+0.j , 0.64788+0.j , 0.64788-0.j ]]) >>> wr, vr = linalg.cdf2rdf(w, v) >>> wr array([[ 1., 0., 0.], [ 0., 4., 5.], [ 0., -5., 4.]]) >>> vr array([[ 1. , 0.40016, -0.01906], [ 0. , 0.64788, 0. ], [ 0. , 0. , 0.64788]]) >>> vr @ wr array([[ 1. , 1.69593, 1.9246 ], [ 0. , 2.59153, 3.23942], [ 0. , -3.23942, 2.59153]]) >>> X @ vr array([[ 1. , 1.69593, 1.9246 ], [ 0. , 2.59153, 3.23942], [ 0. , -3.23942, 2.59153]]) r#z)expected w to be at least one-dimensionalrUz)expected v to be at least two-dimensionalzUexpected eigenvectors array to have exactly one dimension more than eigenvalues arrayr+Nr?zVexpected v to be a square matrix or stacked square matrices: v.shape[-2] = v.shape[-1]z7expected the same number of eigenvalues as eigenvectors)Zaxisrz/expected complex-conjugate pairs of eigenvaluesr2z(Conjugate pair spanned different arrays!)r*.g?y?g?yz...ij,...jk->...ik)r!rr_rGrsumr6rAssertionErrorrrAr*rkr-r,Zcdoubler)r.r/rMZ complex_maskZ n_complexidxZ idx_stackZidx_elemjkZ stack_indr1rbZdiurOr2r2r3rsNR      *)NFTFFTF) NTFFFTNr#T)FFFr`NrT)NFTF)NTFFTNr#T)FFr`NT)r`NTrr)Fr`NTrr)r)FFT)4Z __future__rrr__all__r,rrrrrrrrrrrrrrrrrZscipy._lib.sixr Zscipy._lib._utilr!r"Zmiscr$r%r&Zlapackr'r(rDr4r<rSrrrrr rrr r r rEr rr2r2r2r3sV L    *  a   % I Z [ O ! P