5[g~dZddlmcmZddlZedZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZdZdZd:dZd:dZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$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.Z3d/Z4d0Z5d1Z6d2Z7d3Z8d4Z9d5Z:d6Z;d7Zy);z0 Direct wrappers for Fortran `id_dist` backend. Nznonzero return codectj|}|jjr|j d}|Stj |}|S)z6 Same as np.asfortranarray, but ensure a copy Forder)npasarrayflags f_contiguouscopyasfortranarray)As ^/var/www/html/bid-api/venv/lib/python3.12/site-packages/scipy/linalg/_interpolative_backend.py_asfortranarray_copyr(sL 1 Aww FFF  H   a  Hc,tj|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` )_idid_srand)ns rrr8s <<?rcXtj|}tj|y)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)rr r id_srandi)ts rrrHs  !AMM!rc,tjy)z5 Reset seed values to their original values. N)r id_srandorrrrUs MMOrc0tj|||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` )ridd_frmrwxs rrr`4 ;;q!Q rc2tj||||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` )ridd_sfrmlrrrs rr"r"}4 <<1a ##rc,tj|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` )ridd_frmims rr'r' <<?rc.tj||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_sfrmir$r)s rr,r,$ ==A rct|}tj||\}}}|jd}|jj d|||z zj |||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` Nrr)rriddp_idshapeTravelreshapeepsr kidxrnormsrprojs rr1r1s* QA[[a(NAsF  A 3399;x1Q3 ( (!QqS ( =D c4<rct|}tj||\}}|jd}|jj d|||z zj |||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` r0Nrr)rriddr_idr2r3r4r5r r8r9r:rr;s rr>r>o$ QA++a#KC  A 3399;x1Q3 ( (!QqS ( =D 9rctj|}|jdkDrtj|||S|ddtj |fS)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` rN)rr sizer idd_reconidargsortBr9r;s rrCrCJ$ !A yy1}q#t,,BJJsO#$$rc.tj||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_reconintr9r;s rrIrI   C &&rcZtj|}tj|||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` )rr r idd_copycolsr r8r9s rrMrM%)$ !A   Aq# &&rc~tj|}tj|||\}}}}|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` )rr r idd_id2svd_RETCODE_ERRORrFr9r;UVSiers rrQrQ?B0 !A>>!S$/LAq!S  a7Nrc>tj|||||\}}|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)rmatvectmatvecitssnormvs rrZrZb#8}}Q7FC8HE1 Lrc 8tj|||||||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)rr[matvect2r\matvec2r]s rrbrb"N   Q7Hfgs KKrc|tj|}tj||\}}}}|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` )rr riddr_svdrRr r8rTrUrVrWs rrgrg@* !A<<1%LAq!S  a7NrcJtj|}|j\}}tj||\}}}}}} | rt ||dz |||zzdz j ||fd} ||dz |||zzdz j ||fd} ||dz ||zdz } | | | 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` r0rr)rr r2riddp_svdrRr5 r7r r)rr8iUiViSrrWrTrUrVs rrkrk* !A 77DAqLLa0Ar2r1c  "Q$r!A#vax  !Qs 3A "Q$r!A#vax  !Qs 3A "Q$r!tAvA a7Nrc6tj|}|j\}}t|\}}tj|d|zdzz|zdzd}t j ||||\}}}|d|||z zj|||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` r0rrN)rr r2r'emptyriddp_aidr5 r7r r)rn2rr;r8r9s rrtrts, !A 77DAq QKEB 88AqtaxL2%) 5D<<Q40LAsD AaC> ! !1ac(# ! 6D c4<rctj|}|j\}}t|\}}tj||z|dz|dzzzd}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 r0rr)rr r2r'rsr idd_estrankr7r r)rrvrrar8s rrxrxsq$ !A 77DAq QKEB !B$!a%"q&)) 5B OOCAr *EAr Hrc 6tj|}|j\}}tj|\}}tj t t||dzd|zd|zzdzzdt||dzzzd|zdz|dzzd}tj||||\}}} } }} | rt||dz |||zzdz j||fd} || dz | ||zzdz j||fd} || dz | |zdz }| | |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` r0rrrr) rr r2rr'rsmaxmin iddp_asvdrRr5r7r r)rrvwinitrr8rmrnrorWrTrUrVs rrr-sA, !A 77DAq QIB  SAY]QqS1Q3Y] +bQAo = qS1WrAv   A MM#q%;Ar2r1c  "Q$r!A#vax  !Qs 3A "Q$r!A#vax  !Qs 3A "Q$r!tAvA a7Nrctj|dzd|zt||dzzzd}tj|||||\}}}}|dk7rt |d|||z zj |||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` r0rrrrrN)rrsrriddp_ridrRr5)r7r)rr[r;r8r9rWs rrrWs< 88AEAaCQQ//s ;D S!Q>AsD# ax AaC> ! !1ac(# ! 6D c4<rcNtj||||\}}}|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)r7r)rr[r8rzrWs rrr}.0!!#q!W5JAr3  Hrctj|||||\}}}}} } | rt| |dz |||zzdz j||fd} | |dz |||zzdz j||fd} | |dz ||zdz } | | | 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` r0rr)r iddp_rsvdrRr5)r7r)rr[r\r8rmrnrorrWrTrUrVs rrrF MM#q!WfEAr2r1c  "Q$r!A#vax  !Qs 3A "Q$r!A#vax  !Qs 3A "Q$r!tAvA a7Nrctj|}|j\}}t|||}t j |||\}}||k(r!tj |||z fdd}||fS|j|||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` float64rdtyperr)rr r2 iddr_aidiriddr_aidrsr5r r8r)rrr9r;s rrrs$ !A 77DAq!QA Q1%ICAvxxAaC = 9||Q!HC|0 9rc0tj|||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` )rrr)rr8s rrr$ ==Aq !!rcJtj|}|j\}}tjd|zdz|zd|zdz|zzd|dzzzdzd}t |||}||d |j t j|||\}}}} | d k7rt|||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` rrr~drrNr) rr r2rsrrBr iddr_asvdrR r r8r)rrw_rTrUrVrWs rrrs* !A 77DAq !A#(A1r1 ,r!Q$w6 ! !1ac(# ! 6D 9rc^tj|||||\}}}}|dk7rt|||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)rr[r\r8rTrUrVrWs rrrMs;F==Aw:LAq!S ax a7Nrc0tj|||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` )ridz_frmrs rrrzr rc2tj||||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` )ridz_sfrmr#s rrrr%rc,tj|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` )ridz_frmir(s rrrr*rc.tj||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 rrrr.rct|}tj||\}}}|jd}|jj d|||z zj |||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` r0Nrr)rridzp_idr2r3r4r5r6s rrrr<rct|}tj||\}}|jd}|jj d|||z zj |||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` r0Nrr)rridzr_idr2r3r4r5r?s rrrr@rctj|}|jdkDrtj|||S|ddtj |fS)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` rN)rr rBr idz_reconidrDrEs rrrrGrc.tj||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_reconintrJs rrr-rKrcZtj|}tj|||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` )rr r idz_copycolsrNs rrr?rOrc~tj|}tj|||\}}}}|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` )rr r idz_id2svdrRrSs rrrYrXrc>tj|||||\}}|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)rmatvecar\r]r^r_s rrr|r`rc 8tj|||||||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)rrmatveca2r\rdr]s rrrrerc|tj|}tj||\}}}}|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` )rr ridzr_svdrRrhs rrrrircJtj|}|j\}}tj||\}}}}}} | rt ||dz |||zzdz j ||fd} ||dz |||zzdz j ||fd} ||dz ||zdz } | | | 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` r0rr)rr r2ridzp_svdrRr5rls rrrrprc8tj|}|j\}}t|\}}tj|d|zdzz|zdzdd}t j ||||\}}}|d|||z zj|||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` rrr0 complex128rrNr)rr r2rrsridzp_aidr5rus rrr s, !A 77DAq QKEB 88AqtaxL2%)S ID<<Q40LAsD AaC> ! !1ac(# ! 6D c4<rctj|}|j\}}t|\}}tj||z|dz|dzzzdd}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 r0rrr)rr r2rrsr idz_estrankrys rrr)ss$ !A 77DAq QKEB !B$!a%"q&))S IB OOCAr *EAr Hrc Ttj|}|j\}}tj|\}}tj t t||dzd|zd|zzdzzdt||dzzzd|zdz|dzztjd}tj||||\}}} } }} | rt||dz |||zzdz j||fd } || dz | ||zzdz j||fd } || dz | |zdz }| | |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` r0r|r} rrrrr) rr r2rrrsrrr idzp_asvdrRr5rs rrrGsG, !A 77DAq QIB  SAY]QqS1Q3Y^ ,qQA~ = qS1WrAv  mm3 (A MM#q%;Ar2r1c  "Q$r!A#vax  !Qs 3A "Q$r!A#vax  !Qs 3A "Q$r!tAvA a7Nrctj|dzd|zt||dzzztjd}t j |||||\}}}}|rt |d|||z zj|||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` r0rrrrNr)rrsrrridzp_ridrRr5)r7r)rrr;r8r9rWs rrrqs< 88 A!SAY]##mm3 (D S!Q>AsD#  AaC> ! !1ac(# ! 6D c4<rcNtj||||\}}}|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)r7r)rrr8rzrWs rrrrrctj|||||\}}}}} } | rt| |dz |||zzdz j||fd} | |dz |||zzdz j||fd} | |dz ||zdz } | | | 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` r0rr)r idzp_rsvdrRr5)r7r)rrr\r8rmrnrorrWrTrUrVs rrrrrctj|}|j\}}t|||}t j |||\}}||k(r!tj |||z fdd}||fS|j|||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` rrrr)rr r2 idzr_aidiridzr_aidrsr5rs rrrs$ !A 77DAq!QA Q1%ICAvxxAaC C@ 9||Q!HC|0 9rc0tj|||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` )rrrs rrrrrcRtj|}|j\}}tjd|zdz|zd|zdz|zzd|dzzzd|zzdzdd }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` rrrrr ZrrrN) rr r2rsrrBr idzr_asvdrRrs rrr!s* !A 77DAq  1r1 !b!|#a1f,r!t3b8# 'A 1a BAhrwwK==Aq)LAq!S  a7Nrctj||||\}}|d|||z zj|||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` Nrr)ridzr_ridr5)r)rrr8r9r;s rrrGrrcXtj|||||\}}}}|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)rrr\r8rTrUrVrWs rrrks7F==Aw:LAq!S  a7Nr))?__doc__scipy.linalg._interpolativelinalg_interpolativernumpyr RuntimeErrorrRrrrrrr"r'r,r1r>rCrIrMrQrZrbrgrkrtrxrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsE<*)34    :$:$282%2'$'4F@'L\8H> <#T#L D)`:"2HH&Z :$:$282%2'$'4F@'L\8H> <#T%P D)`:"2LH&r