Changeset 653


Ignore:
Timestamp:
Aug 10, 2005 3:42:46 AM (15 years ago)
Author:
forrest
Message:

for slim

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpMatrixBase.cpp

    r634 r653  
    164164  return weights;
    165165}
     166#ifndef CLP_NO_VECTOR
    166167// Append Columns
    167168void
     
    178179  abort();
    179180}
     181#endif
    180182/* Returns largest and smallest elements of both signs.
    181183   Largest refers to largest absolute value.
  • trunk/ClpMessage.cpp

    r648 r653  
    1111  const char * message;
    1212} Clp_message;
    13 static Clp_message us_english[]=
     13static Clp_message clp_us_english[]=
    1414{
    1515  {CLP_SIMPLEX_FINISHED,0,1,"Optimal - objective value %g"},
     
    110110/* Constructor */
    111111ClpMessage::ClpMessage(Language language) :
    112   CoinMessages(sizeof(us_english)/sizeof(Clp_message))
     112  CoinMessages(sizeof(clp_us_english)/sizeof(Clp_message))
    113113{
    114114  language_=language;
    115115  strcpy(source_,"Clp");
    116116  class_ = 1; //solver
    117   Clp_message * message = us_english;
     117  Clp_message * message = clp_us_english;
    118118
    119119  while (message->internalNumber!=CLP_DUMMY_END) {
  • trunk/ClpModel.cpp

    r651 r653  
    2020#include "ClpPlusMinusOneMatrix.hpp"
    2121#endif
     22#ifndef CLP_NO_VECTOR
    2223#include "CoinPackedVector.hpp"
     24#endif
    2325#include "CoinIndexedVector.hpp"
    2426#if SLIM_CLP==2
     
    7375  secondaryStatus_(0),
    7476  lengthNames_(0),
     77#ifndef CLP_NO_STD
    7578  defaultHandler_(true),
    7679  rowNames_(),
    7780  columnNames_()
     81#else
     82  defaultHandler_(true)
     83#endif
    7884{
    7985  intParam_[ClpMaxNumIteration] = 99999999;
     
    8793  dblParam_[ClpMaxSeconds] = -1.0;
    8894
     95#ifndef CLP_NO_STD
    8996  strParam_[ClpProbName] = "ClpDefaultName";
     97#endif
    9098  handler_ = new CoinMessageHandler();
    9199  handler_->setLogLevel(1);
     
    360368  }
    361369#endif
     370#ifndef CLP_NO_STD
    362371  // Do names if wanted
    363372  int numberItems;
     
    372381    copyColumnNames(columnNames,0,numberItems);
    373382  }
     383#endif
    374384  // Do integers if wanted
    375385  assert(integerType);
     
    638648  dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
    639649  dblParam_[ClpMaxSeconds] = rhs.dblParam_[ClpMaxSeconds];
     650#ifndef CLP_NO_STD
    640651
    641652  strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
     653#endif
    642654
    643655  optimizationDirection_ = rhs.optimizationDirection_;
     
    656668  scalingFlag_ = rhs.scalingFlag_;
    657669  if (trueCopy) {
     670#ifndef CLP_NO_STD
    658671    lengthNames_ = rhs.lengthNames_;
    659672    if (lengthNames_) {
     
    661674      columnNames_ = rhs.columnNames_;
    662675    }
     676#endif
    663677    if (rhs.integerType_) {
    664678      integerType_ = new char[numberColumns_];
     
    729743    //columnScale_ = rhs.columnScale_;
    730744    lengthNames_ = 0;
     745#ifndef CLP_NO_STD
    731746    rowNames_ = std::vector<std::string> ();
    732747    columnNames_ = std::vector<std::string> ();
     748#endif
    733749    integerType_ = NULL;
    734750    status_ = rhs.status_;
     
    853869
    854870//-----------------------------------------------------------------------------
     871#ifndef CLP_NO_STD
    855872
    856873bool
     
    868885  return true;
    869886}
     887#endif
    870888// Useful routines
    871889// Returns resized array and deletes incoming
     
    10381056  }
    10391057  numberColumns_ = newNumberColumns;
     1058#ifndef CLP_NO_STD
    10401059  if (lengthNames_) {
    10411060    // reduce row and column names vectors only if necessary
     
    10451064      columnNames_.resize(numberColumns_);
    10461065  }
     1066#endif
    10471067}
    10481068// Deletes rows
     
    10851105    }
    10861106  }
    1087 #if 1
     1107#ifndef CLP_NO_STD
    10881108  // Now works if which out of order
    10891109  if (lengthNames_) {
     
    11011121    delete [] mark;
    11021122  }
    1103 #else
    1104   // for now gets rid of names
    1105   lengthNames_ = 0;
    1106   rowNames_ = std::vector<std::string> ();
    1107   columnNames_ = std::vector<std::string> ();
    11081123#endif
    11091124  numberRows_=newSize;
     
    11711186  integerType_ = deleteChar(integerType_,numberColumns_,
    11721187                            number, which, newSize,true);
    1173 #if 1
     1188#ifndef CLP_NO_STD
    11741189  // Now works if which out of order
    11751190  if (lengthNames_) {
     
    11871202    delete [] mark;
    11881203  }
    1189 #else
    1190   // for now gets rid of names
    1191   lengthNames_ = 0;
    1192   rowNames_ = std::vector<std::string> ();
    1193   columnNames_ = std::vector<std::string> ();
    11941204#endif
    11951205  numberColumns_=newSize;
     
    12091219                 const double * elements, double rowLower, double rowUpper)
    12101220{
    1211   // Create a CoinPackedVector
    1212   CoinPackedVectorBase * row=
    1213     new CoinPackedVector(numberInRow,columns,elements);
    1214   addRows(1, &rowLower, &rowUpper,
    1215           &row);
    1216   delete row;
     1221  CoinBigIndex starts[2];
     1222  starts[0]=0;
     1223  starts[1]=numberInRow;
     1224  addRows(1, &rowLower, &rowUpper,starts,columns,elements);
    12171225}
    12181226// Add rows
     
    12231231                  const double * elements)
    12241232{
    1225   // Create a list of CoinPackedVectors
    12261233  if (number) {
    1227     CoinPackedVectorBase ** rows=
    1228       new CoinPackedVectorBase * [number];
     1234    whatsChanged_ &= ~(1+2+8+16+32); // all except columns changed
     1235    int numberRowsNow = numberRows_;
     1236    resize(numberRowsNow+number,numberColumns_);
     1237    double * lower = rowLower_+numberRowsNow;
     1238    double * upper = rowUpper_+numberRowsNow;
    12291239    int iRow;
    1230     for (iRow=0;iRow<number;iRow++) {
    1231       int iStart = rowStarts[iRow];
    1232       rows[iRow] =
    1233         new CoinPackedVector(rowStarts[iRow+1]-iStart,
    1234                              columns+iStart,elements+iStart);
    1235     }
    1236     addRows(number, rowLower, rowUpper,
    1237             rows);
    1238     for (iRow=0;iRow<number;iRow++)
    1239       delete rows[iRow];
    1240     delete [] rows;
     1240    if (rowLower) {
     1241      for (iRow = 0; iRow < number; iRow++) {
     1242        double value = rowLower[iRow];
     1243        if (value<-1.0e20)
     1244          value = -COIN_DBL_MAX;
     1245        lower[iRow]= value;
     1246      }
     1247    } else {
     1248      for (iRow = 0; iRow < number; iRow++) {
     1249        lower[iRow]= -COIN_DBL_MAX;
     1250      }
     1251    }
     1252    if (rowUpper) {
     1253      for (iRow = 0; iRow < number; iRow++) {
     1254        double value = rowUpper[iRow];
     1255        if (value>1.0e20)
     1256          value = COIN_DBL_MAX;
     1257        upper[iRow]= value;
     1258      }
     1259    } else {
     1260      for (iRow = 0; iRow < number; iRow++) {
     1261        upper[iRow]= COIN_DBL_MAX;
     1262      }
     1263    }
     1264    // Deal with matrix
     1265   
     1266    delete rowCopy_;
     1267    rowCopy_=NULL;
     1268    if (!matrix_)
     1269      createEmptyMatrix();
     1270    delete [] rowScale_;
     1271    rowScale_ = NULL;
     1272    delete [] columnScale_;
     1273    columnScale_ = NULL;
     1274#ifndef CLP_NO_STD
     1275    if (lengthNames_) {
     1276      rowNames_.resize(numberRows_);
     1277    }
     1278#endif
     1279    if (elements)
     1280      matrix_->appendMatrix(number,0,rowStarts,columns,elements);
    12411281  }
    12421282}
     
    12491289                  const double * elements)
    12501290{
    1251   // Create a list of CoinPackedVectors
    12521291  if (number) {
    1253     CoinPackedVectorBase ** rows=
    1254       new CoinPackedVectorBase * [number];
     1292    CoinBigIndex numberElements=0;
    12551293    int iRow;
     1294    for (iRow=0;iRow<number;iRow++)
     1295      numberElements += rowLengths[iRow];
     1296    int * newStarts = new int[number+1];
     1297    int * newIndex = new int[numberElements];
     1298    double * newElements = new double[numberElements];
     1299    numberElements=0;
     1300    newStarts[0]=0;
    12561301    for (iRow=0;iRow<number;iRow++) {
    12571302      int iStart = rowStarts[iRow];
    1258       rows[iRow] =
    1259         new CoinPackedVector(rowLengths[iRow],
    1260                              columns+iStart,elements+iStart);
     1303      int length = rowLengths[iRow];
     1304      memcpy(newIndex+numberElements,columns+iStart,length*sizeof(int));
     1305      memcpy(newElements+numberElements,elements+iStart,length*sizeof(double));
     1306      numberElements += length;
     1307      newStarts[iRow+1]=numberElements;
    12611308    }
    12621309    addRows(number, rowLower, rowUpper,
    1263             rows);
    1264     for (iRow=0;iRow<number;iRow++)
    1265       delete rows[iRow];
    1266     delete [] rows;
    1267   }
    1268 }
     1310            newStarts,newIndex,newElements);
     1311    delete [] newStarts;
     1312    delete [] newIndex;
     1313    delete [] newElements;
     1314  }
     1315}
     1316#ifndef CLP_NO_VECTOR
    12691317void
    12701318ClpModel::addRows(int number, const double * rowLower,
     
    13201368  }
    13211369}
     1370#endif
    13221371#ifndef SLIM_CLP
    13231372// Add rows from a build object
     
    15621611      }
    15631612      assert (rowLower);
    1564       addRows(numberRows2, rowLower, rowUpper,NULL);
     1613      addRows(numberRows2, rowLower, rowUpper,NULL,NULL,NULL);
    15651614#ifndef SLIM_CLP
    15661615      if (!tryPlusMinusOne) {
     
    16391688                 double  objective)
    16401689{
    1641   whatsChanged_ &= ~(1+2+4+64+128+256); // all except rows changed
    1642   CoinPackedVectorBase * column=
    1643     new CoinPackedVector(numberInColumn,
    1644                            rows,elements);
    1645   addColumns(1, &columnLower, &columnUpper,
    1646                &objective, &column);
    1647   delete column;
    1648 
    1649   delete [] rowScale_;
    1650   rowScale_ = NULL;
    1651   delete [] columnScale_;
    1652   columnScale_ = NULL;
     1690  CoinBigIndex starts[2];
     1691  starts[0]=0;
     1692  starts[1]=numberInColumn;
     1693  addColumns(1, &columnLower, &columnUpper,&objective,starts,rows,elements);
    16531694}
    16541695// Add columns
     
    16631704  if (number) {
    16641705    whatsChanged_ &= ~(1+2+4+64+128+256); // all except rows changed
    1665     CoinPackedVectorBase ** columns=
    1666       new CoinPackedVectorBase * [number];
     1706    int numberColumnsNow = numberColumns_;
     1707    resize(numberRows_,numberColumnsNow+number);
     1708    double * lower = columnLower_+numberColumnsNow;
     1709    double * upper = columnUpper_+numberColumnsNow;
     1710    double * obj = objective()+numberColumnsNow;
    16671711    int iColumn;
    1668     for (iColumn=0;iColumn<number;iColumn++) {
    1669       int iStart = columnStarts[iColumn];
    1670       columns[iColumn] =
    1671         new CoinPackedVector(columnStarts[iColumn+1]-iStart,
    1672                              rows+iStart,elements+iStart);
    1673     }
    1674     addColumns(number, columnLower, columnUpper,
    1675                objIn, columns);
    1676     for (iColumn=0;iColumn<number;iColumn++)
    1677       delete columns[iColumn];
    1678     delete [] columns;
    1679 
    1680   }
    1681   delete [] rowScale_;
    1682   rowScale_ = NULL;
    1683   delete [] columnScale_;
    1684   columnScale_ = NULL;
     1712    if (columnLower) {
     1713      for (iColumn = 0; iColumn < number; iColumn++) {
     1714        double value = columnLower[iColumn];
     1715        if (value<-1.0e20)
     1716          value = -COIN_DBL_MAX;
     1717        lower[iColumn]= value;
     1718      }
     1719    } else {
     1720      for (iColumn = 0; iColumn < number; iColumn++) {
     1721        lower[iColumn]= 0.0;
     1722      }
     1723    }
     1724    if (columnUpper) {
     1725      for (iColumn = 0; iColumn < number; iColumn++) {
     1726        double value = columnUpper[iColumn];
     1727        if (value>1.0e20)
     1728          value = COIN_DBL_MAX;
     1729        upper[iColumn]= value;
     1730      }
     1731    } else {
     1732      for (iColumn = 0; iColumn < number; iColumn++) {
     1733        upper[iColumn]= COIN_DBL_MAX;
     1734      }
     1735    }
     1736    if (objIn) {
     1737      for (iColumn = 0; iColumn < number; iColumn++) {
     1738        obj[iColumn] = objIn[iColumn];
     1739      }
     1740    } else {
     1741      for (iColumn = 0; iColumn < number; iColumn++) {
     1742        obj[iColumn]= 0.0;
     1743      }
     1744    }
     1745    // Deal with matrix
     1746   
     1747    delete rowCopy_;
     1748    rowCopy_=NULL;
     1749    if (!matrix_)
     1750      createEmptyMatrix();
     1751    delete [] rowScale_;
     1752    rowScale_ = NULL;
     1753    delete [] columnScale_;
     1754    columnScale_ = NULL;
     1755#ifndef CLP_NO_STD
     1756    if (lengthNames_) {
     1757      columnNames_.resize(numberColumns_);
     1758    }
     1759#endif
     1760    if (elements)
     1761      matrix_->appendMatrix(number,1,columnStarts,rows,elements);
     1762  }
    16851763}
    16861764// Add columns
     
    16931771                     const double * elements)
    16941772{
    1695   // Create a list of CoinPackedVectors
    16961773  if (number) {
    1697     whatsChanged_ &= ~(1+2+4+64+128+256); // all except rows changed
    1698     CoinPackedVectorBase ** columns=
    1699       new CoinPackedVectorBase * [number];
     1774    CoinBigIndex numberElements=0;
    17001775    int iColumn;
     1776    for (iColumn=0;iColumn<number;iColumn++)
     1777      numberElements += columnLengths[iColumn];
     1778    int * newStarts = new int[number+1];
     1779    int * newIndex = new int[numberElements];
     1780    double * newElements = new double[numberElements];
     1781    numberElements=0;
     1782    newStarts[0]=0;
    17011783    for (iColumn=0;iColumn<number;iColumn++) {
    17021784      int iStart = columnStarts[iColumn];
    1703       columns[iColumn] =
    1704         new CoinPackedVector(columnLengths[iColumn],
    1705                              rows+iStart,elements+iStart);
    1706     }
    1707     addColumns(number, columnLower, columnUpper,
    1708                objIn, columns);
    1709     for (iColumn=0;iColumn<number;iColumn++)
    1710       delete columns[iColumn];
    1711     delete [] columns;
    1712 
    1713   }
    1714   delete [] rowScale_;
    1715   rowScale_ = NULL;
    1716   delete [] columnScale_;
    1717   columnScale_ = NULL;
    1718 }
     1785      int length = columnLengths[iColumn];
     1786      memcpy(newIndex+numberElements,rows+iStart,length*sizeof(int));
     1787      memcpy(newElements+numberElements,elements+iStart,length*sizeof(double));
     1788      numberElements += length;
     1789      newStarts[iColumn+1]=numberElements;
     1790    }
     1791    addColumns(number, columnLower, columnUpper,objIn,
     1792            newStarts,newIndex,newElements);
     1793    delete [] newStarts;
     1794    delete [] newIndex;
     1795    delete [] newElements;
     1796  }
     1797}
     1798#ifndef CLP_NO_VECTOR
    17191799void
    17201800ClpModel::addColumns(int number, const double * columnLower,
     
    17811861  }
    17821862}
     1863#endif
    17831864#ifndef SLIM_CLP
    17841865// Add columns from a build object
     
    19732054      }
    19742055      assert (columnLower);
    1975       addColumns(numberColumns2, columnLower, columnUpper,objective, NULL);
     2056      addColumns(numberColumns2, columnLower, columnUpper,objective, NULL,NULL,NULL);
    19762057#ifndef SLIM_CLP
    19772058      if (!tryPlusMinusOne) {
     
    20082089      }
    20092090#endif
     2091#ifndef CLP_NO_STD
    20102092      // Do names if wanted
    20112093      if (modelObject.columnNames()->numberItems()) {
     
    20132095        copyColumnNames(columnNames,numberColumns,numberColumns_);
    20142096      }
     2097#endif
    20152098      // Do integers if wanted
    20162099      assert(integerType);
     
    22742357      delete [] element;
    22752358    }
    2276 #endif   
     2359#endif
     2360#ifndef CLP_NO_STD   
    22772361    // set problem name
    22782362    setStrParam(ClpProbName,m.getProblemName());
     
    23012385      lengthNames_=0;
    23022386    }
     2387#endif
    23032388    setDblParam(ClpObjOffset,m.objectiveOffset());
    23042389    time2 = CoinCpuTime();
     
    23562441      integerType_ = NULL;
    23572442    }
     2443#ifndef CLP_NO_STD
    23582444    // set problem name
    23592445    setStrParam(ClpProbName,m.getProblemName());
     
    23822468      lengthNames_=0;
    23832469    }
     2470#endif
    23842471    setDblParam(ClpObjOffset,m.objectiveOffset());
    23852472    time2 = CoinCpuTime();
     
    24902577  }
    24912578}
     2579#ifndef CLP_NO_STD
    24922580// Drops names - makes lengthnames 0 and names empty
    24932581void
     
    24982586  columnNames_ = std::vector<std::string> ();
    24992587}
     2588#endif
    25002589// Drop integer informations
    25012590void
     
    26402729  dblParam_[ClpObjOffset] = rhs->dblParam_[ClpObjOffset];
    26412730  dblParam_[ClpMaxSeconds] = rhs->dblParam_[ClpMaxSeconds];
    2642 
     2731#ifndef CLP_NO_STD
    26432732  strParam_[ClpProbName] = rhs->strParam_[ClpProbName];
     2733#endif
    26442734
    26452735  optimizationDirection_ = rhs->optimizationDirection_;
     
    26682758  numberColumns_ = numberColumns;
    26692759  userPointer_ = rhs->userPointer_;
     2760#ifndef CLP_NO_STD
    26702761  if (!dropNames) {
    26712762    unsigned int maxLength=0;
     
    26902781    columnNames_ = std::vector<std::string> ();
    26912782  }
     2783#endif
    26922784  if (rhs->integerType_&&!dropIntegers) {
    26932785    integerType_ = whichChar(rhs->integerType_,numberColumns,whichColumn);
     
    27432835  CoinSeedRandom(1234567);
    27442836}
     2837#ifndef CLP_NO_STD
    27452838// Copies in names
    27462839void
     
    29032996  lengthNames_=(int) maxLength;
    29042997}
     2998#endif
    29052999// Primal objective limit
    29063000void
     
    30703164  char ** rowNames = NULL;
    30713165  char ** columnNames = NULL;
     3166#ifndef CLP_NO_STD
    30723167  if (lengthNames()) {
    30733168    rowNames = new char * [numberRows_];
     
    31053200    }
    31063201  }
     3202#endif
    31073203  CoinMpsIO writer;
    31083204  writer.passInMessageHandler(handler_);
  • trunk/ClpPackedMatrix.cpp

    r650 r653  
    12601260  return ((numberInRowArray>factor*numberRows||!model->rowCopy())&&!hasGaps_);
    12611261}
     1262#ifndef CLP_ALL_ONE_FILE
    12621263// These have to match ClpPrimalColumnSteepest version
    12631264#define reference(i)  (((reference[i>>5]>>(i&31))&1)!=0)
     1265#endif
    12641266// Updates two arrays for steepest
    12651267void
     
    28212823  matrix_->setExtraGap(1.0e-50);
    28222824}
     2825#ifndef CLP_NO_VECTOR
    28232826// Append Columns
    28242827void
     
    28372840  hasGaps_=true;
    28382841}
     2842#endif
    28392843/* Set the dimensions of the matrix. In effect, append new empty
    28402844   columns/rows to the matrix. A negative number for either dimension
     
    28712875  return numberErrors;
    28722876}
     2877#ifdef CLP_ALL_ONE_FILE
     2878#undef reference
     2879#endif
  • trunk/ClpPresolve.cpp

    r650 r653  
    5353  numberPasses_(5),
    5454  substitution_(3),
     55#ifndef CLP_NO_STD
    5556  saveFile_(""),
     57#endif
    5658  presolveActions_(0)
    5759{
     
    100102                                doRowObjective);
    101103}
     104#ifndef CLP_NO_STD
    102105/* This version of presolve updates
    103106   model and saves original data to file.  Returns non-zero if infeasible
     
    126129  }
    127130}
    128 
     131#endif
    129132// Return pointer to presolved model
    130133ClpSimplex *
     
    166169  unsigned char * rowstat=NULL;
    167170  unsigned char * colstat = NULL;
     171#ifndef CLP_NO_STD
    168172  if (saveFile_=="") {
     173#endif
    169174    // reality check
    170175    assert(ncols0==originalModel_->getNumCols());
     
    189194      memcpy(rowstat, presolvedModel_->statusArray()+ncols, nrows);
    190195    }
     196#ifndef CLP_NO_STD
    191197  } else {
    192198    // from file
     
    203209    }
    204210  }
     211#endif
    205212
    206213  // CoinPostsolveMatrix object assumes ownership of sol, acts, colstat;
     
    221228  postsolve(prob);
    222229
     230#ifndef CLP_NO_STD
    223231  if (saveFile_!="") {
    224232    // From file
     
    235243    }
    236244  } else {
     245#endif
    237246    prob.sol_ = 0 ;
    238247    prob.acts_ = 0 ;
    239248    prob.colstat_ = 0 ;
    240   }
     249#ifndef CLP_NO_STD
     250  }
     251#endif
    241252  // put back duals
    242253  memcpy(originalModel_->dualRowSolution(),prob.rowduals_,
     
    288299    originalModel_->setProblemStatus( presolvedModel_->status());
    289300  }
     301#ifndef CLP_NO_STD
    290302  if (saveFile_!="")
    291303    presolvedModel_=NULL;
     304#endif
    292305}
    293306
     
    14201433  while (result==-1) {
    14211434
     1435#ifndef CLP_NO_STD
    14221436    // make new copy
    14231437    if (saveFile_=="") {
     1438#endif
    14241439      delete presolvedModel_;
     1440#ifndef CLP_NO_STD
    14251441      // So won't get names
    14261442      int lengthNames = originalModel->lengthNames();
    14271443      originalModel->setLengthNames(0);
     1444#endif
    14281445      presolvedModel_ = new ClpSimplex(*originalModel);
     1446#ifndef CLP_NO_STD
    14291447      originalModel->setLengthNames(lengthNames);
    14301448    } else {
     
    14321450    }
    14331451    presolvedModel_->dropNames();
     1452#endif
    14341453
    14351454    // drop integer information if wanted
     
    15941613      delete [] prob.originalRow_;
    15951614      prob.originalRow_=NULL;
     1615#ifndef CLP_NO_STD
    15961616      if (!dropNames&&originalModel->lengthNames()) {
    15971617        // Redo names
     
    16131633        presolvedModel_->copyNames(rowNames,columnNames);
    16141634      }
     1635#endif
    16151636      if (rowObjective_) {
    16161637        int iRow;
     
    16851706    } else {
    16861707      // no changes - model needs restoring after Lou's changes
     1708#ifndef CLP_NO_STD
    16871709      if (saveFile_=="") {
     1710#endif
    16881711        delete presolvedModel_;
    16891712        presolvedModel_ = new ClpSimplex(*originalModel);
     1713#ifndef CLP_NO_STD
    16901714      } else {
    16911715        presolvedModel_=originalModel;
    16921716      }
    16931717      presolvedModel_->dropNames();
     1718#endif
    16941719     
    16951720      // drop integer information if wanted
  • trunk/ClpSimplex.cpp

    r652 r653  
    49054905  int matrixStorageChoice;
    49064906} Clp_scalars;
    4907 
     4907#ifndef SLIM_NOIO
    49084908int outDoubleArray(double * array, int length, FILE * fp)
    49094909{
     
    49314931  if (fp) {
    49324932    Clp_scalars scalars;
    4933     int i;
    49344933    CoinBigIndex numberWritten;
    49354934    // Fill in scalars
     
    49664965    if (numberWritten!=1)
    49674966      return 1;
     4967    CoinBigIndex length;
     4968#ifndef CLP_NO_STD
     4969    int i;
    49684970    // strings
    4969     CoinBigIndex length;
    49704971    for (i=0;i<ClpLastStrParam;i++) {
    49714972      length = strParam_[i].size();
     
    49794980      }
    49804981    }
     4982#endif
    49814983    // arrays - in no particular order
    49824984    if (outDoubleArray(rowActivity_,numberRows_,fp))
     
    50285030        return 1;
    50295031    }
     5032#ifndef CLP_NO_STD
    50305033    if (lengthNames_) {
    50315034      char * array =
     
    50535056      delete [] array;
    50545057    }
     5058#endif
    50555059    // just standard type at present
    50565060    assert (matrix_->type()==1);
     
    51615165    // strings
    51625166    CoinBigIndex length;
     5167#ifndef CLP_NO_STD
    51635168    for (i=0;i<ClpLastStrParam;i++) {
    51645169      numberRead = fread(&length,sizeof(int),1,fp);
     
    51755180      }
    51765181    }
     5182#endif
    51775183    // arrays - in no particular order
    51785184    if (inDoubleArray(rowActivity_,numberRows_,fp))
     
    52285234        return 1;
    52295235    }
     5236#ifndef CLP_NO_STD
    52305237    if (lengthNames_) {
    52315238      char * array =
     
    52535260      delete [] array;
    52545261    }
     5262#endif
    52555263    // Pivot choices
    52565264    assert(scalars.dualPivotChoice>0&&(scalars.dualPivotChoice&63)<3);
     
    53345342  return 0;
    53355343}
     5344#endif
    53365345// value of incoming variable (in Dual)
    53375346double
  • trunk/ClpSimplexDual.cpp

    r652 r653  
    31163116  return bestPossible;
    31173117}
     3118#ifdef CLP_ALL_ONE_FILE
     3119#undef MAXTRY
     3120#endif
    31183121/* Checks if tentative optimal actually means unbounded
    31193122   Returns -3 if not, 2 if is unbounded */
  • trunk/ClpSolve.cpp

    r651 r653  
    539539      pinfo.setDoSingletonColumn(true);
    540540    }
     541#ifndef CLP_NO_STD
    541542    if (presolveToFile) {
    542543      // PreSolve to file - not fully tested
     
    546547      model2=this;
    547548    } else {
     549#endif
    548550      model2 = pinfo.presolvedModel(*this,1.0e-8,
    549551                                    false,numberPasses,true,costedSlacks);
    550     }
     552#ifndef CLP_NO_STD
     553    }
     554#endif
    551555    time2 = CoinCpuTime();
    552556    timePresolve = time2-timeX;
  • trunk/include/ClpMatrixBase.hpp

    r634 r653  
    5959  /** Delete the rows whose indices are listed in <code>indDel</code>. */
    6060  virtual void deleteRows(const int numDel, const int * indDel) = 0;
     61#ifndef CLP_NO_VECTOR
    6162  /// Append Columns
    6263  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
    6364  /// Append Rows
    6465  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
     66#endif
    6567  /** Modify one element of packed matrix.  An element may be added.
    6668      This works for either ordering If the new element is zero it will be
  • trunk/include/ClpModel.hpp

    r637 r653  
    147147  void addRows(int number, const double * rowLower,
    148148               const double * rowUpper,
    149                const int * rowStarts, const int * columns,
     149               const CoinBigIndex * rowStarts, const int * columns,
    150150               const double * elements);
    151151  /// Add rows
    152152  void addRows(int number, const double * rowLower,
    153153               const double * rowUpper,
    154                const int * rowStarts, const int * rowLengths,
     154               const CoinBigIndex * rowStarts, const int * rowLengths,
    155155               const int * columns,
    156156               const double * elements);
     157#ifndef CLP_NO_VECTOR
    157158  void addRows(int number, const double * rowLower,
    158159               const double * rowUpper,
    159160               const CoinPackedVectorBase * const * rows);
     161#endif
    160162  /** Add rows from a build object.
    161163      If tryPlusMinusOne then will try adding as +-1 matrix
     
    189191                  const double * columnUpper,
    190192                  const double * objective,
    191                   const int * columnStarts, const int * rows,
     193                  const CoinBigIndex * columnStarts, const int * rows,
    192194                  const double * elements);
    193195  void addColumns(int number, const double * columnLower,
    194196                  const double * columnUpper,
    195197                  const double * objective,
    196                   const int * columnStarts, const int * columnLengths,
     198                  const CoinBigIndex * columnStarts, const int * columnLengths,
    197199                  const int * rows,
    198200                  const double * elements);
     201#ifndef CLP_NO_VECTOR
    199202  void addColumns(int number, const double * columnLower,
    200203               const double * columnUpper,
    201204                  const double * objective,
    202205               const CoinPackedVectorBase * const * columns);
     206#endif
    203207  /** Add columns from a build object
    204208      If tryPlusMinusOne then will try adding as +-1 matrix
     
    241245  /// Create empty ClpPackedMatrix
    242246  void createEmptyMatrix();
     247#ifndef CLP_NO_STD
    243248  /// Drops names - makes lengthnames 0 and names empty
    244249  void dropNames();
     
    258263  /// Set name of col
    259264  void setColumnName(int colIndex, std::string & name) ;
     265#endif
    260266
    261267    /** Write the problem in MPS format to the specified file.
     
    308314  inline double objectiveOffset() const { return dblParam_[ClpObjOffset];}
    309315  void setObjectiveOffset(double value);
     316#ifndef CLP_NO_STD
    310317  inline std::string problemName() const { return strParam_[ClpProbName]; };
     318#endif
    311319   /// Number of iterations
    312320   inline int numberIterations() const  { return numberIterations_; }
     
    634642   /// length of names (0 means no names0
    635643   inline int lengthNames() const { return lengthNames_; }
     644#ifndef CLP_NO_STD
    636645   /// length of names (0 means no names0
    637646   inline void setLengthNames(int value) { lengthNames_=value; }
     
    654663   /// Return name or Cnnnnnnn
    655664   std::string getColumnName(int iColumn) const;
     665#endif
    656666  /// Objective methods
    657667  inline ClpObjective * objectiveAsObject() const
     
    706716    /// Set an double parameter
    707717    bool setDblParam(ClpDblParam key, double value) ;
     718#ifndef CLP_NO_STD
    708719    /// Set an string parameter
    709720    bool setStrParam(ClpStrParam key, const std::string & value);
     721#endif
    710722    // Get an integer parameter
    711723    inline bool getIntParam(ClpIntParam key, int& value) const {
     
    726738      }
    727739    }
     740#ifndef CLP_NO_STD
    728741    // Get a string parameter
    729742    inline bool getStrParam(ClpStrParam key, std::string& value) const {
     
    735748      }
    736749    }
     750#endif
    737751  //@}
    738752
     
    861875  /// Event handler
    862876  ClpEventHandler * eventHandler_;
     877#ifndef CLP_NO_STD
    863878  /// Row names
    864879  std::vector<std::string> rowNames_;
    865880  /// Column names
    866881  std::vector<std::string> columnNames_;
     882#endif
    867883  /// Messages
    868884  CoinMessages messages_;
     885#ifndef CLP_NO_STD
    869886  /// Array of string parameters
    870887  std::string strParam_[ClpLastStrParam];
     888#endif
    871889  //@}
    872890};
  • trunk/include/ClpPackedMatrix.hpp

    r634 r653  
    5656    /** Delete the rows whose indices are listed in <code>indDel</code>. */
    5757  virtual void deleteRows(const int numDel, const int * indDel);
     58#ifndef CLP_NO_VECTOR
    5859  /// Append Columns
    5960  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
    6061  /// Append Rows
    6162  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
     63#endif
    6264  /** Append a set of rows/columns to the end of the matrix. Returns number of errors
    6365      i.e. if any of the new rows/columns contain an index that's larger than the
  • trunk/include/ClpPresolve.hpp

    r618 r653  
    4343                              bool dropNames=false,
    4444                              bool doRowObjective=false);
     45#ifndef CLP_NO_STD
    4546  /** This version saves data in a file.  The passed in model
    4647      is updated to be presolved model.  names are always dropped.
     
    5152                           int numberPasses=5,
    5253                           bool doRowObjective=false);
     54#endif
    5355  /** Return pointer to presolved model,
    5456      Up to user to destroy */
     
    180182  /// Substitution level
    181183  int substitution_;
     184#ifndef CLP_NO_STD
    182185  /// Name of saved model file
    183186  std::string saveFile_;
     187#endif
    184188  /** Whether we want to skip dual part of presolve etc.
    185189      512 bit allows duplicate column processing on integer columns
Note: See TracChangeset for help on using the changeset viewer.