B T\ګ@srddlmZmZmZddlZddlmZddlmZddl Z ddl Z ddl m Z ddlmZddlmZdd lmZd d lmZmZmZd d lmZd d lmZddZddZddZddZd=ddZd>ddZ d?ddZ!d@dd Z"dAd!d"Z#d#d$Z$d%d&Z%d'd(Z&d)d*Z'dBd+d,Z(dCd-d.Z)d/d0Z*d1d2Z+dDd3d4Z,d5d6Z-d7d8Z.d9d:Z/ee j0j1dEd;d<Z1dS)F)absolute_importdivisionprint_functionN)wraps)Number)tokenize) blockwise)apply)HighLevelGraph)dotmanyArray concatenate)eye) RandomStateccs,d}x"|D]}|}||7}||fVq WdS)Nr)itZtotalxZtotal_previousrr0lib/python3.7/site-packages/dask/array/linalg.py_cumsum_blockss  rcCs|d|d|fS)Nr r)Zlastnewrrr _cumsum_partsrcCs0t||g}t|r|n|}t|r,|S|S)N)minnpisnan)mnZk_0Zk_1rrr_nanmins rcCs<|jddkr,tdtd|jdffStj|SdS)z A wrapper for np.linalg.qr that handles arrays with 0 rows Notes: Created for tsqr so as to manage cases with uncertain array dimensions. In particular, the case where arrays have (uncertain) chunks with 0 rows. r)rrr N)shaperzeroslinalgqr)arrr _wrapped_qr%s r$FcU sp tjdtjd}}tjdjdd}}jdkrN|dksbtdjjdt|}j\}|df} t j t j dj d\} } j} j} d| tt d jd j| id }|| <| <d |d t fd dt| dD}|| < h| <d |d t fddt| dD}|| < h| <||}tddjD }t ||}|dkr|n|d|k}|ot|dk}|r|r|rg}g}d}xdtjdD]R\}}|}t||}|}|||kr.||g}d}|||f||7}qWt|dkrb||d|d t fddt|D}|| < h| <tdd|D}t| | } t | t!|f|f| j d}!t"|!|d\ }"t#$ j%j|"j%j} t#$ j%j|"j%j} d|dt fddt|D}#|#| < | <d|}$|$ddf|"jddfi}%|%| |$<|"| |$<d|d}&tt j&|&d d d | | id }'|'| |&<|&h| |&<nއ fddt| dD}(d|d})|)ddft j't|(ffi}*|*| |)< h| |)<d|d }+tt j j |+d |)d |)did },|,| |+<|)h| |+<d |d!ddft(j)|+ddfdfi}-|-| <|+h| <td"djDs܇fd#djdD}.fd$dt*|.D}/i}0t+}1nd%|dfd&d't| dD}2d |d(t(j)t,jddfd%fdfi}3d)|ddfddfgi}4|4-fd*d'td| dDd+|d,fd-d't| dD}5t#$|3|2|4|5}0jh}1fd.dt| dD}/|0| d/|<|1| d/|<d |dtfd0dt|/D}#|#| <d/|h| <d1|d}&tt j&|&d d d | | id }'|'| |&<h| |&<d |d2}$|$ddft(j)|+ddfdfi}%|%| |$<|+h| |$<|szt .jdptd3djdD}6t .jdptd4djdD}7|6rB|7rBj}8jdt j/ff}9t j/t j/f}:t j/ft j/ff};n|6rv|7svj}8jdff}9f}:f};n|6s|7rj}8jdt j/ff}9t j/t j/f}:t j/ft j/ff};njdjdkrԈjnjdjdf}8jdjdkrjnjdjdf}9jdjdkr6fnj}:|:};t| | } t | |&|8|9| j d}tt j j0|>d |$d |$did }?d |d7}@|@ddft(j)|>ddfdfi}Ad |d8}B|Bdft(j)|>ddfdfi}Cd |d9}D|Dddft(j)|>ddfdfi}Ed |d:}Ftt1|Fd |&d;|@d<|&| |@did }G|?| |><|$h| |><|A| |@<|>h| |@<|G| |F<|&|@h| |F<|C| |B<|>h| |B<|E| |D<|>h| |D<t j 0t j dj d\}H}I}Jt2|}K|}Lt .|K st|Kn|K}M|M}N|M}O}Pt|O|P}Qt| | } t | |F|L|Mfjd|Mff|Hj d}Rt | |B|Nf|Nff|Ij d}St | |D|Q|Qffff|Jj d}T|R|S|TfSdS)=a Direct Tall-and-Skinny QR algorithm As presented in: A. Benson, D. Gleich, and J. Demmel. Direct QR factorizations for tall-and-skinny matrices in MapReduce architectures. IEEE International Conference on Big Data, 2013. http://arxiv.org/abs/1301.1071 This algorithm is used to compute both the QR decomposition and the Singular Value Decomposition. It requires that the input array have a single column of blocks, each of which fit in memory. Parameters ---------- data: Array compute_svd: bool Whether to compute the SVD rather than the QR decomposition _max_vchunk_size: Integer Used internally in recursion to set the maximum row dimension of chunks in subsequent recursive calls. Notes ----- With ``k`` blocks of size ``(m, n)``, this algorithm has memory use that scales as ``k * m * n``. The implementation here is the recursive variant due to the ultimate need for one "single core" QR decomposition. In the non-recursive version of the algorithm, given ``k`` blocks, after ``k`` ``m * n`` QR decompositions, there will be a "single core" QR decomposition that will have to work with a ``(k * n, n)`` matrix. Here, recursion is applied as necessary to ensure that ``k * n`` is not larger than ``m`` (if ``m / n >= 2``). In particular, this is done to ensure that single core computations do not have to work on blocks larger than ``(m, n)``. Where blocks are irregular, the above logic is applied with the "height" of the "tallest" block used in place of ``m``. Consider use of the ``rechunk`` method to control this behavior. Blocks that are as tall as possible are recommended. See Also -------- dask.array.linalg.qr - Powered by this algorithm dask.array.linalg.svd - Powered by this algorithm dask.array.linalg.sfqr - Variant for short-and-fat arrays rr raInput must have the following properties: 1. Have two dimensions 2. Have only one column of blocks Note: This function (tsqr) supports QR decomposition in the case of tall-and-skinny matrices (single column chunk/block; see qr)Current shape: {}, Current chunksize: {}-)r r )rdtyper"Zij) numblocksgetitemz-q1c3s*|]"}|dftj|dfdffVqdS)rN)operatorr().0i) name_q_st1 name_qr_st1rr sztsqr..z-r1c3s*|]"}|dftj|dfdffVqdS)rr N)r)r()r*r+)r- name_r_st1rrr.scss"|]}|D]}t|Vq qdS)N)rr)r*cscrrrr.sNstackc3s8|]0\}}|dftjtfdd|DfffVqdS)rcsg|]\}}|dfqS)rr)r*idx_)r/rr sz"tsqr...N)rvstacktuple)r*r+sub_block_info)r/name_r_stackedrrr.scSsg|]}ttdd|qS)cSs|dS)Nr r)rrrrsz!tsqr...)summap)r*r8rrrr5sztsqr..)rchunksr&)_max_vchunk_sizezgetitem-z-q2c 3st|]l\}}tdd|Dtdd|DD]@\}}|dftjj|dft|d|dtdfffVq,qdS)cSsg|] }|dqS)rr)r*rrrrr5sz"tsqr...cSsg|] }|dqS)r r)r*rrrrr5srr N)ziprr)r(nameslice)r*r+r8je)r name_q_st2q_innerrrr.szr-inner-zdot-z-q3csg|]}|dfqS)rr)r*r+)r/rrr5sz-qr2z-q2-auxcss"|]}|D]}t|Vq qdS)N)rr)r*r0r1rrrr.scsg|]}t|qSr)r)r*rC)rrrr5scs(g|] }t|d|dtdfqS)rr )rA)r*rC)rrrr5srcs(i|] }ttj|dfdff|fqS)rr)rgetattrr@)r*r+)data name_q2bsrr sztsqr..z-nZcumsumcs(i|] }t|df|ff|fqS)r )r)r*r+)rH name_q2csrrrIsrAz-qcs.i|]&}ttt|fftdfgf|fqS)r)r7r rA)r*r+)name_blockslicename_nrJrrrIscsg|] }|fqSrr)r*r+)rKrrr5&sz q-blocksizesc3s.|]&\}}|dftjddf|ffVqdS)rN)r)r()r*r+b)rDname_q_st2_auxrrr.-sdotz-r2css|]}t|VqdS)N)rr)r*r1rrrr.Bscss|]}t|VqdS)N)rr)r*r1rrrr.Cssvdz-2z-u2z-s2z-v2z-u4ZikZkj)3lenr=maxndim ValueErrorformatrZ chunksizerrr!r"onesr&__dask_graph__layerscopy dependenciesr r$r@__dask_layers__dictrangeanyZceilint enumeraterappendr7r rr;tsqrtoolzmergeZdaskrOr6r)r(rsetrFupdaternanrPr r)UrG compute_svdr>nrncZcr_maxcctokenrr'qqrrrXrZZ dsk_qr_st1Z dsk_q_st1Z dsk_r_st1Zsingle_core_compute_mZchunks_well_definedZprospective_blocksZmeaningful_reduction_possibleZcan_distributeZ all_blocksZ curr_blockZ curr_block_szr3Za_mZm_qZn_qZm_rZ dsk_r_stackedZvchunks_rstackedgraphZ r_stackedZr_innerZ dsk_q_st2Z name_r_st2Z dsk_r_st2Z name_q_st3Z dsk_q_st3Zto_stackZname_r_st1_stackedZdsk_r_st1_stackedZ name_qr_st2Z dsk_qr_st2Z dsk_q_st2_auxZq2_block_sizesZ block_slicesZdsk_q_blockslicesZdepsZ dsk_q2_shapesZdsk_nZ dsk_q2_cumsumZdsk_block_slicesZ is_unknown_mZ is_unknown_nZq_shapeZq_chunksZr_shapeZr_chunksqrZ name_svd_st2Z dsk_svd_st2Z name_u_st2Z dsk_u_st2Z name_s_st2Z dsk_s_st2Z name_v_st2Z dsk_v_st2Z name_u_st4Z dsk_u_st4uussZvvhkZm_uZn_uZn_sZm_vhZn_vhZd_vhusZvhr) rGrrKrLrHrJr,rDrNr-r/r9rErrb4s4                                            **      00$                    $ rbcsvtjdtjd}}jddjdd}}jdkr^|dkr^||ksf|dksftd|ptdt}|d7}j\}}tjtj dj d\} } j } j } |d } |d | ddfjddfi| | <| | <fd d t|dD| <| <|d }|d}|d}|ddftjj| ddffi| |<| h| |<|ddftj|ddfdfi| |<|h| |<|ddftj|ddfdfi| |<|h| |<t| | }t|||t||f|t||f| j d}t||t|||f||f| j d}|g}|dkrbt|t||||f|jdddf| j d}||j|t|dd}||fS)a$ Direct Short-and-Fat QR Currently, this is a quick hack for non-tall-and-skinny matrices which are one chunk tall and (unless they are one chunk wide) have chunks that are wider than they are tall Q [R_1 R_2 ...] = [A_1 A_2 ...] it computes the factorization Q R_1 = A_1, then computes the other R_k's in parallel. Parameters ---------- data: Array See Also -------- dask.array.linalg.qr - Main user API that uses this function dask.array.linalg.tsqr - Variant for tall-and-skinny case rr raInput must have the following properties: 1. Have two dimensions 2. Have only one row of blocks 3. Either one column of blocks or (first) chunk size on cols is at most that on rows (e.g.: for a 5x20 matrix, chunks=((5), (8,4,8)) is fine, but chunks=((5), (4,8,8)) is not; still, prefer something simple like chunks=(5,10) or chunks=5) Note: This function (sfqr) supports QR decomposition in the case of short-and-fat matrices (single row chunk/block; see qr)zsfqr-r4)r r )rr&ZA_1A_restcs$i|]}jdd|fd|fqS)rr )r@)r*r3)rG name_A_restrrrIszsfqr..ZQ_R_1QR_1)rr=r&N)axis)rQr=rSrTrrrr!r"rVr&rWrXrYrZr@r[r]r)r(r rrraTrOr)rGr@rirjZcrrkprefixrrrmrnrXrZZname_A_1Z name_Q_R1Zname_QZname_R_1roryrzZRsrwRr)rGrxrsfqrsT             " . r cCstt||||S)a  Compression level to use in svd_compressed Given the size ``n`` of a space, compress that that to one of size ``q`` plus oversampling. The oversampling allows for greater flexibility in finding an appropriate subspace, a low value is often enough (10 is already a very conservative choice, it can be further reduced). ``q + oversampling`` should not be larger than ``n``. In this specific implementation, ``q + oversampling`` is at least ``min_subspace_size``. >>> compression_level(100, 10) 20 )rrR)rrpZ oversamplingZmin_subspace_sizerrrcompression_levelsrc Csz|jd}t||}t|}|j||f|jd|ffd}||}x"t|D]} ||j|}qNWt|\}} |jS)a` Randomly sample matrix to find most active subspace This compression matrix returned by this algorithm can be used to compute both the QR decomposition and the Singular Value Decomposition. Parameters ---------- data: Array q: int Size of the desired subspace (the actual size will be bigger, because of oversampling, see ``da.linalg.compression_level``) n_power_iter: int number of power iterations, useful when the singular values of the input matrix decay very slowly. References ---------- N. Halko, P. G. Martinsson, and J. A. Tropp. Finding structure with randomness: Probabilistic algorithms for constructing approximate matrix decompositions. SIAM Rev., Survey and Review section, Vol. 53, num. 2, pp. 217-288, June 2011 http://arxiv.org/abs/0909.4061 r )sizer=) rrrZstandard_normalr=rOr]r|rb) rGrp n_power_iterseedrZ comp_levelstateZomegaZmat_hrBr4rrrcompression_matrixs     rc Cs~t||||d}||}t|jdd\}}}|j|}|j}|ddd|f}|d|}|d|ddf}|||fS)a Randomly compressed rank-k thin Singular Value Decomposition. This computes the approximate singular value decomposition of a large array. This algorithm is generally faster than the normal algorithm but does not provide exact results. One can balance between performance and accuracy with input parameters (see below). Parameters ---------- a: Array Input array k: int Rank of the desired thin SVD decomposition. n_power_iter: int Number of power iterations, useful when the singular values decay slowly. Error decreases exponentially as n_power_iter increases. In practice, set n_power_iter <= 4. Examples -------- >>> u, s, vt = svd_compressed(x, 20) # doctest: +SKIP Returns ------- u: Array, unitary / orthogonal s: Array, singular values in decreasing order (largest first) v: Array, unitary / orthogonal References ---------- N. Halko, P. G. Martinsson, and J. A. Tropp. Finding structure with randomness: Probabilistic algorithms for constructing approximate matrix decompositions. SIAM Rev., Survey and Review section, Vol. 53, num. 2, pp. 217-288, June 2011 http://arxiv.org/abs/0909.4061 )rrT)rhN)rrOrbr|) r#rtrrcompZ a_compressedvrvrurrrsvd_compressed-s'   rcCsRt|jddkr,t|jddkr,t|St|jddkrFt|StddS)a Compute the qr factorization of a matrix. Examples -------- >>> q, r = da.linalg.qr(x) # doctest: +SKIP Returns ------- q: Array, orthonormal r: Array, upper-triangular See Also -------- np.linalg.qr : Equivalent NumPy Operation dask.array.linalg.tsqr: Implementation for tall-and-skinny arrays dask.array.linalg.sfqr: Implementation for short-and-fat arrays r ra}qr currently supports only tall-and-skinny (single column chunk/block; see tsqr) and short-and-fat (single row chunk/block; see sfqr) matrices Consider use of the rechunk method. For example, x.rechunk({0: -1, 1: 'auto'}) or x.rechunk({0: 'auto', 1: -1}) which rechunk one shorter axis to a single chunk, while allowing the other axis to automatically grow/shrink appropriately.N)rQr=rbrNotImplementedError)r#rrrr"_s $r"cCs t|ddS)a Compute the singular value decomposition of a matrix. Examples -------- >>> u, s, v = da.linalg.svd(x) # doctest: +SKIP Returns ------- u: Array, unitary / orthogonal s: Array, singular values in decreasing order (largest first) v: Array, unitary / orthogonal See Also -------- np.linalg.svd : Equivalent NumPy Operation dask.array.linalg.tsqr: Implementation for tall-and-skinny arrays T)rh)rb)r#rrrrPsrPcCsddl}|jj||ddS)NrT)lower) scipy.linalgr!solve_triangular)r#rMscipyrrr_solve_triangular_lowersrcCszddl}|jdkrtd|j\}}||kr4tdtt|jd|jddks`d}t|t|jd}t|jd}t|}d|}d |} d |} d |} d |} d |} d|}d|}d|}i}xtt ||D]}|j ||f}|dkrZg}xFt|D]:}|||||f}t j | ||f| ||ff||<| |q Wtj|t|ff}|jj|f||||f<xt|d|D]}t j | ||f|j ||ff}|dkrg}xFt|D]:}|||||f}t j | ||f| ||ff||<| |qWtj|t|ff}t| ||f|f||||f<qWxt|d|D]}|j ||f}|dkrg}xFt|D]:}|||||f}t j | ||f| ||ff||<| |q\Wtj|t|ff}t jt|||ft j|fff||||f<q4WqWxtt ||D]}xtt ||D]}||krtj|||fdf|| ||f<tj|||fdf|| ||f<tj|||fdf|| ||f<t j | ||f| ||ff|| ||f<t j| ||ff||||f<t j| ||ff|| ||f<q||kr\t j|jd||jd|ff|| ||f<t j | ||f|||ff|| ||f<t j|jd||jd|ff|| ||f<|||f|| ||f<nlt j|jd||jd|ff|| ||f<t j|jd||jd|ff|| ||f<|||f|| ||f<qWqW|jt jd|jd\}}}tj| ||gd}t|| |j|j|jd}tj| ||gd}t|| |j|j|jd}tj| ||gd}t|| |j|j|jd}|||fS)a! Compute the lu decomposition of a matrix. Examples -------- >>> p, l, u = da.linalg.lu(x) # doctest: +SKIP Returns ------- p: Array, permutation matrix l: Array, lower triangular matrix with unit diagonal. u: Array, upper triangular matrix rNrz/Dimension must be 2 to perform lu decompositionz9Input must be a square matrix to perform lu decompositionr zqAll chunks must be a square matrix to perform lu decomposition. Use .rechunk method to change the size of chunks.zlu-lu-zlu-p-zlu-l-zlu-u-z lu-p-inv-z lu-l-permute-zlu-u-transpose-z lu-plu-dot-z lu-lu-dot-)r r )rr&)rZ)rr=r&)rrSrTrrQrer=rr]rr@rrOrar)subr;r!lur transposer(r rVr&r from_collectionsr)r#rxdimydimmsgvdimhdimrlZname_luZname_pZname_lZname_uZ name_p_invZname_l_permutedZname_u_transposedZ name_plu_dotZ name_lu_dotdskr+targetprevspprevrBrtZppZllrrrolrurrrrs        " " ,",,, rcsddl}|jdkrtdjdkrb|jdjdkr@td|jdjdkrjd}t|ntdt|jd}jdkrdn tjd}t||}d |d |}fd d } fd d} i} |rxt|D]} xt|D]} | | | }| dkrbg}xHt| D]<}|| ||| f}tj |j | |f| || f| |<| |qWt j |t|ff}t|j | | f|f| | | | <qWqWnxt|D]} xt|D]} | | | }| |dkr g}xNt| d|D]<}|| ||| f}tj |j | |f| || f| |<| |qWt j |t|ff}|jj|j | | f|f| | | | <qWqWtj| |gd}ttjddgddgg|jdtjddgjd}t|jj|jdS)a Solve the equation `a x = b` for `x`, assuming a is a triangular matrix. Parameters ---------- a : (M, M) array_like A triangular matrix b : (M,) or (M, N) array_like Right-hand side matrix in `a x = b` lower : bool, optional Use only data contained in the lower triangle of `a`. Default is to use upper triangle. Returns ------- x : (M,) or (M, N) array Solution to the system `a x = b`. Shape of return matches `b`. rNrza must be 2 dimensionalr z'a.shape[1] and b.shape[0] must be equalz\a.chunks[1] and b.chunks[0] must be equal. Use .rechunk method to change the size of chunks.zb must be 1 or 2 dimensionalzsolve-triangular-zsolve-tri-dot-cs$jdkrj|fSj||fSdS)Nr )rSr@)r+rB)rMrr_b_initOs  z!solve_triangular.._b_initcs jdkr|fS||fSdS)Nr )rS)r+rB)rMr@rr_keyUs zsolve_triangular.._key)rZ)r&)rr=r&)rrSrTrr=rQrr]rrOr@rar)rr;rr!rr rarrayr&r)r#rMrrrZvchunksZhchunksrlZ name_mdotrrrr+rBrrrtrroZresr)rMr@rr$sZ       & ,rcCsD|rt|\}}nt|\}}}|j|}t||dd}t||S)aq Solve the equation ``a x = b`` for ``x``. By default, use LU decomposition and forward / backward substitutions. When ``sym_pos`` is ``True``, use Cholesky decomposition. Parameters ---------- a : (M, M) array_like A square matrix. b : (M,) or (M, N) array_like Right-hand side matrix in ``a x = b``. sym_pos : bool Assume a is symmetric and positive definite. If ``True``, use Cholesky decomposition. Returns ------- x : (M,) or (M, N) Array Solution to the system ``a x = b``. Shape of the return matches the shape of `b`. T)r) _choleskyrr|rOr)r#rMZsym_posrrurZuyrrrsolve{s  rcCs"t|t|jd|jdddS)a Compute the inverse of a matrix with LU decomposition and forward / backward substitutions. Parameters ---------- a : array_like Square matrix to be inverted. Returns ------- ainv : Array Inverse of the matrix `a`. r)r=)rrrr=)r#rrrinvsrcCsddl}|jj|ddS)NrT)r)rr!cholesky)r#rrrr_cholesky_lowersrcCst|\}}|r|S|SdS)a Returns the Cholesky decomposition, :math:`A = L L^*` or :math:`A = U^* U` of a Hermitian positive-definite matrix A. Parameters ---------- a : (M, M) array_like Matrix to be decomposed lower : bool, optional Whether to compute the upper or lower triangular Cholesky factorization. Default is upper-triangular. Returns ------- c : (M, M) Array Upper- or lower-triangular Cholesky factor of `a`. N)r)r#rrrurrrrs rcCsddl}|jdkrtd|j\}}||kr4tdtt|jd|jddks`d}t|t|jd}t|jd}t|}d|}d |} d |} i} xt|D]} xt|D]} | | krt j |jd| |jd| ff| || | f<|| | f| | | | f<q| | kr|j | | f}| dkrg}xFt| D]:}| | || |f}t j || |f| || ff| |<| |q>Wtj|t|ff}t|f| || | f<t j|| | ff| | | | f<q|j | | f}| dkr,g}xFt| D]:}| | || |f}t j || |f| || ff| |<| |qWtj|t|ff}t|| | f|f| | | | f<t j| | | ff| || | f<qWqWtj| | |gd }tj|| |gd }|jt jddgdd gg|jd }t|||j|j|jd}t|| |j|j|jd}||fS)zq Private function to perform Cholesky decomposition, which returns both lower and upper triangulars. rNrz5Dimension must be 2 to perform cholesky decompositionz?Input must be a square matrix to perform cholesky decompositionr zwAll chunks must be a square matrix to perform cholesky decomposition. Use .rechunk method to change the size of chunks.z cholesky-zcholesky-lt-dot-zcholesky-upper-)rZ)r&)rr=r&)rrSrTrrQrer=rr]rr r@rOrar)rr;rrrr rr!rrr&r)r#rrrrrrrlr@Z name_lt_dotZ name_upperrr+rBrrrrZ graph_upperZ graph_lowerZchorupperrrrrs`    ,     "$rcCs|ddd|S)N)sort)rrrr_sort_decreasingsrc CsNt|\}}t||j|}|||}|djdd}t||}d|}|ftjj|j ddffi}t j |||gd} t | |ddt d} d |} |j} | dfttjtjjtj| j ddf|j ddfffffi} t j | | | gd} tjtjd dgd dgg|jd tjdd g|jd \}}}}t | | |jdf|jd|jd}||| |fS) aA Return the least-squares solution to a linear matrix equation using QR decomposition. Solves the equation `a x = b` by computing a vector `x` that minimizes the Euclidean 2-norm `|| b - a x ||^2`. The equation may be under-, well-, or over- determined (i.e., the number of linearly independent rows of `a` can be less than, equal to, or greater than its number of linearly independent columns). If `a` is square and of full rank, then `x` (but for round-off error) is the "exact" solution of the equation. Parameters ---------- a : (M, N) array_like "Coefficient" matrix. b : (M,) array_like Ordinate or "dependent variable" values. Returns ------- x : (N,) Array Least-squares solution. If `b` is two-dimensional, the solutions are in the `K` columns of `x`. residuals : (1,) Array Sums of residuals; squared Euclidean 2-norm for each column in ``b - a*x``. rank : Array Rank of matrix `a`. s : (min(M, N),) Array Singular values of `a`. rT)keepdimsz lstsq-rank-r)rZr)rr=r&zlstsq-singular-r )r&)r"rr|rOr;rrr!Z matrix_rankr@r rrr_rZsqrtZeigvalslstsqrr&r)r#rMrprqrZ residualsrlZrnameZrdskroZrankZsnameZrtZsdskr4rsrvrrrrs*!  $ rcCs|dkrtt|j}nt|tr.t|f}nt|}t|dkrJtd|dkrjd}t|dkrjtd|t |j t }|dkrt |dj||dd}n|dkrt|dkrtd|jdkrtd t|ddj|d }n|t jkrZt |}t|dkr |j||d}n6|j|dd dj|d d d}|d kr|j|d}n*|t j krt |}t|dkr|j||d}n6|j|dd dj|d d d}|d kr|j|d}n|d krt|dkrtd|d k|j j||d}n~|dkrpt |}t|dkr6|j||d}n6|j|d d dj|dd d}|d kr|j|d}nt|dkr|dkrt |j|d d dj|dd d}|d kr|j|d}nt|dkr |dkr |jdkrtd t|ddj|d }nzt|dkrP|dkrP|jdkr6td t|ddj|d }n4t|dkrftdt ||j||dd|}|S)Nrz&Improper number of dimensions to norm.Zfror zInvalid norm order for vectors.)r{rg?Znucz+SVD based norm not implemented for ndim > 2)rTrF)r{z Invalid norm order for matrices.rg?)r7r]rS isinstancerr_rQrTZastyperZ promote_typesr&floatabsr;rrPinfrRZsqueezer)rordr{rrqrrrnormZsz               $   r)FN)N)rr)rN)rN)F)F)F)NNF)2Z __future__rrrr) functoolsrZnumbersrZnumpyrrcbaserr Z compatibilityr Zhighlevelgraphr Zcorer rrZcreationrZrandomrrrrr$rbrrrrr"rPrrrrrrrrrrr!rrrrrsL         f \  & 2& W  IA