Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • stable/2.8/Cbc/src/CbcSolver.cpp

    r2057 r2102  
    657657    parameters_[whichParam(CBC_PARAM_STR_FPUMP, numberParameters_, parameters_)].setCurrentOption("on");
    658658    parameters_[whichParam(CBC_PARAM_STR_GREEDY, numberParameters_, parameters_)].setCurrentOption("on");
    659     parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("on");
     659    parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("off");
    660660    parameters_[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters_, parameters_)].setCurrentOption("off");
    661661    parameters_[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].setCurrentOption("off");
     
    12891289  return CbcMain1(argc,argv,model,callBack,staticParameterData);
    12901290}
     1291#ifdef GENERAL_HANDLER_PRINTING
     1292static void printGeneralMessage(CbcModel &model,const char * message);
     1293#endif
    12911294/*
    12921295  Meaning of whereFrom:
     
    13081311    bool noPrinting = parameterData.noPrinting_;
    13091312    bool useSignalHandler = parameterData.useSignalHandler_;
     1313#ifdef GENERAL_HANDLER_PRINTING
     1314    //char printByHandler[1000];
     1315#endif
    13101316    CbcModel & model_ = model;
    13111317#ifdef CBC_THREAD_SAFE
     
    29822988#ifdef COIN_HAS_ASL
    29832989                            if (statusUserFunction_[0]) {
    2984                                 double value = model2->getObjValue() * model2->getObjSense();
     2990                                double value = model2->getObjValue();
    29852991                                char buf[300];
    29862992                                int pos = 0;
     
    30473053                        } else {
    30483054#ifndef DISALLOW_PRINTING
    3049                             std::cout << "** Current model not valid" << std::endl;
     3055#ifdef GENERAL_HANDLER_PRINTING
     3056                          sprintf(generalPrint, "** Current model not valid");
     3057                          printGeneralMessage(model_,generalPrint);
     3058#else
     3059                          std::cout << "** Current model not valid" << std::endl;
     3060#endif
    30503061#endif
    30513062                        }
     
    30853096                        } else {
    30863097#ifndef DISALLOW_PRINTING
    3087                             std::cout << "** Current model not valid" << std::endl;
     3098#ifdef GENERAL_HANDLER_PRINTING
     3099                          sprintf(generalPrint, "** Current model not valid");
     3100                          printGeneralMessage(model_,generalPrint);
     3101#else
     3102                          std::cout << "** Current model not valid" << std::endl;
     3103#endif
    30883104#endif
    30893105                        }
     
    30923108                        if (goodModel) {
    30933109                            int numberInfeasibilities = lpSolver->tightenPrimalBounds();
    3094                             if (numberInfeasibilities)
    3095                                 std::cout << "** Analysis indicates model infeasible" << std::endl;
     3110                            if (numberInfeasibilities) {
     3111#ifdef GENERAL_HANDLER_PRINTING
     3112                              sprintf(generalPrint,"** Analysis indicates model infeasible");
     3113                              printGeneralMessage(model_,generalPrint);
     3114#else
     3115                              std::cout << "** Analysis indicates model infeasible" << std::endl;
     3116#endif
     3117                            }
    30963118                        } else {
    30973119#ifndef DISALLOW_PRINTING
    3098                             std::cout << "** Current model not valid" << std::endl;
     3120#ifdef GENERAL_HANDLER_PRINTING
     3121                          sprintf(generalPrint, "** Current model not valid");
     3122                          printGeneralMessage(model_,generalPrint);
     3123#else
     3124                          std::cout << "** Current model not valid" << std::endl;
     3125#endif
    30993126#endif
    31003127                        }
     
    31103137                                    lpSolver->replaceMatrix(newMatrix);
    31113138                                    delete saveMatrix;
     3139#ifdef GENERAL_HANDLER_PRINTING
     3140                                    sprintf(generalPrint, "Matrix converted to +- one matrix");
     3141                                    printGeneralMessage(model_,generalPrint);
     3142#else
    31123143                                    std::cout << "Matrix converted to +- one matrix" << std::endl;
     3144#endif
    31133145                                } else {
     3146#ifdef GENERAL_HANDLER_PRINTING
     3147                                  sprintf(generalPrint, "Matrix can not be converted to +- 1 matrix");
     3148                                  printGeneralMessage(model_,generalPrint);
     3149#else
    31143150                                    std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
     3151#endif
    31153152                                }
    31163153                            } else {
     3154#ifdef GENERAL_HANDLER_PRINTING
     3155                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3156                              printGeneralMessage(model_,generalPrint);
     3157#else
    31173158                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3159#endif
    31183160                            }
    31193161                        } else {
    31203162#ifndef DISALLOW_PRINTING
     3163#ifdef GENERAL_HANDLER_PRINTING
     3164                          sprintf(generalPrint, "** Current model not valid");
     3165                          printGeneralMessage(model_,generalPrint);
     3166#else
    31213167                            std::cout << "** Current model not valid" << std::endl;
     3168#endif
    31223169#endif
    31233170                        }
     
    31393186                        } else {
    31403187#ifndef DISALLOW_PRINTING
     3188#ifdef GENERAL_HANDLER_PRINTING
     3189                          sprintf(generalPrint, "** Current model not valid");
     3190                          printGeneralMessage(model_,generalPrint);
     3191#else
    31413192                            std::cout << "** Current model not valid" << std::endl;
     3193#endif
    31423194#endif
    31433195                        }
     
    31543206                                    lpSolver->replaceMatrix(newMatrix);
    31553207                                    delete saveMatrix;
     3208#ifdef GENERAL_HANDLER_PRINTING
     3209                                    sprintf(generalPrint, "Matrix converted to network matrix");
     3210                                    printGeneralMessage(model_,generalPrint);
     3211#else
    31563212                                    std::cout << "Matrix converted to network matrix" << std::endl;
     3213#endif
    31573214                                } else {
     3215#ifdef GENERAL_HANDLER_PRINTING
     3216                                  sprintf(generalPrint, "Matrix can not be converted to network matrix");
     3217                                  printGeneralMessage(model_,generalPrint);
     3218#else
    31583219                                    std::cout << "Matrix can not be converted to network matrix" << std::endl;
     3220#endif
    31593221                                }
    31603222                            } else {
     3223#ifdef GENERAL_HANDLER_PRINTING
     3224                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3225                              printGeneralMessage(model_,generalPrint);
     3226#else
    31613227                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3228#endif
    31623229                            }
    31633230                        } else {
    31643231#ifndef DISALLOW_PRINTING
     3232#ifdef GENERAL_HANDLER_PRINTING
     3233                          sprintf(generalPrint, "** Current model not valid");
     3234                          printGeneralMessage(model_,generalPrint);
     3235#else
    31653236                            std::cout << "** Current model not valid" << std::endl;
     3237#endif
    31663238#endif
    31673239                        }
     
    34523524                                            if (clpModel->tightenPrimalBounds() != 0) {
    34533525#ifndef DISALLOW_PRINTING
     3526#ifdef GENERAL_HANDLER_PRINTING
     3527                                              sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3528                                              printGeneralMessage(model_,generalPrint);
     3529#else
    34543530                                                std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
     3531#endif
    34553532#endif
    34563533                                                break;
     
    36243701                                if (!complicatedInteger && preProcess == 0 && clpSolver->tightenPrimalBounds(0.0, 0, true) != 0) {
    36253702#ifndef DISALLOW_PRINTING
     3703#ifdef GENERAL_HANDLER_PRINTING
     3704                                  sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3705                                  printGeneralMessage(model_,generalPrint);
     3706#else
    36263707                                    std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
     3708#endif
    36273709#endif
    36283710                                    model_.setProblemStatus(0);
     
    37293811                                    if (modelC->tightenPrimalBounds(tightenFactor) != 0) {
    37303812#ifndef DISALLOW_PRINTING
     3813#ifdef GENERAL_HANDLER_PRINTING
     3814                                      sprintf(generalPrint, "Problem is infeasible!");
     3815                                      printGeneralMessage(model_,generalPrint);
     3816#else
    37313817                                        std::cout << "Problem is infeasible!" << std::endl;
     3818#endif
    37323819#endif
    37333820                                        model_.setProblemStatus(0);
     
    43834470                                if (!complicatedInteger && modelC->tightenPrimalBounds() != 0) {
    43844471#ifndef DISALLOW_PRINTING
     4472#ifdef GENERAL_HANDLER_PRINTING
     4473                                  sprintf(generalPrint, "Problem is infeasible!");
     4474                                  printGeneralMessage(model_,generalPrint);
     4475#else
    43854476                                    std::cout << "Problem is infeasible!" << std::endl;
     4477#endif
    43864478#endif
    43874479                                    model_.setProblemStatus(0);
     
    70687160#endif
    70697161                            } else {
     7162#ifdef GENERAL_HANDLER_PRINTING
     7163                              sprintf(generalPrint, "Model strengthened - now has %d rows",
     7164                                      clpSolver->getNumRows());
     7165                              printGeneralMessage(model_,generalPrint);
     7166#else
    70707167                                std::cout << "Model strengthened - now has " << clpSolver->getNumRows()
    70717168                                          << " rows" << std::endl;
     7169#endif
    70727170                            }
    70737171                            time1 = time2;
     
    70867184                        } else {
    70877185#ifndef DISALLOW_PRINTING
     7186#ifdef GENERAL_HANDLER_PRINTING
     7187                          sprintf(generalPrint, "** Current model not valid");
     7188                          printGeneralMessage(model_,generalPrint);
     7189#else
    70887190                            std::cout << "** Current model not valid" << std::endl ;
     7191#endif
    70897192#endif
    70907193                        }
     
    72147317                                    } else {
    72157318                                        canOpen = false;
     7319#ifdef GENERAL_HANDLER_PRINTING
     7320                                        sprintf(generalPrint, "Unable to open file %s",gmplData.c_str());
     7321                                        printGeneralMessage(model_,generalPrint);
     7322#else
    72167323                                        std::cout << "Unable to open file " << gmplData << std::endl;
     7324#endif
    72177325                                    }
    72187326                                }
    72197327                            } else {
     7328#ifdef GENERAL_HANDLER_PRINTING
     7329                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7330                              printGeneralMessage(model_,generalPrint);
     7331#else
    72207332                                std::cout << "Unable to open file " << fileName << std::endl;
     7333#endif
    72217334                            }
    72227335                        }
     
    72857398                            } else {
    72867399                                // errors
     7400#ifdef GENERAL_HANDLER_PRINTING
     7401                              sprintf(generalPrint, "There were %d errors on input",status);
     7402                              printGeneralMessage(model_,generalPrint);
     7403#else
    72877404                                std::cout << "There were " << status <<
    72887405                                          " errors on input" << std::endl;
     7406#endif
    72897407                            }
    72907408                        }
     
    73437461                                    canOpen = true;
    73447462                                } else {
     7463#ifdef GENERAL_HANDLER_PRINTING
     7464                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7465                                  printGeneralMessage(model_,generalPrint);
     7466#else
    73457467                                    std::cout << "Unable to open file " << fileName << std::endl;
     7468#endif
    73467469                                }
    73477470                            }
     
    74127535                                canOpen = true;
    74137536                            } else {
     7537#ifdef GENERAL_HANDLER_PRINTING
     7538                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7539                                  printGeneralMessage(model_,generalPrint);
     7540#else
    74147541                                std::cout << "Unable to open file " << fileName << std::endl;
     7542#endif
    74157543                            }
    74167544                            if (canOpen) {
     
    75197647                        } else {
    75207648#ifndef DISALLOW_PRINTING
     7649#ifdef GENERAL_HANDLER_PRINTING
     7650                          sprintf(generalPrint, "** Current model not valid");
     7651                          printGeneralMessage(model_,generalPrint);
     7652#else
    75217653                            std::cout << "** Current model not valid" << std::endl;
     7654#endif
    75227655#endif
    75237656                        }
     
    75627695                                    canOpen = true;
    75637696                                } else {
     7697#ifdef GENERAL_HANDLER_PRINTING
     7698                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7699                                  printGeneralMessage(model_,generalPrint);
     7700#else
    75647701                                    std::cout << "Unable to open file " << fileName << std::endl;
     7702#endif
    75657703                                }
    75667704                            }
     
    75787716                        } else {
    75797717#ifndef DISALLOW_PRINTING
     7718#ifdef GENERAL_HANDLER_PRINTING
     7719                          sprintf(generalPrint, "** Current model not valid");
     7720                          printGeneralMessage(model_,generalPrint);
     7721#else
    75807722                            std::cout << "** Current model not valid" << std::endl;
     7723#endif
    75817724#endif
    75827725                        }
     
    78738016                                fclose(fp);
    78748017                            } else {
     8018#ifdef GENERAL_HANDLER_PRINTING
     8019                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8020                              printGeneralMessage(model_,generalPrint);
     8021#else
    78758022                                std::cout << "Unable to open file " << fileName << std::endl;
     8023#endif
    78768024                            }
    78778025                        } else {
    78788026#ifndef DISALLOW_PRINTING
     8027#ifdef GENERAL_HANDLER_PRINTING
     8028                          sprintf(generalPrint, "** Current model not valid");
     8029                          printGeneralMessage(model_,generalPrint);
     8030#else
    78798031                            std::cout << "** Current model not valid" << std::endl;
     8032#endif
    78808033#endif
    78818034                        }
     
    79248077                        } else {
    79258078#ifndef DISALLOW_PRINTING
     8079#ifdef GENERAL_HANDLER_PRINTING
     8080                          sprintf(generalPrint, "** Current model not valid");
     8081                          printGeneralMessage(model_,generalPrint);
     8082#else
    79268083                            std::cout << "** Current model not valid" << std::endl;
     8084#endif
    79278085#endif
    79288086                        }
     
    80018159                                fclose(fp);
    80028160                            } else {
     8161#ifdef GENERAL_HANDLER_PRINTING
     8162                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8163                              printGeneralMessage(model_,generalPrint);
     8164#else
    80038165                                std::cout << "Unable to open file " << fileName << std::endl;
     8166#endif
    80048167                            }
    80058168                        } else {
    80068169#ifndef DISALLOW_PRINTING
     8170#ifdef GENERAL_HANDLER_PRINTING
     8171                          sprintf(generalPrint, "** Current model not valid");
     8172                          printGeneralMessage(model_,generalPrint);
     8173#else
    80078174                            std::cout << "** Current model not valid" << std::endl;
     8175#endif
    80088176#endif
    80098177                        }
     
    80558223                                canOpen = true;
    80568224                            } else {
     8225#ifdef GENERAL_HANDLER_PRINTING
     8226                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8227                              printGeneralMessage(model_,generalPrint);
     8228#else
    80578229                                std::cout << "Unable to open file " << fileName << std::endl;
     8230#endif
    80588231                            }
    80598232                            if (canOpen) {
     
    80668239                        } else {
    80678240#ifndef DISALLOW_PRINTING
     8241#ifdef GENERAL_HANDLER_PRINTING
     8242                          sprintf(generalPrint, "** Current model not valid");
     8243                          printGeneralMessage(model_,generalPrint);
     8244#else
    80688245                            std::cout << "** Current model not valid" << std::endl;
     8246#endif
    80698247#endif
    80708248                        }
     
    81038281                            canOpen = true;
    81048282                        } else {
     8283#ifdef GENERAL_HANDLER_PRINTING
     8284                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8285                          printGeneralMessage(model_,generalPrint);
     8286#else
    81058287                            std::cout << "Unable to open file " << fileName << std::endl;
     8288#endif
    81068289                        }
    81078290                        if (canOpen) {
     
    81428325                            } else {
    81438326                                // errors
     8327#ifdef GENERAL_HANDLER_PRINTING
     8328                              sprintf(generalPrint, "There were errors on output");
     8329                              printGeneralMessage(model_,generalPrint);
     8330#else
    81448331                                std::cout << "There were errors on output" << std::endl;
     8332#endif
    81458333                            }
    81468334                        }
     
    81808368                            canOpen = true;
    81818369                        } else {
     8370#ifdef GENERAL_HANDLER_PRINTING
     8371                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8372                          printGeneralMessage(model_,generalPrint);
     8373#else
    81828374                            std::cout << "Unable to open file " << fileName << std::endl;
     8375#endif
    81838376                        }
    81848377                        if (canOpen) {
     
    81918384                            } else {
    81928385                                // errors
     8386#ifdef GENERAL_HANDLER_PRINTING
     8387                              sprintf(generalPrint, "There were errors on input");
     8388                              printGeneralMessage(model_,generalPrint);
     8389#else
    81938390                                std::cout << "There were errors on input" << std::endl;
     8391#endif
    81948392                            }
    81958393                        }
     
    83088506                            double value = CoinReadGetDoubleField(argc, argv, &valid);
    83098507                            if (!valid) {
     8508#ifdef GENERAL_HANDLER_PRINTING
     8509                              sprintf(generalPrint, "Setting %s to DEBUG %g",parameters_[iParam].name().c_str(),value);
     8510                              printGeneralMessage(model_,generalPrint);
     8511#else
    83108512                                std::cout << "Setting " << parameters_[iParam].name() <<
    83118513                                          " to DEBUG " << value << std::endl;
     8514#endif
    83128515                                int iRow;
    83138516                                int numberRows = lpSolver->numberRows();
     
    85468749                            fclose(fp);
    85478750                        } else {
     8751#ifdef GENERAL_HANDLER_PRINTING
     8752                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8753                          printGeneralMessage(model_,generalPrint);
     8754#else
    85488755                            std::cout << "Unable to open file " << fileName << std::endl;
     8756#endif
    85498757                        }
    85508758                    }
     
    92249432                                }
    92259433                            } else {
     9434#ifdef GENERAL_HANDLER_PRINTING
     9435                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     9436                              printGeneralMessage(model_,generalPrint);
     9437#else
    92269438                                std::cout << "Unable to open file " << fileName << std::endl;
     9439#endif
    92279440                            }
    92289441                        } else {
    92299442#ifndef DISALLOW_PRINTING
     9443#ifdef GENERAL_HANDLER_PRINTING
     9444                          sprintf(generalPrint, "** Current model not valid");
     9445                          printGeneralMessage(model_,generalPrint);
     9446#else
    92309447                            std::cout << "** Current model not valid" << std::endl;
     9448#endif
    92319449#endif
    92329450                        }
     
    92629480                        } else {
    92639481#ifndef DISALLOW_PRINTING
     9482#ifdef GENERAL_HANDLER_PRINTING
     9483                          sprintf(generalPrint, "** Current model not valid");
     9484                          printGeneralMessage(model_,generalPrint);
     9485#else
    92649486                            std::cout << "** Current model not valid" << std::endl;
     9487#endif
    92659488#endif
    92669489                        }
     
    93049527                               time1 = time2;
    93059528                          } else {
     9529#ifdef GENERAL_HANDLER_PRINTING
     9530                            sprintf(generalPrint, "** Current model not valid");
     9531                            printGeneralMessage(model_,generalPrint);
     9532#else
    93069533                               std::cout << "** Current model not valid" << std::endl;
     9534#endif
    93079535                          }
    93089536                          break;
     
    95549782    parameters[whichParam(CBC_PARAM_STR_FPUMP, numberParameters, parameters)].setCurrentOption("on");
    95559783    parameters[whichParam(CBC_PARAM_STR_GREEDY, numberParameters, parameters)].setCurrentOption("on");
    9556     parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("on");
     9784    parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("off");
    95579785    parameters[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters, parameters)].setCurrentOption("off");
    95589786    parameters[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters, parameters)].setCurrentOption("off");
     
    1009810326    printf("C++ file written to %s\n", fileName);
    1009910327}
     10328#ifdef GENERAL_HANDLER_PRINTING
     10329// Print a general message
     10330static void printGeneralMessage(CbcModel &model,const char * message)
     10331{
     10332  model.messageHandler()->message(CBC_FPUMP1, model.messages())
     10333    << message
     10334    << CoinMessageEol;
     10335}
     10336#endif
    1010010337/*
    1010110338  Version 1.00.00 November 16 2005.
Note: See TracChangeset for help on using the changeset viewer.