Changeset 45 for branches


Ignore:
Timestamp:
Oct 29, 2002 4:16:14 PM (17 years ago)
Author:
forrest
Message:

First try at over 2 giga-elements

Location:
branches/devel-1
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/ClpFactorization.cpp

    r35 r45  
    6060    areaFactor_ = areaFactor;
    6161  int numberBasic = 0;
    62   ClpBigIndex numberElements=0;
     62  CoinBigIndex numberElements=0;
    6363  int numberRowBasic=0;
    6464
  • branches/devel-1/ClpModel.cpp

    r40 r45  
    231231ClpModel::loadProblem (
    232232                              const int numcols, const int numrows,
    233                               const int* start, const int* index,
     233                              const CoinBigIndex* start, const int* index,
    234234                              const double* value,
    235235                              const double* collb, const double* colub,   
     
    247247ClpModel::loadProblem (
    248248                              const int numcols, const int numrows,
    249                               const int* start, const int* index,
     249                              const CoinBigIndex* start, const int* index,
    250250                              const double* value,const int* length,
    251251                              const double* collb, const double* colub,   
  • branches/devel-1/ClpPackedMatrix.cpp

    r35 r45  
    107107  // get matrix data pointers
    108108  const int * row = matrix_->getIndices();
    109   const int * columnStart = matrix_->getVectorStarts();
     109  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    110110  const int * columnLength = matrix_->getVectorLengths();
    111111  const double * elementByColumn = matrix_->getElements();
     
    113113  //memset(y,0,matrix_->getNumRows()*sizeof(double));
    114114  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    115     int j;
     115    CoinBigIndex j;
    116116    double value = scalar*x[iColumn];
    117117    if (value) {
     
    131131  // get matrix data pointers
    132132  const int * row = matrix_->getIndices();
    133   const int * columnStart = matrix_->getVectorStarts();
     133  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    134134  const int * columnLength = matrix_->getVectorLengths();
    135135  const double * elementByColumn = matrix_->getElements();
     
    137137  //memset(y,0,numberColumns*sizeof(double));
    138138  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    139     int j;
     139    CoinBigIndex j;
    140140    double value=0.0;
    141141    for (j=columnStart[iColumn];
     
    156156  // get matrix data pointers
    157157  const int * row = matrix_->getIndices();
    158   const int * columnStart = matrix_->getVectorStarts();
     158  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    159159  const int * columnLength = matrix_->getVectorLengths();
    160160  const double * elementByColumn = matrix_->getElements();
     
    162162  //memset(y,0,matrix_->getNumRows()*sizeof(double));
    163163  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    164     int j;
     164    CoinBigIndex j;
    165165    double value = x[iColumn];
    166166    if (value) {
     
    188188  // get matrix data pointers
    189189  const int * row = matrix_->getIndices();
    190   const int * columnStart = matrix_->getVectorStarts();
     190  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    191191  const int * columnLength = matrix_->getVectorLengths();
    192192  const double * elementByColumn = matrix_->getElements();
     
    194194  //memset(y,0,numberColumns*sizeof(double));
    195195  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    196     int j;
     196    CoinBigIndex j;
    197197    double value=0.0;
    198198    // scaled
     
    231231    // get matrix data pointers
    232232    const int * row = matrix_->getIndices();
    233     const int * columnStart = matrix_->getVectorStarts();
     233    const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    234234    const int * columnLength = matrix_->getVectorLengths();
    235235    const double * elementByColumn = matrix_->getElements();
     
    242242        markVector[iColumn]=0.0;
    243243        double value2 = 0.0;
    244         int j;
     244        CoinBigIndex j;
    245245        for (j=columnStart[iColumn];
    246246             j<columnStart[iColumn]+columnLength[iColumn];j++) {
     
    259259        double value = markVector[iColumn];
    260260        markVector[iColumn]=0.0;
    261         int j;
     261        CoinBigIndex j;
    262262        const double * columnScale = model->columnScale();
    263263        double value2 = 0.0;
     
    297297
    298298    const int * column = rowCopy->getIndices();
    299     const int * rowStart = rowCopy->getVectorStarts();
     299    const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    300300    const double * element = rowCopy->getElements();
    301301    const int * whichRow = rowArray->getIndices();
     
    303303      iRow = whichRow[i];
    304304      double value = pi[iRow]*scalar;
    305       int j;
     305      CoinBigIndex j;
    306306      for (j=rowStart[iRow];j<rowStart[iRow+1];j++) {
    307307        int iColumn = column[j];
     
    333333
    334334    const int * column = rowCopy->getIndices();
    335     const int * rowStart = rowCopy->getVectorStarts();
     335    const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    336336    const double * element = rowCopy->getElements();
    337337    const int * whichRow = rowArray->getIndices();
     
    339339    iRow = whichRow[0];
    340340    value = pi[iRow]*scalar;
    341     int j;
     341    CoinBigIndex j;
    342342    for (j=rowStart[iRow];j<rowStart[iRow+1];j++) {
    343343      int iColumn = column[j];
     
    374374    numberNonZero=0;
    375375    const int * column = rowCopy->getIndices();
    376     const int * rowStart = rowCopy->getVectorStarts();
     376    const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    377377    const double * element = rowCopy->getElements();
    378378    double value = pi[iRow]*scalar;
    379     int j;
     379    CoinBigIndex j;
    380380    for (j=rowStart[iRow];j<rowStart[iRow+1];j++) {
    381381      int iColumn = column[j];
     
    409409  // get matrix data pointers
    410410  const int * row = matrix_->getIndices();
    411   const int * columnStart = matrix_->getVectorStarts();
     411  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    412412  const int * columnLength = matrix_->getVectorLengths();
    413413  const double * elementByColumn = matrix_->getElements();
     
    419419      int iColumn = which[jColumn];
    420420      double value = 0.0;
    421       int j;
     421      CoinBigIndex j;
    422422      for (j=columnStart[iColumn];
    423423           j<columnStart[iColumn]+columnLength[iColumn];j++) {
     
    435435      int iColumn = which[jColumn];
    436436      double value = 0.0;
    437       int j;
     437      CoinBigIndex j;
    438438      const double * columnScale = model->columnScale();
    439439      for (j=columnStart[iColumn];
     
    452452/* Returns number of elements in basis
    453453   column is basic if entry >=0 */
    454 ClpBigIndex
     454CoinBigIndex
    455455ClpPackedMatrix::numberInBasis(const int * columnIsBasic) const
    456456{
     
    458458  int numberColumns = getNumCols();
    459459  const int * columnLength = matrix_->getVectorLengths();
    460   ClpBigIndex numberElements=0;
     460  CoinBigIndex numberElements=0;
    461461  for (i=0;i<numberColumns;i++) {
    462462    if (columnIsBasic[i]>=0) {
     
    467467}
    468468// Fills in basis (Returns number of elements and updates numberBasic)
    469 ClpBigIndex
     469CoinBigIndex
    470470ClpPackedMatrix::fillBasis(const ClpSimplex * model,
    471471                                const int * columnIsBasic, int & numberBasic,
     
    475475  const double * rowScale = model->rowScale();
    476476  const int * row = matrix_->getIndices();
    477   const int * columnStart = matrix_->getVectorStarts();
     477  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    478478  const int * columnLength = matrix_->getVectorLengths();
    479479  const double * elementByColumn = matrix_->getElements();
    480480  int i;
    481481  int numberColumns = getNumCols();
    482   ClpBigIndex numberElements=0;
     482  CoinBigIndex numberElements=0;
    483483  if (!rowScale) {
    484484    // no scaling
    485485    for (i=0;i<numberColumns;i++) {
    486486      if (columnIsBasic[i]>=0) {
    487         int j;
     487        CoinBigIndex j;
    488488        for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
    489489          indexRowU[numberElements]=row[j];
     
    499499    for (i=0;i<numberColumns;i++) {
    500500      if (columnIsBasic[i]>=0) {
    501         int j;
     501        CoinBigIndex j;
    502502        double scale = columnScale[i];
    503503        for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     
    530530  int numberColumns = model->numberColumns();
    531531  const int * column = rowCopy->getIndices();
    532   const int * rowStart = rowCopy->getVectorStarts();
     532  const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    533533  const double * element = rowCopy->getElements();
    534534  double * rowScale = new double [numberRows];
     
    556556  // get matrix data pointers
    557557  const int * row = matrix_->getIndices();
    558   const int * columnStart = matrix_->getVectorStarts();
     558  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    559559  const int * columnLength = matrix_->getVectorLengths();
    560560  const double * elementByColumn = matrix_->getElements();
    561561  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    562     int j;
     562    CoinBigIndex j;
    563563    char useful=0;
    564564    if (columnUpper[iColumn]>
     
    592592    for (iRow=0;iRow<numberRows;iRow++) {
    593593      if (usefulRow[iRow]) {
    594         int j;
     594        CoinBigIndex j;
    595595        int useful=0;
    596596        for (j=rowStart[iRow];j<rowStart[iRow+1];j++) {
     
    616616      for (iRow=0;iRow<numberRows;iRow++) {
    617617        if (usefulRow[iRow]) {
    618           int j;
     618          CoinBigIndex j;
    619619          largest=1.0e-20;
    620620          smallest=1.0e50;
     
    642642      for (iColumn=0;iColumn<numberColumns;iColumn++) {
    643643        if (usefulColumn[iColumn]) {
    644           int j;
     644          CoinBigIndex j;
    645645          largest=1.0e-20;
    646646          smallest=1.0e50;
     
    663663    for (iColumn=0;iColumn<numberColumns;iColumn++) {
    664664      if (usefulColumn[iColumn]) {
    665         int j;
     665        CoinBigIndex j;
    666666        largest=1.0e-20;
    667667        smallest=1.0e50;
     
    733733    int numberColumns = model->numberColumns();
    734734    const int * column = rowCopy->getIndices();
    735     const int * rowStart = rowCopy->getVectorStarts();
     735    const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    736736    const double * element = rowCopy->getElements();
    737737    int iRow;
     
    765765  const double * rowScale = model->rowScale();
    766766  const int * row = matrix_->getIndices();
    767   const int * columnStart = matrix_->getVectorStarts();
    768   const int * columnLength = matrix_->getVectorLengths();
    769   const double * elementByColumn = matrix_->getElements();
    770   int i;
     767  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     768  const int * columnLength = matrix_->getVectorLengths();
     769  const double * elementByColumn = matrix_->getElements();
     770  CoinBigIndex i;
    771771  if (!rowScale) {
    772772    for (i=columnStart[iColumn];
     
    792792  const double * rowScale = model->rowScale();
    793793  const int * row = matrix_->getIndices();
    794   const int * columnStart = matrix_->getVectorStarts();
    795   const int * columnLength = matrix_->getVectorLengths();
    796   const double * elementByColumn = matrix_->getElements();
    797   int i;
     794  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     795  const int * columnLength = matrix_->getVectorLengths();
     796  const double * elementByColumn = matrix_->getElements();
     797  CoinBigIndex i;
    798798  if (!rowScale) {
    799799    for (i=columnStart[iColumn];
     
    822822{
    823823  int iColumn;
    824   int numberLarge=0;;
    825   int numberSmall=0;;
     824  CoinBigIndex numberLarge=0;;
     825  CoinBigIndex numberSmall=0;;
    826826  int firstBadColumn=-1;
    827827  int firstBadRow=-1;
     
    829829  // get matrix data pointers
    830830  const int * row = matrix_->getIndices();
    831   const int * columnStart = matrix_->getVectorStarts();
     831  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    832832  const int * columnLength = matrix_->getVectorLengths();
    833833  const double * elementByColumn = matrix_->getElements();
    834834  int numberColumns = matrix_->getNumCols();
    835835  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    836     int j;
     836    CoinBigIndex j;
    837837    for (j=columnStart[iColumn];
    838838         j<columnStart[iColumn]+columnLength[iColumn];j++) {
  • branches/devel-1/ClpSimplex.cpp

    r44 r45  
    19781978  // get matrix data pointers
    19791979  const int * column = copy.getIndices();
    1980   const int * rowStart = copy.getVectorStarts();
     1980  const CoinBigIndex * rowStart = copy.getVectorStarts();
    19811981  const int * rowLength = copy.getVectorLengths();
    19821982  const double * element = copy.getElements();
     
    20192019        double maximumDown = 0.0;
    20202020        double newBound;
    2021         int rStart = rowStart[iRow];
    2022         int rEnd = rowStart[iRow]+rowLength[iRow];
    2023         int j;
     2021        CoinBigIndex rStart = rowStart[iRow];
     2022        CoinBigIndex rEnd = rowStart[iRow]+rowLength[iRow];
     2023        CoinBigIndex j;
    20242024
    20252025        // Compute possible lower and upper ranges
     
    22922292  if (fp) {
    22932293    Clp_scalars scalars;
    2294     int i, numberWritten;
     2294    int i;
     2295    CoinBigIndex numberWritten;
    22952296    // Fill in scalars
    22962297    scalars.optimizationDirection = optimizationDirection_;
     
    23272328      return 1;
    23282329    // strings
    2329     int length;
     2330    CoinBigIndex length;
    23302331    for (i=0;i<ClpLastStrParam;i++) {
    23312332      length = strParam_[i].size();
     
    24802481    factorization_->sparseThreshold(1);
    24812482    Clp_scalars scalars;
    2482     int numberRead;
     2483    CoinBigIndex numberRead;
    24832484
    24842485    // get scalars
     
    25122513    specialOptions_ = scalars.specialOptions;
    25132514    // strings
    2514     int length;
     2515    CoinBigIndex length;
    25152516    for (i=0;i<ClpLastStrParam;i++) {
    25162517      numberRead = fread(&length,sizeof(int),1,fp);
     
    26362637    double * elements = new double[length];
    26372638    int * indices = new int[length];
    2638     int * starts = new int[numberColumns_];
     2639    CoinBigIndex * starts = new CoinBigIndex[numberColumns_];
    26392640    int * lengths = new int[numberColumns_];
    26402641    numberRead = fread(elements, sizeof(double),length,fp);
     
    27402741  return *this;
    27412742}
     2743// Seems to be something odd about exact comparison of doubles on linux
     2744static bool equalDouble(double value1, double value2)
     2745{
     2746  assert(sizeof(unsigned int)*2==sizeof(double));
     2747  unsigned int *i1 = (unsigned int *) &value1;
     2748  unsigned int *i2 = (unsigned int *) &value2;
     2749  return (i1[0]==i2[0]&&i1[1]==i2[1]);
     2750}
    27422751int
    27432752ClpSimplexProgress::looping()
     
    27612770
    27622771  for (i=0;i<CLP_PROGRESS;i++) {
    2763     bool matchedOnObjective = (objective==objective_[i]);
    2764     bool matchedOnInfeasibility = (infeasibility==infeasibility_[i]);
     2772    bool matchedOnObjective = equalDouble(objective,objective_[i]);
     2773    bool matchedOnInfeasibility = equalDouble(infeasibility,infeasibility_[i]);
    27652774    bool matchedOnInfeasibilities =
    27662775      (numberInfeasibilities==numberInfeasibilities_[i]);
     
    27682777      matched |= (1<<i);
    27692778      numberMatched++;
     2779      // here mainly to get over compiler bug?
     2780      if (model_->messageHandler()->logLevel()>10)
     2781        printf("%d %d %d %d %d loop check\n",i,numberMatched,
     2782               matchedOnObjective, matchedOnInfeasibility,
     2783               matchedOnInfeasibilities);
    27702784    }
    27712785    if (i) {
     
    27752789    }
    27762790  }
    2777   if (numberMatched)
    2778     printf("%d loop check\n",numberMatched);
    27792791  objective_[CLP_PROGRESS-1] = objective;
    27802792  infeasibility_[CLP_PROGRESS-1] = infeasibility;
     
    30423054void
    30433055ClpSimplex::loadProblem (  const int numcols, const int numrows,
    3044                     const int* start, const int* index,
     3056                    const CoinBigIndex* start, const int* index,
    30453057                    const double* value,
    30463058                    const double* collb, const double* colub,   
     
    30563068void
    30573069ClpSimplex::loadProblem (  const int numcols, const int numrows,
    3058                            const int* start, const int* index,
     3070                           const CoinBigIndex* start, const int* index,
    30593071                           const double* value,const int * length,
    30603072                           const double* collb, const double* colub,   
  • branches/devel-1/Presolve.cpp

    r44 r45  
    108108  const int ncols0  = ncols_;
    109109  const int nrows0  = nrows_;
    110   const int nelems0 = nelems_;
     110  const CoinBigIndex nelems0 = nelems_;
    111111
    112112  double *acts = new double[nrows0];
     
    137137    {
    138138      const int *link = prob.link_;
    139       int start = 0;
     139      CoinBigIndex start = 0;
    140140     
    141141      for (int j=0; j<ncols0; j++) {
    142         int k = prob.mcstrt_[j];
     142        CoinBigIndex k = prob.mcstrt_[j];
    143143        int n = prob.hincol_[j];
    144144
     
    218218      double *colels    = prob.colels_;
    219219      int *hrow         = prob.hrow_;
    220       int *mcstrt               = prob.mcstrt_;
     220      CoinBigIndex *mcstrt              = prob.mcstrt_;
    221221      int *hincol               = prob.hincol_;
    222222      int ncols         = prob.ncols_;
     
    334334    int nrowsAfter = presolvedModel_->getNumRows();
    335335    int ncolsAfter = presolvedModel_->getNumCols();
    336     int nelsAfter = presolvedModel_->getNumElements();
     336    CoinBigIndex nelsAfter = presolvedModel_->getNumElements();
    337337    presolvedModel_->messageHandler()->message(CLP_PRESOLVE_STATS,
    338338                                               presolvedModel_->messages())
     
    373373  const int ncols0  = ncols_;
    374374  const int nrows0  = nrows_;
    375   const int nelems0 = nelems_;
     375  const CoinBigIndex nelems0 = nelems_;
    376376
    377377  // reality check
     
    471471  for (colx = 0; colx < ncols; ++colx) {
    472472    if (1) {
    473       int k = mcstrt[colx];
     473      CoinBigIndex k = mcstrt[colx];
    474474      int nx = hincol[colx];
    475475      double solutionValue = csol[colx];
     
    816816    for (int i=0; i<ncols0; i++) {
    817817      PRESOLVEASSERT(hincol[i] == &prob->mcstrt0[i+1] - &prob->mcstrt0[i]);
    818       int kcs0 = &prob->mcstrt0[i];
    819       int kcs = mcstrt[i];
     818      CoinBigIndex kcs0 = &prob->mcstrt0[i];
     819      CoinBigIndex kcs = mcstrt[i];
    820820      int n = hincol[i];
    821821      for (int k=0; k<n; k++) {
    822         int k1 = presolve_find_row1(&prob->hrow0[kcs0+k], kcs, kcs+n, hrow);
     822        CoinBigIndex k1 = presolve_find_row1(&prob->hrow0[kcs0+k], kcs, kcs+n, hrow);
    823823       
    824824        if (k1 == kcs+n) {
     
    928928  for (colx = 0; colx < ncols; ++colx) {
    929929    if (cdone[colx]) {
    930       int k = mcstrt[colx];
     930      CoinBigIndex k = mcstrt[colx];
    931931      int nx = hincol[colx];
    932932      double dj = maxmin * dcost[colx];
  • branches/devel-1/PresolveDoubleton.cpp

    r41 r45  
    2727}
    2828
    29 void compact_rep(double *elems, int *indices, int *starts, const int *lengths, int n,
     29void compact_rep(double *elems, int *indices, CoinBigIndex *starts, const int *lengths, int n,
    3030                        const presolvehlink *link)
    3131{
     
    4141  int j = 0;
    4242  for (; i != n; i = link[i].suc) {
    43     int s = starts[i];
    44     int e = starts[i] + lengths[i];
     43    CoinBigIndex s = starts[i];
     44    CoinBigIndex e = starts[i] + lengths[i];
    4545
    4646    // because of the way link is organized, j <= s
    4747    starts[i] = j;
    48     for (int k = s; k < e; k++) {
     48    for (CoinBigIndex k = s; k < e; k++) {
    4949      elems[j] = elems[k];
    5050      indices[j] = indices[k];
     
    5555
    5656// returns true if ran out of memory
    57 static bool expand_col(int *mcstrt,
     57static bool expand_col(CoinBigIndex *mcstrt,
    5858                       double *colels,
    5959                       int *hrow,
     
    6363                       int icolx)
    6464{
    65   int kcsx = mcstrt[icolx];
    66   int kcex = kcsx + hincol[icolx];
     65  CoinBigIndex kcsx = mcstrt[icolx];
     66  CoinBigIndex kcex = kcsx + hincol[icolx];
    6767
    6868  const int maxk = mcstrt[ncols];       // (22)
     
    139139                             int row0, int icolx, int icoly)
    140140{
    141   int kcs = mcstrt[icoly];
    142   int kce = kcs + hincol[icoly];
    143   int kcsx = mcstrt[icolx];
    144   int kcex = kcsx + hincol[icolx];
    145 
    146   for (int kcoly=kcs; kcoly<kce; kcoly++) {
     141  CoinBigIndex kcs = mcstrt[icoly];
     142  CoinBigIndex kce = kcs + hincol[icoly];
     143  CoinBigIndex kcsx = mcstrt[icolx];
     144  CoinBigIndex kcex = kcsx + hincol[icolx];
     145
     146  for (CoinBigIndex kcoly=kcs; kcoly<kce; kcoly++) {
    147147    int row = hrow[kcoly];
    148148
    149149    if (row != row0) {
    150150      // see if row appears in colx
    151       int kcolx = presolve_find_row1(row, kcsx, kcex, hrow);
     151      CoinBigIndex kcolx = presolve_find_row1(row, kcsx, kcex, hrow);
    152152
    153153      if (kcolx<kcex) {
     
    222222 */
    223223static bool elim_doubleton(const char *msg,
    224                            int *mcstrt,
     224                           CoinBigIndex *mcstrt,
    225225                           double *rlo, double * acts, double *rup,
    226226                           double *colels,
     
    228228                           int *hinrow, int *hincol,
    229229                           presolvehlink *clink, int ncols,
    230                            int *mrstrt, double *rowels,
     230                           CoinBigIndex *mrstrt, double *rowels,
    231231                           //double a, double b, double c,
    232232                           double coeff_factor,
     
    234234                           int row0, int icolx, int icoly)
    235235{
    236   int kcs = mcstrt[icoly];
    237   int kce = kcs + hincol[icoly];
    238   int kcsx = mcstrt[icolx];
    239   int kcex = kcsx + hincol[icolx];
     236  CoinBigIndex kcs = mcstrt[icoly];
     237  CoinBigIndex kce = kcs + hincol[icoly];
     238  CoinBigIndex kcsx = mcstrt[icolx];
     239  CoinBigIndex kcex = kcsx + hincol[icolx];
    240240
    241241  //printf("%s %d x=%d y=%d cf=%g bf=%g nx=%d\n", msg,
     
    245245         row0, icolx, icoly, coeff_factor, bounds_factor, hincol[icolx]);
    246246#endif
    247   for (int kcoly=kcs; kcoly<kce; kcoly++) {
     247  for (CoinBigIndex kcoly=kcs; kcoly<kce; kcoly++) {
    248248    int row = hrow[kcoly];
    249249
     
    254254    if (row != row0/* && hinrow[row] > 0*/) {
    255255      // see if row appears in colx
    256       int kcolx = presolve_find_row1(row, kcsx, kcex, hrow);
     256      CoinBigIndex kcolx = presolve_find_row1(row, kcsx, kcex, hrow);
    257257
    258258      if (bounds_factor != 0.0) {
     
    284284        // update row rep
    285285        // first, copy new value for col x into proper place in rowels
    286         int k2 = presolve_find_row(icolx, mrstrt[row], mrstrt[row]+hinrow[row], hcol);
     286        CoinBigIndex k2 = presolve_find_row(icolx, mrstrt[row], mrstrt[row]+hinrow[row], hcol);
    287287        rowels[k2] = colels[kcolx];
    288288
     
    296296        // by just overwriting the icoly entry
    297297        {
    298           int k2 = presolve_find_row(icoly, mrstrt[row], mrstrt[row]+hinrow[row], hcol);
     298          CoinBigIndex k2 = presolve_find_row(icoly, mrstrt[row], mrstrt[row]+hinrow[row], hcol);
    299299          hcol[k2] = icolx;
    300300          rowels[k2] = colels[kcoly] * coeff_factor;
     
    343343                            const int *mrstrt, int *hcol, double *rowels, int *hinrow)
    344344{
    345   int kcs = mcstrt[col];
    346   int kce = kcs + hincol[col];
    347 
    348   for (int k=kcs; k<kce; ++k) {
     345  CoinBigIndex kcs = mcstrt[col];
     346  CoinBigIndex kce = kcs + hincol[col];
     347
     348  for (CoinBigIndex k=kcs; k<kce; ++k) {
    349349    int row = hrow[k];
    350350    double coeff = colels[k];
    351351
    352     int krs = mrstrt[row];
    353     int kre = krs + hinrow[row];
     352    CoinBigIndex krs = mrstrt[row];
     353    CoinBigIndex kre = krs + hinrow[row];
    354354
    355355    // the "quick" refers to the assumption that there will be enough room,
     
    376376  double *colels        = prob->colels_;
    377377  int *hrow             = prob->hrow_;
    378   int *mcstrt           = prob->mcstrt_;
     378  CoinBigIndex *mcstrt          = prob->mcstrt_;
    379379  int *hincol           = prob->hincol_;
    380380  int ncols             = prob->ncols_;
     
    385385  double *rowels        = prob->rowels_;
    386386  int *hcol             = prob->hcol_;
    387   int *mrstrt           = prob->mrstrt_;
     387  CoinBigIndex *mrstrt          = prob->mrstrt_;
    388388  int *hinrow           = prob->hinrow_;
    389389  int nrows             = prob->nrows_;
     
    430430        fabs(rup[irow] - rlo[irow]) <= ZTOLDP) {
    431431      double rhs = rlo[irow];
    432       int krs = mrstrt[irow];
    433       int kre = krs + hinrow[irow];
     432      CoinBigIndex krs = mrstrt[irow];
     433      CoinBigIndex kre = krs + hinrow[irow];
    434434      int icolx, icoly;
    435       int k;
     435      CoinBigIndex k;
    436436     
    437437      /* locate first column */
     
    462462        double coeffx, coeffy;
    463463        /* find this row in each of the columns */
    464         int krowx = presolve_find_row(irow, mcstrt[icolx], mcstrt[icolx] + hincol[icolx], hrow);
    465         int krowy = presolve_find_row(irow, mcstrt[icoly], mcstrt[icoly] + hincol[icoly], hrow);
     464        CoinBigIndex krowx = presolve_find_row(irow, mcstrt[icolx], mcstrt[icolx] + hincol[icolx], hrow);
     465        CoinBigIndex krowy = presolve_find_row(irow, mcstrt[icoly], mcstrt[icoly] + hincol[icoly], hrow);
    466466       
    467467        /* don't do if both integers for now - unless a variant
     
    529529       
    530530        {
    531           int kcs = mcstrt[icoly];
    532           int kce = kcs + hincol[icoly];
     531          CoinBigIndex kcs = mcstrt[icoly];
     532          CoinBigIndex kce = kcs + hincol[icoly];
    533533          for (k=kcs; k<kce; k++) {
    534534            if (hinrow[hrow[k]] == 1) {
     
    807807  double *colels        = prob->colels_;
    808808  int *hrow             = prob->hrow_;
    809   int *mcstrt           = prob->mcstrt_;
     809  CoinBigIndex *mcstrt          = prob->mcstrt_;
    810810  int *hincol           = prob->hincol_;
    811811  int *link             = prob->link_;
     
    833833  char *rdone   = prob->rdone_;
    834834
    835   int free_list = prob->free_list_;
     835  CoinBigIndex free_list = prob->free_list_;
    836836
    837837  const double ztolzb   = prob->ztolzb_;
     
    896896    {
    897897      // find the tail
    898       int k=mcstrt[jcolx];
     898      CoinBigIndex k=mcstrt[jcolx];
    899899      for (int i=0; i<hincol[jcolx]-1; ++i) {
    900900        k = link[k];
     
    909909      int xstart = NO_LINK;
    910910      for (int i=0; i<f->ncolx; ++i) {
    911         int k = free_list;
     911        CoinBigIndex k = free_list;
    912912        free_list = link[free_list];
    913913
     
    925925      int ystart = NO_LINK;
    926926      for (int i=0; i<f->ncoly; ++i) {
    927         int k = free_list;
     927        CoinBigIndex k = free_list;
    928928        free_list = link[free_list];
    929929
     
    967967    // which is similar to the bias
    968968    {
    969       int k = mcstrt[jcoly];
     969      CoinBigIndex k = mcstrt[jcoly];
    970970      int ny = hincol[jcoly];
    971971      double dj = maxmin * dcost[jcoly];
     
    10311031#if     DEBUG_PRESOLVE
    10321032      {
    1033         int k = mcstrt[jcolx];
     1033        CoinBigIndex k = mcstrt[jcolx];
    10341034        int nx = hincol[jcolx];
    10351035        double dj = maxmin * dcost[jcolx];
     
    10471047      }
    10481048      {
    1049         int k = mcstrt[jcoly];
     1049        CoinBigIndex k = mcstrt[jcoly];
    10501050        int ny = hincol[jcoly];
    10511051        double dj = maxmin * dcost[jcoly];
  • branches/devel-1/PresolveDual.cpp

    r39 r45  
    2626  double *colels        = prob->colels_;
    2727  int *hrow             = prob->hrow_;
    28   int *mcstrt           = prob->mcstrt_;
     28  CoinBigIndex *mcstrt          = prob->mcstrt_;
    2929  int *hincol           = prob->hincol_;
    3030  int ncols             = prob->ncols_;
     
    3535  double *rowels        = prob->rowels_;
    3636  int *hcol             = prob->hcol_;
    37   int *mrstrt           = prob->mrstrt_;
     37  CoinBigIndex *mrstrt          = prob->mrstrt_;
    3838  int *hinrow           = prob->hinrow_;
    3939  int nrows             = prob->nrows_;
     
    127127        //  cup[j] = clo[j];
    128128        //}
    129         int kcs = mcstrt[j];
    130         int kce = kcs + hincol[j];
     129        CoinBigIndex kcs = mcstrt[j];
     130        CoinBigIndex kce = kcs + hincol[j];
    131131        int iflagu = 0;
    132132        int iflagl = 0;
     
    134134        double ddjhi = ddjlo;
    135135
    136         for (int k = kcs; k < kce; k++) {
     136        for (CoinBigIndex k = kcs; k < kce; k++) {
    137137          int i = hrow[k];
    138138          double coeff = colels[k];
     
    205205     
    206206      if ((no_ub ^ no_lb) == true) {
    207         int krs = mrstrt[i];
    208         int kre = krs + hinrow[i];
     207        CoinBigIndex krs = mrstrt[i];
     208        CoinBigIndex kre = krs + hinrow[i];
    209209        double rmax  = rdmax[i];
    210210        double rmin  = rdmin[i];
     
    216216
    217217        // all row columns are non-empty
    218         for (int k=krs; k<kre; k++) {
     218        for (CoinBigIndex k=krs; k<kre; k++) {
    219219          double coeff = rowels[k];
    220220          double djmax0 = djmax[hcol[k]];
  • branches/devel-1/PresolveDupcol.cpp

    r44 r45  
    3434}
    3535
    36 int compute_sums(const int *len, const int *starts,
     36int compute_sums(const int *len, const CoinBigIndex *starts,
    3737                 /*const*/ int *index, /*const*/ double *elems, // index/elems are sorted
    3838                 const double *work,
     
    4242  for (int i = 0; i < n; ++i)
    4343    if (len[i] > 0 /*1?*/) {
    44       int kcs = starts[i];
    45       int kce = kcs + len[i];
     44      CoinBigIndex kcs = starts[i];
     45      CoinBigIndex kce = kcs + len[i];
    4646
    4747      double value=0.0;
     
    5151      //ekk_sort2(index+kcs, elems+kcs, len[i]);
    5252
    53       for (int k=kcs;k<kce;k++) {
     53      for (CoinBigIndex k=kcs;k<kce;k++) {
    5454        int irow=index[k];
    5555        value += work[irow]*elems[k];
     
    7878  double *colels        = prob->colels_;
    7979  int *hrow             = prob->hrow_;
    80   int *mcstrt           = prob->mcstrt_;
     80  CoinBigIndex *mcstrt          = prob->mcstrt_;
    8181  int *hincol           = prob->hincol_;
    8282  int ncols             = prob->ncols_;
     
    8888  double *rowels        = prob->rowels_;
    8989  int *hcol     = prob->hcol_;
    90   const int *mrstrt     = prob->mrstrt_;
     90  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    9191  int *hinrow           = prob->hinrow_;
    9292  int nrows             = prob->nrows_;
     
    126126  for (int i = 0; i < ncols; ++i)
    127127    if (hincol[i] > 0 /*1?*/) {
    128       int kcs = mcstrt[i];
    129       int kce = kcs + hincol[i];
     128      CoinBigIndex kcs = mcstrt[i];
     129      CoinBigIndex kce = kcs + hincol[i];
    130130
    131131      double value=0.0;
     
    135135      //ekk_sort2(hrow+kcs, colels+kcs, hincol[i]);
    136136
    137       for (int k=kcs;k<kce;k++) {
     137      for (CoinBigIndex k=kcs;k<kce;k++) {
    138138        int irow=hrow[k];
    139139        value += workrow[irow]*colels[k];
     
    185185      int ithis=sort[jj];
    186186      int ilast=sort[jj-1];
    187       int kcs = mcstrt[ithis];
    188       int kce = kcs + hincol[ithis];
     187      CoinBigIndex kcs = mcstrt[ithis];
     188      CoinBigIndex kce = kcs + hincol[ithis];
    189189
    190190      if (hincol[ithis] == hincol[ilast]) {
    191191        int ishift = mcstrt[ilast] - kcs;
    192         int k;
     192        CoinBigIndex k;
    193193        for (k=kcs;k<kce;k++) {
    194194          if (hrow[k] != hrow[k+ishift] ||
     
    277277            sol[ithis]=clo2;
    278278            {
    279               int kcs = mcstrt[ithis];
    280               int kce = kcs + hincol[ithis];
    281               for (int k=kcs; k<kce; ++k)
     279              CoinBigIndex kcs = mcstrt[ithis];
     280              CoinBigIndex kce = kcs + hincol[ithis];
     281              for (CoinBigIndex k=kcs; k<kce; ++k)
    282282                // delete ithis from its rows
    283283                presolve_delete_from_row(hrow[k], ithis, mrstrt, hinrow, hcol, rowels);
     
    436436
    437437void create_col(int col, int n, int *rows, double *els,
    438                 int *mcstrt, double *colels, int *hrow, int *link,
    439                 int *free_listp)
    440 {
    441   int free_list = *free_listp;
     438                CoinBigIndex *mcstrt, double *colels, int *hrow, int *link,
     439                CoinBigIndex *free_listp)
     440{
     441  CoinBigIndex free_list = *free_listp;
    442442  int xstart = NO_LINK;
    443443  for (int i=0; i<n; ++i) {
    444     int k = free_list;
     444    CoinBigIndex k = free_list;
    445445    free_list = link[free_list];
    446446
     
    470470  double *colels        = prob->colels_;
    471471  int *hrow             = prob->hrow_;
    472   int *mcstrt           = prob->mcstrt_;
     472  CoinBigIndex *mcstrt          = prob->mcstrt_;
    473473  int *hincol           = prob->hincol_;
    474474  int *link             = prob->link_;
     
    476476  double *rcosts        = prob->rcosts_;
    477477
    478   int free_list         = prob->free_list_;
     478  CoinBigIndex free_list                = prob->free_list_;
    479479
    480480  for (const action *f = &actions[nactions-1]; actions<=f; f--) {
     
    569569  double *colels        = prob->colels_;
    570570  int *hrow             = prob->hrow_;
    571   int *mcstrt           = prob->mcstrt_;
     571  CoinBigIndex *mcstrt          = prob->mcstrt_;
    572572  int *hincol           = prob->hincol_;
    573573  int ncols             = prob->ncols_;
     
    578578  double *rowels        = prob->rowels_;
    579579  /*const*/ int *hcol   = prob->hcol_;
    580   const int *mrstrt     = prob->mrstrt_;
     580  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    581581  int *hinrow           = prob->hinrow_;
    582582  int nrows             = prob->nrows_;
     
    604604    if (mpre[i] == 0) {
    605605      double value=0.0;
    606       int krs=mrstrt[i];
    607       int kre=mrstrt[i+1];
     606      CoinBigIndex krs=mrstrt[i];
     607      CoinBigIndex kre=mrstrt[i+1];
    608608      CoinSort_2(hcol+krs,hcol+kre,dels+krs);
    609609      //ekk_sort2(hcol+krs,dels+krs,kre-krs);
     
    625625      int ithis=sort[jj];
    626626      int ilast=sort[jj-1];
    627       int krs = mrstrt[ithis];
    628       int kre = krs + hinrow[ithis];
     627      CoinBigIndex krs = mrstrt[ithis];
     628      CoinBigIndex kre = krs + hinrow[ithis];
    629629      int ishift = mrstrt[ilast];
    630630      if (hinrow[ithis] == hinrow[ilast]) {
    631631        int ishift = mrstrt[ilast] - krs;
    632         int k;
     632        CoinBigIndex k;
    633633        for (k=krs;k<kre;k++) {
    634634          if (hcol[k] != hrow[k+ishift] ||
  • branches/devel-1/PresolveEmpty.cpp

    r39 r45  
    1818{
    1919  int ncols             = prob->ncols_;
    20   int *mcstrt           = prob->mcstrt_;
     20  CoinBigIndex *mcstrt          = prob->mcstrt_;
    2121  int *hincol           = prob->hincol_;
    2222  int *hcol             = prob->hcol_;
     
    169169
    170170  int ncols             = prob->ncols_;
    171   int nelems            = prob->nelems_;
    172 
    173   int *mcstrt   = prob->mcstrt_;
     171  CoinBigIndex nelems           = prob->nelems_;
     172
     173  CoinBigIndex *mcstrt  = prob->mcstrt_;
    174174  int *hincol   = prob->hincol_;
    175175  int *hrow     = prob->hrow_;
     
    251251{
    252252  int ncols     = prob->ncols_;
    253   int *mcstrt   = prob->mcstrt_;
     253  CoinBigIndex *mcstrt  = prob->mcstrt_;
    254254  int *hincol   = prob->hincol_;
    255255  int *hrow     = prob->hrow_;
     
    352352
    353353  int ncols     = prob->ncols_;
    354   int *mcstrt   = prob->mcstrt_;
     354  CoinBigIndex *mcstrt  = prob->mcstrt_;
    355355  int *hincol   = prob->hincol_;
    356356
     
    400400
    401401  for (int j=0; j<ncols; j++) {
    402     int start = mcstrt[j];
    403     int end   = start + hincol[j];
     402    CoinBigIndex start = mcstrt[j];
     403    CoinBigIndex end   = start + hincol[j];
    404404   
    405     for (int k=start; k<end; ++k) {
     405    for (CoinBigIndex k=start; k<end; ++k) {
    406406      hrow[k] = rowmapping[hrow[k]];
    407407    }
  • branches/devel-1/PresolveFixed.cpp

    r44 r45  
    3131  double *colels        = prob->colels_;
    3232  int *hrow             = prob->hrow_;
    33   int *mcstrt           = prob->mcstrt_;
     33  CoinBigIndex *mcstrt          = prob->mcstrt_;
    3434  int *hincol           = prob->hincol_;
    3535
    3636  double *rowels        = prob->rowels_;
    3737  int *hcol             = prob->hcol_;
    38   int *mrstrt           = prob->mrstrt_;
     38  CoinBigIndex *mrstrt          = prob->mrstrt_;
    3939  int *hinrow           = prob->hinrow_;
    4040  int nrows             = prob->nrows_;
     
    5858
    5959    double sol = clo[j];
    60     int kcs = mcstrt[j];
    61     int kce = kcs + hincol[j];
    62     int k;
     60    CoinBigIndex kcs = mcstrt[j];
     61    CoinBigIndex kce = kcs + hincol[j];
     62    CoinBigIndex k;
    6363
    6464    {
     
    8888      // mark
    8989      prob->addRow(row);
    90       int krs = mrstrt[row];
    91       int kre = krs + hinrow[row];
    92       for (int k=krs; k<kre; k++) {
     90      CoinBigIndex krs = mrstrt[row];
     91      CoinBigIndex kre = krs + hinrow[row];
     92      for (CoinBigIndex k=krs; k<kre; k++) {
    9393        int jcol = hcol[k];
    9494        prob->addCol(jcol);
     
    153153  double *colels        = prob->colels_;
    154154  int *hrow             = prob->hrow_;
    155   int *mcstrt           = prob->mcstrt_;
     155  CoinBigIndex *mcstrt          = prob->mcstrt_;
    156156  int *hincol           = prob->hincol_;
    157157  int *link             = prob->link_;
    158158  int ncols             = prob->ncols_;
    159   int free_list         = prob->free_list_;
     159  CoinBigIndex free_list                = prob->free_list_;
    160160
    161161  double *clo   = prob->clo_;
     
    199199
    200200        // pop free_list
    201         int k = free_list;
     201        CoinBigIndex k = free_list;
    202202        free_list = link[free_list];
    203203       
     
    280280  double *colels        = prob->colels_;
    281281  int *hrow     = prob->hrow_;
    282   int *mcstrt   = prob->mcstrt_;
     282  CoinBigIndex *mcstrt  = prob->mcstrt_;
    283283  int *hincol   = prob->hincol_;
    284284
     
    306306    }
    307307    if (movement) {
    308       int k;
     308      CoinBigIndex k;
    309309      for (k=mcstrt[j];k<mcstrt[j]+hincol[j];k++) {
    310310        int row = hrow[k];
  • branches/devel-1/PresolveForcing.cpp

    r40 r45  
    3838                           const double *clo, const double *cup,
    3939                           const int *hcol,
    40                            int krs, int kre,
     40                           CoinBigIndex krs, CoinBigIndex kre,
    4141                           double *maxupp, double *maxdownp,
    4242                           int jcol,
     
    5757
    5858  // compute sum of all bounds except for jcol
    59   int kk;
     59  CoinBigIndex kk;
    6060  for (kk=krs; kk<kre; kk++) {
    6161    if (hcol[kk] == jcol)
     
    6565    // that is, consider jcol last
    6666    // this assumes that jcol occurs in this row
    67     int k = (hcol[kk] == jcol
     67    CoinBigIndex k = (hcol[kk] == jcol
    6868             ? kre-1
    6969             : kk == kre-1
     
    146146                               const double *clo, const double *cup,
    147147                               const int *hcol,
    148                                int krs, int kre,
     148                               CoinBigIndex krs, CoinBigIndex kre,
    149149                               double *maxupp, double *maxdownp)
    150150{
     
    161161}
    162162
    163 static bool some_col_was_fixed(const int *hcol, int krs, int kre,
     163static bool some_col_was_fixed(const int *hcol, CoinBigIndex krs, CoinBigIndex kre,
    164164                               const double *clo,
    165165                               const double *cup)
    166166{
    167   int k;
     167  CoinBigIndex k;
    168168  for (k=krs; k<kre; k++) {
    169169    int jcol = hcol[k];
     
    212212  const double *rowels  = prob->rowels_;
    213213  const int *hcol       = prob->hcol_;
    214   const int *mrstrt     = prob->mrstrt_;
     214  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    215215  const int *hinrow     = prob->hinrow_;
    216216  const int nrows       = prob->nrows_;
     
    241241    int irow = look[iLook];
    242242    if (hinrow[irow] > 0) {
    243       int krs = mrstrt[irow];
    244       int kre = krs + hinrow[irow];
     243      CoinBigIndex krs = mrstrt[irow];
     244      CoinBigIndex kre = krs + hinrow[irow];
    245245
    246246      double maxup, maxdown;
     
    312312        int uk = kre;   // load fix-to-up in back
    313313
    314         for (int k=krs; k<kre; k++) {
     314        for (CoinBigIndex k=krs; k<kre; k++) {
    315315          int jcol = hcol[k];
    316316          prob->addCol(jcol);
     
    381381  const double *colels  = prob->colels_;
    382382  const int *hrow               = prob->hrow_;
    383   const int *mcstrt             = prob->mcstrt_;
     383  const CoinBigIndex *mcstrt            = prob->mcstrt_;
    384384  const int *hincol             = prob->hincol_;
    385385  const int *link               = prob->link_;
    386386
    387   int free_list = prob->free_list_;
     387  CoinBigIndex free_list = prob->free_list_;
    388388
    389389  double *clo   = prob->clo_;
     
    436436    for (int k=0; k<ninrow; k++) {
    437437      int jcol = rowcols[k];
    438       int kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link);
     438      CoinBigIndex kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link);
    439439
    440440      // choose rowdual to cancel out reduced cost
     
    456456      for (int k=0; k<ninrow; k++) {
    457457        int jcol = rowcols[k];
    458         int kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link);
     458        CoinBigIndex kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link);
    459459             
    460460        rcosts[jcol] -= (rowduals[irow] * colels[kk]);
     
    488488
    489489  for (int irow=0; irow<nrows; irow++) {
    490     int krs = mrstrt[irow];
    491     int kre = krs + hinrow[irow];
     490    CoinBigIndex krs = mrstrt[irow];
     491    CoinBigIndex kre = krs + hinrow[irow];
    492492
    493493    double irlo = rlo[irow];
     
    505505    double maxdown = 0.0;
    506506
    507     for (int k=krs; k<kre; k++) {
     507    for (CoinBigIndex k=krs; k<kre; k++) {
    508508      int jcol = hcol[k];
    509509      double coeff = rowels[k];
     
    598598    }
    599599
    600     for (int k = krs; k<kre; ++k) {
     600    for (CoinBigIndex k = krs; k<kre; ++k) {
    601601      int jcol = hcol[k];
    602602      double coeff = rowels[k];
     
    636636    }
    637637
    638     for (int k = krs; k<kre; ++k) {
     638    for (CoinBigIndex k = krs; k<kre; ++k) {
    639639      int jcol = hcol[k];
    640640      double coeff = rowels[k];
     
    736736            double rdual_adjust;
    737737            {
    738               int kk = presolve_find_row(irow, mcstrt[jcol], mcstrt[jcol] + hincol[jcol], hrow);
     738              CoinBigIndex kk = presolve_find_row(irow, mcstrt[jcol], mcstrt[jcol] + hincol[jcol], hrow);
    739739              // adjust rowdual to cancel out reduced cost
    740740              // should probably search for col with largest factor
     
    746746            for (int k=0; k<ninrow; k++) {
    747747              int jcol = rowcols[k];
    748               int kk = presolve_find_row(irow, mcstrt[jcol], mcstrt[jcol] + hincol[jcol], hrow);
     748              CoinBigIndex kk = presolve_find_row(irow, mcstrt[jcol], mcstrt[jcol] + hincol[jcol], hrow);
    749749             
    750750              rcosts[jcol] -= (rdual_adjust * colels[kk]);
  • branches/devel-1/PresolveImpliedFree.cpp

    r41 r45  
    4949  double *colels        = prob->colels_;
    5050  int *hrow     = prob->hrow_;
    51   const int *mcstrt     = prob->mcstrt_;
     51  const CoinBigIndex *mcstrt    = prob->mcstrt_;
    5252  int *hincol   = prob->hincol_;
    5353  const int ncols       = prob->ncols_;
     
    5858  const double *rowels  = prob->rowels_;
    5959  const int *hcol       = prob->hcol_;
    60   const int *mrstrt     = prob->mrstrt_;
     60  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    6161  int *hinrow   = prob->hinrow_;
    6262  const int nrows       = prob->nrows_;
     
    136136    if ((hincol[j] >= 1 && hincol[j] <= 3) &&
    137137        !integerType[j]) {
    138       int kcs = mcstrt[j];
    139       int kce = kcs + hincol[j];
    140 
    141       for (int k=kcs; k<kce; ++k) {
     138      CoinBigIndex kcs = mcstrt[j];
     139      CoinBigIndex kce = kcs + hincol[j];
     140
     141      for (CoinBigIndex k=kcs; k<kce; ++k) {
    142142        int row = hrow[k];
    143143        double coeffj = colels[k];
     
    152152            fabs(coeffj) > ZTOLDP) {
    153153
    154           int krs = mrstrt[row];
    155           int kre = krs + hinrow[row];
     154          CoinBigIndex krs = mrstrt[row];
     155          CoinBigIndex kre = krs + hinrow[row];
    156156
    157157          double maxup, maxdown, ilow, iup;
     
    214214    int j=look[iLook];
    215215    if (hincol[j] == 1 && implied_free[j] == 1) {
    216       int kcs = mcstrt[j];
     216      CoinBigIndex kcs = mcstrt[j];
    217217      int row = hrow[kcs];
    218218      double coeffj = colels[kcs];
    219219
    220       int krs = mrstrt[row];
    221       int kre = krs + hinrow[row];
     220      CoinBigIndex krs = mrstrt[row];
     221      CoinBigIndex kre = krs + hinrow[row];
    222222
    223223#if 0
     
    230230      {
    231231        int n = 0;
    232         for (int k=krs; k<kre; ++k)
     232        for (CoinBigIndex k=krs; k<kre; ++k)
    233233          n += hincol[hcol[k]];
    234234        if (n==hinrow[row]) {
     
    266266        printf("FREE COSTS:  %g  ", costj);
    267267#endif
    268         for (int k=krs; k<kre; k++) {
     268        for (CoinBigIndex k=krs; k<kre; k++) {
    269269          int jcol = hcol[k];
    270270          save_costs[k-krs] = cost[jcol];
     
    298298
    299299      /* remove the row from the columns in the row */
    300       for (int k=krs; k<kre; k++) {
     300      for (CoinBigIndex k=krs; k<kre; k++) {
    301301        int jcol=hcol[k];
    302302        prob->addCol(jcol);
     
    360360  double *colels        = prob->colels_;
    361361  int *hrow             = prob->hrow_;
    362   int *mcstrt           = prob->mcstrt_;
     362  CoinBigIndex *mcstrt          = prob->mcstrt_;
    363363  int *hincol           = prob->hincol_;
    364364  int *link             = prob->link_;
     
    385385  char *cdone   = prob->cdone_;
    386386  char *rdone   = prob->rdone_;
    387   int free_list = prob->free_list_;
     387  CoinBigIndex free_list = prob->free_list_;
    388388
    389389  for (const action *f = &actions[nactions-1]; actions<=f; f--) {
     
    408408
    409409        {
    410           int kk = free_list;
     410          CoinBigIndex kk = free_list;
    411411          free_list = link[free_list];
    412412
     
    448448        else {
    449449          int jcol = rowcols[k];
    450           PRESOLVE_STMT(int kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link));
     450          PRESOLVE_STMT(CoinBigIndex kk = presolve_find_row2(irow, mcstrt[jcol], hincol[jcol], hrow, link));
    451451          PRESOLVEASSERT(colels[kk] == rowels[k]);
    452452          act += rowels[k] * sol[jcol];
  • branches/devel-1/PresolveIsolated.cpp

    r40 r45  
    1818{
    1919  int *hincol   = prob->hincol_;
    20   const int *mcstrt     = prob->mcstrt_;
     20  const CoinBigIndex *mcstrt    = prob->mcstrt_;
    2121  int *hrow     = prob->hrow_;
    2222  double *colels        = prob->colels_;
     
    2727  const double *rowels  = prob->rowels_;
    2828  const int *hcol       = prob->hcol_;
    29   const int *mrstrt     = prob->mrstrt_;
     29  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    3030
    3131  // may be written by useless constraint
     
    3535  double *rup   = prob->rup_;
    3636
    37   int krs = mrstrt[irow];
    38   int kre = krs + hinrow[irow];
     37  CoinBigIndex krs = mrstrt[irow];
     38  CoinBigIndex kre = krs + hinrow[irow];
    3939 
    4040  double *dcost = prob->cost_;
     
    4242#if     DEBUG_PRESOLVE
    4343  printf("ISOLATED:  %d - ", irow);
    44   for (int k = krs; k<kre; ++k)
     44  for (CoinBigIndex k = krs; k<kre; ++k)
    4545    printf("%d ", hcol[k]);
    4646  printf("\n");
     
    5353    return NULL;
    5454  }
    55   for (int k = krs; k<kre; ++k) {
     55  for (CoinBigIndex k = krs; k<kre; ++k) {
    5656    int jcol = hcol[k];
    5757    if (clo[jcol] != 0.0 && cup[jcol] != 0.0) {
     
    8484  // HACK - set costs to 0.0 so empty.cpp doesn't complain
    8585  double *costs = new double[nc];
    86   for (int k = krs; k<kre; ++k) {
     86  for (CoinBigIndex k = krs; k<kre; ++k) {
    8787    costs[k-krs] = dcost[hcol[k]];
    8888    dcost[hcol[k]] = 0.0;
     
    9696                                        next);
    9797
    98   for (int k=krs; k<kre; k++)
     98  for (CoinBigIndex k=krs; k<kre; k++)
    9999    presolve_delete_from_row(hcol[k], irow, mcstrt, hincol, hrow, colels);
    100100  hinrow[irow] = 0;
     
    116116  double *colels        = prob->colels_;
    117117  int *hrow             = prob->hrow_;
    118   int *mcstrt           = prob->mcstrt_;
     118  CoinBigIndex *mcstrt          = prob->mcstrt_;
    119119  int *link             = prob->link_;
    120120  int *hincol           = prob->hincol_;
     
    124124  double *sol           = prob->sol_;
    125125
    126   int free_list         = prob->free_list_;
     126  CoinBigIndex free_list                = prob->free_list_;
    127127
    128128
     
    143143    sol[jcol] = 0.0;    // ONLY ACCEPTED SUCH CONSTRAINTS
    144144
    145     int kk = free_list;
     145    CoinBigIndex kk = free_list;
    146146    free_list = link[free_list];
    147147
  • branches/devel-1/PresolveMatrix.cpp

    r43 r45  
    2626  class presolvehlink;
    2727
    28 void presolve_make_memlists(int *starts, int *lengths,
     28void presolve_make_memlists(CoinBigIndex *starts, int *lengths,
    2929                       presolvehlink *link,
    3030                       int n);
     
    3232/*static*/ void presolve_prefix(const int *starts, int *diffs, int n, int limit);
    3333
    34 /*static*/ void presolve_prefix(const int *starts, int *diffs, int n, int limit)
     34/*static*/ void presolve_prefix(const CoinBigIndex *starts, int *diffs, int n, int limit)
    3535{
    3636  int i;
     
    5050// column/row in the memory region hrow/hcol.
    5151// Note that n itself has a pre and a suc.
    52 void presolve_make_memlists(int *starts, int *lengths, presolvehlink *link, int n)
     52void presolve_make_memlists(CoinBigIndex *starts, int *lengths, presolvehlink *link, int n)
    5353{
    5454  int i;
     
    144144
    145145
    146 int presolve_find_row(int row, int kcs, int kce, const int *hrow)
    147 {
    148   int k;
     146int presolve_find_row(int row, CoinBigIndex kcs, CoinBigIndex kce, const int *hrow)
     147{
     148  CoinBigIndex k;
    149149  for (k=kcs; k<kce; k++)
    150150    if (hrow[k] == row)
     
    154154}
    155155
    156 int presolve_find_row1(int row, int kcs, int kce, const int *hrow)
    157 {
    158   int k;
     156int presolve_find_row1(int row, CoinBigIndex kcs, CoinBigIndex kce, const int *hrow)
     157{
     158  CoinBigIndex k;
    159159  for (k=kcs; k<kce; k++)
    160160    if (hrow[k] == row)
     
    163163}
    164164
    165 int presolve_find_row2(int irow, int ks, int nc, const int *hrow, const int *link)
     165int presolve_find_row2(int irow, CoinBigIndex ks, int nc, const int *hrow, const int *link)
    166166{
    167167  for (int i=0; i<nc; ++i) {
     
    173173}
    174174
    175 int presolve_find_row3(int irow, int ks, int nc, const int *hrow, const int *link)
     175int presolve_find_row3(int irow, CoinBigIndex ks, int nc, const int *hrow, const int *link)
    176176{
    177177  for (int i=0; i<nc; ++i) {
     
    188188// if we didn't want to maintain that property, we could just decrement hinrow[row].
    189189void presolve_delete_from_row(int row, int col /* thing to delete */,
    190                      const int *mrstrt,
     190                     const CoinBigIndex *mrstrt,
    191191                     int *hinrow, int *hcol, double *dels)
    192192{
    193   int krs = mrstrt[row];
    194   int kre = krs + hinrow[row];
    195 
    196   int kcol = presolve_find_row(col, krs, kre, hcol);
     193  CoinBigIndex krs = mrstrt[row];
     194  CoinBigIndex kre = krs + hinrow[row];
     195
     196  CoinBigIndex kcol = presolve_find_row(col, krs, kre, hcol);
    197197
    198198  swap(hcol[kcol], hcol[kre-1]);
     
    203203
    204204void presolve_delete_from_row2(int row, int col /* thing to delete */,
    205                       int *mrstrt,
    206                      int *hinrow, int *hcol, double *dels, int *link, int *free_listp)
    207 {
    208   int k = mrstrt[row];
     205                      CoinBigIndex *mrstrt,
     206                     int *hinrow, int *hcol, double *dels, int *link,
     207                               CoinBigIndex *free_listp)
     208{
     209  CoinBigIndex k = mrstrt[row];
    209210
    210211  if (hcol[k] == col) {
     
    216217  } else {
    217218    int n = hinrow[row] - 1;
    218     int k0 = k;
     219    CoinBigIndex k0 = k;
    219220    k = link[k];
    220221    for (int i=0; i<n; ++i) {
     
    264265                                             int ncols_in,
    265266                                             int nrows_in,
    266                                              int nelems_in) :
     267                                             CoinBigIndex nelems_in) :
    267268  ncols_(si.getNumCols()),
    268269  ncols0_(ncols_in),
    269270  nelems_(si.getNumElements()),
    270271
    271   mcstrt_(new int[ncols_in+1]),
     272  mcstrt_(new CoinBigIndex[ncols_in+1]),
    272273  hincol_(new int[ncols_in+1]),
    273274  hrow_  (new int   [2*nelems_in]),
     
    366367static bool isGapFree(const CoinPackedMatrix& matrix)
    367368{
    368   const int * start = matrix.getVectorStarts();
     369  const CoinBigIndex * start = matrix.getVectorStarts();
    369370  const int * length = matrix.getVectorLengths();
    370371  int i;
     
    397398                                     // rowrep
    398399                                     int nrows_in,
    399                                      int nelems_in,
     400                                     CoinBigIndex nelems_in,
    400401                               bool doStatus) :
    401402
     
    410411
    411412  // temporary init
    412   mrstrt_(new int[nrows_in+1]),
     413  mrstrt_(new CoinBigIndex[nrows_in+1]),
    413414  hinrow_(new int[nrows_in+1]),
    414415  rowels_(new double[2*nelems_in]),
     
    439440  // Do the copy here to try to avoid running out of memory.
    440441
    441   const int * start = m->getVectorStarts();
     442  const CoinBigIndex * start = m->getVectorStarts();
    442443  const int * length = m->getVectorLengths();
    443444  const int * row = m->getIndices();
     
    541542                                     int nrows0,
    542543                                     int ncols0,
    543                                      int nelems0)
     544                                     CoinBigIndex nelems0)
    544545{
    545546  si.loadProblem(ncols_, nrows_, mcstrt_, hrow_, colels_, hincol_,
     
    582583// Note that there may be entries in a row that correspond to empty columns
    583584// and vice-versa.  --- HUH???
    584 static void matrix_consistent(const int *mrstrt, const int *hinrow, const int *hcol,
    585                               const int *mcstrt, const int *hincol, const int *hrow,
     585static void matrix_consistent(const CoinBigIndex *mrstrt, const int *hinrow, const int *hcol,
     586                              const CoinBigIndex *mcstrt, const int *hincol, const int *hrow,
    586587                              const double *rowels,
    587588                              const double *colels,
     
    592593  for (int irow=0; irow<nrows; irow++) {
    593594    if (hinrow[irow] > 0) {
    594       int krs = mrstrt[irow];
    595       int kre = krs + hinrow[irow];
    596 
    597       for (int k=krs; k<kre; k++) {
     595      CoinBigIndex krs = mrstrt[irow];
     596      CoinBigIndex kre = krs + hinrow[irow];
     597
     598      for (CoinBigIndex k=krs; k<kre; k++) {
    598599        int jcol = hcol[k];
    599         int kcs = mcstrt[jcol];
    600         int kce = kcs + hincol[jcol];
    601 
    602         int kk = presolve_find_row1(irow, kcs, kce, hrow);
     600        CoinBigIndex kcs = mcstrt[jcol];
     601        CoinBigIndex kce = kcs + hincol[jcol];
     602
     603        CoinBigIndex kk = presolve_find_row1(irow, kcs, kce, hrow);
    603604        if (kk == kce) {
    604605          printf("MATRIX INCONSISTENT:  can't find %s %d in %s %d\n",
     
    651652                                       int ncols0_in,
    652653                                       int nrows0_in,
    653                                        int nelems0,
     654                                       CoinBigIndex nelems0,
    654655                                   
    655656                                       double maxmin_,
     
    695696  }
    696697
    697   const int nelemsr = m->getNumElements();
     698  const CoinBigIndex nelemsr = m->getNumElements();
    698699
    699700  ClpDisjointCopyN(m->getVectorStarts(), ncols1, mcstrt_);
     
    747748
    748749  for (int j=0; j<ncols1; j++) {
    749     int kcs = mcstrt_[j];
    750     int kce = kcs + hincol_[j];
    751     for (int k=kcs; k<kce; ++k) {
     750    CoinBigIndex kcs = mcstrt_[j];
     751    CoinBigIndex kce = kcs + hincol_[j];
     752    for (CoinBigIndex k=kcs; k<kce; ++k) {
    752753      link_[k] = k+1;
    753754    }
     
    755756  {
    756757    int ml = maxlink_;
    757     for (int k=nelemsr; k<ml; ++k)
     758    for (CoinBigIndex k=nelemsr; k<ml; ++k)
    758759      link_[k] = k+1;
    759760    link_[ml-1] = NO_LINK;
  • branches/devel-1/PresolveSingleton.cpp

    r39 r45  
    2929  double *colels        = prob->colels_;
    3030  int *hrow             = prob->hrow_;
    31   int *mcstrt           = prob->mcstrt_;
     31  CoinBigIndex *mcstrt          = prob->mcstrt_;
    3232  int *hincol           = prob->hincol_;
    3333  int ncols             = prob->ncols_;
     
    3838  double *rowels        = prob->rowels_;
    3939  const int *hcol       = prob->hcol_;
    40   const int *mrstrt     = prob->mrstrt_;
     40  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    4141  int *hinrow           = prob->hinrow_;
    4242  int nrows             = prob->nrows_;
     
    226226  double *colels        = prob->colels_;
    227227  int *hrow             = prob->hrow_;
    228   int *mcstrt           = prob->mcstrt_;
     228  CoinBigIndex *mcstrt          = prob->mcstrt_;
    229229  int *hincol           = prob->hincol_;
    230230  int *link             = prob->link_;
     
    248248  char *cdone           = prob->cdone_;
    249249  char *rdone           = prob->rdone_;
    250   int free_list         = prob->free_list_;
     250  CoinBigIndex free_list                = prob->free_list_;
    251251
    252252  const double ztolzb   = prob->ztolzb_;
     
    272272    // copy col to end to make room for new element
    273273    {
    274       int k = free_list;
     274      CoinBigIndex k = free_list;
    275275      free_list = link[free_list];
    276276
  • branches/devel-1/PresolveSubst.cpp

    r41 r45  
    1212
    1313inline void prepend_elem(int jcol, double coeff, int irow,
    14                     int *mcstrt,
     14                    CoinBigIndex *mcstrt,
    1515                    double *colels,
    1616                    int *hrow,
    17                     int *link, int *free_listp)
     17                    int *link, CoinBigIndex *free_listp)
    1818{
    19   int kk = *free_listp;
     19  CoinBigIndex kk = *free_listp;
    2020  *free_listp = link[*free_listp];
    2121  check_free_list(*free_listp);
     
    3232}
    3333
    34 void compact_rep(double *elems, int *indices, int *starts, const int *lengths, int n,
     34void compact_rep(double *elems, int *indices, CoinBigIndex *starts, const int *lengths, int n,
    3535                 const presolvehlink *link);
    3636
     
    4242
    4343// copy of expand_col; have to rename params
    44 static void expand_row(int *mcstrt,
     44static void expand_row(CoinBigIndex *mcstrt,
    4545                    double *colels,
    4646                       int *hrow, // int *hcol,
     
    5353                       )
    5454{
    55   /////int kcs = mcstrt[icoly];
    56   /////int kce = kcs + hincol[icoly];
    57   int kcsx = mcstrt[icolx];
    58   int kcex = kcsx + hincol[icolx];
     55  /////CoinBigIndex kcs = mcstrt[icoly];
     56  /////CoinBigIndex kce = kcs + hincol[icoly];
     57  CoinBigIndex kcsx = mcstrt[icolx];
     58  CoinBigIndex kcex = kcsx + hincol[icolx];
    5959
    6060  const int maxk = mcstrt[ncols];       // (22)
     
    138138
    139139// add coeff_factor * rowy to rowx
    140 void add_row(int *mrstrt,
     140void add_row(CoinBigIndex *mrstrt,
    141141             double *rlo, double * acts, double *rup,
    142142             double *rowels,
     
    148148             int *x_to_y)
    149149{
    150   int krs = mrstrt[irowy];
    151   int kre = krs + hinrow[irowy];
    152   int krsx = mrstrt[irowx];
    153   int krex = krsx + hinrow[irowx];
     150  CoinBigIndex krs = mrstrt[irowy];
     151  CoinBigIndex kre = krs + hinrow[irowy];
     152  CoinBigIndex krsx = mrstrt[irowx];
     153  CoinBigIndex krex = krsx + hinrow[irowx];
    154154  const int maxk = mrstrt[nrows];       // (22)
    155155
     
    209209  }
    210210
    211   int kcolx = krsx;
    212   int krex0 = krex;
     211  CoinBigIndex kcolx = krsx;
     212  CoinBigIndex krex0 = krex;
    213213  int x_to_y_i = 0;
    214214
    215   for (int krowy=krs; krowy<kre; krowy++) {
     215  for (CoinBigIndex krowy=krs; krowy<kre; krowy++) {
    216216    int jcol = hcol[krowy];
    217217
     
    221221    // see if row appears in colx
    222222    // do NOT look beyond the original elements of rowx
    223     //int kcolx = presolve_find_row1(jcol, krsx, krex, hcol);
     223    //CoinBigIndex kcolx = presolve_find_row1(jcol, krsx, krex, hcol);
    224224    while (kcolx < krex0 && hcol[kcolx] < jcol)
    225225      kcolx++;
     
    309309
    310310  for (int i = 0; i < nrows; ++i) {
    311     int krs = mrstrt[i];
    312     int kre = krs + hinrow[i];
    313     for (int kr = krs; kr < kre; ++kr) {
     311    CoinBigIndex krs = mrstrt[i];
     312    CoinBigIndex kre = krs + hinrow[i];
     313    for (CoinBigIndex kr = krs; kr < kre; ++kr) {
    314314      int icol = hcol[kr];
    315315      int iput = hincol[icol];
     
    327327// exactly the same, with some code #if'ed out
    328328int ekk_makeColumnOrdered(int * indexRow , int * indexColumn , double * element ,
    329                           int * rowCount , int * columnCount , int * startColumn ,
     329                          int * rowCount , int * columnCount , CoinBigIndex * startColumn ,
    330330                          int numberRows , int numberColumns,
    331                           int numberElements, double tolerance)
     331                          CoinBigIndex numberElements, double tolerance)
    332332{
    333333  int iColumn,i,k;
     
    396396  numberElements=0;
    397397  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    398     int start=startColumn[iColumn];
    399     int end =startColumn[iColumn+1];
     398    CoinBigIndex start=startColumn[iColumn];
     399    CoinBigIndex end =startColumn[iColumn+1];
    400400    startColumn[iColumn]=numberElements;
    401401    if (end>start) {
     
    450450  double *colels        = prob->colels_;
    451451  int *hrow     = prob->hrow_;
    452   int *mcstrt   = prob->mcstrt_;
     452  CoinBigIndex *mcstrt  = prob->mcstrt_;
    453453  int *hincol   = prob->hincol_;
    454454  const int ncols       = prob->ncols_;
     
    459459  double *rowels        = prob->rowels_;
    460460  int *hcol     = prob->hcol_;
    461   int *mrstrt   = prob->mrstrt_;
     461  CoinBigIndex *mrstrt  = prob->mrstrt_;
    462462  int *hinrow   = prob->hinrow_;
    463463  const int nrows       = prob->nrows_;
     
    540540    if (hincol[jcoly] > 1 && hincol[jcoly] <= fill_level &&
    541541        implied_free[jcoly] == hincol[jcoly]) {
    542       int kcs = mcstrt[jcoly];
    543       int kce = kcs + hincol[jcoly];
     542      CoinBigIndex kcs = mcstrt[jcoly];
     543      CoinBigIndex kce = kcs + hincol[jcoly];
    544544
    545545      int bestrowy_size = 0;
     
    548548      double bestrowy_coeff=0.0;
    549549
    550       for (int k=kcs; k<kce; ++k) {
     550      for (CoinBigIndex k=kcs; k<kce; ++k) {
    551551        int row = hrow[k];
    552552        double coeffj = colels[k];
     
    563563
    564564            fabs(rlo[row] - rup[row]) < tol) {
    565           int krs = mrstrt[row];
    566           int kre = krs + hinrow[row];
     565          CoinBigIndex krs = mrstrt[row];
     566          CoinBigIndex kre = krs + hinrow[row];
    567567
    568568          double maxup, maxdown, ilow, iup;
     
    616616
    617617      bool all_ok = true;
    618       for (int k=kcs; k<kce; ++k) {
     618      for (CoinBigIndex k=kcs; k<kce; ++k) {
    619619        double coeff_factor = fabs(colels[k] / bestrowy_coeff);
    620620        if (fabs(coeff_factor) > 1.3)
     
    626626        // compute fill-in
    627627        int row1 = -1;
    628         int row2;
    629         for (int kk=kcs; kk<kce; ++kk)
     628        int row2=-1;
     629        for (CoinBigIndex kk=kcs; kk<kce; ++kk)
    630630          if (kk != bestrowy_k) {
    631631            if (row1 == -1)
     
    636636
    637637
    638         int krs = mrstrt[bestrowy_row];
    639         int kre = krs + hinrow[bestrowy_row];
    640         int krs1 = mrstrt[row1];
    641         int kre1 = krs + hinrow[row1];
    642         int krs2 = mrstrt[row2];
    643         int kre2 = krs + hinrow[row2];
     638        CoinBigIndex krs = mrstrt[bestrowy_row];
     639        CoinBigIndex kre = krs + hinrow[bestrowy_row];
     640        CoinBigIndex krs1 = mrstrt[row1];
     641        CoinBigIndex kre1 = krs + hinrow[row1];
     642        CoinBigIndex krs2 = mrstrt[row2];
     643        CoinBigIndex kre2 = krs + hinrow[row2];
    644644
    645645        CoinSort_2(hcol+krs,hcol+krs+hinrow[bestrowy_row],rowels+krs);
     
    651651
    652652        int nfill = -hinrow[bestrowy_row];
    653         int kcol1 = krs1;
    654         for (int kk=krs; kk<kre; ++kk) {
     653        CoinBigIndex kcol1 = krs1;
     654        for (CoinBigIndex kk=krs; kk<kre; ++kk) {
    655655          int jcol = hcol[kk];
    656656
     
    660660            nfill++;
    661661        }
    662         int kcol2 = krs2;
    663         for (int kk=krs; kk<kre; ++kk) {
     662        CoinBigIndex kcol2 = krs2;
     663        for (CoinBigIndex kk=krs; kk<kre; ++kk) {
    664664          int jcol = hcol[kk];
    665665
     
    710710#endif
    711711
    712         int kcs = mcstrt[jcoly];
     712        CoinBigIndex kcs = mcstrt[jcoly];
    713713        int rowy = bestrowy_row;
    714714        double coeffy = bestrowy_coeff;
     
    724724
    725725        int ntotels = 0;
    726         for (int k=kcs; k<kce; ++k) {
     726        for (CoinBigIndex k=kcs; k<kce; ++k) {
    727727          int irow = hrow[k];
    728728          ntotels += hinrow[irow];
     
    753753          {
    754754            int nel = 0;
    755             for (int k=kcs; k<kce; ++k) {
     755            for (CoinBigIndex k=kcs; k<kce; ++k) {
    756756              int irow = hrow[k];
    757               int krs = mrstrt[irow];
    758               int kre = krs + hinrow[irow];
     757              CoinBigIndex krs = mrstrt[irow];
     758              CoinBigIndex kre = krs + hinrow[irow];
    759759
    760760              prob->addRow(irow);
     
    784784          double *save_costs = costsx;
    785785          double coeffj = coeffy;
    786           int krs = mrstrt[rowy];
    787           int kre = krs + hinrow[rowy];
     786          CoinBigIndex krs = mrstrt[rowy];
     787          CoinBigIndex kre = krs + hinrow[rowy];
    788788
    789789          double rhs = rlo[rowy];
    790790          double costj = cost[jcoly];
    791791
    792           for (int k=krs; k<kre; k++) {
     792          for (CoinBigIndex k=krs; k<kre; k++) {
    793793            int jcol = hcol[k];
    794794            prob->addCol(jcol);
     
    816816#if     DEBUG_PRESOLVE
    817817            if (hincol[jcoly] == 3) {
    818               int krs = mrstrt[rowy];
    819               int kre = krs + hinrow[rowy];
     818              CoinBigIndex krs = mrstrt[rowy];
     819              CoinBigIndex kre = krs + hinrow[rowy];
    820820              printf("HROW0 (%d):  ", rowy);
    821               for (int k=krs; k<kre; ++k) {
     821              for (CoinBigIndex k=krs; k<kre; ++k) {
    822822                int jcol = hcol[k];
    823823                double coeff = rowels[k];
     
    829829
    830830            if (hincol[jcoly] != 2) {
    831               int krs = mrstrt[rowy];
    832               int kre = krs + hinrow[rowy];
     831              CoinBigIndex krs = mrstrt[rowy];
     832              CoinBigIndex kre = krs + hinrow[rowy];
    833833              CoinSort_2(hcol+krs,hcol+krs+hinrow[rowy],rowels+krs);
    834834              //ekk_sort2(hcol+krs,  rowels+krs,  hinrow[rowy]);
     
    838838            // Use ap as mcstrt etc may move if compacted
    839839            kce = hincol[jcoly];
    840             int k;
     840            CoinBigIndex k;
    841841            action *ap = &actions[nactions-1];
    842842            for (k=0; k<kce; ++k) {
     
    850850#if     DEBUG_PRESOLVE
    851851                {
    852                   int krs = mrstrt[rowx];
    853                   int kre = krs + hinrow[rowx];
     852                  CoinBigIndex krs = mrstrt[rowx];
     853                  CoinBigIndex kre = krs + hinrow[rowx];
    854854                  printf("HROW (%d %d %d):  ", rowx, hinrow[rowx], jcoly);
    855                   for (int k=krs; k<kre; ++k) {
     855                  for (CoinBigIndex k=krs; k<kre; ++k) {
    856856                    int jcol = hcol[k];
    857857                    double coeff = rowels[k];
     
    860860                  printf("\n");
    861861#if 0
    862                   for (int k=krs; k<kre; ++k) {
     862                  for (CoinBigIndex k=krs; k<kre; ++k) {
    863863                    int jcol = hcol[k];
    864864                    prob->addCol(jcol);
     
    871871#endif
    872872                {
    873                   int krsx = mrstrt[rowx];
    874                   int krex = krsx + hinrow[rowx];
     873                  CoinBigIndex krsx = mrstrt[rowx];
     874                  CoinBigIndex krex = krsx + hinrow[rowx];
    875875                  int i;
    876876                  for (i=krsx;i<krex;i++)
     
    897897                // from the row rep to the col rep
    898898                {
    899                   int krs = mrstrt[rowy];
    900                   int kre = krs + hinrow[rowy];
     899                  CoinBigIndex krs = mrstrt[rowy];
     900                  CoinBigIndex kre = krs + hinrow[rowy];
    901901                  int niny = hinrow[rowy];
    902902                 
    903                   int krsx = mrstrt[rowx];
    904                   int krex = krsx + hinrow[rowx];
    905                   for (int ki=0; ki<niny; ++ki) {
    906                     int k = krs + ki;
     903                  CoinBigIndex krsx = mrstrt[rowx];
     904                  CoinBigIndex krex = krsx + hinrow[rowx];
     905                  for (CoinBigIndex ki=0; ki<niny; ++ki) {
     906                    CoinBigIndex k = krs + ki;
    907907                    int jcol = hcol[k];
    908908                    prob->addCol(jcol);
    909                     int kcs = mcstrt[jcol];
    910                     int kce = kcs + hincol[jcol];
     909                    CoinBigIndex kcs = mcstrt[jcol];
     910                    CoinBigIndex kce = kcs + hincol[jcol];
    911911                   
    912912                    //double coeff = rowels[presolve_find_row(jcol, krsx, krex, hcol)];
     
    916916                   
    917917                    // see if rowx appeared in jcol in the col rep
    918                     int k2 = presolve_find_row1(rowx, kcs, kce, hrow);
     918                    CoinBigIndex k2 = presolve_find_row1(rowx, kcs, kce, hrow);
    919919                   
    920920                    //PRESOLVEASSERT(fabs(coeff) > ZTOLDP);
     
    944944#if     DEBUG_PRESOLVE
    945945                {
    946                   int krs = mrstrt[rowx];
    947                   int kre = krs + hinrow[rowx];
     946                  CoinBigIndex krs = mrstrt[rowx];
     947                  CoinBigIndex kre = krs + hinrow[rowx];
    948948                  printf("HROW (%d %d %d):  ", rowx, hinrow[rowx], jcoly);
    949                   for (int k=krs; k<kre; ++k) {
     949                  for (CoinBigIndex k=krs; k<kre; ++k) {
    950950                    int jcol = hcol[k];
    951951                    double coeff = rowels[k];
     
    954954                  printf("\n");
    955955#if 0
    956                   for (int k=krs; k<kre; ++k) {
     956                  for (CoinBigIndex k=krs; k<kre; ++k) {
    957957                    int jcol = hcol[k];
    958958                    double coeff = rowels[k];
     
    978978            // delete rowy in col rep
    979979            {
    980               int krs = mrstrt[rowy];
    981               int kre = krs + hinrow[rowy];
    982               for (int k=krs; k<kre; ++k) {
     980              CoinBigIndex krs = mrstrt[rowy];
     981              CoinBigIndex kre = krs + hinrow[rowy];
     982              for (CoinBigIndex k=krs; k<kre; ++k) {
    983983                int jcol = hcol[k];
    984984               
     
    10051005#if     0 && DEBUG_PRESOLVE
    10061006            printf("ROWY COLS:  ");
    1007             for (int k=0; k<save_ninrowy; ++k)
     1007            for (CoinBigIndex k=0; k<save_ninrowy; ++k)
    10081008              if (rowycols[k] != col) {
    10091009                printf("%d ", rowycols[k]);
     
    10521052  double *colels        = prob->colels_;
    10531053  int *hrow             = prob->hrow_;
    1054   int *mcstrt           = prob->mcstrt_;
     1054  CoinBigIndex *mcstrt          = prob->mcstrt_;
    10551055  int *hincol           = prob->hincol_;
    10561056  int *link             = prob->link_;
     
    10731073  char *cdone   = prob->cdone_;
    10741074  char *rdone   = prob->rdone_;
    1075   int free_list = prob->free_list_;
     1075  CoinBigIndex free_list = prob->free_list_;
    10761076
    10771077  const double ztolzb   = prob->ztolzb_;
     
    11091109      for (int j=0; j<ncols; ++j)
    11101110        if (hincol[j] > 0 && cdone[j]) {
    1111           int krow = presolve_find_row1(jrowx, mcstrt[j], mcstrt[j] + hincol[j], hrow);
     1111          CoinBigIndex krow = presolve_find_row1(jrowx, mcstrt[j], mcstrt[j] + hincol[j], hrow);
    11121112          if (krow < mcstrt[j] + hincol[j])
    11131113            actx += colels[krow] * sol[j];
     
    12201220            for (int k = 0; k<ninrowx; ++k) {
    12211221              int col = rowcolsx[k];
    1222               int kcolx = presolve_find_row3(jrowx, mcstrt[col], hincol[col], hrow, link);
     1222              CoinBigIndex kcolx = presolve_find_row3(jrowx, mcstrt[col], hincol[col], hrow, link);
    12231223
    12241224              if (kcolx != -1) {
     
    12301230
    12311231                {
    1232                   int kk = free_list;
     1232                  CoinBigIndex kk = free_list;
    12331233                  free_list = link[free_list];
    12341234                  check_free_list(free_list);
     
    12641264
    12651265    {
    1266       int k;
     1266      CoinBigIndex k;
    12671267      double dj = maxmin*dcost[icol];
    12681268      double bounds_factor = rhsy/coeffy;
  • branches/devel-1/PresolveTighten.cpp

    r29 r45  
    5757  double *colels        = prob->colels_;
    5858  int *hrow             = prob->hrow_;
    59   int *mcstrt           = prob->mcstrt_;
     59  CoinBigIndex *mcstrt          = prob->mcstrt_;
    6060  int *hincol           = prob->hincol_;
    6161  int ncols             = prob->ncols_;
     
    9696      int iflag=0; /* 1 - up is towards feasibility, -1 down is towards */
    9797
    98       int kcs = mcstrt[j];
    99       int kce = kcs + hincol[j];
     98      CoinBigIndex kcs = mcstrt[j];
     99      CoinBigIndex kce = kcs + hincol[j];
    100100
    101101      // check constraints
    102       for (int k=kcs; k<kce; ++k) {
     102      for (CoinBigIndex k=kcs; k<kce; ++k) {
    103103        int i = hrow[k];
    104104        double coeff = colels[k];
     
    169169  int *mrstrt           = prob->mrstrt_;
    170170  int *hinrow           = prob->hinrow_;
    171           for (int k=kcs; k<kce; ++k) {
     171          for (CoinBigIndex k=kcs; k<kce; ++k) {
    172172            int irow = hrow[k];
    173             int krs = mrstrt[irow];
    174             int kre = krs + hinrow[irow];
     173            CoinBigIndex krs = mrstrt[irow];
     174            CoinBigIndex kre = krs + hinrow[irow];
    175175            printf("%d  %g %g %g:  ",
    176176                   irow, rlo[irow], rup[irow], colels[irow]);
    177             for (int kk=krs; kk<kre; ++kk)
     177            for (CoinBigIndex kk=krs; kk<kre; ++kk)
    178178              printf("%d(%g) ", hcol[kk], rowels[kk]);
    179179            printf("\n");
     
    195195            int nr = 0;
    196196            prob->addCol(j);
    197             for (int k=kcs; k<kce; ++k) {
     197            for (CoinBigIndex k=kcs; k<kce; ++k) {
    198198              int irow = hrow[k];
    199199              // ignore this if we've already made it useless
     
    267267  double *colels        = prob->colels_;
    268268  int *hrow             = prob->hrow_;
    269   int *mcstrt           = prob->mcstrt_;
     269  CoinBigIndex *mcstrt          = prob->mcstrt_;
    270270  int *hincol           = prob->hincol_;
    271271  int *link             = prob->link_;
     
    320320   
    321321    int last_corrected = -1;
    322     int k = mcstrt[jcol];
     322    CoinBigIndex k = mcstrt[jcol];
    323323    int nk = hincol[jcol];
    324324    for (int i=0; i<nk; ++i) {
  • branches/devel-1/PresolveUseless.cpp

    r29 r45  
    2424        int *hrow       = prob->hrow_;
    2525
    26   const int *mcstrt     = prob->mcstrt_;
     26  const CoinBigIndex *mcstrt    = prob->mcstrt_;
    2727
    2828  // may be modified by useless constraint
     
    3434  const double *rowels  = prob->rowels_;
    3535  const int *hcol       = prob->hcol_;
    36   const int *mrstrt     = prob->mrstrt_;
     36  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    3737
    3838  // may be written by useless constraint
     
    5151  for (int i=0; i<nuseless_rows; ++i) {
    5252    int irow = useless_rows[i];
    53     int krs = mrstrt[irow];
    54     int kre = krs + hinrow[irow];
     53    CoinBigIndex krs = mrstrt[irow];
     54    CoinBigIndex kre = krs + hinrow[irow];
    5555
    5656    action *f = &actions[i];
     
    6363    f->rowels  = copyOfArray(&rowels[krs], hinrow[irow]);
    6464
    65     for (int k=krs; k<kre; k++)
     65    for (CoinBigIndex k=krs; k<kre; k++)
    6666      presolve_delete_from_row(hcol[k], irow, mcstrt, hincol, hrow, colels);
    6767    hinrow[irow] = 0;
     
    9090  double *colels        = prob->colels_;
    9191  int *hrow             = prob->hrow_;
    92   int *mcstrt           = prob->mcstrt_;
     92  CoinBigIndex *mcstrt          = prob->mcstrt_;
    9393  int *link             = prob->link_;
    9494  int *hincol           = prob->hincol_;
     
    9999
    100100
    101   int free_list         = prob->free_list_;
     101  CoinBigIndex free_list                = prob->free_list_;
    102102
    103103  double *rlo   = prob->rlo_;
     
    115115    rlo[irow] = f->rlo;
    116116
    117     for (int k=0; k<ninrow; k++) {
     117    for (CoinBigIndex k=0; k<ninrow; k++) {
    118118      int jcol = rowcols[k];
    119       int kk = mcstrt[jcol];
     119      CoinBigIndex kk = mcstrt[jcol];
    120120
    121121      // append deleted row element to each col
    122122      {
    123         int kk = free_list;
     123        CoinBigIndex kk = free_list;
    124124        free_list = link[free_list];
    125125
  • branches/devel-1/PresolveZeros.cpp

    r35 r45  
    1919// returns number of zeros found.
    2020static int drop_col_zeros(int ncheckcols, int *checkcols,
    21                            const int *mcstrt, double *colels, int *hrow,
     21                           const CoinBigIndex *mcstrt, double *colels, int *hrow,
    2222                           int *hincol,
    2323                           dropped_zero *actions)
     
    2828  for (int i=0; i<ncheckcols; i++) {
    2929    int col = checkcols[i];
    30     int kcs = mcstrt[col];
    31     int kce = mcstrt[col] + hincol[col];
    32     int k;
     30    CoinBigIndex kcs = mcstrt[col];
     31    CoinBigIndex kce = mcstrt[col] + hincol[col];
     32    CoinBigIndex k;
    3333
    3434    for (k=kcs; k<kce; ++k) {
     
    6565// didn't bother to change the param names
    6666void drop_row_zeros(int nzeros, const dropped_zero *zeros,
    67                     const int *mcstrt, double *colels, int *hrow,
     67                    const CoinBigIndex *mcstrt, double *colels, int *hrow,
    6868                    int *hincol)
    6969{
    7070  for (int i=0; i<nzeros; i++) {
    7171    int col = zeros[i].row;
    72     int kcs = mcstrt[col];
    73     int kce = mcstrt[col] + hincol[col];
    74     int k;
     72    CoinBigIndex kcs = mcstrt[col];
     73    CoinBigIndex kce = mcstrt[col] + hincol[col];
     74    CoinBigIndex k;
    7575
    7676    for (k=kcs; k<kce; k++) {
     
    9595  double *colels        = prob->colels_;
    9696  int *hrow             = prob->hrow_;
    97   int *mcstrt           = prob->mcstrt_;
     97  CoinBigIndex *mcstrt          = prob->mcstrt_;
    9898  int *hincol           = prob->hincol_;
    9999  int ncols             = prob->ncols_;
     
    112112    double *rowels      = prob->rowels_;
    113113    int *hcol           = prob->hcol_;
    114     int *mrstrt         = prob->mrstrt_;
     114    CoinBigIndex *mrstrt                = prob->mrstrt_;
    115115    int *hinrow         = prob->hinrow_;
    116116    int nrows           = prob->nrows_;
     
    155155  double *colels        = prob->colels_;
    156156  int *hrow             = prob->hrow_;
    157   int *mcstrt           = prob->mcstrt_;
     157  CoinBigIndex *mcstrt          = prob->mcstrt_;
    158158  int *hincol           = prob->hincol_;
    159159  int *link             = prob->link_;
    160   int free_list         = prob->free_list_;
     160  CoinBigIndex free_list                = prob->free_list_;
    161161
    162162  for (const dropped_zero *z = &zeros[nzeros-1]; zeros<=z; z--) {
     
    165165
    166166    {
    167       int k = free_list;
     167      CoinBigIndex k = free_list;
    168168      free_list = link[free_list];
    169169      check_free_list(free_list);
  • branches/devel-1/Test/unitTest.cpp

    r31 r45  
    355355    // matrix data
    356356    //deliberate hiccup of 2 between 0 and 1
    357     int start[5]={0,4,7,8,9};
     357    CoinBigIndex start[5]={0,4,7,8,9};
    358358    int length[5]={2,3,1,1,1};
    359359    int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
  • branches/devel-1/include/ClpMatrixBase.hpp

    r23 r45  
    1414class CoinIndexedVector;
    1515class ClpSimplex;
    16 typedef int ClpBigIndex;
    1716
    1817/** Abstract base class for Clp Matrices
     
    3938  virtual bool isColOrdered() const = 0;
    4039   /** Number of entries in the packed matrix. */
    41   virtual int getNumElements() const = 0;
     40  virtual CoinBigIndex getNumElements() const = 0;
    4241   /** Number of columns. */
    4342  virtual int getNumCols() const = 0;
     
    5756   virtual const int * getIndices() const = 0;
    5857
    59    virtual const int * getVectorStarts() const = 0;
     58   virtual const CoinBigIndex * getVectorStarts() const = 0;
    6059   /** The lengths of the major-dimension vectors. */
    6160   virtual const int * getVectorLengths() const = 0 ;
     
    7170  /** Returns number of elements in basis
    7271      column is basic if entry >=0 */
    73   virtual ClpBigIndex numberInBasis(const int * columnIsBasic) const = 0;
     72  virtual CoinBigIndex numberInBasis(const int * columnIsBasic) const = 0;
    7473  /// Fills in basis (Returns number of elements and updates numberBasic)
    75   virtual ClpBigIndex fillBasis(const ClpSimplex * model,
     74  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
    7675                                const int * columnIsBasic, int & numberBasic,
    7776                                int * row, int * column,
  • branches/devel-1/include/ClpModel.hpp

    r36 r45  
    7373        given in a standard column major ordered format (without gaps). */
    7474  void loadProblem (  const int numcols, const int numrows,
    75                      const int* start, const int* index,
     75                     const CoinBigIndex* start, const int* index,
    7676                     const double* value,
    7777                     const double* collb, const double* colub,   
     
    8181  /// This one is for after presolve to save memory
    8282  void loadProblem (  const int numcols, const int numrows,
    83                      const int* start, const int* index,
     83                     const CoinBigIndex* start, const int* index,
    8484                      const double* value,const int * length,
    8585                     const double* collb, const double* colub,   
  • branches/devel-1/include/ClpPackedMatrix.hpp

    r23 r45  
    2727    virtual bool isColOrdered() const { return matrix_->isColOrdered(); }
    2828   /** Number of entries in the packed matrix. */
    29   virtual  int getNumElements() const { return matrix_->getNumElements(); }
     29  virtual  CoinBigIndex getNumElements() const
     30  { return matrix_->getNumElements(); }
    3031   /** Number of columns. */
    3132   virtual int getNumCols() const { return matrix_->getNumCols(); }
     
    4748  { return matrix_->getIndices();};
    4849
    49    virtual const int * getVectorStarts() const
     50   virtual const CoinBigIndex * getVectorStarts() const
    5051  { return matrix_->getVectorStarts();};
    5152   /** The lengths of the major-dimension vectors. */
     
    7071  /** Returns number of elements in basis
    7172      column is basic if entry >=0 */
    72   virtual ClpBigIndex numberInBasis(const int * columnIsBasic) const ;
     73  virtual CoinBigIndex numberInBasis(const int * columnIsBasic) const ;
    7374  /// Fills in basis (Returns number of elements and updates numberBasic)
    74   virtual ClpBigIndex fillBasis(const ClpSimplex * model,
     75  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
    7576                                const int * columnIsBasic, int & numberBasic,
    7677                                int * row, int * column,
  • branches/devel-1/include/ClpSimplex.hpp

    r33 r45  
    103103        given in a standard column major ordered format (without gaps). */
    104104  void loadProblem (  const int numcols, const int numrows,
    105                      const int* start, const int* index,
     105                     const CoinBigIndex* start, const int* index,
    106106                     const double* value,
    107107                     const double* collb, const double* colub,   
     
    111111  /// This one is for after presolve to save memory
    112112  void loadProblem (  const int numcols, const int numrows,
    113                      const int* start, const int* index,
     113                     const CoinBigIndex* start, const int* index,
    114114                      const double* value,const int * length,
    115115                     const double* collb, const double* colub,   
  • branches/devel-1/include/Presolve.hpp

    r40 r45  
    116116  int ncols_;
    117117  int nrows_;
    118   int nelems_;
     118  CoinBigIndex nelems_;
    119119  /// Number of major passes
    120120  int numberPasses_;
  • branches/devel-1/include/PresolveForcing.hpp

    r29 r45  
    3939
    4040// HACK - from doubleton.cpp
    41 void compact_rep(double *elems, int *indices, int *starts, const int *lengths, int n,
     41void compact_rep(double *elems, int *indices, CoinBigIndex *starts, const int *lengths, int n,
    4242                 const presolvehlink *link);
    4343
  • branches/devel-1/include/PresolveMatrix.hpp

    r43 r45  
    2323
    2424void presolve_delete_from_row(int row, int col /* thing to delete */,
    25                      const int *mrstrt,
     25                     const CoinBigIndex *mrstrt,
    2626                     int *hinrow, int *hcol, double *dels);
    2727
    28 int presolve_find_row(int row, int kcs, int kce, const int *hrow);
    29 int presolve_find_row1(int row, int kcs, int kce, const int *hrow);
     28int presolve_find_row(int row, CoinBigIndex kcs, CoinBigIndex kce, const int *hrow);
     29int presolve_find_row1(int row, CoinBigIndex kcs, CoinBigIndex kce, const int *hrow);
    3030
    3131//#define       DEBUG_PRESOLVE  1
     
    151151  const int ncols0_;
    152152
    153   int nelems_;
    154 
    155   int *mcstrt_;
     153  CoinBigIndex nelems_;
     154
     155  CoinBigIndex *mcstrt_;
    156156  int *hincol_;
    157157  int *hrow_;
     
    177177                        int ncols_,
    178178                        int nrows_,
    179                         int nelems_);
     179                        CoinBigIndex nelems_);
    180180
    181181  ~PrePostsolveMatrix();
     
    306306  // rowrep
    307307  int nrows_;   // note 77
    308   int *mrstrt_;
     308  CoinBigIndex *mrstrt_;
    309309  int *hinrow_;
    310310  double *rowels_;
     
    388388                    // rowrep
    389389                    int nrows,
    390                     int nelems,
     390                    CoinBigIndex nelems,
    391391                 bool doStatus);
    392392
     
    400400                            int nrows0,
    401401                            int ncols0,
    402                             int nelems0);
     402                            CoinBigIndex nelems0);
    403403};
    404404
     
    410410
    411411
    412   int free_list_;
     412  CoinBigIndex free_list_;
    413413  int maxlink_;
    414414  int *link_;
     
    426426                   int ncols0,
    427427                   int nrows0,
    428                    int nelems0,
     428                   CoinBigIndex nelems0,
    429429                     
    430430                   double maxmin_,
     
    459459inline void swap(int &x, int &y) { int temp = x; x = y; y = temp; }
    460460inline void swap(double &x, double &y) { double temp = x; x = y; y = temp; }
     461inline void swap(long &x, long &y) { long temp = x; x = y; y = temp; }
    461462
    462463inline void swap(int *&x, int *&y) { int *temp = x; x = y; y = temp; }
     
    491492}
    492493#define PRESOLVEFINITE(n)       (-PRESOLVE_INF < (n) && (n) < PRESOLVE_INF)
    493 int presolve_find_row2(int irow, int ks, int nc, const int *hrow, const int *link);
    494 void presolve_make_memlists(int *starts, int *lengths,
     494int presolve_find_row2(int irow, CoinBigIndex ks, int nc, const int *hrow, const int *link);
     495void presolve_make_memlists(CoinBigIndex *starts, int *lengths,
    495496                       presolvehlink *link,
    496497                       int n);
    497 int presolve_find_row3(int irow, int ks, int nc, const int *hrow, const int *link);
     498int presolve_find_row3(int irow, CoinBigIndex ks, int nc, const int *hrow, const int *link);
    498499void presolve_delete_from_row(int row, int col /* thing to delete */,
    499                      const int *mrstrt,
     500                     const CoinBigIndex *mrstrt,
    500501                              int *hinrow, int *hcol, double *dels);
    501502void presolve_delete_from_row2(int row, int col /* thing to delete */,
    502                       int *mrstrt,
    503                                int *hinrow, int *hcol, double *dels, int *link, int *free_listp);
     503                      CoinBigIndex *mrstrt,
     504                               int *hinrow, int *hcol, double *dels, int *link, CoinBigIndex *free_listp);
    504505#endif
  • branches/devel-1/include/PresolvePsdebug.hpp

    r29 r45  
    44#ifndef PresolvePsdebug_H
    55#define PresolvePsdebug_H
    6 void presolve_hincol_ok(const int *mcstrt, const int *hincol,
     6void presolve_hincol_ok(const CoinBigIndex *mcstrt, const int *hincol,
    77               const int *hinrow,
    88               const int *hrow, int ncols);
    99
    10 void presolve_links_ok(presolvehlink *link, int *starts, int *lengths, int n);
     10void presolve_links_ok(presolvehlink *link, CoinBigIndex *starts, int *lengths, int n);
    1111
    1212
    13 void presolve_no_zeros(const int *mcstrt, const double *colels, const int *hincol, int ncols);
     13void presolve_no_zeros(const CoinBigIndex *mcstrt, const double *colels, const int *hincol, int ncols);
    1414#endif
  • branches/devel-1/include/PresolveSubst.hpp

    r29 r45  
    5656                           const double *clo, const double *cup,
    5757                           const int *hcol,
    58                            int krs, int kre,
     58                           CoinBigIndex krs, CoinBigIndex kre,
    5959                           double *maxupp, double *maxdownp,
    6060                           int jcol,
Note: See TracChangeset for help on using the changeset viewer.