The Dantzig-Wolfe Decomposition Algorithm

Example 19.3 Block-Diagonal Structure and METHOD=CONCOMP

This example demonstrates how you can use the METHOD=CONCOMP option in the DECOMP statement to run the Dantzig-Wolfe decomposition algorithm.

Consider a mixed integer linear program that is defined by the MPS data table mylib.mpsdata. In this case, the structure of the model is unknown and only the MPS data table is provided to you.

The following PROC OPTMILP statements solve the problem by using standard methods.

proc optmilp
   nthreads = 4
   data     = mylib.mpsdata;
run;

The solution summary is shown in Output 19.3.1.

Output 19.3.1: Solution Summary

The OPTMILP Procedure

Solution Summary
SolverMILP
AlgorithmBranch and Cut
Objective FunctionR0001298
Solution StatusOptimal
Objective Value120
  
Relative Gap0
Absolute Gap0
Primal Infeasibility6.833871E-14
Bound Infeasibility3.036909E-14
Integer Infeasibility1.998401E-14
  
Best Bound120
Nodes287
Solutions Found9
Iterations41238
  
Presolve Time0.02
Solution Time0.94


The iteration log, which contains the problem statistics and the progress of the solution, is shown in Output 19.3.2.

Output 19.3.2: Log

NOTE: The problem MPSDATA has 388 variables (36 binary, 0 integer, 1 free, 0 fixed).            
NOTE: The problem has 1297 constraints (630 LE, 37 EQ, 630 GE, 0 range).                        
NOTE: The problem has 4204 constraint coefficients.                                             
NOTE: The initial MILP heuristics are applied.                                                  
NOTE: The MILP presolver value AUTOMATIC is applied.                                            
NOTE: The MILP presolver removed 37 variables and 37 constraints.                               
NOTE: The MILP presolver removed 424 constraint coefficients.                                   
NOTE: The MILP presolver modified 0 constraint coefficients.                                    
NOTE: The presolved problem has 351 variables, 1260 constraints, and 3780 constraint            
      coefficients.                                                                             
NOTE: The MILP solver is called.                                                                
NOTE: The parallel Branch and Cut algorithm is used.                                            
NOTE: The Branch and Cut algorithm is using up to 4 threads.                                    
NOTE: The problem has a decomposable structure with 4 blocks. The largest block covers 25.08%   
      of the constraints in the problem.                                                        
          Node   Active   Sols    BestInteger      BestBound      Gap    Time                   
             0        1      3    161.0000000              0    161.0       0                   
             0        1      3    161.0000000     91.4479396   76.06%       0                   
             0        1      3    161.0000000    111.7932692   44.02%       0                   
NOTE: The MILP presolver is applied again.                                                      
             0        1      4    128.0000000    111.7932692   14.50%       0                   
             0        1      5    127.0000000    111.7932692   13.60%       0                   
             0        1      5    127.0000000    112.1093044   13.28%       0                   
NOTE: The MILP solver added 1 cuts with 5 cut coefficients at the root.                         
            10        8      6    126.0000000    112.8931466   11.61%       0                   
            44       36      7    124.0000000    113.2187120    9.52%       0                   
            61       47      8    120.0000000    113.2769146    5.94%       0                   
           168       60      9    120.0000000    116.1478841    3.32%       0                   
           286        0      9    120.0000000    120.0000000    0.00%       0                   
NOTE: Optimal.                                                                                  
NOTE: Objective = 120.                                                                          
NOTE: The Cloud Analytic Services server processed the request in 1.005705 seconds.             


A note in the log mentions that the problem structure is decomposable. The following PROC OPTMILP statements use the METHOD=CONCOMP option in the DECOMP statement to solve the problem using the Dantzig-Wolfe decomposition algorithm.

proc optmilp
   nthreads    = 4
   data        = mylib.mpsdata;
   decomp
      loglevel = moderate
      method   = concomp;
run;

The solution summary is displayed in Output 19.3.3.

Output 19.3.3: Solution Summary

The OPTMILP Procedure

Solution Summary
SolverMILP
AlgorithmDecomposition
Objective FunctionR0001298
Solution StatusOptimal
Objective Value120
  
Relative Gap0
Absolute Gap0
Primal Infeasibility0
Bound Infeasibility0
Integer Infeasibility0
  
Best Bound120
Nodes1
Solutions Found4
Iterations1
  
Presolve Time0.00
Solution Time0.41


The iteration log, which contains the problem statistics and the progress of the solution, is shown in Output 19.3.4. When you specify NTHREADS=4 in the PROC OPTMILP statement, the blocks are processed simultaneously on four threads.

Output 19.3.4: Log

NOTE: The problem MPSDATA has 388 variables (36 binary, 0 integer, 1 free, 0 fixed).            
NOTE: The problem has 1297 constraints (630 LE, 37 EQ, 630 GE, 0 range).                        
NOTE: The problem has 4204 constraint coefficients.                                             
NOTE: The initial MILP heuristics are applied.                                                  
NOTE: The MILP presolver value AUTOMATIC is applied.                                            
NOTE: The MILP presolver removed 37 variables and 37 constraints.                               
NOTE: The MILP presolver removed 424 constraint coefficients.                                   
NOTE: The MILP presolver modified 0 constraint coefficients.                                    
NOTE: The presolved problem has 351 variables, 1260 constraints, and 3780 constraint            
      coefficients.                                                                             
NOTE: The MILP solver is called.                                                                
NOTE: The Decomposition algorithm is used.                                                      
NOTE: The Decomposition algorithm is executing in the distributed computing environment in      
      single-machine mode.                                                                      
NOTE: The DECOMP method value CONCOMP is applied.                                               
NOTE: The decomposition identification used 0.00 (cpu: 0.00) seconds.                           
NOTE: The problem has a decomposable structure with 4 blocks. The largest block covers 25.08%   
      of the constraints in the problem.                                                        
NOTE: The decomposition subproblems cover 351 (100%) variables and 1260 (100%) constraints.     
NOTE: Block 1 has 88 (25.07%) variables and 316 (25.08%) constraints.                           
NOTE: Block 2 has 88 (25.07%) variables and 316 (25.08%) constraints.                           
NOTE: Block 3 has 88 (25.07%) variables and 316 (25.08%) constraints.                           
NOTE: Block 4 has 87 (24.79%) variables and 312 (24.76%) constraints.                           
NOTE: The deterministic parallel mode is enabled.                                               
NOTE: The Decomposition algorithm is using up to 4 threads.                                     
NOTE: ------------------------------------------------------------------                        
NOTE: Starting to process node 0.                                                               
NOTE: ------------------------------------------------------------------                        
NOTE: Using a starting solution with objective value 161 to provide initial columns.            
NOTE: Using a starting solution with objective value 231 to provide initial columns.            
NOTE: Using a starting solution with objective value 231 to provide initial columns.            
NOTE: The initial column pool using the starting solution contains 8 columns.                   
NOTE: The subproblem solver for 4 blocks at iteration 0 is starting.                            
NOTE: The subproblem solver for 4 blocks used 0.38 (cpu: 1.17, max: 0.38) seconds.              
NOTE: The initial column pool after generating initial variables contains 12 columns.           
      Iter         Best       Master         Best       LP       IP  CPU Real                   
                  Bound    Objective      Integer      Gap      Gap Time Time                   
NOTE: The master solver at iteration 1 is starting.                                             
NOTE: The master solver used 0.00 (cpu: 0.00) seconds and 6 iterations.                         
         1     120.0000     120.0000     120.0000    0.00%    0.00%    1    0                   
NOTE: The number of active nodes is 1.                                                          
NOTE: The objective value of the best integer feasible solution is 120.0000 and the best bound  
      is 120.0000.                                                                              
NOTE: The Decomposition algorithm used 4 threads.                                               
NOTE: The Decomposition algorithm time is 0.41 seconds.                                         
NOTE: Optimal.                                                                                  
NOTE: Objective = 120.                                                                          
NOTE: The Cloud Analytic Services server processed the request in 0.47557 seconds.              


In this case, the solver finds that after the presolve, the constraint matrix decomposes into block-diagonal form. That is, all the constraints are covered by subproblem blocks, leaving the set of master constraints empty. Because there are no coupling constraints, the problem decomposes into four completely independent problems. If you specify LOGLEVEL=MODERATE in the DECOMP statement, the log displays the size of each block. The blocks in this case are nicely balanced, allowing parallel execution to be efficient.

Last updated: September 09, 2026