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

  file xbexpl.java
  ````````````````
  Working with multiple problems.

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

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

/********************************************************/
/* This file illustrates how to                         */
/* - do changes to the problem definition               */
/* - retrieve solution information                      */
/* - define and work with several problems              */
/*                                                      */
/* Set at least one of the following options to true.   */
/* It is possible to define all together. In this case  */
/* the last function (expl5) that shows how to switch   */
/* between problems is activated too.                   */
/********************************************************/
public class xbexpl {
    static final boolean CHGCTR = true;    /* Accessing & modifying constraints */
    static final boolean CHGVAR = true;    /* Accessing & modifying variables */
    static final boolean UNBOUNDED = true; /* Solve a small unbounded problem */

    static XPRBprob p2, p3, p4;

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

    public static void main(String[] args) {
        try (XPRB bcl = new XPRB()) {              /* Initialize BCL */
            try {
                if(CHGCTR)
                    expl2(bcl);
                if(CHGVAR)
                    expl3(bcl);
                if(UNBOUNDED) {
                    expl4(bcl);
                    if(CHGCTR&&CHGVAR)
                        expl5(bcl);
                }
            }
            catch(IOException e) {
                System.err.println(e.getMessage());
                System.exit(1);
            }
            finally {
                if (p4 != null)
                    p4.close();
                if (p3 != null)
                    p3.close();
                if (p2 != null)
                    p2.close();
            }
        }
    }

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

    /**** Expl 2: changing bounds and operations on constraints ****/
    static void expl2(XPRB bcl) throws IOException {
        XPRBvar[] x;
        XPRBctr[] ctr;
        XPRBexpr lobj;
        double[] objcof={2.0,1.0,1.0,1.0,0};
        int i;

        p2 = bcl.newProb("expl2");         /* Create a new problem */

        /* Define 5 integer variables in 0,...,100 */
        x = new XPRBvar[5];
        for(i=0;i<5;i++) x[i] = p2.newVar("x_"+i, XPRB.UI,0,100);

        /* Create the constraints:
           ctr0: x0 +10 <= x1
           ctr1: x1     <= x3
           ctr2: x1 + 8 <= x2 */
        ctr = new XPRBctr[4];
        ctr[0]=p2.newCtr("ctr0", x[0].add(10).lEql(x[1]) );
        ctr[1]=p2.newCtr("ctr1", x[1]        .lEql(x[3]) );
        ctr[2]=p2.newCtr("ctr2", x[1].add(8) .lEql(x[2]) );

        lobj = new XPRBexpr();
        for(i=0;i<5;i++) lobj.add(x[i].mul(objcof[i]));
        p2.setObj(lobj);              /* Select objective function */
        p2.setSense(XPRB.MINIM);      /* Set objective sense to minimization */

        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        p2.exportProb(XPRB.LP,"expl2");  /* Matrix generation and output */
        p2.print();                   /* Print current problem definition */

        p2.lpOptimize("");            /* Solve the LP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        ctr[0].setRange(-15,-5);      /* Transform constraint into range constr. */
        System.out.println("\n<<<<<<<<Constraint transformed into range:>>>>>>>>");
        p2.print();                   /* Print current problem definition */
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print new variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        ctr[0].setType(XPRB.L);       /* Change range constraint back to constraint */
        System.out.println("\n<<<<<<<<Constraint restored to inequality:>>>>>>>>");
        p2.print();                   /* Print current problem definition */
        ctr[0].setTerm(-10);          /* Set new RHS value */
        System.out.println("<<<<<<<<Restore original RHS value:>>>>>>>>");
        p2.print();                   /* Print current problem definition */

        x[1].setLB(15);               /* Change the bound on a variable */
        System.out.println("<<<<<<<<Variable bound changed:>>>>>>>>");
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print new variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        /* Change constraint coefficient and RHS */
        ctr[1].setTerm(x[1],-3);      /* ctr1: x1 <= 3*x3 */
        ctr[0].addTerm(-10);          /* ctr0: x0 + 20 <= x1 */
        System.out.println("\n<<<<<<<<Constraint coefficient and RHS changed:>>>>>>>>");
        for(i=0;i<3;i++) ctr[i].print();
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print new variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        /* Change constraint type */
        ctr[2].setType(XPRB.G);       /* ctr2: x1 + 8 >= x2 */
        System.out.println("\n<<<<<<<<Constraint type changed:>>>>>>>>");
        for(i=0;i<3;i++) ctr[i].print();
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        /* Add another constraint ctr3: x0 +37<= x2 */
        ctr[3] = p2.newCtr("ctr3", x[0].add(37).lEql(x[2]) );
        System.out.println("\n<<<<<<<<Constraint added:>>>>>>>>");
        p2.print();
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();

        /* Delete a constraint */
        p2.delCtr(ctr[2]);
        System.out.println("\n<<<<<<<<Constraint deleted:>>>>>>>>");
        p2.print();
        for(i=0;i<4;i++)
            { x[i].print(); System.out.print(" "); } /* Print variable bounds */
        System.out.println();
        p2.mipOptimize("");           /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());
        for(i=0;i<4;i++)              /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();
    }

    /**** Expl 3: Knapsack problem: accessing variables ****/
    static void expl3(XPRB bcl) throws IOException {
        XPRBvar[] x;
        XPRBexpr le, lobj;
        XPRBctr ctr;
        double[] coeff={30.0, 32.0, 27.0, 11.0};
        double[] objcof={9.0, 15.0, 8.0, 3.0};
        int i;

        p3 = bcl.newProb("expl3");     /* Create a new problem */

        x = new XPRBvar[4];
        for(i=0;i<4;i++)               /* Define 4 binary variables */
            x[i] = p3.newVar("x_"+i, XPRB.BV);

        /* Create the knapsack constraint:
           sum_i coeff[i]*x[i] <= 70  */
        le = new XPRBexpr();
        for(i=0;i<4;i++) le.add(x[i].mul(coeff[i]));
        ctr = p3.newCtr("sumkn", le.lEql(70) );

        lobj = new XPRBexpr();
        for(i=0;i<4;i++) lobj.add(x[i].mul(objcof[i]));
        p3.setObj(lobj);               /* Set objective function */

        /* p3.print(); */                /* Uncomment to print the problem */
        p3.exportProb(XPRB.MPS,"expl3");  /* Matrix output in MPS format */
        p3.setSense(XPRB.MAXIM);       /* Change to maximization */
        p3.mipOptimize("");           /* Solve the MIP */
        System.out.println("Objective: " + p3.getObjVal()); /* Get objective value */
        for(i=0;i<4;i++)               /* Print the solution */
            System.out.println(x[i].getName() + ": " + x[i].getSol() + " (rc:"
                               + x[i].getRCost() + "),");
        System.out.println("Dual: " + ctr.getDual() + " slack: " + ctr.getSlack());
        /* Print dual & slack values */

        System.out.println("\n<<<<<<<<Variable type changed from BV to UI>>>>>>>>");
        x[1].setType(XPRB.UI);         /* Change variable type */
        System.out.println(x[1].getName() + ": bounds: " + x[1].getLB() +" "+
                           x[1].getUB() +", type: " + x[1].getType() +", index: " + x[1].getColNum());
        p3.mipOptimize("");           /* Re-solve the MIP */
        System.out.println("Objective: " + p3.getObjVal()); /* Get objective value */

        System.out.println("\n<<<<<<<<Variable bound changed: no matrix regeneration>>>>>>>>");
        x[1].setUB(3);                 /* Change variable bound */
        System.out.println(x[1].getName() + ": bounds: " + x[1].getLB() +" "+
                           x[1].getUB() +", type: " + x[1].getType() +", index: " + x[1].getColNum());
        p3.mipOptimize("");           /* Re-solve the MIP */
        System.out.println("Objective: " + p3.getObjVal()); /* Get objective value */
        for(i=0;i<4;i++)               /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");

        System.out.println("\n\n<<<<<<<<Variable type changed from UI to PI>>>>>>>>");
        x[1].setType(XPRB.PI);         /* Change variable type */
        x[1].setLim(2);                /* Set the integer limit for
                                          the partial integer variable */
        x[1].print(); System.out.println();   /* Print current variable definition */
        p3.mipOptimize("");           /* Re-solve the MIP */
        System.out.println("Objective: " + p3.getObjVal()); /* Get objective value */
        for(i=0;i<4;i++)               /* Print the solution */
            System.out.println(x[i].getName() + ": " + x[i].getSol() + " (rc:"
                               + x[i].getRCost() + "),");
        System.out.println("Dual: " + ctr.getDual() + " slack: " + ctr.getSlack());
        /* Print dual & slack values */
    }

    /****Expl 4: a small unbounded problem ****/
    static void expl4(XPRB bcl) {
        XPRBvar[] x;
        int i;

        p4=bcl.newProb("expl4");       /* Create a new problem */

        /* Define 2 variables in [0,PLUSINFINITY] */
        x = new XPRBvar[2];
        for(i=0;i<2;i++) x[i]=p4.newVar("x_"+i);

        /* Create the constraints:
           ctr0: 4*x0 + x1 >= 4
           ctr1: x0 + x1   >= 3
           ctr2: x0 + 2*x1 >= 4 */
        p4.newCtr("c1", x[0].mul(4).add(x[1]).gEql(4) );
        p4.newCtr("c2", x[0].add(x[1])       .gEql(3) );
        p4.newCtr("c3", x[0].add(x[1].mul(2)).gEql(4) );

        p4.setObj( x[0].add(x[1]) );   /* Define and set objective function */

        p4.setSense(XPRB.MAXIM);       /* Change to maximization */
        p4.lpOptimize("");             /* Solve the LP */
        System.out.println("Problem status: " + p4.getProbStat() + " LP status: "
                           + p4.getLPStat() + " MIP status: " + p4.getMIPStat());
        System.out.println("Objective: "+ p4.getObjVal());  /* Get objective value */
        for(i=0;i<2;i++)               /* Print solution values */
            System.out.print(x[i].getName() + ":" + x[i].getSol() + " ");
        System.out.println();
    }

    /***Expl5: Working with different problems****/
    static void expl5(XPRB bcl) {
        int i;

        System.out.println("\n<<<<<<<<Re-solve problem " + p2.getName() + ">>>>>>>>");
        p2.mipOptimize("");            /* Solve the MIP */
        System.out.println("Problem status: " + p2.getProbStat() + " LP status: "
                           + p2.getLPStat() + " MIP status: " + p2.getMIPStat());
        System.out.println("Objective: " + p2.getObjVal());  /* Get objective value */
        for(i=0;i<4;i++)               /* Print solution values */
            System.out.print("x_" + i + ":" + p2.getVarByName("x_"+i).getSol());

        /* In C and C++, here we delete the problem "expl4". With Java, the
           closest correspondence is to explicitely close this problem. */
        System.out.println("\n\n<<<<<<<<Finalize prob4>>>>>>>>");
        p4.print();
        p4.close();
        p4=null;

        System.out.println("\n\n<<<<<<<<Re-solve problem " + p3.getName() + " and print it>>>>>>>>");
        p3.print();                    /* Print the problem def. */
        p3.mipOptimize("");            /* Solve the MIP */
        System.out.println("Problem status: " + p3.getProbStat() + " LP status: "
                           + p3.getLPStat() + " MIP status: " + p3.getMIPStat());
        System.out.println("Objective: " + p3.getObjVal()); /* Get objective value */
        for(i=0;i<4;i++)               /* Print solution values */
            System.out.print("x_" + i + ":" + p3.getVarByName("x_"+i).getSol());
        System.out.println();
    }
}