Ignore:
File:
1 edited

Legend:

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

    r1908 r2004  
    809809#endif
    810810
    811 static double totalTime = 0.0;
    812811static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
    813812static bool maskMatches(const int * starts, char ** masks,
     
    970969FILE * CbcOrClpReadCommand = stdin;
    971970extern int CbcOrClpEnvironmentIndex;
    972 static bool noPrinting = false;
    973 
    974 
     971
     972int callCbc1(const char * input2, CbcModel & model,
     973             int callBack(CbcModel * currentSolver, int whereFrom),
     974             CbcSolverUsefulData & parameterData);
    975975
    976976/*
     
    10251025int callCbc(const char * input2, CbcModel & babSolver)
    10261026{
    1027     CbcMain0(babSolver);
    1028     return callCbc1(input2, babSolver);
     1027  CbcSolverUsefulData data;
     1028#ifndef CBC_NO_INTERRUPT
     1029    data.useSignalHandler_=true;
     1030#endif
     1031#ifndef CBC_NO_PRINTING
     1032    data.noPrinting_ = false;
     1033#endif
     1034  CbcMain0(babSolver, data);
     1035  return callCbc1(input2, babSolver, dummyCallBack, data);
    10291036}
    10301037
     
    10691076    return returnCode;
    10701077}
    1071 
    10721078int callCbc1(const char * input2, CbcModel & model,
    1073              int callBack(CbcModel * currentSolver, int whereFrom))
     1079             int callBack(CbcModel * currentSolver, int whereFrom),
     1080             CbcSolverUsefulData & parameterData)
    10741081{
    10751082    char * input = CoinStrdup(input2);
     
    11171124    argv[n+1] = CoinStrdup("-quit");
    11181125    free(input);
    1119     totalTime = 0.0;
    11201126    currentBranchModel = NULL;
    11211127    CbcOrClpRead_mode = 1;
    11221128    CbcOrClpReadCommand = stdin;
    1123     noPrinting = false;
    11241129    int returnCode = CbcMain1(n + 2, const_cast<const char **>(argv),
    1125                               model, callBack);
     1130                              model, callBack,parameterData);
    11261131    for (int k = 0; k < n + 2; k++)
    11271132        free(argv[k]);
     
    11291134    return returnCode;
    11301135}
    1131 
    1132 static CbcOrClpParam parameters[CBCMAXPARAMETERS];
    1133 static int numberParameters = 0 ;
     1136static CbcSolverUsefulData staticParameterData;
     1137int callCbc1(const char * input2, CbcModel & model,
     1138             int callBack(CbcModel * currentSolver, int whereFrom))
     1139{
     1140  // allow interrupts and printing
     1141#ifndef CBC_NO_INTERRUPT
     1142  staticParameterData.useSignalHandler_=true;
     1143#endif
     1144#ifndef CBC_NO_PRINTING
     1145  staticParameterData.noPrinting_ = false;
     1146#endif
     1147  return callCbc1(input2,model,callBack,staticParameterData);
     1148}
     1149
    11341150CglPreProcess * cbcPreProcessPointer=NULL;
    11351151
     
    11431159    return CbcMain1(argc, argv, model, dummyCallBack);
    11441160}
    1145 
    1146 
     1161#ifdef CBC_THREAD_SAFE
     1162// Copies of some input decoding
     1163
     1164static std::string
     1165CoinReadGetCommand(int &whichArgument, int argc, const char *argv[])
     1166{
     1167  std::string field;
     1168  if (whichArgument < argc)
     1169    field = argv[whichArgument++];
     1170  else
     1171    field = "quit";
     1172  if (field[0] == '-')
     1173    field = field.substr(1);
     1174  return field;
     1175}
     1176static std::string
     1177CoinReadGetString(int &whichArgument, int argc, const char *argv[])
     1178{
     1179  std::string field;
     1180  if (whichArgument < argc)
     1181    field = argv[whichArgument++];
     1182  else
     1183    field = "";
     1184  return field;
     1185}
     1186// valid 0 - okay, 1 bad, 2 not there
     1187static int
     1188CoinReadGetIntField(int &whichArgument, int argc, const char *argv[], int * valid)
     1189{
     1190  std::string field;
     1191  if (whichArgument < argc)
     1192    field = argv[whichArgument++];
     1193  else
     1194    field = "0";
     1195  long int value = 0;
     1196  const char * start = field.c_str();
     1197  char * endPointer = NULL;
     1198  // check valid
     1199  value =  strtol(start, &endPointer, 10);
     1200  if (*endPointer == '\0') {
     1201    *valid = 0;
     1202  } else {
     1203    *valid = 1;
     1204    std::cout << "String of " << field;
     1205  }
     1206  return static_cast<int>(value);
     1207}
     1208static double
     1209CoinReadGetDoubleField(int &whichArgument, int argc, const char *argv[], int * valid)
     1210{
     1211  std::string field;
     1212  if (whichArgument < argc)
     1213    field = argv[whichArgument++];
     1214  else
     1215    field = "0.0";
     1216  double value = 0.0;
     1217  const char * start = field.c_str();
     1218  char * endPointer = NULL;
     1219  // check valid
     1220  value =  strtod(start, &endPointer);
     1221  if (*endPointer == '\0') {
     1222    *valid = 0;
     1223  } else {
     1224    *valid = 1;
     1225    std::cout << "String of " << field;
     1226  }
     1227  return value;
     1228}
     1229// Redefine all
     1230#define CoinReadGetCommand(x,y) CoinReadGetCommand(whichArgument,x,y)
     1231#define CoinReadGetString(x,y) CoinReadGetString(whichArgument,x,y)
     1232#define CoinReadGetIntField(x,y,z) CoinReadGetIntField(whichArgument,x,y,z)
     1233#define CoinReadGetDoubleField(x,y,z) CoinReadGetDoubleField(whichArgument,x,y,z)
     1234#endif
     1235// Default Constructor
     1236CbcSolverUsefulData::CbcSolverUsefulData()
     1237{
     1238  totalTime_ = 0.0;
     1239  noPrinting_ = true;
     1240  useSignalHandler_ = false;
     1241  establishParams(numberParameters_,parameters_);
     1242}
     1243
     1244/* Copy constructor .
     1245 */
     1246CbcSolverUsefulData::CbcSolverUsefulData(const CbcSolverUsefulData & rhs)
     1247{
     1248  totalTime_ = rhs.totalTime_;
     1249  noPrinting_ = rhs.noPrinting_;
     1250  useSignalHandler_ = rhs.useSignalHandler_;
     1251  numberParameters_ = rhs.numberParameters_;
     1252  memcpy(parameters_,rhs.parameters_,sizeof(parameters_));
     1253}
     1254
     1255// Assignment operator
     1256CbcSolverUsefulData & CbcSolverUsefulData::operator=(const CbcSolverUsefulData& rhs)
     1257{
     1258  if (this != &rhs) {
     1259    totalTime_ = rhs.totalTime_;
     1260    noPrinting_ = rhs.noPrinting_;
     1261    useSignalHandler_ = rhs.useSignalHandler_;
     1262    numberParameters_ = rhs.numberParameters_;
     1263    memcpy(parameters_,rhs.parameters_,sizeof(parameters_));
     1264  }
     1265  return *this;
     1266}
     1267
     1268// Destructor
     1269CbcSolverUsefulData::~CbcSolverUsefulData ()
     1270{
     1271}
    11471272/*
    11481273  Meaning of whereFrom:
     
    11591284              int callBack(CbcModel * currentSolver, int whereFrom))
    11601285{
    1161     CbcOrClpParam * parameters_ = parameters;
    1162     int numberParameters_ = numberParameters;
     1286  // allow interrupts and printing
     1287  staticParameterData.noPrinting_ = false;
     1288  staticParameterData.useSignalHandler_=true;
     1289  return CbcMain1(argc,argv,model,callBack,staticParameterData);
     1290}
     1291/*
     1292  Meaning of whereFrom:
     1293    1 after initial solve by dualsimplex etc
     1294    2 after preprocessing
     1295    3 just before branchAndBound (so user can override)
     1296    4 just after branchAndBound (before postprocessing)
     1297    5 after postprocessing
     1298    6 after a user called heuristic phase
     1299*/
     1300int CbcMain1 (int argc, const char *argv[],
     1301              CbcModel  & model,
     1302              int callBack(CbcModel * currentSolver, int whereFrom),
     1303              CbcSolverUsefulData & parameterData)
     1304{
     1305    CbcOrClpParam * parameters_ = parameterData.parameters_;
     1306    int numberParameters_ = parameterData.numberParameters_;
     1307    double totalTime = parameterData.totalTime_;
     1308    bool noPrinting = parameterData.noPrinting_;
     1309    bool useSignalHandler = parameterData.useSignalHandler_;
    11631310    CbcModel & model_ = model;
     1311#ifdef CBC_THREAD_SAFE
     1312    // Initialize argument
     1313    int whichArgument=1;
     1314#endif
    11641315#ifdef CBC_USE_INITIAL_TIME
    11651316    if (model_.useElapsedTime())
     
    12451396        //CoinSighandler_t saveSignal=signal(SIGINT,signal_handler);
    12461397#if CBC_QUIET < 2
    1247         signal(SIGINT, signal_handler);
     1398        if (useSignalHandler)
     1399          signal(SIGINT, signal_handler);
    12481400#endif
    12491401        // Set up all non-standard stuff
     
    21052257                                  addFlags = 1048576*(value/10);
    21062258                                  value = value % 10;
    2107                                   parameters[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters, parameters)].setIntValue(value);
     2259                                  parameters_[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters_, parameters_)].setIntValue(value);
    21082260                                }
    21092261                                if (value >= 1) {
     
    21172269                                    }
    21182270                                    int extra4 = values[value-1]+addFlags;
    2119                                     parameters[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters, parameters)].setIntValue(extra4);
     2271                                    parameters_[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters_, parameters_)].setIntValue(extra4);
    21202272                                    if (!noPrinting_) {
    21212273                                        generalMessageHandler->message(CLP_GENERAL, generalMessages)
     
    21302282                                        << CoinMessageEol;
    21312283                                    }
    2132                                     parameters[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters, parameters)].setCurrentOption("forceOnStrong");
     2284                                    parameters_[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption("forceOnStrong");
    21332285                                    probingAction = 8;
    21342286                                    parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
     
    21392291                                    lpSolver->factorization()->forceOtherFactorization(3);
    21402292                                    parameters_[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
    2141                                     parameters[whichParam(CBC_PARAM_INT_CUTPASS, numberParameters, parameters)].setIntValue(1000);
     2293                                    parameters_[whichParam(CBC_PARAM_INT_CUTPASS, numberParameters_, parameters_)].setIntValue(1000);
    21422294                                    cutPass = 1000;
    2143                                     parameters[whichParam(CBC_PARAM_STR_RENS, numberParameters, parameters)].setCurrentOption("on");
     2295                                    parameters_[whichParam(CBC_PARAM_STR_RENS, numberParameters_, parameters_)].setCurrentOption("on");
    21442296                                }
    21452297                            } else if (parameters_[iParam].type() == CBC_PARAM_INT_STRATEGY) {
     
    39524104                                if (preProcess == 2) {
    39534105                                    OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (solver2);
    3954                                     ClpSimplex * lpSolver = clpSolver2->getModelPtr();
     4106#if 1
     4107                                    ClpSimplex * lpSolver =
     4108                                      clpSolver2->getModelPtr();
    39554109                                    lpSolver->writeMps("presolved.mps", 0, 1, lpSolver->optimizationDirection());
     4110#else
     4111                                    // put back names
     4112                                    ClpSimplex lpSolver(*clpSolver2->getModelPtr());
     4113                                    //OsiClpSolverInterface * originalSolver = dynamic_cast< OsiClpSolverInterface*> (olver);
     4114                                    ClpSimplex * originalLp = clpSolver->getModelPtr();
     4115                                    const int * originalColumns = process.originalColumns();
     4116                                    int numberColumns = lpSolver.getNumCols();
     4117                                    for (int i = 0; i < numberColumns; i++) {
     4118                                      int jColumn = originalColumns[i];
     4119                                      std::string name = originalLp->getColumnName(jColumn);
     4120                                      lpSolver.setColumnName(i,name);
     4121                                    }
     4122                                    lpSolver.writeMps("presolved.mps", 0, 1, lpSolver.optimizationDirection());
     4123#endif
    39564124                                    printf("Preprocessed model (minimization) on presolved.mps\n");
    39574125                                }
     
    87608928                                    break;
    87618929                                  }
    8762                                   if (lengthName)
     8930                                  if (printMode<9) {
     8931                                    if (lengthName)
    87638932                                    fprintf(fp,",name");
    8764                                   fprintf(fp,",increase,variable,decrease,variable\n");
     8933                                    fprintf(fp,",increase,variable,decrease,variable\n");
     8934                                  }
    87658935                                  int * which = new int [ number];
    87668936                                  if (printMode != 7) {
     
    90969266                               field = CoinReadGetString(argc, argv);
    90979267                               if (field == "$") {
    9098                                     field = parameters[iParam].stringValue();
     9268                                    field = parameters_[iParam].stringValue();
    90999269                               } else if (field == "EOL") {
    9100                                     parameters[iParam].printString();
     9270                                    parameters_[iParam].printString();
    91019271                                    break;
    91029272                               } else {
    9103                                     parameters[iParam].setStringValue(field);
     9273                                    parameters_[iParam].setStringValue(field);
    91049274                               }
    91059275                               std::string fileName;
     
    92329402}
    92339403
    9234 
    92359404void CbcMain0 (CbcModel  & model)
    92369405{
     9406  CbcMain0(model,staticParameterData);
     9407}
     9408void CbcMain0 (CbcModel  & model,
     9409               CbcSolverUsefulData & parameterData)
     9410{
     9411    CbcOrClpParam * parameters = parameterData.parameters_;
     9412    int numberParameters = parameterData.numberParameters_;
    92379413#ifndef CBC_OTHER_SOLVER
    92389414    OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     
    92549430    lpSolver->messageHandler()->setPrefix(false);
    92559431#endif
    9256     establishParams(numberParameters, parameters) ;
     9432    //establishParams(numberParameters, parameters) ;
    92579433    const char dirsep =  CoinFindDirSeparator();
    92589434    std::string directory;
Note: See TracChangeset for help on using the changeset viewer.