Building Expressions Faster¶
Pyomo expressions can be constructed using native binary operators in Python. For example, a sum can be created in a simple loop:
M = ConcreteModel() M.x = Var(range(5)) s = 0 for i in range(5): s = s + M.x[i]
Additionally, Pyomo expressions can be constructed using functions
that iteratively apply Python binary operators. For example, the
sum() function can be used to replace the previous
s = sum(M.x[i] for i in range(5))
sum() function is both more compact and more efficient.
sum() avoids the creation of temporary variables, and
the summation logic is executed in the Python interpreter while the
loop is interpreted.
Linear, Quadratic and General Nonlinear Expressions¶
Pyomo can express a very wide range of algebraic expressions, and there are three general classes of expressions that are recognized by Pyomo:
- linear polynomials
- quadratic polynomials
- nonlinear expressions, including higher-order polynomials and expressions with intrinsic functions
These classes of expressions are leveraged to efficiently generate compact representations of expressions, and to transform expression trees into standard forms used to interface with solvers. Note that There not all quadratic polynomials are recognized by Pyomo; in other words, some quadratic expressions are treated as nonlinear expressions.
For example, consider the following quadratic polynomial:
s = sum(M.x[i] for i in range(5))**2
This quadratic polynomial is treated as a nonlinear expression unless the expression is explicilty processed to identify quadratic terms. This lazy identification of of quadratic terms allows Pyomo to tailor the search for quadratic terms only when they are explicitly needed.
Pyomo Utility Functions¶
Pyomo includes several similar functions that can be used to create expressions:
- A function to compute a product of Pyomo expressions.
- A function to efficiently compute a sum of Pyomo expressions.
- A function that computes a generalized dot product.
prod function is analogous to the builtin
sum() function. Its main argument is a variable length
args, which represents expressions that are multiplied
together. For example:
M = ConcreteModel() M.x = Var(range(5)) M.z = Var() # The product M.x * M.x * ... * M.x e1 = prod(M.x[i] for i in M.x) # The product M.x*M.z e2 = prod([M.x, M.z]) # The product M.z*(M.x + ... + M.x) e3 = prod([sum(M.x[i] for i in M.x), M.z])
The behavior of the
quicksum function is
similar to the builtin
sum() function, but this function often
generates a more compact Pyomo expression. Its main argument is a
variable length argument list,
args, which represents
expressions that are summed together. For example:
M = ConcreteModel() M.x = Var(range(5)) # Summation using the Python sum() function e1 = sum(M.x[i]**2 for i in M.x) # Summation using the Pyomo quicksum function e2 = quicksum(M.x[i]**2 for i in M.x)
The summation is customized based on the
linear arguments. The
start defines the initial
value for summation, which defaults to zero. If
a numeric value, then the
linear argument determines how
the sum is processed:
False, then the terms in
argsare assumed to be nonlinear.
True, then the terms in
argsare assumed to be linear.
None, the first term in
argsis analyze to determine whether the terms are linear or nonlinear.
This argument allows the
function to customize the expression representation used, and
specifically a more compact representation is used for linear
function can be slower than the builtin
but this compact representation can generate problem representations
Consider the following example:
M = ConcreteModel() M.A = RangeSet(100000) M.p = Param(M.A, mutable=True, initialize=1) M.x = Var(M.A) start = time.time() e = sum( (M.x[i] - 1)**M.p[i] for i in M.A) print("sum: %f" % (time.time() - start)) start = time.time() generate_standard_repn(e) print("repn: %f" % (time.time() - start)) start = time.time() e = quicksum( (M.x[i] - 1)**M.p[i] for i in M.A) print("quicksum: %f" % (time.time() - start)) start = time.time() generate_standard_repn(e) print("repn: %f" % (time.time() - start))
The sum consists of linear terms because the exponents are one. The following output illustrates that quicksum can identify this linear structure to generate expressions more quickly:
sum: 1.447861 repn: 0.870225 quicksum: 1.388344 repn: 0.864316
start is not a numeric value, then the
quicksum sets the initial value to
and executes a simple loop to sum the terms. This allows the sum
to be stored in an object that is passed into the function (e.g. the linear context manager
None. While this allows
for efficient expression generation in normal cases, there are
circumstances where the inspection of the first
args is misleading. Consider the following
M = ConcreteModel() M.x = Var(range(5)) e = quicksum(M.x[i]**2 if i > 0 else M.x[i] for i in range(5))
The first term created by the generator is linear, but the
subsequent terms are nonlinear. Pyomo gracefully transitions
to a nonlinear sum, but in this case
is doing additional work that is not useful.
sum_product function supports
a generalized dot product. The
args argument contains one
or more components that are used to create terms in the summation.
args argument contains a single components, then its
sequence of terms are summed together; the sum is equivalent to
quicksum. If two or more components are
provided, then the result is the summation of their terms multiplied
together. For example:
M = ConcreteModel() M.z = RangeSet(5) M.x = Var(range(10)) M.y = Var(range(10)) # Sum the elements of x e1 = sum_product(M.x) # Sum the product of elements in x and y e2 = sum_product(M.x, M.y) # Sum the product of elements in x and y, over the index set z e3 = sum_product(M.x, M.y, index=M.z)
denom argument specifies components whose terms are in
the denominator. For example:
# Sum the product of x_i/y_i e1 = sum_product(M.x, denom=M.y) # Sum the product of 1/(x_i*y_i) e2 = sum_product(denom=(M.x, M.y))
The terms summed by this function are explicitly specified, so
sum_product can identify
whether the resulting expression is linear, quadratic or nonlinear.
Consequently, this function is typically faster than simple loops,
and it generates compact representations of expressions..