FICO
FICO Xpress Optimization Examples Repository
FICO Optimization Community FICO Xpress Optimization Home
Back to examples browserPrevious exampleNext example

UG - Examples from 'BCL Reference Manual'

Description
The following examples are discussed in detail in the 'BCL User Guide and Reference Manual':
  • modeling and solving a small MIP scheduling problem (xbexpl1 version BASIC)
  • using variable arrays and constraint templates (xbexpl1 versions ARRAY and ARRAYC)
  • definition of SOS-1 (xbexpl1 version SOS)
  • data input from file, index sets (xbexpl1i)
  • user error handling, output redirection (xbexpl3)
  • solving multiple scenarios of a transportation problem in parallel (xbexpl2: standard, single thread version)
  • cut generation / adding cuts at MIP tree nodes (xbcutex)
  • quadratic programming (quadratic objective: xbqpr12, quadratic constraints: xbairport)
  • combine BCL problem input with problem solving in Xpress Optimizer (xbcontr1)
  • use an Xpress Optimizer solution callback with a BCL model (xbcontr2s: single MIP thread; xbcontr2: multiple MIP threads)
Further explanation of this example: 'BCL Reference Manual', Appendix B Using BCL with the Optimizer library


Source Files

Data Files





xbexpl1.java

/********************************************************
  Xpress-BCL Java Example Problems
  ================================

  file xbexpl1.java
  `````````````````
  BCL user guide example.
  Definition of variables and constraints, 
  variable arrays and SOS, followed by file output,
  solving and printing of solutions.

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Jan. 2000, rev. Dec. 2011
********************************************************/

import java.io.*;
import com.dashoptimization.*;

public class xbexpl1
{
/**************************************************************************/
/* Expl 1: This example corresponds to the one printed in the             */
/*  BCL User Guide. It shows how to define variables and                  */
/*  constraints, and Special Ordered Sets, followed by file output,       */
/*  solving and printing of solutions.                                    */
/* Set the following parameter to true to try out a problem formulation   */
/* using Special Ordered Sets:                                            */

 static final boolean SOS = false;

/**************************************************************************/

 static final int NJ = 4;        /* Number of jobs */   
 static final int NT = 10;       /* Time limit */   

/**** DATA ****/
 static final double[] DUR = {3,4,2,2};   /* Durations of jobs   */ 

 static XPRBvar[] start;         /* Start times of jobs  */ 
 static XPRBvar[][] delta;       /* Binaries for start times */  
 static XPRBvar z;               /* Maximum completion time (makespan) */ 
 static XPRBsos[] set;           /* Sets regrouping start times for jobs */

 static XPRB bcl;
 static XPRBprob p; 
             
/*************************************************************************/

 static void jobsModel() throws IOException
 {
  XPRBexpr le;
  int j,t;

/****VARIABLES****/
  start = new XPRBvar[NJ];       /* Create start time variables */
  for(j=0;j<NJ;j++) start[j] = p.newVar("start");
  z = p.newVar("z",XPRB.PL,0,NT);  /* Declare the makespan variable */

  delta = new XPRBvar[NJ][NT];
  for(j=0;j<NJ;j++)              /* Declare binaries for each job  */
   for(t=0;t<(NT-DUR[j]+1);t++)
    delta[j][t] = p.newVar("delta"+(j+1)+(t+1), XPRB.BV);

/****CONSTRAINTS****/
  for(j=0;j<NJ;j++)              /* Calculate maximal completion time */
   p.newCtr("Makespan", start[j].add(DUR[j]).lEql(z) );
  
  p.newCtr("Prec", start[0].add(DUR[0]).lEql(start[2]) );
                                 /* Precedence rel. between jobs */

  for(j=0;j<NJ;j++)              /* Linking start times and binaries  */ 
  { 
   le = new XPRBexpr();
   for(t=0;t<(NT-DUR[j]+1);t++)  le.add(delta[j][t].mul((t+1))); 
   p.newCtr("Link_"+(j+1), le.eql(start[j]) );
  } 
               
  for(j=0;j<NJ;j++)              /* One unique start time for each job  */
  { 
   le = new XPRBexpr();
   for(t=0;t<(NT-DUR[j]+1);t++)  le.add(delta[j][t]); 
   p.newCtr("One_"+(j+1), le.eql(1));
  }      
              
/****OBJECTIVE****/
  p.setObj(z);                   /* Define and set objective function */ 

/****BOUNDS****/
  for(j=0;j<NJ;j++) start[j].setUB(NT-DUR[j]+1); 
                                 /* Upper bounds on start time variables */

/****OUTPUT****/
  p.print();                     /* Print out the problem definition */ 
  p.exportProb(XPRB.MPS,"expl1");   /* Output matrix to MPS file */ 
 } 

/*************************************************************************/
 static void jobsSolve()             
 { 
  int j,t,statmip; 

  if(!SOS)
   for(j=0;j<NJ;j++)    
    for(t=0;t<NT-DUR[j]+1;t++)
     delta[j][t].setDir(XPRB.PR, 10*(t+1)); 
            /* Give highest priority to variables for earlier start times */
  else
   for(j=0;j<NJ;j++)    
    set[j].setDir(XPRB.DN);       /* First branch downwards on sets */

  p.setSense(XPRB.MINIM);
  p.mipOptimize("");              /* Solve the problem as MIP */
  statmip = p.getMIPStat();       /* Get the MIP problem status */    
              
  if((statmip == XPRB.MIP_SOLUTION) || (statmip == XPRB.MIP_OPTIMAL))
                                  /* An integer solution has been found */
  {  
   System.out.println("Objective: "+ p.getObjVal()); 
   for(j=0;j<NJ;j++) 
   {                              /* Print the solution for all start times */
    System.out.println(start[j].getName() + ": "+ start[j].getSol()); 
    for(t=0;t<NT-DUR[j]+1;t++) 
     System.out.print(delta[j][t].getName() + ": "+ delta[j][t].getSol());
    System.out.println();
   }
  } 
 }

/*************************************************************************/

 public static void main(String[] args)
 {         
  bcl = new XPRB();              /* Initialize BCL */
  p = bcl.newProb("Jobs");       /* Create a new problem */
  
  try
  {
   if(!SOS)
    jobsModel();                 /* Basic problem definition */
   else
    jobsModelb();                /* Formulation using SOS */
  }
  catch(IOException e)
  {
   System.err.println(e.getMessage());
   System.exit(1);
  }
  
  jobsSolve();                   /* Solve and print solution */

  p.finalize();                  /* Delete the problem */      
  p=null;
 }

/*************************************************************************/

 static void jobsModelb() throws IOException    /**** SOS-formulation ****/
 {
  XPRBexpr le;
  int j,t;

/****VARIABLES****/
  start = new XPRBvar[NJ];         /* Create start time variables */
  for(j=0;j<NJ;j++) start[j] = p.newVar("start");
  z = p.newVar("z",XPRB.PL,0,NT);  /* Declare the makespan variable */

  delta = new XPRBvar[NJ][NT];
  for(j=0;j<NJ;j++)             /* Declare binaries for each job  */
   for(t=0;t<(NT-DUR[j]+1);t++)
    delta[j][t] = p.newVar("delta"+(j+1)+(t+1), XPRB.PL, 0,1);

/****CONSTRAINTS****/
  for(j=0;j<NJ;j++)             /* Calculate maximal completion time */
   p.newCtr("Makespan", start[j].add(DUR[j]).lEql(z));
  
  p.newCtr("Prec", start[0].add(DUR[0]).lEql(start[2]) );
                                /* Precedence rel. betw. jobs */

  for(j=0;j<NJ;j++)             /* Linking start times and binaries  */ 
  { 
   le = new XPRBexpr();
   for(t=0;t<(NT-DUR[j]+1);t++)  le.add(delta[j][t].mul((t+1))); 
   p.newCtr("Link_"+(j+1), le.eql(start[j]) );
  } 
              
  for(j=0;j<NJ;j++)             /* One unique start time for each job  */
  { 
   le = new XPRBexpr();
   for(t=0;t<(NT-DUR[j]+1);t++)  le.add(delta[j][t]); 
   p.newCtr("One_"+(j+1), le.eql(1));
  }         
              
/****OBJECTIVE****/
  p.setObj(z);                  /* Define and set objective function */ 

/****BOUNDS****/
  for(j=0;j<NJ;j++) start[j].setUB(NT-DUR[j]+1); 
                                /* Upper bounds on start time variables */

/****SETS****/
  set = new XPRBsos[NJ];
  for(j=0;j<NJ;j++)  
  {
   le = new XPRBexpr();
   for(t=0;t<(NT-DUR[j]+1);t++)  le.add(delta[j][t].mul((t+1)));
   set[j] = p.newSos("sosj", XPRB.S1, le);
  } 

/****OUTPUT****/
  p.print();                    /* Print out the problem definition */ 
  p.exportProb(XPRB.MPS,"expl1");  /* Output matrix to MPS file */ 
 } 
}

Back to examples browserPrevious exampleNext example