Ignore:
Timestamp:
Sep 21, 2007 4:43:51 PM (13 years ago)
Author:
forrest
Message:

trying to move ampl stuff away

File:
1 edited

Legend:

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

    r781 r789  
    103103#include "OsiColCut.hpp"
    104104#ifndef COIN_HAS_LINK
    105 //#ifdef COIN_HAS_ASL
    106105#define COIN_HAS_LINK
    107 //#endif
    108106#endif
    109107#ifdef COIN_HAS_LINK
     
    141139
    142140#include "OsiClpSolverInterface.hpp"
    143 //#define NEW_STYLE_SOLVER
    144 #ifdef NEW_STYLE_SOLVER
    145141#include "CbcSolver.hpp"
    146142CbcSolver::CbcSolver()
    147143  : babModel_(NULL),
    148144    userFunction_(NULL),
     145    statusUserFunction_(NULL),
     146    originalSolver_(NULL),
     147    originalCoinModel_(NULL),
     148    cutGenerator_(NULL),
    149149    numberUserFunctions_(0),
     150    numberCutGenerators_(0),
    150151    startTime_(CoinCpuTime()),
    151152    parameters_(NULL),
    152153    numberParameters_(0),
    153154    doMiplib_(false),
    154     noPrinting_(false)
     155    noPrinting_(false),
     156    readMode_(1)
    155157{
    156158  callBack_ = new CbcStopNow();
     
    160162  : babModel_(NULL),
    161163    userFunction_(NULL),
     164    statusUserFunction_(NULL),
     165    originalSolver_(NULL),
     166    originalCoinModel_(NULL),
     167    cutGenerator_(NULL),
    162168    numberUserFunctions_(0),
     169    numberCutGenerators_(0),
    163170    startTime_(CoinCpuTime()),
    164171    parameters_(NULL),
    165172    numberParameters_(0),
    166173    doMiplib_(false),
    167     noPrinting_(false)
     174    noPrinting_(false),
     175    readMode_(1)
    168176{
    169177  callBack_ = new CbcStopNow();
     
    174182  : babModel_(NULL),
    175183    userFunction_(NULL),
     184    statusUserFunction_(NULL),
     185    originalSolver_(NULL),
     186    originalCoinModel_(NULL),
     187    cutGenerator_(NULL),
    176188    numberUserFunctions_(0),
     189    numberCutGenerators_(0),
    177190    startTime_(CoinCpuTime()),
    178191    parameters_(NULL),
    179192    numberParameters_(0),
    180193    doMiplib_(false),
    181     noPrinting_(false)
     194    noPrinting_(false),
     195    readMode_(1)
    182196{
    183197  callBack_ = new CbcStopNow();
     
    191205    delete userFunction_[i];
    192206  delete [] userFunction_;
     207  for (i=0;i<numberCutGenerators_;i++)
     208    delete cutGenerator_[i];
     209  delete [] cutGenerator_;
     210  delete [] statusUserFunction_;
     211  delete originalSolver_;
     212  delete originalCoinModel_;
    193213  delete babModel_;
    194214  delete [] parameters_;
     
    200220    babModel_(NULL),
    201221    userFunction_(NULL),
     222    statusUserFunction_(NULL),
    202223    numberUserFunctions_(rhs.numberUserFunctions_),
    203224    startTime_(CoinCpuTime()),
     
    205226    numberParameters_(rhs.numberParameters_),
    206227    doMiplib_(rhs.doMiplib_),
    207     noPrinting_(rhs.noPrinting_)
     228    noPrinting_(rhs.noPrinting_),
     229    readMode_(rhs.readMode_)
    208230{
    209231  fillParameters();
     
    216238  for (i=0;i<numberParameters_;i++)
    217239    parameters_[i]=rhs.parameters_[i];
     240  for (i=0;i<numberCutGenerators_;i++)
     241    cutGenerator_[i] = rhs.cutGenerator_[i]->clone();
    218242  callBack_ = rhs.callBack_->clone();
     243  originalSolver_ = NULL;
     244  if (rhs.originalSolver_) {
     245    OsiSolverInterface * temp = rhs.originalSolver_->clone();
     246    originalSolver_ = dynamic_cast<OsiClpSolverInterface *> (temp);
     247    assert (originalSolver_);
     248  }
     249  originalCoinModel_ = NULL;
     250  if (rhs.originalCoinModel_)
     251    originalCoinModel_ = new CoinModel(*rhs.originalCoinModel_);
    219252}
    220253// Assignment operator
     
    227260      delete userFunction_[i];
    228261    delete [] userFunction_;
     262    for (i=0;i<numberCutGenerators_;i++)
     263      delete cutGenerator_[i];
     264    delete [] cutGenerator_;
     265    delete [] statusUserFunction_;
     266    delete originalSolver_;
     267    delete originalCoinModel_;
     268    statusUserFunction_ = NULL;
    229269    delete babModel_;
    230270    delete [] parameters_;
     
    235275    for (i=0;i<numberParameters_;i++)
    236276      parameters_[i]=rhs.parameters_[i];
     277    for (i=0;i<numberCutGenerators_;i++)
     278      cutGenerator_[i] = rhs.cutGenerator_[i]->clone();
    237279    noPrinting_ = rhs.noPrinting_;
     280    readMode_ = rhs.readMode_;
    238281    doMiplib_ = rhs.doMiplib_;
    239282    model_ = rhs.model_;
     
    246289      userFunction_[i] = rhs.userFunction_[i]->clone();
    247290    callBack_ = rhs.callBack_->clone();
     291    originalSolver_ = NULL;
     292    if (rhs.originalSolver_) {
     293      OsiSolverInterface * temp = rhs.originalSolver_->clone();
     294      originalSolver_ = dynamic_cast<OsiClpSolverInterface *> (temp);
     295    assert (originalSolver_);
     296    }
     297    originalCoinModel_ = NULL;
     298    if (rhs.originalCoinModel_)
     299      originalCoinModel_ = new CoinModel(*rhs.originalCoinModel_);
    248300}
    249301  return *this;
     
    325377  int outputFormat=2;
    326378  int substitution=3;
    327   int dualize=0;
     379  int dualize=3;
    328380  int preSolve=5;
    329381  int doSprint=-1;
     
    456508  parameters_[whichParam(INCREMENT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
    457509}
     510// Add user function
     511void
     512CbcSolver::addUserFunction(CbcUser * function)
     513{
     514  CbcUser ** temp = new CbcUser * [numberUserFunctions_+1];
     515  int i;
     516  for (i=0;i<numberUserFunctions_;i++)
     517    temp[i]=userFunction_[i];
     518  delete [] userFunction_;
     519  userFunction_ = temp;
     520  userFunction_[numberUserFunctions_++] = function->clone();
     521  delete [] statusUserFunction_;
     522  statusUserFunction_ = NULL;
     523}
     524// Set user call back
     525void
     526CbcSolver::setUserCallBack(CbcStopNow * function)
     527{
     528  delete callBack_;
     529  callBack_ = function->clone();
     530}
     531// Copy of model on initial load (will contain output solutions)
     532void
     533CbcSolver::setOriginalSolver(OsiClpSolverInterface * originalSolver)
     534{
     535  delete originalSolver_;
     536  OsiSolverInterface * temp = originalSolver->clone();
     537  originalSolver_ = dynamic_cast<OsiClpSolverInterface *> (temp);
     538  assert (originalSolver_);
     539 
     540}
     541// Copy of model on initial load
     542void
     543CbcSolver::setOriginalCoinModel(CoinModel * originalCoinModel)
     544{
     545  delete originalCoinModel_;
     546  originalCoinModel_ = new CoinModel(*originalCoinModel);
     547}
     548// Add cut generator
     549void
     550CbcSolver::addCutGenerator(CglCutGenerator * generator)
     551{
     552  CglCutGenerator ** temp = new CglCutGenerator * [numberCutGenerators_+1];
     553  int i;
     554  for (i=0;i<numberCutGenerators_;i++)
     555    temp[i]=cutGenerator_[i];
     556  delete [] cutGenerator_;
     557  cutGenerator_ = temp;
     558  cutGenerator_[numberCutGenerators_++] = generator->clone();
     559}
    458560// User stuff (base class)
    459561CbcUser::CbcUser()
     
    492594   0 model and solver untouched - babModel updated
    493595   1 model updated - just with solution basis etc
    494    2 model updated i.e. as babModel (babModel NULL)
     596   2 model updated i.e. as babModel (babModel NULL) (only use without preprocessing!)
    495597*/
    496598void
     
    573675    }
    574676    clpSolver->setWarmStart(NULL); // synchronize bases
     677    if (originalSolver_) {
     678      ClpSimplex * lpSolver2 = originalSolver_->getModelPtr();
     679      assert (model2!=lpSolver2);
     680      lpSolver2->moveInfo(*model2);
     681      originalSolver_->setWarmStart(NULL); // synchronize bases
     682    }
    575683  } else if (returnMode==1) {
    576684    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
     
    583691      OsiClpSolverInterface * clpSolver1 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    584692      ClpSimplex * lpSolver1 = clpSolver1->getModelPtr();
    585       if (lpSolver1!=lpSolver) {
     693      if (lpSolver1!=lpSolver&&model_.bestSolution()) {
    586694        lpSolver->moveInfo(*lpSolver1);
    587695      }
     
    593701    babModel_=NULL;
    594702  }
    595 }
    596 // Clone
    597 CbcUser *
    598 CbcUser::clone() const
    599 {
    600   return new CbcUser(*this);
    601703}
    602704// Stop now stuff (base class)
     
    625727  return new CbcStopNow(*this);
    626728}
    627 #endif
     729//#define NEW_STYLE_SOLVER
     730#undef COIN_HAS_ASL
    628731#ifdef COIN_HAS_ASL
    629732#include "Cbc_ampl.h"
    630 static bool usingAmpl=false;
    631733#endif
    632734static double totalTime=0.0;
     
    10521154                                       const double * lastSolution, double dextra[5])
    10531155{
     1156  if (doAction==11&&!lastSolution)
     1157    lastSolution = model.bestSolution();
    10541158  assert ((doAction==1&&!lastSolution)||(doAction==11&&lastSolution));
    10551159  double fractionIntFixed = dextra[3];
     
    10631167  // Tighten bounds
    10641168  lpSolver->tightenPrimalBounds(0.0,11,true);
    1065   char generalPrint[200];
     1169  //char generalPrint[200];
    10661170  const double *objective = lpSolver->getObjCoefficients() ;
    10671171  double *columnLower = lpSolver->columnLower() ;
     
    14971601    lpSolver->setInfeasibilityCost(1.0e11);
    14981602    lpSolver->defaultFactorizationFrequency();
    1499     lpSolver->initialSolve(solveOptions);
     1603    if (doAction!=11)
     1604      lpSolver->initialSolve(solveOptions);
    15001605    double * columnLower = lpSolver->columnLower();
    15011606    double * columnUpper = lpSolver->columnUpper();
    15021607    double * fullSolution = lpSolver->primalColumnSolution();
    15031608    const double * dj = lpSolver->dualColumnSolution();
    1504     // First squash small and fix big
    1505     //double small=1.0e-7;
    1506     //double djTol=20.0;
    15071609    int iPass=0;
    15081610#define MAXPROB 2
     
    15381640      fullSolution = lpSolver->primalColumnSolution();
    15391641      if (doAction==11) {
     1642        {
     1643          double * columnLower = lpSolver->columnLower();
     1644          double * columnUpper = lpSolver->columnUpper();
     1645          //      lpSolver->dual();
     1646          memcpy(columnLower,originalLpSolver->columnLower(),numberColumns*sizeof(double));
     1647          memcpy(columnUpper,originalLpSolver->columnUpper(),numberColumns*sizeof(double));
     1648          //      lpSolver->dual();
     1649          int iColumn;
     1650          for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1651            if (columnUpper[iColumn] > columnLower[iColumn]+1.0e-8) {
     1652              if (solver->isInteger(iColumn)) {
     1653                double value = lastSolution[iColumn];
     1654                int iValue = (int) (value+0.5);
     1655                assert (fabs(value-((double) iValue))<1.0e-3);
     1656                assert (iValue>=columnLower[iColumn]&&
     1657                        iValue<=columnUpper[iColumn]);
     1658                columnLower[iColumn]=iValue;
     1659                columnUpper[iColumn]=iValue;
     1660              }
     1661            }
     1662          }
     1663          lpSolver->initialSolve(solveOptions);
     1664          memcpy(columnLower,originalLpSolver->columnLower(),numberColumns*sizeof(double));
     1665          memcpy(columnUpper,originalLpSolver->columnUpper(),numberColumns*sizeof(double));
     1666        }
    15401667        for (iColumn=0;iColumn<numberColumns;iColumn++) {
    15411668          if (columnUpper[iColumn] > columnLower[iColumn]+1.0e-8) {
     
    17571884    double * dsort = new double[numberColumns];
    17581885    int chunk=20;
     1886    int iRelax=0;
    17591887    //double fractionFixed=6.0/8.0;
    17601888    // relax while lots fixed
     
    17621890      if (skipZero2>10&&doAction<10)
    17631891        break;
     1892      iRelax++;
    17641893      int n=0;
    17651894      double sum0=0.0;
     
    19172046      }
    19182047      printf("%d relaxed\n",nRelax);
     2048      if (iRelax>20&&nRelax==chunk)
     2049        nRelax=0;
     2050      if (iRelax>50)
     2051        nRelax=0;
    19192052      assert (!nBad);
    19202053      delete [] lo;
     
    19552088}
    19562089#endif
    1957 #ifdef COIN_HAS_ASL
     2090#ifdef COIN_HAS_LINK
    19582091/*  Returns OsiSolverInterface (User should delete)
    19592092    On entry numberKnapsack is maximum number of Total entries
     
    28382971  int outputFormat=2;
    28392972  int substitution=3;
    2840   int dualize=0;
     2973  int dualize=3;
    28412974  int preSolve=5;
    28422975  int doSprint=-1;
     
    31203253void CbcClpUnitTest (const CbcModel & saveModel,
    31213254                     std::string& dirMiplib, bool unitTestOnly);
    3122 
     3255#ifdef NEW_STYLE_SOLVER
     3256/* This takes a list of commands, does "stuff" and returns
     3257   returnMode -
     3258   0 model and solver untouched - babModel updated
     3259   1 model updated - just with solution basis etc
     3260   2 model updated i.e. as babModel (babModel NULL) (only use without preprocessing)
     3261*/
     3262int
     3263CbcSolver::solve(const char * input2, int returnMode)
     3264{
     3265  char * input = strdup(input2);
     3266  int length = strlen(input);
     3267  bool blank = input[0]=='0';
     3268  int n=blank ? 0 : 1;
     3269  for (int i=0;i<length;i++) {
     3270    if (blank) {
     3271      // look for next non blank
     3272      if (input[i]==' ') {
     3273        continue;
     3274      } else {
     3275        n++;
     3276        blank=false;
     3277      }
     3278    } else {
     3279      // look for next blank
     3280      if (input[i]!=' ') {
     3281        continue;
     3282      } else {
     3283        blank=true;
     3284      }
     3285    }
     3286  }
     3287  char ** argv = new char * [n+2];
     3288  argv[0]=strdup("cbc");
     3289  int i=0;
     3290  while(input[i]==' ')
     3291    i++;
     3292  for (int j=0;j<n;j++) {
     3293    int saveI=i;
     3294    for (;i<length;i++) {
     3295      // look for next blank
     3296      if (input[i]!=' ') {
     3297        continue;
     3298      } else {
     3299        break;
     3300      }
     3301    }
     3302    char save = input[i];
     3303    input[i]='\0';
     3304    argv[j+1]=strdup(input+saveI);
     3305    input[i]=save;
     3306    while(input[i]==' ')
     3307      i++;
     3308  }
     3309  argv[n+1]=strdup("-quit");
     3310  free(input);
     3311  int returnCode = solve(n+2,const_cast<const char **>(argv),returnMode);
     3312  for (int k=0;k<n+2;k++)
     3313    free(argv[k]);
     3314  delete [] argv;
     3315  return returnCode;
     3316}
     3317#endif
    31233318/* Meaning of whereFrom:
    31243319   1 after initial solve by dualsimplex etc
     
    31513346  CbcModel * babModel_ = NULL;
    31523347  int returnMode=1;
     3348  int statusUserFunction_[1];
     3349  int numberUserFunctions_=1; // to allow for ampl
    31533350#else
    31543351  delete babModel_;
    31553352  babModel_ = NULL;
     3353  CbcOrClpRead_mode=1;
     3354  delete [] statusUserFunction_;
     3355  statusUserFunction_ = new int [numberUserFunctions_];
     3356  int iUser;
    31563357#endif
     3358  memset(statusUserFunction_,0,numberUserFunctions_*sizeof(int));
    31573359  /* Note
    31583360     This is meant as a stand-alone executable to do as much of coin as possible.
     
    32293431    CglStored storedAmpl;
    32303432    CoinModel * coinModel = NULL;
    3231 #ifdef COIN_HAS_ASL
    3232     ampl_info info;
    32333433    CoinModel saveCoinModel;
    32343434    CoinModel saveTightenedModel;
     
    32373437    int * knapsackRow=NULL;
    32383438    int numberKnapsack=0;
     3439#ifdef NEW_STYLE_SOLVER
     3440    int numberInputs=0;
     3441    readMode_=CbcOrClpRead_mode;
     3442    for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     3443      int status = userFunction_[iUser]->importData(this,argc,const_cast<char **>(argv));
     3444      if (status>=0) {
     3445        if (!status) {
     3446          numberInputs++;
     3447          statusUserFunction_[iUser]=1;
     3448          goodModel=true;
     3449          solver = model_.solver();
     3450          clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     3451          lpSolver = clpSolver->getModelPtr();
     3452        } else {
     3453          printf("Bad input from user function %s\n",userFunction_[iUser]->name().c_str());
     3454          abort();
     3455        }
     3456      }
     3457    }
     3458    if (numberInputs>1) {
     3459      printf("Two or more user inputs!\n");
     3460      abort();
     3461    }
     3462    if (originalCoinModel_)
     3463      complicatedInteger=1;
     3464    testOsiParameters = intValue(TESTOSI);
     3465    if (noPrinting_) {
     3466      model_.messageHandler()->setLogLevel(0);
     3467      setCbcOrClpPrinting(false);
     3468    }
     3469    CbcOrClpRead_mode=readMode_;
     3470#endif
     3471#ifdef COIN_HAS_ASL
     3472    ampl_info info;
     3473    {
    32393474    memset(&info,0,sizeof(info));
    32403475    if (argc>2&&!strcmp(argv[2],"-AMPL")) {
    3241       usingAmpl=true;
     3476      statusUserFunction_[0]=1;
    32423477      // see if log in list
    32433478      noPrinting_=true;
     
    33323567        si->setBiLinearPriority(10000);
    33333568        CoinModel * model2 = (CoinModel *) coinModel;
    3334         int logLevel = whichParam(LOGLEVEL,numberParameters_,parameters_);
     3569        int logLevel = parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].intValue();
    33353570        si->load(*model2,true,logLevel);
    33363571        // redo
     
    34113646      argv = const_cast<const char **>(info.arguments);
    34123647    }
     3648    }
    34133649#endif   
    34143650    // default action on import
     
    34233659    int presolveOptions=0;
    34243660    int substitution=3;
    3425     int dualize=0;
     3661    int dualize=3;
    34263662    int doCrash=0;
    34273663    int doVector=0;
     
    35733809      if (argc>1) {
    35743810        sprintf(generalPrint,"command line - ");
    3575         for (int i=0;i<argc;i++)
     3811        for (int i=0;i<argc;i++) {
     3812          if (!argv[i])
     3813            break;
    35763814          sprintf(generalPrint+strlen(generalPrint),"%s ",argv[i]);
     3815        }
    35773816        generalMessageHandler->message(CLP_GENERAL,generalMessages)
    35783817          << generalPrint
     
    36523891          // check if any integers
    36533892#ifdef COIN_HAS_ASL
    3654           if (info.numberSos&&doSOS&&usingAmpl) {
     3893          if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
    36553894            // SOS
    36563895            numberSOS = info.numberSos;
     
    36703909          }
    36713910#ifdef COIN_HAS_ASL
    3672           if (verbose<4&&usingAmpl)
     3911          if (verbose<4&&statusUserFunction_[0])
    36733912            verbose +=4;
    36743913#endif
     
    39504189                lpSolver->setPrimalColumnPivotAlgorithm(dantzig);
    39514190              } else if (action==3) {
    3952                 ClpPrimalColumnSteepest steep(2);
     4191                ClpPrimalColumnSteepest steep(4);
    39534192                lpSolver->setPrimalColumnPivotAlgorithm(steep);
    39544193              } else if (action==4) {
     
    39564195                lpSolver->setPrimalColumnPivotAlgorithm(steep);
    39574196              } else if (action==5) {
    3958                 ClpPrimalColumnSteepest steep(4);
     4197                ClpPrimalColumnSteepest steep(2);
    39594198                lpSolver->setPrimalColumnPivotAlgorithm(steep);
    39604199              } else if (action==6) {
     
    41464385          if (type==EXIT) {
    41474386#ifdef COIN_HAS_ASL
    4148             if(usingAmpl) {
     4387            if(statusUserFunction_[0]) {
    41494388              if (info.numberIntegers||info.numberBinary) {
    41504389                // integer
     
    41924431              ClpSimplex * model2 = lpSolver;
    41934432              if (dualize) {
    4194                 //printf("dualize %d\n",dualize);
    4195                 model2 = ((ClpSimplexOther *) model2)->dualOfModel();
    4196                 sprintf(generalPrint,"Dual of model has %d rows and %d columns",
    4197                        model2->numberRows(),model2->numberColumns());
    4198                 generalMessageHandler->message(CLP_GENERAL,generalMessages)
    4199                   << generalPrint
    4200                   <<CoinMessageEol;
    4201                 model2->setOptimizationDirection(1.0);
     4433                bool tryIt=true;
     4434                double fractionColumn=1.0;
     4435                double fractionRow=1.0;
     4436                if (dualize==3) {
     4437                  dualize=1;
     4438                  int numberColumns=lpSolver->numberColumns();
     4439                  int numberRows=lpSolver->numberRows();
     4440                  if (numberRows<50000||5*numberColumns>numberRows) {
     4441                    tryIt=false;
     4442                  } else {
     4443                    fractionColumn=0.1;
     4444                    fractionRow=0.1;
     4445                  }
     4446                }
     4447                if (tryIt) {
     4448                  model2 = ((ClpSimplexOther *) model2)->dualOfModel(fractionRow,fractionColumn);
     4449                  if (model2) {
     4450                    sprintf(generalPrint,"Dual of model has %d rows and %d columns",
     4451                            model2->numberRows(),model2->numberColumns());
     4452                    generalMessageHandler->message(CLP_GENERAL,generalMessages)
     4453                      << generalPrint
     4454                      <<CoinMessageEol;
     4455                    model2->setOptimizationDirection(1.0);
     4456                  } else {
     4457                    model2 = lpSolver;
     4458                    dualize=0;
     4459                  }
     4460                } else {
     4461                  dualize=0;
     4462                }
    42024463              }
    42034464              if (noPrinting_)
     
    44374698              if (dualize) {
    44384699                int returnCode=((ClpSimplexOther *) lpSolver)->restoreFromDual(model2);
     4700                if (model2->status()==3)
     4701                  returnCode=0;
    44394702                delete model2;
    44404703                if (returnCode&&dualize!=2)
     
    44424705                model2=lpSolver;
    44434706              }
     4707#ifdef NEW_STYLE_SOLVER
     4708              updateModel(model2,returnMode);
     4709              for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     4710                if (statusUserFunction_[iUser])
     4711                  userFunction_[iUser]->exportSolution(this,1);
     4712              }
     4713#endif
    44444714#ifdef COIN_HAS_ASL
    4445               if (usingAmpl) {
     4715              if (statusUserFunction_[0]) {
    44464716                double value = model2->getObjValue()*model2->getObjSense();
    44474717                char buf[300];
     
    51535423                  //process.messageHandler()->setLogLevel(babModel_->logLevel());
    51545424#ifdef COIN_HAS_ASL
    5155                   if (info.numberSos&&doSOS&&usingAmpl) {
     5425                  if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
    51565426                    // SOS
    51575427                    numberSOS = info.numberSos;
     
    52375507                    solver2->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo) ;
    52385508                }
     5509#ifdef NEW_STYLE_SOLVER
     5510                if (!solver2) {
     5511                  for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     5512                    if (statusUserFunction_[iUser])
     5513                      userFunction_[iUser]->exportSolution(this,11,"infeasible/unbounded by pre-processing");
     5514                  }
     5515                }
     5516#endif
    52395517#ifdef COIN_HAS_ASL
    5240                 if (!solver2&&usingAmpl) {
     5518                if (!solver2&&statusUserFunction_[0]) {
    52415519                  // infeasible
    52425520                  info.problemStatus=1;
     
    53595637              }
    53605638              int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
    5361 #ifdef COIN_HAS_ASL
     5639              //#ifdef COIN_HAS_ASL
     5640#if 1
    53625641              // If linked then see if expansion wanted
    53635642              {
     
    53955674                        // allow gomory
    53965675                        complicatedInteger=0;
     5676#ifdef COIN_HAS_ASL
    53975677                        // Priorities already done
    53985678                        free(info.priorities);
    53995679                        info.priorities=NULL;
     5680#endif
    54005681                      } else {
    54015682                        numberKnapsack=0;
     
    56505931              }
    56515932              if (type==BAB) {
     5933#ifdef NEW_STYLE_SOLVER
     5934                {
     5935                  CbcSolverUsefulData info;
     5936                  bool useInfo=false;
     5937                  for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     5938                    if (statusUserFunction_[iUser]) {
     5939                      userFunction_[iUser]->fillInformation(this,info);
     5940                      useInfo=true;
     5941                    }
     5942                  }
     5943                  if (useInfo) {
     5944                    priorities=info.priorities_;
     5945                    branchDirection=info.branchDirection_;
     5946                    pseudoDown=info.pseudoDown_;
     5947                    pseudoUp=info.pseudoUp_;
     5948                    solutionIn=info.primalSolution_;
     5949                    int numberColumns = originalCoinModel_ ? originalCoinModel_->numberColumns() :
     5950                      lpSolver->getNumCols();
     5951                    prioritiesIn = (int *) malloc(numberColumns*sizeof(int));
     5952                    memcpy(prioritiesIn,info.priorities_,numberColumns*sizeof(int));
     5953                    sosPriority = info.sosPriority_;
     5954                  }
     5955                }
     5956#endif
    56525957#ifdef COIN_HAS_ASL
    5653                 if (usingAmpl) {
     5958                if (statusUserFunction_[0]) {
    56545959                  priorities=info.priorities;
    56555960                  branchDirection=info.branchDirection;
     
    61216426                int statistics = (printOptions>0) ? printOptions: 0;
    61226427#ifdef COIN_HAS_ASL
    6123                 if (!usingAmpl) {
     6428                if (!statusUserFunction_[0]) {
    61246429#endif
    61256430                  free(priorities);
     
    64416746#ifdef COIN_HAS_ASL
    64426747                // add in lotsizing
    6443                 if (usingAmpl&&info.special) {
     6748                if (statusUserFunction_[0]&&info.special) {
    64446749                  int numberColumns = babModel_->getNumCols();
    64456750                  int i;
     
    67447049                clpSolver = dynamic_cast< OsiClpSolverInterface*> (strengthenedModel);
    67457050#ifdef COIN_HAS_ASL
    6746               else if (usingAmpl)
     7051              else if (statusUserFunction_[0])
    67477052                clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    67487053#endif
     
    68017106                  return returnCode;
    68027107                }
     7108#ifdef NEW_STYLE_SOLVER
     7109                if (bestSolution&&numberKnapsack) {
     7110                  // expanded knapsack
     7111                  assert (originalCoinModel_);
     7112                  // Fills in original solution (coinModel length - rest junk)
     7113                  clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     7114                  lpSolver = clpSolver->getModelPtr();
     7115                  int numberColumns = originalCoinModel_->numberColumns();
     7116                  int numberColumns2 = lpSolver->numberColumns();
     7117                  assert (numberColumns2>numberColumns);
     7118                  double * primalSolution = new double [numberColumns2];
     7119                  memset(primalSolution,0,numberColumns2*sizeof(double));
     7120                  afterKnapsack(saveTightenedModel,  whichColumn,  knapsackStart,
     7121                                knapsackRow,  numberKnapsack,
     7122                                lpSolver->primalColumnSolution(), primalSolution,1);
     7123                  memcpy(lpSolver->primalColumnSolution(),primalSolution,numberColumns2*sizeof(double));
     7124                  delete [] primalSolution;
     7125                }
     7126                updateModel(NULL,returnMode);
     7127                for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     7128                  if (statusUserFunction_[iUser])
     7129                    userFunction_[iUser]->exportSolution(this,2);
     7130                }
     7131#endif
    68037132#ifdef COIN_HAS_ASL
    6804                 if (usingAmpl) {
     7133                if (statusUserFunction_[0]) {
    68057134                  clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    68067135                  lpSolver = clpSolver->getModelPtr();
     
    68797208              time1 = time2;
    68807209#ifdef COIN_HAS_ASL
    6881               if (usingAmpl) {
     7210              if (statusUserFunction_[0]) {
    68827211                // keep if going to be destroyed
    68837212                OsiSolverInterface * solver = babModel_->solver();
     
    68997228            {
    69007229#ifdef COIN_HAS_ASL
    6901               if (!usingAmpl) {
     7230              if (!statusUserFunction_[0]) {
    69027231#endif
    69037232                free(priorities);
     
    71927521                bool deleteModel2=false;
    71937522                ClpSimplex * model2 = lpSolver;
    7194                 if (dualize) {
     7523                if (dualize&&dualize<3) {
    71957524                  model2 = ((ClpSimplexOther *) model2)->dualOfModel();
    71967525                  sprintf(generalPrint,"Dual of model has %d rows and %d columns",
     
    72027531                }
    72037532#ifdef COIN_HAS_ASL
    7204                 if (info.numberSos&&doSOS&&usingAmpl) {
     7533                if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
    72057534                  // SOS
    72067535                  numberSOS = info.numberSos;
     
    76738002                fread(debugValues,sizeof(double),numberDebugValues,fp);
    76748003                printf("%d doubles read into debugValues\n",numberDebugValues);
     8004                if (numberDebugValues<200) {
     8005                  for (int i=0;i<numberDebugValues;i++) {
     8006                    if (lpSolver->isInteger(i)&&debugValues[i])
     8007                      printf("%d %g\n",i,debugValues[i]);
     8008                  }
     8009                }
    76758010                fclose(fp);
    76768011              } else {
     
    80948429              lpSolver = clpSolver->getModelPtr();
    80958430#ifdef COIN_HAS_ASL
    8096               if (usingAmpl) {
     8431              if (statusUserFunction_[0]) {
    80978432                int n = clpSolver->getNumCols();
    80988433                double value = objectiveValue*lpSolver->getObjSense();
     
    85178852#ifdef NEW_STYLE_SOLVER
    85188853  updateModel(NULL,returnMode);
     8854  for (iUser=0;iUser<numberUserFunctions_;iUser++) {
     8855    if (statusUserFunction_[iUser])
     8856      userFunction_[iUser]->exportData(this);
     8857  }
    85198858  sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-startTime_);
    85208859#else
Note: See TracChangeset for help on using the changeset viewer.