This example uses both one-dimensional and dense two-dimensional data, as in Chapter 2 and Chapter 3:

proc optmodel;
   set <str> PRODUCTS;
   num profit {PRODUCTS};
   read data product_data into PRODUCTS=[product] profit;

   set PERIODS;
   num demand {PRODUCTS, PERIODS};
   read data demand_data into PERIODS=[_N_]
      {product in PRODUCTS} <demand[product,_N_]=col(product)>;

   set <str> MACHINE_TYPES;
   num num_machines {MACHINE_TYPES};
   read data machine_type_data into MACHINE_TYPES=[machine_type] num_machines;

But this problem also has sparse two-dimensional data: for most pairs, the number of machines down is 0. In the following statements, the INIT option in the second NUM statement initializes num_machines_down_per_period to 0. The read of the sparse data set machine_type_period_data populates only the nonzero values. The subsequent computation of num_machines_per_period[machine_type,period] then uses the initial value of num_machines_down_per_period[machine_type,period] when no other value has been supplied:

   num num_machines_per_period {machine_type in MACHINE_TYPES, PERIODS} 
      init num_machines[machine_type];
   num num_machines_down_per_period {MACHINE_TYPES, PERIODS} init 0;
   read data machine_type_period_data into [machine_type period]
      num_machines_down_per_period=num_down;
   for {machine_type in MACHINE_TYPES, period in PERIODS}
      num_machines_per_period[machine_type,period] = 
      num_machines_per_period[machine_type,period] 
    - num_machines_down_per_period[machine_type,period];
   print num_machines_per_period;

Figure 4.1 shows the resulting values of num_machines_per_period.

The following statements declare and read dense two-dimensional data:

   num production_time {PRODUCTS, MACHINE_TYPES};
   read data machine_type_product_data into [machine_type] 
      {product in PRODUCTS} 
      <production_time[product,machine_type]=col(product)>;

The following statements are straightforward:

   var Make {PRODUCTS, PERIODS} >= 0;
   var Sell {product in PRODUCTS, period in PERIODS} >= 0 
      <= demand[product,period];

   num last_period = max {period in PERIODS} period;
   var Store {PRODUCTS, PERIODS} >= 0 <= &store_ub;
   for {product in PRODUCTS}
      fix Store[product,last_period] = &final_storage;

   impvar StorageCost = 
      sum {product in PRODUCTS, period in PERIODS} 
         &storage_cost_per_unit * Store[product,period];
   max TotalProfit = 
      sum {product in PRODUCTS, period in PERIODS}
         profit[product] * Sell[product,period] 
    - StorageCost;

   con Machine_hours_con {machine_type in MACHINE_TYPES, period in PERIODS}:
      sum {product in PRODUCTS}
         production_time[product,machine_type] * Make[product,period] 
   <= &num_hours_per_period * num_machines_per_period[machine_type,period];

The following Flow_balance_con constraint uses an IF-THEN/ELSE expression to handle the boundary conditions: if a previous period exists, the units in storage at the end of the previous period are available to be sold in the current period. (Because ELSE 0 is the default, you could use just an IF-THEN expression instead.)

   con Flow_balance_con {product in PRODUCTS, period in PERIODS}:
      (if period - 1 in PERIODS then Store[product,period-1] else 0) 
    + Make[product,period] 
    = Sell[product,period] + Store[product,period];

   solve;
   print Make Sell Store;

The maximum total profit is £93,715, as shown in Figure 4.2.

You can use the .dual constraint suffix to access the optimal dual variables returned by the solver:

   print Machine_hours_con.dual;
   create data sol_data1 from [product period] Make Sell Store;
quit;

These values, shown in Figure 4.3, suggest the change in optimal objective value if the factory acquires an additional machine in that period. For this test instance, it turns out that the positive dual variables all correspond to machines that are down.