An embedded DSL to manipulate MathProg Mixed Integer Programming models within Scala

Germán Ferrari
Instituto de Computación, Universidad de la República, Uruguay
An embedded DSL to
manipulate MathProg
Mixed Integer
Programming
models within Scala
An embedded DSL to
manipulate MathProg
Mixed Integer
Programming
models within Scala
Germán Ferrari
Instituto de Computación, Universidad de la República, Uruguay

GNU MathProg
MathProg = Mathematical Programming
Has nothing to do with computer programming
It’s a synonym of “mathematical optimization”
A “program” here refers to a plan or schedule

GNU MathProg
It’s a modeling language
Optimization problem
Mathematical modeling
GNU MathProg
Computational experiments
Supported by the GNU Linear Programming Kit

GNU MathProg
Supports linear models, with either real or
integer decision variables
This is called “Mixed Integer Programming”
(MIP) because it mixes integer and real
variables

Generic MIP optimization problem
minimize f:
sum{j in J} c[j] * x[j] +
sum{k in K} d[k] * y[k];
subject to g{i in I}:
sum{j in J} a[i,j] * x[j] +
sum{k in K} e[i,k] * y[k] <= b[i];

Find x[j] and y[k], that minimize a function f,
satisfying constraints g[i]
minimize f:

minimize f:
Decision variables
(real or integer)

minimize f:
Decision variables
(real or integer)
Objective
function

minimize f:
Decision variables
(real or integer)
Objective
function
Constraints

minimize f:
Decision variables
(real or integer)
Objective
function
Constraints
Linear

Full model
param m; param n; param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J}; param d{K};
param a{I, J}; param e{I, K}; param b{I};
var x{J} integer, >= 0;
var y{K} >= 0;
minimize f: sum{j in J} c[j] * x[j] + sum{k in K} d[k] * y[k];
sum{j in J} a[i,j] * x[j] + sum{k in K} e[i,k] * y[k] <= b[i];

set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
var y{K} >= 0;
Declaration of
variables

set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
var y{K} >= 0;
Parameters

set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
var y{K} >= 0;
Indexing sets

Why MathProg in Scala
Generate constraints
Create derived models
Develop custom resolution methods at high
level
...

MathProg in Scala (deep embedding)
Syntax
Represent MathProg models with Scala data
types
Mimic MathProg syntax with Scala functions
Semantics
Generate MathProg code, others ...

Syntax
types
Semantics
Abstract syntax tree

Syntax
types
Semantics
Smart constructors and
combinators
Abstract syntax tree

MathProg EDSL
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
val m = param("m")
val n = param("n")
val l = param("l")
val I = set("I") := 1 to m
val J = set("J") := 1 to n
val K = set("K") := 1 to l
val c = param("c", J)
val d = param("d", K)
val a = param("a", I, J)
// ...
val x = xvar("x", J).integer >= 0
val y = xvar("y", K) >= 0

MathProg EDSL
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
val m = param("m")
val n = param("n")
val l = param("l")
// ...
set
param
xvar ...

MathProg EDSL
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
val m = param("m")
val n = param("n")
val l = param("l")
// ...
set
param
xvar ...
ParamStat(
"c",
domain = Some(
IndExpr(
List(
IndEntry(
Nil,
SetRef(J)
)
))))

val m = param("m")
val n = param("n")
val l = param("l")
// ...
MathProg EDSL
Scala range
notation for
arithmetic
sets
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;

val m = param("m")
val n = param("n")
val l = param("l")
// ...
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
MathProg EDSL
Varargs for
simple indexing
expressions

val m = param("m")
val n = param("n")
val l = param("l")
// ...
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
MathProg EDSL
Returns a new
variable with the
`integer’ attribute

val m = param("m")
val n = param("n")
val l = param("l")
// ...
MathProg EDSL
Another variable,
now adding the
lower bound
attribute
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;

val m = param("m")
val n = param("n")
val l = param("l")
// ...
param m;
param n;
param l;
set I := 1 .. m;
set J := 1 .. n;
set K := 1 .. l;
param c{J};
param d{K};
param a{I, J};
// ...
var y{K} >= 0;
MathProg EDSL
Everything is
immutable

MathProg EDSL
minimize f:
s.t. g{i in I}:
sum{k in K} e[i,k] * y[k] <=
b[i];
val f =
minimize("f") {
sum(j in J)(c(j) * x(j)) +
sum(k in K)(d(k) * y(k))
}
val g =
st("g", i in I) {
sum(j in J)(a(i, j) * x(j)) +
sum(k in K)(e(i, k) * y(k)) <=
b(i)
}

MathProg EDSL minimize
st ...
minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}

minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}
MathProg EDSL Multiple
parameters lists

minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}
MathProg EDSL addition,
multiplication,
summation ...

minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}
MathProg EDSL References to
individual parameters
and variables by
application

minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}
MathProg EDSL
Constraint

minimize f:
s.t. g{i in I}:
b[i];
val f =
minimize("f") {
}
val g =
st("g", i in I) {
b(i)
}
MathProg EDSL
Creates a new
constraint with the
specified name and
indexing

Implementing the syntax
Many of the syntactic constructs require:
A broad (open?) number of overloadings
Be used with infix notation

type classes and
object-oriented forwarders

type classes and
object-oriented forwarders
implicits prioritization

Implementing the syntax: “>=”
param("p", J) >= 0

param("p", J) >= 0
ParamStat

param("p", J) >= 0
ParamStat
ParamStat doesn’t have a `>=’
method

param("p", J) >= 0
implicit conversion to
something that
provides the method
ParamStat doesn’t have a `>=’
method
ParamStat

param("p", J) >= 0 // ParamStat
param("p", J) >= p2 // ParamStat
xvar("x", I) >= 0 // VarStat
i >= j // LogicExpr
p(j1) >= p(j2) // LogicExpr
x(i) >= 0 // ConstraintStat
10 >= x(i) // ConstraintStat
Many overloadings
… more

implicit class GTESyntax[A](lhe: A) {
def >=[B, C](rhe: B)(implicit GTEOp: GTEOp[A,B,C]): C =
GTEOp.gte(lhe, rhe)
}

GTEOp.gte(lhe, rhe)
}
Fully generic

GTEOp.gte(lhe, rhe)
}
trait GTEOp[A,B,C] {
def gte(lhe: A, rhe: B): C
}
Type class

GTEOp.gte(lhe, rhe)
}
trait GTEOp[A,B,C] {
def gte(lhe: A, rhe: B): C
}
Type class
The implementation is
forwarded to the implicit
instance

GTEOp.gte(lhe, rhe)
}
The available implicit instances
encode the rules by which the
operators can be used

GTEOp.gte(lhe, rhe)
}
The instance of the type class is
required at the method level, so
both A and B can be used in the
implicits search

instances
implicit def ParamStatGTEOp[A](
implicit conv: A => NumExpr):
GTEOp[ParamStat, A, ParamStat] = /* ... */
>= for parameters and “numbers”
param(“p”) >= m

instances
GTEOp[ParamStat, A, ParamStat] = /* ... */
>= for parameters and “numbers”
param(“p”) >= m
View bound

instances
implicit def VarStatGTEOp[A](
GTEOp[VarStat, A, VarStat] = /* ... */
>= for variables and “numbers”
xvar(“x”) >= m
Analogous to the
parameter case

instances
implicit def NumExprGTEOp[A, B](
implicit convA: A => NumExpr,
convB: B => NumExpr):
GTEOp[A, B, LogicExpr] = /* ... */
>= for two “numbers”
i >= j

instances
implicit def LinExprGTEOp[A, B](
implicit convA: A => LinExpr,
convB: B => LinExpr):
GTEOp[A, B, ConstraintStat] = /* ... */
>= for two “linear expressions”
x(i) >= 0 and 10 >= x(i)
Analogous to the
numerical
expression case

convB: B => NumExpr)
conflicts with:
implicit conv: A => NumExpr)
convB: B => LinExpr)
Instances are ambiguous

conflicts with:
`ParamStat <% NumExpr‘
to allow
`param(“p2”) >= p1’

conflicts with:
NumExpr <: LinExpr
=>
NumExpr <% LinExpr

Implicits prioritization
trait GTEInstances extends GTEInstancesLowPriority1 {
implicit def ParamStatGTEOp[A](implicit conv: A => NumExpr) /* */
implicit def VarStatGTEOp[A](implicit conv: A => NumExpr) /* */
}
trait GTEInstancesLowPriority1 extends GTEInstancesLowPriority2 {
implicit convA: A => NumExpr, convB: B => NumExpr) /* */
}
trait GTEInstancesLowPriority2 {
implicit convA: A => LinExpr, convB: B => LinExpr) /* */
}

Implicits prioritization
trait GTEInstances extends GTEInstancesLowPriority1 {
implicit def ParamStatGTEOp[A](implicit conv: A => NumExpr) /* */
implicit def VarStatGTEOp[A](implicit conv: A => NumExpr) /* */
}
trait GTEInstancesLowPriority1 extends GTEInstancesLowPriority2 {
implicit convA: A => NumExpr, convB: B => NumExpr) /* */
}
trait GTEInstancesLowPriority2 {
implicit convA: A => LinExpr, convB: B => LinExpr) /* */
}
> priority
> priority

Next steps
New semantics
More static controls
Support other kind of problems beyond MIP
Talk directly to solvers
Arity, scope, ...
Multi-stage stochastic programming

import amphip.dsl._import amphip.dsl._
amphip is a collection of
experiments around
manipulating MathProg
models within Scala
github.com/gerferra/amphip
amphip is a collection of
experiments around
manipulating MathProg
models within Scala

FIN

An embedded DSL to manipulate MathProg Mixed Integer Programming models within Scala

More Related Content

Viewers also liked (14)

Recently uploaded (20)

An embedded DSL to manipulate MathProg Mixed Integer Programming models within Scala