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





foliolp.java

/********************************************************
 * Xpress-BCL Java Example Problems
 * ================================
 *
 * file foliolp.java
 * `````````````````
 * Modeling a small LP problem
 * to perform portfolio optimization.
 *
 * (c) 2008-2024 Fair Isaac Corporation
 * author: S.Heipcke, 2003, rev. Dec. 2011
 ********************************************************/

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

public class foliolp {
  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 final String[] LPSTATUS = {
    "not loaded",
    "optimal",
    "infeasible",
    "worse than cutoff",
    "unfinished",
    "unbounded",
    "cutoff in dual",
    "unsolved",
    "nonconvex"
  };

  public static void main(String[] args) {
    try (XPRBprob p = new XPRBprob("FolioLP"); /* Initialize BCL and create a new problem */
        XPRBexprContext context =
            new XPRBexprContext() /* Release XPRBexpr instances at end of block. */) {
      int s;
      XPRBexpr Risk, Na, Return, Cap;
      XPRBvar[] frac; /* Fraction of capital used per share */

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

      /* 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", Risk.lEql(1.0 / 3));

      /* Equivalent:
         XPRBctr CRisk;
         CRisk = p.newCtr("Risk");
         for(s=0;s<NRISK;s++) CRisk.addTerm(frac[RISK[s]], 1);
         CRisk.setType(XPRB.L);
         CRisk.addTerm(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", Na.gEql(0.5));

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

      /* Upper bounds on the investment per share */
      for (s = 0; s < NSHARES; s++) frac[s].setUB(0.3);

      /* Export matrix to a file */
      try {
        p.exportProb(XPRB.MPS, "Folio");
        p.setSense(XPRB.MAXIM);
        p.exportProb(XPRB.LP, "Folio");
      } catch (IOException e) {
        System.err.println(e.getMessage());
        System.exit(1);
      }

      /* Disable all BCL and Optimizer message printing, except error messages */
      /*  p.setMsgLevel(1); */

      /* Solve the problem */
      p.setSense(XPRB.MAXIM);
      p.lpOptimize("");

      System.out.println("Problem status: " + LPSTATUS[p.getLPStat()]);

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

Back to examples browserPrevious example