o lÇ hNiã@s0dZddlmZddlmZGdd„deƒZdS)a¸ Linear algebra -------------- Linear equations ................ Basic linear algebra is implemented; you can for example solve the linear equation system:: x + 2*y = -10 3*x + 4*y = 10 using ``lu_solve``:: >>> from mpmath import * >>> mp.pretty = False >>> A = matrix([[1, 2], [3, 4]]) >>> b = matrix([-10, 10]) >>> x = lu_solve(A, b) >>> x matrix( [['30.0'], ['-20.0']]) If you don't trust the result, use ``residual`` to calculate the residual ||A*x-b||:: >>> residual(A, x, b) matrix( [['3.46944695195361e-18'], ['3.46944695195361e-18']]) >>> str(eps) '2.22044604925031e-16' As you can see, the solution is quite accurate. The error is caused by the inaccuracy of the internal floating point arithmetic. Though, it's even smaller than the current machine epsilon, which basically means you can trust the result. If you need more speed, use NumPy, or ``fp.lu_solve`` for a floating-point computation. >>> fp.lu_solve(A, b) # doctest: +ELLIPSIS matrix(...) ``lu_solve`` accepts overdetermined systems. It is usually not possible to solve such systems, so the residual is minimized instead. Internally this is done using Cholesky decomposition to compute a least squares approximation. This means that that ``lu_solve`` will square the errors. If you can't afford this, use ``qr_solve`` instead. It is twice as slow but more accurate, and it calculates the residual automatically. Matrix factorization .................... The function ``lu`` computes an explicit LU factorization of a matrix:: >>> P, L, U = lu(matrix([[0,2,3],[4,5,6],[7,8,9]])) >>> print(P) [0.0 0.0 1.0] [1.0 0.0 0.0] [0.0 1.0 0.0] >>> print(L) [ 1.0 0.0 0.0] [ 0.0 1.0 0.0] [0.571428571428571 0.214285714285714 1.0] >>> print(U) [7.0 8.0 9.0] [0.0 2.0 3.0] [0.0 0.0 0.214285714285714] >>> print(P.T*L*U) [0.0 2.0 3.0] [4.0 5.0 6.0] [7.0 8.0 9.0] Interval matrices ----------------- Matrices may contain interval elements. This allows one to perform basic linear algebra operations such as matrix multiplication and equation solving with rigorous error bounds:: >>> a = iv.matrix([['0.1','0.3','1.0'], ... ['7.1','5.5','4.8'], ... ['3.2','4.4','5.6']]) >>> >>> b = iv.matrix(['4','0.6','0.5']) >>> c = iv.lu_solve(a, b) >>> print(c) [ [5.2582327113062568605927528666, 5.25823271130625686059275702219]] [[-13.1550493962678375411635581388, -13.1550493962678375411635540152]] [ [7.42069154774972557628979076189, 7.42069154774972557628979190734]] >>> print(a*c) [ [3.99999999999999999999999844904, 4.00000000000000000000000155096]] [[0.599999999999999999999968898009, 0.600000000000000000000031763736]] [[0.499999999999999999999979320485, 0.500000000000000000000020679515]] é)Úcopyé)Úxrangec@s¢eZdZd)dd„Zd*dd„Zdd „Zd d „Zd+d d„Zdd„Zdd„Z dd„Z dd„Z dd„Z d*dd„Z d*dd„Zdd„Zdd „Zd*d!d"„Zd#d$„Zd,d'd(„ZdS)-ÚLinearAlgebraMethodsFTc s܈jˆjks tdƒ‚|rtˆˆjƒrˆjrˆjS|s ˆ}ˆ ¡‰ˆ ˆ ˆd¡ˆj ¡}ˆj}dg|d}t |dƒD]}d} t ||ƒD]5‰ˆ  ‡‡‡fdd„t ||ƒDƒ¡} ˆ | ¡|krct dƒ‚d| ˆ ˆˆ|f¡} | | krz| } ˆ||<qEˆ  ˆ|||¡ˆ ˆ||f¡|kr“t dƒ‚t |d|ƒD].} ˆ| |fˆ||f<t |d|ƒD]‰ˆ| ˆfˆ| |fˆ|ˆf8<q±qšq<ˆ ˆ|d|df¡|krÝt dƒ‚|sêt|ˆjƒrêˆ|f|_ˆ|fS)zØ LU-factorization of a n*n matrix using the Gauss algorithm. Returns L and U in one matrix and the pivot indices. Use overwrite to specify whether A will be overwritten with L and U. úneed n*n matrixéNrcsg|] }ˆ ˆˆ|f¡‘qS©)Úabsmin)Ú.0Úl©ÚAÚctxÚkrúj/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/mpmath/matrices/linalg.pyÚ „sz2LinearAlgebraMethods.LU_decomp..úmatrix is numerically singular)ÚrowsÚcolsÚ ValueErrorÚ isinstanceÚmatrixÚ_LUrr ÚmnormÚepsrÚfsumÚZeroDivisionErrorÚswap_row) rr Ú overwriteÚ use_cacheÚorigÚtolÚnÚpÚjÚbiggestÚsÚcurrentÚirr rÚ LU_decompnsF "€*ÿþ zLinearAlgebraMethods.LU_decompNcCs¢|j|jkr tdƒ‚|j}t|ƒ|krtdƒ‚t|ƒ}|r0tdt|ƒƒD] }| ||||¡q$td|ƒD]}t|ƒD]}|||||f||8<q;q5|S)zG Solve the lower part of a LU factorized matrix for y. rúValue should be equal to nrr)rrÚ RuntimeErrorÚlenrrrr)rÚLÚbr#r"rr(r$rrrÚL_solve›s   "ÿzLinearAlgebraMethods.L_solvecCsœ|j|jkr tdƒ‚|j}t|ƒ|krtdƒ‚t|ƒ}t|dddƒD](}t|d|ƒD]}|||||f||8<q,|||||f<q#|S)zG Solve the upper part of a LU factorized matrix for x. rr*réÿÿÿÿ)rrr+r,rrr)rÚUÚyr"Úxr(r$rrrÚU_solve®s  "zLinearAlgebraMethods.U_solvec s ˆj}z~ˆjd7_ˆj|fi|¤Ž ¡ˆj|fi|¤Ž ¡}}|j|jkr,tdƒ‚|j|jkr\|j}||}||}| dd¡sNt‡fdd„|DƒƒsUˆ  ||¡}n'ˆ  ||¡}nˆ  |¡\}}ˆ  |||¡}ˆ  ||¡}W|ˆ_|SW|ˆ_|SW|ˆ_|S|ˆ_w)aÑ Ax = b => x Solve a determined or overdetermined linear equations system. Fast LU decomposition is used, which is less accurate than QR decomposition (especially for overdetermined systems), but it's twice as efficient. Use qr_solve if you want more precision or have to solve a very ill- conditioned system. If you specify real=True, it does not check for overdeterminded complex systems. é ú#cannot solve underdetermined systemÚrealFc3ó|] }t|ƒˆjuVqdS©N©ÚtypeÚmpc©r r(©rrrÚ Ùó€z0LinearAlgebraMethods.lu_solve..)ÚprecrrrrrÚHÚgetÚsumÚcholesky_solveÚlu_solver)r/r4)rr r.ÚkwargsrAÚAHr3r#rr>rrF¾s6 .   ÿøö ÿzLinearAlgebraMethods.lu_solvercCsf|j|jkr tdƒ‚t|ƒD]"}| |||¡}| |d¡d|jkr%|S| || ¡}||7}q|S)zÔ Improve a solution to a linear equation system iteratively. This re-uses the LU decomposition and is thus cheap. Usually 3 up to 4 iterations are giving the maximal improvement. rrr5)rrr+rÚresidualÚnormrrF)rr r3r.ÚmaxstepsÚ_ÚrÚdxrrrÚimprove_solutionçs  þ z%LinearAlgebraMethods.improve_solutionc CsØ| |¡\}}|j}| |¡}| |¡}t|ƒD]7}t|ƒD]0}||kr/|||f|||f<q||krDd|||f<|||f|||f<q|||f|||f<qq| |¡}tt|ƒƒD] } | || || ¡q[|||fS)a7 A -> P, L, U LU factorisation of a square matrix A. L is the lower, U the upper part. P is the permutation matrix indicating the row swaps. P*A = L*U If you need efficiency, use the low-level method LU_decomp instead, it's much more memory efficient. r)r)rrrÚeyer,r) rr r#r"r-r1r(r$ÚPrrrrÚluùs"      ù  zLinearAlgebraMethods.lucCsLd|kr |ksJdƒ‚Jdƒ‚|jg|d|jg|jg||S)z< Return the i-th n-dimensional unit vector. rzthis unit vector does not existr)ÚzeroÚone)rr"r(rrrÚ unitvectors$(zLinearAlgebraMethods.unitvectorcKsê|j}zm|jd7_|j|fi|¤Ž ¡}|j}| |¡\}}g}td|dƒD]}| ||¡}| |||¡} | |  || ¡¡q)g} t|ƒD]}g} t|ƒD] } |  || |¡qP|  | ¡qH|j| fi|¤Ž} W||_| S||_w)zÅ Calculate the inverse of a matrix. If you want to solve an equation system Ax = b, it's recommended to use solve(A, b) instead, it's about 3 times more efficient. r5r) rArrrr)rrUr/Úappendr4)rr rGrAr"r#rr(Úer2ÚinvÚrowr$ÚresultrrrÚinverse s*    ÿzLinearAlgebraMethods.inversec stˆˆjƒs tdƒ‚ˆj‰ˆj‰ˆˆdkrtdƒ‚g}tdˆdƒD]ƒ‰ˆ ‡‡fdd„tˆˆƒDƒ¡}t|ƒˆj ks@t dƒ‚|  ˆ  ˆ  ˆˆˆf¡¡ ˆ |¡¡ˆj||ˆˆˆˆf}ˆˆˆf|ˆ8<tˆdˆƒD].‰ˆ ‡‡‡‡fdd„tˆˆƒDƒ¡|}tˆˆƒD]‰ˆˆˆfˆˆˆf|8<q’qwq#‡‡fd d „tˆdƒDƒ‰tˆd d d ƒD]'‰ˆˆˆ ‡‡‡fd d„tˆdˆdƒDƒ¡8<ˆˆ|ˆ<q½ˆˆdksý‡‡‡fdd „tˆˆdƒDƒ}ndgˆ}ˆ|ˆ|fS)a (A|b) -> H, p, x, res (A|b) is the coefficient matrix with left hand side of an optionally overdetermined linear equation system. H and p contain all information about the transformation matrices. x is the solution, res the residual. ú A should be a type of ctx.matrixrz$Columns should not be less than rowsrc3s$|] }tˆ|ˆfƒdVqdS©rN)Úabsr=©r r$rrr?Só€"z3LinearAlgebraMethods.householder..rc3s.|]}ˆ ˆ|ˆf¡ˆ|ˆfVqdSr9©Úconjr=©r rr$rrrr?Zó€,csg|] }ˆ|ˆdf‘qS©rrr=)r r"rrr^sz4LinearAlgebraMethods.householder..rr0c3s$|] }ˆˆ|fˆ|VqdSr9r©r r$)r r(r3rrr?`r`cs$g|]}ˆˆd|ˆdf‘qSrerr=)r Úmr"rrrds$)rrÚ TypeErrorrrr+rrr^rrrVÚsignÚreÚsqrtrT)rr r#r&Úkappar2rMr)r rr(r$rrgr"r3rÚ householderAs8   *("ÿþ6 $  z LinearAlgebraMethods.householdercKsl|j}z.|jd9_|j|fi|¤Ž|j|fi|¤Ž|j|fi|¤Ž}}}|||W||_S||_w)zt Calculate the residual of a solution to a linear equation system. r = A*x - b for A*x = b r)rAr)rr r3r.rGÚoldprecrrrrIvs : zLinearAlgebraMethods.residualc KsÌ|dur|j}|j}zW|jd7_|j|fi|¤Ž ¡|j|fi|¤Ž ¡}}|j|jkr3tdƒ‚| | ||¡¡\}}}} | | ¡} | dkrS| |  |||¡¡} |j|fi|¤Ž| fW||_S||_w)aa Ax = b => x, ||Ax - b|| Solve a determined or overdetermined linear equations system and calculate the norm of the residual (error). QR decomposition using Householder factorization is applied, which gives very accurate results even for ill-conditioned matrices. qr_solve is twice as efficient. Nr5r6r) rJrArrrrrrmÚextendrI) rr r.rJrGrArBr#r3rMÚresrrrÚqr_solve„s .  zLinearAlgebraMethods.qr_solvec sJt||jƒs tdƒ‚|j|jkstdƒ‚|dur|j }|j}| |¡‰t|ƒD]z‰| |ˆˆf¡}t ||ˆˆfƒ|krCtdƒ‚||j ‡‡fdd„tˆƒDƒddd}||kr_td ƒ‚|  |¡ˆˆˆf<tˆ|ƒD]4‰‡‡fd d„tˆƒDƒ}‡‡fd d„tˆƒDƒ}|j ||dd }|ˆˆf|ˆˆˆfˆˆˆf<qmq(ˆS) a} Cholesky decomposition of a symmetric positive-definite matrix `A`. Returns a lower triangular matrix `L` such that `A = L \times L^T`. More generally, for a complex Hermitian positive-definite matrix, a Cholesky decomposition satisfying `A = L \times L^H` is returned. The Cholesky decomposition can be used to solve linear equation systems twice as efficiently as LU decomposition, or to test whether `A` is positive-definite. The optional parameter ``tol`` determines the tolerance for verifying positive-definiteness. **Examples** Cholesky decomposition of a positive-definite symmetric matrix:: >>> from mpmath import * >>> mp.dps = 25; mp.pretty = True >>> A = eye(3) + hilbert(3) >>> nprint(A) [ 2.0 0.5 0.333333] [ 0.5 1.33333 0.25] [0.333333 0.25 1.2] >>> L = cholesky(A) >>> nprint(L) [ 1.41421 0.0 0.0] [0.353553 1.09924 0.0] [0.235702 0.15162 1.05899] >>> chop(A - L*L.T) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] Cholesky decomposition of a Hermitian matrix:: >>> A = eye(3) + matrix([[0,0.25j,-0.5j],[-0.25j,0,0],[0.5j,0,0]]) >>> L = cholesky(A) >>> nprint(L) [ 1.0 0.0 0.0] [(0.0 - 0.25j) (0.968246 + 0.0j) 0.0] [ (0.0 + 0.5j) (0.129099 + 0.0j) (0.856349 + 0.0j)] >>> chop(A - L*L.H) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] Attempted Cholesky decomposition of a matrix that is not positive definite:: >>> A = -eye(3) + hilbert(3) >>> L = cholesky(A) Traceback (most recent call last): ... ValueError: matrix is not positive-definite **References** 1. [Wikipedia]_ http://en.wikipedia.org/wiki/Cholesky_decomposition r\rNzmatrix is not Hermitianc3ó|] }ˆˆ|fVqdSr9r©r r©r-r$rrr?êó€z0LinearAlgebraMethods.cholesky..T)ÚabsoluteÚsquaredzmatrix is not positive-definitec3rrr9rrs)r-r(rrr?ðruc3rrr9rrsrtrrr?ñru)Ú conjugate) rrr+rrrrrrjr^rrkÚfdot) rr r!r"Úcr&Úit1Úit2Útr)r-r(r$rÚcholesky s2 >   ÿ&üzLinearAlgebraMethods.choleskyc sð|j}zp|jd7_|j|fi|¤Ž ¡|jˆfi|¤Ž ¡}‰|j|jkr,tdƒ‚| |¡‰ˆj}tˆƒ|kr>tdƒ‚t|ƒD]$‰ˆˆ|  ‡‡‡fdd„tˆƒDƒ¡8<ˆˆˆˆˆf<qB|  ˆj ˆ¡}|W||_S||_w)zø Ax = b => x Solve a symmetric positive-definite linear equation system. This is twice as efficient as lu_solve. Typical use cases: * A.T*A * Hessian matrix * differential equations r5z can only solve determined systemr*c3s$|] }ˆˆ|fˆ|VqdSr9rrf©r-r.r(rrr?r`z6LinearAlgebraMethods.cholesky_solve..) rArrrrrr~r,rrr4ÚT)rr r.rGrAr"r3rrrrEös  .    ,z#LinearAlgebraMethods.cholesky_solvecCs |j}zH| |¡ ¡}z | |¡\}}Wnty"YW||_dSwd}t|ƒD] \}}||kr5|d9}q)t|jƒD] }||||f9}q;|W||_S||_w)z8 Calculate the determinant of a matrix. rrr0)rArrr)rÚ enumeraterr)rr rAÚRr#Úzr(rWrrrÚdets$  ö€zLinearAlgebraMethods.detcs*|dur ‡fdd„}||ƒ|ˆ |¡ƒS)a) Calculate the condition number of a matrix using a specified matrix norm. The condition number estimates the sensitivity of a matrix to errors. Example: small input errors for ill-conditioned coefficient matrices alter the solution of the system dramatically. For ill-conditioned matrices it's recommended to use qr_solve() instead of lu_solve(). This does not help with input errors however, it just avoids to add additional errors. Definition: cond(A) = ||A|| * ||A**-1|| Ncs ˆ |d¡S)Nr)r)r3r>rrÚ=s z+LinearAlgebraMethods.cond..)r[)rr rJrr>rÚcond.s zLinearAlgebraMethods.condcCsX| |j|j¡}t|jƒD]}| || |¡¡}tt|ƒƒD] }|||||f<qq |S)z,Solve a * x = b where a and b are matrices.)rrrÚrangerFÚcolumnr,)rÚar.rMr(rzr$rrrÚ lu_solve_mat@sÿz!LinearAlgebraMethods.lu_solve_matÚfullr5c shtˆˆjƒsJ‚ˆj}ˆj}|dksJ‚||ksJ‚|dks J‚t‡fdd„ˆDƒƒ}ˆ |¡øˆ |d¡}ˆ ¡‰|r;ˆ dd¡}ˆ dd¡} ˆ d¡} t d|ƒD]䉈ˆˆf} ˆ  | ¡} ˆ  | ¡} |ˆdkr‰ˆ  ‡‡‡fdd„t ˆd|ƒDƒ¡}ˆ  ˆ  |¡¡}n| }|| kr˜| | kr˜| |ˆ<qU| | kr¬ˆ  | d| d|d¡}nˆ  | d| d|d¡ }ˆ || || |¡|ˆ<ˆ |ˆ¡ }|| |}t ˆd|ƒD] }ˆ|ˆf|9<qà|ˆˆˆf<t ˆd|ƒD]4‰ˆ  ‡‡‡‡fd d„t ˆ|ƒDƒ¡}|ˆ |¡}t ˆ|ƒD]}ˆ|ˆfˆ|ˆf|7<qqúˆ |d¡ˆˆˆf<qUnሠd¡}ˆ d¡} t d|ƒD]щˆˆˆf} |ˆdkrqˆ  ‡‡fd d„t ˆd|ƒDƒ¡}ˆ  |¡}n|ˆdkrƒtˆ|dˆfƒ}n| }|| kr| |ˆ<qJ| | kr¡ˆ  | d|d¡}n ˆ  | d|d¡ }|| ||ˆ<|ˆ }|| |}t ˆd|ƒD] }ˆ|ˆf|9<qÇ|ˆˆˆf<t ˆd|ƒD]1‰ˆ  ‡‡‡fd d„t ˆ|ƒDƒ¡}||}t ˆ|ƒD]}ˆ|ˆfˆ|ˆf|7<qþqâ|ˆˆˆf<qJ|d ks&|d kr1ˆ|fWdƒSˆ ¡}t d|ƒD]‰t ˆd|ƒD] }| ||ˆf<qCq:|}|dks[|dkr]|}ˆj||7_t d|ƒD]‰|ˆˆˆf<t dˆƒD] }| ˆ|ˆf<qxqkt |dddƒD]‰‰|ˆ }ˆˆˆf|7<t ˆd|ƒD]Z‰|rň  ‡‡‡‡fdd„t ˆd|ƒDƒ¡}|ˆ |¡}nˆ  ‡‡‡fdd„t ˆd|ƒDƒ¡}||}|ˆˆˆf<t ˆd|ƒD]}ˆ|ˆfˆ|ˆf|7<qéq¤t ˆd|ƒD] }ˆ|ˆf|9<qqŒˆ|d|…d|…ffWdƒS1s-wYdS)al Compute a QR factorization $A = QR$ where A is an m x n matrix of real or complex numbers where m >= n mode has following meanings: (1) mode = 'raw' returns two matrixes (A, tau) in the internal format used by LAPACK (2) mode = 'skinny' returns the leading n columns of Q and n rows of R (3) Any other value returns the leading m columns of Q and m rows of R edps is the increase in mp precision used for calculations **Examples** >>> from mpmath import * >>> mp.dps = 15 >>> mp.pretty = True >>> A = matrix([[1, 2], [3, 4], [1, 1]]) >>> Q, R = qr(A) >>> Q [-0.301511344577764 0.861640436855329 0.408248290463863] [-0.904534033733291 -0.123091490979333 -0.408248290463863] [-0.301511344577764 -0.492365963917331 0.816496580927726] >>> R [-3.3166247903554 -4.52267016866645] [ 0.0 0.738548945875996] [ 0.0 0.0] >>> Q * R [1.0 2.0] [3.0 4.0] [1.0 1.0] >>> chop(Q.T * Q) [1.0 0.0 0.0] [0.0 1.0 0.0] [0.0 0.0 1.0] >>> B = matrix([[1+0j, 2-3j], [3+j, 4+5j]]) >>> Q, R = qr(B) >>> nprint(Q) [ (-0.301511 + 0.0j) (0.0695795 - 0.95092j)] [(-0.904534 - 0.301511j) (-0.115966 + 0.278318j)] >>> nprint(R) [(-3.31662 + 0.0j) (-5.72872 - 2.41209j)] [ 0.0 (3.91965 + 0.0j)] >>> Q * R [(1.0 + 0.0j) (2.0 - 3.0j)] [(3.0 + 1.0j) (4.0 + 5.0j)] >>> chop(Q.T * Q.conjugate()) [1.0 0.0] [0.0 1.0] rc3r8r9r:)r r3r>rrr?‰r@z*LinearAlgebraMethods.qr..rz1.0z0.0rc3s.|]}ˆ|ˆfˆ ˆ|ˆf¡VqdSr9rar=)r rr$rrr?Ÿrdc3ó.|]}ˆ|ˆfˆ ˆ|ˆf¡VqdSr9rar=rcrrr?¶rdc3s |] }ˆ|ˆfdVqdSr]rr=r_rrr?Ås€c3ó(|]}ˆ|ˆfˆ|ˆfVqdSr9rr=©r r$rrrr?Þó€&ÚrawÚRAWNÚskinnyÚSKINNYr0c3rŒr9rar=rcrrr?rdc3rr9rr=rŽrrr? r)rrrrÚanyÚextradpsrr<ÚmpfrrjÚimrrkrbr^)rr ÚmodeÚedpsrgr"ÚcmplxÚtaurTrSÚrzeroÚalphaÚalphrÚalphiÚxnormÚbetar}Úzar(r2ÚtempÚdar‚r#rrcrÚqrIsÖ8           &    $$ÿÞ $  $      "$ÿ¥bÿ ÿ (& $ÿÿ&ùzLinearAlgebraMethods.qr)FTr9re)r‹r5)Ú__name__Ú __module__Ú __qualname__r)r/r4rFrOrRrUr[rmrIrqr~rEr„r†rŠr¥rrrrrls$  - ) !5  V!  rN)Ú__doc__rÚ libmp.backendrÚobjectrrrrrÚs g