// pass an int for the problem number
int main( int argc, char *argv[] )
{
register int i, j;
int problem, ret;
double p[5], // 5 is max(2, 3, 5)
x[16]; // 16 is max(2, 3, 5, 6, 16)
int m, n;
double opts[LM_OPTS_SZ], info[LM_INFO_SZ];
char *probname[]={
"Rosenbrock function",
"modified Rosenbrock problem",
"Powell's function",
"Wood's function",
"Meyer's (reformulated) problem",
"Osborne's problem",
"helical valley function",
"Boggs & Tolle's problem #3",
"Hock - Schittkowski problem #28",
"Hock - Schittkowski problem #48",
"Hock - Schittkowski problem #51",
"Hock - Schittkowski problem #01",
"Hock - Schittkowski modified problem #21",
"hatfldb problem",
"hatfldc problem",
"equilibrium combustion problem",
"Hock - Schittkowski modified #1 problem #52",
"Schittkowski modified problem #235",
"Boggs & Tolle modified problem #7",
"Hock - Schittkowski modified #2 problem #52",
"Hock - Schittkowski modified problem #76",
};
opts[0]=LM_INIT_MU; opts[1]=1E-15; opts[2]=1E-15; opts[3]=1E-20;
opts[4]= LM_DIFF_DELTA; // relevant only if the Jacobian is approximated using finite differences; specifies forward differencing
//opts[4]=-LM_DIFF_DELTA; // specifies central differencing to approximate Jacobian; more accurate but more expensive to compute!
/* uncomment the appropriate line below to select a minimization problem */
if ( argc < 2 ) {
fprintf(stderr, "Supply an integer specifying problem number as command line argument\n");
exit(1);
}
problem = atoi(argv[1]);
//0; // Rosenbrock function
//1; // modified Rosenbrock problem
//2; // Powell's function
//3; // Wood's function
// 4; // Meyer's (reformulated) problem
//5; // Osborne's problem
//6; // helical valley function
#ifdef HAVE_LAPACK
//7; // Boggs & Tolle's problem 3
//8; // Hock - Schittkowski problem 28
//9; // Hock - Schittkowski problem 48
//10; // Hock - Schittkowski problem 51
#else // no LAPACK
#ifdef _MSC_VER
#pragma message("LAPACK not available, some test problems cannot be used")
#else
#warning LAPACK not available, some test problems cannot be used
#endif // _MSC_VER
#endif /* HAVE_LAPACK */
//11; // Hock - Schittkowski problem 01
//12; // Hock - Schittkowski modified problem 21
//13; // hatfldb problem
//14; // hatfldc problem
//15; // equilibrium combustion problem
#ifdef HAVE_LAPACK
//16; // Hock - Schittkowski modified #1 problem 52
//17; // Schittkowski modified problem 235
//18; // Boggs & Tolle modified problem #7
//19; // Hock - Schittkowski modified #2 problem 52
//20; // Hock - Schittkowski modified problem #76"
#endif /* HAVE_LAPACK */
switch(problem){
default: fprintf(stderr, "unknown problem specified (#%d)! Note that some minimization problems require LAPACK.\n", problem);
exit(1);
break;
case 0:
/* Rosenbrock function */
m=2; n=2;
p[0]=-1.2; p[1]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
ret=dlevmar_der(ros, jacros, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
//ret=dlevmar_dif(ros, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
break;
case 1:
/* modified Rosenbrock problem */
m=2; n=3;
p[0]=-1.2; p[1]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
ret=dlevmar_der(modros, jacmodros, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
//ret=dlevmar_dif(modros, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
break;
case 2:
/* Powell's function */
m=2; n=2;
p[0]=3.0; p[1]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
ret=dlevmar_der(powell, jacpowell, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
//ret=dlevmar_dif(powell, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
break;
case 3:
/* Wood's function */
m=4; n=6;
p[0]=-3.0; p[1]=-1.0; p[2]=-3.0; p[3]=-1.0;
for(i=0; i<n; i++) x[i]=0.0;
ret=dlevmar_dif(wood, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
break;
case 4:
/* Meyer's data fitting problem */
m=3; n=16;
p[0]=8.85; p[1]=4.0; p[2]=2.5;
x[0]=34.780; x[1]=28.610; x[2]=23.650; x[3]=19.630;
x[4]=16.370; x[5]=13.720; x[6]=11.540; x[7]=9.744;
x[8]=8.261; x[9]=7.030; x[10]=6.005; x[11]=5.147;
x[12]=4.427; x[13]=3.820; x[14]=3.307; x[15]=2.872;
//ret=dlevmar_der(meyer, jacmeyer, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{ double *work, *covar;
work=malloc((LM_DIF_WORKSZ(m, n)+m*m)*sizeof(double));
if(!work){
fprintf(stderr, "memory allocation request failed in main()\n");
exit(1);
}
covar=work+LM_DIF_WORKSZ(m, n);
ret=dlevmar_dif(meyer, p, x, m, n, 1000, opts, info, work, covar, NULL); // no Jacobian, caller allocates work memory, covariance estimated
printf("Covariance of the fit:\n");
for(i=0; i<m; ++i){
for(j=0; j<m; ++j)
printf("%g ", covar[i*m+j]);
printf("\n");
}
printf("\n");
free(work);
}
/* uncomment the following block to verify Jacobian */
/*
{
double err[16];
dlevmar_chkjac(meyer, jacmeyer, p, m, n, NULL, err);
for(i=0; i<n; ++i) printf("gradient %d, err %g\n", i, err[i]);
}
*/
break;
case 5:
/* Osborne's data fitting problem */
{
double x33[]={
8.44E-1, 9.08E-1, 9.32E-1, 9.36E-1, 9.25E-1, 9.08E-1, 8.81E-1,
8.5E-1, 8.18E-1, 7.84E-1, 7.51E-1, 7.18E-1, 6.85E-1, 6.58E-1,
6.28E-1, 6.03E-1, 5.8E-1, 5.58E-1, 5.38E-1, 5.22E-1, 5.06E-1,
4.9E-1, 4.78E-1, 4.67E-1, 4.57E-1, 4.48E-1, 4.38E-1, 4.31E-1,
4.24E-1, 4.2E-1, 4.14E-1, 4.11E-1, 4.06E-1};
m=5; n=33;
p[0]=0.5; p[1]=1.5; p[2]=-1.0; p[3]=1.0E-2; p[4]=2.0E-2;
ret=dlevmar_der(osborne, jacosborne, p, x33, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
//ret=dlevmar_dif(osborne, p, x33, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
}
break;
case 6:
/* helical valley function */
m=3; n=3;
p[0]=-1.0; p[1]=0.0; p[2]=0.0;
for(i=0; i<n; i++) x[i]=0.0;
ret=dlevmar_der(helval, jachelval, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
//ret=dlevmar_dif(helval, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // no Jacobian
break;
#ifdef HAVE_LAPACK
case 7:
/* Boggs-Tolle problem 3 */
m=5; n=5;
p[0]=2.0; p[1]=2.0; p[2]=2.0;
p[3]=2.0; p[4]=2.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[3*5]={1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -2.0, 0.0, 1.0, 0.0, 0.0, -1.0},
b[3]={0.0, 0.0, 0.0};
ret=dlevmar_lec_der(bt3, jacbt3, p, x, m, n, A, b, 3, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, analytic Jacobian
//ret=dlevmar_lec_dif(bt3, p, x, m, n, A, b, 3, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, no Jacobian
}
break;
case 8:
/* Hock - Schittkowski problem 28 */
m=3; n=3;
p[0]=-4.0; p[1]=1.0; p[2]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[1*3]={1.0, 2.0, 3.0},
b[1]={1.0};
ret=dlevmar_lec_der(hs28, jachs28, p, x, m, n, A, b, 1, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, analytic Jacobian
//ret=dlevmar_lec_dif(hs28, p, x, m, n, A, b, 1, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, no Jacobian
}
break;
case 9:
/* Hock - Schittkowski problem 48 */
m=5; n=5;
p[0]=3.0; p[1]=5.0; p[2]=-3.0;
p[3]=2.0; p[4]=-2.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[2*5]={1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, -2.0, -2.0},
b[2]={5.0, -3.0};
ret=dlevmar_lec_der(hs48, jachs48, p, x, m, n, A, b, 2, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, analytic Jacobian
//ret=dlevmar_lec_dif(hs48, p, x, m, n, A, b, 2, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, no Jacobian
}
break;
case 10:
/* Hock - Schittkowski problem 51 */
m=5; n=5;
p[0]=2.5; p[1]=0.5; p[2]=2.0;
p[3]=-1.0; p[4]=0.5;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[3*5]={1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -2.0, 0.0, 1.0, 0.0, 0.0, -1.0},
b[3]={4.0, 0.0, 0.0};
ret=dlevmar_lec_der(hs51, jachs51, p, x, m, n, A, b, 3, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, analytic Jacobian
//ret=dlevmar_lec_dif(hs51, p, x, m, n, A, b, 3, 1000, opts, info, NULL, NULL, NULL); // lin. constraints, no Jacobian
}
break;
#endif /* HAVE_LAPACK */
case 11:
/* Hock - Schittkowski problem 01 */
m=2; n=2;
p[0]=-2.0; p[1]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
//ret=dlevmar_der(hs01, jachs01, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{
double lb[2], ub[2];
lb[0]=-DBL_MAX; lb[1]=-1.5;
ub[0]=ub[1]=DBL_MAX;
ret=dlevmar_bc_der(hs01, jachs01, p, x, m, n, lb, ub, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
}
break;
case 12:
/* Hock - Schittkowski (modified) problem 21 */
m=2; n=2;
p[0]=-1.0; p[1]=-1.0;
for(i=0; i<n; i++) x[i]=0.0;
//ret=dlevmar_der(hs21, jachs21, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{
double lb[2], ub[2];
lb[0]=2.0; lb[1]=-50.0;
ub[0]=50.0; ub[1]=50.0;
ret=dlevmar_bc_der(hs21, jachs21, p, x, m, n, lb, ub, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
}
break;
case 13:
/* hatfldb problem */
m=4; n=4;
p[0]=p[1]=p[2]=p[3]=0.1;
for(i=0; i<n; i++) x[i]=0.0;
//ret=dlevmar_der(hatfldb, jachatfldb, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{
double lb[4], ub[4];
lb[0]=lb[1]=lb[2]=lb[3]=0.0;
ub[0]=ub[2]=ub[3]=DBL_MAX;
ub[1]=0.8;
ret=dlevmar_bc_der(hatfldb, jachatfldb, p, x, m, n, lb, ub, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
}
break;
case 14:
/* hatfldc problem */
m=4; n=4;
p[0]=p[1]=p[2]=p[3]=0.9;
for(i=0; i<n; i++) x[i]=0.0;
//ret=dlevmar_der(hatfldc, jachatfldc, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{
double lb[4], ub[4];
lb[0]=lb[1]=lb[2]=lb[3]=0.0;
ub[0]=ub[1]=ub[2]=ub[3]=10.0;
ret=dlevmar_bc_der(hatfldc, jachatfldc, p, x, m, n, lb, ub, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
}
break;
case 15:
/* equilibrium combustion problem */
m=5; n=5;
p[0]=p[1]=p[2]=p[3]=p[4]=0.0001;
for(i=0; i<n; i++) x[i]=0.0;
//ret=dlevmar_der(combust, jaccombust, p, x, m, n, 1000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
{
double lb[5], ub[5];
lb[0]=lb[1]=lb[2]=lb[3]=lb[4]=0.0001;
ub[0]=ub[1]=ub[2]=ub[3]=ub[4]=100.0;
ret=dlevmar_bc_der(combust, jaccombust, p, x, m, n, lb, ub, 5000, opts, info, NULL, NULL, NULL); // with analytic Jacobian
}
break;
#ifdef HAVE_LAPACK
case 16:
/* Hock - Schittkowski modified #1 problem 52 */
m=5; n=4;
p[0]=2.0; p[1]=2.0; p[2]=2.0;
p[3]=2.0; p[4]=2.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[3*5]={1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -2.0, 0.0, 1.0, 0.0, 0.0, -1.0},
b[3]={0.0, 0.0, 0.0};
double lb[5], ub[5];
double weights[5]={2000.0, 2000.0, 2000.0, 2000.0, 2000.0}; // penalty terms weights
lb[0]=-0.09; lb[1]=0.0; lb[2]=-DBL_MAX; lb[3]=-0.2; lb[4]=0.0;
ub[0]=DBL_MAX; ub[1]=0.3; ub[2]=0.25; ub[3]=0.3; ub[4]=0.3;
ret=dlevmar_blec_der(mod1hs52, jacmod1hs52, p, x, m, n, lb, ub, A, b, 3, weights, 1000, opts, info, NULL, NULL, NULL); // box & lin. constraints, analytic Jacobian
//ret=dlevmar_blec_dif(mod1hs52, p, x, m, n, lb, ub, A, b, 3, weights, 1000, opts, info, NULL, NULL, NULL); // box & lin. constraints, no Jacobian
}
break;
case 17:
/* Schittkowski modified problem 235 */
m=3; n=2;
p[0]=-2.0; p[1]=3.0; p[2]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[2*3]={1.0, 0.0, 1.0, 0.0, 1.0, -4.0},
b[2]={-1.0, 0.0};
double lb[3], ub[3];
lb[0]=-DBL_MAX; lb[1]=0.1; lb[2]=0.7;
ub[0]=DBL_MAX; ub[1]=2.9; ub[2]=DBL_MAX;
ret=dlevmar_blec_der(mods235, jacmods235, p, x, m, n, lb, ub, A, b, 2, NULL, 1000, opts, info, NULL, NULL, NULL); // box & lin. constraints, analytic Jacobian
//ret=dlevmar_blec_dif(mods235, p, x, m, n, lb, ub, A, b, 2, NULL, 1000, opts, info, NULL, NULL, NULL); // box & lin. constraints, no Jacobian
}
break;
case 18:
/* Boggs & Tolle modified problem 7 */
m=5; n=5;
p[0]=-2.0; p[1]=1.0; p[2]=1.0; p[3]=1.0; p[4]=1.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[3*5]={1.0, 1.0, -1.0, 0.0, 0.0, 1.0, 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0},
b[3]={1.0, 0.0, 0.5};
double lb[5], ub[5];
lb[0]=-DBL_MAX; lb[1]=-DBL_MAX; lb[2]=-DBL_MAX; lb[3]=-DBL_MAX; lb[4]=-0.3;
ub[0]=0.7; ub[1]= DBL_MAX; ub[2]= DBL_MAX; ub[3]= DBL_MAX; ub[4]=DBL_MAX;
ret=dlevmar_blec_der(modbt7, jacmodbt7, p, x, m, n, lb, ub, A, b, 3, NULL, 1000, opts, info, NULL, NULL, NULL); // box & lin. constraints, analytic Jacobian
//ret=dlevmar_blec_dif(modbt7, p, x, m, n, lb, ub, A, b, 3, NULL, 10000, opts, info, NULL, NULL, NULL); // box & lin. constraints, no Jacobian
}
break;
case 19:
/* Hock - Schittkowski modified #2 problem 52 */
m=5; n=5;
p[0]=2.0; p[1]=2.0; p[2]=2.0;
p[3]=2.0; p[4]=2.0;
for(i=0; i<n; i++) x[i]=0.0;
{
double C[3*5]={1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -2.0, 0.0, -1.0, 0.0, 0.0, 1.0},
d[3]={-1.0, -2.0, -7.0};
// ret=dlevmar_bleic_der(mod2hs52, jacmod2hs52, p, x, m, n, NULL, NULL, NULL, NULL, 0, C, d, 3, 1000, opts, info, NULL, NULL, NULL); // lin. ineq. constraints, analytic Jacobian
ret=dlevmar_lic_der(mod2hs52, jacmod2hs52, p, x, m, n, C, d, 3, 1000, opts, info, NULL, NULL, NULL); // lin. ineq. constraints, analytic Jacobian
//ret=dlevmar_bleic_dif(mod2hs52, p, x, m, n, NULL, NULL, NULL, NULL, 0, C, d, 3, 1000, opts, info, NULL, NULL, NULL); // lin. ineq. constraints, no Jacobian
}
break;
case 20:
/* Hock - Schittkowski modified problem 76 */
m=4; n=4;
p[0]=0.5; p[1]=0.5; p[2]=0.5; p[3]=0.5;
for(i=0; i<n; i++) x[i]=0.0;
{
double A[1*4]={0.0, 1.0, 4.0, 0.0},
b[1]={1.5};
double C[2*4]={-1.0, -2.0, -1.0, -1.0, -3.0, -1.0, -2.0, 1.0},
d[2]={-5.0, -0.4};
double lb[4]={0.0, 0.0, 0.0, 0.0};
ret=dlevmar_bleic_der(modhs76, jacmodhs76, p, x, m, n, lb, NULL, A, b, 1, C, d, 2, 1000, opts, info, NULL, NULL, NULL); // lin. ineq. constraints, analytic Jacobian
//ret=dlevmar_bleic_dif(modhs76, p, x, m, n, lb, NULL, A, b, 1, C, d, 2, 1000, opts, info, NULL, NULL, NULL); // lin. ineq. constraints, no Jacobian
/* variations:
* if no lb is used, the minimizer is (-0.1135922 0.1330097 0.3417476 0.07572816)
* if the rhs of constr2 is 4.0, the minimizer is (0.0, 0.166667, 0.333333, 0.0)
*/
}
break;
#endif /* HAVE_LAPACK */
} /* switch */
printf("Results for %s:\n", probname[problem]);
printf("Levenberg-Marquardt returned %d in %g iter, reason %g\nSolution: ", ret, info[5], info[6]);
for(i=0; i<m; ++i)
printf("%.7g ", p[i]);
printf("\n\nMinimization info:\n");
for(i=0; i<LM_INFO_SZ; ++i)
printf("%g ", info[i]);
printf("\n");
return 0;
}
// Function definitions.
// -----------------------------------------------------------------
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Input Args
user_function_data fun;
double *x0, *ydata = NULL, *lb = NULL, *ub = NULL, *A = NULL, *b = NULL, *Aeq = NULL, *beq = NULL;
//Options
int maxIter = 500;
double info[LM_INFO_SZ];
double opts[LM_OPTS_SZ]={J_INIT_MU, J_STOP_THRESH, J_STOP_THRESH, J_STOP_THRESH, LM_DIFF_DELTA};
//Outputs Args
double *x, *fval, *exitflag, *iter, *feval;
double *pcovar = NULL;
//Internal Vars
size_t ndec, ndat;
int i, status, havJac = 0, conMode = 0;
int nineq=0, neq=0;
double *covar = NULL;
double *Apr, *bpr;
double *llb, *lub;
citer = 1;
iterF.enabled = false;
if (nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(LM_VERSION);
return;
}
//Check user inputs & get constraint information
checkInputs(prhs,nrhs,&conMode);
//Get Sizes
ndec = mxGetNumberOfElements(prhs[2]);
ndat = mxGetNumberOfElements(prhs[3]);
//Get Objective Function Handle
if (mxIsChar(prhs[0])) {
CHECK(mxGetString(prhs[0], fun.f, FLEN) == 0,"error reading objective name string");
fun.nrhs = 1;
fun.xrhs = 0;
} else {
fun.prhs[0] = (mxArray*)prhs[0];
strcpy(fun.f, "feval");
fun.nrhs = 2;
fun.xrhs = 1;
}
fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0
fun.print = 0;
//Check and Get Gradient Function Handle
if(!mxIsEmpty(prhs[1])) {
havJac = 1;
if (mxIsChar(prhs[1])) {
CHECK(mxGetString(prhs[1], fun.g, FLEN) == 0,"error reading gradient name string");
fun.nrhs_g = 1;
fun.xrhs_g = 0;
} else {
fun.prhs_g[0] = (mxArray*)prhs[1];
strcpy(fun.g, "feval");
fun.nrhs_g = 2;
fun.xrhs_g = 1;
}
fun.prhs_g[fun.xrhs_g] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0
}
//Get x0 + data
x0 = mxGetPr(prhs[2]);
ydata = mxGetPr(prhs[3]);
fun.ydata = ydata;
//Get Bounds
if(conMode & 1) {
//LB
if(!mxIsEmpty(prhs[4])){
llb = mxGetPr(prhs[4]);
lb = mxCalloc(ndec,sizeof(double));
memcpy(lb,llb,ndec*sizeof(double));
for(i=0;i<ndec;i++) {
if(mxIsInf(lb[i]))
lb[i] = -DBL_MAX;
}
}
else {
lb = mxCalloc(ndec,sizeof(double));
for(i=0;i<ndec;i++)
lb[i] = -DBL_MAX;
}
//UB
if(nrhs > 5 && !mxIsEmpty(prhs[5])){
lub = mxGetPr(prhs[5]);
ub = mxCalloc(ndec,sizeof(double));
memcpy(ub,lub,ndec*sizeof(double));
for(i=0;i<ndec;i++) {
if(mxIsInf(ub[i]))
ub[i] = DBL_MAX;
}
}
else {
ub = mxCalloc(ndec,sizeof(double));
for(i=0;i<ndec;i++)
ub[i] = DBL_MAX;
}
}
//Get Linear Inequality Constraints
if(conMode & 2) {
nineq = (int)mxGetM(prhs[7]);
Apr = mxGetPr(prhs[6]);
bpr = mxGetPr(prhs[7]);
//Need to flip >= to <=
A = mxCalloc(ndec*nineq,sizeof(double));
b = mxCalloc(nineq,sizeof(double));
for(i=0;i<ndec*nineq;i++)
A[i] = -Apr[i];
for(i=0;i<nineq;i++)
b[i] = -bpr[i];
}
//Get Linear Equality Constraints
if(conMode & 4) {
Aeq = mxGetPr(prhs[8]);
beq = mxGetPr(prhs[9]);
neq = (int)mxGetM(prhs[9]);
}
//Get Options if specified
if(nrhs > 10) {
if(mxGetField(prhs[10],0,"maxiter"))
maxIter = (int)*mxGetPr(mxGetField(prhs[10],0,"maxiter"));
if(mxGetField(prhs[10],0,"display"))
fun.print = (int)*mxGetPr(mxGetField(prhs[10],0,"display"));
if(mxGetField(prhs[10],0,"iterfun") && !mxIsEmpty(mxGetField(prhs[10],0,"iterfun")))
{
iterF.prhs[0] = (mxArray*)mxGetField(prhs[10],0,"iterfun");
strcpy(iterF.f, "feval");
iterF.enabled = true;
iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL);
}
}
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
iter = mxGetPr(plhs[3]);
feval = mxGetPr(plhs[4]);
//Copy initial guess to x
memcpy(x,x0,ndec*sizeof(double));
//Create Covariance Matrix if Required
if(nlhs>4)
covar=mxCalloc(ndec*ndec,sizeof(double));
//Print Header
if(fun.print) {
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is LEVMAR v2.5\n");
mexPrintf(" Author: Manolis Lourakis\n MEX Interface J. Currie 2011\n\n");
mexPrintf(" Problem Properties:\n");
mexPrintf(" # Decision Variables: %4d\n",ndec);
mexPrintf(" # Data Points: %4d\n",ndat);
mexPrintf("------------------------------------------------------------------\n");
}
//Solve based on constraints
switch(conMode)
{
case MIN_UNCONSTRAINED:
//mexPrintf("Unc Problem\n");
if(havJac)
status = dlevmar_der(func, jac, x, ydata, (int)ndec, (int)ndat, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_dif(func, x, ydata, (int)ndec, (int)ndat, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_BC:
//mexPrintf("Box Constrained Problem\n");
if(havJac)
status = dlevmar_bc_der(func, jac, x, ydata, (int)ndec, (int)ndat, lb, ub, NULL, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_bc_dif(func, x, ydata, (int)ndec, (int)ndat, lb, ub, NULL, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_LIC:
//mexPrintf("Linear Inequality Problem\n");
if(havJac)
status = dlevmar_lic_der(func, jac, x, ydata, (int)ndec, (int)ndat, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_lic_dif(func, x, ydata, (int)ndec, (int)ndat, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_BLIC:
//mexPrintf("Boxed Linear Inequality Problem\n");
if(havJac)
status = dlevmar_blic_der(func, jac, x, ydata, (int)ndec, (int)ndat, lb, ub, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_blic_dif(func, x, ydata, (int)ndec, (int)ndat, lb, ub, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_LEC:
//mexPrintf("Linear Equality Problem\n");
if(havJac)
status = dlevmar_lec_der(func, jac, x, ydata, (int)ndec, (int)ndat, Aeq, beq, neq, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_lec_dif(func, x, ydata, (int)ndec, (int)ndat, Aeq, beq, neq, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_BLEC:
//mexPrintf("Boxed Linear Equality Problem\n");
if(havJac)
status = dlevmar_blec_der(func, jac, x, ydata, (int)ndec, (int)ndat, lb, ub, Aeq, beq, neq, NULL, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_blec_dif(func, x, ydata, (int)ndec, (int)ndat, lb, ub, Aeq, beq, neq, NULL, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_LEIC:
//mexPrintf("Linear Inequality + Equality Problem\n");
if(havJac)
status = dlevmar_leic_der(func, jac, x, ydata, (int)ndec, (int)ndat, Aeq, beq, neq, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_leic_dif(func, x, ydata, (int)ndec, (int)ndat, Aeq, beq, neq, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
break;
case MIN_CONSTRAINED_BLEIC:
//mexPrintf("Boxed Linear Inequality + Equality Problem\n");
if(havJac)
status = dlevmar_bleic_der(func, jac, x, ydata, (int)ndec, (int)ndat, lb, ub, Aeq, beq, neq, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
else
status = dlevmar_bleic_dif(func, x, ydata, (int)ndec, (int)ndat, lb, ub, Aeq, beq, neq, A, b, nineq, maxIter, opts, info, NULL, covar, &fun);
break;
default:
mexErrMsgTxt("Unknown constraint configuration");
}
//Save Status & Iterations
*fval = info[1];
*exitflag = getStatus(info[6]);
*iter = (double)status;
*feval = (double)citer;
//Save Covariance if Required
if(nlhs > 5) {
plhs[5] = mxCreateDoubleMatrix(ndec, ndec, mxREAL);
pcovar = mxGetPr(plhs[5]);
memcpy(pcovar,covar,ndec*ndec*sizeof(double));
}
//Print Header
if(fun.print){
//Termination Detected
if(*exitflag == 1)
mexPrintf("\n *** SUCCESSFUL TERMINATION ***\n");
else if(*exitflag == 0)
mexPrintf("\n *** MAXIMUM ITERATIONS REACHED ***\n");
else if(*exitflag == -1)
mexPrintf("\n *** TERMINATION: TOLERANCE TOO SMALL ***\n");
else if(*exitflag == -2)
mexPrintf("\n *** TERMINATION: ROUTINE ERROR ***\n");
if(*exitflag==1)
mexPrintf(" Final SSE: %12.5g\n In %3.0f iterations\n",*fval,*iter);
mexPrintf("------------------------------------------------------------------\n\n");
}
//Clean Up
if(lb) mxFree(lb);
if(ub) mxFree(ub);
if(covar) mxFree(covar);
if(A) mxFree(A);
if(b) mxFree(b);
}