# LinExpr

Filter Content By
Version
Languages

## 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 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__, __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 sum function 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 + x in a loop. Building large expressions in this way also leads to quadratic runtimes.
• The quicksum function is much quicker than sum, as are loops over expr += x or 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