FICO
FICO Xpress Optimization Examples Repository
FICO Optimization Community FICO Xpress Optimization Home
Back to examples browserPrevious example

Folio - Examples from 'Getting Started'

Description
Different versions of a portfolio optimization problem.

Basic modelling and solving tasks:
  • modeling and solving a small LP problem (foliolp)
  • performing explicit initialization (folioinit*)
  • data input from file, index sets (foliodata, requires foliocpplp.dat)
  • modeling and solving a small MIP problem with binary variables (foliomip1)
  • modeling and solving a small MIP problem with semi-continuous variables (foliomip2)
  • modeling and solving QP and MIQP problems (folioqp, requires foliocppqp.dat)
  • modeling and solving QCQP problems (folioqc, requires foliocppqp.dat)
  • heuristic solution of a MIP problem (folioheur)
Advanced modeling and solving tasks:
  • enlarged version of the basic MIP model (foliomip3, to be used with data sets folio5.cdat, folio10.cdat)
  • defining an integer solution callback (foliocb)
  • using the MIP solution pool (foliosolpool)
  • using the solution enumerator (folioenumsol)
  • handling infeasibility through deviation variables (folioinfeas)
  • retrieving IIS (folioiis, foliomiis)
  • using the built-in infeasibility repair functionality (foliorep)
Further explanation of this example: 'Getting Started with BCL' for the basic modelling and solving tasks; 'Advanced Evaluators Guide' for solution enumeration and infeasibilit handling

xbfoliojava.zip[download all files]

Source Files

Data Files





folioheur.java

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

  file folioheur.java
  ```````````````````
  Modeling a small LP problem
  to perform portfolio optimization.
   -- Heuristic solution --

  (c) 2008-2024 Fair Isaac Corporation
      author: S.Heipcke, 2003, rev. Dec. 2011
********************************************************/

import com.dashoptimization.*;

public class folioheur {
    static final int MAXNUM = 4;      /* Max. number of different assets */
    static final int NSHARES = 10;    /* Number of shares */
    static final int NRISK = 5;       /* Number of high-risk shares */
    static final int NNA = 4;         /* Number of North-American shares */

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

    static XPRBvar[] frac;            /* Fraction of capital used per share */
    static XPRBvar[] buy;             /* 1 if asset is in portfolio, 0 otherwise */

    public static void main(String[] args) throws XPRSprobException, XPRSexception {
        int s;
        XPRBexpr Risk,Na,Return,Cap,Num;

        try (XPRBprob p = new XPRBprob("FolioMIPHeur"); /* Initialize BCL and create a new problem */
             XPRS xprs = new XPRS()) {                  /* Initialize Xpress-Optimizer */

            /* Create the decision variables */
            frac = new XPRBvar[NSHARES];
            buy = new XPRBvar[NSHARES];
            for(s=0;s<NSHARES;s++) {
                frac[s] = p.newVar("frac", XPRB.PL, 0, 0.3);
                buy[s] = p.newVar("buy", XPRB.BV);
            }

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

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

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

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

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

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

            /* Solve problem heuristically */
            p.setSense(XPRB.MAXIM);
            solveHeur(p);

            /* Solve the problem */
            p.mipOptimize("");

            /* Solution printing */
            if(p.getMIPStat()==XPRB.MIP_SOLUTION || p.getMIPStat()==XPRB.MIP_OPTIMAL) {
                System.out.println("Exact solution: Total return: " + p.getObjVal());
                for(s=0;s<NSHARES;s++)
                    System.out.println(s + ": " + frac[s].getSol()*100 + "%");
            }
            else
                System.out.println("Heuristic solution is optimal.");

            /* Delete the problem */
        }
    }

    static void solveHeur(XPRBprob p) throws XPRSprobException {
        XPRSprob op;
        XPRBbasis basis;
        int s, ifgsol;
        double solval,TOL;
        double[] fsol;

        op = p.getXPRSprob();                  /* Retrieve the Optimizer problem */
        op.setIntControl(XPRS.CUTSTRATEGY, 0); /* Disable automatic cuts */
        op.setIntControl(XPRS.PRESOLVE, 0);    /* Switch presolve off */
        TOL = op.getDblControl(XPRS.FEASTOL);  /* Get feasibility tolerance */

        p.mipOptimize("l");              /* Solve the LP-problem */
        basis=p.saveBasis();             /* Save the current basis */

        /* Fix all variables `buy' for which `frac' is at 0 or at a relatively
           large value */
        fsol = new double[NSHARES];
        for(s=0;s<NSHARES;s++) {
            fsol[s]=frac[s].getSol();       /* Get the solution values of `frac' */
            if(fsol[s] < TOL)  buy[s].setUB(0);
            else if(fsol[s] > 0.2-TOL)  buy[s].setLB(1);
        }

        p.mipOptimize("c");              /* Continue solving the MIP-problem */
        ifgsol=0; solval=0;
        if(p.getMIPStat()==XPRB.MIP_SOLUTION || p.getMIPStat()==XPRB.MIP_OPTIMAL)
            {                                /* If an integer feas. solution was found */
                ifgsol=1;
                solval=p.getObjVal();           /* Get the value of the best solution */
                System.out.println("Heuristic solution: Total return: " + p.getObjVal());
                for(s=0;s<NSHARES;s++)
                    System.out.println(s + ": " + frac[s].getSol()*100 + "%");
            }

        /* Reset variables to their original bounds */
        for(s=0;s<NSHARES;s++)
            if((fsol[s] < TOL) || (fsol[s] > 0.2-TOL)) {
                buy[s].setLB(0);
                buy[s].setUB(1);
            }

        p.loadBasis(basis);       /* Load the saved basis: bound changes are
                                     immediately passed on from BCL to the
                                     Optimizer if the problem has not been modified
                                     in any other way, so that there is no need to
                                     reload the matrix */
        basis = null;             /* No need to store the saved basis any longer */
        if(ifgsol==1)
            op.setDblControl(XPRS.MIPABSCUTOFF, solval+TOL);
        /* Set the cutoff to the best known solution */
    }
}

Back to examples browserPrevious example