Interactive Simplex Method¶
This module, meant for educational purposes only, supports learning and exploring of the simplex method.
Do you want to solve Linear Programs efficiently? use
MixedIntegerLinearProgram instead.
The methods implemented here allow solving Linear Programming Problems (LPPs) in a number of ways, may require explicit (and correct!) description of steps and are likely to be much slower than “regular” LP solvers. If, however, you want to learn how the simplex method works and see what happens in different situations using different strategies, but don’t want to deal with tedious arithmetic, this module is for you!
Historically it was created to complement the Math 373 course on Mathematical Programming and Optimization at the University of Alberta, Edmonton, Canada.
AUTHORS:
- Andrey Novoseltsev (2013-03-16): initial version. 
- Matthias Koeppe, Peijun Xiao (2015-07-05): allow different output styles. 
EXAMPLES:
Most of the module functionality is demonstrated on the following problem.
Using variables \(C\) and \(B\) for land used to grow corn and barley respectively, in acres, we can construct the following LP problem:
sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P
LP problem (use 'view(...)' or '%display typeset' for details)
>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P
LP problem (use 'view(...)' or '%display typeset' for details)
It is recommended to copy-paste such examples into your own worksheet, so that
you can run these commands with typeset mode on (%display typeset) and get
Since it has only two variables, we can solve it graphically:
sage: P.plot()                                                                      # needs sage.plot
Graphics object consisting of 19 graphics primitives
>>> from sage.all import *
>>> P.plot()                                                                      # needs sage.plot
Graphics object consisting of 19 graphics primitives
The simplex method can be applied only to problems in standard form, which can be created either directly
sage: InteractiveLPProblemStandardForm(A, b, c, ["C", "B"])
LP problem (use ...)
>>> from sage.all import *
>>> InteractiveLPProblemStandardForm(A, b, c, ["C", "B"])
LP problem (use ...)
or from an already constructed problem of “general type”:
sage: P = P.standard_form()
>>> from sage.all import *
>>> P = P.standard_form()
In this case the problem does not require any modifications to be written in standard form, but this step is still necessary to enable methods related to the simplex method.
The simplest way to use the simplex method is:
sage: P.run_simplex_method()
\begin{equation*}
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.
>>> from sage.all import *
>>> P.run_simplex_method()
\begin{equation*}
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.
(This method produces quite long formulas which have been omitted here.) But, of course, it is much more fun to do most of the steps by hand. Let’s start by creating the initial dictionary:
sage: D = P.initial_dictionary()
sage: D
LP problem dictionary (use ...)
>>> from sage.all import *
>>> D = P.initial_dictionary()
>>> D
LP problem dictionary (use ...)
Using typeset mode as recommended, you’ll see
With the initial or any other dictionary you can perform a number of checks:
sage: D.is_feasible()
True
sage: D.is_optimal()
False
>>> from sage.all import *
>>> D.is_feasible()
True
>>> D.is_optimal()
False
You can look at many of its pieces and associated data:
sage: D.basic_variables()
(x3, x4)
sage: D.basic_solution()
(0, 0)
sage: D.objective_value()
0
>>> from sage.all import *
>>> D.basic_variables()
(x3, x4)
>>> D.basic_solution()
(0, 0)
>>> D.objective_value()
0
Most importantly, you can perform steps of the simplex method by picking an entering variable, a leaving variable, and updating the dictionary:
sage: D.enter("C")
sage: D.leave(4)
sage: D.update()
>>> from sage.all import *
>>> D.enter("C")
>>> D.leave(Integer(4))
>>> D.update()
If everything was done correctly, the new dictionary is still feasible and the objective value did not decrease:
sage: D.is_feasible()
True
sage: D.objective_value()
5000
>>> from sage.all import *
>>> D.is_feasible()
True
>>> D.objective_value()
5000
If you are unsure about picking entering and leaving variables, you can use helper methods that will try their best to tell you what are your next options:
sage: D.possible_entering()
[B]
sage: D.possible_leaving()
Traceback (most recent call last):
...
ValueError: leaving variables can be determined
 for feasible dictionaries with a set entering variable
 or for dual feasible dictionaries
>>> from sage.all import *
>>> D.possible_entering()
[B]
>>> D.possible_leaving()
Traceback (most recent call last):
...
ValueError: leaving variables can be determined
 for feasible dictionaries with a set entering variable
 or for dual feasible dictionaries
It is also possible to obtain feasible sets
and final dictionaries of
problems, work with revised dictionaries,
and use the dual simplex method!
Note
Currently this does not have a display format for the terminal.
Classes and functions¶
- class sage.numerical.interactive_simplex_method.InteractiveLPProblem(A, b, c, x='x', constraint_type='<=', variable_type='', problem_type='max', base_ring=None, is_primal=True, objective_constant_term=0)[source]¶
- Bases: - SageObject- Construct an LP (Linear Programming) problem. - Note - This class is for educational purposes only: if you want to solve Linear Programs efficiently, use - MixedIntegerLinearPrograminstead.- This class supports LP problems with “variables on the left” constraints. - INPUT: - A– a matrix of constraint coefficients
- b– a vector of constraint constant terms
- c– a vector of objective coefficients
- x– (default:- 'x') a vector of decision variables or a string giving the base name
- constraint_type– (default:- '<=') a string specifying constraint type(s): either- '<=',- '>=',- '==', or a list of them
- variable_type– (default:- "") a string specifying variable type(s): either- '>=',- '<=',- ""(the empty string), or a list of them, corresponding, respectively, to nonnegative, nonpositive, and free variables
- problem_type– (default:- 'max') a string specifying the problem type:- 'max',- 'min',- '-max', or- '-min'
- base_ring– (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted
- is_primal– boolean (default:- True); whether this problem is primal or dual: each problem is of course dual to its own dual, this flag is mostly for internal use and affects default variable names only
- objective_constant_term– (default: 0) a constant term of the objective
 - EXAMPLES: - We will construct the following problem: \[\begin{split}\begin{array}{l} \begin{array}{lcrcrcl} \max \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 10 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} 5 B \mspace{-6mu} \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 1000 \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 3 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 1500 \\ \end{array} \\ C, B \geq 0 \end{array}\end{split}\]- sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') - Same problem, but more explicitly: - sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], ....: constraint_type='<=', variable_type='>=') - >>> from sage.all import * >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], ... constraint_type='<=', variable_type='>=') - Even more explicitly: - sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], problem_type='max', ....: constraint_type=["<=", "<="], variable_type=[">=", ">="]) - >>> from sage.all import * >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], problem_type='max', ... constraint_type=["<=", "<="], variable_type=[">=", ">="]) - Using the last form you should be able to represent any LP problem, as long as all like terms are collected and in constraints variables and constants are on different sides. - A()[source]¶
- Return coefficients of constraints of - self, i.e. \(A\).- OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.constraint_coefficients() [1 1] [3 1] sage: P.A() [1 1] [3 1] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.constraint_coefficients() [1 1] [3 1] >>> P.A() [1 1] [3 1] 
 - Abcx()[source]¶
- Return \(A\), \(b\), \(c\), and \(x\) of - selfas a tuple.- OUTPUT: a tuple - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (C, B) ) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (C, B) ) 
 - add_constraint(coefficients, constant_term, constraint_type='<=')[source]¶
- Return a new LP problem by adding a constraint to``self``. - INPUT: - coefficients– coefficients of the new constraint
- constant_term– a constant term of the new constraint
- constraint_type– (default:- '<=') a string indicating the constraint type of the new constraint
 - OUTPUT: an - LP problem- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c) sage: P1 = P.add_constraint(([2, 4]), 2000, "<=") sage: P1.Abcx() ( [1 1] [3 1] [2 4], (1000, 1500, 2000), (10, 5), (x1, x2) ) sage: P1.constraint_types() ('<=', '<=', '<=') sage: P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (x1, x2) ) sage: P.constraint_types() ('<=', '<=') sage: P2 = P.add_constraint(([2, 4, 6]), 2000, "<=") Traceback (most recent call last): ... TypeError: number of columns must be the same, not 2 and 3 sage: P3 = P.add_constraint(([2, 4]), 2000, "<") Traceback (most recent call last): ... ValueError: unknown constraint type - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c) >>> P1 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), "<=") >>> P1.Abcx() ( [1 1] [3 1] [2 4], (1000, 1500, 2000), (10, 5), (x1, x2) ) >>> P1.constraint_types() ('<=', '<=', '<=') >>> P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (x1, x2) ) >>> P.constraint_types() ('<=', '<=') >>> P2 = P.add_constraint(([Integer(2), Integer(4), Integer(6)]), Integer(2000), "<=") Traceback (most recent call last): ... TypeError: number of columns must be the same, not 2 and 3 >>> P3 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), "<") Traceback (most recent call last): ... ValueError: unknown constraint type 
 - b()[source]¶
- Return constant terms of constraints of - self, i.e. \(b\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.constant_terms() (1000, 1500) sage: P.b() (1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.constant_terms() (1000, 1500) >>> P.b() (1000, 1500) 
 - base_ring()[source]¶
- Return the base ring of - self.- Note - The base ring of LP problems is always a field. - OUTPUT: a ring - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.base_ring() Rational Field sage: c = (10, 5.) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.base_ring() Real Field with 53 bits of precision - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.base_ring() Rational Field >>> c = (Integer(10), RealNumber('5.')) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.base_ring() Real Field with 53 bits of precision 
 - c()[source]¶
- Return coefficients of the objective of - self, i.e. \(c\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.objective_coefficients() (10, 5) sage: P.c() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.objective_coefficients() (10, 5) >>> P.c() (10, 5) 
 - constant_terms()[source]¶
- Return constant terms of constraints of - self, i.e. \(b\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.constant_terms() (1000, 1500) sage: P.b() (1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.constant_terms() (1000, 1500) >>> P.b() (1000, 1500) 
 - constraint_coefficients()[source]¶
- Return coefficients of constraints of - self, i.e. \(A\).- OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.constraint_coefficients() [1 1] [3 1] sage: P.A() [1 1] [3 1] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.constraint_coefficients() [1 1] [3 1] >>> P.A() [1 1] [3 1] 
 - constraint_types()[source]¶
- Return a tuple listing the constraint types of all rows. - OUTPUT: a tuple of strings - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', constraint_type=["<=", "=="]) sage: P.constraint_types() ('<=', '==') - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', constraint_type=["<=", "=="]) >>> P.constraint_types() ('<=', '==') 
 - decision_variables()[source]¶
- Return decision variables of - self, i.e. \(x\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.decision_variables() (C, B) sage: P.x() (C, B) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.decision_variables() (C, B) >>> P.x() (C, B) 
 - dual(y=None)[source]¶
- Construct the dual LP problem for - self.- INPUT: - y– (default: depends on- style()) a vector of dual decision variables or a string giving the base name
 - OUTPUT: an - InteractiveLPProblem- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: DP = P.dual() sage: DP.b() == P.c() True sage: DP.dual(["C", "B"]) == P True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> DP = P.dual() >>> DP.b() == P.c() True >>> DP.dual(["C", "B"]) == P True 
 - feasible_set()[source]¶
- Return the feasible set of - self.- OUTPUT: a - Polyhedron- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.feasible_set() A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 4 vertices - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.feasible_set() A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 4 vertices 
 - is_bounded()[source]¶
- Check if - selfis bounded.- OUTPUT: - Trueif- selfis bounded,- Falseotherwise- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.is_bounded() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.is_bounded() True - Note that infeasible problems are always bounded: - sage: b = (-1000, 1500) sage: P = InteractiveLPProblem(A, b, c, variable_type='>=') sage: P.is_feasible() False sage: P.is_bounded() True - >>> from sage.all import * >>> b = (-Integer(1000), Integer(1500)) >>> P = InteractiveLPProblem(A, b, c, variable_type='>=') >>> P.is_feasible() False >>> P.is_bounded() True 
 - is_feasible(*x)[source]¶
- Check if - selfor given solution is feasible.- INPUT: - (optional) anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables 
 - OUTPUT: - Trueis this problem or given solution is feasible,- Falseotherwise
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, variable_type='>=') sage: P.is_feasible() True sage: P.is_feasible(100, 200) True sage: P.is_feasible(1000, 200) False sage: P.is_feasible([1000, 200]) False sage: P.is_feasible(1000) Traceback (most recent call last): ... TypeError: given input is not a solution for this problem - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, variable_type='>=') >>> P.is_feasible() True >>> P.is_feasible(Integer(100), Integer(200)) True >>> P.is_feasible(Integer(1000), Integer(200)) False >>> P.is_feasible([Integer(1000), Integer(200)]) False >>> P.is_feasible(Integer(1000)) Traceback (most recent call last): ... TypeError: given input is not a solution for this problem 
 - is_negative()[source]¶
- Return - Truewhen the problem is of type- '-max'or- '-min'.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.is_negative() False sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min') sage: P.is_negative() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.is_negative() False >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min') >>> P.is_negative() True 
 - is_optimal(*x)[source]¶
- Check if given solution is feasible. - INPUT: - anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables 
 - OUTPUT: - Trueif the given solution is optimal,- Falseotherwise- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (15, 5) sage: P = InteractiveLPProblem(A, b, c, variable_type='>=') sage: P.is_optimal(100, 200) False sage: P.is_optimal(500, 0) True sage: P.is_optimal(499, 3) True sage: P.is_optimal(501, -3) False - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(15), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, variable_type='>=') >>> P.is_optimal(Integer(100), Integer(200)) False >>> P.is_optimal(Integer(500), Integer(0)) True >>> P.is_optimal(Integer(499), Integer(3)) True >>> P.is_optimal(Integer(501), -Integer(3)) False 
 - is_primal()[source]¶
- Check if we consider this problem to be primal or dual. - This distinction affects only some automatically chosen variable names. - OUTPUT: boolean - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.is_primal() True sage: P.dual().is_primal() False - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.is_primal() True >>> P.dual().is_primal() False 
 - m()[source]¶
- Return the number of constraints of - self, i.e. \(m\).- OUTPUT: integer - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.n_constraints() 2 sage: P.m() 2 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.n_constraints() 2 >>> P.m() 2 
 - n()[source]¶
- Return the number of decision variables of - self, i.e. \(n\).- OUTPUT: integer - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.n_variables() 2 sage: P.n() 2 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.n_variables() 2 >>> P.n() 2 
 - n_constraints()[source]¶
- Return the number of constraints of - self, i.e. \(m\).- OUTPUT: integer - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.n_constraints() 2 sage: P.m() 2 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.n_constraints() 2 >>> P.m() 2 
 - n_variables()[source]¶
- Return the number of decision variables of - self, i.e. \(n\).- OUTPUT: integer - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.n_variables() 2 sage: P.n() 2 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.n_variables() 2 >>> P.n() 2 
 - objective_coefficients()[source]¶
- Return coefficients of the objective of - self, i.e. \(c\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.objective_coefficients() (10, 5) sage: P.c() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.objective_coefficients() (10, 5) >>> P.c() (10, 5) 
 - objective_constant_term()[source]¶
- Return the constant term of the objective. - OUTPUT: a number - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.objective_constant_term() 0 sage: P.optimal_value() 6250 sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], ....: variable_type='>=', objective_constant_term=-1250) sage: P.objective_constant_term() -1250 sage: P.optimal_value() 5000 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.objective_constant_term() 0 >>> P.optimal_value() 6250 >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], ... variable_type='>=', objective_constant_term=-Integer(1250)) >>> P.objective_constant_term() -1250 >>> P.optimal_value() 5000 
 - objective_value(*x)[source]¶
- Return the value of the objective on the given solution. - INPUT: - anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables 
 - OUTPUT: - the value of the objective on the given solution taking into account - objective_constant_term()and- is_negative()
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, variable_type='>=') sage: P.objective_value(100, 200) 2000 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, variable_type='>=') >>> P.objective_value(Integer(100), Integer(200)) 2000 
 - optimal_solution()[source]¶
- Return an optimal solution of - self.- OUTPUT: a vector or - Noneif there are no optimal solutions- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.optimal_solution() (250, 750) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.optimal_solution() (250, 750) 
 - optimal_value()[source]¶
- Return the optimal value for - self.- OUTPUT: - a number if the problem is bounded, \(\pm \infty\) if it is unbounded, or - Noneif it is infeasible
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.optimal_value() 6250 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.optimal_value() 6250 
 - plot(*args, **kwds)[source]¶
- Return a plot for solving - selfgraphically.- INPUT: - xmin,- xmax,- ymin,- ymax– bounds for the axes, if not given, an attempt will be made to pick reasonable values
- alpha– (default: 0.2) determines how opaque are shadows
 - OUTPUT: a plot - This only works for problems with two decision variables. On the plot the black arrow indicates the direction of growth of the objective. The lines perpendicular to it are level curves of the objective. If there are optimal solutions, the arrow originates in one of them and the corresponding level curve is solid: all points of the feasible set on it are optimal solutions. Otherwise the arrow is placed in the center. If the problem is infeasible or the objective is zero, a plot of the feasible set only is returned. - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: p = P.plot() # needs sage.plot sage: p.show() # needs sage.plot - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> p = P.plot() # needs sage.plot >>> p.show() # needs sage.plot - In this case the plot works better with the following axes ranges: - sage: p = P.plot(0, 1000, 0, 1500) # needs sage.plot sage: p.show() # needs sage.plot - >>> from sage.all import * >>> p = P.plot(Integer(0), Integer(1000), Integer(0), Integer(1500)) # needs sage.plot >>> p.show() # needs sage.plot 
 - plot_feasible_set(xmin=None, xmax=None, ymin=None, ymax=None, alpha=0.2)[source]¶
- Return a plot of the feasible set of - self.- INPUT: - xmin,- xmax,- ymin,- ymax– bounds for the axes, if not given, an attempt will be made to pick reasonable values
- alpha– (default: 0.2) determines how opaque are shadows
 - OUTPUT: a plot - This only works for a problem with two decision variables. The plot shows boundaries of constraints with a shadow on one side for inequalities. If the - feasible_set()is not empty and at least part of it is in the given boundaries, it will be shaded gray and \(F\) will be placed in its middle.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: p = P.plot_feasible_set() # needs sage.plot sage: p.show() # needs sage.plot - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> p = P.plot_feasible_set() # needs sage.plot >>> p.show() # needs sage.plot - In this case the plot works better with the following axes ranges: - sage: p = P.plot_feasible_set(0, 1000, 0, 1500) # needs sage.plot sage: p.show() # needs sage.plot - >>> from sage.all import * >>> p = P.plot_feasible_set(Integer(0), Integer(1000), Integer(0), Integer(1500)) # needs sage.plot >>> p.show() # needs sage.plot 
 - problem_type()[source]¶
- Return the problem type. - Needs to be used together with - is_negative.- OUTPUT: string, one of - 'max',- 'min'- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.problem_type() 'max' sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min') sage: P.problem_type() 'min' - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.problem_type() 'max' >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min') >>> P.problem_type() 'min' 
 - standard_form(transformation=False, **kwds)[source]¶
- Construct the LP problem in standard form equivalent to - self.- INPUT: - transformation– boolean (default:- False); if- True, a map converting solutions of the problem in standard form to the original one will be returned as well
- you can pass (as keywords only) - slack_variables,- auxiliary_variable,``objective_name`` to the constructor of- InteractiveLPProblemStandardForm
 - OUTPUT: - an - InteractiveLPProblemStandardFormby itself or a tuple with variable transformation as the second component
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, variable_type='>=') sage: DP = P.dual() sage: DPSF = DP.standard_form() sage: DPSF.b() (-10, -5) sage: DPSF.slack_variables() (y3, y4) sage: DPSF = DP.standard_form(slack_variables=["L", "F"]) sage: DPSF.slack_variables() (L, F) sage: DPSF, f = DP.standard_form(True) sage: f Vector space morphism represented by the matrix: [1 0] [0 1] Domain: Vector space of dimension 2 over Rational Field Codomain: Vector space of dimension 2 over Rational Field - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, variable_type='>=') >>> DP = P.dual() >>> DPSF = DP.standard_form() >>> DPSF.b() (-10, -5) >>> DPSF.slack_variables() (y3, y4) >>> DPSF = DP.standard_form(slack_variables=["L", "F"]) >>> DPSF.slack_variables() (L, F) >>> DPSF, f = DP.standard_form(True) >>> f Vector space morphism represented by the matrix: [1 0] [0 1] Domain: Vector space of dimension 2 over Rational Field Codomain: Vector space of dimension 2 over Rational Field - A more complicated transformation map: - sage: P = InteractiveLPProblem(A, b, c, variable_type=["<=", ""], ....: objective_constant_term=42) sage: PSF, f = P.standard_form(True) sage: f Vector space morphism represented by the matrix: [-1 0] [ 0 1] [ 0 -1] Domain: Vector space of dimension 3 over Rational Field Codomain: Vector space of dimension 2 over Rational Field sage: PSF.optimal_solution() (0, 1000, 0) sage: P.optimal_solution() (0, 1000) sage: P.is_optimal(PSF.optimal_solution()) Traceback (most recent call last): ... TypeError: given input is not a solution for this problem sage: P.is_optimal(f(PSF.optimal_solution())) True sage: PSF.optimal_value() 5042 sage: P.optimal_value() 5042 - >>> from sage.all import * >>> P = InteractiveLPProblem(A, b, c, variable_type=["<=", ""], ... objective_constant_term=Integer(42)) >>> PSF, f = P.standard_form(True) >>> f Vector space morphism represented by the matrix: [-1 0] [ 0 1] [ 0 -1] Domain: Vector space of dimension 3 over Rational Field Codomain: Vector space of dimension 2 over Rational Field >>> PSF.optimal_solution() (0, 1000, 0) >>> P.optimal_solution() (0, 1000) >>> P.is_optimal(PSF.optimal_solution()) Traceback (most recent call last): ... TypeError: given input is not a solution for this problem >>> P.is_optimal(f(PSF.optimal_solution())) True >>> PSF.optimal_value() 5042 >>> P.optimal_value() 5042 
 - variable_types()[source]¶
- Return a tuple listing the variable types of all decision variables. - OUTPUT: a tuple of strings - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type=[">=", ""]) sage: P.variable_types() ('>=', '') - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type=[">=", ""]) >>> P.variable_types() ('>=', '') 
 - x()[source]¶
- Return decision variables of - self, i.e. \(x\).- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') sage: P.decision_variables() (C, B) sage: P.x() (C, B) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=') >>> P.decision_variables() (C, B) >>> P.x() (C, B) 
 
- class sage.numerical.interactive_simplex_method.InteractiveLPProblemStandardForm(A, b, c, x='x', problem_type='max', slack_variables=None, auxiliary_variable=None, base_ring=None, is_primal=True, objective_name=None, objective_constant_term=0)[source]¶
- Bases: - InteractiveLPProblem- Construct an LP (Linear Programming) problem in standard form. - Note - This class is for educational purposes only: if you want to solve Linear Programs efficiently, use - MixedIntegerLinearPrograminstead.- The used standard form is: \[\begin{split}\begin{array}{l} \pm \max cx \\ Ax \leq b \\ x \geq 0 \end{array}\end{split}\]- INPUT: - A– a matrix of constraint coefficients
- b– a vector of constraint constant terms
- c– a vector of objective coefficients
- x– (default:- 'x') a vector of decision variables or a string the base name giving
- problem_type– (default:- 'max') a string specifying the problem type: either- 'max'or- '-max'
- slack_variables– (default: depends on- style()) a vector of slack variables or a string giving the base name
- auxiliary_variable– (default: same as- xparameter with adjoined- '0'if it was given as a string, otherwise- 'x0') the auxiliary name, expected to be the same as the first decision variable for auxiliary problems
- base_ring– (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted
- is_primal– boolean (default:- True); whether this problem is primal or dual: each problem is of course dual to its own dual, this flag is mostly for internal use and affects default variable names only
- objective_name– string or symbolic expression for the objective used in dictionaries (default: depends on- style())
- objective_constant_term– (default: 0) a constant term of the objective
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) - Unlike - InteractiveLPProblem, this class does not allow you to adjust types of constraints (they are always- '<=') and variables (they are always- '>='), and the problem type may only be- 'max'or- '-max'. You may give custom names to slack and auxiliary variables, but in most cases defaults should work:- sage: P.decision_variables() (x1, x2) sage: P.slack_variables() (x3, x4) - >>> from sage.all import * >>> P.decision_variables() (x1, x2) >>> P.slack_variables() (x3, x4) - add_constraint(coefficients, constant_term, slack_variable=None)[source]¶
- Return a new LP problem by adding a constraint to``self``. - INPUT: - coefficients– coefficients of the new constraint
- constant_term– a constant term of the new constraint
- slack_variable– (default: depends on- style()) a string giving the name of the slack variable of the new constraint
 - OUTPUT: an - LP problem in standard form- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (x1, x2) ) sage: P.slack_variables() (x3, x4) sage: P1 = P.add_constraint(([2, 4]), 2000) sage: P1.Abcx() ( [1 1] [3 1] [2 4], (1000, 1500, 2000), (10, 5), (x1, x2) ) sage: P1.slack_variables() (x3, x4, x5) sage: P2 = P.add_constraint(([2, 4]), 2000, slack_variable='c') sage: P2.slack_variables() (x3, x4, c) sage: P3 = P.add_constraint(([2, 4, 6]), 2000) Traceback (most recent call last): ... TypeError: number of columns must be the same, not 2 and 3 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.Abcx() ( [1 1] [3 1], (1000, 1500), (10, 5), (x1, x2) ) >>> P.slack_variables() (x3, x4) >>> P1 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000)) >>> P1.Abcx() ( [1 1] [3 1] [2 4], (1000, 1500, 2000), (10, 5), (x1, x2) ) >>> P1.slack_variables() (x3, x4, x5) >>> P2 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), slack_variable='c') >>> P2.slack_variables() (x3, x4, c) >>> P3 = P.add_constraint(([Integer(2), Integer(4), Integer(6)]), Integer(2000)) Traceback (most recent call last): ... TypeError: number of columns must be the same, not 2 and 3 
 - auxiliary_problem(objective_name=None)[source]¶
- Construct the auxiliary problem for - self.- INPUT: - objective_name– string or symbolic expression for the objective used in dictionaries (default: depends on- style())
 - OUTPUT: an - LP problem in standard form- The auxiliary problem with the auxiliary variable \(x_0\) is \[\begin{split}\begin{array}{l} \max - x_0 \\ - x_0 + A_i x \leq b_i \text{ for all } i \\ x \geq 0 \end{array}\ .\end{split}\]- Such problems are used when the - initial_dictionary()is infeasible.- EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: AP = P.auxiliary_problem() - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> AP = P.auxiliary_problem() 
 - auxiliary_variable()[source]¶
- Return the auxiliary variable of - self.- Note that the auxiliary variable may or may not be among - decision_variables().- OUTPUT: a variable of the - coordinate_ring()of- self- EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.auxiliary_variable() x0 sage: P.decision_variables() (x1, x2) sage: AP = P.auxiliary_problem() sage: AP.auxiliary_variable() x0 sage: AP.decision_variables() (x0, x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.auxiliary_variable() x0 >>> P.decision_variables() (x1, x2) >>> AP = P.auxiliary_problem() >>> AP.auxiliary_variable() x0 >>> AP.decision_variables() (x0, x1, x2) 
 - coordinate_ring()[source]¶
- Return the coordinate ring of - self.- OUTPUT: - a polynomial ring over the - base_ring()of- selfin the- auxiliary_variable(),- decision_variables(), and- slack_variables()with “neglex” order
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4, x5 over Rational Field sage: P.base_ring() Rational Field sage: P.auxiliary_variable() x0 sage: P.decision_variables() (x1, x2) sage: P.slack_variables() (x3, x4, x5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4, x5 over Rational Field >>> P.base_ring() Rational Field >>> P.auxiliary_variable() x0 >>> P.decision_variables() (x1, x2) >>> P.slack_variables() (x3, x4, x5) 
 - dictionary(*x_B)[source]¶
- Construct a dictionary for - selfwith given basic variables.- INPUT: - basic variables for the dictionary to be constructed 
 - OUTPUT: a - dictionary- Note - This is a synonym for - self.revised_dictionary(x_B).dictionary(), but basic variables are mandatory.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary("x1", "x2") sage: D.basic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary("x1", "x2") >>> D.basic_variables() (x1, x2) 
 - feasible_dictionary(auxiliary_dictionary)[source]¶
- Construct a feasible dictionary for - self.- INPUT: - auxiliary_dictionary– an optimal dictionary for the- auxiliary_problem()of- selfwith the optimal value \(0\) and a non-basic auxiliary variable
 - OUTPUT: a feasible - dictionaryfor- self- EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: AP = P.auxiliary_problem() sage: D = AP.initial_dictionary() sage: D.enter(0) sage: D.leave(5) sage: D.update() sage: D.enter(1) sage: D.leave(0) sage: D.update() sage: D.is_optimal() True sage: D.objective_value() 0 sage: D.basic_solution() (0, 400, 0) sage: D = P.feasible_dictionary(D) sage: D.is_optimal() False sage: D.is_feasible() True sage: D.objective_value() 4000 sage: D.basic_solution() (400, 0) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> AP = P.auxiliary_problem() >>> D = AP.initial_dictionary() >>> D.enter(Integer(0)) >>> D.leave(Integer(5)) >>> D.update() >>> D.enter(Integer(1)) >>> D.leave(Integer(0)) >>> D.update() >>> D.is_optimal() True >>> D.objective_value() 0 >>> D.basic_solution() (0, 400, 0) >>> D = P.feasible_dictionary(D) >>> D.is_optimal() False >>> D.is_feasible() True >>> D.objective_value() 4000 >>> D.basic_solution() (400, 0) 
 - final_dictionary()[source]¶
- Return the final dictionary of the simplex method applied to - self.- See - run_simplex_method()for the description of possibilities.- OUTPUT: a - dictionary- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.final_dictionary() sage: D.is_optimal() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.final_dictionary() >>> D.is_optimal() True 
 - final_revised_dictionary()[source]¶
- Return the final dictionary of the revised simplex method applied to - self.- See - run_revised_simplex_method()for the description of possibilities.- OUTPUT: a - revised dictionary- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.final_revised_dictionary() sage: D.is_optimal() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.final_revised_dictionary() >>> D.is_optimal() True 
 - initial_dictionary()[source]¶
- Construct the initial dictionary of - self.- The initial dictionary “defines” - slack_variables()in terms of the- decision_variables(), i.e. it has slack variables as basic ones.- OUTPUT: a - dictionary- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() 
 - inject_variables(scope=None, verbose=True)[source]¶
- Inject variables of - selfinto- scope.- INPUT: - scope– namespace (default: global)
- verbose– if- True(default), names of injected variables will be printed
 - OUTPUT: none - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: 3*x1 + x2 x2 + 3*x1 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> Integer(3)*x1 + x2 x2 + 3*x1 
 - objective_name()[source]¶
- Return the objective name used in dictionaries for this problem. - OUTPUT: a symbolic expression - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.objective_name() z sage: sage.numerical.interactive_simplex_method.style("Vanderbei") 'Vanderbei' sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.objective_name() zeta sage: sage.numerical.interactive_simplex_method.style("UAlberta") 'UAlberta' sage: P = InteractiveLPProblemStandardForm(A, b, c, objective_name='custom') sage: P.objective_name() custom - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.objective_name() z >>> sage.numerical.interactive_simplex_method.style("Vanderbei") 'Vanderbei' >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.objective_name() zeta >>> sage.numerical.interactive_simplex_method.style("UAlberta") 'UAlberta' >>> P = InteractiveLPProblemStandardForm(A, b, c, objective_name='custom') >>> P.objective_name() custom 
 - static random_element(m, n, bound=5, special_probability=0.2, **kwds)[source]¶
- Construct a random - InteractiveLPProblemStandardForm.- INPUT: - m– the number of constraints/basic variables
- n– the number of decision/non-basic variables
- bound– (default: 5) a bound on coefficients
- special_probability– (default: 0.2) probability of constructing a problem whose initial dictionary is allowed to be primal infeasible or dual feasible
 - All other keyword arguments are passed to the constructor. - EXAMPLES: - sage: InteractiveLPProblemStandardForm.random_element(3, 4) LP problem (use 'view(...)' or '%display typeset' for details) - >>> from sage.all import * >>> InteractiveLPProblemStandardForm.random_element(Integer(3), Integer(4)) LP problem (use 'view(...)' or '%display typeset' for details) 
 - revised_dictionary(*x_B)[source]¶
- Construct a revised dictionary for - self.- INPUT: - basic variables for the dictionary to be constructed; if not given, - slack_variables()will be used, perhaps with the- auxiliary_variable()to give a feasible dictionary
 - OUTPUT: a - revised dictionary- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary("x1", "x2") sage: D.basic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary("x1", "x2") >>> D.basic_variables() (x1, x2) - If basic variables are not given the initial dictionary is constructed: - sage: P.revised_dictionary().basic_variables() (x3, x4) sage: P.initial_dictionary().basic_variables() (x3, x4) - >>> from sage.all import * >>> P.revised_dictionary().basic_variables() (x3, x4) >>> P.initial_dictionary().basic_variables() (x3, x4) - Unless it is infeasible, in which case a feasible dictionary for the auxiliary problem is constructed: - sage: A = ([1, 1], [3, 1], [-1,-1]) sage: b = (1000, 1500, -400) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.initial_dictionary().is_feasible() False sage: P.revised_dictionary().basic_variables() (x3, x4, x0) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1),-Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.initial_dictionary().is_feasible() False >>> P.revised_dictionary().basic_variables() (x3, x4, x0) 
 - run_revised_simplex_method()[source]¶
- Apply the revised simplex method and return all steps. - OUTPUT: - HtmlFragmentwith HTML/\(\LaTeX\) code of all encountered dictionaries
 - Note - You can access the - final_revised_dictionary(), which can be one of the following:- an optimal dictionary with the - auxiliary_variable()among- basic_variables()and a nonzero optimal value indicating that- selfis infeasible;
- a non-optimal dictionary that has marked entering variable for which there is no choice of the leaving variable, indicating that - selfis unbounded;
- an optimal dictionary. 
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.run_revised_simplex_method() \begin{equation*} ... \end{equation*} Entering: $x_{1}$. Leaving: $x_{0}$. \begin{equation*} ... \end{equation*} Entering: $x_{5}$. Leaving: $x_{4}$. \begin{equation*} ... \end{equation*} Entering: $x_{2}$. Leaving: $x_{3}$. \begin{equation*} ... \end{equation*} The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$. - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.run_revised_simplex_method() \begin{equation*} ... \end{equation*} Entering: $x_{1}$. Leaving: $x_{0}$. \begin{equation*} ... \end{equation*} Entering: $x_{5}$. Leaving: $x_{4}$. \begin{equation*} ... \end{equation*} Entering: $x_{2}$. Leaving: $x_{3}$. \begin{equation*} ... \end{equation*} The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$. 
 - run_simplex_method()[source]¶
- Apply the simplex method and return all steps and intermediate states. - OUTPUT: - HtmlFragmentwith HTML/\(\LaTeX\) code of all encountered dictionaries
 - Note - You can access the - final_dictionary(), which can be one of the following:- an optimal dictionary for the - auxiliary_problem()with a nonzero optimal value indicating that- selfis infeasible;
- a non-optimal dictionary for - selfthat has marked entering variable for which there is no choice of the leaving variable, indicating that- selfis unbounded;
- an optimal dictionary for - self.
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.run_simplex_method() \begin{equation*} ... \end{equation*} The initial dictionary is infeasible, solving auxiliary problem. ... Entering: $x_{0}$. Leaving: $x_{5}$. ... Entering: $x_{1}$. Leaving: $x_{0}$. ... Back to the original problem. ... Entering: $x_{5}$. Leaving: $x_{4}$. ... Entering: $x_{2}$. Leaving: $x_{3}$. ... The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$. - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.run_simplex_method() \begin{equation*} ... \end{equation*} The initial dictionary is infeasible, solving auxiliary problem. ... Entering: $x_{0}$. Leaving: $x_{5}$. ... Entering: $x_{1}$. Leaving: $x_{0}$. ... Back to the original problem. ... Entering: $x_{5}$. Leaving: $x_{4}$. ... Entering: $x_{2}$. Leaving: $x_{3}$. ... The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$. 
 - slack_variables()[source]¶
- Return slack variables of - self.- Slack variables are differences between the constant terms and left hand sides of the constraints. - If you want to give custom names to slack variables, you have to do so during construction of the problem. - OUTPUT: a tuple - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: P.slack_variables() (x3, x4) sage: P = InteractiveLPProblemStandardForm(A, b, c, ["C", "B"], ....: slack_variables=["L", "F"]) sage: P.slack_variables() (L, F) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> P.slack_variables() (x3, x4) >>> P = InteractiveLPProblemStandardForm(A, b, c, ["C", "B"], ... slack_variables=["L", "F"]) >>> P.slack_variables() (L, F) 
 
- class sage.numerical.interactive_simplex_method.LPAbstractDictionary[source]¶
- Bases: - SageObject- Abstract base class for dictionaries for LP problems. - Instantiating this class directly is meaningless, see - LPDictionaryand- LPRevisedDictionaryfor useful extensions.- add_row(nonbasic_coefficients, constant, basic_variable=None)[source]¶
- Return a dictionary with an additional row based on a given dictionary. - INPUT: - nonbasic_coefficients– list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)
- constant– the constant term for the new row
- basic_variable– (default: depends on- style()) a string giving the name of the basic variable of the new row
 - OUTPUT: a new dictionary of the same class - EXAMPLES: - sage: A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12]) sage: b = (2, 17, 6) sage: c = (55/10, 21/10, 14/30) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary("x1", "x2", "x4") sage: D1 = D.add_row([7, 11, 19], 42, basic_variable='c') sage: D1.row_coefficients("c") (7, 11, 19) - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1), Integer(7)], [Integer(8), Integer(2), Integer(13)], [Integer(34), Integer(17), Integer(12)]) >>> b = (Integer(2), Integer(17), Integer(6)) >>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10), Integer(14)/Integer(30)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary("x1", "x2", "x4") >>> D1 = D.add_row([Integer(7), Integer(11), Integer(19)], Integer(42), basic_variable='c') >>> D1.row_coefficients("c") (7, 11, 19) 
 - base_ring()[source]¶
- Return the base ring of - self, i.e. the ring of coefficients.- OUTPUT: a ring - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.base_ring() Rational Field sage: D = P.revised_dictionary() sage: D.base_ring() Rational Field - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.base_ring() Rational Field >>> D = P.revised_dictionary() >>> D.base_ring() Rational Field 
 - basic_solution(include_slack_variables=False)[source]¶
- Return the basic solution of - self.- The basic solution associated to a dictionary is obtained by setting to zero all - nonbasic_variables(), in which case- basic_variables()have to be equal to- constant_terms()in equations. It may refer to values of- decision_variables()only or include- slack_variables()as well.- INPUT: - include_slack_variables– boolean (default:- False); if- True, values of slack variables will be appended at the end
 - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.basic_solution() (0, 0) sage: D.basic_solution(True) (0, 0, 1000, 1500) sage: D = P.revised_dictionary() sage: D.basic_solution() (0, 0) sage: D.basic_solution(True) (0, 0, 1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.basic_solution() (0, 0) >>> D.basic_solution(True) (0, 0, 1000, 1500) >>> D = P.revised_dictionary() >>> D.basic_solution() (0, 0) >>> D.basic_solution(True) (0, 0, 1000, 1500) 
 - basic_variables()[source]¶
- Return the basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.basic_variables() (x3, x4) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.basic_variables() (x3, x4) 
 - column_coefficients(v)[source]¶
- Return the coefficients of a nonbasic variable. - INPUT: - v– a nonbasic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector of coefficients of a nonbasic variable - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.column_coefficients(1) (1, 3) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.column_coefficients(Integer(1)) (1, 3) 
 - constant_terms()[source]¶
- Return the constant terms of relations of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.constant_terms() (1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.constant_terms() (1000, 1500) 
 - coordinate_ring()[source]¶
- Return the coordinate ring of - self.- OUTPUT: - a polynomial ring in - auxiliary_variable(),- decision_variables(), and- slack_variables()of- selfover the- base_ring()
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4 over Rational Field sage: D = P.revised_dictionary() sage: D.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4 over Rational Field - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4 over Rational Field >>> D = P.revised_dictionary() >>> D.coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3, x4 over Rational Field 
 - dual_ratios()[source]¶
- Return ratios used to determine the entering variable based on leaving. - OUTPUT: - A list of pairs \((r_j, x_j)\) where \(x_j\) is a non-basic variable and \(r_j = c_j / a_{ij}\) is the ratio of the objective coefficient \(c_j\) to the coefficient \(a_{ij}\) of \(x_j\) in the relation for the leaving variable \(x_i\): \[x_i = b_i - \cdots - a_{ij} x_j - \cdots.\]- The order of pairs matches the order of - nonbasic_variables(), but only \(x_j\) with negative \(a_{ij}\) are considered.
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary(2, 3, 5) sage: D.leave(3) sage: D.dual_ratios() [(5/2, x1), (5, x4)] sage: D = P.revised_dictionary(2, 3, 5) sage: D.leave(3) sage: D.dual_ratios() [(5/2, x1), (5, x4)] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary(Integer(2), Integer(3), Integer(5)) >>> D.leave(Integer(3)) >>> D.dual_ratios() [(5/2, x1), (5, x4)] >>> D = P.revised_dictionary(Integer(2), Integer(3), Integer(5)) >>> D.leave(Integer(3)) >>> D.dual_ratios() [(5/2, x1), (5, x4)] 
 - enter(v)[source]¶
- Set - vas the entering variable of- self.- INPUT: - v– a non-basic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable. It is also possible to enter- Noneto reset choice.
 - OUTPUT: - none, but the selected variable will be used as entering by methods that require an entering variable and the corresponding column will be typeset in green 
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.enter("x1") - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.enter("x1") - We can also use indices of variables: - sage: D.enter(1) - >>> from sage.all import * >>> D.enter(Integer(1)) - Or variable names without quotes after injecting them: - sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: D.enter(x1) - >>> from sage.all import * >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> D.enter(x1) - The same works for revised dictionaries as well: - sage: D = P.revised_dictionary() sage: D.enter(x1) - >>> from sage.all import * >>> D = P.revised_dictionary() >>> D.enter(x1) 
 - entering()[source]¶
- Return the currently chosen entering variable. - OUTPUT: a variable if the entering one was chosen, otherwise - None- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.entering() is None True sage: D.enter(1) sage: D.entering() x1 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.entering() is None True >>> D.enter(Integer(1)) >>> D.entering() x1 
 - entering_coefficients()[source]¶
- Return coefficients of the entering variable. - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.enter(1) sage: D.entering_coefficients() (1, 3) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.enter(Integer(1)) >>> D.entering_coefficients() (1, 3) 
 - is_dual_feasible()[source]¶
- Check if - selfis dual feasible.- OUTPUT: - Trueif all- objective_coefficients()are nonpositive,- Falseotherwise
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.is_dual_feasible() False sage: D = P.revised_dictionary() sage: D.is_dual_feasible() False - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.is_dual_feasible() False >>> D = P.revised_dictionary() >>> D.is_dual_feasible() False 
 - is_feasible()[source]¶
- Check if - selfis feasible.- OUTPUT: - Trueif all- constant_terms()are nonnegative,- Falseotherwise
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.is_feasible() True sage: D = P.revised_dictionary() sage: D.is_feasible() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.is_feasible() True >>> D = P.revised_dictionary() >>> D.is_feasible() True 
 - is_optimal()[source]¶
- Check if - selfis optimal.- OUTPUT: - Trueif- self- is_feasible()and- is_dual_feasible()(i.e. all- constant_terms()are nonnegative and all- objective_coefficients()are nonpositive),- Falseotherwise.
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.is_optimal() False sage: D = P.revised_dictionary() sage: D.is_optimal() False sage: D = P.revised_dictionary(1, 2) sage: D.is_optimal() True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.is_optimal() False >>> D = P.revised_dictionary() >>> D.is_optimal() False >>> D = P.revised_dictionary(Integer(1), Integer(2)) >>> D.is_optimal() True 
 - leave(v)[source]¶
- Set - vas the leaving variable of- self.- INPUT: - v– a basic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable. It is also possible to leave- Noneto reset choice.
 - OUTPUT: - none, but the selected variable will be used as leaving by methods that require a leaving variable and the corresponding row will be typeset in red 
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.leave("x4") - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.leave("x4") - We can also use indices of variables: - sage: D.leave(4) - >>> from sage.all import * >>> D.leave(Integer(4)) - Or variable names without quotes after injecting them: - sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: D.leave(x4) - >>> from sage.all import * >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> D.leave(x4) - The same works for revised dictionaries as well: - sage: D = P.revised_dictionary() sage: D.leave(x4) - >>> from sage.all import * >>> D = P.revised_dictionary() >>> D.leave(x4) 
 - leaving()[source]¶
- Return the currently chosen leaving variable. - OUTPUT: a variable if the leaving one was chosen, otherwise - None- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.leaving() is None True sage: D.leave(4) sage: D.leaving() x4 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.leaving() is None True >>> D.leave(Integer(4)) >>> D.leaving() x4 
 - leaving_coefficients()[source]¶
- Return coefficients of the leaving variable. - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary(2, 3) sage: D.leave(3) sage: D.leaving_coefficients() (-2, -1) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary(Integer(2), Integer(3)) >>> D.leave(Integer(3)) >>> D.leaving_coefficients() (-2, -1) - The same works for revised dictionaries as well: - sage: D = P.revised_dictionary(2, 3) sage: D.leave(3) sage: D.leaving_coefficients() (-2, -1) - >>> from sage.all import * >>> D = P.revised_dictionary(Integer(2), Integer(3)) >>> D.leave(Integer(3)) >>> D.leaving_coefficients() (-2, -1) 
 - nonbasic_variables()[source]¶
- Return non-basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.nonbasic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.nonbasic_variables() (x1, x2) 
 - objective_coefficients()[source]¶
- Return coefficients of the objective of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_coefficients() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_coefficients() (10, 5) 
 - objective_name()[source]¶
- Return the objective name of - self.- OUTPUT: a symbolic expression - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_name() z - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_name() z 
 - objective_value()[source]¶
- Return the value of the objective at the - basic_solution()of- self.- OUTPUT: a number - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_value() 0 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_value() 0 
 - possible_dual_simplex_method_steps()[source]¶
- Return possible dual simplex method steps for - self.- OUTPUT: - A list of pairs - (leaving, entering), where- leavingis a basic variable that may- leave()and- enteringis a list of non-basic variables that may- enter()when- leavingleaves. Note that- enteringmay be empty, indicating that the problem is infeasible (since the dual one is unbounded).
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary(2, 3) sage: D.possible_dual_simplex_method_steps() [(x3, [x1])] sage: D = P.revised_dictionary(2, 3) sage: D.possible_dual_simplex_method_steps() [(x3, [x1])] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary(Integer(2), Integer(3)) >>> D.possible_dual_simplex_method_steps() [(x3, [x1])] >>> D = P.revised_dictionary(Integer(2), Integer(3)) >>> D.possible_dual_simplex_method_steps() [(x3, [x1])] 
 - possible_entering()[source]¶
- Return possible entering variables for - self.- OUTPUT: - a list of non-basic variables of - selfthat can- enter()on the next step of the (dual) simplex method
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.possible_entering() [x1, x2] sage: D = P.revised_dictionary() sage: D.possible_entering() [x1, x2] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.possible_entering() [x1, x2] >>> D = P.revised_dictionary() >>> D.possible_entering() [x1, x2] 
 - possible_leaving()[source]¶
- Return possible leaving variables for - self.- OUTPUT: - a list of basic variables of - selfthat can- leave()on the next step of the (dual) simplex method
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.enter(1) sage: D.possible_leaving() [x4] sage: D = P.revised_dictionary() sage: D.enter(1) sage: D.possible_leaving() [x4] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.enter(Integer(1)) >>> D.possible_leaving() [x4] >>> D = P.revised_dictionary() >>> D.enter(Integer(1)) >>> D.possible_leaving() [x4] 
 - possible_simplex_method_steps()[source]¶
- Return possible simplex method steps for - self.- OUTPUT: - A list of pairs - (entering, leaving), where- enteringis a non-basic variable that may- enter()and- leavingis a list of basic variables that may- leave()when- enteringenters. Note that- leavingmay be empty, indicating that the problem is unbounded.
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.possible_simplex_method_steps() [(x1, [x4]), (x2, [x3])] sage: D = P.revised_dictionary() sage: D.possible_simplex_method_steps() [(x1, [x4]), (x2, [x3])] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.possible_simplex_method_steps() [(x1, [x4]), (x2, [x3])] >>> D = P.revised_dictionary() >>> D.possible_simplex_method_steps() [(x1, [x4]), (x2, [x3])] 
 - ratios()[source]¶
- Return ratios used to determine the leaving variable based on entering. - OUTPUT: - A list of pairs \((r_i, x_i)\) where \(x_i\) is a basic variable and \(r_i = b_i / a_{ik}\) is the ratio of the constant term \(b_i\) to the coefficient \(a_{ik}\) of the entering variable \(x_k\) in the relation for \(x_i\): \[x_i = b_i - \cdots - a_{ik} x_k - \cdots.\]- The order of pairs matches the order of - basic_variables(), but only \(x_i\) with positive \(a_{ik}\) are considered.
 - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.enter(1) sage: D.ratios() [(1000, x3), (500, x4)] sage: D = P.revised_dictionary() sage: D.enter(1) sage: D.ratios() [(1000, x3), (500, x4)] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.enter(Integer(1)) >>> D.ratios() [(1000, x3), (500, x4)] >>> D = P.revised_dictionary() >>> D.enter(Integer(1)) >>> D.ratios() [(1000, x3), (500, x4)] 
 - row_coefficients(v)[source]¶
- Return the coefficients of the basic variable - v.- These are the coefficients with which nonbasic variables are subtracted in the relation for - v.- INPUT: - v– a basic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector of coefficients of a basic variable - EXAMPLES: - sage: A = ([-1, 1], [8, 2]) sage: b = (2, 17) sage: c = (55/10, 21/10) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.final_dictionary() sage: D.row_coefficients("x1") (1/10, -1/5) - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)]) >>> b = (Integer(2), Integer(17)) >>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.final_dictionary() >>> D.row_coefficients("x1") (1/10, -1/5) - We can also use indices of variables: - sage: D.row_coefficients(1) (1/10, -1/5) - >>> from sage.all import * >>> D.row_coefficients(Integer(1)) (1/10, -1/5) - Or use variable names without quotes after injecting them: - sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: D.row_coefficients(x1) (1/10, -1/5) - >>> from sage.all import * >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> D.row_coefficients(x1) (1/10, -1/5) 
 - run_dual_simplex_method()[source]¶
- Apply the dual simplex method and return all steps/intermediate states. - If either entering or leaving variables were already set, they will be used. - OUTPUT: - HtmlFragmentwith HTML/\(\LaTeX\) code of all encountered dictionaries
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.run_dual_simplex_method() Traceback (most recent call last): ... ValueError: leaving variables can be determined for feasible dictionaries with a set entering variable or for dual feasible dictionaries - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.run_dual_simplex_method() Traceback (most recent call last): ... ValueError: leaving variables can be determined for feasible dictionaries with a set entering variable or for dual feasible dictionaries - Let’s start with a dual feasible dictionary then: - sage: D = P.dictionary(2, 3, 5) sage: D.is_dual_feasible() True sage: D.is_optimal() False sage: D.run_dual_simplex_method() \begin{equation*} ... \end{equation*} Leaving: $x_{3}$. Entering: $x_{1}$. \begin{equation*} ... \end{equation*} sage: D.is_optimal() True - >>> from sage.all import * >>> D = P.dictionary(Integer(2), Integer(3), Integer(5)) >>> D.is_dual_feasible() True >>> D.is_optimal() False >>> D.run_dual_simplex_method() \begin{equation*} ... \end{equation*} Leaving: $x_{3}$. Entering: $x_{1}$. \begin{equation*} ... \end{equation*} >>> D.is_optimal() True - This method detects infeasible problems: - sage: A = ([1, 0],) sage: b = (-1,) sage: c = (0, -1) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.run_dual_simplex_method() \begin{equation*} ... \end{equation*} The problem is infeasible because of $x_{3}$ constraint. - >>> from sage.all import * >>> A = ([Integer(1), Integer(0)],) >>> b = (-Integer(1),) >>> c = (Integer(0), -Integer(1)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.run_dual_simplex_method() \begin{equation*} ... \end{equation*} The problem is infeasible because of $x_{3}$ constraint. 
 - run_simplex_method()[source]¶
- Apply the simplex method and return all steps and intermediate states. - If either entering or leaving variables were already set, they will be used. - OUTPUT: - HtmlFragmentwith HTML/\(\LaTeX\) code of all encountered dictionaries
 - EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.run_simplex_method() Traceback (most recent call last): ... ValueError: entering variables can be determined for feasible dictionaries or for dual feasible dictionaries with a set leaving variable - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.run_simplex_method() Traceback (most recent call last): ... ValueError: entering variables can be determined for feasible dictionaries or for dual feasible dictionaries with a set leaving variable - Let’s start with a feasible dictionary then: - sage: D = P.dictionary(1, 3, 4) sage: D.is_feasible() True sage: D.is_optimal() False sage: D.run_simplex_method() \begin{equation*} ... \end{equation*} Entering: $x_{5}$. Leaving: $x_{4}$. \begin{equation*} ... \end{equation*} Entering: $x_{2}$. Leaving: $x_{3}$. \begin{equation*} ... \end{equation*} sage: D.is_optimal() True - >>> from sage.all import * >>> D = P.dictionary(Integer(1), Integer(3), Integer(4)) >>> D.is_feasible() True >>> D.is_optimal() False >>> D.run_simplex_method() \begin{equation*} ... \end{equation*} Entering: $x_{5}$. Leaving: $x_{4}$. \begin{equation*} ... \end{equation*} Entering: $x_{2}$. Leaving: $x_{3}$. \begin{equation*} ... \end{equation*} >>> D.is_optimal() True - This method detects unbounded problems: - sage: A = ([1, 0],) sage: b = (1,) sage: c = (0, 1) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.run_simplex_method() \begin{equation*} ... \end{equation*} The problem is unbounded in $x_{2}$ direction. - >>> from sage.all import * >>> A = ([Integer(1), Integer(0)],) >>> b = (Integer(1),) >>> c = (Integer(0), Integer(1)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.run_simplex_method() \begin{equation*} ... \end{equation*} The problem is unbounded in $x_{2}$ direction. 
 - update()[source]¶
- Update - selfusing previously set entering and leaving variables.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_value() 0 sage: D.enter("x1") sage: D.leave("x4") sage: D.update() sage: D.objective_value() 5000 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_value() 0 >>> D.enter("x1") >>> D.leave("x4") >>> D.update() >>> D.objective_value() 5000 
 
- class sage.numerical.interactive_simplex_method.LPDictionary(A, b, c, objective_value, basic_variables, nonbasic_variables, objective_name)[source]¶
- Bases: - LPAbstractDictionary- Construct a dictionary for an LP problem. - A dictionary consists of the following data: \[\begin{split}\begin{array}{|l|} \hline x_B = b - A x_N\\ \hline z = z^* + c x_N\\ \hline \end{array}\end{split}\]- INPUT: - A– a matrix of relation coefficients
- b– a vector of relation constant terms
- c– a vector of objective coefficients
- objective_value– current value of the objective \(z^*\)
- basic_variables– list of basic variables \(x_B\)
- nonbasic_variables– list of non-basic variables \(x_N\)
- objective_name– a “name” for the objective \(z\)
 - OUTPUT: a - dictionary for an LP problem- Note - This constructor does not check correctness of input, as it is intended to be used internally by - InteractiveLPProblemStandardForm.- EXAMPLES: - The intended way to use this class is indirect: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D LP problem dictionary (use ...) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D LP problem dictionary (use ...) - But if you want you can create a dictionary without starting with an LP problem, here is construction of the same dictionary as above: - sage: A = matrix(QQ, ([1, 1], [3, 1])) sage: b = vector(QQ, (1000, 1500)) sage: c = vector(QQ, (10, 5)) sage: R = PolynomialRing(QQ, "x1, x2, x3, x4", order='neglex') sage: from sage.numerical.interactive_simplex_method \ ....: import LPDictionary sage: D2 = LPDictionary(A, b, c, 0, R.gens()[2:], R.gens()[:2], "z") sage: D2 == D True - >>> from sage.all import * >>> A = matrix(QQ, ([Integer(1), Integer(1)], [Integer(3), Integer(1)])) >>> b = vector(QQ, (Integer(1000), Integer(1500))) >>> c = vector(QQ, (Integer(10), Integer(5))) >>> R = PolynomialRing(QQ, "x1, x2, x3, x4", order='neglex') >>> from sage.numerical.interactive_simplex_method import LPDictionary >>> D2 = LPDictionary(A, b, c, Integer(0), R.gens()[Integer(2):], R.gens()[:Integer(2)], "z") >>> D2 == D True - add_row(nonbasic_coefficients, constant, basic_variable=None)[source]¶
- Return a dictionary with an additional row based on a given dictionary. - INPUT: - nonbasic_coefficients– list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)
- constant– the constant term for the new row
- basic_variable– (default: depends on- style()) a string giving the name of the basic variable of the new row
 - OUTPUT: a - dictionary- EXAMPLES: - sage: A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12]) sage: b = (2, 17, 6) sage: c = (55/10, 21/10, 14/30) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.dictionary("x1", "x2", "x4") sage: D1 = D.add_row([7, 11, 19], 42, basic_variable='c') sage: D1.row_coefficients("c") (7, 11, 19) sage: D1.constant_terms()[-1] 42 sage: D1.basic_variables()[-1] c - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1), Integer(7)], [Integer(8), Integer(2), Integer(13)], [Integer(34), Integer(17), Integer(12)]) >>> b = (Integer(2), Integer(17), Integer(6)) >>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10), Integer(14)/Integer(30)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.dictionary("x1", "x2", "x4") >>> D1 = D.add_row([Integer(7), Integer(11), Integer(19)], Integer(42), basic_variable='c') >>> D1.row_coefficients("c") (7, 11, 19) >>> D1.constant_terms()[-Integer(1)] 42 >>> D1.basic_variables()[-Integer(1)] c 
 - basic_variables()[source]¶
- Return the basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.basic_variables() (x3, x4) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.basic_variables() (x3, x4) 
 - column_coefficients(v)[source]¶
- Return coefficients of a nonbasic variable. - INPUT: - v– a nonbasic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.column_coefficients(1) (1, 3) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.column_coefficients(Integer(1)) (1, 3) 
 - constant_terms()[source]¶
- Return the constant terms of relations of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.constant_terms() (1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.constant_terms() (1000, 1500) 
 - nonbasic_variables()[source]¶
- Return non-basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.nonbasic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.nonbasic_variables() (x1, x2) 
 - objective_coefficients()[source]¶
- Return coefficients of the objective of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_coefficients() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_coefficients() (10, 5) 
 - objective_name()[source]¶
- Return the objective name of - self.- OUTPUT: a symbolic expression - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_name() z - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_name() z 
 - objective_value()[source]¶
- Return the value of the objective at the - basic_solution()of- self.- OUTPUT: a number - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_value() 0 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_value() 0 
 - static random_element(m, n, bound=5, special_probability=0.2)[source]¶
- Construct a random dictionary. - INPUT: - m– the number of constraints/basic variables
- n– the number of decision/non-basic variables
- bound– (default: 5) a bound on dictionary entries
- special_probability– (default: 0.2) probability of constructing a potentially infeasible or potentially optimal dictionary
 - OUTPUT: an - LP problem dictionary- EXAMPLES: - sage: from sage.numerical.interactive_simplex_method \ ....: import random_dictionary sage: random_dictionary(3, 4) # indirect doctest LP problem dictionary (use 'view(...)' or '%display typeset' for details) - >>> from sage.all import * >>> from sage.numerical.interactive_simplex_method import random_dictionary >>> random_dictionary(Integer(3), Integer(4)) # indirect doctest LP problem dictionary (use 'view(...)' or '%display typeset' for details) 
 - row_coefficients(v)[source]¶
- Return the coefficients of the basic variable - v.- These are the coefficients with which nonbasic variables are subtracted in the relation for - v.- INPUT: - v– a basic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector of coefficients of a basic variable - EXAMPLES: - sage: A = ([-1, 1], [8, 2]) sage: b = (2, 17) sage: c = (55/10, 21/10) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.final_dictionary() sage: D.row_coefficients("x1") (1/10, -1/5) - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)]) >>> b = (Integer(2), Integer(17)) >>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.final_dictionary() >>> D.row_coefficients("x1") (1/10, -1/5) - We can also use indices of variables: - sage: D.row_coefficients(1) (1/10, -1/5) - >>> from sage.all import * >>> D.row_coefficients(Integer(1)) (1/10, -1/5) - Or use variable names without quotes after injecting them: - sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: D.row_coefficients(x1) (1/10, -1/5) - >>> from sage.all import * >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> D.row_coefficients(x1) (1/10, -1/5) 
 - update()[source]¶
- Update - selfusing previously set entering and leaving variables.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.initial_dictionary() sage: D.objective_value() 0 sage: D.enter("x1") sage: D.leave("x4") sage: D.update() sage: D.objective_value() 5000 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.initial_dictionary() >>> D.objective_value() 0 >>> D.enter("x1") >>> D.leave("x4") >>> D.update() >>> D.objective_value() 5000 
 
- class sage.numerical.interactive_simplex_method.LPRevisedDictionary(problem, basic_variables)[source]¶
- Bases: - LPAbstractDictionary- Construct a revised dictionary for an LP problem. - INPUT: - problem– an- LP problem in standard form
- basic_variables– list of basic variables or their indices
 - OUTPUT: a - revised dictionary for an LP problem- A revised dictionary encodes the same relations as a - regular dictionary, but stores only what is “necessary to efficiently compute data for the simplex method”.- Let the original problem be \[\begin{split}\begin{array}{l} \pm \max cx \\ Ax \leq b \\ x \geq 0 \end{array}\end{split}\]- Let \(\bar{x}\) be the vector of - decision_variables()\(x\) followed by the- slack_variables(). Let \(\bar{c}\) be the vector of- objective_coefficients()\(c\) followed by zeroes for all slack variables. Let \(\bar{A} = (A | I)\) be the matrix of- constraint_coefficients()\(A\) augmented by the identity matrix as columns corresponding to the slack variables. Then the problem above can be written as\[\begin{split}\begin{array}{l} \pm \max \bar{c} \bar{x} \\ \bar{A} \bar{x} = b \\ \bar{x} \geq 0 \end{array}\end{split}\]- and any dictionary is a system of equations equivalent to \(\bar{A} \bar{x} = b\), but resolved for - basic_variables()\(x_B\) in terms of- nonbasic_variables()\(x_N\) together with the expression for the objective in terms of \(x_N\). Let- c_B()and- c_N()be vectors “splitting \(\bar{c}\) into basic and non-basic parts”. Let- B()and- A_N()be the splitting of \(\bar{A}\). Then the corresponding dictionary is\[\begin{split}\begin{array}{|l|} \hline x_B = B^{-1} b - B^{-1} A_N x_N\\ \hline z = y b + \left(c_N - y^T A_N\right) x_N\\ \hline \end{array}\end{split}\]- where \(y = c_B^T B^{-1}\). To proceed with the simplex method, it is not necessary to compute all entries of this dictionary. On the other hand, any entry is easy to compute, if you know \(B^{-1}\), so we keep track of it through the update steps. - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: from sage.numerical.interactive_simplex_method \ ....: import LPRevisedDictionary sage: D = LPRevisedDictionary(P, [1, 2]) sage: D.basic_variables() (x1, x2) sage: D LP problem dictionary (use ...) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> from sage.numerical.interactive_simplex_method import LPRevisedDictionary >>> D = LPRevisedDictionary(P, [Integer(1), Integer(2)]) >>> D.basic_variables() (x1, x2) >>> D LP problem dictionary (use ...) - The same dictionary can be constructed through the problem: - sage: P.revised_dictionary(1, 2) == D True - >>> from sage.all import * >>> P.revised_dictionary(Integer(1), Integer(2)) == D True - When this dictionary is typeset, you will see two tables like these ones: \[\begin{split}\renewcommand{\arraystretch}{1.500000} \begin{array}{l} \begin{array}{l|r|rr||r||r} x_B & c_B & & \mspace{-16mu} B^{-1} & y & B^{-1} b \\ \hline x_{1} & 10 & -\frac{1}{2} & \frac{1}{2} & \frac{5}{2} & 250 \\ x_{2} & 5 & \frac{3}{2} & -\frac{1}{2} & \frac{5}{2} & 750 \\ \end{array}\\ \\ \begin{array}{r|rr} x_N & x_{3} & x_{4} \\ \hline c_N^T & 0 & 0 \\ \hline y^T A_N & \frac{5}{2} & \frac{5}{2} \\ \hline c_N^T - y^T A_N & -\frac{5}{2} & -\frac{5}{2} \\ \end{array} \end{array}\end{split}\]- More details will be shown if entering and leaving variables are set, but in any case the top table shows \(B^{-1}\) and a few extra columns, while the bottom one shows several rows: these are related to columns and rows of dictionary entries. - A(v)[source]¶
- Return the column of constraint coefficients corresponding to - v.- INPUT: - v– a variable, its name, or its index
 - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.A(1) (1, 3) sage: D.A(0) (-1, -1) sage: D.A("x3") (1, 0) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.A(Integer(1)) (1, 3) >>> D.A(Integer(0)) (-1, -1) >>> D.A("x3") (1, 0) 
 - A_N()[source]¶
- Return the \(A_N\) matrix, constraint coefficients of non-basic variables. - OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.A_N() [1 1] [3 1] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.A_N() [1 1] [3 1] 
 - B()[source]¶
- Return the \(B\) matrix, i.e. constraint coefficients of basic variables. - OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary(1, 2) sage: D.B() [1 1] [3 1] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary(Integer(1), Integer(2)) >>> D.B() [1 1] [3 1] 
 - B_inverse()[source]¶
- Return the inverse of the - B()matrix.- This inverse matrix is stored and computed during dictionary update in a more efficient way than generic inversion. - OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary(1, 2) sage: D.B_inverse() [-1/2 1/2] [ 3/2 -1/2] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary(Integer(1), Integer(2)) >>> D.B_inverse() [-1/2 1/2] [ 3/2 -1/2] 
 - E()[source]¶
- Return the eta matrix between - selfand the next dictionary.- OUTPUT: a matrix - If \(B_{\mathrm{old}}\) is the current matrix \(B\) and \(B_{\mathrm{new}}\) is the \(B\) matrix of the next dictionary (after the update step), then \(B_{\mathrm{new}} = B_{\mathrm{old}} E\). - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.enter(1) sage: D.leave(4) sage: D.E() [1 1] [0 3] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.enter(Integer(1)) >>> D.leave(Integer(4)) >>> D.E() [1 1] [0 3] 
 - E_inverse()[source]¶
- Return the inverse of the matrix - E().- This inverse matrix is computed in a more efficient way than generic inversion. - OUTPUT: a matrix - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.enter(1) sage: D.leave(4) sage: D.E_inverse() [ 1 -1/3] [ 0 1/3] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.enter(Integer(1)) >>> D.leave(Integer(4)) >>> D.E_inverse() [ 1 -1/3] [ 0 1/3] 
 - add_row(nonbasic_coefficients, constant, basic_variable=None)[source]¶
- Return a dictionary with an additional row based on a given dictionary. - The implementation of this method for revised dictionaries adds a new inequality constraint to the problem, in which the given - basic_variablebecomes the slack variable. The resulting dictionary (with- basic_variableadded to the basis) will have the given- nonbasic_coefficientsand- constantas a new row.- INPUT: - nonbasic_coefficients– list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)
- constant– the constant term for the new row
- basic_variable– (default: depends on- style()) a string giving the name of the basic variable of the new row
 - OUTPUT: a - revised dictionary- EXAMPLES: - sage: A = ([-1, 1111, 3, 17], [8, 222, 7, 6], ....: [3, 7, 17, 5], [9, 5, 7, 3]) sage: b = (2, 17, 11, 27) sage: c = (5/133, 1/10, 1/18, 47/3) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.final_revised_dictionary() sage: D1 = D.add_row([7, 11, 13, 9], 42) sage: D1.row_coefficients("x9") (7, 11, 13, 9) sage: D1.constant_terms()[-1] 42 sage: D1.basic_variables()[-1] x9 sage: A = ([-9, 7, 48, 31, 23], [5, 2, 9, 13, 98], ....: [14, 15, 97, 49, 1], [9, 5, 7, 3, 17], ....: [119, 7, 121, 5, 111]) sage: b = (33, 27, 1, 272, 61) sage: c = (51/133, 1/100, 149/18, 47/37, 13/17) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary("x1", "x2", "x3", "x4", "x5") sage: D2 = D.add_row([5 ,7, 11, 13, 9], 99, basic_variable='c') sage: D2.row_coefficients("c") (5, 7, 11, 13, 9) sage: D2.constant_terms()[-1] 99 sage: D2.basic_variables()[-1] c sage: D = P.revised_dictionary(0, 1, 2, 3, 4) sage: D.add_row([1, 2, 3, 4, 5, 6], 0) Traceback (most recent call last): ... ValueError: the sum of coefficients of nonbasic slack variables has to be equal to -1 when inserting a row into a dictionary for the auxiliary problem sage: D3 = D.add_row([1, 2, 3, 4, 5, -15], 0) sage: D3.row_coefficients(11) (1, 2, 3, 4, 5, -15) - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1111), Integer(3), Integer(17)], [Integer(8), Integer(222), Integer(7), Integer(6)], ... [Integer(3), Integer(7), Integer(17), Integer(5)], [Integer(9), Integer(5), Integer(7), Integer(3)]) >>> b = (Integer(2), Integer(17), Integer(11), Integer(27)) >>> c = (Integer(5)/Integer(133), Integer(1)/Integer(10), Integer(1)/Integer(18), Integer(47)/Integer(3)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.final_revised_dictionary() >>> D1 = D.add_row([Integer(7), Integer(11), Integer(13), Integer(9)], Integer(42)) >>> D1.row_coefficients("x9") (7, 11, 13, 9) >>> D1.constant_terms()[-Integer(1)] 42 >>> D1.basic_variables()[-Integer(1)] x9 >>> A = ([-Integer(9), Integer(7), Integer(48), Integer(31), Integer(23)], [Integer(5), Integer(2), Integer(9), Integer(13), Integer(98)], ... [Integer(14), Integer(15), Integer(97), Integer(49), Integer(1)], [Integer(9), Integer(5), Integer(7), Integer(3), Integer(17)], ... [Integer(119), Integer(7), Integer(121), Integer(5), Integer(111)]) >>> b = (Integer(33), Integer(27), Integer(1), Integer(272), Integer(61)) >>> c = (Integer(51)/Integer(133), Integer(1)/Integer(100), Integer(149)/Integer(18), Integer(47)/Integer(37), Integer(13)/Integer(17)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary("x1", "x2", "x3", "x4", "x5") >>> D2 = D.add_row([Integer(5) ,Integer(7), Integer(11), Integer(13), Integer(9)], Integer(99), basic_variable='c') >>> D2.row_coefficients("c") (5, 7, 11, 13, 9) >>> D2.constant_terms()[-Integer(1)] 99 >>> D2.basic_variables()[-Integer(1)] c >>> D = P.revised_dictionary(Integer(0), Integer(1), Integer(2), Integer(3), Integer(4)) >>> D.add_row([Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)], Integer(0)) Traceback (most recent call last): ... ValueError: the sum of coefficients of nonbasic slack variables has to be equal to -1 when inserting a row into a dictionary for the auxiliary problem >>> D3 = D.add_row([Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), -Integer(15)], Integer(0)) >>> D3.row_coefficients(Integer(11)) (1, 2, 3, 4, 5, -15) 
 - basic_indices()[source]¶
- Return the basic indices of - self.- Note - Basic indices are indices of - basic_variables()in the list of generators of the- coordinate_ring()of the- problem()of- self, they may not coincide with the indices of variables which are parts of their names. (They will for the default indexed names.)- OUTPUT: list - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.basic_indices() [3, 4] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.basic_indices() [3, 4] 
 - basic_variables()[source]¶
- Return the basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.basic_variables() (x3, x4) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.basic_variables() (x3, x4) 
 - c_B()[source]¶
- Return the \(c_B\) vector, objective coefficients of basic variables. - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary(1, 2) sage: D.c_B() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary(Integer(1), Integer(2)) >>> D.c_B() (10, 5) 
 - c_N()[source]¶
- Return the \(c_N\) vector, objective coefficients of non-basic variables. - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.c_N() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.c_N() (10, 5) 
 - column_coefficients(v)[source]¶
- Return the coefficients of a nonbasic variable. - INPUT: - v– a nonbasic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.column_coefficients(1) (1, 3) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.column_coefficients(Integer(1)) (1, 3) 
 - constant_terms()[source]¶
- Return constant terms in the relations of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.constant_terms() (1000, 1500) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.constant_terms() (1000, 1500) 
 - dictionary()[source]¶
- Return a regular LP dictionary matching - self.- OUTPUT: an - LP dictionary- EXAMPLES: - sage: A = ([1, 1], [3, 1], [-1, -1]) sage: b = (1000, 1500, -400) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.dictionary() LP problem dictionary (use ...) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)]) >>> b = (Integer(1000), Integer(1500), -Integer(400)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.dictionary() LP problem dictionary (use ...) 
 - nonbasic_indices()[source]¶
- Return the non-basic indices of - self.- Note - Non-basic indices are indices of - nonbasic_variables()in the list of generators of the- coordinate_ring()of the- problem()of- self, they may not coincide with the indices of variables which are parts of their names. (They will for the default indexed names.)- OUTPUT: list - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.nonbasic_indices() [1, 2] - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.nonbasic_indices() [1, 2] 
 - nonbasic_variables()[source]¶
- Return non-basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.nonbasic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.nonbasic_variables() (x1, x2) 
 - objective_coefficients()[source]¶
- Return coefficients of the objective of - self.- OUTPUT: a vector - These are coefficients of non-basic variables when basic variables are eliminated. - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.objective_coefficients() (10, 5) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.objective_coefficients() (10, 5) 
 - objective_name()[source]¶
- Return the objective name of - self.- OUTPUT: a symbolic expression - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.objective_name() z - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.objective_name() z 
 - objective_value()[source]¶
- Return the value of the objective at the basic solution of - self.- OUTPUT: a number - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.objective_value() 0 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.objective_value() 0 
 - problem()[source]¶
- Return the original problem. - OUTPUT: an - LP problem in standard form- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.problem() is P True - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.problem() is P True 
 - row_coefficients(v)[source]¶
- Return the coefficients of the basic variable - v.- These are the coefficients with which nonbasic variables are subtracted in the relation for - v.- INPUT: - v– a basic variable of- self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable
 - OUTPUT: a vector of coefficients of a basic variable - EXAMPLES: - sage: A = ([-1, 1], [8, 2]) sage: b = (2, 17) sage: c = (55/10, 21/10) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.row_coefficients("x3") (-1, 1) - >>> from sage.all import * >>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)]) >>> b = (Integer(2), Integer(17)) >>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.row_coefficients("x3") (-1, 1) - We can also use indices of variables: - sage: D.row_coefficients(3) (-1, 1) - >>> from sage.all import * >>> D.row_coefficients(Integer(3)) (-1, 1) - Or variable names without quotes after injecting them: - sage: P.inject_variables() Defining x0, x1, x2, x3, x4 sage: D.row_coefficients(x3) (-1, 1) - >>> from sage.all import * >>> P.inject_variables() Defining x0, x1, x2, x3, x4 >>> D.row_coefficients(x3) (-1, 1) 
 - update()[source]¶
- Update - selfusing previously set entering and leaving variables.- EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.objective_value() 0 sage: D.enter("x1") sage: D.leave("x4") sage: D.update() sage: D.objective_value() 5000 - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.objective_value() 0 >>> D.enter("x1") >>> D.leave("x4") >>> D.update() >>> D.objective_value() 5000 
 - x_B()[source]¶
- Return the basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.basic_variables() (x3, x4) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.basic_variables() (x3, x4) 
 - x_N()[source]¶
- Return non-basic variables of - self.- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.nonbasic_variables() (x1, x2) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.nonbasic_variables() (x1, x2) 
 - y()[source]¶
- Return the \(y\) vector, the product of - c_B()and- B_inverse().- OUTPUT: a vector - EXAMPLES: - sage: A = ([1, 1], [3, 1]) sage: b = (1000, 1500) sage: c = (10, 5) sage: P = InteractiveLPProblemStandardForm(A, b, c) sage: D = P.revised_dictionary() sage: D.y() (0, 0) - >>> from sage.all import * >>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)]) >>> b = (Integer(1000), Integer(1500)) >>> c = (Integer(10), Integer(5)) >>> P = InteractiveLPProblemStandardForm(A, b, c) >>> D = P.revised_dictionary() >>> D.y() (0, 0) 
 
- sage.numerical.interactive_simplex_method.default_variable_name(variable)[source]¶
- Return default variable name for the current - style().- INPUT: - variable– string describing requested name
 - OUTPUT: string with the requested name for current style - EXAMPLES: - sage: sage.numerical.interactive_simplex_method.default_variable_name("primal slack") 'x' sage: sage.numerical.interactive_simplex_method.style('Vanderbei') 'Vanderbei' sage: sage.numerical.interactive_simplex_method.default_variable_name("primal slack") 'w' sage: sage.numerical.interactive_simplex_method.style('UAlberta') 'UAlberta' - >>> from sage.all import * >>> sage.numerical.interactive_simplex_method.default_variable_name("primal slack") 'x' >>> sage.numerical.interactive_simplex_method.style('Vanderbei') 'Vanderbei' >>> sage.numerical.interactive_simplex_method.default_variable_name("primal slack") 'w' >>> sage.numerical.interactive_simplex_method.style('UAlberta') 'UAlberta' 
- sage.numerical.interactive_simplex_method.random_dictionary(m, n, bound=5, special_probability=0.2)[source]¶
- Construct a random dictionary. - INPUT: - m– the number of constraints/basic variables
- n– the number of decision/non-basic variables
- bound– (default: 5) a bound on dictionary entries
- special_probability– (default: 0.2) probability of constructing a potentially infeasible or potentially optimal dictionary
 - OUTPUT: an - LP problem dictionary- EXAMPLES: - sage: from sage.numerical.interactive_simplex_method \ ....: import random_dictionary sage: random_dictionary(3, 4) # indirect doctest LP problem dictionary (use 'view(...)' or '%display typeset' for details) - >>> from sage.all import * >>> from sage.numerical.interactive_simplex_method import random_dictionary >>> random_dictionary(Integer(3), Integer(4)) # indirect doctest LP problem dictionary (use 'view(...)' or '%display typeset' for details) 
- sage.numerical.interactive_simplex_method.style(new_style=None)[source]¶
- Set or get the current style of problems and dictionaries. - INPUT: - new_style– string or- None(default)
 - OUTPUT: - a string with current style (same as - new_styleif it was given)
 - If the input is not recognized as a valid style, a - ValueErrorexception is raised.- Currently supported styles are: - ‘UAlberta’ (default): Follows the style used in the Math 373 course on Mathematical Programming and Optimization at the University of Alberta, Edmonton, Canada; based on Chvatal’s book. - Objective functions of dictionaries are printed at the bottom. 
 - Variable names default to - \(z\) for primal objective 
- \(z\) for dual objective 
- \(w\) for auxiliary objective 
- \(x_1, x_2, \dots, x_n\) for primal decision variables 
- \(x_{n+1}, x_{n+2}, \dots, x_{n+m}\) for primal slack variables 
- \(y_1, y_2, \dots, y_m\) for dual decision variables 
- \(y_{m+1}, y_{m+2}, \dots, y_{m+n}\) for dual slack variables 
 
- ‘Vanderbei’: Follows the style of Robert Vanderbei’s textbook, Linear Programming – Foundations and Extensions. - Objective functions of dictionaries are printed at the top. 
 - Variable names default to - \(zeta\) for primal objective 
- \(xi\) for dual objective 
- \(xi\) for auxiliary objective 
- \(x_1, x_2, \dots, x_n\) for primal decision variables 
- \(w_1, w_2, \dots, w_m\) for primal slack variables 
- \(y_1, y_2, \dots, y_m\) for dual decision variables 
- \(z_1, z_2, \dots, z_n\) for dual slack variables 
 
 - EXAMPLES: - sage: sage.numerical.interactive_simplex_method.style() 'UAlberta' sage: sage.numerical.interactive_simplex_method.style('Vanderbei') 'Vanderbei' sage: sage.numerical.interactive_simplex_method.style('Doesntexist') Traceback (most recent call last): ... ValueError: Style must be one of: UAlberta, Vanderbei sage: sage.numerical.interactive_simplex_method.style('UAlberta') 'UAlberta' - >>> from sage.all import * >>> sage.numerical.interactive_simplex_method.style() 'UAlberta' >>> sage.numerical.interactive_simplex_method.style('Vanderbei') 'Vanderbei' >>> sage.numerical.interactive_simplex_method.style('Doesntexist') Traceback (most recent call last): ... ValueError: Style must be one of: UAlberta, Vanderbei >>> sage.numerical.interactive_simplex_method.style('UAlberta') 'UAlberta' 
- sage.numerical.interactive_simplex_method.variable(v)[source]¶
- Interpret - vas a variable of- R.- INPUT: - R– a polynomial ring
- v– a variable of- Ror convertible into- R, a string with the name of a variable of- Ror an index of a variable in- R
 - OUTPUT: a variable of - R- EXAMPLES: - sage: from sage.numerical.interactive_simplex_method \ ....: import variable sage: R = PolynomialRing(QQ, "x3, y5, x5, y") sage: R.inject_variables() Defining x3, y5, x5, y sage: variable(R, "x3") x3 sage: variable(R, x3) x3 sage: variable(R, 3) x3 sage: variable(R, 0) Traceback (most recent call last): ... ValueError: there is no variable with the given index sage: variable(R, 5) Traceback (most recent call last): ... ValueError: the given index is ambiguous sage: variable(R, 2 * x3) Traceback (most recent call last): ... ValueError: cannot interpret given data as a variable sage: variable(R, "z") Traceback (most recent call last): ... ValueError: cannot interpret given data as a variable - >>> from sage.all import * >>> from sage.numerical.interactive_simplex_method import variable >>> R = PolynomialRing(QQ, "x3, y5, x5, y") >>> R.inject_variables() Defining x3, y5, x5, y >>> variable(R, "x3") x3 >>> variable(R, x3) x3 >>> variable(R, Integer(3)) x3 >>> variable(R, Integer(0)) Traceback (most recent call last): ... ValueError: there is no variable with the given index >>> variable(R, Integer(5)) Traceback (most recent call last): ... ValueError: the given index is ambiguous >>> variable(R, Integer(2) * x3) Traceback (most recent call last): ... ValueError: cannot interpret given data as a variable >>> variable(R, "z") Traceback (most recent call last): ... ValueError: cannot interpret given data as a variable