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

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

final changes before cleaning

  • 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 1315 2009-11-28 11:09:56Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4
5#include <cstdio>
6#include <string>
7#include <iostream>
8
9#include "CoinTime.hpp"
10#include "CbcModel.hpp"
11#include "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.
279            then check the return code and 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#if 0
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#if 0
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    }
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}
Note: See TracBrowser for help on using the repository browser.