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

  file foliomip1.cs
  `````````````````
  Modeling a small MIP problem
  to perform portfolio optimization.
   -- Limiting the total number of assets --

  (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 TestUGFolioMip1
    {

        const int MAXNUM = 4;                   // Max. number of different assets

        const int NSHARES = 10;                 // Number of shares
        const int NRISK = 5;                    // Number of high-risk shares
        const int NNA = 4;                      // Number of North-American shares

        double[] RET = {5,17,26,12,8,9,7,6,31,21};  // Estimated return in investment
        int[] RISK = {1,2,3,8,9};          // High-risk values among shares
        int[] NA = {0,1,2,3};              // Shares issued in N.-America

        public static void Main()
        {
            XPRB.init();
            int s;
            XPRBprob p = new XPRBprob("FolioMIP1");          // Initialize a new problem in BCL
            XPRBexpr Risk,Na,Return,Cap,Num;
            XPRBvar[] frac = new XPRBvar[NSHARES];            // Fraction of capital used per share
            XPRBvar[] buy = new XPRBvar[NSHARES];             // 1 if asset is in portfolio, 0 otherwise
            TestUGFolioMip1 TestInstance = new TestUGFolioMip1();

            // Create the decision variables (including upper bounds for `frac')
            for(s=0;s<NSHARES;s++)
            {
                frac[s] = p.newVar("frac", BCLconstant.XPRB_PL, 0, 0.3);
                buy[s] = p.newVar("buy", BCLconstant.XPRB_BV);
            }

            // Objective: total return
            Return = new XPRBexpr();
            for (s = 0; s < NSHARES; s++) Return += TestInstance.RET[s] * frac[s];
            p.setObj(p.newCtr("Objective", Return));                // Set the objective function

            // Limit the percentage of high-risk values
            Risk = new XPRBexpr();
            for (s = 0; s < NRISK; s++) Risk += frac[TestInstance.RISK[s]];
            p.newCtr(Risk <= 1.0/3);

            // Minimum amount of North-American values
            Na = new XPRBexpr();
            for (s = 0; s < NNA; s++) Na += frac[TestInstance.NA[s]];
            p.newCtr(Na >= 0.5);

            // Spend all the capital
            Cap = new XPRBexpr();
            for(s=0;s<NSHARES;s++) Cap += frac[s];
            p.newCtr(Cap == 1);

            // Limit the total number of assets
            Num = new XPRBexpr();
            for(s=0;s<NSHARES;s++) Num += buy[s];
            p.newCtr(Num <= MAXNUM);

            // Linking the variables
            for(s=0;s<NSHARES;s++) p.newCtr(frac[s] <= buy[s]);

            // Solve the problem
            p.setSense(BCLconstant.XPRB_MAXIM);
            p.mipOptimize();              /* Solve the LP-problem */


            string[] MIPSTATUS = {"not loaded", "not optimized", "LP optimized",
            "unfinished (no solution)",
            "unfinished (solution found)", "infeasible", "optimal"};

            System.Console.WriteLine("Problem status: " + MIPSTATUS[p.getMIPStat()]);


            // Solution printing
            System.Console.WriteLine("Total return: " + p.getObjVal());
            for(s=0;s<NSHARES;s++)
                System.Console.WriteLine(s + ": " + frac[s].getSol()*100 + "% (" + buy[s].getSol() + ")");

            return;
        }

    }

}