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.
The GRBLinExpr
class is a sub-class of the abstract base
class GRBExpr.
You generally build linear expressions using overloaded operators.
For example, if x
is a GRBVar
object, then 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
).
Another option for building expressions is to use the addTerms method, which adds an array of new terms at once. Terms can also 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:
expr = expr + x
in 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.
To add a linear constraint to your model, you generally build one or
two linear expression objects (expr1
and expr2
) and then use an
overloaded comparison operator to build an argument for
GRBModel::addConstr. To
give a few examples:
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).