Initializing help system before first use

Folio - Examples from 'Getting started'
Type: Portfolio optimization
Rating: 2
Description:
  • Chapter 10 Inputting and Solving a Linear Programming problem
    • foliolp.cpp: modeling and solving a small LP problem
    • folioinit.cpp: performing explicit initialization
    • foliodata.cpp (data file: foliocpplp.dat): data input from file
  • Chapter 11 Mixed Integer Programming
    • foliomip1.cpp: modeling and solving a small MIP problem (binary variables)
    • foliomip2.cpp: modeling and solving a small MIP problem (semi-continuous variables)
  • Chapter 12 Quadratic Programming
    • folioqp.cppmodeling and solving a QP and a MIQP problem
    • folioqc.cpp (data file: foliocppqp.dat): modeling and solving a QCQP
  • Chapter 13 Heuristics
    • folioheur.cpp: heuristic solution of a MIP problem
File(s): foliolp.cpp, folioinit.cpp, foliodata.cpp, foliomip1.cpp, foliomip2.cpp, folioqp.cpp, folioheur.cpp
Data file(s): foliocpplp.dat, foliocppqp.dat
foliolp.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file foliolp.cpp
  ````````````````
  Modeling a small LP problem 
  to perform portfolio optimization.

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define NSHARES 10                   // Number of shares
#define NRISK 5                      // Number of high-risk shares
#define 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

int main(int argc, char **argv)
{
 int s;
 XPRBprob p("FolioLP");              // Initialize a new problem in BCL
 XPRBexpr Risk,Na,Return,Cap;
 XPRBvar frac[NSHARES];              // Fraction of capital used per share

// Create the decision variables
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s
folioinit.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file folioinit.cpp
  ``````````````````
  Modeling a small LP problem 
  to perform portfolio optimization.
  Explicit initialization.

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define NSHARES 10                   // Number of shares
#define NRISK 5                      // Number of high-risk shares
#define 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

void solveProb()
{
 int s;
 XPRBprob p("FolioLP");              // Initialize a new problem in BCL
 XPRBexpr Risk,Na,Return,Cap;
 XPRBvar frac[NSHARES];              // Fraction of capital used per share

// Create the decision variables
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s
foliodata.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file foliodata.cpp
  ``````````````````
  Modeling a small LP problem 
  to perform portfolio optimization.
  -- Data input from file --

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define DATAFILE "foliocpplp.dat"

#define NSHARES 10                   // Number of shares
#define NRISK 5                      // Number of high-risk shares
#define NNA 4                        // Number of North-American shares

double RET[NSHARES];                 // Estimated return in investment
char RISK[][100] = {"hardware", "theater", "telecom", "software", 
                    "electronics"};  // High-risk values among shares
char NA[][100] = {"treasury", "hardware", "theater", "telecom"};   
                                     // Shares issued in N.-America

XPRBindexSet SHARES;                 // Set of shares 

XPRBprob p("FolioLP");               // Initialize a new problem in BCL

void readData(void)
{
 double value;
 int s;
 FILE *datafile;
 char name[100];

 SHARES=p.newIndexSet("Shares",NSHARES);  // Create the `SHARES' index set

// Read `RET' data from file
 datafile=fopen(DATAFILE,"r");
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s
foliomip1.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

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

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define MAXNUM 4                   // Max. number of different assets

#define NSHARES 10                 // Number of shares
#define NRISK 5                    // Number of high-risk shares
#define 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

int main(int argc, char **argv)
{
 int s;
 XPRBprob p("FolioMIP1");          // Initialize a new problem in BCL
 XPRBexpr Risk,Na,Return,Cap,Num;
 XPRBvar frac[NSHARES];            // Fraction of capital used per share
 XPRBvar buy[NSHARES];             // 1 if asset is in portfolio, 0 otherwise

// Create the decision variables (including upper bounds for `frac')
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s
foliomip2.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file foliomip2.cpp
  ``````````````````
  Modeling a small MIP problem 
  to perform portfolio optimization.
   -- Imposing a minimum investment per share --

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define NSHARES 10                   // Number of shares
#define NRISK 5                      // Number of high-risk shares
#define 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

int main(int argc, char **argv)
{
 int s;
 XPRBprob p("FolioSC");              // Initialize a new problem in BCL
 XPRBexpr Risk,Na,Return,Cap;
 XPRBvar frac[NSHARES];              // Fraction of capital used per share

// Create the decision variables
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s
folioqp.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file folioqp.cpp
  ````````````````
  Modeling a small QP problem 
  to perform portfolio optimization.
   -- 1. QP: minimize variance
      2. MIQP: limited number of assets ---

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include 
#include "xprb_cpp.h"

using namespace std;
using namespace ::dashoptimization;

#define DATAFILE "foliocppqp.dat"

#define TARGET 9                   // Target yield
#define MAXNUM 4                   // Max. number of different assets

#define NSHARES 10                 // Number of shares
#define NNA 4                      // Number of North-American shares

double RET[] = {5,17,26,12,8,9,7,6,31,21};  // Estimated return in investment
int NA[] = {0,1,2,3};              // Shares issued in N.-America
double VAR[NSHARES][NSHARES];      // Variance/covariance matrix of
                                   // estimated returns

int main(int argc, char **argv)
{
 int s,t;
 XPRBprob p("FolioQP");            // Initialize a new problem in BCL
 XPRBexpr Na,Return,Cap,Num,Variance;
 XPRBvar frac[NSHARES];            // Fraction of capital used per share
 XPRBvar buy[NSHARES];             // 1 if asset is in portfolio, 0 otherwise
 FILE *datafile;

// Read `VAR' data from file
 datafile=fopen(DATAFILE,"r");
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s= TARGET);

// Solve the problem
 p.setSense(XPRB_MINIM);
 p.lpOptimize("");
 
// Solution printing
 cout << "With a target of " << TARGET << " minimum variance is " << 
         p.getObjVal() << endl;
 for(s=0;s
folioheur.cpp
/********************************************************
  Xpress BCL C++ Example Problems
  ===============================

  file folioheur.cpp
  ``````````````````
  Modeling a small MIP problem 
  to perform portfolio optimization.
   -- Heuristic solution --

  (c) 2008 Fair Isaac Corporation
      author: S.Heipcke, Aug. 2003, rev. Mar. 2011
********************************************************/

#include 
#include "xprb_cpp.h"
#include "xprs.h"

using namespace std;
using namespace ::dashoptimization;

#define MAXNUM 4                   // Max. number of shares to be selected

#define NSHARES 10                 // Number of shares
#define NRISK 5                    // Number of high-risk shares
#define NNA 4                      // Number of North-American shares

void solveHeur();

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

XPRBprob p("FolioMIPHeur");        // Initialize a new problem in BCL
XPRBvar frac[NSHARES];             // Fraction of capital used per share
XPRBvar buy[NSHARES];              // 1 if asset is in portfolio, 0 otherwise

int main(int argc, char **argv)
{
 int s;
 XPRBexpr Risk,Na,Return,Cap,Num;

// Create the decision variables (including upper bounds for `frac')
 for(s=0;s= 0.5);

// Spend all the capital
 for(s=0;s 0.2-TOL)  buy[s].setLB(1);
 }

 p.mipOptimize("c");               // Solve the MIP-problem
 ifgsol=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
  cout << "Heuristic solution: Total return: " << p.getObjVal() << endl;
  for(s=0;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.reset();             // No need to store the saved basis any longer 
 if(ifgsol==1)
  XPRSsetdblcontrol(p.getXPRSprob(), XPRS_MIPABSCUTOFF, solval+TOL);
                            // Set the cutoff to the best known solution

}
Parent Topic Getting Started