(phOSrSSKrSSKJr SSKJr SSKJ r SSK J r J r J r Jr SSKJr \"SS 5rS \R$lS \lS rSS jrSrSrSSjrSrSrSrSrSrSrSSjrSr g)z: Method agnostic utility functions for linear programming N)warn)OptimizeWarning)_remove_redundancy_svd_remove_redundancy_pivot_sparse_remove_redundancy_pivot_dense_remove_redundancy_id) namedtuple _LPProblemz+c A_ub b_ub A_eq b_eq bounds x0 integrality)NNNNNNNa Represents a linear-programming problem. Attributes ---------- c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : various valid formats, optional The bounds of ``x``, as ``min`` and ``max`` pairs. If bounds are specified for all N variables separately, valid formats are: * a 2D array (N x 2); * a sequence of N sequences, each with 2 values. If all variables have the same bounds, the bounds can be specified as a 1-D or 2-D array or sequence with 2 scalar values. If all variables have a lower bound of 0 and no upper bound, the bounds parameter can be omitted (or given as None). Absent lower and/or upper bounds can be specified as -numpy.inf (no lower bound), numpy.inf (no upper bound) or None (both). x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. integrality : 1-D array or int, optional Indicates the type of integrality constraint on each decision variable. ``0`` : Continuous variable; no integrality constraint. ``1`` : Integer variable; decision variable must be an integer within `bounds`. ``2`` : Semi-continuous variable; decision variable must be within `bounds` or take value ``0``. ``3`` : Semi-integer variable; decision variable must be an integer within `bounds` or take value ``0``. By default, all variables are continuous. For mixed integrality constraints, supply an array of shape `c.shape`. To infer a constraint on each decision variable from shorter inputs, the argument will be broadcast to `c.shape` using `np.broadcast_to`. This argument is currently used only by the ``'highs'`` method and ignored otherwise. Notes ----- This namedtuple supports 2 ways of initialization: >>> lp1 = _LPProblem(c=[-1, 4], A_ub=[[-3, 1], [1, 2]], b_ub=[6, 4]) >>> lp2 = _LPProblem([-1, 4], [[-3, 1], [1, 2]], [6, 4]) Note that only ``c`` is a required argument here, whereas all other arguments ``A_ub``, ``b_ub``, ``A_eq``, ``b_eq``, ``bounds``, ``x0`` are optional with default values of None. For example, ``A_eq`` and ``b_eq`` can be set without ``A_ub`` or ``b_ub``: >>> lp3 = _LPProblem(c=[-1, 4], A_eq=[[2, 1]], b_eq=[10]) cURSS5nU(aUb[R"U5nU(aUb[R"U5n[R"U5=(d [R"U5n1SknSS1nX;aU(a[ SUSUS35eUR S S5nU(d!U(aUS :XaS US '[ S [S S9 XU4$)ay Check the provided ``A_ub`` and ``A_eq`` matrices conform to the specified optional sparsity variables. Parameters ---------- A_ub : 2-D array, optional 2-D array such that ``A_ub @ x`` gives the values of the upper-bound inequality constraints at ``x``. A_eq : 2-D array, optional 2-D array such that ``A_eq @ x`` gives the values of the equality constraints at ``x``. options : dict A dictionary of solver options. All methods accept the following generic options: maxiter : int Maximum number of iterations to perform. disp : bool Set to True to print convergence messages. For method-specific options, see :func:`show_options('linprog')`. method : str, optional The algorithm used to solve the standard form problem. Returns ------- A_ub : 2-D array, optional 2-D array such that ``A_ub @ x`` gives the values of the upper-bound inequality constraints at ``x``. A_eq : 2-D array, optional 2-D array such that ``A_eq @ x`` gives the values of the equality constraints at ``x``. options : dict A dictionary of solver options. All methods accept the following generic options: maxiter : int Maximum number of iterations to perform. disp : bool Set to True to print convergence messages. For method-specific options, see :func:`show_options('linprog')`. _sparse_presolveF>highshighs-ds highs-ipmsimplexzrevised simplexzMethod 'zL' does not support sparse constraint matrices. Please consider using one of .sparsezinterior-pointTz9Sparse constraint matrix detected; setting 'sparse':True. stacklevel)popsps coo_matrixissparse ValueErrorgetrr) optionsmethA_ubA_eqr sparse_constraintpreferred_methods dense_methodsrs O/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_linprog_util.py_check_sparse_inputsr%[s\{{#5u=D,~~d#D,~~d# T*@cll4.@: 12M !28D6*N-.a12 2[[5 )F 'D4D,D  H  , $ cU(a![R"UcSU4OU[SS9$Uc[R"SU4[S9$[R "U[SS9$)a5Format the left hand side of the constraints to a 2-D array Parameters ---------- A : 2-D array 2-D array such that ``A @ x`` gives the values of the upper-bound (in)equality constraints at ``x``. n_x : int The number of variables in the linear programming problem. sparse_lhs : bool Whether either of `A_ub` or `A_eq` are sparse. If true return a coo_matrix instead of a numpy array. Returns ------- np.ndarray or sparse.coo_matrix 2-D array such that ``A @ x`` gives the values of the upper-bound (in)equality constraints at ``x``. rTdtypecopyr))rrfloatnpzerosarray)An_x sparse_lhss r$_format_A_constraintsr3sX*~~ QHqD   xxC..xxT22r&cUc[R"/[S9$[R"U[SS9R5nURS:waU$UR S5$)aPFormat the upper bounds of the constraints to a 1-D array Parameters ---------- b : 1-D array 1-D array of values representing the upper-bound of each (in)equality constraint (row) in ``A``. Returns ------- 1-D np.array 1-D array of values representing the upper-bound of each (in)equality constraint (row) in ``A``. r+Tr(r)r-r/r,squeezesizereshape)bs r$_format_b_constraintsr:sR  yxx%(( %d+335A! 1.2.r&c Uupp4pVpxUc[e[R"U[RSS9R 5nUR S:XaUR S5n[U5n U S:Xd[UR5S:wa [S5e[R"U5R5(d [S5e[R"U5=(d [R"U5n [X)U S 9nURSn [UR5S :wdURSU :wa [S 5e[R"U5(a3[R"UR5R5(aD[R"U5(d4[R"U5R5(d [S 5e[!U5nURU 4:wa [S5e[R"U5R5(d [S5e[XIU S 9nURSn [UR5S :wdURSU :wa [S5e[R"U5(a3[R"UR5R5(aD[R"U5(d4[R"U5R5(d [S5e[!U5nURU 4:wa [S5e[R"U5R5(d [S5eUb[R"U["SS9R 5nUR$S:XaUR S5n[U5S:XdUR$S:wa [S5eUR UR :Xd [S5e[R"U5R5(d [S5e[R&"U S 4["S9nUb9[R("U/5(d[R("U//5(aS[R*4n[R,"[R"U["S95nURn[U5S :a[S[U5SS 35e[R"UU S 4:H5(aUnO[R"US!:H5(d[R"US":H5(a)UR15nUSUSS2S4'USUSS2S4'OC[R"US U 4:H5(a[S#U SS$U SS%35e[S&US'35e[R2"USS2S45n[R**UUS4'[R2"USS2S45n[R*UUS4'[5XX4X^Xx5$![an [S 5U eSn A ff=f![an [S5U eSn A ff=f![an [S5U eSn A ff=f![an [S5U eSn A ff=f![an [S5U eSn A ff=f![an [S5U eSn A ff=f![a!n [SU R.S-5U eSn A f[a!n [SU R.S-5U eSn A ff=f)(aZ Given user inputs for a linear programming problem, return the objective vector, upper bound constraints, equality constraints, and simple bounds in a preferred format. Parameters ---------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : various valid formats, optional The bounds of ``x``, as ``min`` and ``max`` pairs. If bounds are specified for all N variables separately, valid formats are: * a 2D array (2 x N or N x 2); * a sequence of N sequences, each with 2 values. If all variables have the same bounds, a single pair of values can be specified. Valid formats are: * a sequence with 2 scalar values; * a sequence with a single element containing 2 scalar values. If all variables have a lower bound of 0 and no upper bound, the bounds parameter can be omitted (or given as None). x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. Returns ------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, as ``min`` and ``max`` pairs, one for each of the N elements of ``x``. The N x 2 array contains lower bounds in the first column and upper bounds in the 2nd. Unbounded variables have lower bound -np.inf and/or upper bound np.inf. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. NTr(rr5rzhInvalid input for linprog: c must be a 1-D array and must not have more than one non-singleton dimensionzFInvalid input for linprog: c must not contain values inf, nan, or NonezJInvalid input for linprog: c must be a 1-D array of numerical coefficients)r2zInvalid input for linprog: A_ub must have exactly two dimensions, and the number of columns in A_ub must be equal to the size of czIInvalid input for linprog: A_ub must not contain values inf, nan, or NonezGInvalid input for linprog: A_ub must be a 2-D array of numerical valueszInvalid input for linprog: b_ub must be a 1-D array; b_ub must not have more than one non-singleton dimension and the number of rows in A_ub must equal the number of values in b_ubzIInvalid input for linprog: b_ub must not contain values inf, nan, or NonezInvalid input for linprog: b_ub must be a 1-D array of numerical values, each representing the upper bound of an inequality constraint (row) in A_ubzInvalid input for linprog: A_eq must have exactly two dimensions, and the number of columns in A_eq must be equal to the size of czIInvalid input for linprog: A_eq must not contain values inf, nan, or NonezGInvalid input for linprog: A_eq must be a 2-D array of numerical valueszInvalid input for linprog: b_eq must be a 1-D array; b_eq must not have more than one non-singleton dimension and the number of rows in A_eq must equal the number of values in b_eqzIInvalid input for linprog: b_eq must not contain values inf, nan, or NonezInvalid input for linprog: b_eq must be a dense, 1-D array of numerical values, each representing the right hand side of an equality constraint (row) in A_eqzKInvalid input for linprog: x0 must be a 1-D array of numerical coefficientszkInvalid input for linprog: x0 should be a 1-D array; it must not have more than one non-singleton dimensionzNInvalid input for linprog: x0 and c should contain the same number of elementszGInvalid input for linprog: x0 must not contain values inf, nan, or Noner+zTInvalid input for linprog: unable to interpret bounds, check values and dimensions: zAInvalid input for linprog: provide a 2-D array for bounds, not a dz -D array.)r<r)rr<z%Invalid input for linprog: provide a z! x 2 array for bounds, not a 2 x z array.zQInvalid input for linprog: unable to interpret bounds with this dimension tuple: r) TypeErrorr-r/float64r6r7r8lenshaperisfiniteallrrr3datar:r,ndimr. array_equalinf atleast_2dargsflattenisnanr )lpcrb_ubr b_eqboundsx0 integralityr1er2n_ubn_eq bounds_clean bounds_convbsh bounds_flati_nones r$ _clean_inputsr[sN:<6ATry% HHQbjjt 4 < < > 66Q; " A!f !8s177|q(AB B{{1~!!##$% %$ d#9s||D'9J%$T:F zz!} tzz?a 4::a=C#7)* * LL  r{{499'='A'A'C'C||D))"++d2C2G2G2I2I$% %%$T* ::$   {{4 $$&&$% %' %$T:F zz!} tzz?a 4::a=C#7)* * LL  r{{499'='A'A'C'C||D))"++d2C2G2G2I2I$% %%$T* ::$   {{4 $$&&$% %' ~ 1"E5==?B 77a<BB r7a<277a<FG Gww!&& *+ +{{2""$$$% %88S!HE2L~33r~~frd7S7SRVV @mmBHHV5$AB    C 3x!| XaL  +, , Qx " &&  266#-#8#8!))+ (^ QT(^ QT 3x 3C7;Qw () ) #uA '( (XXl1a4( )F!vvgL XXl1a4( )F ffL at4r OOo # !" ##, * "#() **& : 239: ::& * "#() **( 8 0178 88, 1)*/0 1 1N @ ,./ffQi 89>? @ @ ,./ffQi 89>? @@s2Y1 Z1 Z- [ < [)(\-\%1 Z ; ZZ  Z* Z%%Z*- [7 [[ [& [!![&) \3 [??\ \" \\"% ]9/]  ]9]44]9c ^/^0UupEpgpp/n Sn Sn[R"UR5nSnSnU SS2S4R5nU SS2S4R5nURunnURunnUb0UR 5S;aS[ U5-S-n[ U5e[R"U5(a4UR5nUR5nS n[RnO [Rn[Rn[R"UU:5(dY[R"U[R:H5(d-[R"U[R*:H5(aS nS nS n[XEXgXU 5XXUU4$[R"[R "US:gSS 9S:H5R#5n[R"U5(a[R"[R$"U[R&"U5U:55(aS nSnS n[XEXgXU 5XXUU4$U[R("U5SS24nU[R("U5n[R"[R "US:gSS 9S:H5R#5n[R"U5(a[R"[R$"UXc*:55(aS nSnS n[XEXgXU 5XXUU4$U[R("U5SS24nU[R("U5nU"Xu45nURSS:Gae[R"[R "US:gSS 9S:H5R#5nU[R$"UUS:5U[R$"UUS:5'U[R$"UUS:5U[R$"UUS:5'[R"[R*"U55(aSnSnS n[XEXgXU 5XXUU4$U[R$"UUS:5U[R$"UUS:5'U[R$"UUS:5U[R$"UUS:5'[R"[R "US:gSS 9S:H5R#5nU"U5SnU"UUSS245Sn[-U5S:a[/UU5HSunn UUUUU 4- n!UU U- U!s=::a UU U-::dO S nSnS n[XEXgXU 5XXUU4s $U!UU 'U!UU 'MU U[R("U5SS24nU[R("U5n[R"[R "US:gSS 9S:H5R#5nU"UUSS245SnU"U5Sn[-U5S:a[/UU5Hyunn UUUUU 4- n!UUU 4S:aU!UU U- :aS nO,U!UU :aU!UU 'OU!UU U-:aS nOU!UU :aU!UU 'U(dMbS nSn[XEXgXU 5XXUU4s $ U[R("U5SS24nU[R("U5n[R&"UU- 5U:m/[R("T/5n"[R0"T/5(aXR3U5- n#XeR3U5- n$UR4S:a[R"U$S:5(d,UR4S:a5[R6"U#S5(dS nSnS n[XEXgXU 5XXUU4$Un%Un&[R"T/5(aXT/R3UT/5- n XSS2T/4R3UT/5- nXeSS2T/4R3UT/5- nUU"nUT/m0UU"nU bU U"n USS2U"4nUSS2U"4nUU"n&UU"n%U/U04Sjn'U R9U'5 UR4S:XGa^UR4S:XGaM[R"/5n[R"/5nUR4S:XaSnSnO[R"[R$"US:U%[R:H55(dE[R"[R$"US:U&[R*:H55(aSnSnOSnSnS nU%US:XS:'U&US:XS:'U%US:Hn(U%US:H[R*"U(5U([R*"U(5'SU([R*"U(5'U(XS:H'[R:"U&SS2[R<4U%SS2[R<445n URSn)Sn*[R"U5(aeU(aKUR4S:a;[?Xx5n+U+upxnnURSU):a[AU*[BSS9 US:waS n[XEXgXU 5XXUU4$Sn,U(a0UR4S:a [RDRGU5n-U(aUR4S:aW-URS:a[AU*[BSS9 URSU-- n.Uc5U.U,::a[KXx5n+U+upxnnU.U,:dUS:Xa[MXx5n+U+upxnnOZUR 5nUS:Xa[KXx5n+U+upxnnO2US:Xa[MXx5n+U+upxnnOUS:Xa[OXxU-5n+U+upxnnOURSU-:aSnSnUS:waS n[XEXgXU 5XXUU4$![Ha Sn-GNf=f) a Given inputs for a linear programming problem in preferred format, presolve the problem: identify trivial infeasibilities, redundancies, and unboundedness, tighten bounds where possible, and eliminate fixed variables. Parameters ---------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, as ``min`` and ``max`` pairs, one for each of the N elements of ``x``. The N x 2 array contains lower bounds in the first column and upper bounds in the 2nd. Unbounded variables have lower bound -np.inf and/or upper bound np.inf. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. rr : bool If ``True`` attempts to eliminate any redundant rows in ``A_eq``. Set False if ``A_eq`` is known to be of full row rank, or if you are looking for a potential speedup (at the expense of reliability). rr_method : string Method used to identify and remove redundant rows from the equality constraint matrix after presolve. 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. Returns ------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, as ``min`` and ``max`` pairs, possibly tightened. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. c0 : 1D array Constant term in objective function due to fixed (and eliminated) variables. x : 1D array Solution vector (when the solution is trivial and can be determined in presolve) revstack: list of functions the functions in the list reverse the operations of _presolve() the function signature is x_org = f(x_mod), where x_mod is the result of a presolve step and x_org the value at the start of the step (currently, the revstack contains only one function) complete: bool Whether the solution is complete (solved or determined to be infeasible or unbounded in presolve) 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 : Serious numerical difficulties encountered message : str A string descriptor of the exit status of the optimization. References ---------- .. [5] Andersen, Erling D. "Finding all linearly dependent rows in large-scale linear programming." Optimization Methods and Software 6.3 (1995): 219-227. .. [8] Andersen, Erling D., and Knud D. Andersen. "Presolving in linear programming." Mathematical Programming 71.2 (1995): 221-245. rFNr>idsvdpivot'z[' is not a valid option for redundancy removal. Valid options are 'SVD', 'pivot', and 'ID'.c"UR5$N)nonzero)r0s r$where_presolve..wheress99; r&r<zThe problem is (trivially) infeasible since one or more upper bounds are smaller than the corresponding lower bounds, a lower bound is np.inf or an upper bound is -np.inf.TaxiszThe problem is (trivially) infeasible due to a row of zeros in the equality constraint matrix with a nonzero corresponding constraint value.zThe problem is (trivially) infeasible due to a row of zeros in the equality constraint matrix with a nonzero corresponding constraint value.zIf feasible, the problem is (trivially) unbounded due to a zero column in the constraint matrices. If you wish to check whether the problem is infeasible, turn presolve off.zzThe problem is (trivially) infeasible because a singleton row in the equality constraints is inconsistent with the bounds.z}The problem is (trivially) infeasible because a singleton row in the upper bound constraints is inconsistent with the bounds.zvThe problem is (trivially) infeasible because the bounds fix all variables to values inconsistent with the constraintsc>[R"T5n[U5n[R"U5nX- n[R"UR [ 5UT5nU$rc)r- flatnonzeror@arangeinsertastyper,)x_modiN index_offsetinsert_indicesx_revi_fx_undos r$rev_presolve..rev sQ s#AAA99Q6JELr&zPThe solution was determined in presolve as there are no non-trivial constraints.aThe problem is (trivially) unbounded because there are no non-trivial constraints and a) at least one decision variable is unbounded above and its corresponding cost is negative, or b) at least one decision variable is unbounded below and its corresponding cost is positive. zA_eq does not appear to be of full row rank. To improve performance, check the problem formulation for redundant equality constraints.rrr_r`r^zDue to numerical issues, redundant equality constraints could not be removed automatically. Try providing your constraint matrices as sparse matrices to activate sparse presolve, try turning off redundancy removal, or try turning off presolve altogether.)(r-r.rAr*lowerstrrrrtocsrvstackreanyrGr r/sumrJ logical_andabs logical_notisinfr@ziprCdotr7allcloseappendhstacknewaxisrrrlinalg matrix_rank Exceptionrrr )1rLrr rr_methodtolrMrrNr rOrPrQ_revstackc0completexstatusmessagelbubm_eqnm_ubrer}zero_rowr0zero_col singleton_rowrowscolsrowcolvali_nfresidualslackub_modlb_modrwx_zero_cn_rows_Aredundancy_warningrr_ressmall_nullspacerankdim_row_nullspacerurvs1 @@r$ _presolvers r02,ATrH BH A FG 1   B 1   BjjGD!jjGD!!)??Y'+((!! ||Dzz|zz|  vvb2g"&&rvv.."&&w2G2G!1DbAx67< <xxtqyq1Q67??AH vvh 66 NNt s" $ % % FAGHqD"E8vw@ @x0!34Dx01Dxxtqyq1Q67??AH vvh 66"..4$;7 8 8FBGHqD"E8vw@ @x0!34Dx01D |AwwqzA~88BFF162a78@@B-/ NN8QU +.-"..1q5 )*-/ NN8QU +.-"..1q5 )* 66"((1+  F,GHqD"E8vw@ @/1 NN8QU +/-2>>(AE *+.0 NN8QU +/-2>>(AE *+ HHRVVDAIA6!;<DDFM   "D dAg  "D 4y1}D$HCs)d38n,Cc7S=C82c7S=8; "1DbIx67DD 33( BNN=1145BNN=12HHRVVDAIA6!;<DDFM mQ&' ( +D   "D 4y1}D$HCs)d38n,CCH~!C3&#H2c7]!BsGC3&#H2c7]!BsGx;#1DbIx67DD#(&BNN=1145BNN=12 &&b/C C >># D vvc{{((2,&xx|# YY]rvveai00Qr{{8Q'?'?F)GHqD"E8vw@ @F F vvc{{ fjjC!!1c6l&&r#w//1c6l&&r#w// dGC dG >DBAtG}AtG}DD   yyA~$))q.xx|xx| 66Q;F5GffR^^AE6RVV+;<==ffR^^AE6bffW+<=>>FBGF5G!a%=a%!a%=a%!q&>'-a1f~bhhx6H'I(#$'((#$q& YYq"**}-vam/DE FFzz!}H@ T $))a-4T@F*0 'Dzz!}x''QG{1DbAx67< < O dii!m 99((.D dii!mtzz!} 4 Q? JJqM$.   O3/;.4+FG ?2fk7C.4+FG")IE!/;.4+FGg%7C.4+FGd".t4@.4+FG ::a=4 %G F Q;H qD" = 8vw 88I D s%q q#"q#cUc0nUR5VVs0sHup4X4_M nnn[XRURUR5upVn[ UR XgS95nX4$s snnf)a; Parse the provided linear programming problem ``_parse_linprog`` employs two main steps ``_check_sparse_inputs`` and ``_clean_inputs``. ``_check_sparse_inputs`` checks for sparsity in the provided constraints (``A_ub`` and ``A_eq) and if these match the provided sparsity optional values. ``_clean inputs`` checks of the provided inputs. If no violations are identified the objective vector, upper bound constraints, equality constraints, and simple bounds are returned in the expected format. Parameters ---------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : various valid formats, optional The bounds of ``x``, as ``min`` and ``max`` pairs. If bounds are specified for all N variables separately, valid formats are: * a 2D array (2 x N or N x 2); * a sequence of N sequences, each with 2 values. If all variables have the same bounds, a single pair of values can be specified. Valid formats are: * a sequence with 2 scalar values; * a sequence with a single element containing 2 scalar values. If all variables have a lower bound of 0 and no upper bound, the bounds parameter can be omitted (or given as None). x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. options : dict A dictionary of solver options. All methods accept the following generic options: maxiter : int Maximum number of iterations to perform. disp : bool Set to True to print convergence messages. For method-specific options, see :func:`show_options('linprog')`. Returns ------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, as ``min`` and ``max`` pairs, one for each of the N elements of ``x``. The N x 2 array contains lower bounds in the first column and upper bounds in the 2nd. Unbounded variables have lower bound -np.inf and/or upper bound np.inf. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. options : dict, optional A dictionary of solver options. All methods accept the following generic options: maxiter : int Maximum number of iterations to perform. disp : bool Set to True to print convergence messages. For method-specific options, see :func:`show_options('linprog')`. )rr )itemsr%rr r[_replace)rLrrkvsolver_optionsrr s r$_parse_linprogrsqH'.}}7tqadN7!5n68ggrww"HN$ r{{{8 9B  8sA)c Uup#pEpgp[R"U5(aUSn [R"U5n[R"U5nSn Sn [Rn [RnOBSn [R n [R n [Rn [Rn[R"USS9nUSS2S4nUSS2S4nURunn[R"U[R*5n[R"U[R5n[R"U5n[R"U5n[R"UU5n[R"U5SnUU*UU*sUU'UU'[R"U[R*5n[R"U[R5n[R"U5n[R"U5nUU==S -ss'Ub UU==S -ss'[U5S:aHURSS:aUSS2U4==S -ss'URSS:aUSS2U4==S -ss'UR5unUUn[U5nUS:aUURS4nU (aL[R "U5U4nU "U[R"[R""U5U4US 945nOGU "U[R"U545nSU[R "UURS5U4'[R$"U[R"U545nUUUS&U "X545n[R$"XF45n[R$"U[R"URS4545nUb:[R$"U[R"URS4545n[R"UU5n [R"U 5Sn![U!5n"[R$"U[R"U"545nUb,[R$"U[R"U"545nU "USS2SU24USS2U!4*45nUU!*UUUU"-&UbAUU!S:n#UU!U#*U[R "UURS5U#'SUU!U#'U "U"URS5U "URSURS45/5n$U "UU$/5n%[R"U5Sn&UUR'[(5n'U[R*"U'UU&-5- nU (acUR-S S5nU%R/5n%UU%SS2U&4[R0"U'5-R+SS 9-nUR35nOUU%SS2U&4U'-R+SS 9-nUb UU&==U'-ss'U%UX!U4$) a Given a linear programming problem of the form: Minimize:: c @ x Subject to:: A_ub @ x <= b_ub A_eq @ x == b_eq lb <= x <= ub where ``lb = 0`` and ``ub = None`` unless set in ``bounds``. Return the problem in standard form: Minimize:: c @ x Subject to:: A @ x == b x >= 0 by adding slack variables and making variable substitutions as necessary. Parameters ---------- lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, lower bounds in the 1st column, upper bounds in the 2nd column. The bounds are possibly tightened by the presolve procedure. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. c0 : float Constant term in objective function due to fixed (and eliminated) variables. Returns ------- A : 2-D array 2-D array such that ``A`` @ ``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 (for standard form problem). c : 1-D array Coefficients of the linear objective function to be minimized (for standard form problem). c0 : float Constant term in objective function due to fixed (and eliminated) variables. x0 : 1-D array Starting values of the independent variables, which will be refined by the optimization algorithm References ---------- .. [9] Bertsimas, Dimitris, and J. Tsitsiklis. "Introduction to linear programming." Athena Scientific 1 (1997): 997. Tc,[R"USS9$Ncsr)format)rrblockss r$r_get_Abc..hstackb::fU3 3r&c,[R"USS9$r)rr}rs r$r}_get_Abc..vstackerr&F)r*Nrrr5)rArg)rr csr_matrixeyer-rr}r.r/rAequalrGrrrdr@rlones concatenaternr,rr8tocscdiagsravel)(rLrrMrrNr rOrPrQrRrrr}r.rlbsubsrrTlb_noneub_nonelb_someub_some l_nolb_someubi_nolbi_newubub_newubn_boundsrAidxsA1r9l_freei_freen_free i_free_negA2r0i_shiftlb_shifts( r$_get_Abcrszj:<6ATr ||D~~d#~~d# 4 4ggffXXf4 (F A,C A,CJD$hhsRVVG$GhhsBFF#GnnW%GnnW%GNN7G4M ZZ &q )F ] c-00+C M*hhsRVVG$GhhsBFF#GnnW%GnnW%GfIOI ~ 6 b  6{Q ::a=1  FOr !O ::a=1  FOr !O HG7|H7|H!|4::a=) IIh'1D41BD0I6;"=>?D4%12D<=D4A/8 9~~tRXXh%789TU  B |$A 288TZZ]$4567A ~ ^^R4::a=*:!;< = ^^GW -F ZZ  "F [F 288F+,-A ~ ^^R&!12 3 AuuH1f9 ~. /BV9*Ad4; ~Z!^ 8:6*;M8N7N299T288A; ' 34!"6*  TZZ]#UDJJqM4::a=+I%JK LBBxAjj!!$G7|""5)H"&&AgJ& ''B IIb!  GGI a7 mcii11 6 6A 6 >> GGI a7 mh& + + + 33 ~ 7 x a?r&c\S[R"[R"U55-$)z: Round elements of the array to the nearest power of two. r<)r-aroundlog2)rs r$_round_to_power_of_twors  bii # ##r&cURupESnSnURS:Gav[R"[R"U5SS9n[ R "U5(aUR5R5nSXwS:H'S[U5- n[ R "U5(a[ R"U5U-OXRUS5-nX-n[R"[R"U5SS9n[ R "U5(aUR5R5nSXfS:H'S[U5- n[ R "U5(aU[ R"U5-OX-nX&-nURS:a*[R"[R"U55OSnUS:XaSnX- nUb X8- SU- -nXX#Xh4$)z} Scales the problem according to equilibration from [12]. Also normalizes the right hand side vector by its maximum element. rrrgg?) rAr7r-maxrrrtoarrayrJrrr8) r0r9rMrQmrCRb_scales r$ _autoscalers~ 77DA A Avvz FF266!91 % <<?? ##%Aq& $Q' '!ll1ooCIIaLN1YYq!_3D C FF266!91 % <<?? ##%Aq& $Q' '!ll1ooAciilN13 C#$66A:bffRVVAY1G!| A ~ Z1   ""r&cf[U5nUSUU-U-$![a [U5nN"f=f)zJ Converts solution to _autoscale problem -> solution to original problem. N)r@r>)rrrrs r$_unscalers@  F Ra5=?  Fs 00cb[U5 US;a[SUS35 [SUS35 g)aW Print the termination summary of the linear program Parameters ---------- message : str A string descriptor of the exit status of the optimization. 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 : Serious numerical difficulties encountered fun : float Value of the objective function. iteration : iteration The number of iterations performed. )rrz! Current function value: z <12.6fz Iterations: r=N)print)rrfun iterations r$_display_summaryrs7, 'N  1#g?@ !)A /0r&cUSup4pVpxpUSSupn [X U 5nURSnU(dUbSn[U5HunnUSnUSnU[R*:Xa.U[R:XaUS- nUUXU-S- - UU'MSU[R*:Xa UUU- UU'MuUU==U- ss'M USUn[ U 5H nU"U5nM UR U5n[R"SS9 XTR U5- nXvR U5- nSSS5 UUWW4$!,(df  N=f)a" Given solution x to presolved, standard form linear program x, add fixed variables back into the problem and undo the variable substitutions to get solution to original linear program. Also, calculate the objective function value, slack in original upper bound constraints, and residuals in original equality constraints. Parameters ---------- x : 1-D array Solution vector to the standard-form problem. postsolve_args : tuple Data needed by _postsolve to convert the solution to the standard-form problem into the solution to the original problem, including: lp : A `scipy.optimize._linprog_util._LPProblem` consisting of the following fields: c : 1D array The coefficients of the linear objective function to be minimized. A_ub : 2D array, optional The inequality constraint matrix. Each row of ``A_ub`` specifies the coefficients of a linear inequality constraint on ``x``. b_ub : 1D array, optional The inequality constraint vector. Each element represents an upper bound on the corresponding value of ``A_ub @ x``. A_eq : 2D array, optional The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. b_eq : 1D array, optional The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. bounds : 2D array The bounds of ``x``, lower bounds in the 1st column, upper bounds in the 2nd column. The bounds are possibly tightened by the presolve procedure. x0 : 1D array, optional Guess values of the decision variables, which will be refined by the optimization algorithm. This argument is currently used only by the 'revised simplex' method, and can only be used if `x0` represents a basic feasible solution. revstack: list of functions the functions in the list reverse the operations of _presolve() the function signature is x_org = f(x_mod), where x_mod is the result of a presolve step and x_org the value at the start of the step complete : bool Whether the solution is was determined in presolve (``True`` if so) Returns ------- x : 1-D array Solution vector to original linear programming problem fun: float optimal objective value for original problem slack : 1-D array The (non-negative) slack in the upper bound constraints, that is, ``b_ub - A_ub @ x`` con : 1-D array The (nominally zero) residuals of the equality constraints, that is, ``b - A_eq @ x`` rrNignore)invalid)rrA enumerater-rGreversedrerrstate)rpostsolve_argsrrMrrNr rOrPrQrRrrrr1 n_unboundedrpbilbiubirwrrcons r$ _postsolver$scB:H9J6ATr)!"-HwA ,,q/C * v&EArQ%CQ%Crvvg~#-q tak 1A 566!266'>1:AaDaDCKD' $3A ! F" %%(C X &xx{"XXa[  ' c5#  ' &s 'E Ec [R"U5S-nUc US:XaSnSnX'4$[R"U5R5=(dl [R"U5=(dO [R"U5R5=(d$ [R"U5R5n U (aSn OUcSnXSS2S4U- :XSS2S4U-:*-n XS:[R"USUS9--n [R "U 5(+n US :g=(a X6*:R5n US :g=(a' [R "U5U:R5nU =(d U =(d U(+n US:XaU (dSnS US -S -nX'4$US :Xa U (aSnSnX'4$)a- Check the validity of the provided solution. A valid (optimal) solution satisfies all bounds, all slack variables are negative and all equality constraint residuals are strictly non-zero. Further, the lower-bounds, upper-bounds, slack and residuals contain no nan values. Parameters ---------- x : 1-D array Solution vector to original linear programming problem fun: float optimal objective value for original problem 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 : Serious numerical difficulties encountered slack : 1-D array The (non-negative) slack in the upper bound constraints, that is, ``b_ub - A_ub @ x`` con : 1-D array The (nominally zero) residuals of the equality constraints, that is, ``b - A_eq @ x`` bounds : 2D array The bounds on the original variables ``x`` message : str A string descriptor of the exit status of the optimization. tol : float Termination tolerance; see [1]_ Section 4.5. Returns ------- 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 : Serious numerical difficulties encountered message : str A string descriptor of the exit status of the optimization. Nrrz^The solver did not provide a solution nor did it report a failure. Please submit a bug report.Fr)atolrizOThe solution does not satisfy the constraints within the required tolerance of z.2Ea,, yet no errors were raised and there is no certificate of infeasibility or unboundedness. Check whether the slack and constraint residuals are acceptable; if not, consider enabling presolve, adjusting the tolerance option(s), and/or using a different method. Please consider submitting a bug report.r<zuThe solution is feasible, but the solver did not report that the solution was optimal. Please try a different method.)r-sqrtrKr~iscloserCr)rrrrrrPrrrR contains_nans is_feasible valid_boundsinvalid_bounds invalid_slack invalid_cons r$ _check_resultr sj ''#, Cy Q;FGG    88C=  88E?     88C=      KAqD\C//A19K4KL qBJJq!#,FFF VVL11! <(:(:(< k?rvvc{S'8&=&=&? )I]IkJ  {;,14S ;>>>" ? 1 ?r&)F)g& .>)!__doc__numpyr- scipy.sparserrwarningsr _optimizer!scipy.optimize._remove_redundancyrrrr collectionsr r __new__ __defaults__r%r3r:r[rrrrrrrrr r&r$rs&#  EG "- E RBJ3>/,EPPw8t l^CL$##L 18ePgr&