source: trunk/Cbc/src/unitTestClp.cpp @ 1573

Last change on this file since 1573 was 1573, checked in by lou, 8 years ago

Change to EPL license notice.

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