Changeset 2278 for trunk/Clp/examples


Ignore:
Timestamp:
Oct 2, 2017 5:51:14 AM (15 months ago)
Author:
forrest
Message:

COIN_BIG_INDEX 2 changes

Location:
trunk/Clp/examples
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/examples/addColumns.cpp

    r1662 r2278  
    1616int main(int argc, const char *argv[])
    1717{
     18#if COIN_BIG_INDEX<2
    1819     {
    1920          // Empty model
     
    278279          model2.initialSolve();
    279280     }
     281#else
     282     printf("addColumns not available with COIN_BIG_INDEX=2\n");
     283#endif
    280284     return 0;
    281285}
  • trunk/Clp/examples/addRows.cpp

    r1935 r2278  
    1616int main(int argc, const char *argv[])
    1717{
     18#if COIN_BIG_INDEX<2
    1819     try {
    1920          // Empty model
     
    279280               std::cout << "This was from a CoinAssert" << std::endl;
    280281     }
     282#else
     283     printf("addRows not available with COIN_BIG_INDEX=2\n");
     284#endif
    281285     return 0;
    282286}
  • trunk/Clp/examples/decomp2.cpp

    r1662 r2278  
    1010int main(int argc, const char *argv[])
    1111{
     12#if COIN_BIG_INDEX<2
    1213     /* Create a structured model by reading mps file and trying
    1314        Dantzig-Wolfe decomposition (that's the 1 parameter)
     
    3435     // Double check
    3536     solver.primal(1);
     37#else
     38     printf("decomp2 not available with COIN_BIG_INDEX=2\n");
     39#endif
    3640     return 0;
    3741}
  • trunk/Clp/examples/decomp3.cpp

    r1662 r2278  
    1212int main(int argc, const char *argv[])
    1313{
     14#if COIN_BIG_INDEX<2
    1415     /* Create a structured model by reading mps file and trying
    1516        Dantzig-Wolfe or Benders decomposition
     
    105106     solver2.dual();
    106107     std::cout << "second try took " << CoinCpuTime() - time1 << " seconds" << std::endl;
     108#else
     109     printf("this does not work with COIN_BIG_INDEX=2\n");
     110#endif
    107111     return 0;
    108112}
  • trunk/Clp/examples/decompose.cpp

    r1662 r2278  
    8383          columnBlock[iColumn] = -2;
    8484     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    85           int kstart = columnStart[iColumn];
    86           int kend = columnStart[iColumn] + columnLength[iColumn];
     85          CoinBigIndex kstart = columnStart[iColumn];
     86          CoinBigIndex kend = columnStart[iColumn] + columnLength[iColumn];
    8787          if (columnBlock[iColumn] == -2) {
    8888               // column not allocated
    89                int j;
     89               CoinBigIndex j;
    9090               int nstack = 0;
    9191               for (j = kstart; j < kend; j++) {
     
    103103                    while (nstack) {
    104104                         int iRow = stack[--nstack];
    105                          int k;
     105                         CoinBigIndex k;
    106106                         for (k = rowStart[iRow]; k < rowStart[iRow] + rowLength[iRow]; k++) {
    107107                              int iColumn = column[k];
    108                               int kkstart = columnStart[iColumn];
    109                               int kkend = kkstart + columnLength[iColumn];
     108                              CoinBigIndex kkstart = columnStart[iColumn];
     109                              CoinBigIndex kkend = kkstart + columnLength[iColumn];
    110110                              if (columnBlock[iColumn] == -2) {
    111111                                   columnBlock[iColumn] = numberBlocks - 1; // mark
    112112                                   // column not allocated
    113                                    int jj;
     113                                   CoinBigIndex jj;
    114114                                   for (jj = kkstart; jj < kkend; jj++) {
    115115                                        int jRow = row[jj];
     
    207207     // Overkill in terms of space
    208208     int numberMasterRows = master.numberRows();
    209      int * columnAdd = new int[numberBlocks+1];
     209     CoinBigIndex * columnAdd = new CoinBigIndex[numberBlocks+1];
    210210     int * rowAdd = new int[numberBlocks*(numberMasterRows+1)];
    211211     double * elementAdd = new double[numberBlocks*(numberMasterRows+1)];
     
    328328               if (sub[iBlock].numberIterations() || !iPass) {
    329329                    double objValue = 0.0;
    330                     int start = columnAdd[numberProposals];
     330                    CoinBigIndex start = columnAdd[numberProposals];
    331331                    // proposal
    332332                    if (sub[iBlock].isProvenOptimal()) {
     
    336336                              objValue += solution[i] * saveObj[i];
    337337                         // See if good dj and pack down
    338                          int number = start;
     338                         CoinBigIndex number = start;
    339339                         double dj = objValue;
    340340                         if (problemStatus)
     
    374374                              objValue += solution[i] * saveObj[i];
    375375                         // See if good dj and pack down
    376                          int number = start;
     376                         CoinBigIndex number = start;
    377377                         double dj = objValue;
    378378                         double smallest = 1.0e100;
  • trunk/Clp/examples/defaults.cpp

    r1662 r2278  
    316316     const double * element = matrix->getElements();
    317317     const int * row = matrix->getIndices();
    318      const int * start = matrix->getVectorStarts();
     318     const CoinBigIndex * start = matrix->getVectorStarts();
    319319     const int * length = matrix->getVectorLengths();
    320320
    321321     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    322322          std::cout << "Column " << iColumn;
    323           int j;
     323          CoinBigIndex j;
    324324          for (j = start[iColumn]; j < start[iColumn] + length[iColumn]; j++)
    325325               std::cout << " ( " << row[j] << ", " << element[j] << ")";
  • trunk/Clp/examples/dualCuts.cpp

    r1662 r2278  
    120120     int iPass;
    121121
    122      const int * start = model2->clpMatrix()->getVectorStarts();
     122     const CoinBigIndex * start = model2->clpMatrix()->getVectorStarts();
    123123     const int * length = model2->clpMatrix()->getVectorLengths();
    124124     const int * row = model2->clpMatrix()->getIndices();
     
    230230               for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    231231                    int n = 0;
    232                     for (int j = start[iColumn]; j < start[iColumn] + length[iColumn]; j++) {
     232                    for (CoinBigIndex j = start[iColumn]; j < start[iColumn] + length[iColumn]; j++) {
    233233                         int iRow = row[j];
    234234                         if (take[iRow])
  • trunk/Clp/examples/hello.cpp

    r1559 r2278  
    5252     for (iRow = 0; iRow < numberRows; iRow++) {
    5353          memset(x, ' ', numberColumns);
    54           for (int k = rowStart[iRow]; k < rowStart[iRow] + rowLength[iRow]; k++) {
     54          for (CoinBigIndex k = rowStart[iRow]; k < rowStart[iRow] + rowLength[iRow]; k++) {
    5555               int iColumn = column[k];
    5656               x[iColumn] = 'x';
  • trunk/Clp/examples/network.cpp

    r1662 r2278  
    129129
    130130     double * element = new double [2*numberColumns];
    131      int * start = new int[numberColumns+1];
     131     CoinBigIndex * start = new CoinBigIndex[numberColumns+1];
    132132     int * row = new int[2*numberColumns];
    133133     start[numberColumns] = 2 * numberColumns;
  • trunk/Clp/examples/piece.cpp

    r1935 r2278  
    3535     // Get data arrays
    3636     const CoinPackedMatrix * matrix1 = m.getMatrixByCol();
    37      const int * start1 = matrix1->getVectorStarts();
     37     const CoinBigIndex * start1 = matrix1->getVectorStarts();
    3838     const int * length1 = matrix1->getVectorLengths();
    3939     const int * row1 = matrix1->getIndices();
     
    4848     int numberColumns = m.getNumCols();
    4949     int numberRows = m.getNumRows();
    50      int numberElements = m.getNumElements();
     50     CoinBigIndex numberElements = m.getNumElements();
    5151
    5252     // Get new arrays
    5353     int numberColumns2 = (numberColumns + 1);
    54      int * start2 = new int[numberColumns2+1];
     54     CoinBigIndex * start2 = new CoinBigIndex[numberColumns2+1];
    5555     int * row2 = new int[numberElements];
    5656     double * element2 = new double[numberElements];
     
    9292          if (iColumn < numberColumns - 1) {
    9393               int  joff = length1[iColumn];
    94                for (int j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
     94               for (CoinBigIndex j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
    9595                    if (row1[j] != row1[j+joff]) {
    9696                         ifcopy = 0;
     
    137137               // do offset
    138138               objectiveOffset += fixed * obj2;
    139                for (int j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
     139               for (CoinBigIndex j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
    140140                    int iRow = row1[j];
    141141                    double value = element1[j];
     
    157157               breakpt[segptr] = lo2;
    158158               slope[segptr++] = obj2;
    159                for (int j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
     159               for (CoinBigIndex j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
    160160                    row2[numberElements] = row1[j];
    161161                    element2[numberElements++] = element1[j];
     
    173173               breakpt[segptr] = columnLower1[iColumn];
    174174               slope[segptr++] = objective1[iColumn];
    175                for (int j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
     175               for (CoinBigIndex j = start1[iColumn]; j < start1[iColumn] + length1[iColumn]; j++) {
    176176                    row2[numberElements] = row1[j];
    177177                    element2[numberElements++] = element1[j];
  • trunk/Clp/examples/rowColumn.cpp

    r1559 r2278  
    2929     double rowUpper[] = {COIN_DBL_MAX, 30.0, 8.0};
    3030     // Matrix by row
    31      int rowStart[] = {0, 5, 10, 13};
     31     CoinBigIndex rowStart[] = {0, 5, 10, 13};
    3232     int column[] = {0, 1, 2, 3, 4,
    3333                     0, 1, 2, 3, 4,
     
    3939                             };
    4040     // Matrix by column
    41      int columnStart[] = {0, 3, 6, 9, 11, 13};
     41     CoinBigIndex columnStart[] = {0, 3, 6, 9, 11, 13};
    4242     int row[] = {0, 1, 2,
    4343                  0, 1, 2,
     
    5252                                 -4.0, -5.0
    5353                                };
    54      int numberElements;
     54     CoinBigIndex numberElements;
    5555     // Do column version first as it can be done two ways
    5656     // a) As one step using matrix as stored
  • trunk/Clp/examples/sprint.cpp

    r1937 r2278  
    6666          model.times(1.0, columnSolution, rowSolution);
    6767
    68           int * addStarts = new int [numberRows+1];
     68          CoinBigIndex * addStarts = new CoinBigIndex [numberRows+1];
    6969          int * addRow = new int[numberRows];
    7070          double * addElement = new double[numberRows];
  • trunk/Clp/examples/testBasis.cpp

    r1662 r2278  
    3434     int numberRows = model.numberRows();
    3535
    36      int * addStarts = new int [numberRows+1];
     36     CoinBigIndex * addStarts = new CoinBigIndex [numberRows+1];
    3737     int * addRow = new int[numberRows];
    3838     double * addElement = new double[numberRows];
  • trunk/Clp/examples/testGub.cpp

    r1937 r2278  
    1313int main(int argc, const char *argv[])
    1414{
     15#if COIN_BIG_INDEX<2
    1516     ClpSimplex  model;
    1617     int status;
     
    450451     delete [] lower;
    451452     delete [] upper;
     453#else
     454     printf("testGub2 not available with COIN_BIG_INDEX=2\n");
     455#endif
    452456     return 0;
    453457}
  • trunk/Clp/examples/testGub2.cpp

    r1662 r2278  
    1313int main(int argc, const char *argv[])
    1414{
     15#if COIN_BIG_INDEX<2
    1516     ClpSimplex  model;
    1617     int status;
     
    392393     delete [] lower;
    393394     delete [] upper;
     395#else
     396     printf("testGub2 not available with COIN_BIG_INDEX=2\n");
     397#endif
    394398     return 0;
    395399}
  • trunk/Clp/examples/testQP.cpp

    r2001 r2278  
    3838                            m.getRowLower(), m.getRowUpper());
    3939          // get quadratic part
    40           int * start = NULL;
     40          CoinBigIndex * start = NULL;
    4141          int * column = NULL;
    4242          double * element = NULL;
     
    4545          for (j = 0; j < 79; j++) {
    4646               if (start[j] < start[j+1]) {
    47                     int i;
     47                    CoinBigIndex i;
    4848                    printf("Column %d ", j);
    4949                    for (i = start[j]; i < start[j+1]; i++) {
Note: See TracChangeset for help on using the changeset viewer.