Changeset 2279


Ignore:
Timestamp:
Oct 2, 2017 12:30:01 PM (21 months ago)
Author:
forrest
Message:

more changes for COIN_BIG_INDEX

Location:
trunk/Clp/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpGubDynamicMatrix.hpp

    r2271 r2279  
    186186     }
    187187     /// size of working matrix (max)
    188      inline int numberElements() const {
     188     inline CoinBigIndex numberElements() const {
    189189          return numberElements_;
    190190     }
  • trunk/Clp/src/ClpModel.cpp

    r2274 r2279  
    407407     matrix_ = new ClpPackedMatrix(matrix);
    408408}
    409 #if COIN_BIG_INDEX==0
    410409#ifndef SLIM_NOIO
    411410// This loads a model from a coinModel object - returns number of errors
     
    505504     return numberErrors;
    506505}
    507 #endif
    508506#endif
    509507void
     
    21192117}
    21202118#endif
    2121 #if COIN_BIG_INDEX==0
    21222119#ifndef SLIM_NOIO
    21232120// Add rows from a model object
     
    22502247     }
    22512248}
    2252 #endif
    22532249#endif
    22542250// Add one column
     
    25722568#endif
    25732569#ifndef SLIM_NOIO
    2574 #if COIN_BIG_INDEX==0
    25752570// Add columns from a model object
    25762571int
     
    26952690     }
    26962691}
    2697 #endif
    26982692#endif
    26992693// chgRowLower
     
    40924086/* This creates a coinModel object
    40934087 */
    4094 #if COIN_BIG_INDEX==0
    40954088CoinModel *
    40964089ClpModel::createCoinModel() const
     
    41924185     return coinModel;
    41934186}
    4194 #else
    4195 CoinModel *
    4196 ClpModel::createCoinModel() const
    4197 {
    4198   fprintf(stderr,"createCoinModel not available with COIN_BIG_INDEX\n");
    4199   abort();
    4200   return NULL;
    4201 }
    4202 #endif
    42034187// Start or reset using maximumRows_ and Columns_
    42044188void
  • trunk/Clp/src/ClpSolve.cpp

    r2271 r2279  
    16971697          }
    16981698     }
    1699 #if COIN_BIG_INDEX==0
    17001699     if (method == ClpSolve::tryBenders) {
    17011700       // Now build model
     
    17291728         abort();
    17301729     }
    1731 #endif
    17321730     if (method == ClpSolve::usePrimalorSprint) {
    17331731          if (doSprint < 0) {
     
    46494647     return matched;
    46504648}
    4651 #if COIN_BIG_INDEX==0
    46524649#include "CoinStructuredModel.hpp"
    46534650// Solve using structure of model and maybe in parallel
     
    50125009     return returnCode;
    50135010}
    5014 #endif
    50155011/*  If input negative scales objective so maximum <= -value
    50165012    and returns scale factor used.  If positive unscales and also
     
    51235119}
    51245120#endif
    5125 #if COIN_BIG_INDEX==0
    51265121// Solve using Dantzig-Wolfe decomposition and maybe in parallel
    51275122int
     
    53365331               delete [] columnAdd;
    53375332               delete [] objective;
    5338                columnAdd = new int[spaceNeeded+1];
     5333               columnAdd = new CoinBigIndex[spaceNeeded+1];
    53395334               objective = new double[spaceNeeded];
    53405335          }
     
    56635658               if (sub[iBlock].numberIterations() || !iPass) {
    56645659                    double objValue = 0.0;
    5665                     int start = columnAdd[numberProposals];
     5660                    CoinBigIndex start = columnAdd[numberProposals];
    56665661                    // proposal
    56675662                    if (sub[iBlock].isProvenOptimal()) {
     
    56715666                              objValue += solution[i] * saveObj[i];
    56725667                         // See if good dj and pack down
    5673                          int number = start;
     5668                         CoinBigIndex number = start;
    56745669                         double dj = objValue;
    56755670                         if (problemStatus)
     
    57125707                              objValue += solution[i] * saveObj[i];
    57135708                         // See if good dj and pack down
    5714                          int number = start;
     5709                         CoinBigIndex number = start;
    57155710                         double dj = objValue;
    57165711                         double smallest = 1.0e100;
     
    59065901  double * objective = model->objective();
    59075902  double * change = new double[CoinMax(numberRows,numberColumns)+numberColumns];
    5908   int * rowStart = new int [2*numberColumns+1];
     5903  CoinBigIndex * rowStart = new CoinBigIndex [2*numberColumns+1];
    59095904  memset(change,0,numberRows*sizeof(double));
    59105905  // first swap ones with infinite lower bounds
     
    59395934  }
    59405935  int nExtra=0;
    5941   int * columnNew = rowStart+numberColumns+1;
     5936  int * columnNew = reinterpret_cast<int *>(rowStart+numberColumns+1);
    59425937  for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    59435938    if (columnUpper[iColumn]<COIN_DBL_MAX&&columnUpper[iColumn]) {
     
    59595954  return model;
    59605955}
    5961 #endif
    59625956#if defined(ABC_INHERIT) || defined(CBC_THREAD) || defined(THREADS_IN_ANALYZE)
    59635957CoinPthreadStuff::CoinPthreadStuff(int numberThreads,
     
    61056099}
    61066100#endif
    6107 #if COIN_BIG_INDEX==0
    61086101// Solve using Benders decomposition and maybe in parallel
    61096102int
     
    62646257                           printf("** Adding artificials\n");
    62656258                           int nRow = sub[kBlock].numberRows();
    6266                            int * addStarts = new int [2*nRow+1];
     6259                           CoinBigIndex * addStarts = new CoinBigIndex [2*nRow+1];
    62676260                           int * addRow = new int[2*nRow];
    62686261                           double * addElement = new double[2*nRow];
     
    63266319     int spaceNeeded = CoinMax(numberBlocks * (numberMasterColumns + 1),
    63276320                               2 * numberMasterColumns);
    6328      int * columnAdd = new int[spaceNeeded];
     6321     CoinBigIndex * columnAdd = new CoinBigIndex[spaceNeeded];
     6322     int * indexColumnAdd = reinterpret_cast<int *>(columnAdd);
    63296323     double * elementAdd = new double[spaceNeeded];
    63306324     spaceNeeded = numberBlocks;
    6331      int * rowAdd = new int[2*spaceNeeded+1]; // temp for block info
    6332      int * blockPrint = rowAdd+spaceNeeded+1;
     6325     CoinBigIndex * rowAdd = new CoinBigIndex[2*spaceNeeded+1]; // temp for block info
     6326     int * blockPrint = reinterpret_cast<int *>(rowAdd+spaceNeeded+1);
    63336327     double * objective = new double[spaceNeeded];
    63346328     int logLevel=handler_->logLevel();
     
    63876381       }
    63886382       temp.addColumns(numberBlocks, lower, NULL, objective,
    6389                        columnAdd, rowAdd, elementAdd);
     6383                       columnAdd, NULL, NULL);
    63906384       delete [] lower;
    63916385       ClpSimplex temp2(&temp,nRow,whichRow,nColumn+numberBlocks,whichColumn);
     
    64846478     }
    64856479     masterModel.addColumns(numberBlocks, NULL, NULL, objective,
    6486                        columnAdd, rowAdd, elementAdd);
     6480                       columnAdd, NULL, NULL);
    64876481     sprintf(generalPrint,"Time to decompose %.2f seconds",CoinCpuTime() - time1);
    64886482     handler_->message(CLP_GENERAL, messages_)
     
    71967190              if (sub[iBlock].numberIterations()||(problemState[iBlock]&4)!=0) {
    71977191                double objValue = 0.0;
    7198                 int start = rowAdd[numberProposals];
     7192                int start = static_cast<int>(rowAdd[numberProposals]);
    71997193                // proposal
    72007194                if (sub[iBlock].isProvenOptimal()) {
     
    72667260                      smallest = CoinMin(smallest, fabs(value));
    72677261                      largest = CoinMax(largest, fabs(value));
    7268                       columnAdd[number] = i;
     7262                      indexColumnAdd[number] = i;
    72697263                      elementAdd[number++] = -value;
    72707264                    }
     
    72727266                 
    72737267                  infeas += primal[numberMasterColumns+iBlock];
    7274                   columnAdd[number] = numberMasterColumns + iBlock;
     7268                  indexColumnAdd[number] = numberMasterColumns + iBlock;
    72757269                  elementAdd[number++] = -1.0;
    72767270                  // if elements large then scale?
     
    72947288                        if (fabs(value) > target) {
    72957289                          smallest=CoinMin(smallest,fabs(value));
    7296                           columnAdd[number] = columnAdd[i];
     7290                          indexColumnAdd[number] = indexColumnAdd[i];
    72977291                          elementAdd[number++] = value;
    72987292                        }
    72997293                      }
    7300                       columnAdd[number] = numberMasterColumns + iBlock;
     7294                      indexColumnAdd[number] = numberMasterColumns + iBlock;
    73017295                      elementAdd[number++] = -1.0;
    73027296                    }
     
    73167310                      double value = elementAdd[i]*scale;
    73177311                      elementAdd[i]=value;
    7318                       int iColumn=columnAdd[i];
     7312                      int iColumn=indexColumnAdd[i];
    73197313                      infeas -= primal[iColumn] * value;
    73207314                    }
     
    73317325                    double sum=0.0;
    73327326                    for (int i=start;i<number;i++) {
    7333                       int iColumn=columnAdd[i];
     7327                      int iColumn=indexColumnAdd[i];
    73347328                      sum  += primal[iColumn]*elementAdd[i];
    73357329                    }
     
    76797673                      smallest = CoinMin(smallest, fabs(value));
    76807674                      largest = CoinMax(largest, fabs(value));
    7681                       columnAdd[number] = i;
     7675                      indexColumnAdd[number] = i;
    76827676                      elementAdd[number++] = value;
    76837677                    }
     
    77027696                      double value = elementAdd[i];
    77037697                      if (fabs(value) > smallest) {
    7704                         columnAdd[number] = columnAdd[i];
     7698                        indexColumnAdd[number] = indexColumnAdd[i];
    77057699                        elementAdd[number++] = value;
    77067700                      }
    77077701                    }
    7708                     columnAdd[number] = numberMasterColumns + iBlock;
     7702                    indexColumnAdd[number] = numberMasterColumns + iBlock;
    77097703                    elementAdd[number++] = -1.0;
    77107704                  }
     
    77127706                    double sum=0.0;
    77137707                    for (int i=start;i<number;i++) {
    7714                       int iColumn=columnAdd[i];
     7708                      int iColumn=indexColumnAdd[i];
    77157709                      sum  += primal[iColumn]*elementAdd[i];
    77167710                    }
     
    77487742                          blockPrint[i]+numberMasterColumns);
    77497743                   int k=0;
    7750                    for (int j=rowAdd[i];j<rowAdd[i+1];j++) {
     7744                   for (CoinBigIndex j=rowAdd[i];j<rowAdd[i+1];j++) {
    77517745                     if (k==12) {
    77527746                       printf("\n");
     
    77547748                     }
    77557749                     k++;
    7756                      printf("(%d,%g) ",columnAdd[j],elementAdd[j]);
     7750                     printf("(%d,%g) ",indexColumnAdd[j],elementAdd[j]);
    77577751                   }
    77587752                   printf(" <= %g\n",objective[i]);
     
    77697763                   double sum2 = 0.0;
    77707764                   for (int j=rowAdd[i];j<rowAdd[i+1];j++) {
    7771                      int iColumn=columnAdd[j];
     7765                     int iColumn=indexColumnAdd[j];
    77727766                     double value=elementAdd[j];
    77737767                     sum += value*solution[iColumn];
     
    78057799               if (logLevel>3) {
    78067800                 goodModel.addRows(numberProposals, NULL, objective,
    7807                                    rowAdd, columnAdd, elementAdd);
     7801                                   rowAdd, indexColumnAdd, elementAdd);
    78087802                 goodModel.dual();
    78097803                 if (goodModel.problemStatus()==1||goodModel.objectiveValue()>goodValue+1.0e-5*fabs(goodValue)) {
     
    79177911#endif
    79187912               masterModel.addRows(numberProposals, NULL, objective,
    7919                               rowAdd, columnAdd, elementAdd);
     7913                              rowAdd, indexColumnAdd, elementAdd);
    79207914          }
    79217915     }
     
    80568050     return 0;
    80578051}
    8058 #endif
  • trunk/Clp/src/ClpSolver.cpp

    r2271 r2279  
    130130              AbcSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
    131131#endif
    132 #if COIN_BIG_INDEX==0
    133132static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
    134 #endif
    135133static void generateCode(const char * fileName, int type);
    136134// Returns next valid field
     
    373371                if (!coinModelStart.model) {
    374372                  // linear
     373#if COIN_BIG_INDEX==0
    375374                    models->loadProblem(info.numberColumns, info.numberRows, info.starts,
    376375                                        info.rows, info.elements,
    377376                                        info.columnLower, info.columnUpper, info.objective,
    378377                                        info.rowLower, info.rowUpper);
     378#else
     379                    int numberColumns=info.numberColumns;
     380                    CoinBigIndex * starts = new CoinBigIndex[numberColumns+1];
     381                    for (int i=0;i<numberColumns+1;i++)
     382                      starts[i]=info.starts[i];
     383                    models->loadProblem(info.numberColumns, info.numberRows, starts,
     384                                        info.rows, info.elements,
     385                                        info.columnLower, info.columnUpper, info.objective,
     386                                        info.rowLower, info.rowUpper);
     387                    delete [] starts;
     388#endif
    379389                } else {
    380390                  // QP
     
    13421352                              break;
    13431353                         case CLP_PARAM_ACTION_STATISTICS:
    1344 #if COIN_BIG_INDEX==0
    13451354                              if (goodModels[iModel]) {
    13461355                                   // If presolve on look at presolved
     
    13771386                                   std::cout << "** Current model not valid" << std::endl;
    13781387                              }
    1379 #endif
    13801388                              break;
    13811389                         case CLP_PARAM_ACTION_TIGHTEN:
     
    30043012     return 0;
    30053013}
    3006 #if COIN_BIG_INDEX==0
    3007 static void breakdown(const char * name, int numberLook, const double * region)
     3014static void breakdown(const char * name, CoinBigIndex numberLook, const double * region)
    30083015{
    30093016     double range[] = {
     
    30513058     delete [] numberExact;
    30523059}
    3053 #endif
    30543060void sortOnOther(int * column,
    30553061                 const CoinBigIndex * rowStart,
     
    30933099     }
    30943100}
    3095 #if COIN_BIG_INDEX==0
    30963101static void statistics(ClpSimplex * originalModel, ClpSimplex * model)
    30973102{
     
    32013206             if (saveModel) {
    32023207               int spaceNeeded=numberSort+numberDifferentObj;
    3203                int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     3208               int * columnAdd = new int[spaceNeeded];
     3209               CoinBigIndex * startAdd = new CoinBigIndex[numberDifferentObj+1];
    32043210               double * elementAdd = new double[spaceNeeded];
    3205                int * rowAdd = new int[2*numberDifferentObj+1];
    3206                int * newIsInteger = rowAdd+numberDifferentObj+1;
     3211               CoinBigIndex * rowAdd = new CoinBigIndex[2*numberDifferentObj+1];
     3212               int * newIsInteger = reinterpret_cast<int *>(rowAdd+numberDifferentObj+1);
    32073213               double * objectiveNew = new double[3*numberDifferentObj];
    32083214               double * lowerNew = objectiveNew+numberDifferentObj;
    32093215               double * upperNew = lowerNew+numberDifferentObj;
    3210                memset(columnAdd+spaceNeeded,0,
    3211                       (numberDifferentObj+1)*sizeof(int));
     3216               memset(startAdd,0,
     3217                      (numberDifferentObj+1)*sizeof(CoinBigIndex));
    32123218               ClpSimplex tempModel=*model;
    32133219               int iLast=0;
     
    32693275               tempModel.addColumns(numberDifferentObj, lowerNew, upperNew,
    32703276                                    objectiveNew,
    3271                                     columnAdd+spaceNeeded, NULL, NULL);
     3277                                    startAdd, NULL, NULL);
    32723278               // add constraints and make integer if all integer in group
    32733279               for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     
    32803286                                 rowAdd,columnAdd,elementAdd);
    32813287               delete [] columnAdd;
     3288               delete [] startAdd;
    32823289               delete [] elementAdd;
    32833290               delete [] rowAdd;
     
    35513558       const double * element = columnCopy.getElements();
    35523559       const double * elementByRow = rowCopy.getElements();
    3553        const int * rowStart = rowCopy.getVectorStarts();
     3560       const CoinBigIndex * rowStart = rowCopy.getVectorStarts();
    35543561       const int * column = rowCopy.getIndices();
    35553562       int nPossibleZeroCost=0;
     
    35763583           int iRow=row[columnStart[iColumn]];
    35773584           double value=COIN_DBL_MAX;
    3578            for (int i=rowStart[iRow];i<rowStart[iRow]+rowLength[iRow];i++) {
     3585           for (CoinBigIndex i=rowStart[iRow];i<rowStart[iRow]+rowLength[iRow];i++) {
    35793586             int jColumn=column[i];
    35803587             if (jColumn!=iColumn) {
     
    39543961          double randomUpper = CoinDrand48();
    39553962          double randomInteger = CoinDrand48();
    3956           int * startAdd = new int[numberRows+1];
     3963          CoinBigIndex * startAdd = new CoinBigIndex[numberRows+1];
    39573964          int * columnAdd = new int [2*numberElements];
    39583965          double * elementAdd = new double[2*numberElements];
     
    42944301                                             for (CoinBigIndex i = start; i < start + length; i++) {
    42954302                                                  int jColumn = column[i];
    4296                                                   backColumn2[jColumn] = i - start;
     4303                                                  backColumn2[jColumn] = static_cast<int>(i - start);
    42974304                                             }
    42984305                                             for (CoinBigIndex i = start; i < start + length; i++) {
     
    44764483     }
    44774484}
    4478 #endif
    44794485static bool maskMatches(const int * starts, char ** masks,
    44804486                        std::string & check)
Note: See TracChangeset for help on using the changeset viewer.