int main( int argc, char *argv[] )
{
int n1 = 5, m1 = 2, m2 = 2;
if(argc >= 4) {
n1 = atoi(argv[1]);
m1 = atoi(argv[2]);
m2 = atoi(argv[3]);
} else {
cout << endl
<< " Erroneous calling sequence; should be " << endl
<< " qpgen-dense-mehrotra.exe n my mz " << endl
<< " where n = # primal variables, " << endl
<< " my = # equality constraints, " << endl
<< " mz = # inequality constraints " << endl << endl;
return 1;
}
int nnzQ = (int) .20 * (n1 * n1);
int nnzA = (int) .15 * (m1 * n1);
int nnzC = (int) .10 * (m2 * n1);
if( nnzQ < 3 * n1 ) nnzQ = 3 * n1;
if( nnzA < 3 * m1 ) nnzA = 3 * m1;
if( nnzC < 3 * m2 ) nnzC = 2 * m2;
QpGenSparseMa27 * qp = new QpGenSparseMa27( n1, m1, m2,
nnzQ, nnzA, nnzC );
QpGenData * prob; QpGenVars * soln;
qp->makeRandomData( prob, soln );
QpGenVars * vars = (QpGenVars *) qp->makeVariables( prob );
Residuals * resid = qp->makeResiduals( prob );
GondzioSolver * s = new GondzioSolver( qp, prob );
s->monitorSelf();
int result = s->solve(prob,vars, resid);
delete s;
if( 0 == result ) {
cout.precision(4);
cout << "\nComputed solution:\n\n";
vars->print();
QpGenVars * temp = (QpGenVars *) qp->makeVariables( prob );
cout << "\nChecking the solution...";
if( solutionMatches( vars, soln, temp, 1e-4 ) ) {
cout << "The solution appears to be correct.\n";
} else {
cout << "\nThe solution may be wrong "
"(or the generated problem may be ill conditioned.)\n";
}
delete temp;
} else {
cout << "Could not solve this problem.\n";
}
delete vars;
delete soln;
delete prob;
delete qp;
return result;
}
//Main Function
void mexFunction( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
//Input Args
double *H = NULL, *f = NULL, *A = NULL, *rl = NULL, *ru = NULL, *Aeq = NULL, *beq = NULL, *lb = NULL, *ub = NULL;
//Return Args
double *x, *fval, *exitflag, *iter;
//Options
int maxIter = 100;
int printLevel = 0;
int linSolver = USE_MA57;
int algorithm = GONDZIO;
double objbias = 0;
double maxTime = 1000;
//Sparse Indicing
double *Ht, *At, *Aeqt;
int *iH_ir, *iH_jc, *iA_ir, *iA_jc, *iAeq_ir, *iAeq_jc;
//Problem Size
size_t ndec, neq, nin;
mwSize nnzH, nnzA, nnzAeq;
//Infinite Check Indexing
char *ilb = NULL, *iub = NULL, *irl = NULL, *iru = NULL;
//Local Copies
double *qp_rl = NULL, *qp_ru = NULL, *qp_lb = NULL , *qp_ub = NULL;
//Internal Vars
int i, err;
const char *fnames[4] = {"pi","y","phi","gamma"};
char msgbuf[1024];
mxArray *d_pi, *d_y, *d_phi, *d_gam;
//Check # Inputs
if(nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else {
sprintf(msgbuf,"%d.%02d.%02d",OOQPVERSIONMAJOR,OOQPVERSIONMINOR,OOQPVERSIONPATCHLEVEL);
plhs[0] = mxCreateString(msgbuf);
plhs[1] = mxCreateDoubleScalar(OPTI_VER);
}
return;
}
//Thorough Check
checkInputs(prhs,nrhs);
//Get pointers to Input variables
f = mxGetPr(pF);
if(!mxIsEmpty(pA)) {
rl = mxGetPr(pRL);
ru = mxGetPr(pRU);
}
if(nrhs > eAEQ && !mxIsEmpty(pAEQ)) {
beq = mxGetPr(pBEQ);
}
if(nrhs > eLB && !mxIsEmpty(pLB))
lb = mxGetPr(pLB);
if(nrhs > eUB && !mxIsEmpty(pUB))
ub = mxGetPr(pUB);
//Get options if specified
if(nrhs > eOPTS) {
if(mxGetField(pOPTS,0,"objbias"))
objbias = *mxGetPr(mxGetField(pOPTS,0,"objbias"));
if(mxGetField(pOPTS,0,"display"))
printLevel = (int)*mxGetPr(mxGetField(pOPTS,0,"display"));
if(mxGetField(pOPTS,0,"maxiter"))
maxIter = (int)*mxGetPr(mxGetField(pOPTS,0,"maxiter"));
if(mxGetField(pOPTS,0,"maxtime"))
maxTime = *mxGetPr(mxGetField(pOPTS,0,"maxtime"));
if(mxGetField(pOPTS,0,"linear_solver")) {
if(mxIsChar(mxGetField(pOPTS,0,"linear_solver"))) {
char *str = mxArrayToString(mxGetField(pOPTS,0,"linear_solver"));
lower(str);
if(!strcmp(str,"pardiso"))
linSolver = USE_PARDISO;
else if(!strcmp(str,"ma57"))
linSolver = USE_MA57;
else if(!strcmp(str,"ma27"))
linSolver = USE_MA27;
else
mexErrMsgTxt("Unknown linear solver - options are 'pardiso', 'ma57' or 'ma27'");
mxFree(str);
}
else
linSolver = (int)*mxGetPr(mxGetField(pOPTS,0,"linear_solver"));
}
if(mxGetField(pOPTS,0,"algorithm")) {
if(mxIsChar(mxGetField(pOPTS,0,"algorithm"))) {
char *str = mxArrayToString(mxGetField(pOPTS,0,"algorithm"));
lower(str);
if(!strcmp(str,"gondzio"))
algorithm = GONDZIO;
else if(!strcmp(str,"mehrotra"))
algorithm = MEHROTRA;
else
mexErrMsgTxt("Unknown algorithm - options are 'gondzio' or 'mehrotra'");
mxFree(str);
}
else
algorithm = (int)*mxGetPr(mxGetField(pOPTS,0,"algorithm"));
}
CheckOptiVersion(pOPTS);
}
//Check Linear Solver is Available
switch(linSolver)
{
case USE_PARDISO:
#if !defined(LINK_PARDISO) && !defined(LINK_MKL_PARDISO)
mexErrMsgTxt("PARDISO is selected as the linear solver but is not available in this build");
#endif
break;
case USE_MA57:
#if !defined(LINK_ML_MA57) && !defined(LINK_MA57)
mexErrMsgTxt("MA57 is selected as the linear solver but is not available in this build");
#endif
break;
case USE_MA27:
#ifndef LINK_MA27
mexErrMsgTxt("MA27 is selected as the linear solver but is not available in this build");
#endif
break;
default:
mexErrMsgTxt("Unknown linear solver selected");
}
//Get sizes
ndec = mxGetNumberOfElements(pF); //f
nin = mxGetM(pA); //A
if(nrhs > eAEQ && !mxIsEmpty(pAEQ))
neq = mxGetM(pAEQ); //Aeq
else
neq = 0;
if(mxIsEmpty(pH))
nnzH = 0;
else
nnzH = mxGetJc(pH)[mxGetN(pH)];
if(mxIsEmpty(pA))
nnzA = 0;
else
nnzA = mxGetJc(pA)[mxGetN(pA)];
if(nrhs <= eAEQ || mxIsEmpty(pAEQ))
nnzAeq = 0;
else
nnzAeq = mxGetJc(pAEQ)[mxGetN(pAEQ)];
//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(nin+neq,1,mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
iter = mxGetPr(plhs[3]);
//Optional Outputs
if(nlhs > 4) {
plhs[4] = mxCreateStructMatrix(1,1,4,fnames);
d_pi = mxCreateDoubleMatrix(nin,1, mxREAL);
d_y = mxCreateDoubleMatrix(neq,1, mxREAL);
d_phi = mxCreateDoubleMatrix(ndec,1, mxREAL);
d_gam = mxCreateDoubleMatrix(ndec,1, mxREAL);
}
try
{
//QP Variables
QpGenSparseMa27 *qp27 = NULL;
QpGenSparseMa57 *qp57 = NULL;
QpGenSparsePardiso *qpPD = NULL;
QpGenData *prob = NULL;
QpGenVars *vars = NULL;
QpGenResiduals *resid = NULL;
MehrotraSolver *sm = NULL;
GondzioSolver *sg = NULL;
mexPrinter *printer; //deleted automatically (I think)
//Bounds Local Vectors
ilb = (char*) mxCalloc(ndec, sizeof(char));
iub = (char*) mxCalloc(ndec, sizeof(char));
qp_lb = (double*)mxCalloc(ndec, sizeof(double));
qp_ub = (double*)mxCalloc(ndec, sizeof(double));
//Copy lb if exists
if(nrhs > eLB && !mxIsEmpty(pLB)) {
for(i=0;i<ndec;i++) {
//Create Finite lb Index Vectors + Copy Finite Values
if(mxIsFinite(lb[i])) {
ilb[i] = 1;
qp_lb[i] = lb[i];
}
else {
ilb[i] = 0;
qp_lb[i] = 0.0;
}
}
}
//Else fill lb with 0s
else {
for(i=0;i<ndec;i++) {
ilb[i] = 0;
qp_lb[i] = 0.0;
}
}
//Copy ub if exists
if(nrhs > eUB && !mxIsEmpty(pUB)) {
for(i=0;i<ndec;i++) {
//Create Finite ub Index Vectors + Copy Finite Values
if(mxIsFinite(ub[i])) {
iub[i] = 1;
qp_ub[i] = ub[i];
}
else {
iub[i] = 0;
qp_ub[i] = 0.0;
}
}
}
//Else fill ub with 0s
else {
for(i=0;i<ndec;i++) {
iub[i] = 0;
qp_ub[i] = 0.0;
}
}
//Copy Linear Inequalities RHS if exist
if(nin > 0) {
irl = (char*) mxCalloc(nin, sizeof(char));
iru = (char*) mxCalloc(nin, sizeof(char));
qp_rl = (double*)mxCalloc(nin, sizeof(double));
qp_ru = (double*)mxCalloc(nin, sizeof(double));
for( i = 0; i < nin; i++ ) {
//Create Finite rl Index Vectors + Copy Finite Values
if(mxIsFinite(rl[i])) {
irl[i] = 1;
qp_rl[i] = rl[i];
}
else {
irl[i] = 0;
qp_rl[i] = 0.0;
}
//Create Finite ru Index Vectors + Copy Finite Values
if(mxIsFinite(ru[i])) {
iru[i] = 1;
qp_ru[i] = ru[i];
}
else {
iru[i] = 0;
qp_ru[i] = 0.0;
}
}
}
//QP H Matrix
if(!mxIsEmpty(pH)) {
iH_jc = (int*)mxCalloc(mxGetM(pH)+1,sizeof(int));
iH_ir = (int*)mxCalloc(nnzH,sizeof(int));
Ht = (double*)mxCalloc(nnzH,sizeof(double));
//Transpose Matrix & convert to int32
sparseTranspose(mxGetJc(pH), mxGetIr(pH), mxGetPr(pH), iH_jc, iH_ir, Ht, nnzH, mxGetM(pH), mxGetN(pH));
}
else {
iH_ir = (int*)mxCalloc(1,sizeof(int));
iH_jc = (int*)mxCalloc(ndec+1,sizeof(int)); iH_jc[ndec] = 0;
Ht = (double*)mxCalloc(1,sizeof(int));
}
//Linear Inequality Constraints A Matrix
if(!mxIsEmpty(pA)) {
//Allocate transpose memory
iA_jc = (int*)mxCalloc(mxGetM(pA)+1,sizeof(int));
iA_ir = (int*)mxCalloc(nnzA,sizeof(int));
At = (double*)mxCalloc(nnzA,sizeof(double));
//Transpose Matrix & convert to int32
sparseTranspose(mxGetJc(pA), mxGetIr(pA), mxGetPr(pA), iA_jc, iA_ir, At, nnzA, mxGetM(pA), mxGetN(pA));
}
else {
iA_ir = (int*)mxCalloc(1,sizeof(int));
iA_jc = (int*)mxCalloc(1,sizeof(int)); iA_jc[0] = 0;
At = (double*)mxCalloc(1,sizeof(double));
}
//Linear Equality Constraints Aeq Matrix
if(nrhs > eAEQ && !mxIsEmpty(pAEQ)) {
//Allocate transpose memory
iAeq_jc = (int*)mxCalloc(mxGetM(pAEQ)+1,sizeof(int));
iAeq_ir = (int*)mxCalloc(nnzAeq,sizeof(int));
Aeqt = (double*)mxCalloc(nnzAeq,sizeof(double));
//Transpose Matrix & convert to int32
sparseTranspose(mxGetJc(pAEQ), mxGetIr(pAEQ), mxGetPr(pAEQ), iAeq_jc, iAeq_ir, Aeqt, nnzAeq, mxGetM(pAEQ), mxGetN(pAEQ));
}
else {
iAeq_ir = (int*)mxCalloc(1,sizeof(int));
iAeq_jc = (int*)mxCalloc(1,sizeof(int)); iAeq_jc[0] = 0;
Aeqt = (double*)mxCalloc(1,sizeof(double));
}
#ifdef DEBUG
mexPrintf("\n\nProblem properties\n");
for(i = 0; i < ndec; i++) {
mexPrintf("%d: f %f lb %f ilb %d ub %f iub %d\n",i,f[i],qp_lb[i],ilb[i],qp_ub[i],iub[i]);
}
mexPrintf("\n");
for(i = 0; i < nin; i++) {
mexPrintf("%d: rl %f irl %d ru %f iru %d\n",i,qp_rl[i],irl[i],qp_ru[i],iru[i]);
}
mexPrintf("\n");
for(i = 0; i < neq; i++) {
mexPrintf("%d: beq %f\n",i,beq[i]);
}
mexPrintf("\n");
H = mxGetPr(pH);
for(i = 0; i < nnzH; i++) {
if(i <= mxGetM(pH))
mexPrintf("%d: Hjc %3d Hir %3d Hpr %f\n",i,iH_jc[i], iH_ir[i], H[i]);
else
mexPrintf("%d: Hir %3d Hpr %f\n",i,iH_ir[i], H[i]);
}
mexPrintf("\n");
for(i = 0; i < nnzA; i++) {
if(i <= mxGetM(pA))
mexPrintf("%d: Ajc %3d Air %3d Apr %f\n",i,iA_jc[i], iA_ir[i], At[i]);
else
mexPrintf("%d: Air %3d Apr %f\n",i,iA_ir[i], At[i]);
}
mexPrintf("\n");
for(i = 0; i < nnzAeq; i++) {
if(i <= mxGetM(pAEQ))
mexPrintf("%d: Aeqjc %3d Aeqir %3d Aeqpr %f\n",i,iAeq_jc[i], iAeq_ir[i], Aeqt[i]);
else
mexPrintf("%d: Aeqir %3d Aeqpr %f\n",i,iAeq_ir[i], Aeqt[i]);
}
#endif
//Create Problem, fill in data and make variables
switch(linSolver)
{
#if defined(LINK_PARDISO) || defined(LINK_MKL_PARDISO)
case USE_PARDISO:
qpPD = new QpGenSparsePardiso((int)ndec,(int)neq,(int)nin,(int)nnzH,(int)nnzAeq,(int)nnzA);
prob = (QpGenData*) qpPD->makeData( f, iH_jc, iH_ir, Ht, qp_lb, ilb, qp_ub, iub, iAeq_jc, iAeq_ir, Aeqt, beq, iA_jc, iA_ir, At, qp_rl, irl, qp_ru, iru);
vars = (QpGenVars*)qpPD->makeVariables(prob);
resid = (QpGenResiduals*)qpPD->makeResiduals(prob);
break;
#endif
#ifdef LINK_MA27
case USE_MA27:
qp27 = new QpGenSparseMa27((int)ndec,(int)neq,(int)nin,(int)nnzH,(int)nnzAeq,(int)nnzA);
prob = (QpGenData*) qp27->makeData( f, iH_jc, iH_ir, Ht, qp_lb, ilb, qp_ub, iub, iAeq_jc, iAeq_ir, Aeqt, beq, iA_jc, iA_ir, At, qp_rl, irl, qp_ru, iru);
vars = (QpGenVars*)qp27->makeVariables(prob);
resid = (QpGenResiduals*)qp27->makeResiduals(prob);
break;
#endif
#if defined(LINK_MA57) || defined(LINK_ML_MA57)
case USE_MA57:
qp57 = new QpGenSparseMa57((int)ndec,(int)neq,(int)nin,(int)nnzH,(int)nnzAeq,(int)nnzA);
prob = (QpGenData*) qp57->makeData( f, iH_jc, iH_ir, Ht, qp_lb, ilb, qp_ub, iub, iAeq_jc, iAeq_ir, Aeqt, beq, iA_jc, iA_ir, At, qp_rl, irl, qp_ru, iru);
vars = (QpGenVars*)qp57->makeVariables(prob);
resid = (QpGenResiduals*)qp57->makeResiduals(prob);
break;
#endif
}
//Make Solver
switch(algorithm)
{
case MEHROTRA:
switch(linSolver)
{
case USE_PARDISO:
sm = new MehrotraSolver(qpPD,prob);
break;
case USE_MA27:
sm = new MehrotraSolver(qp27,prob);
break;
case USE_MA57:
sm = new MehrotraSolver(qp57,prob);
break;
}
break;
case GONDZIO:
switch(linSolver)
{
case USE_PARDISO:
sg = new GondzioSolver(qpPD,prob);
break;
case USE_MA27:
sg = new GondzioSolver(qp27,prob);
break;
case USE_MA57:
sg = new GondzioSolver(qp57,prob);
break;
}
break;
default:
throw exception("Unknown algorithm!");
}
//Assign Status Handler (need more info from solver class really..)
DerivedStatus *ctrlCStatus = new DerivedStatus(maxIter, maxTime, clock());
switch(algorithm)
{
case MEHROTRA:
sm->useStatus(ctrlCStatus);
break;
case GONDZIO:
sg->useStatus(ctrlCStatus);
break;
}
//Setup Options
if(printLevel > 0) {
if(printLevel > 1) { //iter print
printer = new mexPrinter();
switch(algorithm)
{
case MEHROTRA:
sm->addMonitor( printer );
break;
case GONDZIO:
sg->addMonitor( printer );
break;
}
}
//Print Header
char verStr[1024], algStr[128], linStr[128];
getOoqpVersionString( verStr, 1024);
switch(algorithm)
{
case MEHROTRA: sprintf(algStr,"Mehrotra"); break;
case GONDZIO: sprintf(algStr,"Gondzio"); break;
}
switch(linSolver)
{
case USE_PARDISO: sprintf(linStr,"PARDSIO"); break;
case USE_MA27: sprintf(linStr,"MA27"); break;
case USE_MA57: sprintf(linStr,"MA57"); break;
}
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is %s\n Authors: E. Michael Gertz, Stephen J. Wright\n\n",verStr);
mexPrintf(" This run uses the %s Solver with %s\n\n Problem Properties:\n",algStr,linStr);
mexPrintf(" # Decision Variables: %6d [%d nz]\n # Inequality Constraints: %6d [%d nz]\n # Equality Constraints: %6d [%d nz]\n",ndec,nnzH,nin,nnzA,neq,nnzAeq);
if(printLevel > 1)
mexPrintf("------------------------------------------------------------------\n");
mexEvalString("drawnow;");
}
//Solve QP
try
{
switch(algorithm)
{
case MEHROTRA:
err = sm->solve(prob,vars,resid);
break;
case GONDZIO:
err = sg->solve(prob,vars,resid);
break;
}
}
catch(...)
{
mexWarnMsgTxt("Error solving problem with OOQP");
return;
}
//Assign variables
*exitflag = err;
vars->x->copyIntoArray(x);
*fval = prob->objectiveValue(vars)+objbias;
switch(algorithm)
{
case MEHROTRA:
*iter = (double)sm->iter;
break;
case GONDZIO:
*iter = (double)sg->iter;
break;
}
//Assign Dual Solution
if(nlhs > 4) {
vars->pi->copyIntoArray(mxGetPr(d_pi)); //dual row in
mxSetField(plhs[4],0,fnames[0],d_pi);
vars->y->copyIntoArray(mxGetPr(d_y)); //dual row eq
mxSetField(plhs[4],0,fnames[1],d_y);
vars->phi->copyIntoArray(mxGetPr(d_phi)); //dual col upper
mxSetField(plhs[4],0,fnames[2],d_phi);
vars->gamma->copyIntoArray(mxGetPr(d_gam)); //dual col lower
mxSetField(plhs[4],0,fnames[3],d_gam);
}
if(printLevel > 0){
//Termination Detected
switch(err)
{
case SUCCESSFUL_TERMINATION: mexPrintf("\n *** SUCCESSFUL TERMINATION ***\n"); break;
case MAX_ITS_EXCEEDED: mexPrintf("\n *** MAXIMUM ITERATIONS REACHED ***\n"); break;
case MAX_TIME_EXCEEDED: mexPrintf("\n *** MAXIMUM TIME REACHED ***\n"); break;
case USER_EXITED: mexPrintf("\n *** USER EXITED ***\n"); break;
case INFEASIBLE: mexPrintf("\n *** TERMINATION: PROBABLY INFEASIBLE ***\n"); break;
default: mexPrintf("\n *** TERMINATION: STATUS UNKNOWN ***\n"); break;
}
if(err == SUCCESSFUL_TERMINATION || err == MAX_ITS_EXCEEDED || err == MAX_TIME_EXCEEDED)
mexPrintf(" Final Objective Value: %9.3g\n In %3.0f iterations\n",*fval,*iter);
mexPrintf("------------------------------------------------------------------\n\n");
}
/* Free any scratch arrays */
if( iru != NULL ) mxFree( iru ); iru = NULL;
if( irl != NULL ) mxFree( irl ); irl = NULL;
if( iub != NULL ) mxFree( iub ); iub = NULL;
if( ilb != NULL ) mxFree( ilb ); ilb = NULL;
//Free Local Copies
if( qp_ru != NULL ) mxFree( qp_ru ); qp_ru = NULL;
if( qp_rl != NULL ) mxFree( qp_rl ); qp_rl = NULL;
if( qp_ub != NULL ) mxFree( qp_ub ); qp_ub = NULL;
if( qp_lb != NULL ) mxFree( qp_lb ); qp_lb = NULL;
//Free sparse memory
mxFree(iH_ir); mxFree(iH_jc); mxFree(Ht);
mxFree(iA_ir); mxFree(iA_jc); mxFree(At);
mxFree(iAeq_ir); mxFree(iAeq_jc); mxFree(Aeqt);
//Free up classes
if( qp27 != NULL) delete qp27; qp27 = NULL;
if( qp57 != NULL) delete qp57; qp57 = NULL;
if( qpPD != NULL) delete qpPD; qpPD = NULL;
if( prob != NULL) delete prob; prob = NULL;
if( vars != NULL) delete vars; vars = NULL;
if( resid != NULL) delete resid; resid = NULL;
if( sm != NULL) delete sm; sm = NULL;
if( sg != NULL) delete sg; sg = NULL;
}
catch(exception& e) //Unfortunately still crashes matlab...
{
char msgbuf[1024];
sprintf(msgbuf,"Caught OOQP Error: %s",e.what());
mexErrMsgTxt(msgbuf);
}
catch(...)
{
mexErrMsgTxt("Fatal OOQP Error");
}
}
int main( int argc, char *argv[] )
{
Huber * huber = new Huber;
HuberData * prob = 0;
int quiet = 0, print_soln = 0;
char * outfilename = 0;
int argsOk = 1;
{ // Scope of iarg
int iarg;
for( iarg = 1; iarg < argc && argv[iarg][0] == '-'; iarg++ ) {
// it is a option. Check against recognized options
if( 0 == strcmp( argv[iarg], "-quiet" ) ||
0 == strcmp( argv[iarg], "--quiet" ) ) {
quiet = 1;
} else if ( 0 == strcmp( argv[iarg], "-print_solution" ) ||
0 == strcmp( argv[iarg], "--print_solution" ) ) {
print_soln = 1;
} else {
cerr << argv[0] << ": "
<< argv[iarg] << " is not a recognized option.\n";
argsOk = 0;
}
}
if( iarg >= argc ) argsOk = 0; // Not enough arguments
if( argsOk ) { // the options were read successfully
if( 0 == strcmp( argv[iarg] , "random" ) ) {
if( iarg + 3 != argc ) { // wrong number of input args
argsOk = 0;
} else { // the right number of args for a random problem
int nobservations = atoi(argv[iarg+1]);
int npredictors = atoi(argv[iarg+2]);
if(nobservations <= 0 || npredictors <= 0) {
cerr << " Dimensions of random problem should be positive:"
<< " nobservations=" << nobservations
<< ", npredictors=" << npredictors << endl;
return 1;// bail out
}
if( nobservations < npredictors ) {
cerr << " The number of observations "
<< "must be at least as large as\n"
<< " the number of predictors."
<< " nobservations=" << nobservations
<< ", npredictors=" << npredictors << endl;
return 1; // bail out
}
prob = (HuberData *) huber->makeRandomData( nobservations,
npredictors, 1.0 );
} // end else the right number of args for a random problem
} else { // data is to be read from a file
if( iarg + 2 != argc ) { // wrong number of input args
argsOk = 0;
} else { // the right number of args
char * filename = argv[iarg];
double cutoff = atof( argv[iarg+1] );
int iErr;
prob = (HuberData *)
huber->makeDataFromText(filename, cutoff, iErr);
if(iErr != huberinputok) {
cerr << " Error reading input file " << filename
<< " : TERMINATE\n";
return 1;
}
{ // Get a name for the output file
int lenname = strlen( filename );
outfilename = new char[ lenname + 5 ];
strcpy( outfilename, filename );
strcat( outfilename, ".out" );
}
} // else the right number of args
} // end else data is to be read from a file
} // end if the options were read sucessfully
} // end scope of iarg
if( !argsOk ) {
cerr << "Usage:\n\n";
cerr << " " << argv[0] << " [ --quiet ] [ --print-solution ] "
<< "filename cutoff\n\nor\n\n";
cerr << " " << argv[0] << " [ --quiet ] [ --print-solution ] "
<< "random nobs npred\n\n";
cerr << "where \"random\" is a literal keyword.\n\n";
delete huber;
delete prob;
return 1;
}
// OK, solve this sucker.
GondzioSolver * s = new GondzioSolver( huber, prob );
HuberVars * vars = (HuberVars * ) huber->makeVariables( prob );
Residuals * resid = huber->makeResiduals( prob );
if( !quiet ) s->monitorSelf();
int status = s->solve(prob,vars, resid);
// print the interesting variables: beta
if( (!quiet && vars->npredictors < 20) ||
!outfilename || print_soln ) {
cout.precision(4);
vars->printBeta();
}
if( outfilename ) {
{
ofstream outfile( outfilename );
outfile.precision(16);
outfile << vars->npredictors << endl;
vars->beta->writeToStream( outfile );
}
delete [] outfilename;
}
delete vars;
delete resid;
delete s;
delete prob;
delete huber;
return status;
}
