MathProgExtensions Class

It is followed by a pipe operator and an expression to create the objective function.

Objective maxRevenue
    key("total revenue")
    | "Total revenue obtained by completed tasks by assigning a resource"
    | maximize
    | sum(over(r, t), revenue[t] * x[r, t]);

It is followed by a pipe operator and an expression to create the objective function.

Objective minCost
    key("total cost")
    | "Sum of total flow and design cost of all edges."
    | minimize
    | sum(over(j, i), costFlow[i, j] * x[i, j] + costDesign[i, j] * y[i, j]);

This is a shorthand for

Objective obj = minimize | 0

The set generates elements in [0, getIndicesByDependsSet(i)); where i is the value of the dependent set.

Consider the following example.

int numNodes = 4;
List<(int, int)> edges = new()
{
    (0, 1),
    (0, 2),
    (1, 2),
    (1, 3),
    (2, 3),
};
IEnumerable<int> getHeads(int i)
    => edges.Where(e => e.Item1 == i).Select(x => x.Item2);

Set i = Set("i").Represents("nodes").HasElementsUntil(numNodes);
Set j = Set("j").Represents("nodes having an arc from node i").DependsOn(i).HasElements(getHeads);

Here, set i has indices { 0, 1, 2, 3 }.

Set j, on the other hand, depends on set i. In other words, it will generate different elements for different values of i:

• when i takes value 0; j has elements { 1, 2 },
• when i takes value 1; j has elements { 2, 3 },
• when i takes value 2; j has elements { 3 }, and
• when i takes value 3; j is empty set.

The set generates elements in [0, getIndicesByDependsSets(i, j)); where i and j are the values of the dependent sets.

Consider the following example.

int numNodes = 4;
List<(int, int)> edges = new()
{
    (0, 1),
    (0, 2),
    (1, 2),
    (1, 3),
    (2, 3),
};
IEnumerable<int> getHeads(int i)
    => edges.Where(e => e.Item1 == i).Select(x => x.Item2);

Set i = Set("i").Represents("nodes").HasElementsUntil(numNodes);
Set j = Set("j").Represents("nodes having an arc from node i").DependsOn(i).HasElements(getHeads);

Here, set i has indices { 0, 1, 2, 3 }.

Set j, on the other hand, depends on set i. In other words, it will generate different elements for different values of i:

• when i takes value 0; j has elements { 1, 2 },
• when i takes value 1; j has elements { 2, 3 },
• when i takes value 2; j has elements { 3 }, and
• when i takes value 3; j is empty set.

The set generates elements in [0, getUntil(i)); where i is the value of the dependent set.

For instance, consider the following sets.

Set t2 = Set("t2").Represents("time periods").HasElementsUntil(4);
Set t1 = Set("t1").Represents("time periods until t2").DependsOn(t2).HasElementsUntil(t1 => t1 + 1);

Set t2 has elements { 0, 1, 2, 3 }.

Set t1 depends on t2; hence, generates different indices for different values of t2:

• when t1 = 0; t2 has elements { 0 },
• when t1 = 1; t2 has elements { 0, 1 },
• when t1 = 2; t2 has elements { 0, 1, 2 },
• when t1 = 3; t2 has elements { 0, 1, 2, 3 }.

The set generates exactly the elements of the dependent set except for its value.

For instance, consider the following sets.

Set i = Set("i").Represents("node").HasElementsUntil(3);
Set j = Set("j").Represents("node except for i").DependsOn(i).HasSameElementsExceptParent();

Set i has elements { 0, 1, 2 }.

Set j depends on set i; hence, has different elements for different values of i:

• when i=0; j has elements { 1, 2 },
• when i=1; j has elements { 0, 2 },
• when i=2; j has elements { 0, 1 }.

The resulting parameter has the given value.

Value of the resulting parameter will be obtained by the given function.

The resulting parameter has values defined by the given 1-dimensional functional vector.

The resulting parameter has values defined by the given 2-dimensional functional vector.

The resulting parameter has values defined by the given 3-dimensional functional vector.

The resulting parameter has values defined by the given 4-dimensional functional vector.

The resulting variable is unboundd; i.e., in [0, 1].

The resulting variable is unboundd; i.e., in [0, 1].

The resulting variable is unboundd; i.e., in [0, 1].

The resulting variable is unboundd; i.e., in [0, 1].

The resulting variable is unboundd; i.e., in [0, 1].

The resulting variable is binary (0/1) which can take either value 0 or 1.

The resulting variable is binary (0/1) which can take either value 0 or 1.

The resulting variable is binary (0/1) which can take either value 0 or 1.

The resulting variable is binary (0/1) which can take either value 0 or 1.

The resulting variable is binary (0/1) which can take either value 0 or 1.

The resulting variable is nonnegative; i.e., in [0, infinity).

The resulting variable is nonnegative; i.e., in [0, infinity).

The resulting variable is nonnegative; i.e., in [0, infinity).

The resulting variable is nonnegative; i.e., in [0, infinity).

The resulting variable is nonnegative; i.e., in [0, infinity).

The resulting variable is nonpositive; i.e., in (-infinity, 0].

The resulting variable is nonpositive; i.e., in (-infinity, 0].

The resulting variable is nonpositive; i.e., in (-infinity, 0].

The resulting variable is nonpositive; i.e., in (-infinity, 0].

The resulting variable is nonpositive; i.e., in (-infinity, 0].

The resulting variable is unboundd; i.e., in (-infinity, infinity).

The resulting variable is unboundd; i.e., in (-infinity, infinity).

The resulting variable is unboundd; i.e., in (-infinity, infinity).

The resulting variable is unboundd; i.e., in (-infinity, infinity).

The resulting variable is unboundd; i.e., in (-infinity, infinity).

See below three ways to create a flow balance constraint with different levels of details.

Set j = Set("j").Represents("Nodes of the network.").HasElementsUntil(data.NumNodes);
Set i = Set("i").Represents("Tails of edges incoming to j").DependsOn(j).HasElements(data.TailsOf);
Set k = Set("k").Represents("Heads of edges outgoing from j").DependsOn(j).HasElements(data.HeadsOf);
ParD1 demand = Parameter("dem").Represents("Node demand; i.e., amount of flow that needs to be transported to each node.")
    .HasIndices(i).HasValues(data.NodeDemand);

// no details
Constraint flowBalance =
    forall(j)
    | sum(over(i), x[i, j]) - sum(over(k), x[j, k]) == demand[j];

// only with constraint key; this enables matching the constraint in the lp files;
// also makes automatically generated LaTeX, html or text documentation easier to read.
Constraint flowBalance =
    key("flowbal")
    | forall(j)
    | sum(over(i), x[i, j]) - sum(over(k), x[j, k]) == demand[j];

// or with definition to be included in the documentations
Constraint flowBalance =
    key("flowbal")
    | "Flow balance constraints for every node j."
    | forall(j)
    | sum(over(i), x[i, j]) - sum(over(k), x[j, k]) == demand[j];

Similarly, keys and definitions can be included in or omitted from objective function definitions.

// no details
Objective minTotalCost =
    minimize
    | sum(over(j, i), costFlow[i, j] * x[i, j]);

// only key
Objective minTotalCost =
    key("totalcost")
    | minimize
    | sum(over(j, i), costFlow[i, j] * x[i, j]);

// with definition to be included in the documentations
Objective minTotalCost =
    key("totalcost")
    | "Total flow cost of all edges."
    | minimize
    | sum(over(j, i), costFlow[i, j] * x[i, j]);

Builder pattern is used for creating all mathematical symbols, to make creating rather complicated variants more convenient.

ParD0 bigM = Parameter("M").Represents("sufficiently large number").HasValue(Math.Max(demands.Max(), capacities.Max()));
ParD0 lazyBigM = Parameter("M").Represents("sufficiently large number").HasValue(() => Math.Max(demands.Max(), capacities.Max()));

ParD1 demand = Parameter("dem").Represents("Node demand; i.e., amount of flow that needs to be transported to each node.")
    .HasIndices(i).HasValues(data.NodeDemand);

ParD2 costFlow = Parameter("c").Represents("Unit flow cost on edge (i, j).").HasIndices(i, j).HasValues(data.EdgeFlowCost);

// or definitions can be omitted; however, they might be useful in automatically generated LaTex, html or text documentations.
ParD0 bigM = Parameter("M").HasValue(Math.Max(demands.Max(), capacities.Max()));
ParD0 lazyBigM = Parameter("M").HasValue(() => Math.Max(demands.Max(), capacities.Max()));
ParD1 demand = Parameter("dem").HasIndices(i).HasValues(data.NodeDemand);
ParD2 costFlow = Parameter("c").HasIndices(i, j).HasValues(data.EdgeFlowCost);

Builder pattern is used for creating all mathematical symbols, to make creating rather complicated variants more convenient.

Some example set constructions are given below:

Set j = Set("j").Represents("Nodes of the network.").HasElementsUntil(data.NumNodes);
Set i = Set("i").Represents("Tails of edges incoming to j").DependsOn(j).HasElements(data.TailsOf);
Set k = Set("k").Represents("Heads of edges outgoing from j").DependsOn(j).HasElements(data.HeadsOf);

// or definitions can be omitted; however, they might be useful in automatically generated LaTex, html or text documentations.
Set j = Set("j").HasElementsUntil(data.NumNodes);
Set i = Set("i").DependsOn(j).HasElements(data.TailsOf);
Set k = Set("k").DependsOn(j).HasElements(data.HeadsOf);

Builder pattern is used for creating all mathematical symbols, to make creating rather complicated variants more convenient.

VarD0 maxTardiness = Variable("maxTard").Represents("Maximum tardiness of all tasks").IsContinuous().IsNonnegative();

VarD1 y = Variable("y").Represents("Whether or not location p is included in the design").HasIndices(p).IsBinary();

VarD2 x = Variable("x").Represents("Amount of flow on each edge (i, j)").HasIndices(i, j).IsContinuous().WithBounds(0.0, getEdgeCapacity);

// or definitions can be omitted; however, they might be useful in automatically generated LaTex, html or text documentations.
VarD0 maxTardiness = Variable("maxTard").IsContinuous().IsNonnegative();
VarD1 y = Variable("y").HasIndices(p).IsBinary();
VarD2 x = Variable("x").HasIndices(i, j).IsContinuous().WithBounds(0.0, getEdgeCapacity);

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.

The resulting variable has the given lower and upper bounds.