source: branches/sandbox/Cbc/src/unitTestClp.cpp @ 1286

Last change on this file since 1286 was 1286, checked in by EdwinStraver, 10 years ago

Changed formatting using AStyle -A4 -p

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 30.7 KB
Line 
1/* $Id: unitTestClp.cpp 1286 2009-11-09 23:33:07Z EdwinStraver $ */
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.