Changeset 2069


Ignore:
Timestamp:
Sep 1, 2014 4:01:07 AM (5 years ago)
Author:
forrest
Message:

change to printing

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcSolver.cpp

    r2058 r2069  
    12951295  return CbcMain1(argc,argv,model,callBack,staticParameterData);
    12961296}
     1297static void printGeneralMessage(CbcModel &model,const char * message);
    12971298/*
    12981299  Meaning of whereFrom:
     
    30523053#endif
    30533054                        } else {
    3054 #ifndef DISALLOW_PRINTING
    3055                             std::cout << "** Current model not valid" << std::endl;
    3056 #endif
     3055                          sprintf(generalPrint, "** Current model not valid");
     3056                          printGeneralMessage(model_,generalPrint);
    30573057                        }
    30583058                        break;
     
    30903090                                delete model2;
    30913091                        } else {
    3092 #ifndef DISALLOW_PRINTING
    3093                             std::cout << "** Current model not valid" << std::endl;
    3094 #endif
     3092                          sprintf(generalPrint, "** Current model not valid");
     3093                          printGeneralMessage(model_,generalPrint);
    30953094                        }
    30963095                        break;
     
    30983097                        if (goodModel) {
    30993098                            int numberInfeasibilities = lpSolver->tightenPrimalBounds();
    3100                             if (numberInfeasibilities)
    3101                                 std::cout << "** Analysis indicates model infeasible" << std::endl;
     3099                            if (numberInfeasibilities) {
     3100                              sprintf(generalPrint,"** Analysis indicates model infeasible");
     3101                              printGeneralMessage(model_,generalPrint);
     3102                            }
    31023103                        } else {
    3103 #ifndef DISALLOW_PRINTING
    3104                             std::cout << "** Current model not valid" << std::endl;
    3105 #endif
     3104                          sprintf(generalPrint, "** Current model not valid");
     3105                          printGeneralMessage(model_,generalPrint);
    31063106                        }
    31073107                        break;
     
    31163116                                    lpSolver->replaceMatrix(newMatrix);
    31173117                                    delete saveMatrix;
    3118                                     std::cout << "Matrix converted to +- one matrix" << std::endl;
     3118                                    sprintf(generalPrint, "Matrix converted to +- one matrix");
     3119                                    printGeneralMessage(model_,generalPrint);
    31193120                                } else {
    3120                                     std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
     3121                                  sprintf(generalPrint, "Matrix can not be converted to +- 1 matrix");
     3122                                  printGeneralMessage(model_,generalPrint);
    31213123                                }
    31223124                            } else {
    3123                                 std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3125                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3126                              printGeneralMessage(model_,generalPrint);
    31243127                            }
    31253128                        } else {
    3126 #ifndef DISALLOW_PRINTING
    3127                             std::cout << "** Current model not valid" << std::endl;
    3128 #endif
     3129                          sprintf(generalPrint, "** Current model not valid");
     3130                          printGeneralMessage(model_,generalPrint);
    31293131                        }
    31303132                        break;
     
    31443146                            << CoinMessageEol;
    31453147                        } else {
    3146 #ifndef DISALLOW_PRINTING
    3147                             std::cout << "** Current model not valid" << std::endl;
    3148 #endif
     3148                          sprintf(generalPrint, "** Current model not valid");
     3149                          printGeneralMessage(model_,generalPrint);
    31493150                        }
    31503151#endif
     
    31603161                                    lpSolver->replaceMatrix(newMatrix);
    31613162                                    delete saveMatrix;
    3162                                     std::cout << "Matrix converted to network matrix" << std::endl;
     3163                                    sprintf(generalPrint, "Matrix converted to network matrix");
     3164                                    printGeneralMessage(model_,generalPrint);
    31633165                                } else {
    3164                                     std::cout << "Matrix can not be converted to network matrix" << std::endl;
     3166                                  sprintf(generalPrint, "Matrix can not be converted to network matrix");
     3167                                  printGeneralMessage(model_,generalPrint);
    31653168                                }
    31663169                            } else {
    3167                                 std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3170                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3171                              printGeneralMessage(model_,generalPrint);
    31683172                            }
    31693173                        } else {
    3170 #ifndef DISALLOW_PRINTING
    3171                             std::cout << "** Current model not valid" << std::endl;
    3172 #endif
     3174                          sprintf(generalPrint, "** Current model not valid");
     3175                          printGeneralMessage(model_,generalPrint);
    31733176                        }
    31743177                        break;
     
    34733476                                            cbcModel->initialSolve();
    34743477                                            if (clpModel->tightenPrimalBounds() != 0) {
    3475 #ifndef DISALLOW_PRINTING
    3476                                                 std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
    3477 #endif
     3478                                              sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3479                                              printGeneralMessage(model_,generalPrint);
    34783480                                                break;
    34793481                                            }
     
    36453647#ifndef CBC_OTHER_SOLVER
    36463648                                if (!complicatedInteger && preProcess == 0 && clpSolver->tightenPrimalBounds(0.0, 0, true) != 0) {
    3647 #ifndef DISALLOW_PRINTING
    3648                                     std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
    3649 #endif
     3649                                  sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3650                                  printGeneralMessage(model_,generalPrint);
    36503651                                    model_.setProblemStatus(0);
    36513652                                    model_.setSecondaryStatus(1);
     
    37523753                                if (tightenFactor && !complicatedInteger) {
    37533754                                    if (modelC->tightenPrimalBounds(tightenFactor) != 0) {
    3754 #ifndef DISALLOW_PRINTING
    3755                                         std::cout << "Problem is infeasible!" << std::endl;
    3756 #endif
     3755                                      sprintf(generalPrint, "Problem is infeasible!");
     3756                                      printGeneralMessage(model_,generalPrint);
    37573757                                        model_.setProblemStatus(0);
    37583758                                        model_.setSecondaryStatus(1);
     
    45994599                                //modelC->setLogLevel(0);
    46004600                                if (!complicatedInteger && modelC->tightenPrimalBounds() != 0) {
    4601 #ifndef DISALLOW_PRINTING
    4602                                     std::cout << "Problem is infeasible!" << std::endl;
    4603 #endif
     4601                                  sprintf(generalPrint, "Problem is infeasible!");
     4602                                  printGeneralMessage(model_,generalPrint);
    46044603                                    model_.setProblemStatus(0);
    46054604                                    model_.setSecondaryStatus(1);
     
    73997398#endif
    74007399                            } else {
    7401                                 std::cout << "Model strengthened - now has " << clpSolver->getNumRows()
    7402                                           << " rows" << std::endl;
     7400                              sprintf(generalPrint, "Model strengthened - now has %d rows",
     7401                                      clpSolver->getNumRows());
     7402                              printGeneralMessage(model_,generalPrint);
    74037403                            }
    74047404                            time1 = time2;
     
    74167416                            //babModel_=NULL;
    74177417                        } else {
    7418 #ifndef DISALLOW_PRINTING
    7419                             std::cout << "** Current model not valid" << std::endl ;
    7420 #endif
     7418                          sprintf(generalPrint, "** Current model not valid");
     7419                          printGeneralMessage(model_,generalPrint);
    74217420                        }
    74227421                        break ;
     
    75457544                                    } else {
    75467545                                        canOpen = false;
    7547                                         std::cout << "Unable to open file " << gmplData << std::endl;
     7546                                        sprintf(generalPrint, "Unable to open file %s",gmplData.c_str());
     7547                                        printGeneralMessage(model_,generalPrint);
    75487548                                    }
    75497549                                }
    75507550                            } else {
    7551                                 std::cout << "Unable to open file " << fileName << std::endl;
     7551                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7552                              printGeneralMessage(model_,generalPrint);
    75527553                            }
    75537554                        }
     
    76167617                            } else {
    76177618                                // errors
    7618                                 std::cout << "There were " << status <<
    7619                                           " errors on input" << std::endl;
     7619                              sprintf(generalPrint, "There were %d errors on input",status);
     7620                              printGeneralMessage(model_,generalPrint);
    76207621                            }
    76217622                        }
     
    76747675                                    canOpen = true;
    76757676                                } else {
    7676                                     std::cout << "Unable to open file " << fileName << std::endl;
     7677                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7678                                  printGeneralMessage(model_,generalPrint);
    76777679                                }
    76787680                            }
     
    77437745                                canOpen = true;
    77447746                            } else {
    7745                                 std::cout << "Unable to open file " << fileName << std::endl;
     7747                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7748                                  printGeneralMessage(model_,generalPrint);
    77467749                            }
    77477750                            if (canOpen) {
     
    78497852                            }
    78507853                        } else {
    7851 #ifndef DISALLOW_PRINTING
    7852                             std::cout << "** Current model not valid" << std::endl;
    7853 #endif
     7854                          sprintf(generalPrint, "** Current model not valid");
     7855                          printGeneralMessage(model_,generalPrint);
    78547856                        }
    78557857                        break;
     
    78937895                                    canOpen = true;
    78947896                                } else {
    7895                                     std::cout << "Unable to open file " << fileName << std::endl;
     7897                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7898                                  printGeneralMessage(model_,generalPrint);
    78967899                                }
    78977900                            }
     
    79087911                            }
    79097912                        } else {
    7910 #ifndef DISALLOW_PRINTING
    7911                             std::cout << "** Current model not valid" << std::endl;
    7912 #endif
     7913                          sprintf(generalPrint, "** Current model not valid");
     7914                          printGeneralMessage(model_,generalPrint);
    79137915                        }
    79147916                        break;
     
    82048206                                fclose(fp);
    82058207                            } else {
    8206                                 std::cout << "Unable to open file " << fileName << std::endl;
     8208                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8209                              printGeneralMessage(model_,generalPrint);
    82078210                            }
    82088211                        } else {
    8209 #ifndef DISALLOW_PRINTING
    8210                             std::cout << "** Current model not valid" << std::endl;
    8211 #endif
     8212                          sprintf(generalPrint, "** Current model not valid");
     8213                          printGeneralMessage(model_,generalPrint);
    82128214                        }
    82138215                        break;
     
    82548256                            }
    82558257                        } else {
    8256 #ifndef DISALLOW_PRINTING
    8257                             std::cout << "** Current model not valid" << std::endl;
    8258 #endif
     8258                          sprintf(generalPrint, "** Current model not valid");
     8259                          printGeneralMessage(model_,generalPrint);
    82598260                        }
    82608261                        break;
     
    83328333                                fclose(fp);
    83338334                            } else {
    8334                                 std::cout << "Unable to open file " << fileName << std::endl;
     8335                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8336                              printGeneralMessage(model_,generalPrint);
    83358337                            }
    83368338                        } else {
    8337 #ifndef DISALLOW_PRINTING
    8338                             std::cout << "** Current model not valid" << std::endl;
    8339 #endif
     8339                          sprintf(generalPrint, "** Current model not valid");
     8340                          printGeneralMessage(model_,generalPrint);
    83408341                        }
    83418342                        break;
     
    83868387                                canOpen = true;
    83878388                            } else {
    8388                                 std::cout << "Unable to open file " << fileName << std::endl;
     8389                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8390                              printGeneralMessage(model_,generalPrint);
    83898391                            }
    83908392                            if (canOpen) {
     
    83968398                            }
    83978399                        } else {
    8398 #ifndef DISALLOW_PRINTING
    8399                             std::cout << "** Current model not valid" << std::endl;
    8400 #endif
     8400                          sprintf(generalPrint, "** Current model not valid");
     8401                          printGeneralMessage(model_,generalPrint);
    84018402                        }
    84028403                        break;
     
    84348435                            canOpen = true;
    84358436                        } else {
    8436                             std::cout << "Unable to open file " << fileName << std::endl;
     8437                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8438                          printGeneralMessage(model_,generalPrint);
    84378439                        }
    84388440                        if (canOpen) {
     
    84738475                            } else {
    84748476                                // errors
    8475                                 std::cout << "There were errors on output" << std::endl;
     8477                              sprintf(generalPrint, "There were errors on output");
     8478                              printGeneralMessage(model_,generalPrint);
    84768479                            }
    84778480                        }
     
    85118514                            canOpen = true;
    85128515                        } else {
    8513                             std::cout << "Unable to open file " << fileName << std::endl;
     8516                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8517                          printGeneralMessage(model_,generalPrint);
    85148518                        }
    85158519                        if (canOpen) {
     
    85228526                            } else {
    85238527                                // errors
    8524                                 std::cout << "There were errors on input" << std::endl;
     8528                              sprintf(generalPrint, "There were errors on input");
     8529                              printGeneralMessage(model_,generalPrint);
    85258530                            }
    85268531                        }
     
    86398644                            double value = CoinReadGetDoubleField(argc, argv, &valid);
    86408645                            if (!valid) {
    8641                                 std::cout << "Setting " << parameters_[iParam].name() <<
    8642                                           " to DEBUG " << value << std::endl;
     8646                              sprintf(generalPrint, "Setting %s to DEBUG %g",parameters_[iParam].name().c_str(),value);
     8647                              printGeneralMessage(model_,generalPrint);
    86438648                                int iRow;
    86448649                                int numberRows = lpSolver->numberRows();
     
    88778882                            fclose(fp);
    88788883                        } else {
    8879                             std::cout << "Unable to open file " << fileName << std::endl;
     8884                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8885                          printGeneralMessage(model_,generalPrint);
    88808886                        }
    88818887                    }
     
    95579563                                }
    95589564                            } else {
    9559                                 std::cout << "Unable to open file " << fileName << std::endl;
     9565                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     9566                              printGeneralMessage(model_,generalPrint);
    95609567                            }
    95619568                        } else {
    9562 #ifndef DISALLOW_PRINTING
    9563                             std::cout << "** Current model not valid" << std::endl;
    9564 #endif
     9569                          sprintf(generalPrint, "** Current model not valid");
     9570                          printGeneralMessage(model_,generalPrint);
    95659571                        }
    95669572                        break;
     
    95949600                            saveSolution(lpSolver, fileName);
    95959601                        } else {
    9596 #ifndef DISALLOW_PRINTING
    9597                             std::cout << "** Current model not valid" << std::endl;
    9598 #endif
     9602                          sprintf(generalPrint, "** Current model not valid");
     9603                          printGeneralMessage(model_,generalPrint);
    95999604                        }
    96009605                        break;
     
    96379642                               time1 = time2;
    96389643                          } else {
    9639                                std::cout << "** Current model not valid" << std::endl;
     9644                            sprintf(generalPrint, "** Current model not valid");
     9645                            printGeneralMessage(model_,generalPrint);
    96409646                          }
    96419647                          break;
     
    1159411600    printf("C++ file written to %s\n", fileName);
    1159511601}
     11602// Print a general message
     11603static void printGeneralMessage(CbcModel &model,const char * message)
     11604{
     11605#ifndef DISALLOW_PRINTING
     11606  model.messageHandler()->message(CBC_FPUMP1, model.messages())
     11607    << message
     11608    << CoinMessageEol;
     11609#endif
     11610}
    1159611611/*
    1159711612  Version 1.00.00 November 16 2005.
Note: See TracChangeset for help on using the changeset viewer.