Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# gurobipy.LinExpr

class 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 `**` (only for exponent 2). In Python parlance, we’ve defined the following `LinExpr` functions: `__add__`, `__radd__`, `__iadd__`, `__sub__`, `__rsub__`, `__isub__`, `__neg__`, `__mul__`, `__rmul__`, `__imul__`, `__div__`, and `__pow__`.

  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 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 `remove`.

  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 (`expr1` and `expr2`) and then use an overloaded comparison operator to build an argument for `Model.addConstr`. To give a few examples:

      model.addConstr(expr1 <= expr2)
      model.addConstr(expr1 == 1)
      model.addConstr(2*x + 3*y <= 4)

  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).

  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`).

  LinExpr(arg1=0.0, arg2=None)

    Linear expression constructor. For linear expressions of moderate size (only a few terms) and for the ease of usage, you should generally use overloaded operators instead of the explicit constructor to build linear expression objects.

    This constructor takes multiple forms. You can initialize a linear expression using a constant (`LinExpr(2.0)`), a variable (`LinExpr(x)`), an expression (`LinExpr(2*x)`), a pair of lists containing coefficients and variables, respectively (`LinExpr([1.0, 2.0], [x, y])`), or a list of coefficient-variable tuples (`LinExpr([(1.0, x), (2.0, y), (1.0, z)])`).

    Returns:

      A linear expression object.

    Example:

          expr = LinExpr(2.0)
          expr = LinExpr(2*x)
          expr = LinExpr([1.0, 2.0], [x, y])
          expr = LinExpr([(1.0, x), (2.0, y), (1.0, z)])

  add(expr, mult=1.0)

    Add one linear expression into another. Upon completion, the invoking linear expression will be equal to the sum of itself and the argument expression.

    Parameters:

      - expr – Linear expression to add.

      - mult – (optional) Multiplier for argument expression.

    Example:

          e1 = x + y
          e1.add(z, 3.0)

  addConstant(c)

    Add a constant into a linear expression.

    Parameters:

      c – Constant to add to expression.

    Example:

          expr = x + 2 * y
          expr.addConstant(0.1)

  addTerms(coeffs, vars)

    Add new terms into a linear expression.

    Parameters:

      - coeffs – Coefficients for new terms; either a list of coefficients or a single coefficient. The two arguments must have the same size.

      - vars – Variables for new terms; either a list of variables or a single variable. The two arguments must have the same size.

    Example:

          expr.addTerms(1.0, x)
          expr.addTerms([2.0, 3.0], [y, z])

  clear()

    Set a linear expression to 0.

    Example:

          expr.clear()

  copy()

    Copy a linear expression

    Returns:

      Copy of input expression.

    Example:

          e0 = 2 * x + 3
          e1 = e0.copy()

  getConstant()

    Retrieve the constant term from a linear expression.

    Returns:

      Constant from expression.

    Example:

          e = 2 * x + 3
          print(e.getConstant())

  getCoeff(i)

    Retrieve the coefficient from a single term of the expression.

    Returns:

      Coefficient for the term at index `i` in the expression.

    Example:

          e = x + 2 * y + 3
          print(e.getCoeff(1))

  getValue()

    Compute the value of an expression using the current solution.

    Returns:

      The value of the expression.

    Example:

          obj = model.getObjective()
          print(obj.getValue())

  getVar(i)

    Retrieve the variable object from a single term of the expression.

    Returns:

      Variable for the term at index `i` in the expression.

    Example:

          e = x + 2 * y + 3
          print(e.getVar(1))

  linTerms()

    Return an iterator over linear terms in the expression. Each element in the iteration is a tuple of the form `(coefficient, variable)`. The constant term is not included in the iteration.

    Example:

          >>> e = x + 2*y + z - 1.0
          >>> for coeff, var in e.linTerms():
          >>>     print(coeff, var.VarName)
          1.0 x
          2.0 y
          1.0 z

  remove(item)

    Remove a term from a linear expression.

    Parameters:

      item – If `item` is an integer, then the term stored at index `item` of the expression is removed. If `item` is a Var, then all terms that involve `item` are removed.

    Example:

          e = x + 2 * y + 3
          e.remove(x)

  size()

    Retrieve the number of terms in the linear expression (not including the constant).

    Returns:

      Number of terms in the expression.

    Example:

          e = x + 2 * y + 3
          print(e.size())

  __eq__()

    Overloads the `==` operator, creating a `TempConstr` object that captures an equality constraint. The result is typically immediately passed to `Model.addConstr`.

    Returns:

      A `TempConstr` object.

    Example:

          m.addConstr(x + y == 1)

  __le__()

    Overloads the `<=` operator, creating a `TempConstr` object that captures an inequality constraint. The result is typically immediately passed to `Model.addConstr`.

    Returns:

      A `TempConstr` object.

    Example:

          m.addConstr(x + y <= 1)

  __ge__(arg)

    Overloads the `>=` operator, creating a `TempConstr` object that captures an inequality constraint. The result is typically immediately passed to `Model.addConstr`.

    Returns:

      A `TempConstr` object.

    Example:

          m.addConstr(x + y >= 1)

Help and Feedback

Press `/` or click to search this documentation | Gurobi website | Gurobi community forum
Go to other Gurobi documentation | Gurobi download | Contact support