Changeset 295 for trunk


Ignore:
Timestamp:
Apr 2, 2006 5:10:40 AM (14 years ago)
Author:
forrest
Message:

for ampl

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/CbcBranchActual.cpp

    r293 r295  
    214214  }
    215215}
     216// Redoes data when sequence numbers change
     217void
     218CbcClique::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     219{
     220  model_=model;
     221  int n2=0;
     222  for (int j=0;j<numberMembers_;j++) {
     223    int iColumn = members_[j];
     224    int i;
     225    for (i=0;i<numberColumns;i++) {
     226      if (originalColumns[i]==iColumn)
     227        break;
     228    }
     229    if (i<numberColumns) {
     230      members_[n2]=i;
     231      type_[n2++]=type_[j];
     232    }
     233  }
     234  if (n2<numberMembers_) {
     235    printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
     236    numberMembers_=n2;
     237  }
     238  // Find out how many non sos
     239  int i;
     240  numberNonSOSMembers_=0;
     241  for (i=0;i<numberMembers_;i++)
     242    if (!type_[i])
     243      numberNonSOSMembers_++;
     244}
    216245
    217246
     
    489518    int iColumn = members_[j];
    490519    solver->setColUpper(iColumn,0.0);
     520  }
     521}
     522// Redoes data when sequence numbers change
     523void
     524CbcSOS::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     525{
     526  model_=model;
     527  int n2=0;
     528  for (int j=0;j<numberMembers_;j++) {
     529    int iColumn = members_[j];
     530    int i;
     531    for (i=0;i<numberColumns;i++) {
     532      if (originalColumns[i]==iColumn)
     533        break;
     534    }
     535    if (i<numberColumns) {
     536      members_[n2]=i;
     537      weights_[n2++]=weights_[j];
     538    }
     539  }
     540  if (n2<numberMembers_) {
     541    printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
     542    numberMembers_=n2;
    491543  }
    492544}
     
    750802  solver->setColLower(columnNumber_,nearest);
    751803  solver->setColUpper(columnNumber_,nearest);
     804}
     805// Redoes data when sequence numbers change
     806void
     807CbcSimpleInteger::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     808{
     809  model_=model;
     810  int i;
     811  for (i=0;i<numberColumns;i++) {
     812    if (originalColumns[i]==columnNumber_)
     813      break;
     814  }
     815  if (i<numberColumns)
     816    columnNumber_=i;
     817  else
     818    abort(); // should never happen
    752819}
    753820/* Column number if single column object -1 otherwise,
     
    29042971  }
    29052972}
     2973// Redoes data when sequence numbers change
     2974void
     2975CbcNWay::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     2976{
     2977  model_=model;
     2978  int n2=0;
     2979  for (int j=0;j<numberMembers_;j++) {
     2980    int iColumn = members_[j];
     2981    int i;
     2982    for (i=0;i<numberColumns;i++) {
     2983      if (originalColumns[i]==iColumn)
     2984        break;
     2985    }
     2986    if (i<numberColumns) {
     2987      members_[n2]=i;
     2988      consequence_[n2++]=consequence_[j];
     2989    } else {
     2990      delete consequence_[j];
     2991    }
     2992  }
     2993  if (n2<numberMembers_) {
     2994    printf("** NWay number of members reduced from %d to %d!\n",numberMembers_,n2);
     2995    numberMembers_=n2;
     2996  }
     2997}
    29062998
    29072999
  • trunk/CbcModel.cpp

    r285 r295  
    398398  // original solver (only set if pre-processing)
    399399  OsiSolverInterface * originalSolver=NULL;
     400  int numberOriginalObjects=numberObjects_;
     401  CbcObject ** originalObject = NULL;
    400402  // Set up strategies
    401403  if (strategy_) {
     
    412414        originalContinuousObjective_ = COIN_DBL_MAX;
    413415        return ;
     416      } else if (numberObjects_&&object_) {
     417        numberOriginalObjects=numberObjects_;
     418        // redo sequence
     419        numberIntegers_=0;
     420        int numberColumns = getNumCols();
     421        int nOrig = originalSolver->getNumCols();
     422        CglPreProcess * process = strategy_->process();
     423        assert (process);
     424        const int * originalColumns = process->originalColumns();
     425        // allow for cliques etc
     426        nOrig = CoinMax(nOrig,originalColumns[numberColumns-1]+1);
     427        originalObject = object_;
     428        // object number or -1
     429        int * temp = new int[nOrig];
     430        int iColumn;
     431        for (iColumn=0;iColumn<nOrig;iColumn++)
     432          temp[iColumn]=-1;
     433        int iObject;
     434        int nNonInt=0;
     435        for (iObject=0;iObject<numberOriginalObjects;iObject++) {
     436          iColumn = originalObject[iObject]->columnNumber();
     437          if (iColumn<0) {
     438            nNonInt++;
     439          } else {
     440            temp[iColumn]=iObject;
     441          }
     442        }
     443        int numberNewIntegers=0;
     444        int numberOldIntegers=0;
     445        int numberOldOther=0;
     446        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     447          int jColumn = originalColumns[iColumn];
     448          if (temp[jColumn]>=0) {
     449            int iObject= temp[jColumn];
     450            CbcSimpleInteger * obj =
     451              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
     452            if (obj)
     453              numberOldIntegers++;
     454            else
     455              numberOldOther++;
     456          } else if (isInteger(iColumn)) {
     457            numberNewIntegers++;
     458          }
     459        }
     460        /*
     461          Allocate an array to hold the indices of the integer variables.
     462          Make a large enough array for all objects
     463        */
     464        numberObjects_= numberNewIntegers+numberOldIntegers+numberOldOther+nNonInt;
     465        object_ = new CbcObject * [numberObjects_];
     466        integerVariable_ = new int [numberNewIntegers+numberOldIntegers];
     467        /*
     468          Walk the variables again, filling in the indices and creating objects for
     469          the integer variables. Initially, the objects hold the index and upper &
     470          lower bounds.
     471        */
     472        numberIntegers_=0;
     473        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     474          int jColumn = originalColumns[iColumn];
     475          if (temp[jColumn]>=0) {
     476            int iObject= temp[jColumn];
     477            CbcSimpleInteger * obj =
     478              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
     479            if (obj) {
     480              object_[numberIntegers_] = originalObject[iObject]->clone();
     481              // redo ids etc
     482              object_[numberIntegers_]->redoSequenceEtc(this,numberColumns,originalColumns);
     483              integerVariable_[numberIntegers_++]=iColumn;
     484            }
     485          } else if (isInteger(iColumn)) {
     486            object_[numberIntegers_] =
     487              new CbcSimpleInteger(this,numberIntegers_,iColumn);
     488            integerVariable_[numberIntegers_++]=iColumn;
     489          }
     490        }
     491        numberObjects_=numberIntegers_;
     492        // Now append other column stuff
     493        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     494          int jColumn = originalColumns[iColumn];
     495          if (temp[jColumn]>=0) {
     496            int iObject= temp[jColumn];
     497            CbcSimpleInteger * obj =
     498              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
     499            if (!obj) {
     500              object_[numberObjects_] = originalObject[iObject]->clone();
     501              // redo ids etc
     502              object_[numberObjects_]->redoSequenceEtc(this,numberColumns,originalColumns);
     503              numberObjects_++;
     504            }
     505          }
     506        }
     507        // now append non column stuff
     508        for (iObject=0;iObject<numberOriginalObjects;iObject++) {
     509          iColumn = originalObject[iObject]->columnNumber();
     510          if (iColumn<0) {
     511            object_[numberObjects_] = originalObject[iObject]->clone();
     512            // redo ids etc
     513            object_[numberObjects_]->redoSequenceEtc(this,numberColumns,originalColumns);
     514            numberObjects_++;
     515          }
     516        }
     517        delete [] temp;
     518        if (!numberObjects_)
     519          handler_->message(CBC_NOINT,messages_) << CoinMessageEol ;
    414520      }
    415521    } else {
     
    17781884    if (bestSolution_)
    17791885      memcpy(bestSolution_,solver_->getColSolution(),n*sizeof(double));
     1886    // put back original objects if there were any
     1887    if (originalObject) {
     1888      int iColumn;
     1889      for (iColumn=0;iColumn<numberObjects_;iColumn++)
     1890        delete object_[iColumn];
     1891      delete [] object_;
     1892      numberObjects_ = numberOriginalObjects;
     1893      object_=originalObject;
     1894      delete [] integerVariable_;
     1895      numberIntegers_=0;
     1896      for (iColumn=0;iColumn<n;iColumn++) {
     1897        if (solver_->isInteger(iColumn))
     1898          numberIntegers_++;
     1899      }
     1900      integerVariable_ = new int[numberIntegers_];
     1901      numberIntegers_=0;
     1902      for (iColumn=0;iColumn<n;iColumn++) {
     1903        if (solver_->isInteger(iColumn))
     1904            integerVariable_[numberIntegers_++]=iColumn;
     1905      }
     1906    }
    17801907  }
    17811908  return ; }
     
    46704797      numberIterations_ += solver_->getIterationCount() ;
    46714798      feasible = solver_->isProvenOptimal();
     4799      //      solver_->writeMps("infeas");
    46724800    }
    46734801  }
     
    51425270
    51435271void
    5144 CbcModel::findIntegers(bool startAgain)
     5272CbcModel::findIntegers(bool startAgain,int type)
    51455273{
    51465274  assert(solver_);
     
    51915319  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    51925320    if(isInteger(iColumn)) {
    5193       object_[numberIntegers_] =
    5194         new CbcSimpleInteger(this,numberIntegers_,iColumn);
     5321      if (!type)
     5322        object_[numberIntegers_] =
     5323          new CbcSimpleInteger(this,numberIntegers_,iColumn);
     5324      else if (type==1)
     5325        object_[numberIntegers_] =
     5326          new CbcSimpleIntegerPseudoCost(this,numberIntegers_,iColumn,0.3);
    51955327      integerVariable_[numberIntegers_++]=iColumn;
    51965328    }
     
    52115343{
    52125344  int iObject;
     5345  const double * cost = solver_->getObjCoefficients();
    52135346  for (iObject = 0;iObject<numberObjects_;iObject++) {
    52145347    CbcSimpleInteger * obj1 =
    52155348      dynamic_cast <CbcSimpleInteger *>(object_[iObject]) ;
     5349    CbcSimpleIntegerPseudoCost * obj1a =
     5350      dynamic_cast <CbcSimpleIntegerPseudoCost *>(object_[iObject]) ;
    52165351    CbcSimpleIntegerDynamicPseudoCost * obj2 =
    52175352      dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]) ;
     
    52205355      int iColumn = obj1->columnNumber();
    52215356      int priority = obj1->priority();
     5357      int preferredWay = obj1->preferredWay();
    52225358      delete object_[iObject];
     5359      double costValue = CoinMax(1.0e-5,fabs(cost[iColumn]));
     5360      // treat as if will cost what it says up
     5361      double upCost=costValue;
     5362      // and balance at breakeven of 0.3
     5363      double downCost=(0.7*upCost)/0.3;
     5364      if (obj1a) {
     5365        upCost=obj1a->upPseudoCost();
     5366        downCost=obj1a->downPseudoCost();
     5367      }
    52235368      CbcSimpleIntegerDynamicPseudoCost * newObject =
    5224         new CbcSimpleIntegerDynamicPseudoCost(this,iObject,iColumn,0.3);
     5369        new CbcSimpleIntegerDynamicPseudoCost(this,iObject,iColumn,downCost,upCost);
    52255370      newObject->setNumberBeforeTrust(numberBeforeTrust_);
    52265371      newObject->setPriority(priority);
     5372      newObject->setPreferredWay(preferredWay);
    52275373      object_[iObject] = newObject;
    52285374    }
  • trunk/CbcStrategy.cpp

    r277 r295  
    369369          /* model may not have created objects
    370370             If none then create
     371             NOTE - put back to original column numbers as
     372             CbcModel will pack down ALL as it doesn't know where from
    371373          */
     374          bool someObjects = model.numberObjects()>0;
    372375          if (!numberIntegers||!model.numberObjects()) {
    373376            model.findIntegers(true);
     
    401404            delete objects[iSOS];
    402405          delete [] objects;
     406          if (!someObjects) {
     407            // put back old column numbers
     408            const int * originalColumns = process_->originalColumns();
     409            // use reverse lookup to fake it
     410            int n=originalColumns[numberColumns-1]+1;
     411            int * fake = new int[n];
     412            int i;
     413            for ( i=0;i<n;i++)
     414              fake[i]=-1;
     415            for (i=0;i<numberColumns;i++)
     416              fake[originalColumns[i]]=i;
     417            for (int iObject=0;iObject<model.numberObjects();iObject++) {
     418              // redo ids etc
     419              model.modifiableObject(iObject)->redoSequenceEtc(&model,n,fake);
     420            }
     421            delete [] fake;
     422          }
    403423        }
    404424      } else {
  • trunk/Test/Cbc_ampl.cpp

    r260 r295  
    100100        { "sosref", 0, ASL_Sufkind_var | ASL_Sufkind_real },
    101101#endif
     102        { "direction", 0, ASL_Sufkind_var },
     103        { "downPseudocost", 0, ASL_Sufkind_var | ASL_Sufkind_real },
     104        { "priority", 0, ASL_Sufkind_var },
    102105        { strdup("sstatus"), 0, ASL_Sufkind_var, 0 },
    103         { strdup("sstatus"), 0, ASL_Sufkind_con, 0 }
     106        { strdup("sstatus"), 0, ASL_Sufkind_con, 0 },
     107        { "upPseudocost", 0, ASL_Sufkind_var | ASL_Sufkind_real }
    104108#if 0
    105109        { "unbdd", 0, ASL_Sufkind_var | ASL_Sufkind_outonly},
     
    113117static FILE *nl=NULL;
    114118
     119static void
     120mip_stuff(void)
     121{
     122  int i;
     123  double *pseudoUp, *pseudoDown;
     124  int *priority, *direction;
     125  SufDesc *dpup, *dpdown, *dpri, *ddir;
     126 
     127  ddir = suf_get("direction", ASL_Sufkind_var);
     128  direction = ddir->u.i;
     129  dpri = suf_get("priority", ASL_Sufkind_var);
     130  priority = dpri->u.i;
     131  dpdown = suf_get("downPseudocost", ASL_Sufkind_var);
     132  pseudoDown = dpdown->u.r;
     133  dpup = suf_get("upPseudocost", ASL_Sufkind_var);
     134  pseudoUp = dpup->u.r;
     135  assert(saveInfo);
     136  int numberColumns = saveInfo->numberColumns;
     137  if (direction) {
     138    int baddir=0;
     139    saveInfo->branchDirection = (int *) malloc(numberColumns*sizeof(int));
     140    for (i=0;i<numberColumns;i++) {
     141      int value = direction[i];
     142      if (value<-1||value>1) {
     143        baddir++;
     144        value=0;
     145      }
     146      saveInfo->branchDirection[i]=value;
     147    }
     148    if (baddir)
     149      fprintf(Stderr,
     150              "Treating %d .direction values outside [-1, 1] as 0.\n",
     151              baddir);
     152  }
     153  if (priority) {
     154    int badpri=0;
     155    saveInfo->priorities= (int *) malloc(numberColumns*sizeof(int));
     156    for (i=0;i<numberColumns;i++) {
     157      int value = priority[i];
     158      if (value<0) {
     159        badpri++;
     160        value=0;
     161      }
     162      saveInfo->priorities[i]=value;
     163    }
     164    if (badpri)
     165      fprintf(Stderr,
     166              "Treating %d negative .priority values as 0\n",
     167              badpri);
     168  }
     169  if (pseudoDown||pseudoUp) {
     170    int badpseudo=0;
     171    if (!pseudoDown||!pseudoUp)
     172      fprintf(Stderr,
     173              "Only one set of pseudocosts - assumed same\n");
     174    saveInfo->pseudoDown= (double *) malloc(numberColumns*sizeof(double));
     175    saveInfo->pseudoUp = (double *) malloc(numberColumns*sizeof(double));
     176    for (i=0;i<numberColumns;i++) {
     177      double valueD=0.0, valueU=0.0;
     178      if (pseudoDown) {
     179        valueD = pseudoDown[i];
     180        if (valueD<0) {
     181          badpseudo++;
     182          valueD=0.0;
     183        }
     184      }
     185      if (pseudoUp) {
     186        valueU = pseudoUp[i];
     187        if (valueU<0) {
     188          badpseudo++;
     189          valueU=0.0;
     190        }
     191      }
     192      if (!valueD)
     193        valueD=valueU;
     194      if (!valueU)
     195        valueU=valueD;
     196      saveInfo->pseudoDown[i]=valueD;
     197      saveInfo->pseudoUp[i]=valueU;
     198    }
     199    if (badpseudo)
     200      fprintf(Stderr,
     201              "Treating %d negative pseudoCosts as 0.0\n",badpseudo);
     202  }
     203}
    115204static void
    116205stat_map(int *stat, int n, int *map, int mx, const char *what)
     
    252341  }
    253342  info->dualSolution=NULL;
     343  if (niv+nbv>0)
     344    mip_stuff(); // get any extra info
    254345  if ((!(niv+nbv)&&(csd->kind & ASL_Sufkind_input))
    255346      ||(rsd->kind & ASL_Sufkind_input)) {
     
    353444  free(info->columnStatus);
    354445  info->columnStatus=NULL;
     446  free(info->priorities);
     447  info->priorities=NULL;
     448  free(info->branchDirection);
     449  info->branchDirection=NULL;
     450  free(info->pseudoDown);
     451  info->pseudoDown=NULL;
     452  free(info->pseudoUp);
     453  info->pseudoUp=NULL;
    355454  ASL_free(&asl);
    356455}
  • trunk/Test/CoinSolve.cpp

    r291 r295  
    423423    clpSolver->messageHandler()->setLogLevel(0) ;
    424424    model.messageHandler()->setLogLevel(1);
     425    // For priorities etc
     426    int * priorities=NULL;
     427    int * branchDirection=NULL;
     428    double * pseudoDown=NULL;
     429    double * pseudoUp=NULL;
    425430#ifdef CBC_AMPL
    426431    ampl_info info;
     
    512517    std::string exportFile ="default.mps";
    513518    std::string importBasisFile ="";
     519    std::string importPriorityFile ="";
    514520    std::string debugFile="";
    515521    std::string printMask="";
     
    527533    establishParams(numberParameters,parameters) ;
    528534    parameters[whichParam(BASISIN,numberParameters,parameters)].setStringValue(importBasisFile);
     535    parameters[whichParam(PRIORITYIN,numberParameters,parameters)].setStringValue(importPriorityFile);
    529536    parameters[whichParam(BASISOUT,numberParameters,parameters)].setStringValue(exportBasisFile);
    530537    parameters[whichParam(DEBUG,numberParameters,parameters)].setStringValue(debugFile);
     
    18641871              }
    18651872              if (type==BAB) {
     1873#ifdef CBC_AMPL
     1874                if (usingAmpl) {
     1875                  priorities=info.priorities;
     1876                  branchDirection=info.branchDirection;
     1877                  pseudoDown=info.pseudoDown;
     1878                  pseudoUp=info.pseudoUp;
     1879                }
     1880#endif               
     1881                const int * originalColumns = NULL;
     1882                if (preProcess)
     1883                  originalColumns = process.originalColumns();
    18661884                if (preProcess&&process.numberSOS()) {
    18671885                  int numberSOS = process.numberSOS();
     
    18711889                  */
    18721890                  if (!numberIntegers||!babModel->numberObjects()) {
    1873                     babModel->findIntegers(true);
     1891                    int type = (pseudoUp) ? 1 : 0;
     1892                    babModel->findIntegers(true,type);
    18741893                    numberIntegers = babModel->numberIntegers();
    18751894                  }
     
    18801899                  int numberOldObjects = babModel->numberObjects();
    18811900                  int numberColumns = babModel->getNumCols();
    1882                   for (int iObj = 0;iObj<numberOldObjects;iObj++)
     1901                  for (int iObj = 0;iObj<numberOldObjects;iObj++) {
    18831902                    oldObjects[iObj]->setPriority(numberColumns+1);
     1903                    int iColumn = oldObjects[iObj]->columnNumber();
     1904                    assert (iColumn>=0);
     1905                    if (originalColumns)
     1906                      iColumn = originalColumns[iColumn];
     1907                    if (branchDirection)
     1908                      oldObjects[iObj]->setPreferredWay(branchDirection[iColumn]);
     1909                    if (pseudoUp) {
     1910                      CbcSimpleIntegerPseudoCost * obj1a =
     1911                        dynamic_cast <CbcSimpleIntegerPseudoCost *>(oldObjects[iObj]) ;
     1912                      assert (obj1a);
     1913                      obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     1914                      obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     1915                    }
     1916                  }
    18841917                  const int * starts = process.startSOS();
    18851918                  const int * which = process.whichSOS();
     
    18991932                    delete objects[iSOS];
    19001933                  delete [] objects;
     1934                } else if (priorities||branchDirection||pseudoDown||pseudoUp) {
     1935                  // do anyway for priorities etc
     1936                  int numberIntegers = babModel->numberIntegers();
     1937                  /* model may not have created objects
     1938                     If none then create
     1939                  */
     1940                  if (!numberIntegers||!babModel->numberObjects()) {
     1941                    int type = (pseudoUp) ? 1 : 0;
     1942                    babModel->findIntegers(true,type);
     1943                  }
     1944                  CbcObject ** objects = babModel->objects();
     1945                  int numberObjects = babModel->numberObjects();
     1946                  for (int iObj = 0;iObj<numberObjects;iObj++) {
     1947                    int iColumn = objects[iObj]->columnNumber();
     1948                    assert (iColumn>=0);
     1949                    if (originalColumns)
     1950                      iColumn = originalColumns[iColumn];
     1951                    if (branchDirection)
     1952                      objects[iObj]->setPreferredWay(branchDirection[iColumn]);
     1953                    if (priorities) {
     1954                      int iPriority = priorities[iColumn];
     1955                      if (iPriority>0)
     1956                        objects[iObj]->setPriority(iPriority);
     1957                    }
     1958                    if (pseudoUp&&pseudoUp[iColumn]) {
     1959                      CbcSimpleIntegerPseudoCost * obj1a =
     1960                        dynamic_cast <CbcSimpleIntegerPseudoCost *>(objects[iObj]) ;
     1961                      assert (obj1a);
     1962                      obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     1963                      obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     1964                    }
     1965                  }
    19011966                }
     1967#ifdef CBC_AMPL
     1968                if (!usingAmpl) {
     1969#endif
     1970                  free(priorities);
     1971                  priorities=NULL;
     1972                  free(branchDirection);
     1973                  branchDirection=NULL;
     1974                  free(pseudoDown);
     1975                  pseudoDown=NULL;
     1976                  free(pseudoUp);
     1977                  pseudoUp=NULL;
     1978#ifdef CBC_AMPL
     1979                }
     1980#endif               
    19021981                int statistics = (printOptions>0) ? printOptions: 0;
    19031982                babModel->branchAndBound(statistics);
     
    19622041                clpSolver = dynamic_cast< OsiClpSolverInterface*> (strengthenedModel);
    19632042              lpSolver = clpSolver->getModelPtr();
    1964               if (debugFile=="create"&&bestSolution) {
    1965                 saveSolution(lpSolver,"debug.file");
    1966               }
    19672043              if (numberChanged) {
    19682044                for (int i=0;i<numberChanged;i++) {
     
    19772053                if (bestSolution)
    19782054                  memcpy(lpSolver->primalColumnSolution(),bestSolution,n*sizeof(double));
     2055                if (debugFile=="create"&&bestSolution) {
     2056                  saveSolution(lpSolver,"debug.file");
     2057                }
    19792058                delete [] bestSolution;
    19802059                std::string statusName[]={"Finished","Stopped on ","Difficulties",
     
    20552134          case IMPORT:
    20562135            {
     2136#ifdef CBC_AMPL
     2137              if (!usingAmpl) {
     2138#endif
     2139                free(priorities);
     2140                priorities=NULL;
     2141                free(branchDirection);
     2142                branchDirection=NULL;
     2143                free(pseudoDown);
     2144                pseudoDown=NULL;
     2145                free(pseudoUp);
     2146                pseudoUp=NULL;
     2147#ifdef CBC_AMPL
     2148              }
     2149#endif               
    20572150              delete babModel;
    20582151              babModel=NULL;
     
    23512444                else
    23522445                  basisHasValues=1;
     2446              }
     2447            } else {
     2448              std::cout<<"** Current model not valid"<<std::endl;
     2449            }
     2450            break;
     2451          case PRIORITYIN:
     2452            if (goodModel) {
     2453              // get next field
     2454              field = CoinReadGetString(argc,argv);
     2455              if (field=="$") {
     2456                field = parameters[iParam].stringValue();
     2457              } else if (field=="EOL") {
     2458                parameters[iParam].printString();
     2459                break;
     2460              } else {
     2461                parameters[iParam].setStringValue(field);
     2462              }
     2463              std::string fileName;
     2464              if (field[0]=='/'||field[0]=='\\') {
     2465                fileName = field;
     2466              } else if (field[0]=='~') {
     2467                char * environVar = getenv("HOME");
     2468                if (environVar) {
     2469                  std::string home(environVar);
     2470                  field=field.erase(0,1);
     2471                  fileName = home+field;
     2472                } else {
     2473                  fileName=field;
     2474                }
     2475              } else {
     2476                fileName = directory+field;
     2477              }
     2478              FILE *fp=fopen(fileName.c_str(),"r");
     2479              if (fp) {
     2480                // can open - lets go for it
     2481                std::string headings[]={"name","number","direction","priority","up","down"};
     2482                int order[]={-1,-1,-1,-1,-1,-1};
     2483                int nAcross=0;
     2484                char line[1000];
     2485                int numberColumns = lpSolver->numberColumns();
     2486                if (!fgets(line,1000,fp)) {
     2487                  std::cout<<"Odd file "<<fileName<<std::endl;
     2488                } else {
     2489                  char * pos = line;
     2490                  char * put = line;
     2491                  while (*pos>=' '&&*pos!='\n') {
     2492                    if (*pos!=' '&&*pos!='\t') {
     2493                      *put=tolower(*pos);
     2494                      put++;
     2495                    }
     2496                  }
     2497                  *put='\0';
     2498                  pos=line;
     2499                  int i;
     2500                  bool good=true;
     2501                  while (pos) {
     2502                    char * comma = strchr(pos,',');
     2503                    if (comma)
     2504                      *comma='\0';
     2505                    for (i=0;i<(int) (sizeof(order)/sizeof(int));i++) {
     2506                      if (headings[i]==pos) {
     2507                        if (order[i]<0) {
     2508                          order[i]=nAcross++;
     2509                        } else {
     2510                          // duplicate
     2511                          good=false;
     2512                        }
     2513                        break;
     2514                      }
     2515                    }
     2516                    if (i==(int) (sizeof(order)/sizeof(int)))
     2517                      good=false;
     2518                    if (comma) {
     2519                      *comma=',';
     2520                      pos=comma+1;
     2521                    } else {
     2522                      break;
     2523                    }
     2524                  }
     2525                  if (order[0]<0&&order[1]<0)
     2526                    good=false;
     2527                  if (order[0]>=0&&order[1]>=0)
     2528                    good=false;
     2529                  if (order[0]>=0&&!lpSolver->lengthNames())
     2530                    good=false;
     2531                  if (good) {
     2532                    char ** columnNames = columnNames = new char * [numberColumns];
     2533                    pseudoDown= (double *) malloc(numberColumns*sizeof(double));
     2534                    pseudoUp = (double *) malloc(numberColumns*sizeof(double));
     2535                    branchDirection = (int *) malloc(numberColumns*sizeof(int));
     2536                    priorities= (int *) malloc(numberColumns*sizeof(int));
     2537                    int iColumn;
     2538                    for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2539                      columnNames[iColumn] =
     2540                        strdup(lpSolver->columnName(iColumn).c_str());
     2541                      pseudoDown[iColumn]=0.0;
     2542                      pseudoUp[iColumn]=0.0;
     2543                      branchDirection[iColumn]=0;
     2544                      priorities[iColumn]=0;
     2545                    }
     2546                    int nBadPseudo=0;
     2547                    int nBadDir=0;
     2548                    int nBadPri=0;
     2549                    int nBadName=0;
     2550                    int nBadLine=0;
     2551                    int nLine=0;
     2552                    while (fgets(line,1000,fp)) {
     2553                      nLine++;
     2554                      iColumn = -1;
     2555                      double up =0.0;
     2556                      double down=0.0;
     2557                      int pri=0;
     2558                      int dir=0;
     2559                      char * pos = line;
     2560                      char * put = line;
     2561                      while (*pos>=' '&&*pos!='\n') {
     2562                        if (*pos!=' '&&*pos!='\t') {
     2563                          *put=tolower(*pos);
     2564                          put++;
     2565                        }
     2566                      }
     2567                      *put='\0';
     2568                      pos=line;
     2569                      for (int i=0;i<nAcross;i++) {
     2570                        char * comma = strchr(pos,',');
     2571                        if (comma) {
     2572                          *comma='\0';
     2573                        } else if (i<nAcross-1) {
     2574                          nBadLine++;
     2575                          break;
     2576                        }
     2577                        switch (order[i]) {
     2578                          // name
     2579                        case 0:
     2580                          for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2581                            if (!strcmp(columnNames[iColumn],pos))
     2582                              break;
     2583                          }
     2584                          if (iColumn==numberColumns)
     2585                            iColumn=-1;
     2586                          break;
     2587                          // number
     2588                        case 1:
     2589                          iColumn = atoi(pos);
     2590                          if (iColumn<0||iColumn>=numberColumns)
     2591                            iColumn=-1;
     2592                          break;
     2593                          // direction
     2594                        case 2:
     2595                          if (*pos=='D')
     2596                            dir=-1;
     2597                          else if (*pos=='U')
     2598                            dir=1;
     2599                          else if (*pos=='N')
     2600                            dir=0;
     2601                          else if (*pos=='1'&&*(pos+1)=='\0')
     2602                            dir=1;
     2603                          else if (*pos=='0'&&*(pos+1)=='\0')
     2604                            dir=0;
     2605                          else if (*pos=='1'&&*(pos+1)=='1'&&*(pos+2)=='\0')
     2606                            dir=-1;
     2607                          else
     2608                            dir=-2; // bad
     2609                          break;
     2610                          // priority
     2611                        case 3:
     2612                          pri=atoi(pos);
     2613                          break;
     2614                          // up
     2615                        case 4:
     2616                          up = atof(pos);
     2617                          break;
     2618                          // down
     2619                        case 5:
     2620                          down = atof(pos);
     2621                          break;
     2622                        }
     2623                        if (comma) {
     2624                          *comma=',';
     2625                          pos=comma+1;
     2626                        }
     2627                      }
     2628                      if (iColumn>=0) {
     2629                        if (down<0.0) {
     2630                          nBadPseudo++;
     2631                          down=0.0;
     2632                        }
     2633                        if (up<0.0) {
     2634                          nBadPseudo++;
     2635                          up=0.0;
     2636                        }
     2637                        if (!up)
     2638                          up=down;
     2639                        if (!down)
     2640                          down=up;
     2641                        if (dir<-1||dir>1) {
     2642                          nBadDir++;
     2643                          dir=0;
     2644                        }
     2645                        if (pri<0) {
     2646                          nBadPri++;
     2647                          pri=0;
     2648                        }
     2649                        pseudoDown[iColumn]=down;
     2650                        pseudoUp[iColumn]=up;
     2651                        branchDirection[iColumn]=dir;
     2652                        priorities[iColumn]=pri;
     2653                      } else {
     2654                        nBadName++;
     2655                      }
     2656                    }
     2657                    if (!noPrinting) {
     2658                      printf("%d fields and %d records",nAcross,nLine);
     2659                      if (nBadPseudo)
     2660                        printf(" %d bad pseudo costs",nBadPseudo);
     2661                      if (nBadDir)
     2662                        printf(" %d bad directions",nBadDir);
     2663                      if (nBadPri)
     2664                        printf(" %d bad priorities",nBadPri);
     2665                      if (nBadName)
     2666                        printf(" ** %d records did not match on name/sequence",nBadName);
     2667                      printf("\n");
     2668                    }
     2669                    for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2670                      free(columnNames[iColumn]);
     2671                    }
     2672                    delete [] columnNames;
     2673                  } else {
     2674                    std::cout<<"Duplicate or unknown keyword - or name/number fields wrong"<<line<<std::endl;
     2675                  }
     2676                }
     2677                fclose(fp);
     2678              } else {
     2679                std::cout<<"Unable to open file "<<fileName<<std::endl;
    23532680              }
    23542681            } else {
  • trunk/Test/include/Cbc_ampl.h

    r237 r295  
    2727  int * columnStatus;
    2828  int * rowStatus;
     29  int * priorities;
     30  int * branchDirection;
     31  double * pseudoDown;
     32  double * pseudoUp;
    2933  char ** arguments;
    3034  char buffer[300];
  • trunk/include/CbcBranchActual.hpp

    r276 r295  
    6464  inline int cliqueType() const
    6565  {return cliqueType_;};
     66  /// Redoes data when sequence numbers change
     67  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
    6668
    6769protected:
     
    133135  */
    134136  virtual OsiSolverBranch * solverBranch() const;
     137  /// Redoes data when sequence numbers change
     138  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
    135139 
    136140  /// Number of members
     
    211215  */
    212216  virtual OsiSolverBranch * solverBranch() const;
     217  /// Redoes data when sequence numbers change
     218  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
    213219 
    214220  /** \brief Given a valid solution (with reduced costs, etc.),
     
    251257  inline int modelSequence() const
    252258  {return columnNumber_;};
     259  /// Set model column number
     260  inline void setColumnNumber(int value)
     261  {columnNumber_=value;};
    253262 
    254263  /** Column number if single column object -1 otherwise,
     
    340349  inline const int * members() const
    341350  {return members_;};
     351  /// Redoes data when sequence numbers change
     352  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
    342353
    343354protected:
  • trunk/include/CbcBranchBase.hpp

    r293 r295  
    184184  inline void setPreferredWay(int value)
    185185  { preferredWay_=value;};
     186  /// Redoes data when sequence numbers change
     187  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns) {};
    186188 
    187189protected:
  • trunk/include/CbcModel.hpp

    r287 r295  
    370370    If \p startAgain is true, a new scan is forced, overwriting any existing
    371371    integer variable information.
    372   */
    373 
    374   void findIntegers(bool startAgain);
     372    If type > 0 then 1==PseudoCost
     373  */
     374
     375  void findIntegers(bool startAgain,int type=0);
    375376
    376377  //@}
  • trunk/include/CbcStrategy.hpp

    r271 r295  
    145145  /// Set up preProcessing - see below
    146146  inline void setupPreProcessing(int desired=1, int passes=10)
    147   { desiredPreProcess_=1;preProcessPasses_=passes;};
     147  { desiredPreProcess_=desired;preProcessPasses_=passes;};
    148148  /// See what sort of preprocessing wanted
    149149  inline int desiredPreProcess() const
Note: See TracChangeset for help on using the changeset viewer.