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
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:
(only for exponent 2).
In Python parlance, we've defined the following
You can also use add or
addTerms to modify
expressions. The LinExpr()
constructor can also 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
Given all these options for building expressions, you may wonder which is fastest. For small expressions, you won't need to worry about performance differences between them. If you are building lots of very large expressions (100s of terms), you will find that the LinExpr() constructor is generally going to be fastest, followed by the addTerms method, and then the quicksum function.
To add a linear constraint to your model, you generally build one or
two linear expression objects ( and ) and then use an
overloaded comparison operator to build an argument for
give a few examples:
Once you add a constraint to your model, subsequent changes to the expression object you used to build the constraint will not change the constraint (you would use Model.chgCoeff for that).
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).