| 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�� � � � d Z ddlmc mZ ddlZ ed� � Zd� Z d� Z
d� Z d� Z d� Z
d � Zd
� Zd � Zd � Zd
� Zd� Zd� Zd� Zd� Zd;d�Zd;d�Zd� Zd� Zd� Zd� Z d� Z d� Z d� Z d � Z d � Z!d � Z"d � Z#d � Z$d!� Z%d"� Z&d#� Z'd$� Z(d%� Z)d&� Z*d'� Z+d(� Z,d)� Z-d*� Z.d+� Z/d;d,�Z0d;d-�Z1d.� Z2d/� Z3d0� Z4d1� Z5d2� Z6d3� Z7d4� Z8d5� Z9d6� Z:d7� Z;d8� Z<d9� Z=d:� Z>dS )<z0
Direct wrappers for Fortran `id_dist` backend.
� Nznonzero return codec � � t j | � � } | j j r| � d�� � } nt j | � � } | S )z6
Same as np.asfortranarray, but ensure a copy
�F��order)�np�asarray�flags� f_contiguous�copy�asfortranarray)�As �E/usr/lib/python3/dist-packages/scipy/linalg/_interpolative_backend.py�_asfortranarray_copyr ( sH � � �
�1�
�
�A��w�� !�
�F�F��F� � ��� � �a� � �� �H� c �* � t j | � � S )a
Generate standard uniform pseudorandom numbers via a very efficient lagged
Fibonacci method.
:param n:
Number of pseudorandom numbers to generate.
:type n: int
:return:
Pseudorandom numbers.
:rtype: :class:`numpy.ndarray`
)�_id�id_srand)�ns r r r 8 s � � �<��?�?�r c �V � t j | � � } t j | � � dS )z�
Initialize seed values for :func:`id_srand` (any appropriately random
numbers will do).
:param t:
Array of 55 seed values.
:type t: :class:`numpy.ndarray`
N)r r r � id_srandi)�ts r r r H s* � � ��!� � �A��M�!�����r c �, � t j � � dS )z5
Reset seed values to their original values.
N)r � id_srando� r r r r U s � � �M�O�O�O�O�Or c �. � t j | ||� � S )a|
Transform real vector via a composition of Rokhlin's random transform,
random subselection, and an FFT.
In contrast to :func:`idd_sfrm`, this routine works best when the length of
the transformed vector is the power-of-two integer output by
:func:`idd_frmi`, or when the length is not specified but instead
determined a posteriori from the output. The returned transformed vector is
randomly permuted.
:param n:
Greatest power-of-two integer satisfying `n <= x.size` as obtained from
:func:`idd_frmi`; `n` is also the length of the output vector.
:type n: int
:param w:
Initialization array constructed by :func:`idd_frmi`.
:type w: :class:`numpy.ndarray`
:param x:
Vector to be transformed.
:type x: :class:`numpy.ndarray`
:return:
Transformed vector.
:rtype: :class:`numpy.ndarray`
)r �idd_frm�r �w�xs r r r ` � � �4 �;�q�!�Q� � � r c �0 � t j | |||� � S )a�
Transform real vector via a composition of Rokhlin's random transform,
random subselection, and an FFT.
In contrast to :func:`idd_frm`, this routine works best when the length of
the transformed vector is known a priori.
:param l:
Length of transformed vector, satisfying `l <= n`.
:type l: int
:param n:
Greatest power-of-two integer satisfying `n <= x.size` as obtained from
:func:`idd_sfrmi`.
:type n: int
:param w:
Initialization array constructed by :func:`idd_sfrmi`.
:type w: :class:`numpy.ndarray`
:param x:
Vector to be transformed.
:type x: :class:`numpy.ndarray`
:return:
Transformed vector.
:rtype: :class:`numpy.ndarray`
)r �idd_sfrm��lr r r s r r" r" } � � �4 �<��1�a�� #� #�#r c �* � t j | � � S )aC
Initialize data for :func:`idd_frm`.
:param m:
Length of vector to be transformed.
:type m: int
:return:
Greatest power-of-two integer `n` satisfying `n <= m`.
:rtype: int
:return:
Initialization array to be used by :func:`idd_frm`.
:rtype: :class:`numpy.ndarray`
)r �idd_frmi��ms r r' r' � � � � �<��?�?�r c �, � t j | |� � S )a�
Initialize data for :func:`idd_sfrm`.
:param l:
Length of output transformed vector.
:type l: int
:param m:
Length of the vector to be transformed.
:type m: int
:return:
Greatest power-of-two integer `n` satisfying `n <= m`.
:rtype: int
:return:
Initialization array to be used by :func:`idd_sfrm`.
:rtype: :class:`numpy.ndarray`
)r � idd_sfrmi�r$ r) s r r, r, � � � �$ �=��A� � � r c � � t |� � }t j | |� � \ }}}|j d }|j � � � d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a real matrix to a specified relative precision.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
� Nr r )r r �iddp_id�shape�T�ravel�reshape��epsr
�k�idx�rnormsr �projs r r1 r1 � �z � �* �Q� � �A��[��a�(�(�N�A�s�F� ���
�A� �3�9�9�;�;�x��1�Q�3��x� � (� (�!�Q�q�S��� (� =� =�D� �c�4�<�r c �� � t | � � } t j | |� � \ }}| j d }| j � � � d|||z
z � � |||z
fd�� � }||fS )aQ
Compute ID of a real matrix to a specified rank.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r0 Nr r )r r �iddr_idr2 r3 r4 r5 �r
r8 r9 r: r r; s r r> r> � �v � �$ �Q� � �A��+�a��#�#�K�C�� ���
�A� �3�9�9�;�;�x��1�Q�3��x� � (� (�!�Q�q�S��� (� =� =�D� ��9�r c � � t j | � � } |j dk rt j | ||� � S | dd�t j |� � f S )as
Reconstruct matrix from real ID.
:param B:
Skeleton matrix.
:type B: :class:`numpy.ndarray`
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Reconstructed matrix.
:rtype: :class:`numpy.ndarray`
r N)r r �sizer � idd_reconid�argsort��Br9 r; s r rC rC � �O � �$ ��!� � �A� �y�1�}�}���q�#�t�,�,�,�����B�J�s�O�O�#�$�$r c �, � t j | |� � S )a6
Reconstruct interpolation matrix from real ID.
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Interpolation matrix.
:rtype: :class:`numpy.ndarray`
)r � idd_reconint�r9 r; s r rI rI � � � � �C�� &� &�&r c �V � t j | � � } t j | ||� � S )aN
Reconstruct skeleton matrix from real ID.
:param A:
Original matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:return:
Skeleton matrix.
:rtype: :class:`numpy.ndarray`
)r r r � idd_copycols�r
r8 r9 s r rM rM % �) � �$ ��!� � �A� � �A�q�#� &� &�&r c �| � t j | � � } t j | ||� � \ }}}}|rt �|||fS )a
Convert real ID to SVD.
:param B:
Skeleton matrix.
:type B: :class:`numpy.ndarray`
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
)r r r �
idd_id2svd�_RETCODE_ERROR�rF r9 r; �U�V�S�iers r rQ rQ ? �H � �0 ��!� � �A��>�!�S�$�/�/�L�A�q�!�S�
� � � � �a��7�Nr � c �< � t j | ||||� � \ }}|S )a
Estimate spectral norm of a real matrix by the randomized power method.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param its:
Number of power method iterations.
:type its: int
:return:
Spectral norm estimate.
:rtype: float
)r � idd_snorm)r) r �matvect�matvec�its�snorm�vs r r[ r[ b �$ � �8 �}�Q��7�F�C�8�8�H�E�1� �Lr c �6 � t j | ||||||� � S )a0
Estimate spectral norm of the difference of two real matrices by the
randomized power method.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the transpose of the first matrix to a vector, with
call signature `y = matvect(x)`, where `x` and `y` are the input and
output vectors, respectively.
:type matvect: function
:param matvect2:
Function to apply the transpose of the second matrix to a vector, with
call signature `y = matvect2(x)`, where `x` and `y` are the input and
output vectors, respectively.
:type matvect2: function
:param matvec:
Function to apply the first matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param matvec2:
Function to apply the second matrix to a vector, with call signature
`y = matvec2(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec2: function
:param its:
Number of power method iterations.
:type its: int
:return:
Spectral norm estimate of matrix difference.
:rtype: float
)r �
idd_diffsnorm)r) r r\ �matvect2r] �matvec2r^ s r rc rc � �" � �N � �Q��7�H�f�g�s� K� K�Kr c �z � t j | � � } t j | |� � \ }}}}|rt �|||fS )a�
Compute SVD of a real matrix to a specified rank.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
)r r r �iddr_svdrR �r
r8 rT rU rV rW s r rh rh � �F � �* ��!� � �A��<��1�%�%�L�A�q�!�S�
� � � � �a��7�Nr c �l � t j |� � }|j \ }}t j | |� � \ }}}}}} | rt
�||dz
|||z z dz
� � ||fd�� � }
||dz
|||z z dz
� � ||fd�� � } ||dz
||z dz
� } |
| | fS )a�
Compute SVD of a real matrix to a specified relative precision.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 r r )r r r2 r �iddp_svdrR r5 �
r7 r
r) r r8 �iU�iV�iSr rW rT rU rV s
r rl rl � �� � �* ��!� � �A� �7�D�A�q� �L��a� 0� 0��A�r�2�r�1�c�
� � � � �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�t�A�v�+��A� �a��7�Nr c �@ � t j |� � }|j \ }}t |� � \ }}t j |d|z dz z |z dz d�� � }t j | |||� � \ }}}|d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a real matrix to a specified relative precision using random
sampling.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
� r0 r r N)r r r2 r' �emptyr �iddp_aidr5 � r7 r
r) r �n2r r; r8 r9 s r ru ru � s� � �, ��!� � �A� �7�D�A�q� �Q�K�K�E�B��
�8�A�q��t�a�x�L�2�%��)�� 5� 5� 5�D��<��Q��4�0�0�L�A�s�D� ���A�a�C���>� !� !�1�a��c�(�#� !� 6� 6�D� �c�4�<�r c �� � t j |� � }|j \ }}t |� � \ }}t j ||z |dz |dz z z d�� � }t j | |||� � \ }}|S )ae
Estimate rank of a real matrix to a specified relative precision using
random sampling.
The output rank is typically about 8 higher than the actual rank.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank estimate.
:rtype: int
r0 r r )r r r2 r' rt r � idd_estrank�r7 r
r) r rw r �rar8 s r ry ry sv � �$ ��!� � �A� �7�D�A�q� �Q�K�K�E�B�� ��!�B�$�!�a�%�"�q�&�)�)�� 5� 5� 5�B� �O�C��A�r� *� *�E�A�r� �Hr c
�l � t j |� � }|j \ }}t j |� � \ }}t j t
t ||� � dz d|z d|z z dz z dt ||� � dz z z d|z dz |dz z � � d�� � }t j | |||� � \ }}} }
}} | rt �||dz
|||z z dz
� �
||fd�� � } || dz
| ||z z dz
� �
||fd�� � }
||
dz
|
|z dz
� }| |
|fS )a�
Compute SVD of a real matrix to a specified relative precision using random
sampling.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 � � � rs r r ) r r r2 r r' rt �max�min� iddp_asvdrR r5 �r7 r
r) r rw �winitr r8 rn ro rp rW rT rU rV s r r� r� - sb � �, ��!� � �A� �7�D�A�q�� �Q���I�B��
�� �S��A�Y�Y��]�Q�q�S�1�Q�3�Y��]� +�b��Q����A� �o� =�
�q�S�1�W�r�A�v� � � �� � � �A� �M�#�q�%�� ;� ;��A�r�2�r�1�c�
� � � � �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�t�A�v�+��A� �a��7�Nr c � � t j |dz d|z t ||� � dz z z d�� � }t j | ||||� � \ }}}}|dk rt
�|d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a real matrix to a specified relative precision using random
matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r0 rs r r r N)r rt r� r �iddp_ridrR r5 )r7 r) r r\ r; r8 r9 rW s r r� r� W s� � �< �8�A��E�A�a�C��Q����Q� � /�/�s� ;� ;� ;�D�� �S�!�Q���>�>��A�s�D�#�
�a�x�x� � � ���A�a�C���>� !� !�1�a��c�(�#� !� 6� 6�D� �c�4�<�r c �N � t j | |||� � \ }}}|rt �|S )aQ
Estimate rank of a real matrix to a specified relative precision using
random matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:return:
Rank estimate.
:rtype: int
)r � idd_findrankrR )r7 r) r r\ r8 r{ rW s r r� r� } �3 � �0 �!�#�q�!�W�5�5�J�A�r�3�
� � � � �Hr c �6 � t j | ||||� � \ }}}}} }
|
rt �| |dz
|||z z dz
� � ||fd�� � } | |dz
|||z z dz
� � ||fd�� � } | |dz
||z dz
� }
| | |
fS )a�
Compute SVD of a real matrix to a specified relative precision using random
matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 r r )r � iddp_rsvdrR r5 )r7 r) r r\ r] r8 rn ro rp r rW rT rU rV s r r� r� � �� � �F �M�#�q�!�W�f� E� E��A�r�2�r�1�c�
� � � � �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�t�A�v�+��A� �a��7�Nr c � � t j | � � } | j \ }}t |||� � }t j | ||� � \ }}||k r t j |||z
fdd�� � }n |� |||z
fd�� � }||fS )ag
Compute ID of a real matrix to a specified rank using random sampling.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
�float64r ��dtyper r )r r r2 � iddr_aidir �iddr_aidrt r5 �r
r8 r) r r r9 r; s r r� r� � s� � �$ ��!� � �A� �7�D�A�q��!�Q����A�� �Q��1�%�%�I�C���A�v�v��x��A�a�C�� ��=�=�=����|�|�Q��!��H�C�|�0�0�� ��9�r c �. � t j | ||� � S )aO
Initialize array for :func:`iddr_aid`.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param k:
Rank of ID.
:type k: int
:return:
Initialization array to be used by :func:`iddr_aid`.
:rtype: :class:`numpy.ndarray`
)r r� �r) r r8 s r r� r� � � � �$ �=��A�q� !� !�!r c �@ � t j | � � } | j \ }}t j d|z dz |z d|z dz |z z d|dz z z dz d�� � }t |||� � }||d |j �< t
j | ||� � \ }}}} | d
k rt �|||fS ) a�
Compute SVD of a real matrix to a specified rank using random sampling.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
rs � � � r �d r r Nr ) r r r2 rt r� rB r � iddr_asvdrR �
r
r8 r) r r �w_rT rU rV rW s
r r� r� s� � �* ��!� � �A� �7�D�A�q�
��!�A�#��(�A� ��1��r��1� �,�r�!�Q�$�w�6��<�C�H�H�H�A� �1�a�� � �B��A�h�r�w�h�K��=��A�q�)�)�L�A�q�!�S�
�a�x�x� � � �a��7�Nr c � � t j | |||� � \ }}|d|||z
z � � |||z
fd�� � }||fS )a�
Compute ID of a real matrix to a specified rank using random matrix-vector
multiplication.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
Nr r )r �iddr_ridr5 )r) r r\ r8 r9 r; s r r� r� ) �W � �6 � �Q��7�A�.�.�I�C�� ���A�a�C���>� !� !�1�a��c�(�#� !� 6� 6�D� ��9�r c �` � t j | ||||� � \ }}}}|dk rt �|||fS )a�
Compute SVD of a real matrix to a specified rank using random matrix-vector
multiplication.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matvect:
Function to apply the matrix transpose to a vector, with call signature
`y = matvect(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvect: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r )r � iddr_rsvdrR ) r) r r\ r] r8 rT rU rV rW s r r� r� M s> � �F �=��A�w���:�:�L�A�q�!�S�
�a�x�x� � � �a��7�Nr c �. � t j | ||� � S )a
Transform complex vector via a composition of Rokhlin's random transform,
random subselection, and an FFT.
In contrast to :func:`idz_sfrm`, this routine works best when the length of
the transformed vector is the power-of-two integer output by
:func:`idz_frmi`, or when the length is not specified but instead
determined a posteriori from the output. The returned transformed vector is
randomly permuted.
:param n:
Greatest power-of-two integer satisfying `n <= x.size` as obtained from
:func:`idz_frmi`; `n` is also the length of the output vector.
:type n: int
:param w:
Initialization array constructed by :func:`idz_frmi`.
:type w: :class:`numpy.ndarray`
:param x:
Vector to be transformed.
:type x: :class:`numpy.ndarray`
:return:
Transformed vector.
:rtype: :class:`numpy.ndarray`
)r �idz_frmr s r r� r� z r r c �0 � t j | |||� � S )a�
Transform complex vector via a composition of Rokhlin's random transform,
random subselection, and an FFT.
In contrast to :func:`idz_frm`, this routine works best when the length of
the transformed vector is known a priori.
:param l:
Length of transformed vector, satisfying `l <= n`.
:type l: int
:param n:
Greatest power-of-two integer satisfying `n <= x.size` as obtained from
:func:`idz_sfrmi`.
:type n: int
:param w:
Initialization array constructed by :func:`idd_sfrmi`.
:type w: :class:`numpy.ndarray`
:param x:
Vector to be transformed.
:type x: :class:`numpy.ndarray`
:return:
Transformed vector.
:rtype: :class:`numpy.ndarray`
)r �idz_sfrmr# s r r� r� � r% r c �* � t j | � � S )aC
Initialize data for :func:`idz_frm`.
:param m:
Length of vector to be transformed.
:type m: int
:return:
Greatest power-of-two integer `n` satisfying `n <= m`.
:rtype: int
:return:
Initialization array to be used by :func:`idz_frm`.
:rtype: :class:`numpy.ndarray`
)r �idz_frmir( s r r� r� � r* r c �, � t j | |� � S )a�
Initialize data for :func:`idz_sfrm`.
:param l:
Length of output transformed vector.
:type l: int
:param m:
Length of the vector to be transformed.
:type m: int
:return:
Greatest power-of-two integer `n` satisfying `n <= m`.
:rtype: int
:return:
Initialization array to be used by :func:`idz_sfrm`.
:rtype: :class:`numpy.ndarray`
)r � idz_sfrmir- s r r� r� � r. r c � � t |� � }t j | |� � \ }}}|j d }|j � � � d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a complex matrix to a specified relative precision.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r0 Nr r )r r �idzp_idr2 r3 r4 r5 r6 s r r� r� � r< r c �� � t | � � } t j | |� � \ }}| j d }| j � � � d|||z
z � � |||z
fd�� � }||fS )aT
Compute ID of a complex matrix to a specified rank.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r0 Nr r )r r �idzr_idr2 r3 r4 r5 r? s r r� r� � r@ r c � � t j | � � } |j dk rt j | ||� � S | dd�t j |� � f S )av
Reconstruct matrix from complex ID.
:param B:
Skeleton matrix.
:type B: :class:`numpy.ndarray`
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Reconstructed matrix.
:rtype: :class:`numpy.ndarray`
r N)r r rB r � idz_reconidrD rE s r r� r� rG r c �, � t j | |� � S )a9
Reconstruct interpolation matrix from complex ID.
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Interpolation matrix.
:rtype: :class:`numpy.ndarray`
)r � idz_reconintrJ s r r� r� - rK r c �V � t j | � � } t j | ||� � S )aQ
Reconstruct skeleton matrix from complex ID.
:param A:
Original matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:return:
Skeleton matrix.
:rtype: :class:`numpy.ndarray`
)r r r � idz_copycolsrN s r r� r� ? rO r c �| � t j | � � } t j | ||� � \ }}}}|rt �|||fS )a
Convert complex ID to SVD.
:param B:
Skeleton matrix.
:type B: :class:`numpy.ndarray`
:param idx:
Column index array.
:type idx: :class:`numpy.ndarray`
:param proj:
Interpolation coefficients.
:type proj: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
)r r r �
idz_id2svdrR rS s r r� r� Y rX r c �< � t j | ||||� � \ }}|S )a
Estimate spectral norm of a complex matrix by the randomized power method.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param its:
Number of power method iterations.
:type its: int
:return:
Spectral norm estimate.
:rtype: float
)r � idz_snorm)r) r �matvecar] r^ r_ r` s r r� r� | ra r c �6 � t j | ||||||� � S )a/
Estimate spectral norm of the difference of two complex matrices by the
randomized power method.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the adjoint of the first matrix to a vector, with
call signature `y = matveca(x)`, where `x` and `y` are the input and
output vectors, respectively.
:type matveca: function
:param matveca2:
Function to apply the adjoint of the second matrix to a vector, with
call signature `y = matveca2(x)`, where `x` and `y` are the input and
output vectors, respectively.
:type matveca2: function
:param matvec:
Function to apply the first matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param matvec2:
Function to apply the second matrix to a vector, with call signature
`y = matvec2(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec2: function
:param its:
Number of power method iterations.
:type its: int
:return:
Spectral norm estimate of matrix difference.
:rtype: float
)r �
idz_diffsnorm)r) r r� �matveca2r] re r^ s r r� r� � rf r c �z � t j | � � } t j | |� � \ }}}}|rt �|||fS )a�
Compute SVD of a complex matrix to a specified rank.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
)r r r �idzr_svdrR ri s r r� r� � rj r c �l � t j |� � }|j \ }}t j | |� � \ }}}}}} | rt
�||dz
|||z z dz
� � ||fd�� � }
||dz
|||z z dz
� � ||fd�� � } ||dz
||z dz
� } |
| | fS )a�
Compute SVD of a complex matrix to a specified relative precision.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 r r )r r r2 r �idzp_svdrR r5 rm s
r r� r� � rq r c �B � t j |� � }|j \ }}t |� � \ }}t j |d|z dz z |z dz dd�� � }t j | |||� � \ }}}|d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a complex matrix to a specified relative precision using
random sampling.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
rs r0 �
complex128r r� Nr )r r r2 r� rt r �idzp_aidr5 rv s r r� r�
s� � �, ��!� � �A� �7�D�A�q� �Q�K�K�E�B��
�8�A�q��t�a�x�L�2�%��)� �S� I� I� I�D��<��Q��4�0�0�L�A�s�D� ���A�a�C���>� !� !�1�a��c�(�#� !� 6� 6�D� �c�4�<�r c �� � t j |� � }|j \ }}t |� � \ }}t j ||z |dz |dz z z dd�� � }t j | |||� � \ }}|S )ah
Estimate rank of a complex matrix to a specified relative precision using
random sampling.
The output rank is typically about 8 higher than the actual rank.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Rank estimate.
:rtype: int
r0 r� r r� )r r r2 r� rt r � idz_estrankrz s r r� r� ) sx � �$ ��!� � �A� �7�D�A�q� �Q�K�K�E�B�� ��!�B�$�!�a�%�"�q�&�)�)� �S� I� I� I�B� �O�C��A�r� *� *�E�A�r� �Hr c
� � t j |� � }|j \ }}t j |� � \ }}t j t
t ||� � dz d|z d|z z dz z dt ||� � dz z z d|z dz |dz z � � t j d�� � }t j | |||� � \ }}} }
}} | rt �||dz
|||z z dz
� � ||fd� � � } || dz
| ||z z dz
� � ||fd� � � }
||
dz
|
|z dz
� }| |
|fS )
a�
Compute SVD of a complex matrix to a specified relative precision using
random sampling.
:param eps:
Relative precision.
:type eps: float
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 r} r~ � � rs r r� r ) r r r2 r r� rt r� r� r� � idzp_asvdrR r5 r� s r r� r� G sf � �, ��!� � �A� �7�D�A�q�� �Q���I�B��
�� �S��A�Y�Y��]�Q�q�S�1�Q�3�Y��^� ,�q��Q����A� �~� =�
�q�S�1�W�r�A�v� � � ��m�3� (� (� (�A� �M�#�q�%�� ;� ;��A�r�2�r�1�c�
� � � � �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�A�#�v�a�x�-�� � �!�Q��s� �3�3�A� �"�Q�$�r�!�t�A�v�+��A� �a��7�Nr c �( � t j |dz d|z t ||� � dz z z t j d�� � }t j | ||||� � \ }}}}|rt �|d|||z
z � � |||z
fd�� � }|||fS )a�
Compute ID of a complex matrix to a specified relative precision using
random matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:return:
Rank of ID.
:rtype: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r0 rs r r� Nr )r rt r� r� r �idzp_ridrR r5 )r7 r) r r� r; r8 r9 rW s r r� r� q s� � �< �8� �A���!��S��A�Y�Y��]�#�#��m�3� (� (� (�D� � �S�!�Q���>�>��A�s�D�#�
� � � � ���A�a�C���>� !� !�1�a��c�(�#� !� 6� 6�D� �c�4�<�r c �N � t j | |||� � \ }}}|rt �|S )aR
Estimate rank of a complex matrix to a specified relative precision using
random matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:return:
Rank estimate.
:rtype: int
)r � idz_findrankrR )r7 r) r r� r8 r{ rW s r r� r� � r� r c �6 � t j | ||||� � \ }}}}} }
|
rt �| |dz
|||z z dz
� � ||fd�� � } | |dz
|||z z dz
� � ||fd�� � } | |dz
||z dz
� }
| | |
fS )a�
Compute SVD of a complex matrix to a specified relative precision using
random matrix-vector multiplication.
:param eps:
Relative precision.
:type eps: float
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
r0 r r )r � idzp_rsvdrR r5 )r7 r) r r� r] r8 rn ro rp r rW rT rU rV s r r� r� � r� r c � � t j | � � } | j \ }}t |||� � }t j | ||� � \ }}||k r t j |||z
fdd�� � }n |� |||z
fd�� � }||fS )aj
Compute ID of a complex matrix to a specified rank using random sampling.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
r� r r� r )r r r2 � idzr_aidir �idzr_aidrt r5 r� s r r� r� � s� � �$ ��!� � �A� �7�D�A�q��!�Q����A�� �Q��1�%�%�I�C���A�v�v��x��A�a�C�� �C�@�@�@����|�|�Q��!��H�C�|�0�0�� ��9�r c �. � t j | ||� � S )aO
Initialize array for :func:`idzr_aid`.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param k:
Rank of ID.
:type k: int
:return:
Initialization array to be used by :func:`idzr_aid`.
:rtype: :class:`numpy.ndarray`
)r r� r� s r r� r� r� r c �F � t j | � � } | j \ }}t j d|z dz |z d|z dz |z z d|dz z z d|z z dz dd �
� � }t |||� � }||d |j �< t
j | ||� � \ }}}} | rt �|||fS ) a�
Compute SVD of a complex matrix to a specified rank using random sampling.
:param A:
Matrix.
:type A: :class:`numpy.ndarray`
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
rs � r� r� r� �
�Z r� r r� N) r r r2 rt r� rB r � idzr_asvdrR r� s
r r� r� ! s� � �* ��!� � �A� �7�D�A�q�
��
�1��r��1� ��!��b��!�|�#�a��1��f�,�r�!�t�3�b�8��#� '� '� '�A�
�1�a�� � �B��A�h�r�w�h�K��=��A�q�)�)�L�A�q�!�S�
� � � � �a��7�Nr c � � t j | |||� � \ }}|d|||z
z � � |||z
fd�� � }||fS )a�
Compute ID of a complex matrix to a specified rank using random
matrix-vector multiplication.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:param k:
Rank of ID.
:type k: int
:return:
Column index array.
:rtype: :class:`numpy.ndarray`
:return:
Interpolation coefficients.
:rtype: :class:`numpy.ndarray`
Nr r )r �idzr_ridr5 )r) r r� r8 r9 r; s r r� r� G r� r c �X � t j | ||||� � \ }}}}|rt �|||fS )a�
Compute SVD of a complex matrix to a specified rank using random
matrix-vector multiplication.
:param m:
Matrix row dimension.
:type m: int
:param n:
Matrix column dimension.
:type n: int
:param matveca:
Function to apply the matrix adjoint to a vector, with call signature
`y = matveca(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matveca: function
:param matvec:
Function to apply the matrix to a vector, with call signature
`y = matvec(x)`, where `x` and `y` are the input and output vectors,
respectively.
:type matvec: function
:param k:
Rank of SVD.
:type k: int
:return:
Left singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Right singular vectors.
:rtype: :class:`numpy.ndarray`
:return:
Singular values.
:rtype: :class:`numpy.ndarray`
)r � idzr_rsvdrR ) r) r r� r] r8 rT rU rV rW s r r� r� k s= � �F �=��A�w���:�:�L�A�q�!�S�
� � � � �a��7�Nr )rY )?�__doc__�scipy.linalg._interpolative�linalg�_interpolativer �numpyr � RuntimeErrorrR r r r r r r" r' r, r1 r> rC rI rM rQ r[ rc rh rl ru ry r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r �<module>r� s� ��<� � *� )� )� )� )� )� )� )� )� � � � � � � 3�4�4��
�
�
�
�
�
�
�
�
�� � � � � �:$� $� $�:� � �$ � � �2� � �8� � �2%� %� %�2'� '� '�$'� '� '�4 � � �F � � � �@'L� 'L� 'L� 'L�\� � �8 � � �H � � �>
�
�
�<#� #� #�T#� #� #�L
�
�
�D)� )� )�`� � �:"� "� "�2 � � �H � � �H&� &� &�Z � � �:$� $� $�:� � �$ � � �2� � �8� � �2%� %� %�2'� '� '�$'� '� '�4 � � �F � � � �@'L� 'L� 'L� 'L�\� � �8 � � �H � � �>
�
�
�<#� #� #�T%� %� %�P
�
�
�D)� )� )�`� � �:"� "� "�2 � � �L � � �H&� &� &� &� &r