Changeset 169 for trunk


Ignore:
Timestamp:
May 5, 2003 2:53:23 PM (17 years ago)
Author:
forrest
Message:

Fixes for Mikhail

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpModel.cpp

    r164 r169  
    2121#include "ClpModel.hpp"
    2222#include "ClpPackedMatrix.hpp"
     23#include "CoinPackedVector.hpp"
    2324#include "CoinIndexedVector.hpp"
    2425#include "CoinMpsIO.hpp"
     
    779780                                        number, which, newSize,false);
    780781    unsigned char * temp = new unsigned char [numberRows_+newSize];
    781     memcpy(temp,status_,newSize*sizeof(unsigned char));
     782    memcpy(temp,tempC,newSize*sizeof(unsigned char));
    782783    memcpy(temp+newSize,status_+numberColumns_,
    783784           numberRows_*sizeof(unsigned char));
     
    797798  integerType_ = deleteChar(integerType_,numberColumns_,
    798799                            number, which, newSize,true);
     800}
     801// Add rows
     802void
     803ClpModel::addRows(int number, const double * rowLower,
     804                  const double * rowUpper,
     805                  const int * rowStarts, const int * columns,
     806                  const double * elements)
     807{
     808  // Create a list of CoinPackedVectors
     809  if (number) {
     810    CoinPackedVectorBase ** rows=
     811      new CoinPackedVectorBase * [number];
     812    int iRow;
     813    for (iRow=0;iRow<number;iRow++) {
     814      int iStart = rowStarts[iRow];
     815      rows[iRow] =
     816        new CoinPackedVector(rowStarts[iRow+1]-iStart,
     817                             columns+iStart,elements+iStart);
     818    }
     819    addRows(number, rowLower, rowUpper,
     820            rows);
     821    for (iRow=0;iRow<number;iRow++)
     822      delete rows[iRow];
     823    delete [] rows;
     824  }
     825}
     826void
     827ClpModel::addRows(int number, const double * rowLower,
     828                  const double * rowUpper,
     829                  const CoinPackedVectorBase * const * rows)
     830{
     831  if (!number)
     832    return;
     833  int numberRowsNow = numberRows_;
     834  resize(numberRowsNow+number,numberColumns_);
     835  double * lower = rowLower_+numberRowsNow;
     836  double * upper = rowUpper_+numberRowsNow;
     837  int iRow;
     838  if (rowLower) {
     839    for (iRow = 0; iRow < number; iRow++) {
     840      double value = rowLower[iRow];
     841      if (value<-1.0e20)
     842        value = -COIN_DBL_MAX;
     843      lower[iRow]= value;
     844    }
     845  } else {
     846    for (iRow = 0; iRow < number; iRow++) {
     847      lower[iRow]= -COIN_DBL_MAX;
     848    }
     849  }
     850  if (rowUpper) {
     851    for (iRow = 0; iRow < number; iRow++) {
     852      double value = rowUpper[iRow];
     853      if (value>1.0e20)
     854        value = COIN_DBL_MAX;
     855      upper[iRow]= value;
     856    }
     857  } else {
     858    for (iRow = 0; iRow < number; iRow++) {
     859      upper[iRow]= COIN_DBL_MAX;
     860    }
     861  }
     862  // Deal with matrix
     863
     864  delete rowCopy_;
     865  rowCopy_=NULL;
     866  if (!matrix_)
     867    createEmptyMatrix();
     868  // Use matrix() to get round virtual problem
     869  matrix()->appendRows(number,rows);
     870}
     871// Add columns
     872void
     873ClpModel::addColumns(int number, const double * columnLower,
     874                     const double * columnUpper,
     875                     const double * objIn,
     876                     const int * columnStarts, const int * rows,
     877                     const double * elements)
     878{
     879  // Create a list of CoinPackedVectors
     880  if (number) {
     881    CoinPackedVectorBase ** columns=
     882      new CoinPackedVectorBase * [number];
     883    int iColumn;
     884    for (iColumn=0;iColumn<number;iColumn++) {
     885      int iStart = columnStarts[iColumn];
     886      columns[iColumn] =
     887        new CoinPackedVector(columnStarts[iColumn+1]-iStart,
     888                             rows+iStart,elements+iStart);
     889    }
     890    addColumns(number, columnLower, columnUpper,
     891               objIn, columns);
     892    for (iColumn=0;iColumn<number;iColumn++)
     893      delete columns[iColumn];
     894    delete [] columns;
     895
     896  }
     897}
     898void
     899ClpModel::addColumns(int number, const double * columnLower,
     900                     const double * columnUpper,
     901                     const double * objIn,
     902                     const CoinPackedVectorBase * const * columns)
     903{
     904  if (!number)
     905    return;
     906  int numberColumnsNow = numberColumns_;
     907  resize(numberRows_,numberColumnsNow+number);
     908  double * lower = columnLower_+numberColumnsNow;
     909  double * upper = columnUpper_+numberColumnsNow;
     910  double * obj = objective()+numberColumnsNow;
     911  int iColumn;
     912  if (columnLower) {
     913    for (iColumn = 0; iColumn < number; iColumn++) {
     914      double value = columnLower[iColumn];
     915      if (value<-1.0e20)
     916        value = -COIN_DBL_MAX;
     917      lower[iColumn]= value;
     918    }
     919  } else {
     920    for (iColumn = 0; iColumn < number; iColumn++) {
     921      lower[iColumn]= 0.0;
     922    }
     923  }
     924  if (columnUpper) {
     925    for (iColumn = 0; iColumn < number; iColumn++) {
     926      double value = columnUpper[iColumn];
     927      if (value>1.0e20)
     928        value = COIN_DBL_MAX;
     929      upper[iColumn]= value;
     930    }
     931  } else {
     932    for (iColumn = 0; iColumn < number; iColumn++) {
     933      upper[iColumn]= COIN_DBL_MAX;
     934    }
     935  }
     936  if (objIn) {
     937    for (iColumn = 0; iColumn < number; iColumn++) {
     938      obj[iColumn] = objIn[iColumn];
     939    }
     940  } else {
     941    for (iColumn = 0; iColumn < number; iColumn++) {
     942      obj[iColumn]= 0.0;
     943    }
     944  }
     945  // Deal with matrix
     946
     947  delete rowCopy_;
     948  rowCopy_=NULL;
     949  if (!matrix_)
     950    createEmptyMatrix();
     951  // Use matrix() to get round virtual problem
     952  matrix()->appendCols(number,columns);
    799953}
    800954// Infeasibility/unbounded ray (NULL returned if none/wrong)
  • trunk/ClpSimplex.cpp

    r166 r169  
    478478  if (!factorization_->status()) {
    479479    // put in standard form
    480     createRim(7+8+16);
     480    createRim(7+8+16+32);
    481481    // do work
    482482    gutsOfSolution ( rowActivities, columnActivities,NULL,NULL);
    483483    // release extra memory
    484     deleteRim(false);
     484    deleteRim(0);
    485485  }
    486486  return factorization_->status();
     
    505505{
    506506  // put in standard form
    507   createRim(7+8+16);
     507  createRim(7+8+16+32,false);
    508508  // do work
    509509  int status = internalFactorize(-1);
    510510  // release extra memory
    511   deleteRim(false);
     511  deleteRim(0);
    512512
    513513  return status;
     
    17851785  bool goodMatrix=true;
    17861786  int i;
    1787   if ((what&16)!=0) {
     1787  if ((what&(16+32))!=0) {
    17881788    // move information to work arrays
    17891789    if (optimizationDirection_<0.0) {
     
    18021802      memcpy(rowReducedCost_,dual_,numberRows_*sizeof(double));
    18031803    }
    1804     if (!solution_) {
    1805       solution_ = new double[numberRows_+numberColumns_];
     1804    if (!solution_||(what&32)!=0) {
     1805      if (!solution_)
     1806        solution_ = new double[numberRows_+numberColumns_];
    18061807      columnActivityWork_ = solution_;
    18071808      rowActivityWork_ = solution_+numberColumns_;
     
    18111812             numberRows_*sizeof(double));
    18121813    }
     1814  }
     1815  if ((what&16)!=0) {
    18131816    //check matrix
    18141817    if (!matrix_->allElementsInRange(this,smallElement_,1.0e20)) {
     
    19021905    }
    19031906  }
    1904   if ((what&1)!=0&&rowScale_) {
     1907  if ((what&(1+32))!=0&&rowScale_) {
    19051908    for (i=0;i<numberColumns_;i++) {
    19061909      double multiplier = 1.0/columnScale_[i];
     
    19171920    }
    19181921  }
    1919   if ((what&8)!=0&&rowScale_) {
     1922  if ((what&(8+32))!=0&&rowScale_) {
    19201923    // on entry
    19211924    for (i=0;i<numberColumns_;i++) {
     
    19681971}
    19691972void
    1970 ClpSimplex::deleteRim(bool getRidOfFactorizationData)
     1973ClpSimplex::deleteRim(int getRidOfFactorizationData)
    19711974{
    19721975  int i;
     
    20162019  // scaling may have been turned off
    20172020  scalingFlag_ = abs(scalingFlag_);
    2018   if(getRidOfFactorizationData)
    2019     gutsOfDelete(2);
    2020   else
    2021     gutsOfDelete(1);
     2021  if(getRidOfFactorizationData>=0)
     2022    gutsOfDelete(getRidOfFactorizationData+1);
    20222023}
    20232024void
     
    33263327#endif
    33273328  // release extra memory
    3328   deleteRim(false);
     3329  deleteRim(0);
    33293330}
    33303331/* Crash - at present just aimed at dual, returns
     
    41534154  assert (internalFactorize(1)==0);
    41544155  // put back original costs and then check
    4155   createRim(4);
     4156  // also move to work arrays
     4157  createRim(4+32);
     4158  abort();
     4159  //memcpy(rowActivityWork_,rowActivity_,numberRows_*sizeof(double));
     4160  //memcpy(columnActivityWork_,columnActivity_,numberColumns_*sizeof(double));
    41564161  gutsOfSolution(rowActivityWork_, columnActivityWork_,NULL,NULL);
     4162  //memcpy(rowActivity_,rowActivityWork_,numberRows_*sizeof(double));
     4163  //memcpy(columnActivity_,columnActivityWork_,numberColumns_*sizeof(double));
     4164  //memcpy(reducedCost_,dj_,numberColumns_*sizeof(double));
     4165  deleteRim(-1);
    41574166  return (primalFeasible()&&dualFeasible());
    41584167}
  • trunk/include/ClpSimplex.hpp

    r166 r169  
    490490  bool createRim(int what,bool makeRowCopy=false);
    491491  /** releases above arrays and does solution scaling out.  May also
    492       get rid of factorization data */
    493   void deleteRim(bool getRidOfFactorizationData=true);
     492      get rid of factorization data -
     493      0 get rid of nothing, 1 get rid of arrays, 2 also factorization
     494  */
     495  void deleteRim(int getRidOfFactorizationData=2);
    494496  /// Sanity check on input rim data (after scaling) - returns true if okay
    495497  bool sanityCheck();
Note: See TracChangeset for help on using the changeset viewer.