Try our new documentation site (beta).
LinExpr
Gurobi linear expression object. A linear expression consists of a constant term, plus a list of coefficient-variable pairs that capture the linear terms. Linear expressions are used to build linear objective and constraints. They are temporary objects that typically have short lifespans.
You generally build linear expressions using overloaded operators.
For example, if x is a Var
object, then x + 1 is a
LinExpr object. Expressions
can be built from constants (e.g., expr = 0), variables (e.g.,
expr = 1 * x + 2 * y), or from other expressions (e.g.,
expr2 = 2 * expr1 + x, or expr3 = expr1 + 2 * expr2).
You can also modify existing expressions (e.g., expr += x, or
expr2 -= expr1).
The full list of overloaded operators on
LinExpr objects is as follows:
+, +=,
-, -=, *, *=, and /.
In Python parlance, we've defined the following
LinExpr functions:
__add__, __radd__, __iadd__,
__sub__, __rsub__, __isub__, __neg__,
__mul__, __rmul__, __imul__, and
__div__.
We've also overloaded the comparison operators (==, <=, and >=), to make it easier to build constraints from linear expressions.
You can also use add or
addTerms to modify
expressions. The LinExpr()
constructor can be used to build expressions. Another option is
quicksum; it is a more
efficient version of the Python sum function. Terms can be
removed from an expression using
remove.
Note that the cost of building expressions depends heavily on the approach you use. While you can generally ignore this issue when building small expressions, you should be aware of a few efficiency issues when building large expressions:
- While the Python
sumfunction can be used to build expressions, it should be avoided. Its cost is quadratic in the length of the expression. - For similar reasons, you should avoid using
expr = expr + xin a loop. Building large expressions in this way also leads to quadratic runtimes. - The quicksum function is
much quicker than
sum, as are loops overexpr += xor expr.add(x). These approaches are fast enough for most programs, but they may still be expensive for very large expressions. - The two most efficient ways to build large linear expressions are addTerms or the LinExpr() constructor.
Individual terms in a linear expression can be queried using the getVar, getCoeff, and getConstant methods. You can query the number of terms in the expression using the size method.
Note that a linear expression may contain multiple terms that involve the same variable. These duplicate terms are merged when creating a constraint from an expression, but they may be visible when inspecting individual terms in the expression (e.g., when using getVar).
Subsections
