JtjNi>dZddlmZddlmZGddeZdS)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)xrangeceZdZddZddZdZdZdd Zd Zd Z d Z d Z dZ ddZ ddZdZdZddZdZddZdS)LinearAlgebraMethodsFTc  jjkstd|r#tjrjrjS|s}dj z}j}dg|dz z}t|dz D]Y}d} t||D]  fdt||D} | |krtdd| z  |fz} | | kr| } ||< |||||f|krtdt|dz|D]W} | |fxx||fzcc<t|dz|D]' | fxx| |f| fzzcc<(X[|dz |dz f|krtd|st|jr |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 matrixNrcJg|]}|f S)absmin).0lActxks T/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/mpmath/matrices/linalg.py z2LinearAlgebraMethods.LU_decomp..s-GGGQcjj1Q300GGGmatrix is numerically singular)rowscols ValueError isinstancematrix_LUrr mnormepsrfsumZeroDivisionErrorswap_row)rr overwrite use_cacheorigtolnpjbiggestscurrentirs`` @r LU_decompzLinearAlgebraMethods.LU_decompnsv.// /  Asz22 qu 5L DAjj1Q#'122 F FAENA , ,AGAq\\  HHGGGGGG&A,,GGGHH::a==C''+,LMMMA# 1QqS6 2 22W$$%GAaD LLAqt $ $ $zz!AaC&!!S(('(HIIIAE1%% , ,!A#!AaC& Aq)),,AacFFFa!fQqsVm+FFFF, , ::aAa!e n % % , ,#$DEE E Zcj99 1vDH!t rNc|j|jkrtd|j}t||krt dt |}|r=t dt|D]}||||| t d|D]5}t |D]#}||xx|||f||zzcc<$6|S)zG Solve the lower part of a LU factorized matrix for y. r Value should be equal to nrr )rr RuntimeErrorlenrrrr!)rLbr'r&rr,r(s rL_solvezLinearAlgebraMethods.L_solves 6QV  011 1 F q66Q;;9:: : GG  )As1vv&& ) ) Q1Q4((((1 & &AAYY & &!!A#1 % &rc|j|jkrtd|j}t||krt dt |}t |dz ddD]Q}t |dz|D]#}||xx|||f||zzcc<$||xx|||fzcc<R|S)zG Solve the upper part of a LU factorized matrix for x. r r/r )rrr0r1rrr)rUyr&xr,r(s rU_solvezLinearAlgebraMethods.U_solves 6QV  011 1 F q66Q;;9:: : GGAr2&&  AAE1%% & &!!A#1 % aDDDAacFNDDDDrc j} xjdz c_j|fi|j|fi|}}|j|jkrt d|j|jkrp|j}||z}||z}|ddstfd|Ds ||}n\ ||}nE |\}} |||} ||}|_n #|_wxYw|S)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 systemrealFc3DK|]}t|juVdSNtypempc)rr,rs r z0LinearAlgebraMethods.lu_solve..s0::1DGGsw.::::::r)precrrrrrHgetsumcholesky_solvelu_solver-r4r:)rrr3kwargsrEAHr9r's` rrJzLinearAlgebraMethods.lu_solvesrx  HHNHH3:a**6**//11:3:a3J3J63J3J3O3O3Q3QqAv !FGGGvSFFJJvu--+:::::::::+**1a00AA Q**AA}}Q''1KK1a((KK1%%CHHtCHOOOOs D4E Er c|j|jkrtdt|D]Y}||||}||dd|jzkrn||| }||z }Z|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. r rr<)rrr0rresidualnormrrJ)rrr9r3maxsteps_rdxs rimprove_solutionz%LinearAlgebraMethods.improve_solutions 6QV  011 1!!  A Q1%%Axx1~~37 **a!$$B GAArc ||\}}|j}||}||}t|D]V}t|D]D}||kr|||f|||f<||krd|||f<|||f|||f<5|||f|||f<EW||}tt |D]} ||| ||  |||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-rrreyer1r!) rrr'r&r2r7r,r(Prs rluzLinearAlgebraMethods.lus%}}Q1 F JJqMM JJqMM $ $AAYY $ $q55qsVAacFF!VVAacFqsVAacFFqsVAacFF $ GGAJJA % %A LLAqt $ $ $ $!Qwrcd|cxkr|ks nJd|jg|dz z|jgz|jg||z zzS)z< Return the i-th n-dimensional unit vector. rzthis unit vector does not existr )zeroone)rr&r,s r unitvectorzLinearAlgebraMethods.unitvectorsT1zzzzzzzzz>>rc |j} |xjdz c_|j|fi|}|j}||\}}g}t d|dzD]X}|||}||||} || || Yg} t |D]L}g} t |D]#} | || |$| | M|j| fi|} ||_n #||_wxYw| S)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. r<r ) rErrrr-rr\r4appendr:)rrrKrEr&r'rr,er8invrowr(results rinversezLinearAlgebraMethods.inverse sex  HHNHH 1'''',,..AA==##DAqDAq1u%% / /NN1a((KK1a(( CKK1--....CAYY  ++AJJtAwqz**** 3SZ..v..FCHHtCHOOOO s D)D:: Ec 2 tjstdj j dz krt dg}t d dz D]efdt  D}t|j kstd| f |zj||fzz z }fxx|zcc<t dz D]g  fdt  D|z}t  D] fxxf|zzcc< hg fdt dz D t d z d d D]] xx fd t dz dz Dzcc< xx|zcc<^ dz ks$ fd t z dzD}ndg z}| |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.matrixr z$Columns should not be less than rowsrc3LK|]}t|fdzVdSrN)absrr,rr(s rrDz3LinearAlgebraMethods.householder..Ss5>>AQqsVa>>>>>>rrc3hK|],}|f|fzV-dSr@conjrr,rrr(rs rrDz3LinearAlgebraMethods.householder..ZsDMM1SXXa!f--!A#6MMMMMMrc*g|]}|dz fSr r )rr,rr&s rrz4LinearAlgebraMethods.householder..^s% / / /AQqQwZ / / /rrr6c3>K|]}|f|zVdSr@r )rr(rr,r9s rrDz3LinearAlgebraMethods.householder..`s3IIqQqsVad]IIIIIIrc6g|]}dz |z dz fSror )rr,rmr&s rrz4LinearAlgebraMethods.householder..ds-:::11Q3q5!A#::::r)rr TypeErrorrrr0rrrhrrr^signresqrtr[) rrr'r*kappar8rRr,r(rrrr&r9s `` @@@@@@r householderz LinearAlgebraMethods.householderAs!SZ(( @>?? ? F F q1u99EFF F 1q5!! ) )A>>>>>1>>>>>Aq66CG## !ABBB HHchhsvva!f~~...!< = = =Gq1Q4!AaC&=01E acFFFadNFFFAaC^^ ) )HHMMMMMMMq! MMMMMPUU1))AacFFFa!fqj(FFFF) ) 0 / / / /A / / /Ar2&&  A aDDDCHHIIIIIIF1q5!a%4H4HIIIII IDDD aDDDAaDLDDDDAEzz::::::q1uqy(9(9:::AAAA!Qzrc |j} |xjdzc_|j|fi||j|fi||j|fi|}}}||z|z ||_S#||_wxYw)zt Calculate the residual of a solution to a linear equation system. r = A*x - b for A*x = b r)rEr)rrr9r3rKoldprecs rrNzLinearAlgebraMethods.residualvs (  HHMHH cj--f--zsz!/F/Fv/F/F  STH_H_X^H_H_!qAQ37CHHwCH    s AA Ac .||j}|j} |xjdz c_|j|fi||j|fi|}}|j|jkrt d||||\}}}} || } | dkr*|| |||} |j|fi|| f||_S#||_wxYw)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. Nr<r=r) rOrErrrrrrxextendrN) rrr3rOrKrErFr'r9rRress rqr_solvezLinearAlgebraMethods.qr_solves$ <8Dx  HHNHH3:a**6**//11:3:a3J3J63J3J3O3O3Q3QqAv !FGGGAq)9)9::JAq!Q((1++Caxxhhs||Aq!44553:a**6**C/CHHtCHOOOOs C1D Dcb t||jstd|j|jkst d||j }|j}|| t|D]1 || f}t|| fz |krt d|| fdt Dddz }||krt d| | f<t |D]o fd t D} fd t D}| ||d }| f|z fz f<p3 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 rer Nzmatrix is not Hermitianc3,K|]}|fVdSr@r rrr2r(s rrDz0LinearAlgebraMethods.cholesky..s+88a!f888888rT)absolutesquaredzmatrix is not positive-definitec3,K|]}|fVdSr@r )rrr2r,s rrDz0LinearAlgebraMethods.cholesky..+11!q1v111111rc3,K|]}|fVdSr@r rs rrDz0LinearAlgebraMethods.cholesky..rr) conjugate) rrr0rrrrrrurhrrvfdot) rrr%r&cr*it1it2tr2r,r(s @@@rcholeskyzLinearAlgebraMethods.choleskys|!SZ(( CABB Bv.// / ;7(C F JJqMM / /Aq1vA1QqsV8}}s"" !:;;;CHH88888fQii888t---A3ww !BCCCXXa[[AacFAq\\ / /11111vayy11111111vayy111HHS#H66AaC&1*!A#.!A#  / rc |j} |xjdz c_|j|fi||jfi|c}|j|jkrt d||j}t|krt dt|D]Xxx| fdtDzcc<xxfzcc<Y| j }|||_S#||_wxYw)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 r<z can only solve determined systemr/c3>K|]}|f|zVdSr@r )rr(r2r3r,s rrDz6LinearAlgebraMethods.cholesky_solve..s3 B B11Q3!A$ B B B B B Br) rErrrrrrr1rrr:T) rrr3rKrEr&r9r2r,s ` @@rrIz#LinearAlgebraMethods.cholesky_solvesfx  HHNHH3:a**6**//11:3:a3J3J63J3J3O3O3Q3QDAqv!&   !CDDD QAA1vv{{ !=>>>AYY  ! B B B B B Bq B B BBBB!!A# AC##ACHHtCHOOOOs D2E Ecz|j} ||} ||\}}n#t$r Y||_dSwxYwd}t |D]\}}||kr|dz}t |jD]}||||fz}|||_S#||_wxYw)z8 Calculate the determinant of a matrix. rr r6)rErrr-r enumeraterr)rrrERr'zr,r_s rdetzLinearAlgebraMethods.detsx  1 ""$$A }}Q''11$   CHHH A!!   166GAAF^^  QqsV CHHtCHOOOOs/'B1A B1 AB1AA B11 B:cf|fd}||||zS)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|| Nc0|dS)Nr )r)r9rs rz+LinearAlgebraMethods.cond..=sSYYq^^r)rc)rrrOs` rcondzLinearAlgebraMethods.cond.s? <++++DtAwwckk!nn----rc||j|j}t|jD]W}||||}tt |D]}|||||f<X|S)z,Solve a * x = b where a and b are matrices.)rrrrangerJcolumnr1)rar3rRr,rr(s r lu_solve_matz!LinearAlgebraMethods.lu_solve_mat@s JJqvqv & &qv  A Q ,,A3q66]]  A$!Q$ rfullr<c tjsJj}j}|dksJ||ksJ|dksJt fdD}|5|d}|rwdd}dd} d} td|D]"f} | } | } |z dkr] fdtdz|D} |}n| }|| kr | | kr| |<| | kr% | dz| dzz|dzz}n% | dz| dzz|dzz }|| z |z | |z |<| }|| |z z }tdz|D]}|fxx|zcc<|f<tdz|D]| fdt|D}||z}t|D]}|fxx|f|zz cc< }|df<$n߉d}d} td|D]f} |z dkrI fd tdz|D} |}n&|z dkrt|dz f}n| }|| kr| |<| | kr | dz|dzz}n | dz|dzz }|| z |z |<| }|| |z z }tdz|D]}|fxx|zcc<|f<tdz|D]h fd t|D}||z}t|D]}|fxx|f|zz cc< i|f<|d ks|d kr|fcd d d S}td|D]tdz|D] }| ||f< |}|dks|dkr|}xj||z z c_td|D]#|f<tdD] }| |f< $t|dz ddD]| }fxx|z cc<tdz|D]Ŋ|rN fdtdz|D}||z}n9 fdtdz|D}||z}|f<tdz|D]}|fxx|f|zz cc< tdz|D]}|fxx|zcc<!|d|d|ffcd d d S#1swxYwYd S)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] rc3DK|]}t|juVdSr@rA)rr9rs rrDz*LinearAlgebraMethods.qr..s0221DGGsw&222222rr z1.0z0.0rc3hK|],}|f|fzV-dSr@rk)rr,rrr(s rrDz*LinearAlgebraMethods.qr..sD([([a!AaC&!AaC&1A1A*A([([([([([([rc3hK|],}|f|fzV-dSr@rkrms rrDz*LinearAlgebraMethods.qr..sD$U$U1QqsVchhq1v.>.>%>$U$U$U$U$U$Urc32K|]}|fdzVdSrgr ris rrDz*LinearAlgebraMethods.qr..s/(O(O!1QqS6A+(O(O(O(O(O(Orc3BK|]}|f|fzVdSr@r rr,rr(rs rrDz*LinearAlgebraMethods.qr..s7$M$M!a!fq1vo$M$M$M$M$M$MrrawRAWNskinnySKINNYr6c3hK|],}|f|fzV-dSr@rkrms rrDz*LinearAlgebraMethods.qr..sD$W$W1QqsVchhq1v.>.>%>$W$W$W$W$W$Wrc3BK|]}|f|fzVdSr@r rs rrDz*LinearAlgebraMethods.qr.. s7$M$MQqsVa!f_$M$M$M$M$M$Mr)rrrranyextradpsrrCmpfrruimrrvrlrh)rrmodeedpsrrr&cmplxtaur[rZrzeroalphaalphralphixnormbetarzar,r8tempdarr'r(rs`` @@rqrzLinearAlgebraMethods.qrIsp!SZ((((( F FAvvvvAvvvvqyyyy222222222\\$  F !F !**Qq//CA P "ggeU++wwue,, 1"2"2AacFEFF5MMEFF5MME!zz #([([([([([([6RSTURUWX>>([([([ [ [ # 9 9 %Ue^^!%A u}}"xxq5!8(;eQh(FGG #E1H)G[>>\\)FTr@ro)rr<)__name__ __module__ __qualname__r-r4r:rJrTrXr\rcrxrNr~rrIrrrrr rrrrlsG++++Z& '''R$@???B'''j   8TTTTlB.....$I!I!I!I!I!I!rrN)__doc__r libmp.backendrobjectrr rrrsv``N""""""f !f !f !f !f !6f !f !f !f !f !r