Try our new documentation site (beta).


Gurobi quadratic expression object. A quadratic expression consists of a linear expression plus a list of coefficient-variable-variable triples that capture the quadratic terms. Quadratic expressions are used to build quadratic objective functions and quadratic constraints. They are temporary objects that typically have short lifespans.

You generally build quadratic expressions using overloaded operators. For example, if x is a Var object, then x * x is a QuadExpr object. Expressions can be built from constants (e.g., expr = 0), variables (e.g., expr = 1 * x *x + 2 * x * y), or from other expressions (e.g., expr2 = 2 * expr1 + x * x, or expr3 = expr1 + 2 * expr2). You can also modify existing expressions (e.g., expr += x * x, or expr2 -= expr1).

The full list of overloaded operators on QuadExpr objects is as follows: +, +=, -, -=, *, *=, and /. In Python parlance, we've defined the following QuadExpr functions: __add__, __radd__, __iadd__, __sub__, __rsub__, __isub__, __neg__, __mul__, __rmul__, __imul__, and __div__.

We've also overloaded the comparison operators (==, <=, and >=), to make it easier to build constraints from quadratic expressions.

You can use quicksum to build quadratic expressions; it is a more efficient version of the Python sum function. You can also use add or addTerms to modify expressions. 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*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*x or expr.add(x*x). These approaches are fast enough for most programs, but they may still be expensive for very large expressions.
  • The most efficient way to build a large quadratic expression is with a single call to addTerms.

Individual quadratic terms in a quadratic expression can be queried using the getVar1, getVar2, and getCoeff methods. You can query the number of quadratic terms in the expression using the size method. To query the constant and linear terms associated with a quadratic expression, use getLinExpr to obtain the linear portion of the quadratic expression, and then use the getVar, getCoeff, and getConstant methods on this LinExpr object. Note that a quadratic expression may contain multiple terms that involve the same variable pair. 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 getVar1 and getVar2).


Try Gurobi for Free

Choose the evaluation license that fits you best, and start working with our Expert Team for technical guidance and support.

Evaluation License
Get a free, full-featured license of the Gurobi Optimizer to experience the performance, support, benchmarking and tuning services we provide as part of our product offering.
Academic License
Gurobi supports the teaching and use of optimization within academic institutions. We offer free, full-featured copies of Gurobi for use in class, and for research.
Cloud Trial

Request free trial hours, so you can see how quickly and easily a model can be solved on the cloud.