\h̉0SrSSKJr SSKJr SSKJrJrJr SSK J r SSK J r SSK Jr SSKJr SS KJrJr SS KJr SS KJr SS KJr "S S\5r"SS\5rSrSrS SjrS!Sjr S"Sjr!S#Sjr"Sr#Sr$Sr%Sr&Sr'Sr(S$Sjr)S$Sjr*g)%aTools for optimizing a linear function for a given simplex. For the linear objective function ``f`` with linear constraints expressed using `Le`, `Ge` or `Eq` can be found with ``lpmin`` or ``lpmax``. The symbols are **unbounded** unless specifically constrained. As an alternative, the matrices describing the objective and the constraints, and an optional list of bounds can be passed to ``linprog`` which will solve for the minimization of ``C*x`` under constraints ``A*x <= b`` and/or ``Aeq*x = beq``, and individual bounds for variables given as ``(lo, hi)``. The values returned are **nonnegative** unless bounds are provided that indicate otherwise. Errors that might be raised are UnboundedLPError when there is no finite solution for the system or InfeasibleLPError when the constraints represent impossible conditions (i.e. a non-existent simplex). Here is a simple 1-D system: minimize `x` given that ``x >= 1``. >>> from sympy.solvers.simplex import lpmin, linprog >>> from sympy.abc import x The function and a list with the constraint is passed directly to `lpmin`: >>> lpmin(x, [x >= 1]) (1, {x: 1}) For `linprog` the matrix for the objective is `[1]` and the uivariate constraint can be passed as a bound with None acting as infinity: >>> linprog([1], bounds=(1, None)) (1, [1]) Or the matrices, corresponding to ``x >= 1`` expressed as ``-x <= -1`` as required by the routine, can be passed: >>> linprog([1], [-1], [-1]) (1, [1]) If there is no limit for the objective, an error is raised. In this case there is a valid region of interest (simplex) but no limit to how small ``x`` can be: >>> lpmin(x, []) Traceback (most recent call last): ... sympy.solvers.simplex.UnboundedLPError: Objective function can assume arbitrarily large values! An error is raised if there is no possible solution: >>> lpmin(x,[x<=1,x>=2]) Traceback (most recent call last): ... sympy.solvers.simplex.InfeasibleLPError: Inconsistent/False constraint )sympify) factor_terms)LeGeEq)S)Dummy)ordered)sign)Matrixzeros)linear_eq_to_matrixnumbered_symbols) filldedentc\rSrSrSrSrg)UnboundedLPErrorMz A linear programming problem is said to be unbounded if its objective function can assume arbitrarily large values. Example ======= Suppose you want to maximize 2x subject to x >= 0 There's no upper limit that 2x can take. N__name__ __module__ __qualname____firstlineno____doc____static_attributes__rM/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/simplex.pyrrMs   rrc\rSrSrSrSrg)InfeasibleLPError`a; A linear programming problem is considered infeasible if its constraint set is empty. That is, if the set of all vectors satisfying the constraints is empty, then the problem is infeasible. Example ======= Suppose you want to maximize x subject to x >= 10 x <= 9 No x can satisfy those constraints. rNrrrrr r `s " rr cXSS24USS2U4XU4pTnUS:Xa [S5eXX5- -- nX5- XaSS24'U*U- USS2U4'SU- XaU4'U$)a The pivot element `M[i, j]` is inverted and the rest of the matrix modified and returned as a new matrix; original is left unmodified. Example ======= >>> from sympy.matrices.dense import Matrix >>> from sympy.solvers.simplex import _pivot >>> from sympy import var >>> Matrix(3, 3, var('a:i')) Matrix([ [a, b, c], [d, e, f], [g, h, i]]) >>> _pivot(_, 1, 0) Matrix([ [-a/d, -a*e/d + b, -a*f/d + c], [ 1/d, e/d, f/d], [-g/d, h - e*g/d, i - f*g/d]]) Nrz'Tried to pivot about zero-valued entry.)ZeroDivisionError)MijMiMjMijAs r_pivotr,us|,qD'1QT7AdGCB ax 57 7 "(OAhAdGcCiAadG#gAdG Hrc,^^^^[UUUUU4SjS9$)Nc(>TUTUT4- TU4$Nr)r&r+BY pivot_cols r#_choose_pivot_row..sadQq)|_.Dad-Kr)key)min)r+r0candidate_rowsr2r1s`` ``r_choose_pivot_rowr8s ~#K LLrNcl^^UTX#=(d S/4Vs/sHn[U5PM snunmp#U(a6[UR*URTRU*5upgnU*Xx4$U(aT(a[UT/X#//5n O&U(dT(a [S5e[X#//5n U RS- n U R S- n [ SU 55(d[[S55e[U 5V s/sHn SU 4PM sn m[U 5Vs/sHnSU4PM n nSnU SS 2S 4mU SS 2SS 24n[ U4S j[TR 555(aGO[TR 5HnTUS:dM O [UR5Vs/sHnUWU4S:dMUPM nnU(d[[S 55e[U4S jU55unn[UR 5Vs/sHnUUU4S:dMTUS:dMUPM nnURW5 [UTUUU 5nUU4U:XaSnO%UU4n[U UU5n U UTUsTU'U U'GM]U SS 2S 4mU SS 2SS 24nU S SS 24n[U 5Vs/sHnUUS:dMUPM nnU(dO[U4S jU55unn[U 5Vs/sHnUUU4S:dMUPM nnU(d[[S55e[UTUUU 5n[U UU5n U UTUsTU'U U'MS/U -nS/U -n[!T5H ununn US:XaSUU 'MU S U4UU 'M" [!U 5Hununn US:XaSUU 'MXS 4UU 'M! U(a.[ SUU-55(d[[S55eU S*UU4$s snfs sn fs snfs snfs snfs snfs snf)aReturn ``(o, x, y)`` obtained from the two-phase simplex method using Bland's rule: ``o`` is the minimum value of primal, ``Cx - D``, under constraints ``Ax <= B`` (with ``x >= 0``) and the maximum of the dual, ``y^{T}B - D``, under constraints ``A^{T}*y >= C^{T}`` (with ``y >= 0``). To compute the dual of the system, pass `dual=True` and ``(o, y, x)`` will be returned. Note: the nonnegative constraints for ``x`` and ``y`` supercede any values of ``A`` and ``B`` that are inconsistent with that assumption, so if a constraint of ``x >= -1`` is represented in ``A`` and ``B``, no value will be obtained that is negative; if a constraint of ``x <= -1`` is represented, an error will be raised since no solution is possible. This routine relies on the ability of determining whether an expression is 0 or not. This is guaranteed if the input contains only Float or Rational entries. It will raise a TypeError if a relationship does not evaluate to True or False. Examples ======== >>> from sympy.solvers.simplex import _simplex >>> from sympy import Matrix Consider the simple minimization of ``f = x + y + 1`` under the constraint that ``y + 2*x >= 4``. This is the "standard form" of a minimization. In the nonnegative quadrant, this inequality describes a area above a triangle with vertices at (0, 4), (0, 0) and (2, 0). The minimum of ``f`` occurs at (2, 0). Define A, B, C, D for the standard minimization: >>> A = Matrix([[2, 1]]) >>> B = Matrix([4]) >>> C = Matrix([[1, 1]]) >>> D = Matrix([-1]) Confirm that this is the system of interest: >>> from sympy.abc import x, y >>> X = Matrix([x, y]) >>> (C*X - D)[0] x + y + 1 >>> [i >= j for i, j in zip(A*X, B)] [2*x + y >= 4] Since `_simplex` will do a minimization for constraints given as ``A*x <= B``, the signs of ``A`` and ``B`` must be negated since the currently correspond to a greater-than inequality: >>> _simplex(-A, -B, C, D) (3, [2, 0], [1/2]) The dual of minimizing ``f`` is maximizing ``F = c*y - d`` for ``a*y <= b`` where ``a``, ``b``, ``c``, ``d`` are derived from the transpose of the matrix representation of the standard minimization: >>> tr = lambda a, b, c, d: [i.T for i in (a, c, b, d)] >>> a, b, c, d = tr(A, B, C, D) This time ``a*x <= b`` is the expected inequality for the `_simplex` method, but to maximize ``F``, the sign of ``c`` and ``d`` must be changed (so that minimizing the negative will give the negative of the maximum of ``F``): >>> _simplex(a, b, -c, -d) (-3, [1/2], [2, 0]) The negative of ``F`` and the min of ``f`` are the same. The dual point `[1/2]` is the value of ``y`` that minimized ``F = c*y - d`` under constraints a*x <= b``: >>> y = Matrix(['y']) >>> (c*y - d)[0] 4*y + 1 >>> [i <= j for i, j in zip(a*y,b)] [2*y <= 1, y <= 1] In this 1-dimensional dual system, the more restrictive constraint is the first which limits ``y`` between 0 and 1/2 and the maximum of ``F`` is attained at the nonzero value, hence is ``4*(1/2) + 1 = 3``. In this case the values for ``x`` and ``y`` were the same when the dual representation was solved. This is not always the case (though the value of the function will be the same). >>> l = [[1, 1], [-1, 1], [0, 1], [-1, 0]], [5, 1, 2, -1], [[1, 1]], [-1] >>> A, B, C, D = [Matrix(i) for i in l] >>> _simplex(A, B, -C, -D) (-6, [3, 2], [1, 0, 0, 0]) >>> _simplex(A, B, -C, -D, dual=True) # [5, 0] != [3, 2] (-6, [1, 0, 0, 0], [5, 0]) In both cases the function has the same value: >>> Matrix(C)*Matrix([3, 2]) == Matrix(C)*Matrix([5, 0]) True See Also ======== _lp - poses min/max problem in form compatible with _simplex lpmin - minimization which calls _lp lpmax - maximimzation which calls _lp References ========== .. [1] Thomas S. Ferguson, LINEAR PROGRAMMING: A Concise Introduction web.tecnico.ulisboa.pt/mcasquilho/acad/or/ftp/FergusonUCLA_lp.pdf rzmust give A and Br#c3^# UH#oR=(d URv M% g7fr/)is_Float is_Rational.0r&s r _simplex..s6Aqzz*Q]]*As+-z@ Only rationals and floats are allowed. FTNc34># UH nTUS:v M g7frNr)r>r&r0s rr?r@3s0-Qqtqy-sz- The constraint set is empty!c32># UH nTUU4v M g7fr/rr>r&Xs rr?r@C/hAaD!9hc32># UH nTUU4v M g7fr/rrEs rr?r@mrGrHzX Objective function can assume arbitrarily large values!c3*# UH oS:v M g7frCrr=s rr?r@s=(<1Q("D !t 1aOqT1Q4 !adc h  crc2gJ crc3B3hK b#2#gJ %Qx4x!1Q4!8Ax4 /h//1 %Qx7x!1QT7Q;Ax7":/-$./ / aHa 3 1aOqT1Q4 !ad) ,VaZF&1*Kq\ 6Aq :F1Ir1uXKN " q\ 6Aq 9KNR%F1I "  C=(<=== ,%!&' ' fI:v{ **A:4 '%,=JH5 8sGPP&P;P"P" P'3P'>P' P,P,P1P1cSnUSS2SS24USS2S4USSS24USS2SS244nU(dU$[UVs/sH oB"U5PM sn5$s snf)areturn parts of M as matrices or lists Examples ======== >>> from sympy import Matrix >>> from sympy.solvers.simplex import _abcd >>> m = Matrix(3, 3, range(9)); m Matrix([ [0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> a, b, c, d = _abcd(m) >>> a Matrix([ [0, 1], [3, 4]]) >>> b Matrix([ [2], [5]]) >>> c Matrix([[6, 7]]) >>> d Matrix([[8]]) The matrices can be returned as compact lists, too: >>> L = a, b, c, d = _abcd(m, list=True); L ([[0, 1], [3, 4]], [2, 5], [[6, 7]], [8]) c~UR5n[US5S:XaUVs/sHoSPM sn$U$s snf)Nrr#)tolistlen)r&ls raslist_abcd..aslists= HHJ qt9>"#$!QaD!$ $%s:NrA)tuple)r%listrmr]r&s r_abcdrqsuD #2#ss( QssBwZ2ss7QrsBCx[8A  Q'Q&)Q' (('sAcXX#=(d S/4Vs/sHn[U5PM snupp#[X/X#//5$s snf)areturn Matrix([[a, b], [c, d]]) from matrices in Matrix or list form. Examples ======== >>> from sympy import Matrix >>> from sympy.solvers.simplex import _abcd, _m >>> m = Matrix(3, 3, range(9)) >>> L = _abcd(m, list=True); L ([[0, 1], [3, 4]], [2, 5], [[6, 7]], [8]) >>> _abcd(m) (Matrix([ [0, 1], [3, 4]]), Matrix([ [2], [5]]), Matrix([[6, 7]]), Matrix([[8]])) >>> assert m == _m(*L) == _m(*_) r)r )abrbrZr&s r_mrusF('(AxQC%89%8&)%89JA! A6A6" ##:s;c^U(dS/4S/44$[US5(d"[U5S;a [S5e[U6nURVs/sHo"S- PM snup4[ U5upVpxUSnSn [ [U "S5[U55VV s/sHup*UPM sn n5n [ [U "S 5[U55VV s/sHup*UPM sn n5Rn U4S jn S nU"X{-U5nU"X-U5nX"X[-U[54UU "X-U[544$s snfs sn nfs sn nf) a?return primal and dual function and constraints assuming that ``M = Matrix([[A, b], [c, d]])`` and the function ``c*x - d`` is being minimized with ``Ax >= b`` for nonnegative values of ``x``. The dual and its constraints will be for maximizing `b.T*y - d` subject to ``A.T*y <= c.T``. Examples ======== >>> from sympy.solvers.simplex import _primal_dual, lpmin, lpmax >>> from sympy import Matrix The following matrix represents the primal task of minimizing x + y + 7 for y >= x + 1 and y >= -2*x + 3. The dual task seeks to maximize x + 3*y + 7 with 2*y - x <= 1 and and x + y <= 1: >>> M = Matrix([ ... [-1, 1, 1], ... [ 2, 1, 3], ... [ 1, 1, -7]]) >>> p, d = _primal_dual(M) The minimum of the primal and maximum of the dual are the same (though they occur at different points): >>> lpmin(*p) (28/3, {x1: 2/3, x2: 5/3}) >>> lpmax(*d) (28/3, {y1: 1/3, y2: 2/3}) If the equivalent (but canonical) inequalities are desired, leave `factor=True`, otherwise the unmodified inequalities for M will be returned. >>> m = Matrix([ ... [-3, -2, 4, -2], ... [ 2, 0, 0, -2], ... [ 0, 1, -3, 0]]) >>> _primal_dual(m, False) # last condition is 2*x1 >= -2 ((x2 - 3*x3, [-3*x1 - 2*x2 + 4*x3 >= -2, 2*x1 >= -2]), (-2*y1 - 2*y2, [-3*y1 + 2*y2 <= 0, -2*y1 <= 1, 4*y1 <= -3])) >>> _primal_dual(m) # condition now x1 >= -1 ((x2 - 3*x3, [-3*x1 - 2*x2 + 4*x3 >= -2, x1 >= -1]), (-2*y1 - 2*y2, [-3*y1 + 2*y2 <= 0, -2*y1 <= 1, 4*y1 <= -3])) If you pass the transpose of the matrix, the primal will be identified as the standard minimization problem and the dual as the standard maximization: >>> _primal_dual(m.T) ((-2*x1 - 2*x2, [-3*x1 + 2*x2 >= 0, -2*x1 >= 1, 4*x1 >= -3]), (y2 - 3*y3, [-3*y1 - 2*y2 + 4*y3 <= -2, y1 <= -1])) A matrix must have some size or else None will be returned for the functions: >>> _primal_dual(Matrix([[1, 2]])) ((x1 - 2, []), (-2, [])) >>> _primal_dual(Matrix([])) ((None, []), (None, [])) References ========== .. [1] David Galvin, Relations between Primal and Dual www3.nd.edu/~dgalvin1/30210/30210_F07/presentations/dual_opt.pdf Nshape)z expecting Matrix or 3 or 4 listsr#rc[USS9$)Nr#)startr)xs rr3_primal_dual..2s "1A.rr|ycp>^/nU4Sj[X55GHnUS:XaM US:XaS/s $T(a[U5nURR(aURURR S-S:Xa[ URR 5S:XdUR5eURR SnUR[U5URR S-UR[U5-5nURU5 GM U$)Nc38># UHupT"X5v M g7fr/r)r>r&r'ops rr?-_primal_dual..ineq..8s1ytq"Q((ysTFrr#) ziprlhsis_Mulrhsargsrkfuncr absrT)Lrdrrvfr_factors ` rineq_primal_dual..ineq6s 1s1y1ADyew O55<quuzz?a/66/ 1 AtAwA6QHA IIaL2 rc&U(aUSU- $U*$Nrr)r|rZs rr3r}Fs!adQh+!+r) hasattrrkrNrurwrqr rrSrMrr)r%rr&r]r\r+rtrbrZr`r'r|yTreqFrs ` r _primal_dualrs=^ bzD":%% 1g   q6 ?@ @ F77 #7aE7 #DAqJA! !A.Ac!C&%(343da345A s1S658454tq45 6 8 8B ,B 15! A 261 A tAE1b! "QRVQ(;$< <<5 $55sD9D> E c20n/n/n[SS[S9n0n/n[U5nUGH?nUS:XaM US:Xa gUR[R [R 5(a [S5e[U[[45(aURUR- nURn X- (a[SX- -5e[U 5S:aURU5 MU (aKU R!5n X;aM[US SS 9R#5n X;aXU 'GMXj==U -ss'GMU(a gGM+[%['S U-55e UHn UR)U S5nU(d gUS:XaURU 5 M7UR*UR,pU R.(a$[1U5nX- X*'URU5 MU R.(a-U (a$[1U5nX-X*'URU5 MM[1U5nURU5 X-X*'URXU - - 5 M UH%n [1U5nX- X*'URU5 M' X2U4$) areturn `(np, d, aux)` where `np` is a list of nonpositive expressions that represent the given constraints (possibly rewritten in terms of auxilliary variables) expressible with nonnegative symbols, and `d` is a dictionary mapping a given symbols to an expression with an auxilliary variable. In some cases a symbol will be used as part of the change of variables, e.g. x: x - z1 instead of x: z1 - z2. If any constraint is False/empty, return None. All variables in ``constr`` are assumed to be unbounded unless explicitly indicated otherwise with a univariate constraint, e.g. ``x >= 0`` will restrict ``x`` to nonnegative values. The ``syms`` must be included so all symbols can be given an unbounded assumption if they are not otherwise bound with univariate conditions like ``x <= 3``. Examples ======== >>> from sympy.solvers.simplex import _rel_as_nonpos >>> from sympy.abc import x, y >>> _rel_as_nonpos([x >= y, x >= 0, y >= 0], (x, y)) ([-x + y], {}, []) >>> _rel_as_nonpos([x >= 3, x <= 5], [x]) ([_z1 - 2], {x: _z1 + 3}, [_z1]) >>> _rel_as_nonpos([x <= 5], [x]) ([], {x: 5 - _z1}, [_z1]) >>> _rel_as_nonpos([x >= 1], [x]) ([], {x: _z1 + 1}, [_z1]) zr#)r{clsTFNz only finite bounds are permittedz&unexpected symbol(s) in constraint: %sr)evaluatez only equalities like Eq(x, y) or non-strict inequalities like x >= y are allowed in lp, not %s)rr sethasrInfinityNegativeInfinityrN isinstancerrltsgts free_symbolsrkrTpopas_setrRrgetinfsup is_infinitenext)constrsymsrdnpauxui univariateunboundr&freeir|ivlrsrtus r_rel_as_nonposrLsR@ A B C #QE 2BJG t9D 9  :  55Q// 0 0?@ @ a"b " " ANNE| < M5zA~ ! IIK<A.557&$'qMMS(MJ(FHI(JKL L9D NN1d # 9 NN1  uuaee1 ==RA5AD JJqM ]]Hu 1 RA JJqM5AD IIaq5k "9> Hu 1  #:rc[U5nUVs/sHn[U5PM nn[R"/U/U-Vs/sHo3RPM snQ[5P76n[ [ U55H_n[ XC[5(dMXCRXCR- S:*XC'URXCR*S:*5 Ma [XE5nUc[[S55eUupGnURU5nUVs/sHo3RU5PM nn[[!U55U-n [#XI5up[#U/U 5upXXXyU4$s snfs snfs snf)areturn A, B, C, D, r, x+X, X for maximizing objective = Cx - D with constraints Ax <= B, introducing introducing auxilliary variables, X, as necessary to make replacements of symbols as given in r, {xi: expression with Xj}, so all variables in x+X will take on nonnegative values. Every univariate condition creates a semi-infinite condition, e.g. a single ``x <= 3`` creates the interval ``[-oo, 3]`` while ``x <= 3`` and ``x >= 2`` create an interval ``[2, 3]``. Variables not in a univariate expression will take on nonnegative values. rz* Inconsistent/False constraint)rrunionrrSrkrrrrrTrr rxreplacerpr r) objective constraintsrr&rrr`rdrxxr+r0rVrWs r _lp_matricesrsV  A) *k'!*kB * 99 @sRx8x!~~x8 @#% @D3r7^ beR EII )Q.BE IIruyyjAo & r Ay ,-!./ /JB3 1 A!# $A**Q-B $ gdm s "B r &DA sB 'DA qc !!1 +8" %sE-E2 E7c[X5up4pVpxn [U5R5n SU ;a[X4U*U*5upn U *nO!SU ;a[X4XV5upn O [ S5e[ [ X55n U(akUR5VVs0sHunnUURU 5_M nnnU RU5 [U 5Vs0sHoU ;dM XU_M n nX4$s snnfs snf)aReturn the optimization (min or max) of ``f`` with the given constraints. All variables are unbounded unless constrained. If `min_max` is 'max' then the results corresponding to the maximization of ``f`` will be returned, else the minimization. The constraints can be given as Le, Ge or Eq expressions. Examples ======== >>> from sympy.solvers.simplex import _lp as lp >>> from sympy import Eq >>> from sympy.abc import x, y, z >>> f = x + y - 2*z >>> c = [7*x + 4*y - 7*z <= 3, 3*x - y + 10*z <= 6] >>> c += [i >= 0 for i in (x, y, z)] >>> lp(min, f, c) (-6/5, {x: 0, y: 0, z: 3/5}) By passing max, the maximum value for f under the constraints is returned (if possible): >>> lp(max, f, c) (3/4, {x: 0, y: 3/4, z: 0}) Constraints that are equalities will require that the solution also satisfy them: >>> lp(max, f, c + [Eq(y - 9*x, 1)]) (5/7, {x: 0, y: 1, z: 1/7}) All symbols are reported, even if they are not in the objective function: >>> lp(min, x, [y + x >= 3, x >= 0]) (0, {x: 0, y: 3}) maxr6zexpecting min or max) rstrlowerrLrNdictritemsrupdater )min_maxrrr+r0rVrWrdrrhowrYr[rZor_rgs r_lprsP*!4A!s g,   C |A1"qb)q C #1&a/00 SZA*+'') 4)$!QQ 1 ) 4  %aj 9jSLWQ!Wj 9 4K 5 :sC0 C6" C6c"[[X5$)aOreturn minimum of linear equation ``f`` under linear constraints expressed using Ge, Le or Eq. All variables are unbounded unless constrained. Examples ======== >>> from sympy.solvers.simplex import lpmin >>> from sympy import Eq >>> from sympy.abc import x, y >>> lpmin(x, [2*x - 3*y >= -1, Eq(x + 3*y, 2), x <= 2*y]) (1/3, {x: 1/3, y: 5/9}) Negative values for variables are permitted unless explicitly excluding, so minimizing ``x`` for ``x <= 3`` is an unbounded problem while the following has a bounded solution: >>> lpmin(x, [x >= 0, x <= 3]) (0, {x: 0}) Without indicating that ``x`` is nonnegative, there is no minimum for this objective: >>> lpmin(x, [x <= 3]) Traceback (most recent call last): ... sympy.solvers.simplex.UnboundedLPError: Objective function can assume arbitrarily large values! See Also ======== linprog, lpmax )rr6rrs rlpminr.sF sA rc"[[X5$)areturn maximum of linear equation ``f`` under linear constraints expressed using Ge, Le or Eq. All variables are unbounded unless constrained. Examples ======== >>> from sympy.solvers.simplex import lpmax >>> from sympy import Eq >>> from sympy.abc import x, y >>> lpmax(x, [2*x - 3*y >= -1, Eq(x+ 3*y,2), x <= 2*y]) (4/5, {x: 4/5, y: 2/5}) Negative values for variables are permitted unless explicitly excluding: >>> lpmax(x, [x <= -1]) (-1, {x: -1}) If a non-negative constraint is added for x, there is no possible solution: >>> lpmax(x, [x <= -1, x >= 0]) Traceback (most recent call last): ... sympy.solvers.simplex.InfeasibleLPError: inconsistent/False constraint See Also ======== linprog, lpmin )rrrs rlpmaxrTsB sA rc S[4Sjn/n/n/n[U5n[U5GHEunupxUcUcURU5 M"UcSUS- nURU"XVS4S/55 URU"XVS4S/55 UR U/U*//5 MxUc\U(aSUS- nURU"XVS4S/55 URU"XVS4S/55 UR U/U*//5 MMUS- nURU"XVS4S/55 URU"XVS4S/55 URU"US/55 UR U/U*/X- //5 GMH UHUnUS- nURU"XVS4SS/55 URU"XVS4SS /55 UR S /S //5 MW [ UV s/sHoS /U[U 5- --PM sn 5[ U54$s sn f) Nlengthc0S/U-nUH up4XBU'M U$rr)rindex_value_pairsliidxvals r _make_list"_handle_bounds.._make_list|s%S6\)HCsG* rr#)rAr#rArKr)rA)rr#r)intrkrUrTextendr ) boundsrrrowrow2b_lenr|rsrtrds r_handle_boundsrxs3 G C D KEv& 6A 9 NN1  Y QJE JJz%a&'):; < JJz%b'8)<= > KK!rd $ Y  :e!fh-?@A :e"gw-?@A aSA2$K( QJE JJz%a&();< = JJz%b'7);< = JJz%'3 4 KK!rdQUG, -5':   :e!fgx%@AB :e"gx%ABC aS1#J  S9SsECFN++S9 :F4L HH9sHc[U5nURS:waURS:Xa URnURS:wa [ S5eU(d>U(a [ S5e[ SUR5[ URS5p!OX4Vs/sHn[U5PM snupURUR:wa [ S5eUcUb [ S5eOeX44Vs/sHn[U5PM snup4UR U5nUR U*5nUR U5nUR U*5nUGbrU0:XGdkUS:XGdd[U5[La [U5S :XaU/UR-nO[U5UR:Xa[S U55(aO~[U5[La^[S UR555(a9UnS/UR-nU(aUR5upyXU'U(aMO[ S U-5e[U5upU RUR- n U(a6[U[ URU 5/U //5nUR U 5nOU nU nUR[ SU 55nO UR*n [!XU5upnXSU *4$s snfs snf) a(Return the minimization of ``c*x`` with the given constraints ``A*x <= b`` and ``A_eq*x = b_eq``. Unless bounds are given, variables will have nonnegative values in the solution. If ``A`` is not given, then the dimension of the system will be determined by the length of ``C``. By default, all variables will be nonnegative. If ``bounds`` is given as a single tuple, ``(lo, hi)``, then all variables will be constrained to be between ``lo`` and ``hi``. Use None for a ``lo`` or ``hi`` if it is unconstrained in the negative or positive direction, respectively, e.g. ``(None, 0)`` indicates nonpositive values. To set individual ranges, pass a list with length equal to the number of columns in ``A``, each element being a tuple; if only a few variables take on non-default values they can be passed as a dictionary with keys giving the corresponding column to which the variable is assigned, e.g. ``bounds={2: (1, 4)}`` would limit the 3rd variable to have a value in range ``[1, 4]``. Examples ======== >>> from sympy.solvers.simplex import linprog >>> from sympy import symbols, Eq, linear_eq_to_matrix as M, Matrix >>> x = x1, x2, x3, x4 = symbols('x1:5') >>> X = Matrix(x) >>> c, d = M(5*x2 + x3 + 4*x4 - x1, x) >>> a, b = M([5*x2 + 2*x3 + 5*x4 - (x1 + 5)], x) >>> aeq, beq = M([Eq(3*x2 + x4, 2), Eq(-x1 + x3 + 2*x4, 1)], x) >>> constr = [i <= j for i,j in zip(a*X, b)] >>> constr += [Eq(i, j) for i,j in zip(aeq*X, beq)] >>> linprog(c, a, b, aeq, beq) (9/2, [0, 1/2, 0, 1/2]) >>> assert all(i.subs(dict(zip(x, _[1]))) for i in constr) See Also ======== lpmin, lpmax r#C must be a single row.A and b must both be givenr'number of columns in A and C must matchN A_eq and b_eq must both be givenrCrc3n# UH+n[U5[L=(a [U5S:Hv M- g7frNtyperorkr=s rr?linprog..-+B:@QQ5 0SVq[0&35c3n# UH+n[U5[L=(a [U5S:Hv M- g7frrr=s rr?r0**(AQ5 0SVq[0(runexpected bounds %s)r rPrOrMrNr col_joinrrorkrQrvaluespopitemrrow_joinrL)rbr+rtA_eqb_eqrrVr&dbr'A_b_rrr[rZs rlinprogrsX q Avv{qvv{ CCvv{233 9: :Qqvvq!11$%6*6aq 6*vvBCC ||?@ @+/6AfQi6  JJt  JJu  JJt  JJu  Nflf .A <5 S[A%5X&F [AFF "s+B:@+B(B(B  &\T !c****'*'*B[166)Fzz|q "3f<= ='gg E!&&#./"67A 2AAA JJuQ} %vvgqQGA! #h;a+7s K,3K1c SSKJn [U5nURS:waURS:Xa UR nURS:wa [ S5eU(d>U(a [ S5e[SUR5[URS5p!OX4Vs/sHn[U5PM snupURUR:wa [ S5eUcUb [ S5eOX44Vs/sHn[U5PM snup4UbU0:XdUS:Xd[U5[La [U5S :XaU/UR-nO[U5UR:Xa[S U55(aO~[U5[La^[S UR555(a9Un S/UR-nU (aU R5upXU'U (aMO[ S U-5e[U"S URS--55n X{-S[X-U5VV s/sH upX:*PM sn n[X;-U5VV s/sHup[!X5PM sn n-p [#U5H<unupU bUR%XU :5 UcM&UR%XU:*5 M> X4$s snfs snfs sn nfs sn nf)Nr)symbolsr#rrrrrCrc3n# UH+n[U5[L=(a [U5S:Hv M- g7frrr=s rr?show_linprog..:rrc3n# UH+n[U5[L=(a [U5S:Hv M- g7frrr=s rr?r=rrrzx1:%s)sympyrr rPrOrMrNr rrorkrQrrrrrrUrT)rbr+rtrrrrrVr&rr'r|rlohis r show_linprogrsq Avv{qvv{ CCvv{233 9: :Qqvvq!11$%6*6aq 6*vvBCC ||?@ @+/6AfQi6  Nflf .A <5 S[A%5X&F [AFF "s+B:@+B(B(B  &\T !c****'*'*B[166)Fzz|q "3f<= =ww!&&(+,-A 3(Sa[1[caQT[1DFSWHX4YHXRWHX4YYa ( 8B > HHQT2X  > HHQT2X  ) 3JM+7,24Ys#K 9K;KK )NF)Fr/)T)NNNNN)+r sympy.corersympy.core.exprtoolsrsympy.core.relationalrrrsympy.core.singletonrsympy.core.symbolr sympy.core.sortingr $sympy.functions.elementary.complexesr sympy.matrices.denser r sympy.solvers.solvesetrsympy.utilities.iterablesrsympy.utilities.miscr Exceptionrr r,r8rLrqrurrrrrrrrrrrrr s=~-,,"#&5.66+ y &  * BM r+p+)\$0o=dod("VBJ#L!H2IjjX7r