ó ʽ÷Xc @`sídZddlmZmZmZddlZddlmZm Z dddgZ d Z d „Z d „Z d ed „Zd d„Zdded ded„Zeeeeedeed ed„ Zeeeeedeed„ZdS(s" A top-level linear programming interface. Currently this interface only solves linear programming problems via the Simplex Method. .. versionadded:: 0.15.0 Functions --------- .. autosummary:: :toctree: generated/ linprog linprog_verbose_callback linprog_terse_callback i(tdivisiontprint_functiontabsolute_importNi(tOptimizeResultt_check_unknown_optionstlinprogtlinprog_verbose_callbacktlinprog_terse_callbacksrestructuredtext enc K`s‚|d}|d}|d\}}|d}|d}|d}tjƒ} tjddd id „d 6ƒ|r”td j|ƒƒtd ƒnB|dkr¶tdj|ƒƒn tdj||ƒƒtd ƒ|dkrqtdt|ƒdƒ|stdj||ƒƒntd|ƒtƒtdƒtd|ƒtƒtdƒtd|d ƒtƒntj| dS(s] A sample callback function demonstrating the linprog callback interface. This callback produces detailed output to sys.stdout before each iteration and after the final iteration of the simplex algorithm. Parameters ---------- xk : array_like The current solution vector. **kwargs : dict A dictionary containing the following parameters: tableau : array_like The current tableau of the simplex algorithm. Its structure is defined in _solve_simplex. phase : int The current Phase of the simplex algorithm (1 or 2) nit : int The current iteration number. pivot : tuple(int, int) The index of the tableau selected as the next pivot, or nan if no pivot exists basis : array(int) A list of the current basic variables. Each element contains the name of a basic variable and its value. complete : bool True if the simplex algorithm has completed (and this is the final call to callback), otherwise False. ttableautnittpivottphasetbasistcompletet linewidthiôt formattercS`s dj|ƒS(Ns {0: 12.4f}(tformat(tx((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pytCstfloats3--------- Iteration Complete - Phase {0:d} ------- sTableau:is3--------- Initial Tableau - Phase {0:d} ---------- s2--------- Iteration {0:d} - Phase {1:d} -------- ts s#Pivot Element: T[{0:.0f}, {1:.0f}] sBasic Variables:sCurrent Solution:sx = sCurrent Objective Value:sf = iÿÿÿÿN(iÿÿÿÿiÿÿÿÿ(tnptget_printoptionstset_printoptionstprintRtstr( txktkwargsRR tpivrowtpivcolR R R tsaved_printoptions((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyRs:               cK`sJ|d}|dkr#tdƒntdj|ƒddƒt|ƒdS(sz A sample callback function demonstrating the linprog callback interface. This callback produces brief output to sys.stdout before each iteration and after the final iteration of the simplex algorithm. Parameters ---------- xk : array_like The current solution vector. **kwargs : dict A dictionary containing the following parameters: tableau : array_like The current tableau of the simplex algorithm. Its structure is defined in _solve_simplex. vars : tuple(str, ...) Column headers for each column in tableau. "x[i]" for actual variables, "s[i]" for slack surplus variables, "a[i]" for artificial variables, and "RHS" for the constraint RHS vector. phase : int The current Phase of the simplex algorithm (1 or 2) nit : int The current iteration number. pivot : tuple(int, int) The index of the tableau selected as the next pivot, or nan if no pivot exists basics : list[tuple(int, float)] A list of the current basic variables. Each element contains the index of a basic variable and its value. complete : bool True if the simplex algorithm has completed (and this is the final call to callback), otherwise False. R is Iter: X:s {0: <5d} tendRN(RR(RRR ((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyR]s $   gê-™—q=cC`sµtjj|ddd…f| k|ddd…fdtƒ}|jƒdkrattjfS|r‹ttj|jtkƒddfSttjj||j ƒkƒddfS(s´ Given a linear programming simplex tableau, determine the column of the variable to enter the basis. Parameters ---------- T : 2D ndarray The simplex tableau. tol : float Elements in the objective row larger than -tol will not be considered for pivoting. Nominally this value is zero, but numerical issues cause a tolerance about zero to be necessary. bland : bool If True, use Bland's rule for selection of the column (select the first column with a negative coefficient in the objective row, regardless of magnitude). Returns ------- status: bool True if a suitable pivot column was found, otherwise False. A return of False indicates that the linear programming simplex algorithm is complete. col: int The index of the column of the pivot element. If status is False, col will be returned as nan. iÿÿÿÿNtcopyi( Rtmat masked_wheretFalsetcounttnantTruetwheretmasktmin(tTttoltblandR!((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyt _pivot_col‰s B $cC`sô|dkrd}nd}tjj|d| …|f|k|d| …|fdtƒ}|jƒdkr}ttjfStjj|d| …|f|k|d| …dfdtƒ}||}ttjj||jƒkƒddfS(sI Given a linear programming simplex tableau, determine the row for the pivot operation. Parameters ---------- T : 2D ndarray The simplex tableau. pivcol : int The index of the pivot column. phase : int The phase of the simplex algorithm (1 or 2). tol : float Elements in the pivot column smaller than tol will not be considered for pivoting. Nominally this value is zero, but numerical issues cause a tolerance about zero to be necessary. Returns ------- status: bool True if a suitable pivot row was found, otherwise False. A return of False indicates that the linear programming problem is unbounded. row: int The index of the row of the pivot element. If status is False, row will be returned as nan. iiNR iiÿÿÿÿ( RR!R"R#R$R%R&R'R)(R*RR R+tkR!tmbtq((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyt _pivot_row­s  C C ièic C`s1|} t} |dkr,|jdd} n,|dkrL|jdd} n tdƒ‚|dkrÏxhgt|jƒD]'} || |jddkrw| ^qwD]&} gt|jddƒD]"}|| |fdkrÀ|^qÀ}t|ƒdkr¢|d}||| <|| |}|| dd…f||| dd…fd|(|d| …df||| <||| i|d 6|d 6| d 6| |fd 6|d 6| o3|dkd6n| sH| |kr_d}t } q#||| <|| |}|| dd…f||| dd…f= 0 b_j >= 0 Parameters ---------- T : array_like A 2-D array representing the simplex T corresponding to the maximization problem. It should have the form: [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]], [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]], . . . [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]], [c[0], c[1], ..., c[n_total], 0]] for a Phase 2 problem, or the form: [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]], [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]], . . . [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]], [c[0], c[1], ..., c[n_total], 0], [c'[0], c'[1], ..., c'[n_total], 0]] for a Phase 1 problem (a Problem in which a basic feasible solution is sought prior to maximizing the actual objective. T is modified in place by _solve_simplex. n : int The number of true variables in the problem. basis : array An array of the indices of the basic variables, such that basis[i] contains the column corresponding to the basic variable for row i. Basis is modified in place by _solve_simplex maxiter : int The maximum number of iterations to perform before aborting the optimization. phase : int The phase of the optimization being executed. In phase 1 a basic feasible solution is sought and the T has an additional row representing an alternate objective function. callback : callable, optional If a callback function is provided, it will be called within each iteration of the simplex algorithm. The callback must have the signature `callback(xk, **kwargs)` where xk is the current solution vector and kwargs is a dictionary containing the following:: "T" : The current Simplex algorithm T "nit" : The current iteration. "pivot" : The pivot (row, column) used for the next iteration. "phase" : Whether the algorithm is in Phase 1 or Phase 2. "basis" : The indices of the columns of the basic variables. 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 to serve as an optimal solution. nit0 : int The initial iteration number used to keep an accurate iteration total in a two-phase problem. bland : bool If True, choose pivots using Bland's rule [3]. In problems which fail to converge due to cycling, using Bland's rule can provide convergence at the expense of a less optimal path about the simplex. Returns ------- res : OptimizeResult The optimization result represented as a ``OptimizeResult`` object. Important attributes are: ``x`` the solution array, ``success`` a Boolean flag indicating if the optimizer exited successfully and ``message`` which describes the cause of the termination. Possible values for the ``status`` attribute are: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded See `OptimizeResult` for a description of other attributes. iiis1Argument 'phase' to _solve_simplex must be 1 or 2NtdtypeiiÿÿÿÿRR R R R R (R#tshapet ValueErrortrangetsizetlenRtzerostfloat64tmaxR-R%R&R1tNone(R*tnR tmaxiterR tcallbackR+tnit0R,R R tmtrowRtcolt non_zero_rowRtpivvaltirowtsolutiont pivcol_foundtstatust pivrow_found((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyt_solve_simplexÔsr^    +"  * O&.           * Oc 2K`s… t| ƒd} idd6dd6dd6dd6d d 6} t}tj|ƒ}d}t|ƒ}|dk r{tj|ƒntjdt|ƒgƒ}|dk r±tj|ƒntjdt|ƒgƒ}|dk rðtjtj|ƒƒntjdgƒ}|dk r&tjtj|ƒƒntjdgƒ}tj|d tj ƒ}tj |d tj ƒtj }|dkst|ƒdkrn‹t|ƒdkr>t |dd ƒ r>|ddk rÐ|dntj }|ddk rô|dntj }tj||gd tj ƒ}tj||gd tj ƒ}nÝt|ƒ|kr_d } d}n¼yœx•t |ƒD]‡}t||ƒdkr—tƒ‚n||ddk r¹||dntj ||<||ddk ré||dntj ||= -3 where: -inf <= x[0] <= inf This problem deviates from the standard linear programming problem. In standard form, linear programming problems assume the variables x are non-negative. Since the variables don't have standard bounds where 0 <= x <= inf, the bounds of the variables must be explicitly set. There are two upper-bound constraints, which can be expressed as dot(A_ub, x) <= b_ub The input for this problem is as follows: >>> from scipy.optimize import linprog >>> c = [-1, 4] >>> A = [[-3, 1], [1, 2]] >>> b = [6, 4] >>> x0_bnds = (None, None) >>> x1_bnds = (-3, None) >>> res = linprog(c, A, b, bounds=(x0_bnds, x1_bnds)) >>> print(res) fun: -22.0 message: 'Optimization terminated successfully.' nit: 1 slack: array([ 39., 0.]) status: 0 success: True x: array([ 10., -3.]) References ---------- .. [1] Dantzig, George B., Linear programming and extensions. Rand Corporation Research Study Princeton Univ. Press, Princeton, NJ, 1963 .. [2] Hillier, S.H. and Lieberman, G.J. (1995), "Introduction to Mathematical Programming", McGraw-Hill, Chapter 4. .. [3] Bland, Robert G. New finite pivoting rules for the simplex method. Mathematics of Operations Research (2), 1977: pp. 103-107. is%Optimization terminated successfully.sIteration limit reached.is>Optimization failed. Unable to find a feasible starting point.is9Optimization failed. The problem appears to be unbounded.is1Optimization failed. Singular matrix encountered.iR2t__len__iÿÿÿÿsiInvalid input for linprog with method = 'simplex'. Length of bounds is inconsistent with the length of cskInvalid input for linprog with method = 'simplex'. bounds must be a n x 2 sequence/array where n = len(c).saInvalid input for linprog with method = 'simplex'. Lower bound %d is greater than upper bound %dsTInvalid input for linprog with method = 'simplex'. Lower bound may not be +infinitysTInvalid input for linprog with method = 'simplex'. Upper bound may not be -infinityNsPInvalid input for linprog with method = 'simplex'. Upper bound may not be -inf.s,Invalid input. A_ub must be two-dimensionals,Invalid input. A_eq must be two-dimensionals|Invalid input for linprog with method = 'simplex'. The number of rows in A_eq must be equal to the number of values in b_eqs|Invalid input for linprog with method = 'simplex'. The number of rows in A_ub must be equal to the number of values in b_ubslInvalid input for linprog with method = 'simplex'. Number of columns in A_eq must be equal to the size of cslInvalid input for linprog with method = 'simplex'. Number of columns in A_ub must be equal to the size of ciþÿÿÿR R>R=R+R,RtfunR RHtmessagetsuccessR?R(t fill_valuegs, Current function value: {0: <12.6f}s Iterations: {0:d}tslack(iþÿÿÿiÿÿÿÿ(iÿÿÿÿiÿÿÿÿ(iÿÿÿÿiÿÿÿÿ(iÿÿÿÿiÿÿÿÿ(ii(&RR#RtasarrayR7R;temptytravelR8R9tonestinfthasattrR5t IndexErrortanyt concatenatetarraythstackR3R&tisinftisfinitetvstackt count_nonzeroR4t fill_diagonaltintRJtabstdeletets_RRR%R!tfilledR(2tctA_ubtb_ubtA_eqtb_eqtboundsR=tdispR>R+R,tunknown_optionsRHtmessagesthave_floor_variabletcctf0R<tAeqtAubtbeqtbubtLtUtatbRMtitmubtmeqR@tn_slackt n_artificialtAub_rowstAub_colstAeq_rowstAeq_colsR*tslcounttavcountR t r_artificialtrtnit1tnit2RFRRPtmasked_Ltobj((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyt_linprog_simplex‡sV    6666&$#"  07   !$!++ # # #& %#""::            %     -   >.   &  -    *tsimplexc C`sr|jƒ} |d kr!i}n| dkr^t|d|d|d|d|d|d||Std|ƒ‚d S( sš Minimize a linear objective function subject to linear equality and inequality constraints. Linear Programming is intended to solve the following problem form: Minimize: c^T * x Subject to: A_ub * x <= b_ub A_eq * x == b_eq Parameters ---------- c : array_like Coefficients of the linear objective function to be minimized. A_ub : array_like, optional 2-D array which, when matrix-multiplied by x, gives the values of the upper-bound inequality constraints at x. b_ub : array_like, optional 1-D array of values representing the upper-bound of each inequality constraint (row) in A_ub. A_eq : array_like, optional 2-D array which, when matrix-multiplied by x, gives the values of the equality constraints at x. b_eq : array_like, optional 1-D array of values representing the RHS of each equality constraint (row) in A_eq. bounds : sequence, optional ``(min, max)`` pairs for each element in ``x``, defining the bounds on that parameter. Use None for one of ``min`` or ``max`` when there is no bound in that direction. By default bounds are ``(0, None)`` (non-negative) If a sequence containing a single tuple is provided, then ``min`` and ``max`` will be applied to all variables in the problem. method : str, optional Type of solver. At this time only 'simplex' is supported :ref:`(see here) `. callback : callable, optional If a callback function is provide, it will be called within each iteration of the simplex algorithm. The callback must have the signature `callback(xk, **kwargs)` where xk is the current solution vector and kwargs is a dictionary containing the following:: "tableau" : The current Simplex algorithm tableau "nit" : The current iteration. "pivot" : The pivot (row, column) used for the next iteration. "phase" : Whether the algorithm is in Phase 1 or Phase 2. "basis" : The indices of the columns of the basic variables. 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 `show_options('linprog')`. Returns ------- A `scipy.optimize.OptimizeResult` consisting of the following fields: x : ndarray The independent variable vector which optimizes the linear programming problem. fun : float Value of the objective function. slack : ndarray The values of the slack variables. Each slack variable corresponds to an inequality constraint. If the slack is zero, then the corresponding constraint is active. success : bool Returns True if the algorithm succeeded in finding an optimal solution. 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 nit : int The number of iterations performed. message : str A string descriptor of the exit status of the optimization. See Also -------- show_options : Additional options accepted by the solvers Notes ----- This section describes the available solvers that can be selected by the 'method' parameter. The default method is :ref:`Simplex `. Method *Simplex* uses the Simplex algorithm (as it relates to Linear Programming, NOT the Nelder-Mead Simplex) [1]_, [2]_. This algorithm should be reasonably reliable and fast. .. versionadded:: 0.15.0 References ---------- .. [1] Dantzig, George B., Linear programming and extensions. Rand Corporation Research Study Princeton Univ. Press, Princeton, NJ, 1963 .. [2] Hillier, S.H. and Lieberman, G.J. (1995), "Introduction to Mathematical Programming", McGraw-Hill, Chapter 4. .. [3] Bland, Robert G. New finite pivoting rules for the simplex method. Mathematics of Operations Research (2), 1977: pp. 103-107. Examples -------- Consider the following problem: Minimize: f = -1*x[0] + 4*x[1] Subject to: -3*x[0] + 1*x[1] <= 6 1*x[0] + 2*x[1] <= 4 x[1] >= -3 where: -inf <= x[0] <= inf This problem deviates from the standard linear programming problem. In standard form, linear programming problems assume the variables x are non-negative. Since the variables don't have standard bounds where 0 <= x <= inf, the bounds of the variables must be explicitly set. There are two upper-bound constraints, which can be expressed as dot(A_ub, x) <= b_ub The input for this problem is as follows: >>> c = [-1, 4] >>> A = [[-3, 1], [1, 2]] >>> b = [6, 4] >>> x0_bounds = (None, None) >>> x1_bounds = (-3, None) >>> from scipy.optimize import linprog >>> res = linprog(c, A_ub=A, b_ub=b, bounds=(x0_bounds, x1_bounds), ... options={"disp": True}) Optimization terminated successfully. Current function value: -22.000000 Iterations: 1 >>> print(res) fun: -22.0 message: 'Optimization terminated successfully.' nit: 1 slack: array([ 39., 0.]) status: 0 success: True x: array([ 10., -3.]) Note the actual objective value is 11.428571. In this case we minimized the negative of the objective function. RŒRgRhRiRjRkR>sUnknown solver %sN(tlowerR;R‹R4( RfRgRhRiRjRktmethodR>toptionstmeth((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyR8s£    !(t__doc__t __future__RRRtnumpyRtoptimizeRRt__all__t __docformat__RRR#R-R1R;RJR‹R(((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_linprog.pyts$  A ,$ ' ²  ÿ°