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 constraints. They are temporary objects that typically have short lifespans.
GRBLinExpr class is a sub-class of the abstract base
You generally build linear expressions using overloaded operators.
For example, if
x is a GRBVar
x + 1 is a
GRBLinExpr 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).
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:
- You should avoid using
expr = expr + xin a loop. It will lead to runtimes that are quadratic in the number of terms in the expression.
expr += x(or
expr -= x) is much more efficient than
expr = expr + x. Building a large expression by looping over
+=statements is reasonably efficient, but it isn't the most efficient approach.
- The most efficient way to build a large expression is to make a single call to addTerms.
To add a linear constraint to your model, you generally build one or
two linear expression objects (
expr2) and then use an
overloaded comparison operator to build an argument for
give a few examples:
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).