FICO Xpress Optimization Examples Repository
 FICO Optimization Community FICO Xpress Optimization Home

Recurse - A successive linear programming model

Description
A non-linear problem (quadratic terms in the constraints) is modeled as a successive linear programming (SLP) model. (SLP is also known as 'recursion'.) The constraint coefficients are changed iteratively. Shows how to save and re-load an LP basis.

Source Files

xbrecurs.java

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

file xbrecurs.java
``````````````````
Recursion solving a non-linear financial planning problem
The problem is to solve
net(t) = Payments(t)  - interest(t)
balance(t) = balance(t-1) - net(t)
interest(t) = (92/365) * balance(t) * interest_rate
where
balance(0) = 0
balance[T] = 0
for interest_rate

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

import java.lang.*;
import com.dashoptimization.*;

public class xbrecurs
{
static final int T=6;

/****DATA****/
static double X = 0.00;         /* An INITIAL GUESS as to interest rate x */
static final double[] B =
/* {796.35, 589.8918, 398.1351, 201.5451, 0.0, 0.0}; */
{1,1,1,1,1,1};      /* An INITIAL GUESS as to balances b(t) */
static final double[] P = {-1000, 0, 0, 0, 0, 0};            /* Payments */
static final double[] R = {206.6, 206.6, 206.6, 206.6, 206.6, 0}; /*  "  */
static final double[] V = {-2.95, 0, 0, 0, 0, 0};                 /*  "  */

static XPRBvar[] b;             /* Balance */
static XPRBvar x;               /* Interest rate */
static XPRBvar dx;              /* Change to x */
static XPRBctr[] interest;
static XPRBctr ctrd;
static XPRB bcl;
static XPRBprob p;

/***********************************************************************/

static void modFinNLP() throws XPRSexception
{
XPRBvar[] i;                   /* Interest */
XPRBvar[] n;                   /* Net */
XPRBvar[] epl, emn;            /* + and - deviations */
XPRBexpr cobj, le;
int t;

bcl = new XPRB();              /* Initialize BCL */
p = bcl.newProb("Fin_nlp");    /* Create a new problem in BCL*/
XPRS.init();                   /* Initialize Xpress-Optimizer */

/****VARIABLES****/
b = new XPRBvar[T];
i = new XPRBvar[T];
n = new XPRBvar[T];
epl = new XPRBvar[T];
emn = new XPRBvar[T];
for(t=0;t<T;t++)
{
i[t]=p.newVar("i");
n[t]=p.newVar("n", XPRB.PL, -XPRB.INFINITY, XPRB.INFINITY);
b[t]=p.newVar("b", XPRB.PL, -XPRB.INFINITY, XPRB.INFINITY);
epl[t]=p.newVar("epl");
emn[t]=p.newVar("emn");
}
x=p.newVar("x");
dx=p.newVar("dx", XPRB.PL, -XPRB.INFINITY, XPRB.INFINITY);
i[0].fix(0);
b[T-1].fix(0);

/****OBJECTIVE****/
cobj = new XPRBexpr();
for(t=0;t<T;t++)               /* Objective: get feasible */
p.setObj(cobj);                /* Select objective function */
p.setSense(XPRB.MINIM);        /* Choose the sense of the optimization */

/****CONSTRAINTS****/
for(t=0;t<T;t++)
{                              /* net = payments - interest */
/* Money balance across periods */
else  p.newCtr("bal", b[t].eql(n[t].mul(-1)) );
}

interest = new XPRBctr[T];
for(t=1;t<T;t++)    /* i(t) = (92/365)*( b(t-1)*X + B(t-1)*dx ) approx. */
interest[t] =
.eql(i[t].mul(365/92.0)) );

ctrd = p.newCtr("def", x.eql(dx.add(X)) );   /* x = dx + X */
}

/**************************************************************************/
/*  Recursion loop (repeat until variation of x converges to 0):          */
/*    save the current basis and the solutions for variables b[t] and x   */
/*    set the balance estimates B[t] to the value of b[t]                 */
/*    set the interest rate estimate X to the value of x                  */
/*    reload the problem and the saved basis                              */
/*    solve the LP and calculate the variation of x                       */
/**************************************************************************/
static void solveFinNLP() throws XPRSexception
{
XPRBbasis basis;
double variation=1.0, oldval, XC;
double[] BC;
int t, ct=0;

p.getXPRSprob().setIntControl(XPRS.CUTSTRATEGY, 0);
/* Switch automatic cut generation off */

p.lpOptimize("");               /* Solve the LP-problem */

BC = new double[T];
while(variation>0.000001)
{
ct++;
basis=p.saveBasis();           /* Save the current basis */

/* Get the solution values for b and x */
for(t=1;t<T;t++) BC[t-1]=b[t-1].getSol();
XC=x.getSol();
System.out.println("Loop " + ct + ": " + x.getName() + ":" + x.getSol()
+ " (variation:" + variation + ")");

for(t=1;t<T;t++)               /* Change coefficients in interest[t] */
{
interest[t].setTerm(dx, BC[t-1]);
B[t-1]=BC[t-1];
interest[t].setTerm(b[t-1], XC);
}
ctrd.setTerm(XC);              /* Change constant term of ctrd */
X=XC;

oldval=XC;
basis=null;                    /* No need to keep the basis any longer */

p.lpOptimize("");              /* Solve the LP-problem */
variation=Math.abs(x.getSol()-oldval);
}

System.out.println("Objective: " + p.getObjVal()); /* Get objective value */
System.out.println("Interest rate: " + x.getSol()*100 + "%");
System.out.print("Balances:  ");
for(t=0;t<T;t++)                /* Print out the solution values */
System.out.print(b[t].getName() + ":" + b[t].getSol() + " ");
System.out.println();
}

/***********************************************************************/

public static void main(String[] args) throws XPRSprobException, XPRSexception
{
modFinNLP();                    /* Model the problem */
solveFinNLP();                  /* Solve the problem */
}
}

```