00001
00021 #include "OSKnitroSolver.h"
00022 #include "OSCommonUtil.h"
00023
00024 using std::cout;
00025 using std::endl;
00026 using std::ostringstream;
00027 using namespace std;
00028
00029 #if defined(_WIN32)
00030 #include <windows.h>
00031 #else
00032 #include <dlfcn.h>
00033 #endif
00034
00035
00036
00037
00038
00039
00040 static NlpProblemDef * g_pTheNlpProblemDefInstance = NULL;
00041
00042
00043 static NlpProblemDef * g_pOptProblem = NULL;
00044
00045 static int wrapperEvalFC (const int evalRequestCode,
00046 const int n,
00047 const int m,
00048 const int nnzJ,
00049 const int nnzH,
00050 const double * const daX,
00051 const double * const daLambda,
00052 double * const dObj,
00053 double * const daC,
00054 double * const daG,
00055 double * const daJ,
00056 double * const daH,
00057 double * const daHV,
00058 void * userParams){
00059 if (g_pOptProblem == NULL)
00060 {
00061 cout << "*** Problem not defined <wrapperEvalFC>\n";
00062 return( -1 );
00063 }
00064 if (evalRequestCode != KTR_RC_EVALFC)
00065 {
00066 cout << "*** Bad request code " << evalRequestCode
00067 << " <wrapperEvalFC>\n";
00068 return( -1 );
00069 }
00070 return( g_pOptProblem->evalFC (daX, dObj, daC, userParams) );
00071 }
00072
00073
00074
00075
00076
00080 static int wrapperEvalGA (const int evalRequestCode,
00081 const int n,
00082 const int m,
00083 const int nnzJ,
00084 const int nnzH,
00085 const double * const daX,
00086 const double * const daLambda,
00087 double * const dObj,
00088 double * const daC,
00089 double * const daG,
00090 double * const daJ,
00091 double * const daH,
00092 double * const daHV,
00093 void * userParams){
00094 if (g_pOptProblem == NULL)
00095 {
00096 cout << "*** Problem not defined <wrapperEvalGA>\n";
00097 return( -1 );
00098 }
00099 if (evalRequestCode != KTR_RC_EVALGA)
00100 {
00101 cout << "*** Bad request code " << evalRequestCode
00102 << " <wrapperEvalGA>\n";
00103 return( -1 );
00104 }
00105 return( g_pOptProblem->evalGA (daX, daG, daJ, userParams) );
00106 }
00107
00108
00109
00110
00111
00115 static int wrapperEvalHorHV (const int evalRequestCode,
00116 const int n,
00117 const int m,
00118 const int nnzJ,
00119 const int nnzH,
00120 const double * const daX,
00121 const double * const daLambda,
00122 double * const dObj,
00123 double * const daC,
00124 double * const daG,
00125 double * const daJ,
00126 double * const daH,
00127 double * const daHV,
00128 void * userParams){
00129 if (g_pOptProblem == NULL)
00130 {
00131 cout << "*** Problem not defined <wrapperEvalHorHV>\n";
00132 return( -1 );
00133 }
00134 if (evalRequestCode == KTR_RC_EVALH)
00135 {
00136 if (g_pOptProblem->areDerivativesImplemented (nCAN_COMPUTE_H) == false)
00137 {
00138 cout << "*** This problem not evaluate H <wrapperEvalHorHV>\n";
00139 return( -1 );
00140 }
00141 return( g_pOptProblem->evalH (daX, daLambda, daH, userParams) );
00142 }
00143 else if (evalRequestCode == KTR_RC_EVALHV)
00144 {
00145 if (g_pOptProblem->areDerivativesImplemented (nCAN_COMPUTE_HV) == false)
00146 {
00147 cout << "*** This problem not evaluate H*v <wrapperEvalHorHV>\n";
00148 return( -1 );
00149 }
00150 return( g_pOptProblem->evalHV (daX, daLambda, daHV, userParams) );
00151 }
00152 else
00153 {
00154 cout << "*** Bad request code " << evalRequestCode
00155 << " <wrapperEvalHorHV>\n";
00156 return( -1 );
00157 }
00158 }
00159
00160
00161
00162
00163
00164
00165
00166 #ifdef __cplusplus
00167 extern "C"
00168 {
00169 #if defined(_WIN32)
00170 __declspec(dllexport) NlpProblemDef * getNlpProblemDef (void)
00171 #else
00172 NlpProblemDef * getNlpProblemDef (void)
00173 #endif
00174 {
00175 if (g_pTheNlpProblemDefInstance == NULL)
00176 g_pTheNlpProblemDefInstance = new KnitroProblem(NULL, NULL);
00177
00178 return( g_pTheNlpProblemDefInstance );
00179 }
00180 }
00181 #endif
00182
00183
00184 KnitroProblem::KnitroProblem(OSInstance *osinstance_, OSResult *osresult_ ) {
00185
00186 _daXInit = NULL;
00187 osinstance = osinstance_;
00188 osresult = osresult_;
00189 }
00190
00191
00192
00193 KnitroProblem::~KnitroProblem() {
00194 delete [] _daXInit;
00195 _daXInit = NULL;
00196 }
00197
00198
00199
00200
00201
00202
00203
00204 int KnitroProblem::getN (void){
00205 return( _nN );
00206 }
00207
00208
00209 int KnitroProblem::getM (void){
00210 return( _nM );
00211 }
00212
00213
00214 void KnitroProblem::getInitialX (double * const daX){
00215 if (_daXInit == NULL){
00216 cout << "*** Must call 'loadProblemIntoKnitro' before 'KnitroSolver::getInitialX'\n";
00217 exit( EXIT_FAILURE );
00218 }
00219
00220 for (int i = 0; i < _nN; i++){
00221 daX[i] = _daXInit[i];
00222 }
00223 return;
00224 }
00225
00226
00227
00228
00232 bool KnitroProblem::loadProblemIntoKnitro (KTR_context_ptr kc){
00233 int i;
00234 if(osinstance->getObjectiveNumber() <= 0) throw ErrorClass("Knitro NEEDS AN OBJECTIVE FUNCTION");
00235
00236 _nN = osinstance->getVariableNumber();
00237
00238 _nM = osinstance->getConstraintNumber();
00239 cout << "number variables !!!!!!!!!!!!!!!!!!!!!!!!!!!" << _nN << endl;
00240 cout << "number constraints !!!!!!!!!!!!!!!!!!!!!!!!!!!" << _nM << endl;
00241 try{
00242 osinstance->initForAlgDiff( );
00243 }
00244 catch(const ErrorClass& eclass){
00245 knitroErrorMsg = eclass.errormsg;
00246 throw;
00247 }
00248
00249
00250 double * mdVarLB = osinstance->getVariableLowerBounds();
00251 std::cout << "GET BOUNDS INFORMATION FOR KNITRO!!!!!!!!!!!!!!!" << std::endl;
00252
00253 double * mdVarUB = osinstance->getVariableUpperBounds();
00254
00255 _daXLo = new double[_nN];
00256 _daXUp = new double[_nN];
00257 for(i = 0; i < _nN; i++){
00258 if( mdVarLB[ i] == -OSDBL_MAX) _daXLo[i] = -KTR_INFBOUND;
00259 else _daXLo[i] = mdVarLB[ i];
00260 if( mdVarUB[ i] == OSDBL_MAX) _daXUp[i] = KTR_INFBOUND;
00261 else _daXUp[i] = mdVarUB[ i];
00262
00263
00264 }
00265
00266
00267 double * mdConLB = osinstance->getConstraintLowerBounds();
00268
00269 double * mdConUB = osinstance->getConstraintUpperBounds();
00270
00271 _naCType = new int[ _nM];
00272 _daCLo = new double[ _nM];
00273 _daCUp = new double[ _nM];
00274 _naCType[0] = KTR_CONTYPE_LINEAR;
00275 for(i = 0; i < _nM; i++){
00276 if( mdConLB[ i] == -OSDBL_MAX) _daCLo[i] = -KTR_INFBOUND;
00277 else _daCLo[i] = mdConLB[ i];
00278 if( mdConUB[ i] == OSDBL_MAX) _daCUp[i] = KTR_INFBOUND;
00279 else _daCUp[i] = mdConUB[ i];
00280
00281
00282 _naCType[i] = KTR_CONTYPE_GENERAL;
00283 }
00284
00285
00286 osinstance->bUseExpTreeForFunEval = true;
00287 std::cout << "Call sparse jacobian" << std::endl;
00288 SparseJacobianMatrix *sparseJacobian = NULL;
00289 try{
00290 sparseJacobian = osinstance->getJacobianSparsityPattern();
00291 }
00292 catch(const ErrorClass& eclass){
00293 knitroErrorMsg = eclass.errormsg;
00294 throw;
00295 }
00296 std::cout << "Done calling sparse jacobian" << std::endl;
00297 _nNnzJ = sparseJacobian->valueSize;
00298
00299 _naJacIndexVars = new int[_nNnzJ];
00300 _naJacIndexCons = new int[_nNnzJ];
00301 int k, idx;
00302 i = 0;
00303 for(idx = 0; idx < _nM; idx++){
00304 for(k = *(sparseJacobian->starts + idx); k < *(sparseJacobian->starts + idx + 1); k++){
00305 _naJacIndexCons[i] = idx;
00306 _naJacIndexVars[i] = *(sparseJacobian->indexes + k);
00307
00308
00309 i++;
00310 }
00311 }
00312
00313
00314
00315 if( (osinstance->getNumberOfNonlinearExpressions() == 0) && (osinstance->getNumberOfQuadraticTerms() == 0) ) {
00316 cout << "This is a linear program" << endl;
00317 _nNnzH = 0;
00318 }
00319 else{
00320 std::cout << "Get Lagrangain Hessian Sparsity Pattern " << std::endl;
00321 SparseHessianMatrix *sparseHessian = osinstance->getLagrangianHessianSparsityPattern();
00322 std::cout << "Done Getting Lagrangain Hessian Sparsity Pattern " << std::endl;
00323 _nNnzH = sparseHessian->hessDimension;
00324 _naHessRows = new int[_nNnzH];
00325 _naHessCols = new int[_nNnzH];
00326 for(i = 0; i < _nNnzH; i++){
00327 _naHessCols[i] = *(sparseHessian->hessColIdx + i);
00328 _naHessRows[i] = *(sparseHessian->hessRowIdx + i);
00329 cout << "ROW HESS IDX !!!!!!!!!!!!!!!!!!!!!!!!!!!" << _naHessRows[i] << endl;
00330 cout << "COL HESS IDX !!!!!!!!!!!!!!!!!!!!!!!!!!!" << _naHessCols[i] << endl;
00331 }
00332 }
00333
00334
00335
00336
00337
00338 double *mdXInit = osinstance->getVariableInitialValues();
00339 _daXInit = new double[_nN];
00340 if( mdXInit != NULL) {
00341 for(i = 0; i < _nN; i++){
00342 if( CommonUtil::ISOSNAN( mdXInit[ i]) == true){
00343 _daXInit[ i] = 1.7171;
00344 }
00345 else _daXInit[ i] = mdXInit[ i];
00346 }
00347 }
00348 else{
00349 for(i = 0; i < _nN; i++){
00350 _daXInit[ i] = 1.7171;
00351 }
00352 }
00353
00354
00355 double * daLambdaInit = new double[_nM + _nN];
00356 for (i = 0; i < _nM + _nN; i++)
00357 daLambdaInit[i] = 0.0;
00358
00359
00360 int iObjSense = KTR_OBJGOAL_MINIMIZE;
00361 if( osinstance->instanceData->objectives->obj[ 0]->maxOrMin.compare("max") == 0){
00362 iObjSense = KTR_OBJGOAL_MAXIMIZE;
00363 }
00364 int iObjType = KTR_OBJTYPE_GENERAL;
00365 i = KTR_init_problem (kc, _nN,
00366 iObjSense, iObjType,
00367 _daXLo, _daXUp,
00368 _nM, _naCType, _daCLo, _daCUp,
00369 _nNnzJ, _naJacIndexVars, _naJacIndexCons,
00370 _nNnzH, _naHessRows, _naHessCols,
00371 _daXInit, daLambdaInit);
00372
00373 delete [] _daXLo;
00374 delete [] _daXUp;
00375 delete [] _naCType;
00376 delete [] _daCLo;
00377 delete [] _daCUp;
00378 delete [] _naJacIndexVars;
00379 delete [] _naJacIndexCons;
00380 delete [] _naHessRows;
00381 delete [] _naHessCols;
00382 delete [] daLambdaInit;
00383
00384 if (i != 0)
00385 {
00386 cout << "*** KTR_init_problem() returned " << i << "\n";
00387 return( false );
00388 }
00389
00390 return( true );
00391 }
00392
00393
00394
00395
00396 bool KnitroProblem::areDerivativesImplemented(const DerivativesImplementedType nWhichDers){
00397 if (nWhichDers == nCAN_COMPUTE_GA)
00398 return( true );
00399 if (nWhichDers == nCAN_COMPUTE_H)
00400 return( true );
00401 if (nWhichDers == nCAN_COMPUTE_HV)
00402 return( false);
00403 return( false );
00404 }
00405
00406
00407
00408
00409
00410 int KnitroProblem::evalFC (const double * const daX,
00411 double * const dObj,
00412 double * const daC,
00413 void * userParams){
00414 try{
00415 *dObj = osinstance->calculateAllObjectiveFunctionValues((double*)daX, NULL, NULL, true, 0 )[0];
00416 }
00417 catch(const ErrorClass& eclass){
00418 knitroErrorMsg = eclass.errormsg;
00419 return (-1);
00420 }
00421 if( CommonUtil::ISOSNAN( *dObj )) return (-1);
00422
00423
00424
00425 try{
00426 double *conVals = osinstance->calculateAllConstraintFunctionValues((double*)daX, NULL, NULL, true, 0 );
00427 int i;
00428 for(i = 0; i < _nM; i++){
00429 if( CommonUtil::ISOSNAN( (double)conVals[ i] ) ) return (-1);
00430 daC[i] = conVals[ i] ;
00431 }
00432 }
00433 catch(const ErrorClass& eclass){
00434 knitroErrorMsg = eclass.errormsg;
00435 return (-1);
00436 }
00437
00438
00439 return( 0 );
00440 }
00441
00442
00443
00444
00445
00446 int KnitroProblem::evalGA (const double * const daX,
00447 double * const daG,
00448 double * const daJ,
00449 void * userParams){
00450 try{
00451 double *objGrad = osinstance->calculateAllObjectiveFunctionGradients((double*)daX, NULL, NULL, true, 1 )[0];
00452 int i;
00453 std::cout << "EVALUATING OBJ GRADIENT" << std::endl;
00454 for(i = 0; i < _nN; i++){
00455 if( CommonUtil::ISOSNAN( (double)objGrad[ i] ) ) return (-1);
00456 daG[i] = objGrad[ i] ;
00457 }
00458 }
00459 catch(const ErrorClass& eclass){
00460 knitroErrorMsg = eclass.errormsg;
00461 return (-1);
00462 }
00463
00464 SparseJacobianMatrix *sparseJacobian;
00465 std::cout << "EVALUATING JACOBIAN" << std::endl;
00466 try{
00467 sparseJacobian = osinstance->calculateAllConstraintFunctionGradients((double*)daX, NULL, NULL, true, 1);
00468 }
00469 catch(const ErrorClass& eclass){
00470 knitroErrorMsg = eclass.errormsg;
00471 return (-1);
00472 }
00473
00474 for(int i = 0; i < _nNnzJ; i++){
00475 daJ[ i] = sparseJacobian->values[i];
00476
00477 cout << "daJ[i]:!!!!!!!!!!!! " << daJ[ i] << endl;
00478
00479 }
00480
00481 return( 0 );
00482 }
00483
00484
00485
00486
00487
00488 int KnitroProblem::evalH (const double * const daX,
00489 const double * const daLambda,
00490 double * const daH,
00491 void * userParams){
00492 SparseHessianMatrix *sparseHessian;
00493 int i;
00494 double* objMultipliers = new double[1];
00495 objMultipliers[0] = 1;
00496 try{
00497 sparseHessian = osinstance->calculateLagrangianHessian((double*)daX, objMultipliers, (double*)daLambda , true, 2);
00498 }
00499 catch(const ErrorClass& eclass){
00500 knitroErrorMsg = eclass.errormsg;
00501 return (-1);
00502 }
00503 for(i = 0; i < _nNnzH; i++){
00504 daH[ i] = *(sparseHessian->hessValues + i);
00505 std::cout << "Hessian Value = " << daH[ i] << std::endl;
00506 }
00507 delete[] objMultipliers;
00508 return( 0 );
00509 }
00510
00511
00512
00513
00514
00515 int KnitroProblem::evalHV (const double * const daX,
00516 const double * const daLambda,
00517 double * const daHV,
00518 void * userParams){
00519
00520 return( 0 );
00521 }
00522
00523
00524
00525
00526 KnitroSolver::KnitroSolver() {
00527 osrlwriter = new OSrLWriter();
00528 osresult = new OSResult();
00529 knitroErrorMsg = "";
00530
00531 }
00532
00533
00534 void KnitroSolver::buildSolverInstance() throw (ErrorClass) {
00535 try{
00536
00537 }
00538 catch(const ErrorClass& eclass){
00539 std::cout << "THERE IS AN ERROR" << std::endl;
00540 osresult->setGeneralMessage( eclass.errormsg);
00541 osresult->setGeneralStatusType( "error");
00542 osrl = osrlwriter->writeOSrL( osresult);
00543 throw ErrorClass( osrl) ;
00544 }
00545 }
00546
00547
00548
00549
00550 void Knitro::setSolverOptions() throw (ErrorClass) {
00551 try{
00552
00553 }
00554 catch(const ErrorClass& eclass){
00555 std::cout << "THERE IS AN ERROR" << std::endl;
00556 osresult->setGeneralMessage( eclass.errormsg);
00557 osresult->setGeneralStatusType( "error");
00558 osrl = osrlwriter->writeOSrL( osresult);
00559 throw ErrorClass( osrl) ;
00560 }
00561 }
00562
00563 KnitroSolver::~KnitroSolver() {
00564 #ifdef DEBUG
00565 cout << "inside KnitroSolver destructor" << endl;
00566 #endif
00567 delete osresult;
00568 osresult = NULL;
00569 delete osrlwriter;
00570 osrlwriter = NULL;
00571
00572
00573 #ifdef DEBUG
00574 cout << "leaving KnitroSolver destructor" << endl;
00575 #endif
00576 }
00577
00578 void KnitroSolver::solve() throw (ErrorClass) {
00579 try{
00580 OSiLReader* osilreader = NULL;
00581
00582 if(osil.length() == 0 && osinstance == NULL) throw ErrorClass("there is no instance");
00583 clock_t start, finish;
00584 double duration;
00585 start = clock();
00586 bool newOSiLReader = false;
00587 if( osinstance == NULL){
00588 osilreader = new OSiLReader();
00589 osinstance = osilreader->readOSiL( osil);
00590 newOSiLReader = true;
00591 }
00592 OSiLWriter osilwriter;
00593
00594 if(osinstance->getVariableNumber() <= 0)throw ErrorClass("Knitro requires decision variables");
00595 finish = clock();
00596 duration = (double) (finish - start) / CLOCKS_PER_SEC;
00597 cout << "Parsing took (seconds): "<< duration << endl;
00598
00599
00600
00601
00602 NlpProblemDef *pOptProb = new KnitroProblem(osinstance, osresult);
00603 bool bWantToSolve;
00604
00605
00606 KTR_context *kc;
00607 kc = KTR_new();
00608 if (kc == NULL){
00609 cout << "*** KTR_new failed, maybe a license issue?\n";
00610 exit( EXIT_FAILURE );
00611 }
00612
00613
00614 KTR_load_param_file (kc, "knitro.opt");
00615
00616 if (pOptProb->loadProblemIntoKnitro ( kc) == false){
00617 cout << "*** loadProblemIntoKnitro failed\n";
00618 exit( EXIT_FAILURE );
00619 }
00620
00621
00622
00623
00624
00625 g_pOptProblem = pOptProb;
00626 if (KTR_set_func_callback (kc, wrapperEvalFC) != 0){
00627 cout << "*** KTR_set_func_callback failed\n";
00628 exit( EXIT_FAILURE );
00629 }
00630 if (pOptProb->areDerivativesImplemented (nCAN_COMPUTE_GA) == true){
00631 if (KTR_set_grad_callback (kc, wrapperEvalGA) != 0){
00632 cout << "*** KTR_set_grad_callback failed\n";
00633 exit( EXIT_FAILURE );
00634 }
00635 }
00636 if ((pOptProb->areDerivativesImplemented (nCAN_COMPUTE_H) == true)
00637 || (pOptProb->areDerivativesImplemented (nCAN_COMPUTE_HV) == true)){
00638 if (KTR_set_hess_callback (kc, wrapperEvalHorHV) != 0){
00639 cout << "*** KTR_set_hess_callback failed\n";
00640 exit( EXIT_FAILURE );
00641 }
00642 }
00643
00644
00645 double * daX = new double[pOptProb->getN()];
00646 double * daLambda = new double[pOptProb->getM() + pOptProb->getN()];
00647 double* mdObjValues = new double[1];
00648 bWantToSolve = true;
00649 if (bWantToSolve == true){
00650
00651 double dFinalObj;
00652 int nStatus = KTR_solve (kc, daX, daLambda, 0, &dFinalObj,
00653 NULL, NULL, NULL, NULL, NULL, NULL);
00654 std::cout << "dFinalObj = " << dFinalObj << std::endl;
00655 cout << "*** Final KNITRO status = " << nStatus << "\n";
00656 cout << "dax[0] = " << daX[0] << "\n";
00657
00658
00659 int solIdx = 0;
00660
00661 std::string message = "Knitro solver finishes to the end.";
00662 std::string solutionDescription = "";
00663
00664
00665 if(osresult->setServiceName( "Knitro solver service") != true)
00666 throw ErrorClass("OSResult error: setServiceName");
00667 if(osresult->setInstanceName( osinstance->getInstanceName()) != true)
00668 throw ErrorClass("OSResult error: setInstanceName");
00669
00670
00671
00672
00673
00674 if(osresult->setVariableNumber( osinstance->getVariableNumber()) != true)
00675 throw ErrorClass("OSResult error: setVariableNumer");
00676 if(osresult->setObjectiveNumber( 1) != true)
00677 throw ErrorClass("OSResult error: setObjectiveNumber");
00678 if(osresult->setConstraintNumber( osinstance->getConstraintNumber()) != true)
00679 throw ErrorClass("OSResult error: setConstraintNumber");
00680 if(osresult->setSolutionNumber( 1) != true)
00681 throw ErrorClass("OSResult error: setSolutionNumer");
00682
00683
00684 if(osresult->setGeneralMessage( message) != true)
00685 throw ErrorClass("OSResult error: setGeneralMessage");
00686 std::cout << "START CASES " << 0 << endl;
00687 switch( nStatus){
00688 case 0:
00689 std::cout << "WE ARE IN CASE " << 0 << endl;
00690 solutionDescription = "LOCALLY OPTIMAL SOLUTION FOUND[KNITRO STATUS 0]: Knitro found a locally optimal point which satisfies the stopping criterion.If the problem is convex (for example, a linear program), then this point corresponds to a globally optimal solution.";
00691 osresult->setSolutionStatus(solIdx, "locallyOptimal", solutionDescription);
00692 std::cout << "SET SOLUTION STATUS " << endl;
00693 osresult->setPrimalVariableValuesDense(solIdx, daX);
00694 std::cout << "SET PRIMAL VALUES " << endl;
00695 osresult->setDualVariableValuesDense(solIdx, daLambda);
00696 mdObjValues[0] = dFinalObj;
00697 osresult->setObjectiveValuesDense(solIdx, mdObjValues);
00698 std::cout << "SET OBJECTIVE VALUES " << endl;
00699 break;
00700 case -1:
00701 solutionDescription = "Iteration limit reached[KNITRO STATUS -1]: The iteration limit was reached before being able to satisfy the required stopping criteria.";
00702 osresult->setSolutionStatus(solIdx, "stoppedByLimit", solutionDescription);
00703 osresult->setPrimalVariableValuesDense(solIdx, daX);
00704 osresult->setDualVariableValuesDense(solIdx, daLambda);
00705 mdObjValues[0] = dFinalObj;
00706 osresult->setObjectiveValuesDense(solIdx, mdObjValues);
00707 break;
00708 case -2:
00709 solutionDescription = "Convergence to an infeasible point[KNITRO STATUS -2]: Problem may be locally infeasible.The algorithm has converged to an infeasible point from which it cannot further decrease the infeasibility measure. This happens when the problem is infeasible, but may also occur on occasion for feasible problems with nonlinear constraints or badly scaled problems. It is recommended to try various initial points. If this occurs for a variety of initial points, it is likely the problem is infeasible.";
00710 osresult->setSolutionStatus(solIdx, "infeasible", solutionDescription);
00711 break;
00712 case -3:
00713 solutionDescription = "Problem appears to be unbounded[KNITRO STATUS -3]: Iterate is feasible and objective magnitude > objrange. The objective function appears to be decreasing without bound, while satisfying the constraints.If the problem really is bounded, increase the size of the parameter objrange to avoid terminating with this message.";
00714 osresult->setSolutionStatus(solIdx, "unbounded", solutionDescription);
00715 break;
00716 case -4:
00717 solutionDescription = "Relative change in solution estimate < xtol[KNITRO STATUS -4]: The relative change in the solution estimate is less than that specified by the paramater xtol.To try to get more accuracy one may decrease xtol. If xtol is very small already, it is an indication that no more significant progress can be made. If the current point is feasible, it is possible it may be optimal, however the stopping tests cannot be satisfied (perhaps because of degeneracy, ill-conditioning or bad scaling).";
00718 osresult->setSolutionStatus(solIdx, "stoppedByLimit", solutionDescription);
00719 osresult->setPrimalVariableValuesDense(solIdx, daX);
00720 osresult->setDualVariableValuesDense(solIdx, daLambda);
00721 mdObjValues[0] = dFinalObj;
00722 osresult->setObjectiveValuesDense(solIdx, mdObjValues);
00723 break;
00724 case -5:
00725 solutionDescription = "Current solution estimate cannot be improved. Point appears to be optimal, but desired accuracy could not be achieved.[KNITRO STATUS -5]: No more progress can be made, but the stopping tests are close to being satisfied (within a factor of 100) and so the current approximate solution is believed to be optimal.";
00726 osresult->setSolutionStatus(solIdx, "locallyOptimal", solutionDescription);
00727 osresult->setPrimalVariableValuesDense(solIdx, daX);
00728 osresult->setDualVariableValuesDense(solIdx, daLambda);
00729 mdObjValues[0] = dFinalObj;
00730 osresult->setObjectiveValuesDense(solIdx, mdObjValues);
00731 break;
00732 case -6:
00733 solutionDescription = "Time limit reached[KNITRO STATUS -6]: The time limit was reached before being able to satisfy the required stopping criteria.";
00734 osresult->setSolutionStatus(solIdx, "stoppedByLimit", solutionDescription);
00735 osresult->setPrimalVariableValuesDense(solIdx, daX);
00736 osresult->setDualVariableValuesDense(solIdx, daLambda);
00737 mdObjValues[0] = dFinalObj;
00738 osresult->setObjectiveValuesDense(solIdx, mdObjValues);
00739 break;
00740 case -50:
00741 case -51:
00742 case -52:
00743 case -53:
00744 case -54:
00745 case -55:
00746 case -56:
00747 case -57:
00748 case -58:
00749 case -59:
00750 case -60:
00751 solutionDescription = "Input Error[KNITRO STATUS -50 to -60]: Termination values in this range imply some input error. If outlev>0 details of this error will be printed to standard output or the file knitro.log depending on the value of outmode.";
00752 osresult->setSolutionStatus(solIdx, "error", solutionDescription);
00753 break;
00754 case -90:
00755 solutionDescription = "Callback function error[KNITRO STATUS -90]: This termination value indicates that an error (i.e., negative return value) occurred in a user provided callback routine.";
00756 osresult->setSolutionStatus(solIdx, "error", solutionDescription);
00757 break;
00758 case -97:
00759 solutionDescription = "LP solver error[KNITRO STATUS -97]: This termination value indicates that an unrecoverable error occurred in the LP solver used in the active-set algorithm preventing the optimization from continuing.";
00760 osresult->setSolutionStatus(solIdx, "error", solutionDescription);
00761 break;
00762 case -98:
00763 solutionDescription = "Evaluation error[KNITRO STATUS -98]: This termination value indicates that an evaluation error occurred (e.g., divide by 0, taking the square root of a negative number), preventing the optimization from continuing.";
00764 osresult->setSolutionStatus(solIdx, "error", solutionDescription);
00765 break;
00766 case -99:
00767 solutionDescription = "Not enough memory available to solve problem[KNITRO STATUS -99]: This termination value indicates that there was not enough memory available to solve the problem.";
00768 osresult->setSolutionStatus(solIdx, "error", solutionDescription);
00769 break;
00770 default:
00771 solutionDescription = "OTHER[KNITRO]: other unknown solution status from Knitro solver";
00772 osresult->setSolutionStatus(solIdx, "other", solutionDescription);
00773 }
00774
00775 osresult->setGeneralStatusType("normal");
00776 osrl = osrlwriter->writeOSrL( osresult);
00777 }
00778 else{
00779
00780 pOptProb->getInitialX (daX);
00781 KTR_check_first_ders (kc, daX, 2, 1.0e-14, 1.0e-14,
00782 0, 0.0, NULL, NULL, NULL, NULL);
00783 }
00784
00785 if(newOSiLReader == true){
00786 delete osilreader;
00787 osilreader = NULL;
00788 }
00789 delete [] daX;
00790 delete [] daLambda;
00791 delete [] mdObjValues;
00792
00793 KTR_free( &kc);
00794 delete pOptProb;
00795
00796
00797
00798 }
00799 catch(const ErrorClass& eclass){
00800 osresult->setGeneralMessage( eclass.errormsg);
00801 osresult->setGeneralStatusType( "error");
00802 osrl = osrlwriter->writeOSrL( osresult);
00803
00804 }
00805 }
00806
00807
00808 void KnitroSolver::dataEchoCheck(){
00809
00810 int i;
00811
00812
00813 cout << "This is problem: " << osinstance->getInstanceName() << endl;
00814 cout << "The problem source is: " << osinstance->getInstanceSource() << endl;
00815 cout << "The problem description is: " << osinstance->getInstanceDescription() << endl;
00816 cout << "number of variables = " << osinstance->getVariableNumber() << endl;
00817 cout << "number of Rows = " << osinstance->getConstraintNumber() << endl;
00818
00819
00820 if(osinstance->getVariableNumber() > 0){
00821 for(i = 0; i < osinstance->getVariableNumber(); i++){
00822 if(osinstance->getVariableNames() != NULL) cout << "variable Names " << osinstance->getVariableNames()[ i] << endl;
00823 if(osinstance->getVariableTypes() != NULL) cout << "variable Types " << osinstance->getVariableTypes()[ i] << endl;
00824 if(osinstance->getVariableLowerBounds() != NULL) cout << "variable Lower Bounds " << osinstance->getVariableLowerBounds()[ i] << endl;
00825 if(osinstance->getVariableUpperBounds() != NULL) cout << "variable Upper Bounds " << osinstance->getVariableUpperBounds()[i] << endl;
00826 }
00827 }
00828
00829
00830 if(osinstance->getVariableNumber() > 0 || osinstance->instanceData->objectives->obj != NULL || osinstance->instanceData->objectives->numberOfObjectives > 0){
00831 if( osinstance->getObjectiveMaxOrMins()[0] == "min") cout << "problem is a minimization" << endl;
00832 else cout << "problem is a maximization" << endl;
00833 for(i = 0; i < osinstance->getVariableNumber(); i++){
00834 cout << "OBJ COEFFICIENT = " << osinstance->getDenseObjectiveCoefficients()[0][i] << endl;
00835 }
00836 }
00837
00838 if(osinstance->getConstraintNumber() > 0){
00839 for(i = 0; i < osinstance->getConstraintNumber(); i++){
00840 if(osinstance->getConstraintNames() != NULL) cout << "row name = " << osinstance->getConstraintNames()[i] << endl;
00841 if(osinstance->getConstraintLowerBounds() != NULL) cout << "row lower bound = " << osinstance->getConstraintLowerBounds()[i] << endl;
00842 if(osinstance->getConstraintUpperBounds() != NULL) cout << "row upper bound = " << osinstance->getConstraintUpperBounds()[i] << endl;
00843 }
00844 }
00845
00846
00847 cout << endl;
00848 cout << "number of nonzeros = " << osinstance->getLinearConstraintCoefficientNumber() << endl;
00849 for(i = 0; i <= osinstance->getVariableNumber(); i++){
00850 cout << "Start Value = " << osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[ i] << endl;
00851 }
00852 cout << endl;
00853 for(i = 0; i < osinstance->getLinearConstraintCoefficientNumber(); i++){
00854 cout << "Index Value = " << osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes[i] << endl;
00855 cout << "Nonzero Value = " << osinstance->getLinearConstraintCoefficientsInColumnMajor()->values[i] << endl;
00856 }
00857
00858
00859 cout << "number of qterms = " << osinstance->getNumberOfQuadraticTerms() << endl;
00860 for(int i = 0; i < osinstance->getNumberOfQuadraticTerms(); i++){
00861 cout << "Row Index = " << osinstance->getQuadraticTerms()->rowIndexes[i] << endl;
00862 cout << "Var Index 1 = " << osinstance->getQuadraticTerms()->varOneIndexes[ i] << endl;
00863 cout << "Var Index 2 = " << osinstance->getQuadraticTerms()->varTwoIndexes[ i] << endl;
00864 cout << "Coefficient = " << osinstance->getQuadraticTerms()->coefficients[ i] << endl;
00865 }
00866 }
00867
00868
00869 NlpProblemDef::~NlpProblemDef (void)
00870 {
00871
00872
00873 }
00874
00875
00876
00877