/******************************************************** Xpress-BCL C# Example Problems ============================== file xbelsc.cs `````````````` Economic lot sizing, ELS, problem, solved by adding (l,S)-inequalities) in a branch-and-cut heuristic (using the cut manager). ELS considers production planning over a horizon of T periods. In period t, t=1,...,T, there is a given demand DEMAND[t] that must be satisfied by production prod[t] in period t and by inventory carried over from previous periods. There is a set-up up cost SETUPCOST[t] associated with production in period t. The unit production cost in period t is PRODCOST[t]. There is no inventory or stock-holding cost. (c) 2008 Fair Isaac Corporation authors: S.Heipcke, D.Brett. ********************************************************/ using System; using System.Text; using System.IO; using Optimizer; using BCL; namespace Examples { public class TestAdvElsCallback { const int T = 6; /* Number of time periods */ /****DATA****/ int[] DEMAND = { 1, 3, 5, 3, 4, 2}; /* Demand per period */ int[] SETUPCOST = {17,16,11, 6, 9, 6}; /* Setup cost per period */ int[] PRODCOST = { 5, 3, 2, 1, 3, 1}; /* Production cost per period */ int[,] D = new int[T,T]; /* Total demand in periods t1 - t2 */ XPRBvar[] prod = new XPRBvar[T]; /* Production in period t */ XPRBvar[] setup = new XPRBvar[T]; /* Setup in period t */ XPRBprob p = new XPRBprob("ElsC"); /* Initialize a new problem in BCL */ /***********************************************************************/ public void modEls() { int s,t,k; XPRBexpr cobj,le; for(s=0;s<T;s++) for(t=0;t<T;t++) for(k=s;k<=t;k++) +=DEMAND[k]; prod[t]=p.newVar("prod" setup[t]=p.newVar("setup" cobj=new Minimize total cost Production in period t must not exceed the demand for remaining if there is production during then a setup <=D[t,T-1]*setup[t]); periods to satisfy this of time le=new for(s=0;s<=t;s++)>= D[0,t]);
            }

        }

        /**************************************************************************/
        /*  Cut generation loop at the tree node:                                 */
        /*    get the solution values                                             */
        /*    identify and set up violated constraints                            */
        /*    add cuts to the matrix                                              */
        /**************************************************************************/
        public int cbNode(XPRSprob xprsp, object mobj)
        {
            BCLconstant.XPRBprobStruct mo;
            double objval;                  /* Objective value */
            int t,l;
            int ncut;                       /* Counters for cuts */
            double[] solprod = new double[T];
            double[] solsetup = new double[T]; /* Solution values for var.s prod & setup */
            double ds;
            int depth,node;
            XPRBcut[] cut = new XPRBcut[T];
            XPRBexpr le;

            mo=(BCLconstant.XPRBprobStruct)mobj;

            ncut = 0;

            depth = xprsp.NodeDepth;
            node = xprsp.Nodes;

            /* Get the solution values */
            mo.prob.beginCB(xprsp);
            mo.prob.sync(BCLconstant.XPRB_XPRS_SOL);
            for(t=0;t<T;t++) solprod[t]=prod[t].getSol(); solsetup[t]=setup[t].getSol(); Search for violated constraints: for(l=0;l<T;l++) (ds=0.0, t=0; t<=l; ds +=solprod[t]; else Add the inequality: minimum of actual production and maximum potential in periods to l must at least equal total demand l. sum(t=1:l)>= D[0][l]
                */
                if(ds < D[0,l] - mo.tol) 
                {
                    le = new XPRBexpr(0);
                    for(t=0;t<=l;t++) 
                    {
                        if (solprod[t] < D[t,l]*solsetup[t] + mo.tol)
                            le += prod[t];
                        else
                            le += D[t,l]*setup[t];
                    }
                    cut[ncut] = mo.prob.newCut(le >= D[0,l]);
                    ncut++; 
                }
            }

            /* Add cuts to the problem */
            if(ncut>0)
            { 
                mo.prob.addCuts(cut, ncut);
                objval = xprsp.LPObjVal;
                System.Console.Write("Cuts added : " + ncut + " (depth " + depth + ", node ");
                System.Console.WriteLine(node + "), obj. " + objval); 
            }
            mo.prob.endCB();

            return 0;
        }

        /***********************************************************************/
        public void treeCutGen()
        {
            IntPtr oprob;
            BCLconstant.XPRBprobStruct mo;
            double feastol;
            int starttime,t;
            CutmgrCallback del = new CutmgrCallback(cbNode);
            XPRSprob xprsp = p.getXPRSprob();

            starttime=XPRB.getTime();

            xprsp.LPLog = 0;
            xprsp.MIPLog = 3;

            xprsp.CutStrategy = 0;
            xprsp.Presolve = 0;
            xprsp.ExtraRows = 5000;

            feastol = xprsp.FeasTol;
            feastol*= 10;

            mo.prob=p;
            mo.tol=feastol;
            p.setCutMode(1);
            xprsp.AddCutmgrCallback(del, (object)mo);
            
            p.mipOptimize();                                    /* Solve the MIP */
            System.Console.Write("(" + (XPRB.getTime()-starttime)/1.000 + " sec) Global status ");
            System.Console.WriteLine(p.getMIPStat() + ", best solution: " + p.getObjVal());  
            for(t=0;t<T;t++)
            {
                System.Console.Write("Period " + (t+1) + ": prod " + prod[t].getSol() + " (demand: ");
                System.Console.Write(DEMAND[t] + ", cost: " + PRODCOST[t] + "), setup ");
                System.Console.WriteLine(setup[t].getSol() + " (cost: " + SETUPCOST[t] + ")");
            }
        }

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

        public static void Main()
        {
           XPRB.init();
           TestAdvElsCallback TestInstance = new TestAdvElsCallback();

            TestInstance.modEls();                    /* Model the problem */
            TestInstance.treeCutGen();                /* Solve the problem */

            return;
        } 

    }

}