source: stable/2.4/Cbc/src/unitTestClp.cpp @ 1271

Last change on this file since 1271 was 1271, checked in by forrest, 10 years ago

Creating new stable branch 2.4 from trunk (rev 1270)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.4 KB
Line 
1/* $Id: unitTestClp.cpp 1271 2009-11-05 15:57:25Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4
5#include <cstdio>
6#include <string>
7#include <iostream>
8
9#include "CoinTime.hpp"
10#include "CbcModel.hpp"
11#include "CbcCutGenerator.hpp"
12#include "CbcBranchCut.hpp"
13#include "CglProbing.hpp"
14#include "OsiClpSolverInterface.hpp"
15#include "ClpFactorization.hpp"
16#include "OsiRowCutDebugger.hpp"
17//#############################################################################
18
19#ifdef NDEBUG
20#undef NDEBUG
21#endif
22
23//#############################################################################
24
25// Display message on stdout and stderr
26void testingMessage( const char * const msg )
27{
28  std::cout <<msg;
29  //cout <<endl <<"*****************************************"
30  //     <<endl <<msg <<endl;
31}
32
33//#############################################################################
34
35static inline bool CbcTestFile(const std::string name)
36{
37  FILE *fp = fopen(name.c_str(),"r");
38  if (fp) {
39    fclose(fp);
40    return true;
41  }
42  return false;
43}
44
45//#############################################################################
46
47bool CbcTestMpsFile(std::string& fname)
48{
49  if (CbcTestFile(fname)) {
50    return true;
51  }
52  if (CbcTestFile(fname+".mps")) {
53    fname += ".mps";
54    return true;
55  }
56  if (CbcTestFile(fname+".MPS")) {
57    fname += ".MPS";
58    return true;
59  }
60#ifdef COIN_HAS_ZLIB
61  if (CbcTestFile(fname+".gz")) {
62    return true;
63  }
64  if (CbcTestFile(fname+".mps.gz")) {
65    fname += ".mps";
66    return true;
67  }
68  if (CbcTestFile(fname+".MPS.gz")) {
69    fname += ".MPS";
70    return true;
71  }
72  if (CbcTestFile(fname+".MPS.GZ")) {
73    fname += ".MPS";
74    return true;
75  }
76#endif
77  return false;
78}
79
80//#############################################################################
81// testSwitch -2 unitTest, -1 normal (==2)
82int CbcClpUnitTest (const CbcModel & saveModel, std::string& dirMiplib,
83                    int testSwitch,
84                    double * stuff)
85{
86  // Stop Windows popup
87  WindowsErrorPopupBlocker();
88  unsigned int m ;
89
90  // Set directory containing miplib data files.
91  std::string test1 = dirMiplib +"p0033";
92  // See if files exist
93  bool doTest=CbcTestMpsFile(test1);
94
95  if (!doTest) {
96    printf("Not doing miplib run as can't find mps files - ? .gz without libz\n");
97    return -1;
98  }
99  /*
100    Vectors to hold test problem names and characteristics. The objective value
101    after optimization (objValue) must agree to the specified tolerance
102    (objValueTol).
103  */
104  std::vector<std::string> mpsName ;
105  std::vector<int> nRows ;
106  std::vector<int> nCols ;
107  std::vector<double> objValueC ;
108  std::vector<double> objValue ;
109  std::vector<int> testSet ;
110  /*
111    And a macro to make the vector creation marginally readable.
112  */
113#define PUSH_MPS(zz_mpsName_zz,\
114                 zz_nRows_zz,zz_nCols_zz,zz_objValue_zz,zz_objValueC_zz, \
115                 zz_testSet_zz) \
116  mpsName.push_back(zz_mpsName_zz) ; \
117  nRows.push_back(zz_nRows_zz) ; \
118  nCols.push_back(zz_nCols_zz) ; \
119  objValueC.push_back(zz_objValueC_zz) ; \
120  testSet.push_back(zz_testSet_zz) ; \
121  objValue.push_back(zz_objValue_zz) ;
122  int loSwitch=0;
123  if (testSwitch==-2) {
124    PUSH_MPS("p0033",16,33,3089,2520.57,0);
125    PUSH_MPS("p0201",133,201,7615,6875.0,0);
126    testSwitch=0;
127  } else {
128    if (testSwitch==-1) {
129      testSwitch=1;
130    } else {
131      loSwitch=static_cast<int>(stuff[6]);
132      printf("Solving miplib problems in sets >= %d and <=%d\n",
133             loSwitch,testSwitch);
134    }
135    /*
136      Load up the problem vector. Note that the row counts here include the
137      objective function.
138    */
139    // 0 for no test, 1 for some, 2 for many, 3 for all
140    //PUSH_MPS("blend2",274,353,7.598985,6.9156751140,0);
141    //PUSH_MPS("p2756",755,2756,3124,2688.75,0);
142    //PUSH_MPS("seymour_1",4944,1372,410.7637014,404.35152,0);
143    //PUSH_MPS("enigma",21,100,0.0,0.0,0);
144    //PUSH_MPS("misc03",96,160,3360,1910.,0);
145    //PUSH_MPS("p0201",133,201,7615,6875.0,0);
146#define HOWMANY 6
147#if HOWMANY
148    PUSH_MPS("10teams",230,2025,924,917,1);
149    PUSH_MPS("air03",124,10757,340160,338864.25,0);
150    PUSH_MPS("air04",823,8904,56137,55535.436,2);
151    PUSH_MPS("air05",426,7195,26374,25877.609,2);
152    PUSH_MPS("arki001",1048,1388,7580813.0459,7579599.80787,7);
153    PUSH_MPS("bell3a",123,133,878430.32,862578.64,0);
154    PUSH_MPS("bell5",91,104,8966406.49,8608417.95,1);
155    PUSH_MPS("blend2",274,353,7.598985,6.9156751140,0);
156    PUSH_MPS("cap6000",2176,6000,-2451377,-2451537.325,1);
157    PUSH_MPS("dano3mip",3202,13873,728.1111,576.23162474,7);
158    PUSH_MPS("danoint",664,521,65.67,62.637280418,6);
159    PUSH_MPS("dcmulti",290,548,188182,183975.5397,0);
160    PUSH_MPS("dsbmip",1182,1886,-305.19817501,-305.19817501,0);
161    PUSH_MPS("egout",98,141,568.101,149.589,0);
162    PUSH_MPS("enigma",21,100,0.0,0.0,0);
163    PUSH_MPS("fast0507",507,63009,174,172.14556668,5);
164    PUSH_MPS("fiber",363,1298,405935.18000,156082.51759,0);
165    PUSH_MPS("fixnet6",478,878,3983,1200.88,1);
166    PUSH_MPS("flugpl",18,18,1201500,1167185.7,0);
167    PUSH_MPS("gen",780,870,112313,112130.0,0);
168    PUSH_MPS("gesa2",1392,1224,25779856.372,25476489.678,1);
169    PUSH_MPS("gesa2_o",1248,1224,25779856.372,25476489.678,1);
170    PUSH_MPS("gesa3",1368,1152,27991042.648,27833632.451,0);
171    PUSH_MPS("gesa3_o",1224,1152,27991042.648,27833632.451,0);
172    PUSH_MPS("gt2",29,188,21166.000,13460.233074,0);
173    PUSH_MPS("harp2",112,2993,-73899798.00,-74353341.502,6);
174    PUSH_MPS("khb05250",101,1350,106940226,95919464.0,0);
175    PUSH_MPS("l152lav",97,1989,4722,4656.36,1);
176    PUSH_MPS("lseu",28,89,1120,834.68,0);
177    PUSH_MPS("mas74",13,151,11801.18573,10482.79528,3);
178    PUSH_MPS("mas76",12,151,40005.05414,38893.9036,2);
179    PUSH_MPS("misc03",96,160,3360,1910.,0);
180    PUSH_MPS("misc06",820,1808,12850.8607,12841.6,0);
181    PUSH_MPS("misc07",212,260,2810,1415.0,1);
182    PUSH_MPS("mitre",2054,10724,115155,114740.5184,1);
183    PUSH_MPS("mkc",3411,5325,-553.75,-611.85,7); // this is suboptimal
184    PUSH_MPS("mod008",6,319,307,290.9,0);
185    PUSH_MPS("mod010",146,2655,6548,6532.08,0);
186    PUSH_MPS("mod011",4480,10958,-54558535,-62121982.55,2);
187    PUSH_MPS("modglob",291,422,20740508,20430947.,2);
188    PUSH_MPS("noswot",182,128,-43,-43.0,6);
189    PUSH_MPS("nw04",36,87482,16862,16310.66667,1);
190    PUSH_MPS("p0033",16,33,3089,2520.57,0);
191    PUSH_MPS("p0201",133,201,7615,6875.0,0);
192    PUSH_MPS("p0282",241,282,258411,176867.50,0);
193    PUSH_MPS("p0548",176,548,8691,315.29,0);
194    PUSH_MPS("p2756",755,2756,3124,2688.75,0);
195    PUSH_MPS("pk1",45,86,11.0,0.0,2);
196    PUSH_MPS("pp08a",136,240,7350.0,2748.3452381,1);
197    PUSH_MPS("pp08aCUTS",246,240,7350.0,5480.6061563,1);
198    PUSH_MPS("qiu",1192,840,-132.873137,-931.638857,3);
199    PUSH_MPS("qnet1",503,1541,16029.692681,14274.102667,0);
200    PUSH_MPS("qnet1_o",456,1541,16029.692681,12095.571667,0);
201    PUSH_MPS("rentacar",6803,9557,30356761,28806137.644,0);
202    PUSH_MPS("rgn",24,180,82.1999,48.7999,0);
203    PUSH_MPS("rout",291,556,1077.56,981.86428571,3);
204    PUSH_MPS("set1ch",492,712,54537.75,32007.73,5);
205    PUSH_MPS("seymour",4944,1372,423,403.84647413,7);
206    PUSH_MPS("seymour_1",4944,1372,410.76370,403.84647413,5);
207    PUSH_MPS("stein27",118,27,18,13.0,0);
208    PUSH_MPS("stein45",331,45,30,22.0,1);
209    PUSH_MPS("swath",884,6805,497.603,334.4968581,7);
210    PUSH_MPS("vpm1",234,378,20,15.4167,0);
211    PUSH_MPS("vpm2",234,378,13.75,9.8892645972,0);
212#endif
213  }
214#undef PUSH_MPS
215   
216  int numProbSolved = 0;
217  double timeTaken=0.0;
218  //#define CLP_FACTORIZATION_INSTRUMENT
219#ifdef CLP_FACTORIZATION_INSTRUMENT
220  double timeTakenFac=0.0;
221#endif
222  // Normally do in order
223  int which[100];
224  int nLoop=static_cast<int>(mpsName.size());
225  assert (nLoop<=100);
226  for (int i=0;i<nLoop;i++)
227    which[i]=i;
228  //#define RANDOM_ORDER
229#ifdef RANDOM_ORDER
230  unsigned int iTime = static_cast<unsigned int>(CoinGetTimeOfDay()-1.256e9);
231  printf("Time %d\n",iTime);
232  double sort[100];
233  CoinDrand48(true,iTime);
234  for (int i=0;i<nLoop;i++)
235    sort[i]=CoinDrand48();
236  CoinSort_2(sort,sort+nLoop,which);
237#endif
238  int numberFailures=0;
239  int numberAttempts=0;
240  int numberPossibleAttempts=0;
241  for (m = 0 ; m < mpsName.size() ; m++) {
242    int test = testSet[m];
243    if(testSwitch>=test&&loSwitch<=test) 
244      numberPossibleAttempts++;
245  }
246 
247  /*
248    Open the main loop to step through the MPS problems.
249  */
250  for (unsigned int mw = 0 ; mw < mpsName.size() ; mw++) {
251    m=which[mw];
252    int test = testSet[m];
253    if(testSwitch>=test&&loSwitch<=test) {
254      numberAttempts++;
255      std::cout << "  processing mps file: " << mpsName[m] 
256                << " (" << numberAttempts << " out of " 
257                << numberPossibleAttempts << ")\n";
258      /*
259        Stage 1: Read the MPS
260        and make sure the size of the constraint matrix is correct.
261      */
262      CbcModel * model = new CbcModel(saveModel);
263     
264      std::string fn = dirMiplib+mpsName[m] ;
265      if (!CbcTestMpsFile(fn)) {
266        std::cout << "ERROR: Cannot find MPS file " << fn << "\n";
267        continue;
268      }
269      CoinDrand48(true,1234567);
270      //printf("RAND1 %g %g\n",CoinDrand48(true,1234567),model->randomNumberGenerator()->randomDouble());
271      //printf("RAND1 %g\n",CoinDrand48(true,1234567));
272      model->solver()->readMps(fn.c_str(),"") ;
273      assert(model->getNumRows() == nRows[m]) ;
274      assert(model->getNumCols() == nCols[m]) ;
275     
276      /*
277        Stage 2: Call solver to solve the problem.
278        then check the return code and objective.
279      */
280     
281#ifdef CLP_FACTORIZATION_INSTRUMENT
282      extern double factorization_instrument(int type);
283      double facTime1=factorization_instrument(0);
284      printf("Factorization - initial solve %g seconds\n",
285             facTime1);
286      timeTakenFac += facTime1;
287#endif
288      double startTime = CoinCpuTime()+CoinCpuTimeJustChildren();
289      int testMaximumNodes=200000;
290      if (testSwitch>1)
291        testMaximumNodes=20000000;
292      if (model->getMaximumNodes()>testMaximumNodes) {
293        model->setMaximumNodes(testMaximumNodes);
294      }
295      OsiClpSolverInterface * si =
296        dynamic_cast<OsiClpSolverInterface *>(model->solver()) ;
297      ClpSimplex * modelC = NULL;
298      if (si) {
299        // get clp itself
300        modelC = si->getModelPtr();
301        ClpMatrixBase * matrix = modelC->clpMatrix();
302        ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
303        if (stuff&&stuff[9]&&clpMatrix) {
304          // vector matrix!
305          clpMatrix->makeSpecialColumnCopy();
306        }
307#if 0
308        if (clpMatrix) {
309          int numberRows = clpMatrix->getNumRows();
310          int numberColumns = clpMatrix->getNumCols();
311          double * elements = clpMatrix->getMutableElements();
312          const int * row = clpMatrix->getIndices();
313          const CoinBigIndex * columnStart = clpMatrix->getVectorStarts();
314          const int * columnLength = clpMatrix->getVectorLengths();
315          double * smallest = new double [numberRows];
316          double * largest = new double [numberRows];
317          char * flag = new char [numberRows];
318          CoinZeroN(flag,numberRows);
319          for (int i=0;i<numberRows;i++) {
320            smallest[i]=COIN_DBL_MAX;
321            largest[i]=0.0;
322          }
323          for (int iColumn=0;iColumn<numberColumns;iColumn++) {
324            bool isInteger = modelC->isInteger(iColumn);
325            CoinBigIndex j;
326            for (j=columnStart[iColumn];
327                 j<columnStart[iColumn]+columnLength[iColumn];j++) {
328              int iRow=row[j];
329              double value = fabs(elements[j]);
330              if (!isInteger)
331                flag[iRow]=1;
332              smallest[iRow]=CoinMin(smallest[iRow],value);
333              largest[iRow]=CoinMax(largest[iRow],value);
334            }
335          }
336          double * rowLower = modelC->rowLower();
337          double * rowUpper = modelC->rowUpper();
338          bool changed=false;
339          for (int i=0;i<numberRows;i++) {
340            if (flag[i]&&smallest[i]>10.0&&false) {
341              smallest[i]=1.0/smallest[i];
342              if (rowLower[i]>-1.0e20)
343                rowLower[i] *= smallest[i];
344              if (rowUpper[i]<1.0e20)
345                rowUpper[i] *= smallest[i];
346              changed = true;
347            } else {
348              smallest[i]=0.0;
349            }
350          }
351          if (changed) {
352            printf("SCALED\n");
353            for (int iColumn=0;iColumn<numberColumns;iColumn++) {
354              CoinBigIndex j;
355              for (j=columnStart[iColumn];
356                   j<columnStart[iColumn]+columnLength[iColumn];j++) {
357                int iRow=row[j];
358                if (smallest[iRow])
359                  elements[j] *= smallest[iRow];
360              }
361            }
362          }
363          delete [] smallest;
364          delete [] largest;
365          delete [] flag;
366        }
367#endif
368        model->checkModel();
369        modelC->tightenPrimalBounds(0.0,0,true);
370        model->initialSolve();
371        if (modelC->dualBound()==1.0e10) {
372          // user did not set - so modify
373          // get largest scaled away from bound
374          ClpSimplex temp=*modelC;
375          temp.dual(0,7);
376          double largestScaled=1.0e-12;
377          double largest=1.0e-12;
378          int numberRows = temp.numberRows();
379          const double * rowPrimal = temp.primalRowSolution();
380          const double * rowLower = temp.rowLower();
381          const double * rowUpper = temp.rowUpper();
382          const double * rowScale = temp.rowScale();
383          int iRow;
384          for (iRow=0;iRow<numberRows;iRow++) {
385            double value = rowPrimal[iRow];
386            double above = value-rowLower[iRow];
387            double below = rowUpper[iRow]-value;
388            if (above<1.0e12) {
389              largest = CoinMax(largest,above);
390            }
391            if (below<1.0e12) {
392              largest = CoinMax(largest,below);
393            }
394            if (rowScale) {
395              double multiplier = rowScale[iRow];
396              above *= multiplier;
397              below *= multiplier;
398            }
399            if (above<1.0e12) {
400              largestScaled = CoinMax(largestScaled,above);
401            }
402            if (below<1.0e12) {
403              largestScaled = CoinMax(largestScaled,below);
404            }
405          }
406         
407          int numberColumns = temp.numberColumns();
408          const double * columnPrimal = temp.primalColumnSolution();
409          const double * columnLower = temp.columnLower();
410          const double * columnUpper = temp.columnUpper();
411          const double * columnScale = temp.columnScale();
412          int iColumn;
413          for (iColumn=0;iColumn<numberColumns;iColumn++) {
414            double value = columnPrimal[iColumn];
415            double above = value-columnLower[iColumn];
416            double below = columnUpper[iColumn]-value;
417            if (above<1.0e12) {
418              largest = CoinMax(largest,above);
419            }
420            if (below<1.0e12) {
421              largest = CoinMax(largest,below);
422            }
423            if (columnScale) {
424              double multiplier = 1.0/columnScale[iColumn];
425              above *= multiplier;
426              below *= multiplier;
427            }
428            if (above<1.0e12) {
429              largestScaled = CoinMax(largestScaled,above);
430            }
431            if (below<1.0e12) {
432              largestScaled = CoinMax(largestScaled,below);
433            }
434          }
435          std::cout<<"Largest (scaled) away from bound "<<largestScaled
436                   <<" unscaled "<<largest<<std::endl;
437#if 0
438          modelC->setDualBound(CoinMax(1.0001e8,
439                                       CoinMin(1000.0*largestScaled,1.00001e10)));
440#else
441          modelC->setDualBound(CoinMax(1.0001e9,
442                                       CoinMin(1000.0*largestScaled,1.0001e10)));
443#endif
444        }
445      }
446      model->setMinimumDrop(CoinMin(5.0e-2,
447                                    fabs(model->getMinimizationObjValue())*1.0e-3+1.0e-4));
448      if (CoinAbs(model->getMaximumCutPassesAtRoot())<=100) {
449        if (model->getNumCols()<500) {
450          model->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
451        } else if (model->getNumCols()<5000) {
452          model->setMaximumCutPassesAtRoot(100); // use minimum drop
453        } else {
454          model->setMaximumCutPassesAtRoot(20);
455        }
456      }
457      // If defaults then increase trust for small models
458      if (model->numberStrong()==5&&model->numberBeforeTrust()==10) {
459        int numberColumns = model->getNumCols();
460        if (numberColumns<=50) {
461          model->setNumberBeforeTrust(1000);
462        } else if (numberColumns<=100) {
463          model->setNumberBeforeTrust(100);
464        } else if (numberColumns<=300) {
465          model->setNumberBeforeTrust(50);
466        }
467      }
468      //if (model->getNumCols()>=500) {
469      // switch off Clp stuff
470      //model->setFastNodeDepth(-1);
471      //}
472      if (model->getNumCols()==-2756) {
473        // p2756
474        std::string problemName ;
475        model->solver()->getStrParam(OsiProbName,problemName) ;
476        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
477      }
478      if (model->getNumCols()==-201) {
479        // p201
480        std::string problemName ;
481        model->solver()->getStrParam(OsiProbName,problemName) ;
482        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
483      }
484      if (model->getNumCols()==-104) {
485        // bell5
486        std::string problemName ;
487        model->solver()->getStrParam(OsiProbName,problemName) ;
488        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
489      }
490      if (model->getNumCols()==-548&&model->getNumRows()==176) {
491        // p0548
492        std::string problemName ;
493        model->solver()->getStrParam(OsiProbName,problemName) ;
494        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
495      }
496      if (model->getNumCols()==-160) {
497        // misc03
498        std::string problemName ;
499        model->solver()->getStrParam(OsiProbName,problemName) ;
500        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
501      }
502      if (model->getNumCols()==-353) {
503        // blend2
504        std::string problemName ;
505        model->solver()->getStrParam(OsiProbName,problemName) ;
506        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
507      }
508      if (model->getNumCols()==-100&&model->getNumRows()==21) {
509        // enigma
510        std::string problemName ;
511        model->solver()->getStrParam(OsiProbName,problemName) ;
512        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
513      }
514      if (model->getNumCols()==-1541) {
515        // qnet1
516        std::string problemName ;
517        model->solver()->getStrParam(OsiProbName,problemName) ;
518        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
519      }
520      if (model->getNumCols()==-10724) {
521        // mitre
522        std::string problemName ;
523        model->solver()->getStrParam(OsiProbName,problemName) ;
524        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
525      }
526      if (model->getNumCols()==-1224) {
527        //PUSH_MPS("gesa2",1392,1224,25779856.372,25476489.678,7);
528        // gesa2
529        std::string problemName ;
530        model->solver()->getStrParam(OsiProbName,problemName) ;
531        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
532      }
533      if (model->getNumCols()==-1224&&model->getNumRows()<1380) {
534        //PUSH_MPS("gesa2_o",1248,1224,25779856.372,25476489.678,1);
535        // gesa2_o
536        std::string problemName ;
537        model->solver()->getStrParam(OsiProbName,problemName) ;
538        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
539      }
540      if (model->getNumCols()==-1152&&model->getNumRows()==1368) {
541        //PUSH_MPS("gesa3",1368,1152,27991042.648,27833632.451,7);
542        // gesa3
543        std::string problemName ;
544        model->solver()->getStrParam(OsiProbName,problemName) ;
545        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
546      }
547      if (model->getNumCols()==-1152&&model->getNumRows()==1224) {
548        //PUSH_MPS("gesa3_o",1224,1152,27991042.648,27833632.451,7);
549        // gesa3
550        std::string problemName ;
551        model->solver()->getStrParam(OsiProbName,problemName) ;
552        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
553      }
554      if (model->getNumCols()==-282) {
555        //PUSH_MPS("p0282",241,282,258411,176867.50,7);
556        // p0282
557        std::string problemName ;
558        model->solver()->getStrParam(OsiProbName,problemName) ;
559        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
560      }
561      if (model->getNumCols()==-141) {
562        // egout
563        std::string problemName ;
564        model->solver()->getStrParam(OsiProbName,problemName) ;
565        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
566      }
567      if (model->getNumCols()==-378) {
568        // vpm2
569        std::string problemName ;
570        model->solver()->getStrParam(OsiProbName,problemName) ;
571        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
572      }
573      if (model->getNumCols()==-240&&model->getNumRows()==246) {
574        // pp08aCUTS
575        std::string problemName ;
576        model->solver()->getStrParam(OsiProbName,problemName) ;
577        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
578      }
579      if (model->getNumCols()==-240&&model->getNumRows()==136) {
580        // pp08a
581        std::string problemName ;
582        model->solver()->getStrParam(OsiProbName,problemName) ;
583        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
584      }
585      if (model->getNumCols()==-1372&&model->getNumRows()==4944) {
586        // seymour1
587        std::string problemName ;
588        model->solver()->getStrParam(OsiProbName,problemName) ;
589        model->solver()->activateRowCutDebugger(problemName.c_str()) ;
590      }
591      setCutAndHeuristicOptions(*model);
592      if (si) {
593#ifdef CLP_MULTIPLE_FACTORIZATIONS
594        if (!modelC->factorization()->isDenseOrSmall()) {
595          int denseCode = stuff ? static_cast<int> (stuff[4]) : -1;
596          int smallCode = stuff ? static_cast<int> (stuff[10]) : -1;
597          if (stuff&&stuff[8]>=1) {
598            if (denseCode<0)
599              denseCode=40;
600            if (smallCode<0)
601              smallCode=40;
602          }
603          if (denseCode>0)
604            modelC->factorization()->setGoDenseThreshold(denseCode);
605          if (smallCode>0)
606            modelC->factorization()->setGoSmallThreshold(smallCode);
607          if (denseCode>=modelC->numberRows()) {
608            //printf("problem going dense\n");
609            //modelC->factorization()->goDenseOrSmall(modelC->numberRows());
610          }
611        }
612#endif
613        if (stuff&&stuff[8]>=1) {
614          if (modelC->numberColumns()+modelC->numberRows()<=10000&&
615              model->fastNodeDepth()==-1) 
616            model->setFastNodeDepth(-9);
617        }
618      }
619      //OsiObject * obj = new CbcBranchToFixLots(model,0.3,0.0,3,3000003);
620      //model->addObjects(1,&obj);
621      //delete obj;
622      model->branchAndBound();
623#ifdef CLP_FACTORIZATION_INSTRUMENT
624      double facTime=factorization_instrument(0);
625      printf("Factorization %g seconds\n",
626             facTime);
627      timeTakenFac += facTime;
628#endif
629     
630      double timeOfSolution = CoinCpuTime()+CoinCpuTimeJustChildren()-startTime;
631      // Print more statistics
632      std::cout<<"Cuts at root node changed objective from "<<model->getContinuousObjective()
633               <<" to "<<model->rootObjectiveAfterCuts()<<std::endl;
634      int numberGenerators = model->numberCutGenerators();
635      for (int iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
636        CbcCutGenerator * generator = model->cutGenerator(iGenerator);
637#ifndef CLP_INVESTIGATE
638        CglImplication * implication = dynamic_cast<CglImplication*>(generator->generator());
639        if (implication)
640          continue;
641#endif
642        std::cout<<generator->cutGeneratorName()<<" was tried "
643                 <<generator->numberTimesEntered()<<" times and created "
644                 <<generator->numberCutsInTotal()<<" cuts of which "
645                 <<generator->numberCutsActive()<<" were active after adding rounds of cuts";
646        if (generator->timing())
647          std::cout<<" ( "<<generator->timeInCutGenerator()<<" seconds)"<<std::endl;
648        else
649          std::cout<<std::endl;
650      }
651      if (!model->status()) { 
652        double soln = model->getObjValue(); 
653        double tolerance = CoinMax(1.0e-5,1.0e-5*CoinMin(fabs(soln),fabs(objValue[m])));
654        //CoinRelFltEq eq(1.0e-3) ;
655        if (fabs(soln-objValue[m])<tolerance) { 
656          std::cout
657            <<"cbc_clp"<<" "
658            << soln << " = " << objValue[m] << " ; okay";
659          numProbSolved++;
660        } else  { 
661          std::cout <<"cbc_clp" <<" " <<soln << " != " <<objValue[m]
662                    << "; error=" << fabs(objValue[m] - soln); 
663          numberFailures++;
664          //#ifdef COIN_DEVELOP
665          //abort();
666          //#endif
667        }
668      } else {
669        std::cout << "cbc_clp error; too many nodes" ;
670      }
671      timeTaken += timeOfSolution;
672      std::cout<<" - took " <<timeOfSolution<<" seconds.("<<
673        model->getNodeCount()<<" / "<<model->getIterationCount()<<
674        " ) subtotal "<<timeTaken
675               <<" ("<<mpsName[m]<<")"<<std::endl;
676      delete model;
677    }
678  }
679  int returnCode=0;
680  std::cout
681    <<"cbc_clp" 
682    <<" solved " 
683    <<numProbSolved
684    <<" out of "
685    <<numberAttempts;
686  int numberOnNodes = numberAttempts-numProbSolved-numberFailures;
687  if (numberFailures||numberOnNodes) {
688    if (numberOnNodes) {
689      std::cout<<" ("<<numberOnNodes<<" stopped on nodes)";
690      returnCode = numberOnNodes;
691    }
692    if (numberFailures) {
693      std::cout<<" ("<<numberFailures<<" gave bad answer!)";
694      returnCode += 100*numberFailures;
695    }
696  }
697  std::cout<<" and took "
698    <<timeTaken
699    <<" seconds."
700    <<std::endl;
701  if (testSwitch==-2) {
702    if(numberFailures||numberOnNodes) {
703      printf("****** Unit Test failed\n");
704      fprintf(stderr,"****** Unit Test failed\n");
705    } else {
706      fprintf(stderr,"Unit Test succeeded\n");
707    }
708  }
709#ifdef CLP_FACTORIZATION_INSTRUMENT
710  printf("Total factorization time %g seconds\n",
711         timeTakenFac);
712#endif
713  return returnCode;
714}
Note: See TracBrowser for help on using the repository browser.