/******************************************************** Xpress-BCL Java Example Problems ================================ file xbpurch.java ````````````````` Purchasing problem using SOS-2. (c) 2008-2024 Fair Isaac Corporation author: S.Heipcke, Jan. 2000, rev. Mar. 2011 ********************************************************/ /* WARNING. This model is not for the novice, but it does contain many * * useful ideas. * * The formulation is tricky because the discounts are all-quantity, * * so the graph of cost against quantity purchased is discontinuous. * * To maintain sanity in the special ordered set formulation, we must * * coarsen the discontinuity by stopping purchases just at the break * * point. */ import java.io.*; import com.dashoptimization.*; public class xbpurch { static final String PARAMSFILE = System.getProperty("XPRBDATA") + "/purchase/params.dat"; static final String MAXPERCFILE= System.getProperty("XPRBDATA") + "/purchase/maxperc.dat"; static final String REQFILE = System.getProperty("XPRBDATA") + "/purchase/required.dat"; static final String PRICEFILE = System.getProperty("XPRBDATA") + "/purchase/pricebk.dat"; /****TABLES****/ static int NS; /* Number of suppliers */ static int NB; /* Number of price breaks */ static int NB2; /* Useful parameter */ static double[][] UC; /* Unit cost */ static double[][] BR; /* Breakpoints (quantities at which unit cost changes) */ static double[][] X; /* Coarsened break points */ static double[][] C; /* Total cost at break points */ static double[] DELTA; /* Coarsening factors */ static double[] MAXPERC; /* Maximum percentage from each supplier */ static double REQ; /* Total quantity required */ static final double delta = 0,1; /* Base coarsening factor */ /***********************************************************************/ static void modPurchase() { XPRBexpr lobj, lc; XPRBexpr[] lr; int s,b; XPRBvar[] x; XPRBvar[][] lam; try (XPRBprob p = new XPRBprob("Purchase")) { /* Initialize BCL and create a new problem */ /****VARIABLES****/ x = new XPRBvar[NS]; /* Quantity to purchase from supplier s */ for(s=0;s<NS;s++) x[s] = p.newVar("x"); lam = new XPRBvar[NS][NB2]; for(s=0;s<NS;s++) for(b=0;b<NB2;b++) lam[s][b] = p.newVar("lam_" + (s+1)); /* Weights at breakpoint b for supplier s */ /****OBJECTIVE****/ lobj = new XPRBexpr(); for(s=0;s<NS;s++) /* Minimize the sum of costs*weights */ for(b=0;b<NB2;b++) lobj.add(lam[s][b].mul(C[s][b])); p.setObj(lobj); /* Set objective function */ /****CONSTRAINTS****/ /* Define x and also order the lam variables by breakpoint quantities */ lr = new XPRBexpr[NS]; for(s=0;s<NS;s++) { lr[s] = new XPRBexpr(); for(b=0;b<NB2;b++) lr[s].add(lam[s][b].mul(X[s][b])); p.newCtr("DefX", lr[s].eql(x[s]) ); } /* The convexity constraint (lam sum to 1) */ for(s=0;s<NS;s++) { lc = new XPRBexpr(); for(b=0;b<NB2;b++) lc.add(lam[s][b]); p.newCtr("Conv", lc.eql(1) ); } /* The minimum quantity that must be bought */ lc = new XPRBexpr(); for(s=0;s<NS;s++) lc.add(x[s]); p.newCtr("MustBuy", lc.gEql(REQ) ); /****BOUNDS****/ /* No more than the maximum percentage from each supplier */ for(s=0;s<NS;s++) x[s].setUB(MAXPERC[s]*REQ/100); /****SETS****/ /* Define the lam as SOS2 as we can linearly interpolate between the * breakpoints. The weights are the DefX coefficients augmented by 1 because BCL does not accept the weight 0. */ for(s=0;s<NS;s++) { for(b=0;b<NB2;b++) lr[s].add(lam[s][b]); p.newSos("SetLam", XPRB.S2, lr[s]); } /****SOLVING + OUTPUT****/ try { p.exportProb(XPRB.MPS,"purc"); /* Output to MPS file */ } catch(IOException e) { System.err.println(e.getMessage()); System.exit(1); } p.setSense(XPRB.MINIM); /* Choose the sense of the optimization */ p.mipOptimize(""); /* Solve the MIP-problem */ System.out.println("Objective: " + p.getObjVal()); /* Get objective value */ for(s=0;s<NS;s++) /* Print out the solution values */ System.out.print(x[s].getName() +":"+ x[s].getSol() +" "); System.out.println(); for(s=0;s<NS;s++) for(b=0;b<NB2;b++) System.out.print(lam[s][b].getName() +":"+ lam[s][b].getSol() +" "); System.out.println(); } } /***********************************************************************/ /**** Initialize the stream tokenizer ****/ static StreamTokenizer initST(FileReader file) { StreamTokenizer st=null; st= new StreamTokenizer(file); /* Initialize the stream tokenizer */ st.commentChar('!'); /* Use the character '!' for comments */ st.eolIsSignificant(true); /* Return end-of-line character */ st.ordinaryChar(','); /* Use ',' as separator */ st.parseNumbers(); /* Read numbers as numbers (not strings)*/ return st; } /**** Read single line data file ****/ static void readOneLineFile(String filename, double[] data) throws IOException { FileReader datafile=null; StreamTokenizer st; int i=0; datafile = new FileReader(filename); st = initST(datafile); do { do { st.nextToken(); } while(st.ttype==st.TT_EOL); /* Skip empty lines */ while(st.ttype == st.TT_NUMBER) { data[i++] = st.nval; if(st.nextToken() != ',') break; st.nextToken(); } } while( st.ttype == st.TT_EOL ); datafile.close(); } /**** Read data from files ****/ static void readData() throws IOException { int s,b; double[] val; FileReader datafile=null; StreamTokenizer st; int i=0; /* Read the parameter file */ val = new double[2]; readOneLineFile(PARAMSFILE,val); NS = (int)val[0]; NB = (int)val[1]; NB2 = 2*NB; /* Now define the tables that we will use, using the sizes we have just read. */ UC= new double[NS][NB]; BR = new double[NS][NB]; X=new double[NS][NB2]; C=new double[NS][NB2]; DELTA=new double[NB2]; MAXPERC=new double[NS]; /* Define coarsening factors */ DELTA[0]=0; DELTA[1] = -1*delta; for(b=2;b<NB2;b++) DELTA[b] = -1*DELTA[b-1]; /* Read the price and breakpoint data file */ for(s=0;s<NS;s++) for(b=0;b<NB;b++) { UC[s][b]=0; BR[s][b]=0; } datafile = new FileReader(PRICEFILE); st = initST(datafile); do { do { st.nextToken(); } while(st.ttype==st.TT_EOL); /* Skip empty lines */ if(st.ttype != st.TT_NUMBER) break; s=(int)st.nval; if(st.nextToken() != ',') break; if(st.nextToken() != st.TT_NUMBER) break; b=(int)st.nval; if(st.nextToken() != ',') break; if(st.nextToken() != st.TT_NUMBER) break; UC[s-1][b-1]=st.nval; if(st.nextToken() != ',') break; if(st.nextToken() != st.TT_NUMBER) break; BR[s-1][b-1]=st.nval; } while( st.nextToken() == st.TT_EOL ); datafile.close(); /* Read the percentages data file */ readOneLineFile(MAXPERCFILE,MAXPERC); /* Read the required amount data file */ readOneLineFile(REQFILE,val); REQ = val[0]; /* We now pick out the data from the tables into which they have been read. */ for(s=0;s<NS;s++) { C[s][0] = 0; /* First total cost and (new) breakpoint are (0,0) */ X[s][0] = 0; for(b=1;b<NB2;b++) { /* Rest calculated... */ C[s][b] = UC[s][b/2] * BR[s][(b-1)/2]; /* ...unit price*quantity */ X[s][b] = BR[s][(b-1)/2] + DELTA[b]; /* ...coarsened grids */ } } } /***********************************************************************/ public static void main(String[] args) { try { readData(); /* Data input from file */ } catch(IOException e) { System.err.println(e.getMessage()); System.exit(1); } modPurchase(); /* Formulate and solve the problem */ } }