o EbA@sdZddlZddlZddlmZmZmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*d d Z+d d Z,     dddZ-dS)arHiGHS Linear Optimization Methods Interface to HiGHS linear optimization software. https://www.maths.ed.ac.uk/hall/HiGHS/ .. 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_MINIMALMODEL_STATUS_NOTSETMODEL_STATUS_LOAD_ERRORMODEL_STATUS_MODEL_ERRORMODEL_STATUS_PRESOLVE_ERRORMODEL_STATUS_SOLVE_ERRORMODEL_STATUS_POSTSOLVE_ERRORMODEL_STATUS_MODEL_EMPTYMODEL_STATUS_PRIMAL_INFEASIBLEMODEL_STATUS_PRIMAL_UNBOUNDEDMODEL_STATUS_OPTIMAL5MODEL_STATUS_REACHED_DUAL_OBJECTIVE_VALUE_UPPER_BOUNDMODEL_STATUS_REACHED_TIME_LIMIT$MODEL_STATUS_REACHED_ITERATION_LIMIT#MODEL_STATUS_PRIMAL_DUAL_INFEASIBLEMODEL_STATUS_DUAL_INFEASIBLEHIGHS_SIMPLEX_STRATEGY_CHOOSEHIGHS_SIMPLEX_STRATEGY_DUAL HIGHS_SIMPLEX_CRASH_STRATEGY_OFF.HIGHS_SIMPLEX_DUAL_EDGE_WEIGHT_STRATEGY_CHOOSE/HIGHS_SIMPLEX_DUAL_EDGE_WEIGHT_STRATEGY_DANTZIG-HIGHS_SIMPLEX_DUAL_EDGE_WEIGHT_STRATEGY_DEVEX5HIGHS_SIMPLEX_DUAL_EDGE_WEIGHT_STRATEGY_STEEPEST_EDGE) csc_matrixvstackissparsecCs$t|}t||t||<|S)N)npZisinfsignr )xZinfsr'?/usr/lib/python3/dist-packages/scipy/optimize/_linprog_highs.py _replace_inf8s r)c Csz||WSty||YStyCtt}|j|j}td|d|dt | d|d t dd||YSw)NzOption z is z, but only values in z are allowed. Using default: .) stacklevel) lowerAttributeErrorKeyErrorinspectZ signature_linprog_highsZ parametersdefaultrsetkeysr)optionZ option_strchoicesZsigZ default_strr'r'r(_convert_to_highs_enum?s        r7TFc -Ks2t| t| dttttddd} tdtdtdt dt d t d t d t d td tdtdtdtdtdtdi} |\} }}}}}}|j\}}t| tj}|}|}|}t||f}t||f}t|sft|rmt||f}nt||f}t|}|d||t||||| tt ||d }t!|}t!|}t!|}t!|}t"| |j#|j$|j%||||| }d|vr|d}t&|t'|d} t&|dt'|}nd\}} d|vr|d}!t&|!dt'|}"t&|!t'|d}#t&|ddddf}$t&|ddddf}%nd\}"}#d\}$}%dddd}&|dtkr6|d|dkr6| |d\}'}(d d!|(d"})}*n| |d\})}*d#|vrJt&|d#nd}+|+|| t(||"d$t(| |#d$t(|+durcdn|+||%d$t(|+durrdn||+|$d$|)d%|)|dtk|*|)d&dp|)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. 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`. 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)ZdantzigZdevexzsteepest-devexZsteepestN)r6)z+HiGHS Status Code 0: HighsModelStatusNOTSET)r9z/HiGHS Status Code 1: HighsModelStatusLOAD_ERROR)z0HiGHS Status Code 2: HighsModelStatusMODEL_ERROR)r9z3HiGHS Status Code 4: HighsModelStatusPRESOLVE_ERROR)r9z0HiGHS Status Code 5: HighsModelStatusSOLVE_ERROR)r9z4HiGHS Status Code 6: HighsModelStatusPOSTSOLVE_ERROR)r9z0HiGHS Status Code 3: HighsModelStatusMODEL_EMPTY)r9zNHiGHS Status Code 10: HighsModelStatusREACHED_DUAL_OBJECTIVE_VALUE_UPPER_BOUND)r:zThe problem is infeasible.)r+zThe problem is unbounded.)rz%Optimization terminated successfully.)rzTime limit reached.)rzIteration limit reached.)r:z&The problem is primal/dual infeasible.)r:zThe problem is dual infeasible.r) presolveZsensesolver time_limitZ message_leveldual_feasibility_toleranceipm_optimality_toleranceprimal_feasibility_tolerancer8Zsimplex_strategyZsimplex_crash_strategyZipm_iteration_limitZsimplex_iteration_limitslack)NNlambdaZ marg_bndsrz highs-ipmzhighs-ds)ZipmZsimplexNstatusZunscaled_statusr9z:An optimal solution to the scaled model was found but was zN in the unscaled model. For more information run with the option `disp: True`.r&)ZresidualZ marginalsfunZ simplex_nitZipm_nit crossover_nit) r&rAconZineqlinZeqlinr-upperrDrCZsuccessmessageZnitrE)*rr7rrrr r r r rrrrMODEL_STATUS_RDOVUBrrrrrrrTcopyr$Z ones_likeinfZ concatenater#r"r!r rrr)rZindptrindicesdataZarraylenrget)-Zlpr<r=r;Zdispmaxiterr>r@r?r8Zunknown_optionsZ&simplex_dual_edge_weight_strategy_enumZstatusescZA_ubZb_ubZA_eqZb_eqZboundsZx0ZlbZubZlhs_ubZrhs_ubZlhs_eqZrhs_eqZlhsZrhsAoptionsresrArFZlamdaZ marg_ineqlinZ marg_eqlinZ marg_upperZ marg_lowerZsolversZ_unscaled_statusZunscaled_messagerCrHr&Zsolr'r'r(r1Ps2 @   r1)NTFNNNNN).__doc__r0Znumpyr$ _optimizerrrwarningsrZ_highs._highs_wrapperrZ_highs._highs_constantsrr r r r r rrrrrrrrrIrrrrrrrrrrr Z scipy.sparser!r"r#r)r7r1r'r'r'r(s"  l