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

Last change on this file since 1433 was 1432, checked in by bjarni, 10 years ago

Added extra return at end of each source file where needed, to remove possible linefeed conflicts (NightlyBuild? errors)

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