(phjZSrSSKrSSKJr SSKJr SSKJr SSK J r SSK J r SS K J r SS KJr S rS rS rSrSrSSjrSrSrSSjrSSjrg)a[Revised simplex method for linear programming The *revised simplex* method uses the method described in [1]_, except that a factorization [2]_ of the basis matrix, rather than its inverse, is efficiently maintained and used to solve the linear systems at each iteration of the algorithm. .. versionadded:: 1.3.0 References ---------- .. [1] Bertsimas, Dimitris, and J. Tsitsiklis. "Introduction to linear programming." Athena Scientific 1 (1997): 997. .. [2] Bartels, Richard H. "A stabilization of the simplex method." Journal in Numerische Mathematik 16.5 (1971): 414-434. N) LinAlgError)solve)_check_unknown_options)LU)BGLU) _postsolve)OptimizeResultc PURupSn [XX&5uppnn U S:XaURU5nSnUXUUU U4$U nSn[XUXUXVUXU UU5unpnURU5nU S:XaUU:aSn [R "U [ S9nXU :HnUSS2U4n[R"[UU55n[R"USS2U45n[R "U [ S9nSUXU :'[R"U5Sn[R"USS2SU 24UU45nUUnUUU4U:aSUU'MUXU:H'M UUSU 24nUUnUSU nURSn UXUUU U4$![a Sn GMf=f)aS The purpose of phase one is to find an initial basic feasible solution (BFS) to the original problem. Generates an auxiliary problem with a trivial BFS and an objective that minimizes infeasibility of the original problem. Solves the auxiliary problem using the main simplex routine (phase two). This either yields a BFS to the original problem or determines that the original problem is infeasible. If feasible, phase one detects redundant rows in the original constraint matrix and removes them, then chooses additional indices as necessary to complete a basis/BFS for the original problem. rdtypeNF) shape_generate_auxiliary_problemdot _phase_twonponesboolabsrargmaxwherer)Abx0callbackpostsolve_argsmaxitertoldisp maxupdatemastpivotmnstatuscbasisxresidualiter_k phase_one_n keep_rows basis_columnB basis_finder pertinent_roweligible_columnseligible_column_indicesindexnew_basis_columns M/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_linprog_rs.py _phase_oner9s 77DA F!>@AE6u= M+;;>5), --cSnURupVUbUnO[R"U5nXU-- nXS:*XS:'XS:*XS:'XS:==S-ss'Uc[R"U5n O[R"X:5Sn [R"[R "U5U:5Sn [ U 5S:Xa5[ U 5U::a&[R"U5n [X 5n XXXt4$[ U 5U[ U 5- :d[R"US:5(a[R"U5n SnXXXt4$[X5up[R"X5n[R"[R"X55n[R"X5nU Un U Un U [R"[R"X55n[ U5nU[R"U5-n[R"U U45n[R"U U45n[R"U[R"UU4545nSUUU4'[R"U[R"U545nUUUUU4- UU'[R"UU-5n SU U'[R"U U45n [X 5n XXXt4$)aI Modifies original problem to create an auxiliary problem with a trivial initial basic feasible solution and an objective that minimizes infeasibility in the original problem. Conceptually, this is done by stacking an identity matrix on the right of the original constraint matrix, adding artificial variables to correspond with each of these new columns, and generating a cost vector that is all zeros except for ones corresponding with each of the new variables. A initial basic feasible solution is trivial: all variables are zero except for the artificial variables, which are set equal to the corresponding element of the right hand side `b`. Running the simplex method on this auxiliary problem drives all of the artificial variables - and thus the cost - to zero if the original problem is feasible. The original problem is declared infeasible otherwise. Much of the complexity below is to improve efficiency by using singleton columns in the original problem where possible, thus generating artificial variables only as necessary, and using an initial 'guess' basic feasible solution. rr r)rrr<r;rrr=rLany_select_singleton_columnsisin logical_not logical_andrEhstack)rrrr!r(r&r'r+rnonzero_constraintsr*r)colsrowsi_tofix i_notinbasisi_fix_without_auxarowsn_auxacolsbasis_ng basis_ng_rowss r8rrs0F 77DA ~  HHQK aCAa%yA!eHa%yA!eH!eHNH  z iil hhqw/2 HHRVVAY_ %a (E 1$Uq HHQK'1Qq(( ! "QU^ 3 &&Q-- HHQKQq((+10JDggd0G>>"''$"67Lw= ! "D ! "D  "(; B!D EE JE  % E~~tUm,HNND%=1M 1bhh5z*+,AAeUlO 288E?+,AM"1]H%<#==AhK AAeH NNE8, -E #A -E 1 $$rMc[R"[R"[R"U5S:gSS9S:H5SnUSS2U4n[R"[ U5[ S9n[R"U5upVXTU'XU4X-S:nX'SSS2nXGSSS2n[R"USS9upX)U4$) aD Finds singleton columns for which the singleton entry is of the same sign as the right-hand side; these columns are eligible for inclusion in an initial basis. Determines the rows in which the singleton entries are located. For each of these rows, returns the indices of the one singleton column and its corresponding row. raxisrNrrOT) return_index)rnonzerosumrr<r=intunique) rrcolumn_indicescolumns row_indices nonzero_rowsnonzero_columns same_signunique_row_indices first_columnss r8rQrQsZZrvvayA~A >! CDQGN>!"G((3~.c:K$&JJw$7!L#/ ~-.q~=BI#.tt4N(2.K)+ +?C)E%  (*< < U S- n SnU(dUb[ XUUXU5 X#UU 4$![a Sn Mf=f) aO The heart of the simplex method. Beginning with a basic feasible solution, moves to adjacent basic feasible solutions successively lower reduced cost. Terminates when there are no basic feasible solutions with lower reduced cost or if the problem is determined to be unbounded. This implementation follows the revised simplex method based on LU decomposition. Rather than maintaining a tableau or an inverse of the basis matrix, we keep a factorization of the basis matrix that allows efficient solution of linear systems while avoiding stability issues associated with inverted matrices. rNrrT) transposedr)ryr!)rrr;rrrBrr<r=rrrrallrzrPrwupdater)r)rr+rrrr r!r"r#r$r%rr.r&r'r(rFabr1rGxbcbvrxjurJthlth_stars r8rrNs 77DA F ! A 1B y ' qH9. 8' !+.&"+8 =XXc!fD )1 T T t,A AEE!H rc  66%C4-  r15 B GGAadG  GvvayyF  U1Q4Z IIbMQ%tgai! Aq1 CCY/d Q  8' !+.&"+8 =  ""U F  s4G  GGc  ,[U 5 /SQnURS:Xa'[R"UR5SUSS4$[ X#XEUXxXX5 unnp#nnnUS:Xa[ XUUUUXxU XU U5 unnnnUUUURUU5U4$)a Solve the following linear programming problem via a two-phase revised simplex algorithm.:: minimize: c @ x subject to: A @ x == b 0 <= x < oo User-facing documentation is in _linprog_doc.py. Parameters ---------- c : 1-D array Coefficients of the linear objective function to be minimized. c0 : float Constant term in objective function due to fixed (and eliminated) variables. (Currently unused.) A : 2-D array 2-D array which, when matrix-multiplied by ``x``, gives the values of the equality constraints at ``x``. b : 1-D array 1-D array of values representing the RHS of each equality constraint (row) in ``A_eq``. x0 : 1-D array, optional Starting values of the independent variables, which will be refined by the optimization algorithm. For the revised simplex method, these must correspond with a basic feasible solution. callback : callable, optional If a callback function is provided, it will be called within each iteration of the algorithm. The callback function must accept a single `scipy.optimize.OptimizeResult` consisting of the following fields: x : 1-D array Current solution vector. fun : float Current value of the objective function ``c @ x``. success : bool True only when an algorithm has completed successfully, so this is always False as the callback function is called only while the algorithm is still iterating. slack : 1-D array The values of the slack variables. Each slack variable corresponds to an inequality constraint. If the slack is zero, the corresponding constraint is active. con : 1-D array The (nominally zero) residuals of the equality constraints, that is, ``b - A_eq @ x``. phase : int The phase of the algorithm being executed. status : int For revised simplex, this is always 0 because if a different status is detected, the algorithm terminates. nit : int The number of iterations performed. message : str A string descriptor of the exit status of the optimization. postsolve_args : tuple Data needed by _postsolve to convert the solution to the standard-form problem into the solution to the original problem. Options ------- maxiter : int The maximum number of iterations to perform in either phase. tol : float The tolerance which determines when a solution is "close enough" to zero in Phase 1 to be considered a basic feasible solution or close enough to positive to serve as an optimal solution. disp : bool Set to ``True`` if indicators of optimization status are to be printed to the console each iteration. maxupdate : int The maximum number of updates performed on the LU factorization. After this many updates is reached, the basis matrix is factorized from scratch. mast : bool Minimize Amortized Solve Time. If enabled, the average time to solve a linear system using the basis factorization is measured. Typically, the average solve time will decrease with each successive solve after initial factorization, as factorization takes much more time than the solve operation (and updates). Eventually, however, the updated factorization becomes sufficiently complex that the average solve time begins to increase. When this is detected, the basis is refactorized from scratch. Enable this option to maximize speed at the risk of nondeterministic behavior. Ignored if ``maxupdate`` is 0. pivot : "mrc" or "bland" Pivot rule: Minimum Reduced Cost (default) or Bland's rule. Choose Bland's rule if iteration limit is reached and cycling is suspected. unknown_options : dict Optional arguments not used by this particular solver. If `unknown_options` is non-empty a warning is issued listing all unused options. Returns ------- x : 1-D array Solution vector. status : int An integer representing the exit status of the optimization:: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Numerical difficulties encountered 5 : No constraints; turn presolve on 6 : Guess x0 cannot be converted to a basic feasible solution message : str A string descriptor of the exit status of the optimization. iteration : int The number of iterations taken to solve the problem. )z%Optimization terminated successfully.zIteration limit reached.aSThe problem appears infeasible, as the phase one auxiliary problem terminated successfully with a residual of {0:.1e}, greater than the tolerance {1} required for the solution to be considered feasible. Consider increasing the tolerance to be greater than {0:.1e}. If this tolerance is unacceptably large, the problem is likely infeasible.zThe problem is unbounded, as the simplex algorithm found a basic feasible solution from which there is a direction with negative reduced cost in which all decision variables increase.zLNumerical difficulties encountered; consider trying method='interior-point'.zKProblems with no constraints are trivially solved; please turn presolve on.z?The guess x0 cannot be converted to a basic feasible solution. r)rr>rr<rr9rr)r)c0rrrrrr r!r"r#r$r%unknown_optionsmessagesr+r*r,r(rs r8 _linprog_rsrsn?+H( vv{xx !Xa[!33 1~$ ?0AuaHfi{&0q%1?18t1:%1: '<#5&) fhv&--hrsp&$-%%%C4L .Fd%N=@+'I,9.AEP#h/405[HrM