/********************************************************
  Xpress-BCL C# Example Problems
  ==============================

  file xbcontr1.cs
  ````````````````
  Contract allocation example.
  Combining BCL problem input with problem solving
  in Xpress-Optimizer.

  (c) 2008-2024 Fair Isaac Corporation
      authors: S.Heipcke, D.Brett.
********************************************************/

using System;
using System.Text;
using System.IO;
using BCL;


namespace Examples
{
    public class TestContract
    {
        const int District = 6;               /* Number of districts */
        const int Contract = 10;               /* Number of contracts */

        /**** DATA ****/
        int[] OUTPUT = {50, 40, 10, 20, 70, 50};    /* Max. output per district */
        int[] COST   = {50, 20, 25, 30, 45, 40};    /* Cost per district */
        int[] VOLUME   = {20, 10, 30, 15, 20, 30, 10, 50, 10, 20};
        /* Volume of contracts */

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

        public static void Main()
        {
            XPRB.init();
            int d,c;
            XPRBprob p = new XPRBprob("Contract");          /* Initialize a new problem in BCL */
            XPRBexpr l1,l2,lobj;
            XPRBvar[,] x = new XPRBvar[District,Contract];   /* Variables indicating whether a project
            is chosen */
            XPRBvar[,] y = new XPRBvar[District,Contract];   /* Quantities allocated to contractors */

            TestContract TestInstance = new TestContract();

            /**** VARIABLES ****/
            for(d=0;d<District;d++)
                for(c=0;c<Contract;c++)
                {
                    x[d,c] = p.newVar("x_d" + (d+1) + "c" + (c+1), BCLconstant.XPRB_BV);
                    y[d,c] = p.newVar("q_d" + (d + 1) + "c" + (c + 1), BCLconstant.XPRB_SC, 0, TestInstance.OUTPUT[d]);
                    y[d,c].setLim(5);
                }

            /****OBJECTIVE****/
            lobj = new XPRBexpr();
            for(d=0;d<District;d++)
                for(c=0;c<Contract;c++)
                    lobj += TestInstance.COST[d] * y[d,c];

            p.setObj(p.newCtr("OBJ",lobj));  /* Set the objective function */

            /**** CONSTRAINTS ****/
            for(c=0;c<Contract;c++)
            {
                l1= new XPRBexpr(0);
                l2= new XPRBexpr(0);
                for(d=0;d<District;d++)
                {
                    l1 += y[d,c];
                    l2 += x[d,c];
                }
                p.newCtr("Size", l1 >= TestInstance.VOLUME[c]);  /* "Size": cover the required volume */
                p.newCtr("Min", l2 >= 2 ); 	 /* "Min": at least 2 districts per contract */
            }

            for(d=0;d<District;d++)         /* Do not exceed max. output of any district */
            {
                l1=new XPRBexpr(0);
                for(c=0;c<Contract;c++)
                    l1 += y[d,c];
                p.newCtr("Output", l1 <= TestInstance.OUTPUT[d]);
            }

            for(d=0;d<District;d++)         /* If a contract is allocated to a district,
            then at least 1 unit is allocated to it */
                for(c=0;c<Contract;c++)
                    p.newCtr("XY", x[d,c] <= y[d,c]);

            /****SOLVING + OUTPUT****/
            p.exportProb(BCLconstant.XPRB_MPS,"Contract");  /* Output the matrix in MPS format */
            p.setSense(BCLconstant.XPRB_MINIM);         /* Choose the sense of the optimization */
            p.mipOptimize();                   /* Solve the MIP-problem */

            if((p.getMIPStat()==BCLconstant.XPRB_MIP_SOLUTION) || (p.getMIPStat()==BCLconstant.XPRB_MIP_OPTIMAL))
            /* Test whether an integer sol. was found */
            {
                System.Console.WriteLine("Objective: " + p.getObjVal());  /* Get objective value */

                for(d=0;d<District;d++)        /* Print the solution values */
                {
                    for(c=0;c<Contract;c++)
                    if(x[d,c].getSol()>0)
                        System.Console.Write(y[d, c].getName() + ":" + y[d, c].getSol() + ", ");
                    System.Console.WriteLine();
                }
            }
            return;
        }
    }
}