� I�gJ_���dZddlmZGd�de��Zd�Zd�Zd�Zedd ���Zd �Z d �Z edd ���Z d �Z d�Z edd���Zedd���ZdS)a+ The eigenvalue problem ---------------------- This file contains routines for the eigenvalue problem. high level routines: hessenberg : reduction of a real or complex square matrix to upper Hessenberg form schur : reduction of a real or complex square matrix to upper Schur form eig : eigenvalues and eigenvectors of a real or complex square matrix low level routines: hessenberg_reduce_0 : reduction of a real or complex square matrix to upper Hessenberg form hessenberg_reduce_1 : auxiliary routine to hessenberg_reduce_0 qr_step : a single implicitly shifted QR step for an upper Hessenberg matrix hessenberg_qr : Schur decomposition of an upper Hessenberg matrix eig_tr_r : right eigenvectors of an upper triangular matrix eig_tr_l : left eigenvectors of an upper triangular matrix �)�xrangec��eZdZdS)�EigenN)�__name__� __module__� __qualname__���e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/mpmath/matrices/eigen.pyrr&s�������Dr rc�<�tt|j|��|S)N)�setattrrr)�fs r �defunr)s�� �E�1�:�q�!�!�!� �Hr c �F�|j}|dkrdSt|dz dd��D�]{}d}td|��D]Z}|t|�|||f����t|�|||f����zz }�[d}|dkrd|z }|dks|�|��rd||<d|||dz f<��d}td|��D]\}|||fxx|zcc<|�|||f��} |�|||f��} || | z| | zzz }�]|||dz f} t| ��} |�|��} | |z|||dz f<| dkr| ||<n%| | z }| | |zz||<|||dz fxx|zcc<|| | zz }d|�|��z }||xx|zcc<td|dz ��D]}|||fxx|zcc<�td|��D]�}|�||��|||dz fz} td|dz ��D]-}| |�|||f��|||fzz } �.|||dz fxx| ||zzcc<td|dz ��D]}|||fxx| |||fzzcc<� ��td|��D]�}||||dz |fz} td|dz ��D]}| |||f|||fzz } �||dz |fxx| |�||��zzcc<td|dz ��D]2}|||fxx| |�|||f��zzcc<�3����}dS)a� This routine computes the (upper) Hessenberg decomposition of a square matrix A. Given A, an unitary matrix Q is calculated such that Q' A Q = H and Q' Q = Q Q' = 1 where H is an upper Hessenberg matrix, meaning that it only contains zeros below the first subdiagonal. Here ' denotes the hermitian transpose (i.e. transposition and conjugation). parameters: A (input/output) On input, A contains the square matrix A of dimension (n,n). On output, A contains a compressed representation of Q and H. T (output) An array of length n containing the first elements of the Householder reflectors. rN�������)�rowsr�abs�re�im�isinf�sqrt�conj)�ctx�A�T�n�i�scale�k� scale_inv�H�rr�ii�Fr�G�ff�js r �hessenberg_reduce_0r*-s]��@ ��A��A�v�v�v�v� �A�a�C��B� � �B/�B/������1��� ?� ?�A� �S�����!�A�#����(�(�3�s�v�v�a��!��f�~�~�+>�+>�>� >�E�E�� � �A�:�:��E� �I� �A�:�:����9�-�-�:��A�a�D��A�a��!��e�H� � ����1��� #� #�A� �a��c�F�F�F�i� �F�F�F�����!�A�#����B�����!�A�#����B� ��b��2��7�"� "�A�A� �a��!��e�H�� ��F�F�� �H�H�Q�K�K���3��;��!�A�a�C�%�� ��6�6��A�a�D�D��Q��B��q�2�v�:�A�a�D� �a��!��e�H�H�H��N�H�H�H� �Q��U� �� ����� � �O�� �!����� ������1�q�5�!�!� � �A� �a��c�F�F�F�a�K�F�F�F�F���1��� %� %�A�����1�����1�Q�q�S�5��)�A��A�q��s�^�^� /� /���S�X�X�a��!��f�%�%��!�A�#��.�.��� �a��!��e�H�H�H��A�a�D�� �H�H�H��A�q��s�^�^� %� %���!�A�#����!�a��!��f�*�$����� %���1��� /� /�A��!��q��1��Q��x��A��A�q��s�^�^� %� %���Q�q��s�V�a��!��f�_�$��� �a��c�!�e�H�H�H��C�H�H�Q�q�T�N�N�*� *�H�H�H��A�q��s�^�^� /� /���!�A�#����!�c�h�h�q��1��v�.�.�.�.����� /� /�sB/�B/r c ��|j}|dkrd|d<dSdx|d<|d<dx|d<|d<td|��D�]}||dkr�td|��D]�}||||dz |fz}td|dz ��D]}||||f|||fzz }�||dz |fxx||�||��zzcc<td|dz ��D]2}|||fxx||�|||f��zzcc<�3��d|||f<td|��D]}dx|||f<|||f<���dS) a> This routine forms the unitary matrix Q described in hessenberg_reduce_0. parameters: A (input/output) On input, A is the same matrix as delivered by hessenberg_reduce_0. On output, A is set to Q. T (input) On input, T is the same array as delivered by hessenberg_reduce_0. r)rrN)rrr)rr)rrr)rrr)rrrrrr)r'r!s r �hessenberg_reduce_1r,�s��� ��A��A�v�v���#������A�c�F�Q�s�V���A�c�F�Q�s�V� �A�q�\�\� � �� �Q�4�1�9�9��A�q�\�\� 3� 3���a�D�1�Q�q�S��U�8�O����1�Q�3���)�)�A���1�Q�3��!�A�a�C�&��(�A�A��!�A�#�a�%����A�����1����.�.������1�Q�3���3�3�A��a��c�F�F�F�a�#�(�(�1�Q�q�S�6�"2�"2�2�2�F�F�F�F�3���!�A�#����1��� � �A�� �A�a��c�F�Q�q��s�V�V� � � r Fc�x�|j}|dkr|�dgg��|fS|s|���}|�|d��}t|||��|���}t |||��t |��D]}t |dz|��D] }d|||f<� � ||fS)a This routine computes the Hessenberg decomposition of a square matrix A. Given A, an unitary matrix Q is determined such that Q' A Q = H and Q' Q = Q Q' = 1 where H is an upper right Hessenberg matrix. Here ' denotes the hermitian transpose (i.e. transposition and conjugation). input: A : a real or complex square matrix overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: Q : an unitary matrix H : an upper right Hessenberg matrix example: >>> from mpmath import mp >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]]) >>> Q, H = mp.hessenberg(A) >>> mp.nprint(H, 3) # doctest:+SKIP [ 3.15 2.23 4.44] [-0.769 4.85 3.05] [ 0.0 3.61 7.0] >>> print(mp.chop(A - Q * H * Q.transpose_conj())) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] return value: (Q, H) rrr)r�matrix�copyr*r,r�rr� overwrite_arr�Q�x�ys r � hessenbergr5�s���H ��A��A�v�v�� � �Q�C�5�!�!�1�%�%� �� �F�F�H�H�� � � �1�a���A���Q��"�"�"� �����A���Q��"�"�"� �A�Y�Y������!��Q��� � �A��A�a��c�F�F� � �a�4�Kr c �n�|j}|||f|z }||dz|f}|�|�|�|��|�|����|�|�|��|�|������} | dkrd} d}d}n || z}|| z}|�|��} |�|��} t ||��D]<} ||| f} ||dz| f}| | z| |zz||| f<||z|| zz ||dz| f<�=t t ||dz����D]<} || |f} || |dzf}|| z||zz|| |f<| |z| | zz || |dzf<�=t|t��sLt |��D]<} || |f} || |dzf}|| z||zz|| |f<| |z| | zz || |dzf<�=t ||dz ��D�](}||dz|f}||dz|f}|�|�|�|��|�|����|�|�|��|�|������} | dkrd||dz|f<d} d}d}n| ||dz|f<|| z}|| z}d||dz|f<|�|��} |�|��} t |dz|��D]B} ||dz| f} ||dz| f}| | z| |zz||dz| f<||z|| zz ||dz| f<�Ct dt ||dz����D]B} || |dzf} || |dzf}|| z||zz|| |dzf<| |z| | zz || |dzf<�Ct|t��sSt d|��D]B} || |dzf} || |dzf}|| z||zz|| |dzf<| |z| | zz || |dzf<�C��*dS)a This subroutine executes a single implicitly shifted QR step applied to an upper Hessenberg matrix A. Given A and shift as input, first an QR decomposition is calculated: Q R = A - shift * 1 . The output is then following matrix: R Q + shift * 1 parameters: n0, n1 (input) Two integers which specify the submatrix A[n0:n1,n0:n1] on which this subroutine operators. The subdiagonal elements to the left and below this submatrix must be deflated (i.e. zero). following restriction is imposed: n1>=n0+2 A (input/output) On input, A is an upper Hessenberg matrix. On output, A is replaced by "R Q + shift * 1" Q (input/output) The parameter Q is multiplied by the unitary matrix Q arising from the QR decomposition. Q can also be false, in which case the unitary matrix Q is not computated. shift (input) a complex number specifying the shift. idealy close to an eigenvalue of the bottemmost part of the submatrix A[n0:n1,n0:n1]. references: Stoer, Bulirsch - Introduction to Numerical Analysis. Kresser : Numerical Methods for General and Structured Eigenvalue Problems rr�r�N) r�hypotrrrr�min� isinstance�bool)r�n0�n1rr2�shiftr�c�s�v�cc�csr!r3r4r)s r �qr_steprE�s���V ��A� �"�r�'� �U��A� �"�Q�$�r�'� �A� � � �#�)�)�C�F�F�1�I�I�s�v�v�a�y�y�1�1�3�9�9�S�V�V�A�Y�Y����q� � �3R�3R�S�S�A��A�v�v� �� �� ��� �Q��� �Q��� ���!���B� ���!���B� �B��]�]�"�"�� �b�1�f�I�� �b��d�1�f�I����F�R�!�V�O��"�q�&� ���E�A��E�M��"�Q�$�q�&� � � �C��B�q�D�M�M� "� "�$�$�� �a��d�I�� �a��1��f�I����E�A��E�M��!�B�$� ���F�R�!�V�O��!�B�q�D�&� � � �a�� � �(����� (� (�A��!�B�$� �A��!�B�q�D�&� �A��A���A�� �A�a��d�I��Q���a���A�a��1��f�I�I��B��Q�� � �++�++�� �a��c�!�e�H�� �a��c�!�e�H�� �I�I�c�i�i����q� � �3�6�6�!�9�9�5�5�s�y�y�������C�F�F�ST�I�I�7V�7V� W� W�� ��6�6��A�a��c�!�e�H��A��A��A�A��A�a��c�!�e�H� ��F�A� ��F�A���!�A�#�a�%�� �X�X�a�[�[�� �X�X�a�[�[����!��Q��� %� %�A��!�A�#�a�%��A��!�A�#�a�%��A��A�v��Q���A�a��c�!�e�H��1�u�q�1�u�}�A�a��c�!�e�H�H���3�r�1�Q�3�<�<�(�(� '� '�A��!�A�a�C�%��A��!�A�a�C�%��A��1�u�q�1�u�}�A�a��!��e�H��A�v��Q���A�a��!��e�H�H��!�T�"�"� +��A�q�\�\� +� +���a��!��e�H���a��!��e�H���q�5�1�q�5�=��!�A�a�C�%����6�B��F�?��!�A�a�C�%����W++�++r c � �|j}d}t|��D]i}tt|dz|����D]F}||�|||f��dz|�|||f��dzzz }�G�j|�|��|z }|dkrdSd}|}|jd|zz } |jdz} dx} } |} | dz|kr�t|�|| | f����t|�|| | f����zt|�|| dz| dzf����zt|�|| dz| dzf����z}|| |zkr|}t|| dz| f��| |zkrn| dz } | dz|k��| dz|kr+d|| dz| f<| dz}d} |dz|krd}| dz}|dkrdS�n�| dzdkr||dz |dz f}�n>| dzd krt||dz |dz f��}�n| dzd kr|}�n ||dz |dz f||dz |dz fz}||dz |dz f||dz |dz fz dzd||dz |dz fz||dz |dz fzz}|�|��dkr|�|��}n|�| ��d z}||zdz }||z dz }t||dz |dz f|z ��t||dz |dz f|z ��kr|}n|}| dz } | dz } t||||||��| | krtd | z������) a� This routine computes the Schur decomposition of an upper Hessenberg matrix A. Given A, an unitary matrix Q is determined such that Q' A Q = R and Q' Q = Q Q' = 1 where R is an upper right triangular matrix. Here ' denotes the hermitian transpose (i.e. transposition and conjugation). parameters: A (input/output) On input, A contains an upper Hessenberg matrix. On output, A is replace by the upper right triangluar matrix R. Q (input/output) The parameter Q is multiplied by the unitary matrix Q arising from the Schur decomposition. Q can also be false, in which case the unitary matrix Q is not computated. rrN�dr8r�� ��y�?z%qr: failed to converge after %d steps) rrr:rrr�eps�dpsrrE� RuntimeError)rrr2r�normr3r4r=r>rL�maxits�its�totalitsr!rAr?�t�a�bs r � hessenberg_qrrVs)��& ��A� �D� �A�Y�Y�>�>����A�a�C�� � �$�$� >� >�A� �C�F�F�1�Q�q�S�6�N�N�a�'�#�&�&��1�Q�3��.�.�A�*=�=� =�D�D� >� �8�8�D�>�>�A� �D� �q�y�y��� �B� �B� �'�S�1�W� �C� �W�q�[�F���C�(�CR� ���!�e�b�j�j��C�F�F�1�Q�q�S�6�N�N�#�#�c�#�&�&��1�Q�3��.�.�&9�&9�9�C����q��1��Q�q�S��z�@R�@R�<S�<S�S�VY�Z]�Z`�Z`�ab�cd�ef�cf�gh�ij�gj�cj�ak�Zl�Zl�Vm�Vm�m�A��3��:�~�~����1�Q�q�S��U�8�}�}�s�Q�w�&�&�� ��F�A� �!�e�b�j�j� �q�5�2�:�:��A�a��c�!�e�H��Q��B��C��A�v��|�|�����U����6�6��F���b��R����"�Q�$�r�!�t�)� �����(�r�!�!��A�b��d�2�a�4�i�L�)�)�����(�r�!�!�����r�!�t�B�q�D�y�\�A�b��d�2�a�4�i�L�0���r�!�t�B�q�D�y�\�A�b��d�2�a�4�i�L�0�Q�6��Q�r�!�t�B�q�D�y�\�9I�A�b�QR�d�SU�VW�SW�i�L�9X�X���6�6�!�9�9�q�=�=����� � �A�A����!�� � �r�)�A���U�a�K����U�a�K���q��A��b��d��|�a�'�(�(�3�q��A��b��d��|�a�/?�+@�+@�@�@��E�E��E� �1�H�C� ��M�H� �C��R��A�u� -� -� -��V�|�|�"�#J�S�#P�Q�Q�Q�GCRr c��|j}|dkr|�dgg��|fS|s|���}|�|d��}t|||��|���}t |||��t |��D]}t |dz|��D] }d|||f<� � t |||��||fS)a; This routine computes the Schur decomposition of a square matrix A. Given A, an unitary matrix Q is determined such that Q' A Q = R and Q' Q = Q Q' = 1 where R is an upper right triangular matrix. Here ' denotes the hermitian transpose (i.e. transposition and conjugation). input: A : a real or complex square matrix overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: Q : an unitary matrix R : an upper right triangular matrix return value: (Q, R) example: >>> from mpmath import mp >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]]) >>> Q, R = mp.schur(A) >>> mp.nprint(R, 3) # doctest:+SKIP [2.0 0.417 -2.53] [0.0 4.0 -4.74] [0.0 0.0 9.0] >>> print(mp.chop(A - Q * R * Q.transpose_conj())) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] warning: The Schur decomposition is not unique. rrr)rr.r/r*r,rrVr0s r �schurrX�s���L ��A��A�v�v�� � �Q�C�5�!�!�1�%�%� �� �F�F�H�H�� � � �1�a���A���Q��"�"�"� �����A���Q��"�"�"� �A�Y�Y������A��q�!�!� � �A��A�a��c�F�F� ��#�q�!���� �a�4�Kr c�>�|j}|�|��}|j}|�|j|j dz��}|||z z}d|�|��z }d}td|��D�]!} || | f} t|t| ��z|��} t| dz dd��D]�} d} t| dz| dz��D]}| || |f||| fzz } �|| | f| z }t|��| kr| }| |z } | || | f<t|t| ����}||kr*t| | dz��D]}||| fxx|zcc<�d}��|dkr(td| dz��D]}||| fxx|zcc<���#|S)z� This routine calculates the right eigenvectors of an upper right triangular matrix. input: A an upper right triangular matrix output: ER a matrix whose columns form the right eigenvectors of A return value: ER rHrrr� r�eyerL�ldexp�one�precrr�maxr)rrr�ERrL�unfl�smlnum�simin�rmaxrrA�sminr)�rr!rSs r �eig_tr_rrg(s��� ��A� ������B� �'�C� �9�9�S�W�s�x�i�"�n� -� -�D��Q��W� �F� ����� � � �E� �D� �A�q�\�\� � �� �a��c�F���3��Q���<��(�(����A��r�2�&�&� � �A��A��A��E�1�q�5�)�)� &� &���Q�q��s�V�b��1��g�%�%����!�A�#��� �A��1�v�v��}�}�����Q��A��B�q��s�G��t�S��V�V�$�$�D��e�|�|���1�Q�3���$�$�A��q��s�G�G�G�t�O�G�G�G�G���� �1�9�9��A�q�1�u�%�%� � ���1�Q�3����4������� �Ir c�0�|j}|�|��}|j}|�|j|j dz��}|||z z}d|�|��z }d}td|dz ��D�]} || | f} t|t| ��z|��} t| dz|��D]�} d} t| | ��D]}| || |f||| fzz } �|| | f| z }t|��| kr| }| |z } | || | f<t|t| ����}||kr*t| | dz��D]}|| |fxx|zcc<�d}��|dkr%t| |��D]}|| |fxx|zcc<���|S)z� This routine calculates the left eigenvectors of an upper right triangular matrix. input: A an upper right triangular matrix output: EL a matrix whose rows form the left eigenvectors of A return value: EL rHrrrZ)rrr�ELrLrarbrcrdrrArer)rfr!rSs r �eig_tr_lrjds��� ��A� ������B� �'�C� �9�9�S�W�s�x�i�"�n� -� -�D��Q��W� �F� ����� � � �E� �D� �A�q�1�u� � � � �� �a��c�F���3��Q���<��(�(����A��q�!�!� � �A��A��A�q�\�\� &� &���R��!��W�q��1��v�%�%����!�A�#��� �A��1�v�v��}�}�����Q��A��B�q��s�G��t�S��V�V�$�$�D��e�|�|���1�q�5�)�)�$�$�A��q��s�G�G�G�t�O�G�G�G�G���� �1�9�9��A�q�\�\� � ���1�Q�3����4������� �Ir Tc��|j}|dkr~|r"|s |dg|�dgg��fS|r"|s |dg|�dgg��fS|dg|�dgg��|�dgg��fS|s|���}|�|d��}t |||��|s|r&|���}t |||��nd}t |��D]}t |dz|��D] } d|| |f<� � t|||��d�t |��D��} t |��D]} || | f| | <�|s|s| S|r't||��} | |� ��z} |rt||��} || z} |r|s| | fS|r|s| | fS| | | fS)a� This routine computes the eigenvalues and optionally the left and right eigenvectors of a square matrix A. Given A, a vector E and matrices ER and EL are calculated such that A ER[:,i] = E[i] ER[:,i] EL[i,:] A = EL[i,:] E[i] E contains the eigenvalues of A. The columns of ER contain the right eigenvectors of A whereas the rows of EL contain the left eigenvectors. input: A : a real or complex square matrix of shape (n, n) left : if true, the left eigenvectors are calculated. right : if true, the right eigenvectors are calculated. overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: E : a list of length n containing the eigenvalues of A. ER : a matrix whose columns contain the right eigenvectors of A. EL : a matrix whose rows contain the left eigenvectors of A. return values: E if left and right are both false. (E, ER) if right is true and left is false. (E, EL) if left is true and right is false. (E, EL, ER) if left and right are true. examples: >>> from mpmath import mp >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]]) >>> E, ER = mp.eig(A) >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0])) [0.0] [0.0] [0.0] >>> E, EL, ER = mp.eig(A,left = True, right = True) >>> E, EL, ER = mp.eig_sort(E, EL, ER) >>> mp.nprint(E) [2.0, 4.0, 9.0] >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0])) [0.0] [0.0] [0.0] >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0])) [0.0 0.0 0.0] warning: - If there are multiple eigenvalues, the eigenvectors do not necessarily span the whole vectorspace, i.e. ER and EL may have not full rank. Furthermore in that case the eigenvectors are numerical ill-conditioned. - In the general case the eigenvalues have no natural order. see also: - eigh (or eigsy, eighe) for the symmetric eigenvalue problem. - eig_sort for sorting of eigenvalues and eigenvectors rrFrc��g|]}d��S)rr )�.0rs r � <listcomp>zeig.<locals>.<listcomp>�s�����q����r ) rr.r/�zerosr*r,rrVrj�transpose_conjrg)rr�left�rightr1rrr2r3r4�Errir`s r �eigrt�sN��@ ��A��A�v�v� � /�� /��q�T�F�C�J�J���u�-�-�.� .� � /�$� /��q�T�F�C�J�J���u�-�-�.� .��1���� � �Q�C�5�)�)�3�:�:��s�e�+<�+<�=�=� �� �F�F�H�H�� � � �!�Q���A���Q��"�"�"� ��u�� �F�F�H�H���C��A�&�&�&�&� �� �A�Y�Y������A��q�!�!� � �A��A�a��c�F�F� ��#�q�!������F�1�I�I����A� �A�Y�Y������1��v��!��� ��E���� �%� �c�1� � �� �!�"�"�$�$� $�� �� �c�1� � �� ��V�� ��U���2�w�� ��d���2�w�� �r�2�;�r �realc���t|t��r<|dkr|j}n.|dkr|j}n |dkrt}nt d|z���t |��}t|��D]�}|}|||��}t|dz|��D]} ||| ��} | |kr| }| }�||kr�||} ||||<| ||<t|t��s2t|��D]"} ||| f} ||| f||| f<| ||| f<�#t|t��s2t|��D]"} || |f} || |f|| |f<| || |f<�#��t|t��rt|t��r|St|t��rt|t��s||fSt|t��rt|t��s||fS|||fS)aA This routine sorts the eigenvalues and eigenvectors delivered by ``eig``. parameters: E : the eigenvalues as delivered by eig EL : the left eigenvectors as delivered by eig, or false ER : the right eigenvectors as delivered by eig, or false f : either a string ("real" sort by increasing real part, "imag" sort by increasing imag part, "abs" sort by absolute value) or a function mapping complexs to the reals, i.e. ``f = lambda x: -mp.re(x) `` would sort the eigenvalues by decreasing real part. return values: E if EL and ER are both false. (E, ER) if ER is not false and left is false. (E, EL) if EL is not false and right is false. (E, EL, ER) if EL and ER are not false. example: >>> from mpmath import mp >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]]) >>> E, EL, ER = mp.eig(A,left = True, right = True) >>> E, EL, ER = mp.eig_sort(E, EL, ER) >>> mp.nprint(E) [2.0, 4.0, 9.0] >>> E, EL, ER = mp.eig_sort(E, EL, ER,f = lambda x: -mp.re(x)) >>> mp.nprint(E) [9.0, 4.0, 2.0] >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0])) [0.0] [0.0] [0.0] >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0])) [0.0 0.0 0.0] ru�imagrzunknown function %sr) r;�strrrrrN�lenrr<) rrsrir`rrr�imaxrAr)r@�zs r �eig_sortr|s@��L�!�S���:� ��;�;���A�A� �&�[�[���A�A� �%�Z�Z��A�A��4�q�8�9�9� 9� �A���A��A�Y�Y�#�#���� �A�a��d�G�G����A��q�!�!� � �A���!�A�$���A��1�u�u������ �1�9�9��!��A��T�7�A�a�D��A�d�G��b�$�'�'� #�����#�#�A��1�Q�3��A� ��a��j�B�q��s�G�!"�B�t�A�v�J�J��b�$�'�'� #�����#�#�A��1�Q�3��A� ��4��j�B�q��s�G�!"�B�q��v�J�J���"�d���� �2�t� 4� 4�����"�d����J�r�4�$8�$8���2�w���"�d����J�r�4�$8�$8���2�w�� �r�2�;�r N)F)FTF)FFru)�__doc__� libmp.backendr�objectrrr*r,r5rErVrXrgrjrtr|r r r �<module>r�s_����,#�"�"�"�"�"� � � � � �F� � � � � � �e/�e/�e/�R" �" �" �L�5�5�5���5�vC+�C+�C+�NiR�iR�iR�X�9�9�9���9�x:�:�:�x8�8�8�t�r�r�r���r�h�Y�Y�Y���Y�Y�Yr
Memory