The first several PROC OPTMODEL statements declare index sets and parameters and then read the input data:

proc optmodel;
   set <str,str> ARCS;
   num cost {ARCS};
   read data arc_data into ARCS=[i j] cost;

   set <str> FACTORIES;
   num capacity {FACTORIES};
   read data factory_data into FACTORIES=[factory] capacity;

   set <str> DEPOTS;
   num throughput {DEPOTS};
   read data depot_data into DEPOTS=[depot] throughput;

   set <str> CUSTOMERS;
   num demand {CUSTOMERS};
   read data customer_data into CUSTOMERS=[customer] demand;

The following statements use the UNION set operator to declare the NODES index set, declare the supply parameter with an initial value of 0, and populate supply for both factories and customers:

   set NODES = FACTORIES union DEPOTS union CUSTOMERS;
   num supply {NODES} init 0;
   for {i in FACTORIES} supply[i] = capacity[i];
   for {i in CUSTOMERS} supply[i] = -demand[i];

The following statements declare the variables, constraints, and TotalCost objective:

   var Flow {ARCS} >= 0;

   con Flow_balance_con {i in NODES}:
      sum {<(i),j> in ARCS} Flow[i,j] - sum {<j,(i)> in ARCS} Flow[j,i]
   <= supply[i];

   con Depot_con {i in DEPOTS}:
      sum {<(i),j> in ARCS} Flow[i,j] <= throughput[i];

   min TotalCost = sum {<i,j> in ARCS} cost[i,j] * Flow[i,j];

The following statements call the default linear programming algorithm (which is the dual simplex algorithm), print the positive variables in the resulting optimal solution, and print the left-hand side (.body), right-hand side (.ub), and dual value (.dual) of each constraint:

   put 'Minimizing TotalCost...';
   solve;
   print {<i,j> in ARCS: Flow[i,j].sol > 0} Flow;
   print Flow_balance_con.body Flow_balance_con.ub Flow_balance_con.dual;
   print Depot_con.body Depot_con.ub Depot_con.dual;

Figure 19.2 shows the output when you use the (default) dual simplex algorithm.

The following statements call the network simplex linear programming algorithm and print the same solution information as before:

   put 'Minimizing TotalCost by using network simplex...';
   solve with LP / algorithm=ns;
   print {<i,j> in ARCS: Flow[i,j].sol > 0} Flow;
   print Flow_balance_con.body Flow_balance_con.ub Flow_balance_con.dual;
   print Depot_con.body Depot_con.ub Depot_con.dual;

Figure 19.3 shows the output when you use the ALGORITHM=NS option to invoke the network simplex algorithm.

The following statements call the linear programming solver to minimize NonpreferredFlow and print both objectives, the positive variables in the resulting optimal solution, and the flow along nonpreferred arcs:

   set <str,str> PREFERRED_ARCS;
   read data preferred_arc_data into PREFERRED_ARCS=[i j];
   set CUSTOMERS_WITH_PREFERENCES = setof {<i,j> in PREFERRED_ARCS} j;
   min NonpreferredFlow =
      sum {<i,j> in ARCS diff PREFERRED_ARCS: j in CUSTOMERS_WITH_PREFERENCES}
         Flow[i,j];

   put 'Minimizing NonpreferredFlow...';
   solve;
   print TotalCost NonpreferredFlow;
   print {<i,j> in ARCS: Flow[i,j].sol > 0} Flow;
   print
      {<i,j> in ARCS diff PREFERRED_ARCS: j in CUSTOMERS_WITH_PREFERENCES}
         Flow;

Figure 19.4 shows the output from the linear programming solver.

The following CON statement declares a constraint that limits NonpreferredFlow to the minimum value found in the previous solve:

   con Objective_cut:
      NonpreferredFlow <= NonpreferredFlow.sol;

The following statements call the linear programming solver to minimize TotalCost with a constrained NonpreferredFlow and print the same solution information as before:

   put 'Minimizing TotalCost with constrained NonpreferredFlow...';
   solve obj TotalCost;
   print TotalCost NonpreferredFlow;
   print {<i,j> in ARCS: Flow[i,j].sol > 0} Flow;
   print
      {<i,j> in ARCS diff PREFERRED_ARCS: j in CUSTOMERS_WITH_PREFERENCES}
         Flow;
quit;

Figure 19.5 shows the output from the linear programming solver. As expected, NonpreferredFlow remains at its minimum value and TotalCost is less than its value from Figure 19.4.