| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/linalg/__pycache__/ |
Upload File : |
�
d�c�� �
�f � g d �Z ddlZddlZddlmZmZmZmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZ ddlmZ ddlmZmZmZ ddlmZmZ ed d � � Z d
� Z d � Z d � Z d!d�Z d"d�Z!dddddddddd� Z"d� Z# d#d�Z$ d$d�Z% d%d�Z& d&d�Z' d'd�Z( d(d �Z)d)d �Z*d*d �Z+d � Z,dS )+)
�eig�eigvals�eigh�eigvalsh�
eig_banded�eigvals_banded�eigh_tridiagonal�eigvalsh_tridiagonal�
hessenberg�cdf2rdf� N)�array�isfinite�inexact�nonzero� iscomplexobj�cast� flatnonzero�conj�asarray�argsort�empty� iscomplex�zeros�einsum�eye�inf)�_asarray_validated� )� LinAlgError� _datacopied�norm)�get_lapack_funcs�_compute_lwork�Fy �?c �6 � t j ||�� � }| j dk }|dd�xx | j dd� dk z cc< t |� � D ]D}|dd�|dz f |j dd�|f< t |dd�|f |dd�|dz f � � �E|S )zR
Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output
��dtyper N���r )�numpyr
�imagr r )�w�vinr' �v�m�is �6/usr/lib/python3/dist-packages/scipy/linalg/_decomp.py�_make_complex_eigvecsr1 # s� � �
� �C�u�%�%�%�A�
��!��A��c�r�c�F�F�F�q�v�a�b�b�z�A�~� �F�F�F�
��^�^� !� !���1�1�1�a��c�6�{���q�q�q�!�t� � �Q�q�q�q�!�t�W�a����1�Q�3��i� � � � � �H� c �� � |r@|�(t j | t j | � � f� � S t j | |f� � S |�| S t j | � � }| dk }|dk }| }| | || z ||< t j || |z < t j | j dk � � rt j |||z < n*t t j t j � � |||z < |S )Nr ) r) �vstack� ones_like�
empty_liker �allr* �nan�complex)�alpha�beta�homogeneous_eigvalsr+ �
alpha_zero� beta_zero� beta_nonzeros r0 �
_make_eigvalsr@ 1 s� � �� � �<��<�����(>�(>� ?�@�@� @��<���
�.�.� .� �<��L�� ��'�'�A� �1�*�J� ���I� %�:�L� #�L� 1�$�|�2D� D�A�l�O� */��A�z�k�I�%� &��y���q� �)�)�
J�,1�I��*�y�(�)�)�,3�E�I�u�y�,I�,I��*�y�(�)��Hr2 c �r � t d| |f� � \ }||} } || |d�� � }
|
d d j � t j � � } |j dv r* || ||| | ||� � \ } }
}}}}t
| |
|� � }n7 || ||| | ||� � \ }}}
}}}}|t |z z } t
| |
|� � }t |d� � t j |j
dk � � }|j dv s4|s2|j j }|rt |||� � }|rt |||� � }t |j d � � D ]\}|r+|d d �|fxx t! |d d �|f � � z cc< |r+|d d �|fxx t! |d d �|f � � z cc< �]|s|s|S |r |r|||fS ||fS ||fS ) N)�ggevr( )�lwork���r �czz generalized eig algorithm (ggev)� )r" �real�astyper) �int_�typecoder@ �_I� _check_infor7 r* r' �charr1 �range�shaper! )�a1�b1�left�right� overwrite_a� overwrite_br< rB �cvl�cvr�resrC r: r; �vl�vr�work�infor+ �alphar�alphai� only_real�tr/ s r0 �_geneigra K s> � � �Y��R�� 1� 1�E�D��U��C�
�$�r�2�R�
�
�
�C� ��G�A�J�O� "� "�5�:� .� .�E� �}�� � �*.�$�r�2�s�C��/:�K�+I� +I�'��t�R��T�4� �%��':� ;� ;���37�4��B��S�8=�{�8C�4E� 4E�0����b�"�d�D� ��f��$�� �%��':� ;� ;����8�9�9�9�� �!�&�C�-�(�(�I� �M�T� !� !�Y� !�
�G�L�� � 1�&�q�"�a�0�0�B� � 1�&�q�"�a�0�0�B� �2�8�A�;�
�
� '� '�� � '� �q�q�q�!�t�H�H�H��R����1��X��� &�H�H�H� � '� �q�q�q�!�t�H�H�H��R����1��X��� &�H�H�H�� � �E� ��� � � � ��b�"�9� ��"�u� � �b�5�Lr2 FTc �j � t | |�� � }t |j � � dk s |j d |j d k rt d� � �|pt || � � }|��t ||�� � } |pt | |� � }t | j � � dk s | j d | j d k rt d� � �| j |j k rt d� � �t || |||||� � S t
d|f� � \ }
} ||}
} t | |j d | |
� � � }|
j d
v r' |
||| |
|� � � \ }}}}t |d|� � }nI |
||| |
|� � � \ }}}}}d d
d�|j
j }|t |z z }t |d|� � }t |dd�� � t j |j dk � � }|
j d
v s4|s2|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
--------
>>> import numpy as np
>>> 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_finite� r r �expected square matrixNz a and b must have the same shape)�geev�
geev_lwork)�
compute_vl�
compute_vrrE )rC ri rj rT r$ �D)�f�dzeig algorithm (geev)zCdid not converge (only eigenvalues with order >= %d have converged)��positiverF )r �lenrO �
ValueErrorr ra r" r# rJ r@ r' rM rK rL r) r7 r* r1 )�a�brR rS rT rU rd r< rP rQ rg rh ri rj rC r+ rY rZ r\ �wr�wir` r_ s r0 r r u s� � �B
�A�L� 9� 9� 9�B�
�2�8�}�}����R�X�a�[�B�H�Q�K� 7� 7��1�2�2�2� �5�+�b�!�"4�"4�K��}�
�� �
=�
=�
=��!�7�[��Q�%7�%7� � �r�x�=�=�A� � ���!����� �!;�!;� � 5�6�6� 6�
�8�r�x� � � � ?�@�@� @��r�2�t�U�K��*�,� ,� ,� (�(>���F�F��D�*� !�5�
�J� �:�r�x��{�&0�&0�
2�
2�
2�E� �}�� � � �$�r��*4�*4�+6�8� 8� 8���2�r�4�
�!�T�#6� 7� 7��� #�t�B�e�/9�/9�0;� =� =� =� ��B��B�� �C� � ��� � /�� ��b��L�� �!�T�#6� 7� 7����,�<�=� =� =� =� � �!�&�C�-�(�(�I� �M�T� !� !�Y� !�
�G�L�� � 1�&�q�"�a�0�0�B� � 1�&�q�"�a�0�0�B� � �E� ��� � � � ��b�"�9� ��"�u� � �b�5�Lr2 c
�0 � |r t j dt d�� � |r t j dt d�� � |rdnd}
|rdnd}g d �}| |vr>t d
� | d � |d d
� � � � � � � �t
| | �� � }t |j � � dk s |j d |j d k rt d� � �|pt || � � }t |� � rdnd}|j d }d|i}|��t
|| �� � }|pt ||� � }t |j � � dk s |j d |j d k rt d� � �|j |j k r-t d� |j |j � � � � �|dvrt d� � �t |� � rdn|pd}|� ||d�� � |�|
n|}
|
d
up| d
u}|
r| rt d� � �|r|�|rdnd} |
rkd � |
D � � \ }}d|cxk r
|cxk r|k s)n t d � |d z
||� � � � �|� d |d z |d z d �� � | rb| \ }}t |cxk r|cxk r t k s%n t d � ||� � � � �|� d||d!�� � |rd"nd#}| ry|�&| d$v r"t d%� | � � � � �|�&| d&v r"t d'� | � � � � �|r&| d(v r"t d)� | � � � � �n
|�d*n|rdnd} d+d,gd+d,gg d-�g d.�d/�}|��t || z || z d0z f|g� � \ }}||d1�} | d2k r | � d3|dk rdnd i� � t |fi | ��} t | t � � r't# t% ||| z | � � � � } nd+| i} |� ||dk rdnd d4�� � |dFd5|i|�| ���^} } }!}"n~| dk rt |dz ||g� � }i } n6t || z || z d0z f||g� � \ }}t |||
�6� � } d+| i} |� |
|d7�� � |dF||d8�|�| ���^} } }!}"|r| d
|!d � n| } |r|s| d
d
�d
|!d �f n| } |"dk r|r| S | | fS |"d9k r/t' d:� |" |j |z | z � � � � �|"|k r%t' d;� |"|z
� � � � �d<d=d>d?d@�}#| dAv r |#dB � |"� � }$nj| dCv r |#dD � |"� � }$nJ| dEv r>|r |#dB � |"� � }$n(|#d2 � |"|d z � � }$n|#d* }$t' |$� � �)GuK
Solve a standard or generalized eigenvalue problem for a complex
Hermitian or real symmetric matrix.
Find eigenvalues array ``w`` and optionally eigenvectors array ``v`` of
array ``a``, where ``b`` is positive definite such that for every
eigenvalue λ (i-th entry of w) and its eigenvector ``vi`` (i-th column of
``v``) satisfies::
a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1
In the standard problem, ``b`` is assumed to be the identity matrix.
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`` and, if applicable, ``b``. (Default: lower)
eigvals_only : bool, optional
Whether to calculate only eigenvalues and no eigenvectors.
(Default: both are calculated)
subset_by_index : iterable, optional
If provided, this two-element iterable defines the start and the end
indices of the desired eigenvalues (ascending order and 0-indexed).
To return only the second smallest to fifth smallest eigenvalues,
``[1, 4]`` is used. ``[n-3, n-1]`` returns the largest three. Only
available with "evr", "evx", and "gvx" drivers. The entries are
directly converted to integers via ``int()``.
subset_by_value : iterable, optional
If provided, this two-element iterable defines the half-open interval
``(a, b]`` that, if any, only the eigenvalues between these values
are returned. Only available with "evr", "evx", and "gvx" drivers. Use
``np.inf`` for the unconstrained ends.
driver : str, optional
Defines which LAPACK driver should be used. Valid options are "ev",
"evd", "evr", "evx" for standard problems and "gv", "gvd", "gvx" for
generalized (where b is not None) problems. See the Notes section.
The default for standard problems is "evr". For generalized problems,
"gvd" is used for full set, and "gvx" for subset requested cases.
type : int, optional
For the generalized problems, this keyword specifies the problem type
to be solved for ``w`` and ``v`` (only takes 1, 2, 3 as possible
inputs)::
1 => a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v
This keyword is ignored for standard problems.
overwrite_a : bool, optional
Whether to overwrite data in ``a`` (may improve performance). Default
is False.
overwrite_b : bool, optional
Whether to overwrite data in ``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.
turbo : bool, optional, deprecated
.. deprecated:: 1.5.0
`eigh` keyword argument `turbo` is deprecated in favour of
``driver=gvd`` keyword instead and will be removed in SciPy
1.12.0.
eigvals : tuple (lo, hi), optional, deprecated
.. deprecated:: 1.5.0
`eigh` keyword argument `eigvals` is deprecated in favour of
`subset_by_index` keyword instead and will be removed in SciPy
1.12.0.
Returns
-------
w : (N,) ndarray
The N (1<=N<=M) selected eigenvalues, in ascending order, each
repeated according to its multiplicity.
v : (M, N) ndarray
(if ``eigvals_only == False``)
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 will be 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_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. Also, note that even though not taken into account,
finiteness check applies to the whole array and unaffected by "lower"
keyword.
This function uses LAPACK drivers for computations in all possible keyword
combinations, prefixed with ``sy`` if arrays are real and ``he`` if
complex, e.g., a float array with "evr" driver is solved via
"syevr", complex arrays with "gvx" driver problem is solved via "hegvx"
etc.
As a brief summary, the slowest and the most robust driver is the
classical ``<sy/he>ev`` which uses symmetric QR. ``<sy/he>evr`` is seen as
the optimal choice for the most general cases. However, there are certain
occasions that ``<sy/he>evd`` computes faster at the expense of more
memory usage. ``<sy/he>evx``, while still being faster than ``<sy/he>ev``,
often performs worse than the rest except when very few eigenvalues are
requested for large arrays though there is still no performance guarantee.
For the generalized problem, normalization with respect to the given
type argument::
type 1 and 3 : v.conj().T @ a @ v = w
type 2 : inv(v).conj().T @ a @ inv(v) = w
type 1 or 2 : v.conj().T @ b @ v = I
type 3 : v.conj().T @ inv(b) @ v = I
Examples
--------
>>> import numpy as np
>>> 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
Request only the eigenvalues
>>> w = eigh(A, eigvals_only=True)
Request eigenvalues that are less than 10.
>>> A = np.array([[34, -4, -10, -7, 2],
... [-4, 7, 2, 12, 0],
... [-10, 2, 44, 2, -19],
... [-7, 12, 2, 79, -34],
... [2, 0, -19, -34, 29]])
>>> eigh(A, eigvals_only=True, subset_by_value=[-np.inf, 10])
array([6.69199443e-07, 9.11938152e+00])
Request the second smallest eigenvalue and its eigenvector
>>> w, v = eigh(A, subset_by_index=[1, 1])
>>> w
array([9.11938152])
>>> v.shape # only a single column is returned
(5, 1)
zuKeyword argument 'turbo' is deprecated in favour of 'driver=gvd' keyword instead and will be removed in SciPy 1.12.0.re )�
stacklevelz|Keyword argument 'eigvals' is deprecated in favour of 'subset_by_index' keyword instead and will be removed in SciPy 1.12.0.�L�U�N�V)N�ev�evd�evr�evx�gv�gvd�gvxz2"{}" is unknown. Possible values are "None", "{}".z", "r Nrc r zexpected square "a" matrixTFrT zexpected square "b" matrixz#wrong b dimensions {}, should be {})r re � z("type" keyword only accepts 1, 2, and 3.)rU �itypez.Either index or value subset can be requested.r� r� c �, � g | ]}t |� � ��S � )�int)�.0�xs r0 �
<listcomp>zeigh.<locals>.<listcomp>� s � �2�2�2�Q�#�a�&�&�2�2�2r2 zrRequested eigenvalue indices are not valid. Valid range is [0, {}] and start <= end, but start={}, end={} is given�I)rN �il�iuzrRequested eigenvalue bounds are not valid. Valid range is (-inf, inf) and low < high, but low={}, high={} is given)rN rY �vu�he�sy)r� r� r� zM{} requires input b array to be supplied for generalized eigenvalue problems.)r| r} r~ r zD"{}" does not accept input b array for standard eigenvalue problems.)r| r} r� r� z*"{}" cannot compute subsets of eigenvaluesr~ rC �liwork)rC r� �lrwork)rC r� r� )�syevd�syevr�heevd�heevr�_lwork)�n�lowerr} � compute_v)r� r� rr )�uplo)r� �jobz)rr rs r( z+Illegal value in argument {} of internal {}z�The leading minor of order {} of B is not positive definite. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.zxThe algorithm failed to converge; {} off-diagonal elements of an intermediate tridiagonal form did not converge to zero.z#{} eigenvectors failed to converge.z�The algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns {0}/{1} through mod({0},{1}).zInternal Error.)r| r r} r~ )r| r� r| )r r� r )r} r� r� )�warnings�warn�DeprecationWarningrq �format�joinr rp rO r r �updater r" r# �
isinstance�tuple�dict�zipr rJ )%rr rs r� � eigvals_onlyrT rU �turbor �typerd �subset_by_index�subset_by_value�driverr� �_job�drv_strrP �cplxr� �drv_argsrQ �subset�lo�hi�pfx�
lwork_spec�drv�drvlw�clw_args�lw�
lwork_argsr+ r- �
other_argsr\ �drv_err�msgs% r0 r r sM � �T
� 8��
� &� )�Q� 8� 8� 8� 8� � 8��
� )� )�Q� 8� 8� 8� 8� � �3�3�S�D� � '�3�3�C�D�C�C�C�G�
�W� � �� � "�F�6�6�;�;�w�q�r�r�{�+C�+C� D� D�F� F� F�
�A�L� 9� 9� 9�B�
�2�8�}�}����R�X�a�[�B�H�Q�K� 7� 7��5�6�6�6� �5�+�b�!�"4�"4�K� ��#�#� .�4�4��D�
��� �A� �{�+�H��}�
�� �
=�
=�
=��!�7�[��Q�%7�%7� � �r�x�=�=�A� � ���!����� �!;�!;� � 9�:�:� :�
�8�r�x� � � � %�%+�V�B�H�b�h�%?�%?�A� A�
A� �y� � � � G�H�H� H�#�B�'�'�<�t�t�d�m�e����� �d�C�C�D�D�D� +2�/�o�o��O� �T�)�
K��d�/J�F� � K�?� K��I�J�J�J�
� ,�� � �+���e�� � D�2�2�/�2�2�2���B��R�!�!�!�!�2�!�!�!�!��!�!�!�!� � 9�9?���!��R��9L�9L�N� N�
N� ���#�R�!�V�2��6�B�B�C�C�C�� <� ���B����&�&�&�&�R�&�&�&�&�3�&�&�&�&� � 8�8>��r�2���H� H�
H� ���#�R�r�:�:�;�;�;� �
�$�$�D�C� � F� �9�&�$8�8�8� � � &��v���0� 0�
0�
�M��*E� E� E� � � &��v���0� 0�
0� � 0�v�!;�;�;� � � &��v���0� 0�
0��
�)���6�*D�%�%�u�� $�X�.� #�X�.�8�8�8�8�8�8� � �J� �y�%�s�V�|�S��Z��5H�&I�')�d�,� ,�
��U��U�+�+�� �U�?�?� �O�O�[�t�s�{�{�!�!�� B� C� C� C�
�E�
.�
.�X�
.�
.�� �b�%� � � '� �c�*�S��Z�"8�"� =� =�>�>�J�J�!�2� �J����%�4�3�;�;�a�a�A�N�N�O�O�O�"%�#�"E�"E��"E�h�"E�*�"E�"E� ��1�z�4�4� �U�?�?�"�3��;��R��9�9�C��J�J�)�3��<��V��H�9L�*M�+-�r�(�4� 4�J�C�� ��q�t�4�4�4�B�!�2� �J�����t�4�4�5�5�5�"%�#�"K��b�"K�"K�H�"K�
�"K�"K� ��1�z�4� $�*��.�:�a�=�.����A�!'�D� �D��!�!�!�^�j��m�^�
� � �1�A� �q�y�y� � ��H��a�4�K� �"�9�9� � !�!'����s�|�c�/A�F�/J�!K�!K�M� M�
M�
�A�X�X� � ?� @F�v�d�1�f�~�~�O� O�
O�
J� D� J� 0�� �G� � �%�%� �d�m�*�*�4�0�0����>�)�)� �e�n�+�+�D�1�1����>�)�)� � ;�!�$�-�.�.�t�4�4�C�C�!�%�.�/�/��a��c�:�:�C�C� �e�n�� �c�"�"� "r2 re ) r r re r7 �value�indexrr r- r/ c � � t | t � � r| � � � } t | } n"# t $ r}t d� � |�d}~ww xY wd\ }}dx}}| dk r�t
|� � } | j dk s | j dk s| d | d k rt d� � �| dk r| \ }}|dk r|}n�| j j
� � � dvr%t d | j �d
| j j
�d �� � �| dz \ }}t ||� � dk st ||� � |k rt d � � �||z
dz }| |||||fS )
z5Check that select is valid, convert to Fortran style.zinvalid argument for selectN)rF � �?r r re zBselect_range must be a 2-element array-like in nondecreasing order�hilqpzEwhen using select="i", select_range must contain integers, got dtype z (�)zselect_range out of bounds)
r� �strr� �
_conv_dict�KeyErrorrq r �ndim�sizer' rM �min�max)
�select� select_range�max_ev�max_len�erY r� r� r� �srs
r0 �
_check_selectr� t s� � ��&�#� � � �� � � � ��?��F�#���� � ?� ?� ?��6�7�7�Q�>�����?����
�F�B���K�B��
��{�{�
�\�
"�
"��
�7�a�<�<�2�7�a�<�<�2�a�5�2�a�5�=�=� � 6� 7� 7�
7� �Q�;�;��F�B����{�{� ����x�}�"�"�$�$�G�3�3� �j�$&�H�H�H�b�h�m�m�m�"=� >� >� >� �!�V�F�B���2�r�{�{�Q���#�b�"�+�+��"7�"7� �!=�>�>�>��"�W�q�[�F� �2�r�2�r�6� )�)s �
9 �
A�A�Arr c
�� � |s|r$t | |�� � }|pt || � � }n`t | � � }t |j j t � � r0t |� � � � � st d� � �d}t |j � � dk rt d� � �t ||||j d � � \ }} }
} } }~|dk r<|j j
dv rd}
nd }
t |
f|f� � \ } ||| ||�
� � \ }}}n�|rd}|j j
d v r#t d t dd
�� � f� � \ }n"t d t dd�� � f� � \ }d |d� � z }|j j
dv rd}
nd}
t |
f|f� � \ } ||| |
| | | |||||�� � \ }}}}}|d|� }|s|dd�d|�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 eigenvectors for
symmetric/Hermitian tridiagonal matrices
Examples
--------
>>> import numpy as np
>>> 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])
rc z#array must not contain infs or NaNsr re zexpected a 2-D arrayr �GFD�hbevd�sbevd)r� r� � overwrite_ab�fF)�lamchrl r& rm �s�hbevx�sbevx)r� �mmaxrN r� r� �abstolN)r r r
�
issubclassr' r� r r r7 rq rp rO r� rM r" rL )�a_bandr� r� �overwrite_a_bandr� r� r� rd rP rY r� r� r� �
internal_name�bevdr+ r- r\ r� r� �bevxr. �ifails r0 r r � s� � �X � �'� �
��\�
B�
B�
B��+�H� �B��0G�0G���
�6�]�]�� �b�h�m�W� -� -� D�h�r�l�l�6F�6F�6H�6H� D� � B�C�C� C� ��
�2�8�}�}�����/�0�0�0�%2�� �f�b�h�q�k�&3� &3�"�F�B��B��F��
��{�{�
�8�=�E� !� !�
$�M�M�
$�M� �-�!1�B�5�9�9����T�"�L�(8� %�4D�F� F� F�
��1�d�d� � ��F�
�8�=�D� � �%�j�5��#�3F�3F�3F�2H�I�I�F�E�E�%�j�5��#�3F�3F�3F�2H�I�I�F�E��U�U�3�Z�Z� ��
�8�=�E� !� !� #�M�M� #�M� �-�!1�B�5�9�9��� #�t� ��B��B�l�*:����4D�� � � � ��1�a���
�b�q�b�E��� ��!�!�!�R�a�R�%��A���m�$�$�$�� ��� �a�4�Kr2 c �. � t | |dd|||�� � S )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
--------
>>> import numpy as np
>>> 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 )rs rR rS rT rd r< )r )rr rs rT rd r< s r0 r r : s, � �L �q�A�A�Q�K� (�#6� 8� 8� 8� 8r2 c �: � t | ||d||||||| |
| ��
�
S )up
Solves a standard or generalized eigenvalue problem for a complex
Hermitian or real symmetric matrix.
Find eigenvalues array ``w`` of array ``a``, where ``b`` is positive
definite such that for every eigenvalue λ (i-th entry of w) and its
eigenvector vi (i-th column of v) satisfies::
a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1
In the standard problem, b is assumed to be the identity matrix.
Parameters
----------
a : (M, M) array_like
A complex Hermitian or real symmetric matrix whose eigenvalues 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`` and, if applicable, ``b``. (Default: lower)
overwrite_a : bool, optional
Whether to overwrite data in ``a`` (may improve performance). Default
is False.
overwrite_b : bool, optional
Whether to overwrite data in ``b`` (may improve performance). Default
is False.
type : int, optional
For the generalized problems, this keyword specifies the problem type
to be solved for ``w`` and ``v`` (only takes 1, 2, 3 as possible
inputs)::
1 => a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v
This keyword is ignored for standard problems.
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.
subset_by_index : iterable, optional
If provided, this two-element iterable defines the start and the end
indices of the desired eigenvalues (ascending order and 0-indexed).
To return only the second smallest to fifth smallest eigenvalues,
``[1, 4]`` is used. ``[n-3, n-1]`` returns the largest three. Only
available with "evr", "evx", and "gvx" drivers. The entries are
directly converted to integers via ``int()``.
subset_by_value : iterable, optional
If provided, this two-element iterable defines the half-open interval
``(a, b]`` that, if any, only the eigenvalues between these values
are returned. Only available with "evr", "evx", and "gvx" drivers. Use
``np.inf`` for the unconstrained ends.
driver : str, optional
Defines which LAPACK driver should be used. Valid options are "ev",
"evd", "evr", "evx" for standard problems and "gv", "gvd", "gvx" for
generalized (where b is not None) problems. See the Notes section of
`scipy.linalg.eigh`.
turbo : bool, optional, deprecated
.. deprecated:: 1.5.0
'eigvalsh' keyword argument `turbo` is deprecated in favor of
``driver=gvd`` option and will be removed in SciPy 1.12.0.
eigvals : tuple (lo, hi), optional
.. deprecated:: 1.5.0
'eigvalsh' keyword argument `eigvals` is deprecated in favor of
`subset_by_index` option and will be removed in SciPy 1.12.0.
Returns
-------
w : (N,) 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 will be 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.
This function serves as a one-liner shorthand for `scipy.linalg.eigh` with
the option ``eigvals_only=True`` to get the eigenvalues and not the
eigenvectors. Here it is kept as a legacy convenience. It might be
beneficial to use the main function to have full control and to be a bit
more pythonic.
Examples
--------
For more examples see `scipy.linalg.eigh`.
>>> import numpy as np
>>> 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) rs r� r� rT rU r� r r� rd r� r� r� )r ) rr rs r� rT rU r� r r� rd r� r� r� s r0 r r � s> � �t ��Q�e�$� '�[��W�4� )�?� /�� @� @� @� @r2 c �. � t | |d||||�� � S )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
--------
>>> import numpy as np
>>> 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 )r� r� r� r� r� rd )r )r� r� r� r� r� rd s r0 r r s0 � �p �f�E��'7��#/�l� L� L� L� Lr2 rF �autoc
�0 � t | |d|||||�� � S )ac
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
--------
>>> import numpy as np
>>> 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)r� r� r� rd �tol�
lapack_driver)r )rm r� r� r� rd r� r� s r0 r r c s2 � �X � �1�4��\�!�s�-� I� I� I� Ir2 c � � t | |�� � } t ||�� � }| |fD ]9}|j dk rt d� � �|j j dv rt d� � ��:| j |j dz k r t d| j �d|j �d�� � �t ||d | j � � \ }} }
} } }
t |t � � st d
� � �d }||vrt d |�d
|��� � �|dk r
|d k rdnd}t |f| |f� � \ }| }|dk rF|d k rt d� � �|st d� � � || |� � \ }}t |� � }�n|dk r7|d k rt d� � � || ||�� � \ }}}t |� � }n�|dk rFt |� � }d}t |f| |f� � \ }|rdnd} || ||| |
| | ||� � \ }}}}}nyt |j dz |j � � }||dd�< t d| |f� � \ } || ||| |
| | |�� � \ } } }t |d � � || ||| |
| | || | � �
�
\ }}}}t ||d z � � |d|� }|r|S |dk r\t d | |f� � \ } || ||||� � \ }}t |d d!�"� � t |� � }|| |dd�|f }}n|dd�d|�f }||fS )#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
--------
>>> import numpy as np
>>> 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
rc r zexpected a 1-D arrayr� z$Only real arrays currently supportedzd (z%) must have one more element than e (r� r zlapack_driver must be str)r� �stemr�sterf�stebz�stevz lapack_driver must be one of z, got r� r� r� r� z)sterf can only be used when select == "a"z0sterf can only be used when eigvals_only is Truer� z(stev can only be used when select == "a")r� �E�BNr( )� stemr_lworkr� )r� rC r� z (eigh_tridiagonal))�steinzstein (eigh_tridiagonal)z"%d eigenvectors failed to convergern )r r� rq r' rM � TypeErrorr� r� r� r� r" rp �floatr rL r ) rm r� r� r� r� rd r� r� �checkrY r� r� r� �_�drivers�funcr� r+ r\ r. r- r� r� �order�iblock�isplit�e_r� rC r� s r0 r r � s � �r �1�<�8�8�8�A��1�<�8�8�8�A��Q�� D� D�� �:��?�?� � 3�4�4� 4� �;� �u� $� $�� B�C�C� C� %��v���!�����j� �F�F�F�A�F�F�F�,� -� -� -� -�� �a���!)� !)� �F�B��B��A� �m�S� )� )� 5��3�4�4�4�9�G��G�#�#��j� #�G�G�]�]�4� 5� 5� 5��� � �#)�Q�;�;���G�
� �m� -��1�v� 6� 6�E�D� � �I��� � � �Q�;�;� � H�I�I� I�� %� � $� %� %�
%��$�q�!�*�*���4� ��F�F��� �&� � � �Q�;�;� � G�H�H� H��T�!�Q�)�4�4�4�
��1�d� ��F�F��� �'� !� !��C�j�j�� �
�!�=�"2�Q��F�;�;��� $�,�����%*�U�1�a���R��R��+0�&2� &2�"��1�f�f�d�d� �1�6�!�8�Q�W�
%�
%����3�B�3��'�(8�1�a�&�A�A� � � )�k�!�R���R��R�4=� ?� ?� ?���v�t��D�-�(�(�(� ��Q��F�B��B��'0��f�N� N� N�
��1�a����m�&;�;�<�<�<� �"�1�"��A�� ��� �G� #� #�$�Z�!�Q��8�8�E�D��d�1�a��F�F�3�3�G�A�t� �� 8�!E�
G�
G�
G�
G� �A�J�J�E��U�8�Q�q�q�q�%�x�[�q�A�A��!�!�!�R�a�R�%��A��!�t� r2 �!did not converge (LAPACK info=%d)c �~ � | dk rt d| |fz � � �| dk r|rt d|z || fz � � �dS dS )zCheck info return value.r z+illegal value in argument %d of internal %sz%s N)rq r )r\ r� ro s r0 rL rL V sb � � �a�x�x��F� !�E�6�?�+� ,� ,� ,� �a�x�x�H�x��5�8�+����>�?�?�?� �x�x�xr2 c � � t | |�� � }t |j � � dk s |j d |j d k rt d� � �|pt || � � }|j d dk r |r |t |j d � � fS |S t
d|f� � \ }}} ||d|�� � \ }} }
} } t | dd �
� � t |� � }
t ||j d | |
� � � } ||| |
|d� � � \ }}} t | d
d �
� � t j
|d� � }|s|S t
d|f� � \ }}t ||
| |
� � � } |||| |
|d�� � \ }} t | dd �
� � ||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
--------
>>> import numpy as np
>>> 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
rc re r r rf )�gehrd�gebal� gehrd_lwork)�permuterT zgebal (hessenberg)Frn )r� r� )r� r� rC rT zgehrd (hessenberg)r( )�orghr� orghr_lwork)rr �taur� r� rC rT zorghr (hessenberg)) r rp rO rq r r r" rL r# r) �triu)rr �calc_qrT rd rP r r r �bar� r� �pivscaler\ r� rC �hqr �hr r �qs r0 r
r
_ s� � �^
�A�L� 9� 9� 9�B�
�2�8�}�}����b�h�q�k�R�X�a�[� 8� 8��1�2�2�2� �5�+�b�!�"4�"4�K�
�x��{�a��� � (��s�2�8�A�;�'�'�'� '�� � 0� 2A�CE�%�!I� !I� �E�5�+�!&��r�1�+�!N�!N�!N� �B��B��$���*�U�;�;�;�;� �B���A� �;���� ��r� B� B� B�E��E�"���%�Q�G�G�G�M�B��T���*�U�;�;�;�;�
�
�2�r���A� � ��� *�*B�R�E�J�J��E�;� �;��b�R� 8� 8� 8�E��e�b�c�b�R�u�!�L�L�L�G�A�t���*�U�;�;�;�;� �a�4�Kr2 c � � t | � � t |� � }} | j dk rt d� � �|j dk rt d� � �|j | j dz k rt d� � �| j d }| j dd� }|j d |j d k rt d � � �|j d |k rt d
� � �t | � � }|� d� � � }|dz d k � � � st d
� � �t |� � }|dd� }|d }|d dd� } |ddd� }
d} |D ]E} | d dd� | ddd� k � � � s
J d� � �| | d dd� fz
} �Ft |||fz | j j
�� � }
t |� � }| j |
d||f< | | | fz j |
| | |
fz < | | |
fz j |
| |
| fz < t |||fz t j �� � }d|d||f< d|| | | fz < d|| | |
fz < d|| |
| fz < d|| |
|
fz < t d||� � 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
--------
>>> import numpy as np
>>> 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 1Dre z expected v to be at least 2DzUexpected eigenvectors array to have exactly one dimension more than eigenvalues arrayr( NrD 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)�axisr z/expected complex-conjugate pairs of eigenvaluesr� z(Conjugate pair spanned different arrays!r& .r� y �?g �?y � �z...ij,...jk->...ik)r r� rq rO r �sumr7 r r rG r' rN r* r) �cdoubler )r+ r- r� �M� complex_mask� n_complex�idx� idx_stack�idx_elem�j�k� stack_indr/ rt �di�urZ s r0 r r � s � �f �a� � �"4�Q�"7�"7�q�A� �v��z�z��7�8�8�8��v��z�z��7�8�8�8��v���!����� A� B� B� B�
��� �A� ����� �A��w�r�{�a�g�b�k�!�!�� ?� @� @� @��w�r�{�a���� (� )� )� )� �Q�<�<�L� � � �b� �)�)�I�
��M�Q� � #� #� %� %� L��J�K�K�K� �,�
�
�C��C�R�C��I��2�w�H� ���A���A����A���A��I�
� � ���!�$�Q�$��1�Q�T��T�7�"�'�'�)�)� ;� ;�:� ;� ;� ;��a���1��g�Z� � � �
�q�A�q�6�z��� � .� .� .�B� �q���B��f�B�s�B��{�O� �y�A�4� /� 0� 5�B�y�A�q�6��� �y�A�4� /� 0� 5�B�y�A�q�6��� �a�1�a�&�j��
�.�.�.�A��A�c�2�r�k�N� �A�i�1�a�&��� �A�i�1�a�&��� !�A�i�1�a�&��� �A�i�1�a�&���
�$�a�� +� +� 0�B�
�r�6�Mr2 )NFTFFTF) NTFFFFNr TNNN)FFFrr Nr T)NFTF) NTFFFNr TNNN)FFrr NT)rr NTrF r� )Frr NTrF r� )r� )FFT)-�__all__r� r) r
r r r r r r r r r r r r r r r �scipy._lib._utilr �_miscr r r! �lapackr" r# rK r1 r@ ra r r r� r� r r r r r r rL r
r r� r2 r0 �<module>r# s �� P� P� P�� ���� � � � �7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 0� /� /� /� /� /� 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 4� 4� 4� 4� 4� 4� 4� 4� �T�#�Y�r�]�]��
�
�
� � � �4'� '� '�T 8=�BG�V� V� V� V�r AF�<=�BF��^#� ^#� ^#� ^#�B �q�Q���Q��1�1�&� &�
�
*� *� *�@ JO�EI�c� c� c� c�L 8<� %�H8� H8� H8� H8�V 16�@A�FJ��~@� ~@� ~@� ~@�B :?�?C�ZL� ZL� ZL� ZL�z 9=�BH�NI� NI� NI� NI�b IM�>D�_� _� _� _�D@� @� @� @�N� N� N� N�bS� S� S� S� Sr2