h8DdZddlZddlZddlmZmZmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,d Z-d Z.d Z/ ddZ0dS)a^HiGHS Linear Optimization Methods Interface to HiGHS linear optimization software. https://highs.dev/ .. versionadded:: 1.5.0 References ---------- .. [1] Q. Huangfu and J.A.J. Hall. "Parallelizing the dual revised simplex method." Mathematical Programming Computation, 10 (1), 119-142, 2018. DOI: 10.1007/s12532-017-0130-5 N)_check_unknown_optionsOptimizeWarningOptimizeResult)warn)_highs_wrapper) CONST_I_INF CONST_INFMESSAGE_LEVEL_NONEHIGHS_OBJECTIVE_SENSE_MINIMIZEMODEL_STATUS_NOTSETMODEL_STATUS_LOAD_ERRORMODEL_STATUS_MODEL_ERRORMODEL_STATUS_PRESOLVE_ERRORMODEL_STATUS_SOLVE_ERRORMODEL_STATUS_POSTSOLVE_ERRORMODEL_STATUS_MODEL_EMPTYMODEL_STATUS_OPTIMALMODEL_STATUS_INFEASIBLE$MODEL_STATUS_UNBOUNDED_OR_INFEASIBLEMODEL_STATUS_UNBOUNDED5MODEL_STATUS_REACHED_DUAL_OBJECTIVE_VALUE_UPPER_BOUND%MODEL_STATUS_REACHED_OBJECTIVE_TARGETMODEL_STATUS_REACHED_TIME_LIMIT$MODEL_STATUS_REACHED_ITERATION_LIMITHIGHS_SIMPLEX_STRATEGY_CHOOSEHIGHS_SIMPLEX_STRATEGY_DUAL HIGHS_SIMPLEX_CRASH_STRATEGY_OFF)HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_CHOOSE*HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DANTZIG(HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DEVEX0HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_STEEPEST_EDGEHIGHS_VAR_TYPE_CONTINUOUS) csc_matrixvstackissparsecPiddtdtdtdtdtdt dt dtdtdtdtdtdtdtd td }d }|||\}}|d |d |d}||fS)zCConverts HiGHS status number/message to SciPy status number/messageN)z%HiGHS did not provide a status code. )r()r))rz&Optimization terminated successfully. )rzTime limit reached. )rzIteration limit reached. )r*zThe problem is infeasible. )zThe problem is unbounded. )r(z(The problem is unbounded or infeasible. )r(z*The HiGHS status code was not recognized. z(HiGHS Status z: ))r rrrrrrMODEL_STATUS_RDOVUBrrrrrrrget) highs_status highs_messagescipy_statuses_messages unrecognized scipy_status scipy_messages Y/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/scipy/optimize/_linprog_highs.py_highs_to_scipy_status_messager6;sEC :CWC C !' C $W C !' C %gC !'C WC .wC KC ()DC -.NC !CC  AC -/B!C$EL##L,?? L-%GG&2GG6CGGGM  &&cxtj|}tj||tz||<|S)N)npisinfsignr )xinfss r5 _replace_infr>Xs0 8A;;Dgagy(AdG Hr7c j ||S#t$r ||cYSt$rytjt }|j|j}td|d|dt| d|d td||cYSwxYw)NzOption z is z, but only values in z are allowed. Using default: .r+) stacklevel) lowerAttributeErrorKeyErrorinspect signature_linprog_highs parametersdefaultrsetkeysr)option option_strchoicessig default_strs r5_convert_to_highs_enumrQ_s $v||~~&& v $$$//nZ08  zvGLLNN## , , , ,{####$sB2A?B21B2TFc  x t| t| dtttt dd} |\}}}}}}}}|j\}}tj | tj z}|}|}|}tj ||f}tj ||f}t|st|rt||f}ntj ||f}t|}id|dtd|d|d t d |d |d |d | d|d|d| dt"dt$d|d|d| }t'|}t'|}t'|}t'|}|tj|dkrtjd}ntj|}t/||j|j|j|||||tj| } d| vr[| d}!tj|!t;|d}"tj|!dt;|}!nd\}!}"d| vr| d}#tj|#dt;|}$tj|#t;|d}%tj| ddddf}&tj| ddddf}'n d\}$}%d\}&}'dddd}(| dd})| dd}*t?|)|*\}+},d | vrtj| d nd}-|-|!|"tA|!|$d!tA|"|%d!tA|-dn|-|z |'d!tA|-dn||-z |&d!| d"|+| dtBk|,| d#dp| d$d| d%d& }.tj"|-rW|U|.#| d'd| d(d)| d*d)d+|.S),a Solve the following linear programming problem using one of the HiGHS solvers: User-facing documentation is in _linprog_doc.py. Parameters ---------- lp : _LPProblem A ``scipy.optimize._linprog_util._LPProblem`` ``namedtuple``. solver : "ipm" or "simplex" or None Which HiGHS solver to use. If ``None``, "simplex" will be used. Options ------- maxiter : int The maximum number of iterations to perform in either phase. For ``solver='ipm'``, this does not include the number of crossover iterations. Default is the largest possible value for an ``int`` on the platform. disp : bool Set to ``True`` if indicators of optimization status are to be printed to the console each iteration; default ``False``. time_limit : float The maximum time in seconds allotted to solve the problem; default is the largest possible value for a ``double`` on the platform. presolve : bool Presolve attempts to identify trivial infeasibilities, identify trivial unboundedness, and simplify the problem before sending it to the main solver. It is generally recommended to keep the default setting ``True``; set to ``False`` if presolve is to be disabled. dual_feasibility_tolerance : double Dual feasibility tolerance. Default is 1e-07. The minimum of this and ``primal_feasibility_tolerance`` is used for the feasibility tolerance when ``solver='ipm'``. primal_feasibility_tolerance : double Primal feasibility tolerance. Default is 1e-07. The minimum of this and ``dual_feasibility_tolerance`` is used for the feasibility tolerance when ``solver='ipm'``. ipm_optimality_tolerance : double Optimality tolerance for ``solver='ipm'``. Default is 1e-08. Minimum possible value is 1e-12 and must be smaller than the largest possible value for a ``double`` on the platform. simplex_dual_edge_weight_strategy : str (default: None) Strategy for simplex dual edge weights. The default, ``None``, automatically selects one of the following. ``'dantzig'`` uses Dantzig's original strategy of choosing the most negative reduced cost. ``'devex'`` uses the strategy described in [15]_. ``steepest`` uses the exact steepest edge strategy as described in [16]_. ``'steepest-devex'`` begins with the exact steepest edge strategy until the computation is too costly or inexact and then switches to the devex method. Curently, using ``None`` always selects ``'steepest-devex'``, but this may change as new options become available. mip_max_nodes : int The maximum number of nodes allotted to solve the problem; default is the largest possible value for a ``HighsInt`` on the platform. Ignored if not using the MIP solver. 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 ------- sol : dict A dictionary consisting of the fields: x : 1D array The values of the decision variables that minimizes the objective function while satisfying the constraints. fun : float The optimal value of the objective function ``c @ x``. slack : 1D array The (nominally positive) values of the slack, ``b_ub - A_ub @ x``. con : 1D array The (nominally zero) residuals of the equality constraints, ``b_eq - A_eq @ x``. success : bool ``True`` when the algorithm succeeds in finding an optimal solution. status : int An integer representing the exit status of the algorithm. ``0`` : Optimization terminated successfully. ``1`` : Iteration or time limit reached. ``2`` : Problem appears to be infeasible. ``3`` : Problem appears to be unbounded. ``4`` : The HiGHS solver ran into a problem. message : str A string descriptor of the exit status of the algorithm. nit : int The total number of iterations performed. For ``solver='simplex'``, this includes iterations in all phases. For ``solver='ipm'``, this does not include crossover iterations. crossover_nit : int The number of primal/dual pushes performed during the crossover routine for ``solver='ipm'``. This is ``0`` for ``solver='simplex'``. ineqlin : OptimizeResult Solution and sensitivity information corresponding to the inequality constraints, `b_ub`. A dictionary consisting of the fields: residual : np.ndnarray The (nominally positive) values of the slack variables, ``b_ub - A_ub @ x``. This quantity is also commonly referred to as "slack". marginals : np.ndarray The sensitivity (partial derivative) of the objective function with respect to the right-hand side of the inequality constraints, `b_ub`. eqlin : OptimizeResult Solution and sensitivity information corresponding to the equality constraints, `b_eq`. A dictionary consisting of the fields: residual : np.ndarray The (nominally zero) residuals of the equality constraints, ``b_eq - A_eq @ x``. marginals : np.ndarray The sensitivity (partial derivative) of the objective function with respect to the right-hand side of the equality constraints, `b_eq`. lower, upper : OptimizeResult Solution and sensitivity information corresponding to the lower and upper bounds on decision variables, `bounds`. residual : np.ndarray The (nominally positive) values of the quantity ``x - lb`` (lower) or ``ub - x`` (upper). marginals : np.ndarray The sensitivity (partial derivative) of the objective function with respect to the lower and upper `bounds`. mip_node_count : int The number of subproblems or "nodes" solved by the MILP solver. Only present when `integrality` is not `None`. mip_dual_bound : float The MILP solver's final estimate of the lower bound on the optimal solution. Only present when `integrality` is not `None`. mip_gap : float The difference between the final objective function value and the final dual bound, scaled by the final objective function value. Only present when `integrality` is not `None`. Notes ----- The result fields `ineqlin`, `eqlin`, `lower`, and `upper` all contain `marginals`, or partial derivatives of the objective function with respect to the right-hand side of each constraint. These partial derivatives are also referred to as "Lagrange multipliers", "dual values", and "shadow prices". The sign convention of `marginals` is opposite that of Lagrange multipliers produced by many nonlinear solvers. References ---------- .. [15] Harris, Paula MJ. "Pivot selection methods of the Devex LP code." Mathematical programming 5.1 (1973): 1-28. .. [16] Goldfarb, Donald, and John Ker Reid. "A practicable steepest-edge simplex algorithm." Mathematical Programming 12.1 (1977): 361-371. !simplex_dual_edge_weight_strategyN)dantzigdevexzsteepest-devexsteepestN)rNpresolvesensesolver time_limithighs_debug_leveldual_feasibility_toleranceipm_optimality_tolerancelog_to_console mip_max_nodes output_flagprimal_feasibility_tolerancesimplex_strategysimplex_crash_strategyipm_iteration_limitsimplex_iteration_limit mip_rel_gaprslack)NNlambda marg_bndsrz highs-ipmzhighs-ds)ipmsimplexNstatusmessager<)residual marginalsfun simplex_nitipm_nit crossover_nit) r<rgconineqlineqlinrBupperrprlsuccessrmnitrsmip_node_countmip_dual_boundgmip_gap)rzr{r|)$rrQr r!rr"Tcopyr9 ones_likeinf concatenater&r%r$r r rrr>sumemptyarrayrindptrindicesdataastypeuint8lenr.r6rranyupdate)/lprYrZrWdispmaxiterr\rar]rSrfr_unknown_options&simplex_dual_edge_weight_strategy_enumcA_ubb_ubA_eqb_eqboundsx0 integralitylbublhs_ubrhs_ublhs_eqrhs_eqlhsrhsAoptionsresrgrtlamda marg_ineqlin marg_eqlin marg_upper marg_lowersolversr/r0rlrmr<sols/ r5rGrGpsyL?+++.D)+FB#LA ...*:<6AtT4vr; X]]__FBl4   'F F F F .&&) * *C .&&) * *C~~$$$ D$<  ItTl # #1 AH/ & j  /  %&@  #$< $  t '(D , 2 7 !"B w!" "7#$ {%G, s  C s  C b  B b  Bbf[11Q66hqkk h{++ AHaicR!3!3BH!=!=w H HC #~~G huSYYZZ())zD z*++ s3H xjs4yyj 122 XeCIIJJ/00 Xc+.q!!!t455 Xc+.q!!!t455 #- j!+ J"j KKG778T**LGGIt,,M4\5BDDOFG"SjjSdA$ (& & #&$ $ ##$944!b&&$ $ ##$944"q&&$$''%..(m';;''-++Dswwy!/D/DGGO441  C6 vayy [, !gg&6::!gg&6<<wwy#..     Jr7) NTFNNNNNNN)1__doc__rEnumpyr9 _optimizerrrwarningsr_highs._highs_wrapperr_highs._highs_constantsr r r r r rrrrrrrrrrrr-rrrrrrrr r!r"r# scipy.sparser$r%r&r6r>rQrGr7r5rs  NNNNNNNNNN111111""""""""""""""""""""""""""""""""""""""""""""""""""""""""""F6555555555''':   $$$":>'+.204,059#!%HHHHHHr7