00001
00002
00003
00004 #if defined(_MSC_VER)
00005
00006 # pragma warning(disable:4786)
00007 #endif
00008
00009 #include <cassert>
00010
00011
00012
00013
00014 #include "OsiClpSolverInterface.hpp"
00015 #include "OsiCuts.hpp"
00016 #include "OsiRowCut.hpp"
00017 #include "OsiColCut.hpp"
00018 #include "CoinMessage.hpp"
00019 #include "ClpMessage.hpp"
00020 #include "ClpFactorization.hpp"
00021
00022
00023
00024 #ifdef NDEBUG
00025 #undef NDEBUG
00026 #endif
00027 class OsiClpMessageTest :
00028 public CoinMessageHandler {
00029
00030 public:
00031 virtual int print() ;
00032 OsiClpMessageTest();
00033 };
00034
00035 OsiClpMessageTest::OsiClpMessageTest() : CoinMessageHandler()
00036 {
00037 }
00038 int
00039 OsiClpMessageTest::print()
00040 {
00041 if (currentMessage().externalNumber()==0&¤tSource()=="Clp")
00042 std::cout<<"This is not actually an advertisement by Dash Associates - just my feeble attempt to test message handling and language - JJHF"<<std::endl;
00043 else if (currentMessage().externalNumber()==5&¤tSource()=="Osi")
00044 std::cout<<"End of search trapped"<<std::endl;
00045 return CoinMessageHandler::print();
00046 }
00047
00048
00049
00050 void
00051 OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir)
00052 {
00053
00054
00055 {
00056 OsiClpSolverInterface m;
00057 assert( m.rowsense_==NULL );
00058 assert( m.rhs_==NULL );
00059 assert( m.rowrange_==NULL );
00060 assert( m.matrixByRow_==NULL );
00061 assert( m.ws_==NULL);
00062 assert( m.itlimOrig_==9999999);
00063 assert( m.lastAlgorithm_==0);
00064 assert( m.integerInformation_==NULL);
00065 }
00066
00067
00068 {
00069 CoinRelFltEq eq;
00070 OsiClpSolverInterface m;
00071 std::string fn = mpsDir+"exmip1";
00072 m.readMps(fn.c_str(),"mps");
00073
00074 {
00075 OsiClpSolverInterface im;
00076
00077 assert( im.getNumCols() == 0 );
00078
00079 assert( im.getModelPtr()!=NULL );
00080
00081 im.reset();
00082 assert( im.rowsense_==NULL );
00083 assert( im.rhs_==NULL );
00084 assert( im.rowrange_==NULL );
00085 assert( im.matrixByRow_==NULL );
00086 assert( im.ws_==NULL);
00087 assert( im.itlimOrig_==9999999);
00088 assert( im.lastAlgorithm_==0);
00089 assert( im.integerInformation_==NULL);
00090 }
00091
00092
00093 {
00094 OsiClpSolverInterface lhs;
00095 {
00096 OsiClpSolverInterface im(m);
00097
00098 OsiClpSolverInterface imC1(im);
00099 assert( imC1.getModelPtr()!=im.getModelPtr() );
00100 assert( imC1.getNumCols() == im.getNumCols() );
00101 assert( imC1.getNumRows() == im.getNumRows() );
00102
00103 OsiClpSolverInterface imC2(im);
00104 assert( imC2.getModelPtr()!=im.getModelPtr() );
00105 assert( imC2.getNumCols() == im.getNumCols() );
00106 assert( imC2.getNumRows() == im.getNumRows() );
00107
00108 assert( imC2.getModelPtr()!=imC1.getModelPtr() );
00109
00110 lhs=imC2;
00111 }
00112
00113
00114 assert( lhs.getModelPtr() != m.getModelPtr() );
00115 assert( lhs.getNumCols() == m.getNumCols() );
00116 assert( lhs.getNumRows() == m.getNumRows() );
00117 }
00118
00119 {
00120 OsiClpSolverInterface oslSi(m);
00121 OsiSolverInterface * siPtr = &oslSi;
00122 OsiSolverInterface * siClone = siPtr->clone();
00123 OsiClpSolverInterface * oslClone = dynamic_cast<OsiClpSolverInterface*>(siClone);
00124 assert( oslClone != NULL );
00125 assert( oslClone->getModelPtr() != oslSi.getModelPtr() );
00126 assert( oslClone->getNumRows() == oslSi.getNumRows() );
00127 assert( oslClone->getNumCols() == m.getNumCols() );
00128
00129 delete siClone;
00130 }
00131
00132
00133 {
00134 OsiClpSolverInterface si;
00135 assert( eq(si.getInfinity(),OsiClpInfinity));
00136 }
00137
00138
00139 {
00140 OsiClpSolverInterface m1(m);
00141 int i;
00142
00143 double * cs = new double[m1.getNumCols()];
00144 for ( i = 0; i < m1.getNumCols(); i++ )
00145 cs[i] = i + .5;
00146 m1.setColSolution(cs);
00147 for ( i = 0; i < m1.getNumCols(); i++ )
00148 assert(m1.getColSolution()[i] == i + .5);
00149
00150 double * rs = new double[m1.getNumRows()];
00151 for ( i = 0; i < m1.getNumRows(); i++ )
00152 rs[i] = i - .5;
00153 m1.setRowPrice(rs);
00154 for ( i = 0; i < m1.getNumRows(); i++ )
00155 assert(m1.getRowPrice()[i] == i - .5);
00156
00157 delete [] cs;
00158 delete [] rs;
00159 }
00160
00161
00162
00163 {
00164 OsiClpSolverInterface fim;
00165 std::string fn = mpsDir+"exmip1";
00166 fim.readMps(fn.c_str(),"mps");
00167
00168 assert( fim.isContinuous(0) );
00169 assert( fim.isContinuous(1) );
00170 assert( !fim.isContinuous(2) );
00171 assert( !fim.isContinuous(3) );
00172 assert( fim.isContinuous(4) );
00173
00174 assert( !fim.isInteger(0) );
00175 assert( !fim.isInteger(1) );
00176 assert( fim.isInteger(2) );
00177 assert( fim.isInteger(3) );
00178 assert( !fim.isInteger(4) );
00179
00180 assert( !fim.isBinary(0) );
00181 assert( !fim.isBinary(1) );
00182 assert( fim.isBinary(2) );
00183 assert( fim.isBinary(3) );
00184 assert( !fim.isBinary(4) );
00185
00186 assert( !fim.isIntegerNonBinary(0) );
00187 assert( !fim.isIntegerNonBinary(1) );
00188 assert( !fim.isIntegerNonBinary(2) );
00189 assert( !fim.isIntegerNonBinary(3) );
00190 assert( !fim.isIntegerNonBinary(4) );
00191
00192
00193 {
00194 double sol[]={2.9,3.0};
00195 memcpy(fim.modelPtr_->primalColumnSolution()+2,sol,2*sizeof(double));
00196 OsiVectorInt fi = fim.getFractionalIndices(1e-5);
00197 assert( fi.size() == 1 );
00198 assert( fi[0]==2 );
00199
00200
00201 sol[0]=5 + .00001/2.;
00202 sol[1]=8 - .00001/2.;
00203 memcpy(fim.modelPtr_->primalColumnSolution()+2,sol,2*sizeof(double));
00204 fi = fim.getFractionalIndices(1e-5);
00205 assert( fi.size() == 0 );
00206
00207
00208 sol[0]=5 + .00001*2.;
00209 sol[1]=8 - .00001*2.;
00210 memcpy(fim.modelPtr_->primalColumnSolution()+2,sol,2*sizeof(double));
00211 fi = fim.getFractionalIndices(1e-5);
00212 assert( fi.size() == 2 );
00213 assert( fi[0]==2 );
00214 assert( fi[1]==3 );
00215 }
00216
00217
00218
00219
00220 double ub[]={5.0,6.0};
00221 memcpy(fim.modelPtr_->columnUpper()+2,ub,2*sizeof(double));
00222 assert( !fim.isBinary(0) );
00223 assert( !fim.isBinary(1) );
00224 assert( !fim.isBinary(2) );
00225 assert( !fim.isBinary(3) );
00226 assert( !fim.isBinary(4) );
00227
00228 assert( !fim.isIntegerNonBinary(0) );
00229 assert( !fim.isIntegerNonBinary(1) );
00230 assert( fim.isIntegerNonBinary(2) );
00231 assert( fim.isIntegerNonBinary(3) );
00232 assert( !fim.isIntegerNonBinary(4) );
00233 }
00234
00235
00236 {
00237 OsiClpSolverInterface im(m);
00238 OsiCuts cuts;
00239
00240
00241 {
00242
00243 int nr=im.getNumRows();
00244 int nc=im.getNumCols();
00245 assert( nr == 5 );
00246 assert( nc == 8 );
00247
00248
00249 int c;
00250 {
00251 int *inx = new int[nc];
00252 for (c=0;c<nc;c++) inx[c]=c;
00253 double *el = new double[nc];
00254 for (c=0;c<nc;c++) el[c]=((double)c)*((double)c);
00255
00256 OsiRowCut rc;
00257 rc.setRow(nc,inx,el);
00258 rc.setLb(-100.);
00259 rc.setUb(100.);
00260 rc.setEffectiveness(22);
00261
00262 cuts.insert(rc);
00263 delete[]el;
00264 delete[]inx;
00265 }
00266
00267
00268 {
00269 const double * oslColLB = im.getColLower();
00270 const double * oslColUB = im.getColUpper();
00271 int *inx = new int[nc];
00272 for (c=0;c<nc;c++) inx[c]=c;
00273 double *lb = new double[nc];
00274 double *ub = new double[nc];
00275 for (c=0;c<nc;c++) lb[c]=oslColLB[c]+0.001;
00276 for (c=0;c<nc;c++) ub[c]=oslColUB[c]-0.001;
00277
00278 OsiColCut cc;
00279 cc.setLbs(nc,inx,lb);
00280 cc.setUbs(nc,inx,ub);
00281
00282 cuts.insert(cc);
00283 delete [] ub;
00284 delete [] lb;
00285 delete [] inx;
00286 }
00287
00288 {
00289
00290 OsiRowCut * rcP= new OsiRowCut;
00291 rcP->setEffectiveness(-1.);
00292 cuts.insert(rcP);
00293 assert(rcP==NULL);
00294
00295 OsiColCut * ccP= new OsiColCut;
00296 ccP->setEffectiveness(-12.);
00297 cuts.insert(ccP);
00298 assert(ccP==NULL);
00299 }
00300 {
00301
00302 OsiRowCut rc;
00303 const int ne=1;
00304 int inx[ne]={-10};
00305 double el[ne]={2.5};
00306 rc.setRow(ne,inx,el);
00307 rc.setLb(3.);
00308 rc.setUb(4.);
00309 assert(!rc.consistent());
00310 cuts.insert(rc);
00311 }
00312 {
00313
00314 OsiColCut cc;
00315 const int ne=1;
00316 int inx[ne]={-10};
00317 double el[ne]={2.5};
00318 cc.setUbs(ne,inx,el);
00319 assert(!cc.consistent());
00320 cuts.insert(cc);
00321 }
00322 {
00323
00324 OsiRowCut rc;
00325 const int ne=1;
00326 int inx[ne]={10};
00327 double el[ne]={2.5};
00328 rc.setRow(ne,inx,el);
00329 assert(rc.consistent());
00330 assert(!rc.consistent(im));
00331 cuts.insert(rc);
00332 }
00333 {
00334
00335 OsiColCut cc;
00336 const int ne=1;
00337 int inx[ne]={30};
00338 double el[ne]={2.0};
00339 cc.setLbs(ne,inx,el);
00340 assert(cc.consistent());
00341 assert(!cc.consistent(im));
00342 cuts.insert(cc);
00343 }
00344 {
00345
00346 OsiColCut cc;
00347 const int ne=1;
00348 int inx[ne]={0};
00349 double el[ne]={2.0};
00350 cc.setUbs(ne,inx,el);
00351 cc.setEffectiveness(1000.);
00352 assert(cc.consistent());
00353 assert(cc.consistent(im));
00354 assert(cc.infeasible(im));
00355 cuts.insert(cc);
00356 }
00357 }
00358 assert(cuts.sizeRowCuts()==4);
00359 assert(cuts.sizeColCuts()==5);
00360
00361 OsiSolverInterface::ApplyCutsReturnCode rc = im.applyCuts(cuts);
00362 assert( rc.getNumIneffective() == 2 );
00363 assert( rc.getNumApplied() == 2 );
00364 assert( rc.getNumInfeasible() == 1 );
00365 assert( rc.getNumInconsistentWrtIntegerModel() == 2 );
00366 assert( rc.getNumInconsistent() == 2 );
00367 assert( cuts.sizeCuts() == rc.getNumIneffective() +
00368 rc.getNumApplied() +
00369 rc.getNumInfeasible() +
00370 rc.getNumInconsistentWrtIntegerModel() +
00371 rc.getNumInconsistent() );
00372 }
00373
00374 {
00375 OsiClpSolverInterface oslSi(m);
00376 int nc = oslSi.getNumCols();
00377 int nr = oslSi.getNumRows();
00378 const double * cl = oslSi.getColLower();
00379 const double * cu = oslSi.getColUpper();
00380 const double * rl = oslSi.getRowLower();
00381 const double * ru = oslSi.getRowUpper();
00382 assert( nc == 8 );
00383 assert( nr == 5 );
00384 assert( eq(cl[0],2.5) );
00385 assert( eq(cl[1],0.0) );
00386 assert( eq(cu[1],4.1) );
00387 assert( eq(cu[2],1.0) );
00388 assert( eq(rl[0],2.5) );
00389 assert( eq(rl[4],3.0) );
00390 assert( eq(ru[1],2.1) );
00391 assert( eq(ru[4],15.0) );
00392
00393 const double * cs = oslSi.getColSolution();
00394 assert( eq(cs[0],2.5) );
00395 assert( eq(cs[7],0.0) );
00396
00397 assert( !eq(cl[3],1.2345) );
00398 oslSi.setColLower( 3, 1.2345 );
00399 assert( eq(oslSi.getColLower()[3],1.2345) );
00400
00401 assert( !eq(cu[4],10.2345) );
00402 oslSi.setColUpper( 4, 10.2345 );
00403 assert( eq(oslSi.getColUpper()[4],10.2345) );
00404
00405 double objValue = oslSi.getObjValue();
00406 assert( eq(objValue,3.5) );
00407
00408 assert( eq( oslSi.getObjCoefficients()[0], 1.0) );
00409 assert( eq( oslSi.getObjCoefficients()[1], 0.0) );
00410 assert( eq( oslSi.getObjCoefficients()[2], 0.0) );
00411 assert( eq( oslSi.getObjCoefficients()[3], 0.0) );
00412 assert( eq( oslSi.getObjCoefficients()[4], 2.0) );
00413 assert( eq( oslSi.getObjCoefficients()[5], 0.0) );
00414 assert( eq( oslSi.getObjCoefficients()[6], 0.0) );
00415 assert( eq( oslSi.getObjCoefficients()[7], -1.0) );
00416 }
00417
00418
00419 {
00420 const OsiClpSolverInterface si(m);
00421 const CoinPackedMatrix * smP = si.getMatrixByRow();
00422
00423
00424
00425 CoinRelFltEq eq;
00426 const double * ev = smP->getElements();
00427 assert( eq(ev[0], 3.0) );
00428 assert( eq(ev[1], 1.0) );
00429 assert( eq(ev[2], -2.0) );
00430 assert( eq(ev[3], -1.0) );
00431 assert( eq(ev[4], -1.0) );
00432 assert( eq(ev[5], 2.0) );
00433 assert( eq(ev[6], 1.1) );
00434 assert( eq(ev[7], 1.0) );
00435 assert( eq(ev[8], 1.0) );
00436 assert( eq(ev[9], 2.8) );
00437 assert( eq(ev[10], -1.2) );
00438 assert( eq(ev[11], 5.6) );
00439 assert( eq(ev[12], 1.0) );
00440 assert( eq(ev[13], 1.9) );
00441
00442 const int * mi = smP->getVectorStarts();
00443 assert( mi[0]==0 );
00444 assert( mi[1]==5 );
00445 assert( mi[2]==7 );
00446 assert( mi[3]==9 );
00447 assert( mi[4]==11 );
00448 assert( mi[5]==14 );
00449
00450 const int * ei = smP->getIndices();
00451 assert( ei[0] == 0 );
00452 assert( ei[1] == 1 );
00453 assert( ei[2] == 3 );
00454 assert( ei[3] == 4 );
00455 assert( ei[4] == 7 );
00456 assert( ei[5] == 1 );
00457 assert( ei[6] == 2 );
00458 assert( ei[7] == 2 );
00459 assert( ei[8] == 5 );
00460 assert( ei[9] == 3 );
00461 assert( ei[10] == 6 );
00462 assert( ei[11] == 0 );
00463 assert( ei[12] == 4 );
00464 assert( ei[13] == 7 );
00465
00466 assert( smP->getMajorDim() == 5 );
00467 assert( smP->getNumElements() == 14 );
00468
00469 }
00470
00471 {
00472 OsiClpSolverInterface fim;
00473 std::string fn = mpsDir+"exmip1";
00474 fim.readMps(fn.c_str(),"mps");
00475
00476 fim.initialSolve();
00477 OsiRowCut cuts[3];
00478
00479
00480
00481 int c;
00482 int nc = fim.getNumCols();
00483 int *inx = new int[nc];
00484 for (c=0;c<nc;c++) inx[c]=c;
00485 double *el = new double[nc];
00486 for (c=0;c<nc;c++) el[c]=1.0e-50+((double)c)*((double)c);
00487
00488 cuts[0].setRow(nc,inx,el);
00489 cuts[0].setLb(-100.);
00490 cuts[0].setUb(500.);
00491 cuts[0].setEffectiveness(22);
00492 el[4]=0.0;
00493
00494 for (c=2;c<4;c++) {
00495 el[0]=1.0;
00496 inx[0]=c;
00497 cuts[c-1].setRow(1,inx,el);
00498 cuts[c-1].setLb(1.);
00499 cuts[c-1].setUb(100.);
00500 cuts[c-1].setEffectiveness(c);
00501 }
00502 fim.writeMps("x1.mps");
00503 fim.applyRowCuts(3,cuts);
00504 fim.writeMps("x2.mps");
00505
00506 fim.resolve();
00507 fim.writeMps("x3.mps");
00508
00509 const double * cs = fim.getColSolution();
00510 CoinRelFltEq eq;
00511 assert( eq(cs[2], 1.0) );
00512 assert( eq(cs[3], 1.0) );
00513
00514 el[0]=1.0/el[4];
00515 inx[0]=0;
00516 cuts[0].setRow(nc,inx,el);
00517 cuts[0].setLb(-100.);
00518 cuts[0].setUb(500.);
00519 cuts[0].setEffectiveness(22);
00520 fim.applyRowCut(cuts[0]);
00521
00522 fim.resolve();
00523 assert (fim.isAbandoned());
00524 delete[]el;
00525 delete[]inx;
00526 }
00527
00528 {
00529
00530 const OsiClpSolverInterface si(m);
00531 const CoinPackedMatrix * smP = si.getMatrixByCol();
00532
00533
00534
00535 CoinRelFltEq eq;
00536 const double * ev = smP->getElements();
00537 assert( eq(ev[0], 3.0) );
00538 assert( eq(ev[1], 5.6) );
00539 assert( eq(ev[2], 1.0) );
00540 assert( eq(ev[3], 2.0) );
00541 assert( eq(ev[4], 1.1) );
00542 assert( eq(ev[5], 1.0) );
00543 assert( eq(ev[6], -2.0) );
00544 assert( eq(ev[7], 2.8) );
00545 assert( eq(ev[8], -1.0) );
00546 assert( eq(ev[9], 1.0) );
00547 assert( eq(ev[10], 1.0) );
00548 assert( eq(ev[11], -1.2) );
00549 assert( eq(ev[12], -1.0) );
00550 assert( eq(ev[13], 1.9) );
00551
00552 const int * mi = smP->getVectorStarts();
00553 assert( mi[0]==0 );
00554 assert( mi[1]==2 );
00555 assert( mi[2]==4 );
00556 assert( mi[3]==6 );
00557 assert( mi[4]==8 );
00558 assert( mi[5]==10 );
00559 assert( mi[6]==11 );
00560 assert( mi[7]==12 );
00561 assert( mi[8]==14 );
00562
00563 const int * ei = smP->getIndices();
00564 assert( ei[0] == 0 );
00565 assert( ei[1] == 4 );
00566 assert( ei[2] == 0 );
00567 assert( ei[3] == 1 );
00568 assert( ei[4] == 1 );
00569 assert( ei[5] == 2 );
00570 assert( ei[6] == 0 );
00571 assert( ei[7] == 3 );
00572 assert( ei[8] == 0 );
00573 assert( ei[9] == 4 );
00574 assert( ei[10] == 2 );
00575 assert( ei[11] == 3 );
00576 assert( ei[12] == 0 );
00577 assert( ei[13] == 4 );
00578
00579 assert( smP->getMajorDim() == 8 );
00580 assert( smP->getNumElements() == 14 );
00581
00582 assert( smP->getSizeVectorStarts()==9 );
00583 assert( smP->getMinorDim() == 5 );
00584
00585 }
00586
00587
00588 {
00589 OsiClpSolverInterface lhs;
00590 {
00591 assert( m.rowrange_==NULL );
00592 assert( m.rowsense_==NULL );
00593 assert( m.rhs_==NULL );
00594 assert( m.matrixByRow_==NULL );
00595
00596 OsiClpSolverInterface siC1(m);
00597 assert( siC1.rowrange_==NULL );
00598 assert( siC1.rowsense_==NULL );
00599 assert( siC1.rhs_==NULL );
00600 assert( siC1.matrixByRow_==NULL );
00601
00602 const char * siC1rs = siC1.getRowSense();
00603 assert( siC1rs[0]=='G' );
00604 assert( siC1rs[1]=='L' );
00605 assert( siC1rs[2]=='E' );
00606 assert( siC1rs[3]=='R' );
00607 assert( siC1rs[4]=='R' );
00608
00609 const double * siC1rhs = siC1.getRightHandSide();
00610 assert( eq(siC1rhs[0],2.5) );
00611 assert( eq(siC1rhs[1],2.1) );
00612 assert( eq(siC1rhs[2],4.0) );
00613 assert( eq(siC1rhs[3],5.0) );
00614 assert( eq(siC1rhs[4],15.) );
00615
00616 const double * siC1rr = siC1.getRowRange();
00617 assert( eq(siC1rr[0],0.0) );
00618 assert( eq(siC1rr[1],0.0) );
00619 assert( eq(siC1rr[2],0.0) );
00620 assert( eq(siC1rr[3],5.0-1.8) );
00621 assert( eq(siC1rr[4],15.0-3.0) );
00622
00623 const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
00624 assert( siC1mbr != NULL );
00625
00626 const double * ev = siC1mbr->getElements();
00627 assert( eq(ev[0], 3.0) );
00628 assert( eq(ev[1], 1.0) );
00629 assert( eq(ev[2], -2.0) );
00630 assert( eq(ev[3], -1.0) );
00631 assert( eq(ev[4], -1.0) );
00632 assert( eq(ev[5], 2.0) );
00633 assert( eq(ev[6], 1.1) );
00634 assert( eq(ev[7], 1.0) );
00635 assert( eq(ev[8], 1.0) );
00636 assert( eq(ev[9], 2.8) );
00637 assert( eq(ev[10], -1.2) );
00638 assert( eq(ev[11], 5.6) );
00639 assert( eq(ev[12], 1.0) );
00640 assert( eq(ev[13], 1.9) );
00641
00642 const int * mi = siC1mbr->getVectorStarts();
00643 assert( mi[0]==0 );
00644 assert( mi[1]==5 );
00645 assert( mi[2]==7 );
00646 assert( mi[3]==9 );
00647 assert( mi[4]==11 );
00648 assert( mi[5]==14 );
00649
00650 const int * ei = siC1mbr->getIndices();
00651 assert( ei[0] == 0 );
00652 assert( ei[1] == 1 );
00653 assert( ei[2] == 3 );
00654 assert( ei[3] == 4 );
00655 assert( ei[4] == 7 );
00656 assert( ei[5] == 1 );
00657 assert( ei[6] == 2 );
00658 assert( ei[7] == 2 );
00659 assert( ei[8] == 5 );
00660 assert( ei[9] == 3 );
00661 assert( ei[10] == 6 );
00662 assert( ei[11] == 0 );
00663 assert( ei[12] == 4 );
00664 assert( ei[13] == 7 );
00665
00666 assert( siC1mbr->getMajorDim() == 5 );
00667 assert( siC1mbr->getNumElements() == 14 );
00668
00669
00670 assert( siC1rs == siC1.getRowSense() );
00671 assert( siC1rhs == siC1.getRightHandSide() );
00672 assert( siC1rr == siC1.getRowRange() );
00673
00674
00675 OsiRowCut rc;
00676 rc.setLb(-DBL_MAX);
00677 rc.setUb( DBL_MAX);
00678 OsiCuts cuts;
00679 cuts.insert(rc);
00680 siC1.applyCuts(cuts);
00681
00682
00683
00684 assert( siC1.rowrange_==NULL );
00685 assert( siC1.rowsense_==NULL );
00686 assert( siC1.rhs_==NULL );
00687 assert( siC1.matrixByRow_==NULL );
00688
00689 siC1rs = siC1.getRowSense();
00690 assert( siC1rs[0]=='G' );
00691 assert( siC1rs[1]=='L' );
00692 assert( siC1rs[2]=='E' );
00693 assert( siC1rs[3]=='R' );
00694 assert( siC1rs[4]=='R' );
00695 assert( siC1rs[5]=='N' );
00696
00697 siC1rhs = siC1.getRightHandSide();
00698 assert( eq(siC1rhs[0],2.5) );
00699 assert( eq(siC1rhs[1],2.1) );
00700 assert( eq(siC1rhs[2],4.0) );
00701 assert( eq(siC1rhs[3],5.0) );
00702 assert( eq(siC1rhs[4],15.) );
00703 assert( eq(siC1rhs[5],0.0 ) );
00704
00705 siC1rr = siC1.getRowRange();
00706 assert( eq(siC1rr[0],0.0) );
00707 assert( eq(siC1rr[1],0.0) );
00708 assert( eq(siC1rr[2],0.0) );
00709 assert( eq(siC1rr[3],5.0-1.8) );
00710 assert( eq(siC1rr[4],15.0-3.0) );
00711 assert( eq(siC1rr[5],0.0) );
00712
00713 lhs=siC1;
00714 }
00715
00716 assert( lhs.rowrange_==NULL );
00717 assert( lhs.rowsense_==NULL );
00718 assert( lhs.rhs_==NULL );
00719 assert( lhs.matrixByRow_==NULL );
00720
00721 const char * lhsrs = lhs.getRowSense();
00722 assert( lhsrs[0]=='G' );
00723 assert( lhsrs[1]=='L' );
00724 assert( lhsrs[2]=='E' );
00725 assert( lhsrs[3]=='R' );
00726 assert( lhsrs[4]=='R' );
00727 assert( lhsrs[5]=='N' );
00728
00729 const double * lhsrhs = lhs.getRightHandSide();
00730 assert( eq(lhsrhs[0],2.5) );
00731 assert( eq(lhsrhs[1],2.1) );
00732 assert( eq(lhsrhs[2],4.0) );
00733 assert( eq(lhsrhs[3],5.0) );
00734 assert( eq(lhsrhs[4],15.) );
00735 assert( eq(lhsrhs[5],0.0) );
00736
00737 const double *lhsrr = lhs.getRowRange();
00738 assert( eq(lhsrr[0],0.0) );
00739 assert( eq(lhsrr[1],0.0) );
00740 assert( eq(lhsrr[2],0.0) );
00741 assert( eq(lhsrr[3],5.0-1.8) );
00742 assert( eq(lhsrr[4],15.0-3.0) );
00743 assert( eq(lhsrr[5],0.0) );
00744
00745 const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
00746 assert( lhsmbr != NULL );
00747 const double * ev = lhsmbr->getElements();
00748 assert( eq(ev[0], 3.0) );
00749 assert( eq(ev[1], 1.0) );
00750 assert( eq(ev[2], -2.0) );
00751 assert( eq(ev[3], -1.0) );
00752 assert( eq(ev[4], -1.0) );
00753 assert( eq(ev[5], 2.0) );
00754 assert( eq(ev[6], 1.1) );
00755 assert( eq(ev[7], 1.0) );
00756 assert( eq(ev[8], 1.0) );
00757 assert( eq(ev[9], 2.8) );
00758 assert( eq(ev[10], -1.2) );
00759 assert( eq(ev[11], 5.6) );
00760 assert( eq(ev[12], 1.0) );
00761 assert( eq(ev[13], 1.9) );
00762
00763 const int * mi = lhsmbr->getVectorStarts();
00764 assert( mi[0]==0 );
00765 assert( mi[1]==5 );
00766 assert( mi[2]==7 );
00767 assert( mi[3]==9 );
00768 assert( mi[4]==11 );
00769 assert( mi[5]==14 );
00770
00771 const int * ei = lhsmbr->getIndices();
00772 assert( ei[0] == 0 );
00773 assert( ei[1] == 1 );
00774 assert( ei[2] == 3 );
00775 assert( ei[3] == 4 );
00776 assert( ei[4] == 7 );
00777 assert( ei[5] == 1 );
00778 assert( ei[6] == 2 );
00779 assert( ei[7] == 2 );
00780 assert( ei[8] == 5 );
00781 assert( ei[9] == 3 );
00782 assert( ei[10] == 6 );
00783 assert( ei[11] == 0 );
00784 assert( ei[12] == 4 );
00785 assert( ei[13] == 7 );
00786
00787 int md = lhsmbr->getMajorDim();
00788 assert( md == 6 );
00789 assert( lhsmbr->getNumElements() == 14 );
00790 }
00791
00792 }
00793
00794
00795 {
00796 OsiClpSolverInterface m;
00797 std::string fn = mpsDir+"p0033";
00798 m.readMps(fn.c_str(),"mps");
00799 double inf = m.getInfinity();
00800
00801 CoinPackedVector c0;
00802 c0.insert(0, 4);
00803 c0.insert(1, 1);
00804 m.addCol(c0, 0, inf, 3);
00805 m.initialSolve();
00806 double objValue = m.getObjValue();
00807 CoinRelFltEq eq(1.0e-2);
00808 assert( eq(objValue,2520.57) );
00809
00810 int * d = new int[1];
00811 d[0]=0;
00812 m.deleteCols(1,d);
00813 delete [] d;
00814 d=NULL;
00815 m.resolve();
00816 objValue = m.getObjValue();
00817 assert( eq(objValue,2520.57) );
00818
00819 int iCol = m.getNumCols()-1;
00820 m.deleteCols(1,&iCol);
00821 m.resolve();
00822 objValue = m.getObjValue();
00823 assert( eq(objValue,2520.57) );
00824
00825 }
00826
00827 if (fopen("../Clp/matt.mps","r")) {
00828 OsiClpSolverInterface m;
00829 m.readMps("../Clp/matt","mps");
00830 m.setHintParam(OsiDoPresolveInResolve, true, OsiHintDo);
00831 m.resolve();
00832
00833 std::vector<double *> rays = m.getDualRays(1);
00834 std::cout << "Dual Ray: " << std::endl;
00835 for(int i = 0; i < m.getNumRows(); i++){
00836 if(fabs(rays[0][i]) > 0.00001)
00837 std::cout << i << " : " << rays[0][i] << std::endl;
00838 }
00839
00840 std::cout << "isProvenOptimal = " << m.isProvenOptimal() << std::endl;
00841 std::cout << "isProvenPrimalInfeasible = " << m.isProvenPrimalInfeasible()
00842 << std::endl;
00843
00844 delete [] rays[0];
00845
00846 }
00847
00848
00849 {
00850 OsiClpSolverInterface m;
00851 std::string fn = mpsDir+"p0033";
00852 m.readMps(fn.c_str(),"mps");
00853 m.setObjSense(-1.0);
00854 m.getModelPtr()->messageHandler()->setLogLevel(4);
00855 m.initialSolve();
00856 m.getModelPtr()->factorization()->maximumPivots(5);
00857 m.setObjSense(1.0);
00858
00859 m.enableSimplexInterface(true);
00860
00861 int numberIterations=0;
00862 int numberColumns = m.getNumCols();
00863 int numberRows = m.getNumRows();
00864 double * fakeCost = new double[numberColumns];
00865 double * duals = new double [numberRows];
00866 double * djs = new double [numberColumns];
00867 const double * solution = m.getColSolution();
00868 memcpy(fakeCost,m.getObjCoefficients(),numberColumns*sizeof(double));
00869 while (1) {
00870 const double * dj;
00871 const double * dual;
00872 if ((numberIterations&1)==0) {
00873
00874 dj = m.getReducedCost();
00875 dual = m.getRowPrice();
00876 } else {
00877
00878 dj = djs;
00879 dual = duals;
00880 m.getReducedGradient(djs,duals,fakeCost);
00881 }
00882 int i;
00883 int colIn=9999;
00884 int direction=1;
00885 double best=1.0e-6;
00886
00887
00888 for (i=0;i<numberRows;i++) {
00889 double value=dual[i];
00890 if (value>best) {
00891 direction=-1;
00892 best=value;
00893 colIn=-i-1;
00894 }
00895 }
00896 for (i=0;i<numberColumns;i++) {
00897 double value=dj[i];
00898 if (value<-best&&solution[i]<1.0e-6) {
00899 direction=1;
00900 best=-value;
00901 colIn=i;
00902 } else if (value>best&&solution[i]>1.0-1.0e-6) {
00903 direction=-1;
00904 best=value;
00905 colIn=i;
00906 }
00907 }
00908 if (colIn==9999)
00909 break;
00910 int colOut;
00911 int outStatus;
00912 double theta;
00913 assert(!m.primalPivotResult(colIn,direction,colOut,outStatus,theta,NULL));
00914 printf("out %d, direction %d theta %g\n",
00915 colOut,outStatus,theta);
00916 numberIterations++;
00917 }
00918 delete [] fakeCost;
00919 delete [] duals;
00920 delete [] djs;
00921
00922 m.disableSimplexInterface();
00923 m.getModelPtr()->messageHandler()->setLogLevel(4);
00924 m.resolve();
00925 assert (!m.getIterationCount());
00926 m.setObjSense(-1.0);
00927 m.initialSolve();
00928 }
00929
00930 {
00931 OsiClpSolverInterface m;
00932 OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
00933 }
00934 }