Orx.MathProg Namespace

Constraint xyRelation =
    key("x-y relation")
    | "capacity of a location can be used only if it is opened"
    | forall(p)
    | x[p] <= M * y[p];

// sets
Set j = Set("j").Represents("a node of the network").HasElementsUntil(data.NumNodes);
Set i = Set("i").Represents("nodes which have an edge into node j").DependsOn(j).HasElements(j => data.TailsOf(j));
Set k = Set("k").Represents("nodes which have an edge from node j").DependsOn(j).HasElements(j => data.HeadsOf(j));
Set c = Set("c").Represents("a commodity to be transported").HasElementsUntil(data.NumCommodities);

// parameters
ParD2 capacity = Parameter("cap").Represents("capacity of arc (j,k)").HasIndices(j, k).HasValues(data.GetEdgeCapacity);
ParD2 nodeBalance = Parameter("b").Represents("equal to (negative of) demand of commodity c if j is its (source) sink node").HasIndices(c, j).HasValues(data.GetNodeBalance);
ParD3 cost = Parameter("cost").Represents("cost of unit flow of commodity c on arc (j, k)").HasIndices(j, k, c).HasValues(1);

// variables
VarD3 f = Variable("f").Represents("flow of commodity c on arc (j,k)").HasIndices(j, k, c).IsContinuous().IsNonnegative();

// constraints
Constraint conFlowBal = key("flowBal")
    | "flow balance constraint at node j"
    | forall(j)
    | sum(over(c, i), f[i, j, c]) - sum(over(c, k), f[j, k, c]) == nodeBalance[c, j];

Constraint conCapacity = key("capacity")
    | "capacity constraint of arc (j, k)"
    | forall(j, k)
    | sum(over(c), f[j, k, c]) <= capacity[j, k]; 

// objective
Objective totalCost = key("minFlowCost")
    | "minimize total flow cost"
    | minimize
    | sum(over(c, j, k), cost[j, k, c] * f[j, k, c]);

// mathematical model
var model =
    MathModel.New("multi-commodity mcnf problem")
    .Represents("multi commodity minimum cost network flow problem")
    .WithObjective(totalCost)
    .HasConstraints(conFlowBal, conCapacity);

// i, j: nodes
// x[i, j]: arc flow variable
// cost[i, j]: unit flow cost on arc (i,j)
// fixedCost[i]: fixed cost of including node i in the network
Objective minFlowCost = minimize | sum(over(i, j), cost[i, j] * x[i, j]);
Objective minTotalCost = minimize | sum(over(i, j), cost[i, j] * x[i, j]) + sum(over(i), fixedCost[i] * y[i]);

// p: person; t: task
// utility[p, t]: utility of person p when assigned to task t
// fitness[p, t]: fitness of person p's skills to task t
// revenue[t]: revenue of completing task t
// x[p, t]: 1 if person p is assigned to task t; 0 o/w
MathExpr totalUtility = sum(over(p, t), utility[p, t] * x[p, t]);
MathExpr totalFitness = sum(over(p, t), fitness[p, t] * x[p, t]);
MathExpr totalRevenue = sum(over(p, t), revenue[t] * x[p, t]);

double weightUtility = 0.40;
double weightFitness = 0.35;
double weightRevenue = 0.25;

Objective weighted = maximize
                    | weightUtility * totalUtility + weightFitness * totalFitness + weightRevenue * totalRevenue

Sca s = 42;
Sca s = 4.2;
Sca s = i; // where i is a .
Sca s = 2 * i;
Sca s = M; // where M is a .
Sca s = demand[i]; // where demand is a .
Sca s = (i * demand[i] + 2) / density[i]; // where density also is a .

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

Set i = ...;
Set j = ...;
VarD2 x = ...; // arc flow variable
ParD1 supply = ...; // parameter representing the supply at each node

Constraint flowBal = forall(i)
                    | sum(over(j), x[i, j]) == sum(over(j), x[j, i]) + supply[i];

sum(over(i),       y[i])
sum(over(j),       x[i, j])
sum(over(i, j),    cost[i, j] * x[i, j])
sum(over(i, j, c), cost[i, j] * x[i, j, c] + fixed[c] * y[i, j, c])

sum(over(i, k), y[i])