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

Folio - Examples from 'Getting Started'

Different versions of a portfolio optimization problem.

Basic modelling and solving tasks:
  • modeling and solving a small LP problem (foliolp)
  • performing explicit initialization (folioini*)
  • 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 with include file readfoliodata.c_, to be used with data set 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)
  • 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[download all files]

Source Files

Data Files


  Xpress-BCL C++ Example Problems

  file foliosolpool.cpp
  Modeling a MIP problem
  to perform portfolio optimization.

  Same model as in foliomip3.cpp.
  -- Using the MIP solution pool --

  (c) 2009 Fair Isaac Corporation
      author: S.Heipcke, May 2009, rev. Mar. 2011

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include "xprb_cpp.h"
#include "xprs.h"

using namespace std;
using namespace ::dashoptimization;

#define MAXNUM 7                   // Max. number of different assets
#define MAXRISK 1.0/3              // Max. investment into high-risk values
#define MINREG 0.2                 // Min. investment per geogr. region
#define MAXREG 0.5                 // Max. investment per geogr. region
#define MAXSEC 0.25                // Max. investment per ind. sector
#define MAXVAL 0.2                 // Max. investment per share
#define MINVAL 0.1                 // Min. investment per share

#define DATAFILE "folio10.cdat"    // File with problem data
#define MAXENTRIES 10000

int NSHARES;                       // Number of shares
int NRISK;                         // Number of high-risk shares
int NREGIONS;                      // Number of geographical regions
int NTYPES;                        // Number of share types

double *RET;                       // Estimated return in investment
int *RISK;                         // High-risk values among shares
char **LOC;                        // Geogr. region of shares
char **SECT;                        // Industry sector of shares

char **SHARES_n;
char **REGIONS_n;
char **TYPES_n;

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

#include "readfoliodata.c_"

void print_sol(int num);

int main(int argc, char **argv)
 int s,r,t;
 XPRBprob p("FolioMIP3");          // Initialize a new problem in BCL
 XPRBexpr Risk,Cap,Num,le;
 XPRBexpr *MinReg, *MaxReg, *LimSec, LinkL, LinkU;

 readdata(DATAFILE);               // Data input from file

// Create the decision variables (including upper bounds for `frac')
 frac = new XPRBvar[NSHARES];
 buy = new XPRBvar[NSHARES];
  frac[s] = p.newVar("frac", XPRB_PL, 0, MAXVAL);
  buy[s] = p.newVar("buy", XPRB_BV);

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

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

// Limits on geographical distribution
 MinReg = new XPRBexpr[NREGIONS];
 MaxReg = new XPRBexpr[NREGIONS];
    MinReg[r] += frac[s];
    MaxReg[r] += frac[s];
  p.newCtr(MinReg[r] >= MINREG);
  p.newCtr(MaxReg[r] <= MAXREG);

// Diversification across industry sectors
 LimSec = new XPRBexpr[NTYPES];
   if(SECT[t][s]>0) LimSec[t] += frac[s];
  p.newCtr(LimSec[t] <= MAXSEC);

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

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

// Linking the variables
  p.newCtr(frac[s] <= MAXVAL*buy[s]);
  p.newCtr(frac[s] >= MINVAL*buy[s]);

// Create a MIP solution pool and attach it to the problem
// (so it collects the solutions)
 XPRSmipsolpool msp;
 XPRS_msp_probattach(msp, p.getXPRSprob());

// Avoid storing of duplicate solutions (3: compare discrete variables only)

// Solve the problem

// Setup some resources to iterate through the solutions stored
// in the MIP solution pool
 int nSols, nCols, i;
 double *xsol;
 int *solIDs;
 XPRSgetintattrib(p.getXPRSprob(), XPRS_ORIGINALCOLS, &nCols);
 XPRS_msp_getintattrib(msp, XPRS_MSP_SOLUTIONS, &nSols);
 xsol = (double *) malloc(nCols * sizeof(double));
 solIDs = (int *) malloc(nSols * sizeof(int));

                                         // Get the solution IDs
 XPRS_msp_getsollist(msp, p.getXPRSprob(), XPRS_MSP_SOLPRB_OBJ, 1, 1,
		     nSols, solIDs, &nSols, NULL);

// Display all solutions from the pool
 for(i=0; i<nSols; i++)
 {                                       // Get the solution
  XPRS_msp_getsol(msp, solIDs[i], NULL, xsol, 0, nCols - 1, NULL);
  p.loadMIPSol(xsol, nCols, 0);          // Load the solution into BCL
  print_sol(i+1);                        // Display the solution


 return 0;

// Solution printing
void print_sol(int num)
 int s;

 cout << "Solution " << num << ": Total return: " << Return.getAct() << endl;
   cout << "  " << SHARES_n[s] << ": " << frac[s].getSol()*100 << "% ("
        << buy[s].getSol() << ")" << endl;

Back to examples browserPrevious exampleNext example