Changeset 2344


Ignore:
Timestamp:
Sep 29, 2017 7:14:01 AM (9 months ago)
Author:
forrest
Message:

change int to CoinBigIndex?

Location:
trunk/Cbc/src
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchToFixLots.cpp

    r1899 r2344  
    192192                // check elements
    193193                int numberUnsatisfied = 0;
    194                 for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     194                for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    195195                    int iColumn = column[j];
    196196                    double value = elementByRow[j];
     
    209209                if (oneRow && rhsValue <= 1.0 + tolerance) {
    210210                    if (!numberUnsatisfied) {
    211                         for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     211                        for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    212212                            int iColumn = column[j];
    213213                            if (dsort[iColumn] > 1.0e50) {
     
    265265            int numberUnsatisfied = 0;
    266266            double sum = 0.0;
    267             for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     267            for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    268268                int iColumn = column[j];
    269269                if (solver->isInteger(iColumn)) {
     
    286286        }
    287287        assert (nBest > 0);
    288         for (int j = rowStart[kRow]; j < rowStart[kRow] + rowLength[kRow]; j++) {
     288        for (CoinBigIndex j = rowStart[kRow]; j < rowStart[kRow] + rowLength[kRow]; j++) {
    289289            int iColumn = column[j];
    290290            if (solver->isInteger(iColumn)) {
     
    447447            // check elements
    448448            int numberUnsatisfied = 0;
    449             for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     449            for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    450450                int iColumn = column[j];
    451451                double value = elementByRow[j];
     
    467467                } else {
    468468                    numberClean++;
    469                     for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     469                    for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    470470                        int iColumn = column[j];
    471471                        if (columnLower[iColumn] != columnUpper[iColumn] && !mark[iColumn]) {
     
    524524            int numberUnsatisfied = 0;
    525525            double sum = 0.0;
    526             for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     526            for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    527527                int iColumn = column[j];
    528528                if (solver->isInteger(iColumn)) {
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r2341 r2344  
    824824            //printf("%s has %d cuts and %d elements\n",generatorName_,
    825825            //     nCuts,nEls);
    826             int nElsNow = solver->getMatrixByCol()->getNumElements();
     826            CoinBigIndex nElsNow = solver->getMatrixByCol()->getNumElements();
    827827            int numberColumns = solver->getNumCols();
    828828            int numberRows = solver->getNumRows();
    829829            //double averagePerRow = static_cast<double>(nElsNow)/
    830830            //static_cast<double>(numberRows);
    831             int nAdd;
    832             int nAdd2;
    833             int nReasonable;
     831            CoinBigIndex nAdd;
     832            CoinBigIndex nAdd2;
     833            CoinBigIndex nReasonable;
    834834            if (!model_->parentModel() && depth < 2) {
    835835                if (inaccuracy_ < 3) {
     
    866866                // just add most effective
    867867#ifndef JJF_ONE
    868                 int nDelete = nEls - nReasonable;
     868                CoinBigIndex nDelete = nEls - nReasonable;
    869869
    870870                nElsNow = nEls;
  • trunk/Cbc/src/CbcFathomDynamicProgramming.cpp

    r1886 r2344  
    167167       variables may get fixed but seems unlikely */
    168168    for (i = 0; i < numberColumns; i++) {
    169         int j;
     169        CoinBigIndex j;
    170170        double lowerValue = lower[i];
    171171        assert (lowerValue == floor(lowerValue));
     
    238238    // See if we can tighten bounds
    239239    for (i = 0; i < numberColumns; i++) {
    240         int j;
     240        CoinBigIndex j;
    241241        double lowerValue = lower[i];
    242242        double gap = upper[i] - lowerValue;
     
    576576                        if (n == columnLength[i]) {
    577577                            bool good = true;
    578                             for (int j = columnStart[i];
     578                            for (CoinBigIndex j = columnStart[i];
    579579                                    j < columnStart[i] + columnLength[i]; j++) {
    580580                                int iRow = row[j];
     
    602602            memset(rowActivity, 0, numberRows*sizeof(double));
    603603            for (i = 0; i < numberColumns; i++) {
    604                 int j;
     604                CoinBigIndex j;
    605605                double value = betterSolution[i];
    606606                if (value) {
  • trunk/Cbc/src/CbcFollowOn.cpp

    r1899 r2344  
    6464                // check elements
    6565                bool good = true;
    66                 for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     66                for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    6767                    int iColumn = column[j];
    6868                    if (!solver->isBinary(iColumn))
     
    152152            int number1 = 0;
    153153            int numberUnsatisfied = 0;
    154             for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     154            for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    155155                int iColumn = column[j];
    156156                double value = elementByRow[j];
     
    194194            int numberUnsatisfied = 0;
    195195            int n = 0;
    196             int j;
     196            CoinBigIndex j;
    197197            for (j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    198198                int iColumn = column[j];
     
    201201                    if (solValue < 1.0 - integerTolerance && solValue > integerTolerance) {
    202202                        numberUnsatisfied++;
    203                         for (int jj = columnStart[iColumn]; jj < columnStart[iColumn] + columnLength[iColumn]; jj++) {
     203                        for (CoinBigIndex jj = columnStart[iColumn]; jj < columnStart[iColumn] + columnLength[iColumn]; jj++) {
    204204                            int iRow = row[jj];
    205205                            if (rhs_[iRow]) {
     
    336336    int * upList = new int[numberColumns];
    337337    int * downList = new int[numberColumns];
    338     int j;
     338    CoinBigIndex j;
    339339    for (j = rowStart[whichRow]; j < rowStart[whichRow] + rowLength[whichRow]; j++) {
    340340        int iColumn = column[j];
    341341        if (columnLower[iColumn] != columnUpper[iColumn]) {
    342342            bool up = true;
    343             for (int jj = columnStart[iColumn]; jj < columnStart[iColumn] + columnLength[iColumn]; jj++) {
     343            for (CoinBigIndex jj = columnStart[iColumn]; jj < columnStart[iColumn] + columnLength[iColumn]; jj++) {
    344344                int iRow = row[jj];
    345345                if (iRow == otherRow) {
  • trunk/Cbc/src/CbcHeuristic.cpp

    r2341 r2344  
    20972097    memset(rowActivity, 0, numberRows*sizeof(double));
    20982098    for (i = 0; i < numberColumns; i++) {
    2099         int j;
     2099        CoinBigIndex j;
    21002100        double value = newSolution[i];
    21012101        if (value < lower[i]) {
     
    21512151            newSolution[iColumn] = newValue;
    21522152            newSolutionValue += move * cost;
    2153             int j;
     2153            CoinBigIndex j;
    21542154            for (j = columnStart[iColumn];
    21552155                    j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     
    21732173            // maybe put in coding for multiple slacks?
    21742174            double bestCost = 1.0e50;
    2175             int k;
     2175            CoinBigIndex k;
    21762176            int iBest = -1;
    21772177            double addCost = 0.0;
     
    22612261            double lowerValue = lower[iColumn];
    22622262            double upperValue = upper[iColumn];
    2263             int j;
     2263            CoinBigIndex j;
    22642264            int anyBadDown = 0;
    22652265            int anyBadUp = 0;
     
    24092409                double lowerValue = lower[iColumn];
    24102410                double upperValue = upper[iColumn];
    2411                 int j;
     2411                CoinBigIndex j;
    24122412                int anyBadDown = 0;
    24132413                int anyBadUp = 0;
     
    26272627                    } else {
    26282628                        // see if we can move
    2629                         int j;
     2629                        CoinBigIndex j;
    26302630                        for (j = columnStart[iColumn];
    26312631                                j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     
    26412641                            newSolution[iColumn] = newValue;
    26422642                            newSolutionValue += move * cost;
    2643                             int j;
     2643                            CoinBigIndex j;
    26442644                            for (j = columnStart[iColumn];
    26452645                                    j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     
    26662666            memset(rowActivity, 0, numberRows*sizeof(double));
    26672667            for (i = 0; i < numberColumns; i++) {
    2668                 int j;
     2668                CoinBigIndex j;
    26692669                double value = newSolution[i];
    26702670                if (value) {
  • trunk/Cbc/src/CbcHeuristicDW.cpp

    r2094 r2344  
    18831883  // get space to add elements
    18841884#define MAX_ADD 100000
    1885   int * startsDW = new int[numberBlocks_+1+MAX_ADD];
    1886   int * rowDW = startsDW+numberBlocks_+1;
     1885  CoinBigIndex * startsDW = new CoinBigIndex[numberBlocks_+1+MAX_ADD];
     1886  int * rowDW = reinterpret_cast<int *>(startsDW+numberBlocks_+1);
    18871887  double * elementDW = new double[MAX_ADD+3*numberBlocks_+numberMasterRows_];
    18881888  double * newCost = elementDW+MAX_ADD;
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r2280 r2344  
    10591059      memset(rowActivity, 0, numberRows*sizeof(double));
    10601060      for (int i = 0; i < numberColumns; i++) {
    1061         int j;
     1061        CoinBigIndex j;
    10621062        double value = newSolution[i];
    10631063        if (value) {
     
    13731373        int nPositiveOther = 0;
    13741374        int nNegativeOther = 0;
    1375         for (int k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
     1375        for (CoinBigIndex k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
    13761376            int iColumn = column[k];
    13771377            if (isHeuristicInteger(solver,iColumn) &&
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r2280 r2344  
    16571657                    numberIterations = solver->getIterationCount();
    16581658                } else {
    1659                     int * addStart = new int[2*general+1];
     1659                    CoinBigIndex * addStart = new CoinBigIndex[2*general+1];
    16601660                    int * addIndex = new int[4*general];
    16611661                    double * addElement = new double[4*general];
     
    25352535    if (general) {
    25362536      CbcModel * saveModel = model_;
    2537       int * addStart = new int[nAdd+1];
    2538       memset(addStart,0,(nAdd+1)*sizeof(int));
     2537      CoinBigIndex * addStart = new CoinBigIndex[nAdd+1];
     2538      memset(addStart,0,(nAdd+1)*sizeof(CoinBigIndex));
    25392539      int * addIndex = new int[general+nAdd];
    25402540      double * addElement = new double[general+nAdd];
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r2280 r2344  
    523523
    524524    for (i = 0; i < numberColumns; i++) {
    525         int j;
     525        CoinBigIndex j;
    526526        double value = newSolution[i];
    527527        if (value) {
     
    631631            double objectiveCoefficient = cost[i];
    632632            int k;
    633             int j;
     633            CoinBigIndex j;
    634634            int goodK = -1;
    635635            int wayK = -1, wayI = -1;
     
    884884
    885885            for (i = 0; i < numberColumns; i++) {
    886                 int j;
     886                CoinBigIndex j;
    887887                double value = newSolution[i];
    888888                if (value) {
  • trunk/Cbc/src/CbcHeuristicRandRound.cpp

    r2094 r2344  
    217217    const double * matrixElements = matrixByRow->getElements();
    218218    const int * matrixIndices = matrixByRow->getIndices();
    219     const int * matrixStarts = matrixByRow->getVectorStarts();
     219    const CoinBigIndex * matrixStarts = matrixByRow->getVectorStarts();
    220220    for (int j = 0; j < numRows; j++) {
    221         for (int i = matrixStarts[j]; i < matrixStarts[j+1]; i++) {
     221        for (CoinBigIndex i = matrixStarts[j]; i < matrixStarts[j+1]; i++) {
    222222            matrix[j][matrixIndices[i]] = matrixElements[i];
    223223        }
  • trunk/Cbc/src/CbcLinked.cpp

    r1899 r2344  
    484484                                //const int * rowLength = originalRowCopy_->getVectorLengths();
    485485                                //int numberColumns2 = coinModel_.numberColumns();
    486                                 for ( i = rowStart[objectiveRow_]; i < rowStart[objectiveRow_+1]; i++)
     486                                for (CoinBigIndex i = rowStart[objectiveRow_]; i < rowStart[objectiveRow_+1]; i++)
    487487                                    gradient[column2[i]] = element[i];
    488488                                for ( i = 0; i < numberObjects_; i++) {
     
    730730                            CoinZeroN(gradient, numberColumns2);
    731731                            //const double * objective = modelPtr_->objective();
    732                             for ( i = rowStart[iRow]; i < rowStart[iRow+1]; i++)
     732                            for (CoinBigIndex i = rowStart[iRow]; i < rowStart[iRow+1]; i++)
    733733                                gradient[column2[i]] = element[i];
    734734                            for ( i = startNonLinear_[iNon]; i < startNonLinear_[iNon+1]; i++) {
     
    807807    //const int * rowLength = originalRowCopy_->getVectorLengths();
    808808    //int numberColumns2 = coinModel_.numberColumns();
    809     for ( i = rowStart[objectiveRow_]; i < rowStart[objectiveRow_+1]; i++)
     809    for (CoinBigIndex i = rowStart[objectiveRow_]; i < rowStart[objectiveRow_+1]; i++)
    810810        gradient[column2[i]] = element[i];
    811811    //const double * columnLower = modelPtr_->columnLower();
     
    34593459                if (clpModel->isInteger(i)) {
    34603460                    double value = 0.0;
    3461                     for (int j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
     3461                    for (CoinBigIndex j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
    34623462                        value += fabs(element[j]);
    34633463                    }
     
    49974997    for (i = 0; i < nAdd; i++) {
    49984998        CoinBigIndex iStart = starts[i];
    4999         coinModel->addRow(starts[i+1] - iStart, index + iStart, element + iStart, rowLower[i], rowUpper[i]);
     4999        coinModel->addRow(static_cast<int>(starts[i+1] - iStart),
     5000                          index + iStart, element + iStart,
     5001                          rowLower[i], rowUpper[i]);
    50005002    }
    50015003    int n = 0;
     
    50935095    for (i = 0; i < 4; i++) {
    50945096        CoinBigIndex iStart = starts[i];
    5095         coinModel->addColumn(starts[i+1] - iStart, index + iStart, element + iStart, columnLower[i],
     5097        coinModel->addColumn(static_cast<int>(starts[i+1] - iStart),
     5098                             index + iStart, element + iStart, columnLower[i],
    50965099                             columnUpper[i], objective[i]);
    50975100    }
     
    52995302        for (j = 0; j < 4; j++) {
    53005303            int iColumn = firstLambda_ + j;
    5301             int iStart = columnStart[iColumn];
    5302             int iEnd = iStart + columnLength[iColumn];
    5303             int k = iStart;
     5304            CoinBigIndex iStart = columnStart[iColumn];
     5305            CoinBigIndex iEnd = iStart + columnLength[iColumn];
     5306            CoinBigIndex k = iStart;
    53045307            double sol = info->solution_[iColumn];
    53055308            for (; k < iEnd; k++) {
     
    54075410            for (j = 0; j < 4; j++) {
    54085411                int iColumn = firstLambda_ + j;
    5409                 int iStart = columnStart[iColumn];
    5410                 int iEnd = iStart + columnLength[iColumn];
    5411                 int k = iStart;
     5412                CoinBigIndex iStart = columnStart[iColumn];
     5413                CoinBigIndex iEnd = iStart + columnLength[iColumn];
     5414                CoinBigIndex k = iStart;
    54125415                double sol = info->solution_[iColumn];
    54135416                for (; k < iEnd; k++) {
     
    57475750            for (j = 0; j < 4; j++) {
    57485751                int iColumn = firstLambda_ + j;
    5749                 int iStart = columnStart[iColumn];
    5750                 int iEnd = iStart + columnLength[iColumn];
    5751                 int k = iStart;
     5752                CoinBigIndex iStart = columnStart[iColumn];
     5753                CoinBigIndex iEnd = iStart + columnLength[iColumn];
     5754                CoinBigIndex k = iStart;
    57525755                double sol = info->solution_[iColumn];
    57535756                for (; k < iEnd; k++) {
     
    58525855            for (j = 0; j < 4; j++) {
    58535856                int iColumn = firstLambda_ + j;
    5854                 int iStart = columnStart[iColumn];
    5855                 int iEnd = iStart + columnLength[iColumn];
    5856                 int k = iStart;
     5857                CoinBigIndex iStart = columnStart[iColumn];
     5858                CoinBigIndex iEnd = iStart + columnLength[iColumn];
     5859                CoinBigIndex k = iStart;
    58575860                double sol = info->solution_[iColumn];
    58585861                for (; k < iEnd; k++) {
     
    59415944        for (j = 0; j < 4; j++) {
    59425945            int iColumn = firstLambda_ + j;
    5943             int iStart = columnStart[iColumn];
    5944             int iEnd = iStart + columnLength[iColumn];
    5945             int k = iStart;
     5946            CoinBigIndex iStart = columnStart[iColumn];
     5947            CoinBigIndex iEnd = iStart + columnLength[iColumn];
     5948            CoinBigIndex k = iStart;
    59465949            double sol = info->solution_[iColumn];
    59475950            for (; k < iEnd; k++) {
     
    63086311        for (j = 0; j < 4; j++) {
    63096312            int iColumn = firstLambda_ + j;
    6310             int iStart = columnStart[iColumn];
    6311             int iEnd = iStart + columnLength[iColumn];
    6312             int k = iStart;
     6313            CoinBigIndex iStart = columnStart[iColumn];
     6314            CoinBigIndex iEnd = iStart + columnLength[iColumn];
     6315            CoinBigIndex k = iStart;
    63136316            double x = 0.0;
    63146317            double y = 0.0;
     
    63386341        for (j = 0; j < 4; j++) {
    63396342            int iColumn = firstLambda_ + j;
    6340             int iStart = columnStart[iColumn];
    6341             int iEnd = iStart + columnLength[iColumn];
    6342             int k = iStart;
     6343            CoinBigIndex iStart = columnStart[iColumn];
     6344            CoinBigIndex iEnd = iStart + columnLength[iColumn];
     6345            CoinBigIndex k = iStart;
    63436346            double x = 0.0;
    63446347            xybar[j] = 0.0;
     
    69016904            int iColumn = i + firstLambda_;
    69026905            if (fabs(solution[iColumn]) > 1.0e-7) {
    6903                 int k = columnStart[iColumn] + 1;
     6906                CoinBigIndex k = columnStart[iColumn] + 1;
    69046907                xValue += element[k] * solution[iColumn];
    69056908                if (first == -1) {
     
    69316934        double y = coefficient_ / x;
    69326935        //assert (columnLength[iColumn]==3); - could have cuts
    6933         int k = columnStart[iColumn];
     6936        CoinBigIndex k = columnStart[iColumn];
    69346937#ifdef KEEPXY
    69356938        // xy
  • trunk/Cbc/src/CbcModel.cpp

    r2341 r2344  
    13541354            } else if (possibleRow[i]) {
    13551355                if (rowLength[i] == 1) {
    1356                     int k = rowStart[i];
     1356                    CoinBigIndex k = rowStart[i];
    13571357                    int iColumn = column[k];
    13581358                    if (!copy2->isInteger(iColumn)) {
     
    82568256              resizeWhichGenerator(numberViolated, numberViolated + numberCuts);
    82578257              // only add new cuts up to 10% of current elements
    8258               int numberElements = solver_->getNumElements();
     8258              CoinBigIndex numberElements = solver_->getNumElements();
    82598259              int numberColumns = solver_->getNumCols();
    8260               int maximumAdd = CoinMax(numberElements/10,2*numberColumns)+100;
     8260              CoinBigIndex maximumAdd = CoinMax(numberElements/10,
     8261                                                static_cast<CoinBigIndex>(2*numberColumns))+100;
    82618262              double * violations = new double[numberCuts];
    82628263              int * which = new int[numberCuts];
     
    1067610677    for (iRow = 0; iRow < numberRows; iRow++) {
    1067710678        int numberP1 = 0, numberM1 = 0;
    10678         int j;
     10679        CoinBigIndex j;
    1067910680        double upperValue = rowUpper[iRow];
    1068010681        double lowerValue = rowLower[iRow];
     
    1358313584        double * sort = new double[numberColumns];
    1358413585        for (iRow = 0; iRow < numberRows; iRow++) {
    13585             int j;
     13586            CoinBigIndex j;
    1358613587            int numberBinary = 0;
    1358713588            int numberUnsatisfiedBinary = 0;
     
    1403714038                thisCut.setLb(rowLower[iRow]);
    1403814039                thisCut.setUb(rowUpper[iRow]);
    14039                 int start = rowStart[iRow];
     14040                CoinBigIndex start = rowStart[iRow];
    1404014041                thisCut.setRow(rowLength[iRow], column + start, elementByRow + start, false);
    1404114042                thisCut.setGloballyValid(true);
  • trunk/Cbc/src/CbcSolver.cpp

    r2333 r2344  
    44974497                                      << CoinMessageEol;
    44984498                                    int spaceNeeded=numberSort+numberDifferentObj;
    4499                                     int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     4499                                    CoinBigIndex * columnAddDummy = new CoinBigIndex[numberDifferentObj+1];
     4500                                    int * columnAdd = new int[spaceNeeded];
    45004501                                    double * elementAdd = new double[spaceNeeded];
    4501                                     int * rowAdd = new int[numberDifferentObj+1];
     4502                                    CoinBigIndex * rowAdd = new CoinBigIndex[numberDifferentObj+1];
    45024503                                    double * objectiveNew = new double[3*numberDifferentObj];
    45034504                                    double * lowerNew = objectiveNew+numberDifferentObj;
    45044505                                    double * upperNew = lowerNew+numberDifferentObj;
    4505                                     memset(columnAdd+spaceNeeded,0,
    4506                                            (numberDifferentObj+1)*sizeof(int));
     4506                                    memset(columnAddDummy,0,
     4507                                           (numberDifferentObj+1)*sizeof(CoinBigIndex));
    45074508                                    iLast=0;
    45084509                                    last=obj[0];
     
    45844585                                      // add columns
    45854586                                      solver2->addCols(numberDifferentObj,
    4586                                                        columnAdd+spaceNeeded, NULL, NULL,
     4587                                                       columnAddDummy, NULL, NULL,
    45874588                                                       lowerNew, upperNew,objectiveNew);
    45884589                                      // add constraints and make integer if all integer in group
     
    46074608                                    }
    46084609                                    delete [] columnAdd;
     4610                                    delete [] columnAddDummy;
    46094611                                    delete [] elementAdd;
    46104612                                    delete [] rowAdd;
     
    47064708                                          double newUpper = 0.0;
    47074709                                          double constantObjective=0.0;
    4708                                           for (int j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     4710                                          for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    47094711                                            int iColumn = column[j];
    47104712                                            if (!solver2->isInteger(iColumn)) {
     
    47544756                                              // move some of objective here if looks constant
    47554757                                              newObjective[addSlacks]=constantObjective;
    4756                                               for (int j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     4758                                              for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    47574759                                                int iColumn = column[j];
    47584760                                                double value = element[j];
     
    1057310575             if (saveModel) {
    1057410576               int spaceNeeded=numberSort+numberDifferentObj;
    10575                int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     10577               CoinBigIndex * columnAddDummy = new CoinBigIndex[numberDifferentObj+1];
     10578               int * columnAdd = new int[spaceNeeded];
    1057610579               double * elementAdd = new double[spaceNeeded];
    10577                int * rowAdd = new int[2*numberDifferentObj+1];
    10578                int * newIsInteger = rowAdd+numberDifferentObj+1;
     10580               CoinBigIndex * rowAdd = new CoinBigIndex[2*numberDifferentObj+1];
     10581               int * newIsInteger = reinterpret_cast<int *>(rowAdd+numberDifferentObj+1);
    1057910582               double * objectiveNew = new double[3*numberDifferentObj];
    1058010583               double * lowerNew = objectiveNew+numberDifferentObj;
    1058110584               double * upperNew = lowerNew+numberDifferentObj;
    10582                memset(columnAdd+spaceNeeded,0,
    10583                       (numberDifferentObj+1)*sizeof(int));
     10585               memset(columnAddDummy,0,
     10586                      (numberDifferentObj+1)*sizeof(CoinBigIndex));
    1058410587               ClpSimplex tempModel=*model;
    1058510588               int iLast=0;
     
    1064110644               tempModel.addColumns(numberDifferentObj, lowerNew, upperNew,
    1064210645                                    objectiveNew,
    10643                                     columnAdd+spaceNeeded, NULL, NULL);
     10646                                    columnAddDummy, NULL, NULL);
    1064410647               // add constraints and make integer if all integer in group
    1064510648               for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     
    1065210655                                 rowAdd,columnAdd,elementAdd);
    1065310656               delete [] columnAdd;
     10657               delete [] columnAddDummy;
    1065410658               delete [] elementAdd;
    1065510659               delete [] rowAdd;
     
    1092210926       const double * element = columnCopy.getElements();
    1092310927       const double * elementByRow = rowCopy.getElements();
    10924        const int * rowStart = rowCopy.getVectorStarts();
     10928       const CoinBigIndex * rowStart = rowCopy.getVectorStarts();
    1092510929       const int * column = rowCopy.getIndices();
    1092610930       int nPossibleZeroCost=0;
     
    1094710951           int iRow=row[columnStart[iColumn]];
    1094810952           double value=COIN_DBL_MAX;
    10949            for (int i=rowStart[iRow];i<rowStart[iRow]+rowLength[iRow];i++) {
     10953           for (CoinBigIndex i=rowStart[iRow];i<rowStart[iRow]+rowLength[iRow];i++) {
    1095010954             int jColumn=column[i];
    1095110955             if (jColumn!=iColumn) {
     
    1134411348          double randomUpper = CoinDrand48();
    1134511349          double randomInteger = CoinDrand48();
    11346           int * startAdd = new int[numberRows+1];
     11350          CoinBigIndex * startAdd = new CoinBigIndex[numberRows+1];
    1134711351          int * columnAdd = new int [2*numberElements];
    1134811352          double * elementAdd = new double[2*numberElements];
     
    1168411688                                             for (CoinBigIndex i = start; i < start + length; i++) {
    1168511689                                                  int jColumn = column[i];
    11686                                                   backColumn2[jColumn] = i - start;
     11690                                                  backColumn2[jColumn] = static_cast<int>(i - start);
    1168711691                                             }
    1168811692                                             for (CoinBigIndex i = start; i < start + length; i++) {
     
    1183911843     delete [] number;
    1184011844     // Now do breakdown of ranges
    11841      breakdown("Elements", numberElements, elementByColumn);
     11845     breakdown("Elements", static_cast<int>(numberElements), elementByColumn);
    1184211846     breakdown("RowLower", numberRows, rowLower);
    1184311847     breakdown("RowUpper", numberRows, rowUpper);
  • trunk/Cbc/src/CbcSolverAnalyze.cpp

    r2071 r2344  
    156156                            && !lower[jColumn2]) {
    157157                        int n = 0;
    158                         int i;
     158                        CoinBigIndex i;
    159159                        double objChange = direction * (objective[jColumn1] + objective[jColumn2]);
    160160                        double bound = CoinMin(upper[jColumn1], upper[jColumn2]);
  • trunk/Cbc/src/CbcSolverExpandKnapsack.cpp

    r1899 r2344  
    291291                        if (iKnapsack < 0) {
    292292                            // might be able to swap - but for now can't have knapsack in
    293                             for (int j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
     293                            for (CoinBigIndex j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
    294294                                int iColumn = column[j];
    295295                                if (whichKnapsack[iColumn] >= 0) {
     
    302302                            // OK if in same knapsack - or maybe just one
    303303                            int marked = markKnapsack[iKnapsack];
    304                             for (int j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
     304                            for (CoinBigIndex j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
    305305                                int iColumn = column[j];
    306306                                if (whichKnapsack[iColumn] != iKnapsack && whichKnapsack[iColumn] >= 0) {
     
    412412                double * buildObj = new double [nLargest];
    413413                double * buildElement = new double [nelLargest];
    414                 int * buildStart = new int[nLargest+1];
     414                CoinBigIndex * buildStart = new CoinBigIndex[nLargest+1];
    415415                int * buildRow = new int[nelLargest];
    416416                // alow for integers in knapsacks
     
    425425                    // Redo row numbers
    426426                    for (iColumn = 0; iColumn < nCreate; iColumn++) {
    427                         for (int j = buildStart[iColumn]; j < buildStart[iColumn+1]; j++) {
     427                        for (CoinBigIndex j = buildStart[iColumn]; j < buildStart[iColumn+1]; j++) {
    428428                            int jRow = buildRow[j];
    429429                            jRow = lookupRow[jRow];
     
    491491                            int jRow = lookupRow[iRow];
    492492                            whichRow[nDelete++] = jRow;
    493                             int start = rowStart[jRow];
     493                            CoinBigIndex start = rowStart[jRow];
    494494                            stored.addCut(rowLower[jRow], rowUpper[jRow],
    495495                                          rowLength[jRow], column + start, elementByRow + start);
  • trunk/Cbc/src/CbcSolverHeuristics.cpp

    r2280 r2344  
    220220    // Get maximum size of VUB tree
    221221    // otherColumn is one fixed to 0 if this one zero
    222     int nEl = matrixByCol.getNumElements();
     222    CoinBigIndex nEl = matrixByCol.getNumElements();
    223223    CoinBigIndex * fixColumn = new CoinBigIndex [numberColumns+1];
    224224    int * otherColumn = new int [nEl];
     
    489489                    }
    490490                }
    491                 for (int i = fixColumn[iColumn]; i < numberOther; i++)
     491                for (CoinBigIndex i = fixColumn[iColumn]; i < numberOther; i++)
    492492                    mark[otherColumn[i]] = 0;
    493493                // reset bound unless infeasible
     
    506506    CoinZeroN(counts, numberColumns);
    507507    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    508         for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++)
     508        for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++)
    509509            counts[otherColumn[i]]++;
    510510    }
     
    520520    // Create other way
    521521    for ( iColumn = 0; iColumn < numberColumns; iColumn++) {
    522         for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     522        for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    523523            int jColumn = otherColumn[i];
    524524            CoinBigIndex put = fixColumn2[jColumn] + counts[jColumn];
     
    533533        for ( iColumn = 0; iColumn < numberColumns; iColumn++) {
    534534            if (fix[iColumn] == kLayer) {
    535                 for (int i = fixColumn2[iColumn]; i < fixColumn2[iColumn+1]; i++) {
     535                for (CoinBigIndex i = fixColumn2[iColumn]; i < fixColumn2[iColumn+1]; i++) {
    536536                    int jColumn = otherColumn2[i];
    537537                    if (fix[jColumn] == kLayer) {
     
    565565                if (fix[iColumn] == jLayer) {
    566566                    numberLayered++;
    567                     int nFix = fixColumn[iColumn+1] - fixColumn[iColumn];
     567                    int nFix = static_cast<int>(fixColumn[iColumn+1] - fixColumn[iColumn]);
    568568                    if (iPass) {
    569569                        // just integers
    570570                        nFix = 0;
    571                         for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     571                        for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    572572                            int jColumn = otherColumn[i];
    573573                            if (clpSolver->isInteger(jColumn))
     
    731731                    for ( iColumn = 0; iColumn < numberColumns; iColumn++) {
    732732                        if (columnUpper[iColumn] == 0.0 && fix[iColumn] == jLayer) {
    733                             for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     733                            for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    734734                                int jColumn = otherColumn[i];
    735735                                if (columnUpper[jColumn]) {
    736736                                    bool canFix = true;
    737                                     for (int k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
     737                                    for (CoinBigIndex k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
    738738                                        int kColumn = otherColumn2[k];
    739739                                        if (state[kColumn] == 1) {
     
    815815                for ( iColumn = 0; iColumn < numberColumns; iColumn++) {
    816816                    if (columnUpper[iColumn] == 0.0 && fix[iColumn] == jLayer) {
    817                         for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     817                        for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    818818                            int jColumn = otherColumn[i];
    819819                            if (columnUpper[jColumn]) {
    820820                                bool canFix = true;
    821                                 for (int k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
     821                                for (CoinBigIndex k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
    822822                                    int kColumn = otherColumn2[k];
    823823                                    if (state[kColumn] == 1) {
     
    859859            if (way == -1) {
    860860                // fix others
    861                 for (int i = fixColumn[iSmallest]; i < fixColumn[iSmallest+1]; i++) {
     861                for (CoinBigIndex i = fixColumn[iSmallest]; i < fixColumn[iSmallest+1]; i++) {
    862862                    int jColumn = otherColumn[i];
    863863                    if (state[jColumn] == -1) {
     
    891891                state[iSmallest] = 1;
    892892                // unfix others
    893                 for (int i = fixColumn[iSmallest]; i < fixColumn[iSmallest+1]; i++) {
     893                for (CoinBigIndex i = fixColumn[iSmallest]; i < fixColumn[iSmallest+1]; i++) {
    894894                    int jColumn = otherColumn[i];
    895895                    if (state[jColumn] == 3) {
     
    945945                    double otherValue = 0.0;
    946946                    int nn = 0;
    947                     for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     947                    for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    948948                        int jColumn = otherColumn[i];
    949949                        if (columnUpper[jColumn] == 0.0) {
     
    992992                    nFixed++;
    993993                    nFixed0++;
    994                     for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     994                    for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    995995                        int jColumn = otherColumn[i];
    996996                        if (columnUpper[jColumn]) {
    997997                            bool canFix = true;
    998                             for (int k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
     998                            for (CoinBigIndex k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
    999999                                int kColumn = otherColumn2[k];
    10001000                                if (state[kColumn] == 1 || state[kColumn] == -2) {
     
    10231023                for ( iColumn = 0; iColumn < numberColumns; iColumn++) {
    10241024                    if (columnUpper[iColumn] == 0.0 && fix[iColumn] == jLayer) {
    1025                         for (int i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
     1025                        for (CoinBigIndex i = fixColumn[iColumn]; i < fixColumn[iColumn+1]; i++) {
    10261026                            int jColumn = otherColumn[i];
    10271027                            if (columnUpper[jColumn]) {
    10281028                                bool canFix = true;
    1029                                 for (int k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
     1029                                for (CoinBigIndex k = fixColumn2[jColumn]; k < fixColumn2[jColumn+1]; k++) {
    10301030                                    int kColumn = otherColumn2[k];
    10311031                                    if (state[kColumn] == 1 || state[kColumn] == -2) {
  • trunk/Cbc/src/CbcStrategy.cpp

    r1641 r2344  
    397397            int iColumn;
    398398            for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    399                 for (int j = columnStart[iColumn];
     399                for (CoinBigIndex j = columnStart[iColumn];
    400400                        j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    401401                    //int iRow = row[j];
     
    424424                                         numberInt, numberClose));
    425425                for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    426                     for (int j = columnStart[iColumn];
     426                    for (CoinBigIndex j = columnStart[iColumn];
    427427                            j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    428428                        //int iRow = row[j];
  • trunk/Cbc/src/OsiCbc/OsiCbcSolverInterface.cpp

    r2083 r2344  
    744744  return modelPtr_->solver()->getNumRows();
    745745}
    746 int
     746CoinBigIndex
    747747OsiCbcSolverInterface::getNumElements() const
    748748{
  • trunk/Cbc/src/OsiCbc/OsiCbcSolverInterface.hpp

    r1899 r2344  
    165165 
    166166  /// Get number of nonzero elements
    167   virtual int getNumElements() const ;
     167  virtual CoinBigIndex getNumElements() const ;
    168168 
    169169  /// Get pointer to array[getNumCols()] of column lower bounds
Note: See TracChangeset for help on using the changeset viewer.