Changeset 2271 for trunk


Ignore:
Timestamp:
Aug 14, 2017 4:50:39 AM (14 months ago)
Author:
forrest
Message:

change some ints to CoinBigIndex?

Location:
trunk/Clp/src
Files:
44 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/CbcOrClpParam.cpp

    r2259 r2271  
    39353935     parameters[numberParameters++] =
    39363936          CbcOrClpParam("vector!Mode", "Try and use vector instructions",
    3937                         0, 1, CLP_PARAM_INT_VECTOR_MODE);
     3937                        0, 11, CLP_PARAM_INT_VECTOR_MODE);
    39383938     parameters[numberParameters-1].setLonghelp
    39393939     (
    39403940          "At present only for Intel architectures - but could be extended.  \
    39413941Uses avx2 or avx512 instructions. Uses different storage for matrix - can be \
    3942 of benefit without instruction set on some problems."
     3942of benefit without instruction set on some problems.  \
     3943Being lazy I have used 10 to switch on a pool matrix (11 may come later)"
    39433944     );
    39443945     parameters[numberParameters-1].setIntValue(0);
  • trunk/Clp/src/ClpCholeskyBase.cpp

    r2030 r2271  
    305305          numberRowsDropped_ = 0;
    306306          // Space for starts
    307           choleskyStart_ = new CoinBigIndex[numberRows_+1];
     307          choleskyStart_ = new int[numberRows_+1];
    308308          const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
    309309          const int * columnLength = model_->clpMatrix()->getVectorLengths();
     
    501501          if (quadraticObj)
    502502               quadratic = quadraticObj->quadraticObjective();
    503           int numberElements = model_->clpMatrix()->getNumElements();
     503          CoinBigIndex numberElements = model_->clpMatrix()->getNumElements();
    504504          numberElements = numberElements + 2 * numberRowsModel + numberTotal;
    505505          if (quadratic)
    506506               numberElements += quadratic->getNumElements();
    507507          // Space for starts
    508           choleskyStart_ = new CoinBigIndex[numberRows_+1];
     508          choleskyStart_ = new int[numberRows_+1];
    509509          const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
    510510          const int * columnLength = model_->clpMatrix()->getVectorLengths();
     
    767767     } else {
    768768          // KKT
    769           int numberElements = model_->clpMatrix()->getNumElements();
     769          CoinBigIndex numberElements = model_->clpMatrix()->getNumElements();
    770770          numberElements = numberElements + 2 * numberRowsModel + numberTotal;
    771771          if (quadratic)
     
    773773          // off diagonal
    774774          numberElements -= numberRows_;
    775           sizeFactor_ = numberElements;
     775          sizeFactor_ = static_cast<int>(numberElements);
    776776          // If we sort we need to redo symbolic etc
    777777     }
     
    18291829     int space = 2 * sizeFactor_ + 10000 + 4 * numberRows_;
    18301830     int * temp = new int [space];
    1831      CoinBigIndex * count = new CoinBigIndex [numberRows_];
    1832      CoinBigIndex * tempStart = new CoinBigIndex [numberRows_+1];
     1831     int * count = new int [numberRows_];
     1832     int * tempStart = new int [numberRows_+1];
    18331833     memset(count, 0, numberRows_ * sizeof(int));
    18341834     for (int iRow = 0; iRow < numberRows_; iRow++) {
    1835           count[iRow] += choleskyStart_[iRow+1] - choleskyStart_[iRow] - 1;
     1835       count[iRow] += static_cast<int>(choleskyStart_[iRow+1] - choleskyStart_[iRow] - 1);
    18361836          for (CoinBigIndex j = choleskyStart_[iRow] + 1; j < choleskyStart_[iRow+1]; j++) {
    18371837               int jRow = choleskyRow_[j];
     
    18401840     }
    18411841#define OFFSET 1
    1842      CoinBigIndex sizeFactor = 0;
     1842     int sizeFactor = 0;
    18431843     for (int iRow = 0; iRow < numberRows_; iRow++) {
    18441844          int length = count[iRow];
     
    19621962     int iColumn;
    19631963     bool noMemory = false;
    1964      CoinBigIndex * Astart = new CoinBigIndex[numberRows_+1];
     1964     int * Astart = new int[numberRows_+1];
    19651965     int * Arow = NULL;
    19661966     try {
     
    19731973     choleskyStart_ = new int[numberRows_+1];
    19741974     link_ = new int[numberRows_];
    1975      workInteger_ = new CoinBigIndex[numberRows_];
    1976      indexStart_ = new CoinBigIndex[numberRows_];
     1975     workInteger_ = new int [numberRows_];
     1976     indexStart_ = new int[numberRows_];
    19771977     clique_ = new int[numberRows_];
    19781978     // Redo so permuted upper triangular
     
    24322432}
    24332433int
    2434 ClpCholeskyBase::symbolic1(const CoinBigIndex * Astart, const int * Arow)
     2434ClpCholeskyBase::symbolic1(const int * Astart, const int * Arow)
    24352435{
    24362436     int * marked = reinterpret_cast<int *> (workInteger_);
     
    24652465}
    24662466void
    2467 ClpCholeskyBase::symbolic2(const CoinBigIndex * Astart, const int * Arow)
     2467ClpCholeskyBase::symbolic2(const int * Astart, const int * Arow)
    24682468{
    24692469     int * mergeLink = clique_;
     
    26042604       COIN_DETAIL_PRINT(printf("Going dense for last %d rows\n", nDense));
    26052605          // make sure we don't disturb any indices
    2606           CoinBigIndex k = 0;
     2606          int k = 0;
    26072607          for (int jRow = 0; jRow < iRow; jRow++) {
    26082608               int nz = choleskyStart_[jRow+1] - choleskyStart_[jRow];
     
    32863286#define MINCLIQUE 3
    32873287     longDouble * work = workDouble_;
    3288      CoinBigIndex * first = workInteger_;
     3288     int * first = workInteger_;
    32893289
    32903290     for (iRow = 0; iRow < numberRows_; iRow++) {
     
    34053405               nextRow = link_[kRow];
    34063406               // Modify by outer product of L[*,irow] by L[*,krow] from first
    3407                CoinBigIndex k = first[kRow];
    3408                CoinBigIndex end = choleskyStart_[kRow+1];
     3407               int k = first[kRow];
     3408               int end = choleskyStart_[kRow+1];
    34093409               assert(k < end);
    34103410               CoinWorkDouble a_ik = sparseFactor_[k++];
     
    34133413               first[kRow] = k;
    34143414               diagonalValue -= value1 * a_ik;
    3415                CoinBigIndex offset = indexStart_[kRow] - choleskyStart_[kRow];
     3415               int offset = indexStart_[kRow] - choleskyStart_[kRow];
    34163416               if (k < end) {
    34173417                    int jRow = choleskyRow_[k+offset];
     
    34423442                         nextRow = link_[last-1];
    34433443                         link_[last-1] = linkSave;
    3444                          int length = end - k;
     3444                         int length = static_cast<int>(end - k);
    34453445                         for (int i = 0; i < length; i++) {
    34463446                              int lRow = choleskyRow_[currentIndex++];
     
    34593459               // in clique
    34603460               diagonal_[iRow] = diagonalValue;
    3461                CoinBigIndex start = choleskyStart_[iRow];
    3462                CoinBigIndex end = choleskyStart_[iRow+1];
    3463                CoinBigIndex currentIndex = indexStart_[iRow];
     3461               int start = choleskyStart_[iRow];
     3462               int end = choleskyStart_[iRow+1];
     3463               int currentIndex = indexStart_[iRow];
    34643464               nextRow2 = -1;
    3465                CoinBigIndex get = start + clique_[iRow] - 1;
     3465               int get = start + clique_[iRow] - 1;
    34663466               if (get < end) {
    34673467                    nextRow2 = choleskyRow_[currentIndex+get-start];
    34683468                    first[iRow] = get;
    34693469               }
    3470                for (CoinBigIndex j = start; j < end; j++) {
     3470               for (int j = start; j < end; j++) {
    34713471                    int kRow = choleskyRow_[currentIndex++];
    34723472                    sparseFactor_[j] -= work[kRow]; // times?
     
    35043504               }
    35053505               diagonal_[iRow] = diagonalValue;
    3506                CoinBigIndex offset = indexStart_[iRow] - choleskyStart_[iRow];
    3507                CoinBigIndex start = choleskyStart_[iRow];
    3508                CoinBigIndex end = choleskyStart_[iRow+1];
     3506               int offset = indexStart_[iRow] - choleskyStart_[iRow];
     3507               int start = choleskyStart_[iRow];
     3508               int end = choleskyStart_[iRow+1];
    35093509               assert (first[iRow] == start);
    35103510               if (start < end) {
     
    35123512                    link_[iRow] = link_[nextRow];
    35133513                    link_[nextRow] = iRow;
    3514                     for (CoinBigIndex j = start; j < end; j++) {
     3514                    for (int j = start; j < end; j++) {
    35153515                         int jRow = choleskyRow_[j+offset];
    35163516                         CoinWorkDouble value = sparseFactor_[j] - work[jRow];
     
    35653565{
    35663566     for (int iRow = 0; iRow < firstDense_; iRow++) {
    3567           CoinBigIndex start = first[iRow];
    3568           CoinBigIndex end = choleskyStart_[iRow+1];
     3567          int start = first[iRow];
     3568          int end = choleskyStart_[iRow+1];
    35693569          if (start < end) {
    3570                CoinBigIndex offset = indexStart_[iRow] - choleskyStart_[iRow];
     3570               int offset = indexStart_[iRow] - choleskyStart_[iRow];
    35713571               if (clique_[iRow] < 2) {
    35723572                    CoinWorkDouble dValue = d[iRow];
    3573                     for (CoinBigIndex k = start; k < end; k++) {
     3573                    for (int k = start; k < end; k++) {
    35743574                         int kRow = choleskyRow_[k+offset];
    35753575                         assert(kRow >= firstDense_);
     
    35773577                         CoinWorkDouble value1 = dValue * a_ik;
    35783578                         diagonal_[kRow] -= value1 * a_ik;
    3579                          CoinBigIndex base = choleskyStart_[kRow] - kRow - 1;
    3580                          for (CoinBigIndex j = k + 1; j < end; j++) {
     3579                         int base = choleskyStart_[kRow] - kRow - 1;
     3580                         for (int j = k + 1; j < end; j++) {
    35813581                              int jRow = choleskyRow_[j+offset];
    35823582                              CoinWorkDouble a_jk = sparseFactor_[j];
     
    35913591                    // skip row
    35923592                    iRow++;
    3593                     for (CoinBigIndex k = start; k < end; k++) {
     3593                    for (int k = start; k < end; k++) {
    35943594                         int kRow = choleskyRow_[k+offset];
    35953595                         assert(kRow >= firstDense_);
     
    35993599                         CoinWorkDouble value1 = dValue1 * a_ik1;
    36003600                         diagonal_[kRow] -= value0 * a_ik0 + value1 * a_ik1;
    3601                          CoinBigIndex base = choleskyStart_[kRow] - kRow - 1;
    3602                          for (CoinBigIndex j = k + 1; j < end; j++) {
     3601                         int base = choleskyStart_[kRow] - kRow - 1;
     3602                         for (int j = k + 1; j < end; j++) {
    36033603                              int jRow = choleskyRow_[j+offset];
    36043604                              CoinWorkDouble a_jk0 = sparseFactor_[j];
     
    36223622                    int offset1 = first[++iRow] - start;
    36233623                    int offset2 = first[++iRow] - start;
    3624                     for (CoinBigIndex k = start; k < end; k++) {
     3624                    for (int k = start; k < end; k++) {
    36253625                         int kRow = choleskyRow_[k+offset];
    36263626                         assert(kRow >= firstDense_);
     
    36323632                         CoinWorkDouble a_ik2 = sparseFactor_[k+offset2];
    36333633                         CoinWorkDouble value2 = dValue2 * a_ik2;
    3634                          CoinBigIndex base = choleskyStart_[kRow] - kRow - 1;
     3634                         int base = choleskyStart_[kRow] - kRow - 1;
    36353635                         diagonal_[kRow] = diagonalValue - value0 * a_ik0 - value1 * a_ik1 - value2 * a_ik2;
    3636                          for (CoinBigIndex j = k + 1; j < end; j++) {
     3636                         for (int j = k + 1; j < end; j++) {
    36373637                              int jRow = choleskyRow_[j+offset];
    36383638                              CoinWorkDouble a_jk0 = sparseFactor_[j];
     
    36563656                    int offset2 = first[++iRow] - start;
    36573657                    int offset3 = first[++iRow] - start;
    3658                     for (CoinBigIndex k = start; k < end; k++) {
     3658                    for (int k = start; k < end; k++) {
    36593659                         int kRow = choleskyRow_[k+offset];
    36603660                         assert(kRow >= firstDense_);
     
    36683668                         CoinWorkDouble a_ik3 = sparseFactor_[k+offset3];
    36693669                         CoinWorkDouble value3 = dValue3 * a_ik3;
    3670                          CoinBigIndex base = choleskyStart_[kRow] - kRow - 1;
     3670                         int base = choleskyStart_[kRow] - kRow - 1;
    36713671                         diagonal_[kRow] = diagonalValue - (value0 * a_ik0 + value1 * a_ik1 + value2 * a_ik2 + value3 * a_ik3);
    3672                          for (CoinBigIndex j = k + 1; j < end; j++) {
     3672                         for (int j = k + 1; j < end; j++) {
    36733673                              int jRow = choleskyRow_[j+offset];
    36743674                              CoinWorkDouble a_jk0 = sparseFactor_[j];
     
    37313731     CoinWorkDouble * work = reinterpret_cast<CoinWorkDouble *> (workDouble_);
    37323732     int i;
    3733      CoinBigIndex j;
     3733     int j;
    37343734     for (i = 0; i < numberRows_; i++) {
    37353735          int iRow = permute_[i];
     
    37403740          for (i = 0; i < numberRows_; i++) {
    37413741               CoinWorkDouble value = work[i];
    3742                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3742               int offset = indexStart_[i] - choleskyStart_[i];
    37433743               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
    37443744                    int iRow = choleskyRow_[j+offset];
     
    37533753     case 2:
    37543754          for (i = numberRows_ - 1; i >= 0; i--) {
    3755                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3755               int offset = indexStart_[i] - choleskyStart_[i];
    37563756               CoinWorkDouble value = work[i] * diagonal_[i];
    37573757               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    37663766     case 3:
    37673767          for (i = 0; i < firstDense_; i++) {
    3768                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3768               int offset = indexStart_[i] - choleskyStart_[i];
    37693769               CoinWorkDouble value = work[i];
    37703770               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    37873787          }
    37883788          for (i = firstDense_ - 1; i >= 0; i--) {
    3789                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3789               int offset = indexStart_[i] - choleskyStart_[i];
    37903790               CoinWorkDouble value = work[i] * diagonal_[i];
    37913791               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    38033803          longDouble * work = workDouble_;
    38043804          int i;
    3805           CoinBigIndex j;
     3805          int j;
    38063806          double largestO = 0.0;
    38073807          for (i = 0; i < numberRows_; i++) {
     
    38133813          }
    38143814          for (i = 0; i < firstDense_; i++) {
    3815                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3815               int offset = indexStart_[i] - choleskyStart_[i];
    38163816               CoinWorkDouble value = work[i];
    38173817               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    38343834          }
    38353835          for (i = firstDense_ - 1; i >= 0; i--) {
    3836                CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3836               int offset = indexStart_[i] - choleskyStart_[i];
    38373837               CoinWorkDouble value = work[i] * diagonal_[i];
    38383838               for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    38643864     CoinWorkDouble * work = reinterpret_cast<CoinWorkDouble *> (workDouble_);
    38653865     int i;
    3866      CoinBigIndex j;
     3866     int j;
    38673867     for (i = 0; i < numberRows_; i++) {
    38683868          int iRow = permute_[i];
     
    38703870     }
    38713871     for (i = 0; i < firstDense_; i++) {
    3872           CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3872          int offset = indexStart_[i] - choleskyStart_[i];
    38733873          CoinWorkDouble value = work[i];
    38743874          for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
     
    38913891     }
    38923892     for (i = firstDense_ - 1; i >= 0; i--) {
    3893           CoinBigIndex offset = indexStart_[i] - choleskyStart_[i];
     3893          int offset = indexStart_[i] - choleskyStart_[i];
    38943894          CoinWorkDouble value = work[i] * diagonal_[i];
    38953895          for (j = choleskyStart_[i]; j < choleskyStart_[i+1]; j++) {
  • trunk/Clp/src/ClpCholeskyBase.hpp

    r1722 r2271  
    120120     }
    121121     /// Return size
    122      inline CoinBigIndex size() const {
     122     inline int size() const {
    123123          return sizeFactor_;
    124124     }
     
    204204         Returns size
    205205      */
    206      int symbolic1(const CoinBigIndex * Astart, const int * Arow);
     206     int symbolic1(const int * Astart, const int * Arow);
    207207     /** Symbolic2  - Fills in indices
    208208         Uses lower triangular so can do cliques etc
    209209      */
    210      void symbolic2(const CoinBigIndex * Astart, const int * Arow);
     210     void symbolic2(const int * Astart, const int * Arow);
    211211     /** Factorize - filling in rowsDropped and returning number dropped
    212212         in integerParam.
     
    254254     longDouble * sparseFactor_;
    255255     /// choleskyStart - element starts
    256      CoinBigIndex * choleskyStart_;
     256     int * choleskyStart_;
    257257     /// choleskyRow (can be shorter than sparsefactor)
    258258     int * choleskyRow_;
    259259     /// Index starts
    260      CoinBigIndex * indexStart_;
     260     int * indexStart_;
    261261     /// Diagonal
    262262     longDouble * diagonal_;
     
    266266     int * link_;
    267267     // Integer work array
    268      CoinBigIndex * workInteger_;
     268     int * workInteger_;
    269269     // Clique information
    270270     int * clique_;
    271271     /// sizeFactor.
    272      CoinBigIndex sizeFactor_;
     272     int sizeFactor_;
    273273     /// Size of index array
    274      CoinBigIndex sizeIndex_;
     274     int sizeIndex_;
    275275     /// First dense row
    276276     int firstDense_;
  • trunk/Clp/src/ClpCholeskyDense.cpp

    r1910 r2271  
    125125}
    126126/* Returns space needed */
    127 CoinBigIndex
     127int
    128128ClpCholeskyDense::space( int numberRows) const
    129129{
     
    131131     /* allow one stripe extra*/
    132132     numberBlocks = numberBlocks + ((numberBlocks * (numberBlocks + 1)) / 2);
    133      CoinBigIndex sizeFactor = numberBlocks * BLOCKSQ;
     133     int sizeFactor = numberBlocks * BLOCKSQ;
    134134#ifdef CHOL_COMPARE
    135135     sizeFactor += 95000;
  • trunk/Clp/src/ClpCholeskyDense.hpp

    r1910 r2271  
    3939     int reserveSpace(const ClpCholeskyBase * factor, int numberRows) ;
    4040     /** Returns space needed */
    41      CoinBigIndex space( int numberRows) const;
     41     int space( int numberRows) const;
    4242     /** part 2 of Factorize - filling in rowsDropped */
    4343     void factorizePart2(int * rowsDropped) ;
  • trunk/Clp/src/ClpConstraintQuadratic.cpp

    r1665 r2271  
    4242     numberQuadraticColumns_ = numberQuadraticColumns;
    4343     start_ = CoinCopyOfArray(start, numberQuadraticColumns + 1);
    44      int numberElements = start_[numberQuadraticColumns_];
     44     CoinBigIndex numberElements = start_[numberQuadraticColumns_];
    4545     column_ = CoinCopyOfArray(column, numberElements);
    4646     coefficient_ = CoinCopyOfArray(coefficient, numberElements);
     
    7777     numberQuadraticColumns_ = rhs.numberQuadraticColumns_;
    7878     start_ = CoinCopyOfArray(rhs.start_, numberQuadraticColumns_ + 1);
    79      int numberElements = start_[numberQuadraticColumns_];
     79     CoinBigIndex numberElements = start_[numberQuadraticColumns_];
    8080     column_ = CoinCopyOfArray(rhs.column_, numberElements);
    8181     coefficient_ = CoinCopyOfArray(rhs.coefficient_, numberElements);
     
    107107          numberQuadraticColumns_ = rhs.numberQuadraticColumns_;
    108108          start_ = CoinCopyOfArray(rhs.start_, numberQuadraticColumns_ + 1);
    109           int numberElements = start_[numberQuadraticColumns_];
     109          CoinBigIndex numberElements = start_[numberQuadraticColumns_];
    110110          column_ = CoinCopyOfArray(rhs.column_, numberElements);
    111111          coefficient_ = CoinCopyOfArray(rhs.coefficient_, numberElements);
  • trunk/Clp/src/ClpDummyMatrix.cpp

    r1665 r2271  
    150150}
    151151/// returns number of elements in column part of basis,
    152 CoinBigIndex
     152int
    153153ClpDummyMatrix::countBasis(const int * ,
    154154                           int & )
  • trunk/Clp/src/ClpDummyMatrix.hpp

    r1665 r2271  
    6565     virtual ClpMatrixBase * reverseOrderedCopy() const;
    6666     /// Returns number of elements in column part of basis
    67      virtual CoinBigIndex countBasis(const int * whichColumn,
     67     virtual int countBasis(const int * whichColumn,
    6868                                     int & numberColumnBasic);
    6969     /// Fills in column part of basis
  • trunk/Clp/src/ClpDynamicExampleMatrix.cpp

    r1936 r2271  
    6363/* This is the real constructor*/
    6464ClpDynamicExampleMatrix::ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
    65           int numberGubColumns, const int * starts,
     65          int numberGubColumns, const CoinBigIndex * starts,
    6666          const double * lower, const double * upper,
    6767          const CoinBigIndex * startColumn, const int * row,
     
    167167          assert (!numberIds);
    168168          memset(status_, 0, numberSets_);
    169           for (i = 0; i < numberSets_; i++) {
     169          for (int i = 0; i < numberSets_; i++) {
    170170               // make slack key
    171171               setStatus(i, ClpSimplex::basic);
     
    174174     dynamicStatusGen_ = new unsigned char [numberColumns_];
    175175     memset(dynamicStatusGen_, 0, numberColumns_); // for clarity
    176      for (i = 0; i < numberColumns_; i++)
     176     for (int i = 0; i < numberColumns_; i++)
    177177          setDynamicStatusGen(i, atLowerBound);
    178178     // Populate with enough columns
     
    180180          // This could be made more sophisticated
    181181          for (iSet = 0; iSet < numberSets_; iSet++) {
    182                int sequence = fullStartGen_[iSet];
     182               CoinBigIndex sequence = fullStartGen_[iSet];
    183183               CoinBigIndex start = startColumnGen_[sequence];
    184184               addColumn(startColumnGen_[sequence+1] - start,
     
    411411          startColumnGen_ = ClpCopyOfArray(rhs.startColumnGen_, numberColumns_ + 1);
    412412          CoinBigIndex numberElements = startColumnGen_[numberColumns_];
    413           rowGen_ = ClpCopyOfArray(rhs.rowGen_, numberElements);;
    414           elementGen_ = ClpCopyOfArray(rhs.elementGen_, numberElements);;
     413          rowGen_ = ClpCopyOfArray(rhs.rowGen_, numberElements);
     414          elementGen_ = ClpCopyOfArray(rhs.elementGen_, numberElements);
    415415          costGen_ = ClpCopyOfArray(rhs.costGen_, numberColumns_);
    416416          fullStartGen_ = ClpCopyOfArray(rhs.fullStartGen_, numberSets_ + 1);
     
    539539               }
    540540               // do ones in small
    541                int iSequence = startSet_[iSet];
     541               CoinBigIndex iSequence = startSet_[iSet];
    542542               while (iSequence >= 0) {
    543543                    DynamicStatus status = getDynamicStatus(iSequence);
  • trunk/Clp/src/ClpDynamicExampleMatrix.hpp

    r1936 r2271  
    6464      */
    6565     ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
    66                              int numberColumns, const int * starts,
     66                             int numberColumns, const CoinBigIndex * starts,
    6767                             const double * lower, const double * upper,
    68                              const int * startColumn, const int * row,
     68                             const CoinBigIndex * startColumn, const int * row,
    6969                             const double * element, const double * cost,
    7070                             const double * columnLower = NULL, const double * columnUpper = NULL,
     
    115115     }
    116116     /// full starts
    117      inline int * fullStartGen() const {
     117     inline CoinBigIndex * fullStartGen() const {
    118118          return fullStartGen_;
    119119     }
     
    170170     double * costGen_;
    171171     /// start of each set
    172      int * fullStartGen_;
     172     CoinBigIndex * fullStartGen_;
    173173     /// for status and which bound
    174174     unsigned char * dynamicStatusGen_;
  • trunk/Clp/src/ClpDynamicMatrix.cpp

    r1936 r2271  
    24752475// Adds in a column to gub structure (called from descendant)
    24762476int
    2477 ClpDynamicMatrix::addColumn(int numberEntries, const int * row, const double * element,
     2477ClpDynamicMatrix::addColumn(CoinBigIndex numberEntries, const int * row, const double * element,
    24782478                            double cost, double lower, double upper, int iSet,
    24792479                            DynamicStatus status)
  • trunk/Clp/src/ClpDynamicMatrix.hpp

    r1755 r2271  
    100100     void initialProblem();
    101101     /** Adds in a column to gub structure (called from descendant) and returns sequence */
    102      int addColumn(int numberEntries, const int * row, const double * element,
     102     int addColumn(CoinBigIndex numberEntries, const int * row, const double * element,
    103103                   double cost, double lower, double upper, int iSet,
    104104                   DynamicStatus status);
     
    267267     }
    268268     /// size of working matrix (max)
    269      inline int numberElements() const {
     269     inline CoinBigIndex numberElements() const {
    270270          return numberElements_;
    271271     }
     
    337337     int numberStaticRows_;
    338338     /// size of working matrix (max)
    339      int numberElements_;
     339     CoinBigIndex numberElements_;
    340340     /// Number of dual infeasibilities
    341341     int numberDualInfeasibilities_;
     
    355355     int maximumGubColumns_;
    356356     /// current maximum number of elemnts (then compress)
    357      int maximumElements_;
     357     CoinBigIndex maximumElements_;
    358358     /// Start of each set
    359359     int * startSet_;
  • trunk/Clp/src/ClpFactorization.cpp

    r2235 r2271  
    11521152}
    11531153#else
     1154#if COIN_BIG_INDEX==0
    11541155// This one allows multiple factorizations
    11551156#if CLP_MULTIPLE_FACTORIZATIONS == 1
     
    11671168//#define CoinOslFactorization CoinDenseFactorization
    11681169#include "CoinOslFactorization.hpp"
     1170#endif
    11691171#endif
    11701172
     
    12461248          if (goDense == 1)
    12471249               coinFactorizationB_ = new CoinDenseFactorization();
     1250#if COIN_BIG_INDEX==0
    12481251          else if (goDense == 2)
    12491252               coinFactorizationB_ = new CoinSimpFactorization();
    12501253          else
    12511254               coinFactorizationB_ = new CoinOslFactorization();
     1255#endif
    12521256          if (rhs.coinFactorizationA_) {
    12531257               coinFactorizationB_->maximumPivots(rhs.coinFactorizationA_->maximumPivots());
     
    13601364               coinFactorizationA_ = NULL;
    13611365          }
    1362 
     1366#if COIN_BIG_INDEX==0
    13631367          if (rhs.coinFactorizationB_) {
    13641368               if (coinFactorizationB_) {
     
    13861390               coinFactorizationB_ = NULL;
    13871391          }
     1392#endif
    13881393     }
    13891394#ifdef CLP_FACTORIZATION_INSTRUMENT
     
    14041409               coinFactorizationB_ = new CoinDenseFactorization();
    14051410               //printf("going dense\n");
     1411#if COIN_BIG_INDEX==0
    14061412          } else if (numberRows <= goSmallThreshold_) {
    14071413               delete coinFactorizationA_;
     
    14161422               coinFactorizationB_ = new CoinOslFactorization();
    14171423               //printf("going small\n");
     1424#endif
    14181425          }
    14191426     }
     
    14361443               goDenseThreshold_ = COIN_INT_MAX;
    14371444               break;
     1445#if COIN_BIG_INDEX==0
    14381446          case 2:
    14391447               coinFactorizationB_ = new CoinSimpFactorization();
     
    14441452               goOslThreshold_ = COIN_INT_MAX;
    14451453               break;
     1454#endif
    14461455          }
    14471456     } else if (!coinFactorizationA_) {
     
    18031812                    }
    18041813               }
    1805                CoinBigIndex numberElements = numberRowBasic;
     1814               int numberElements = numberRowBasic;
    18061815
    18071816               // compute how much in basis
     
    18281837               CoinFactorizationDouble * elementU;
    18291838               int * indexRowU;
    1830                CoinBigIndex * startColumnU;
     1839               int * startColumnU;
    18311840               int * numberInRow;
    18321841               int * numberInColumn;
     
    22192228                    coinFactorizationA_->gutsOfDestructor();
    22202229                    coinFactorizationA_->gutsOfInitialize(2);
    2221                     CoinBigIndex numberElements = numberRowBasic;
     2230                    int numberElements = numberRowBasic;
    22222231
    22232232                    // compute how much in basis
     
    22442253                    CoinFactorizationDouble * elementU = coinFactorizationA_->elementU();
    22452254                    int * indexRowU = coinFactorizationA_->indexRowU();
    2246                     CoinBigIndex * startColumnU = coinFactorizationA_->startColumnU();
     2255                    int * startColumnU = coinFactorizationA_->startColumnU();
    22472256#ifndef COIN_FAST_CODE
    22482257                    double slackValue = coinFactorizationA_->slackValue();
     
    26212630          int nNew=0;
    26222631          int seq;
     2632#if COIN_BIG_INDEX==0 && CLP_POOL_MATRIX==0       
    26232633          const CoinPackedMatrix * matrix=model->matrix();
    26242634          const int * columnLength = matrix->getVectorLengths();
     2635#else
     2636          const int * columnLength = model->clpMatrix()->getVectorLengths();
     2637#endif
    26252638          seq=model->sequenceIn();
    26262639          if (seq>=0&&seq<model->numberColumns()+model->numberRows()) {
    2627             if (seq<model->numberColumns())
     2640            if (seq<model->numberColumns()) {
    26282641              nNew=columnLength[seq];
    2629             else
     2642            } else {
    26302643              nNew=1;
     2644            }
    26312645          }
    26322646          seq=model->sequenceOut();
    26332647          if (seq>=0&&seq<model->numberColumns()+model->numberRows()) {
    2634             if (seq<model->numberColumns())
     2648            if (seq<model->numberColumns()) {
    26352649              nOld=columnLength[seq];
    2636             else
     2650            } else {
    26372651              nOld=1;
     2652            }
    26382653          }
    26392654          effectiveStartNumberU_ += nNew-nOld;
     
    31963211     int * permuteBack = coinFactorizationA_->pivotColumnBack();
    31973212     int * indexRowU = coinFactorizationA_->indexRowU();
    3198      const CoinBigIndex * startColumnU = coinFactorizationA_->startColumnU();
    3199      const CoinBigIndex * startRowL = coinFactorizationA_->startRowL();
     3213     const int * startColumnU = coinFactorizationA_->startColumnU();
     3214     const int * startRowL = coinFactorizationA_->startRowL();
    32003215     int numberRows = coinFactorizationA_->numberRows();
    32013216     if (!startRowL || !coinFactorizationA_->numberInRow()) {
     
    32063221               // one for pivot
    32073222               temp[i]++;
    3208                CoinBigIndex j;
     3223               int j;
    32093224               for (j = startColumnU[i]; j < startColumnU[i] + numberInColumn[i]; j++) {
    32103225                    int iRow = indexRowU[j];
     
    32123227               }
    32133228          }
    3214           CoinBigIndex * startColumnL = coinFactorizationA_->startColumnL();
     3229          int * startColumnL = coinFactorizationA_->startColumnL();
    32153230          int * indexRowL = coinFactorizationA_->indexRowL();
    32163231          int numberL = coinFactorizationA_->numberL();
    3217           CoinBigIndex baseL = coinFactorizationA_->baseL();
     3232          int baseL = coinFactorizationA_->baseL();
    32183233          for (i = baseL; i < baseL + numberL; i++) {
    3219                CoinBigIndex j;
     3234               int j;
    32203235               for (j = startColumnL[i]; j < startColumnL[i+1]; j++) {
    32213236                    int iRow = indexRowL[j];
  • trunk/Clp/src/ClpGubDynamicMatrix.hpp

    r1665 r2271  
    8686                         int numberColumns, const int * starts,
    8787                         const double * lower, const double * upper,
    88                          const int * startColumn, const int * row,
     88                         const CoinBigIndex * startColumn, const int * row,
    8989                         const double * element, const double * cost,
    9090                         const double * lowerColumn = NULL, const double * upperColumn = NULL,
     
    241241     int lastDynamic_;
    242242     /// size of working matrix (max)
    243      int numberElements_;
     243     CoinBigIndex numberElements_;
    244244     //@}
    245245};
  • trunk/Clp/src/ClpGubMatrix.cpp

    r1929 r2271  
    893893}
    894894/// returns number of elements in column part of basis,
    895 CoinBigIndex
     895int
    896896ClpGubMatrix::countBasis(const int * whichColumn,
    897897                         int & numberColumnBasic)
     
    966966     // update number of column basic
    967967     numberColumnBasic = numberBasic;
    968      return numberElements;
     968#if COIN_BIG_INDEX
     969     if (numberElements>COIN_INT_MAX) {
     970       printf("Factorization too large\n");
     971       abort();
     972     }
     973#endif
     974     return static_cast<int>(numberElements);
    969975}
    970976void
  • trunk/Clp/src/ClpGubMatrix.hpp

    r1665 r2271  
    2828     virtual ClpMatrixBase * reverseOrderedCopy() const;
    2929     /// Returns number of elements in column part of basis
    30      virtual CoinBigIndex countBasis(const int * whichColumn,
     30     virtual int countBasis(const int * whichColumn,
    3131                                     int & numberColumnBasic);
    3232     /// Fills in column part of basis
  • trunk/Clp/src/ClpMatrixBase.hpp

    r2235 r2271  
    9999
    100100     /// Returns number of elements in column part of basis
    101      virtual CoinBigIndex countBasis(const int * whichColumn,
     101     virtual int countBasis(const int * whichColumn,
    102102                                     int & numberColumnBasic) = 0;
    103103     /// Fills in column part of basis
  • trunk/Clp/src/ClpModel.cpp

    r2132 r2271  
    380380     gutsOfLoadModel(numrows, numcols,
    381381                     collb, colub, obj, rowlb, rowub, rowObjective);
    382      int numberElements = start ? start[numcols] : 0;
     382     CoinBigIndex numberElements = start ? start[numcols] : 0;
    383383     CoinPackedMatrix matrix(true, numrows, numrows ? numcols : 0, numberElements,
    384384                             value, index, start, NULL);
     
    407407     matrix_ = new ClpPackedMatrix(matrix);
    408408}
     409#if COIN_BIG_INDEX==0
    409410#ifndef SLIM_NOIO
    410411// This loads a model from a coinModel object - returns number of errors
     
    504505     return numberErrors;
    505506}
     507#endif
    506508#endif
    507509void
     
    12431245   returns number of elements eliminated or -1 if not ClpMatrix
    12441246*/
    1245 int
     1247CoinBigIndex
    12461248ClpModel::cleanMatrix(double threshold)
    12471249{
     
    17341736        if (backColumns[iColumn]>=0) {
    17351737          CoinBigIndex start = columnStart[iColumn];
    1736           int nSave=n;
     1738          CoinBigIndex nSave=n;
    17371739          columnStart[newNumberColumns]=n;
    17381740          for (CoinBigIndex j=start;j<start+columnLength[iColumn];j++) {
     
    17441746            }
    17451747          }
    1746           columnLength[newNumberColumns++]=n-nSave;
     1748          columnLength[newNumberColumns++]=static_cast<int>(n-nSave);
    17471749        }
    17481750      }
     
    18631865          for (iRow = 0; iRow < number; iRow++)
    18641866               numberElements += rowLengths[iRow];
    1865           int * newStarts = new int[number+1];
     1867          CoinBigIndex * newStarts = new CoinBigIndex[number+1];
    18661868          int * newIndex = new int[numberElements];
    18671869          double * newElements = new double[numberElements];
     
    18691871          newStarts[0] = 0;
    18701872          for (iRow = 0; iRow < number; iRow++) {
    1871                int iStart = rowStarts[iRow];
     1873               CoinBigIndex iStart = rowStarts[iRow];
    18721874               int length = rowLengths[iRow];
    18731875               CoinMemcpyN(columns + iStart, length, newIndex + numberElements);
     
    21172119}
    21182120#endif
     2121#if COIN_BIG_INDEX==0
    21192122#ifndef SLIM_NOIO
    21202123// Add rows from a model object
     
    22482251}
    22492252#endif
     2253#endif
    22502254// Add one column
    22512255void
     
    22672271                     const double * columnUpper,
    22682272                     const double * objIn,
    2269                      const int * columnStarts, const int * rows,
     2273                     const CoinBigIndex * columnStarts, const int * rows,
    22702274                     const double * elements)
    22712275{
     
    23362340                     const double * columnUpper,
    23372341                     const double * objIn,
    2338                      const int * columnStarts,
     2342                     const CoinBigIndex * columnStarts,
    23392343                     const int * columnLengths, const int * rows,
    23402344                     const double * elements)
     
    23452349          for (iColumn = 0; iColumn < number; iColumn++)
    23462350               numberElements += columnLengths[iColumn];
    2347           int * newStarts = new int[number+1];
     2351          CoinBigIndex * newStarts = new CoinBigIndex[number+1];
    23482352          int * newIndex = new int[numberElements];
    23492353          double * newElements = new double[numberElements];
     
    23512355          newStarts[0] = 0;
    23522356          for (iColumn = 0; iColumn < number; iColumn++) {
    2353                int iStart = columnStarts[iColumn];
     2357               CoinBigIndex iStart = columnStarts[iColumn];
    23542358               int length = columnLengths[iColumn];
    23552359               CoinMemcpyN(rows + iStart, length, newIndex + numberElements);
     
    25682572#endif
    25692573#ifndef SLIM_NOIO
     2574#if COIN_BIG_INDEX==0
    25702575// Add columns from a model object
    25712576int
     
    26912696}
    26922697#endif
     2698#endif
    26932699// chgRowLower
    26942700void
     
    29542960          // get quadratic part
    29552961          if (m.reader()->whichSection (  ) == COIN_QUAD_SECTION ) {
    2956                int * start = NULL;
     2962               CoinBigIndex * start = NULL;
    29572963               int * column = NULL;
    29582964               double * element = NULL;
     
    40864092/* This creates a coinModel object
    40874093 */
     4094#if COIN_BIG_INDEX==0
    40884095CoinModel *
    40894096ClpModel::createCoinModel() const
     
    41854192     return coinModel;
    41864193}
     4194#endif
    41874195// Start or reset using maximumRows_ and Columns_
    41884196void
  • trunk/Clp/src/ClpModel.hpp

    r2074 r2271  
    260260         returns number of elements eliminated or -1 if not ClpPackedMatrix
    261261     */
    262      int cleanMatrix(double threshold = 1.0e-20);
     262     CoinBigIndex cleanMatrix(double threshold = 1.0e-20);
    263263     /// Copy contents - resizing if necessary - otherwise re-use memory
    264264     void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
     
    700700     }
    701701     /// Number of elements in matrix
    702      inline int getNumElements() const {
     702     inline CoinBigIndex getNumElements() const {
    703703          return matrix_->getNumElements();
    704704     }
  • trunk/Clp/src/ClpNetworkBasis.cpp

    r1732 r2271  
    4444                                 int numberRows, const CoinFactorizationDouble * pivotRegion,
    4545                                 const int * permuteBack,
    46                                  const CoinBigIndex * startColumn,
     46                                 const int * startColumn,
    4747                                 const int * numberInColumn,
    4848                                 const int * indexRow, const CoinFactorizationDouble * /*element*/)
  • trunk/Clp/src/ClpNetworkBasis.hpp

    r1722 r2271  
    3535     ClpNetworkBasis(const ClpSimplex * model,
    3636                     int numberRows, const CoinFactorizationDouble * pivotRegion,
    37                      const int * permuteBack, const CoinBigIndex * startColumn,
     37                     const int * permuteBack, const int * startColumn,
    3838                     const int * numberInColumn,
    3939                     const int * indexRow, const CoinFactorizationDouble * element);
  • trunk/Clp/src/ClpNetworkMatrix.cpp

    r1665 r2271  
    524524}
    525525/// returns number of elements in column part of basis,
    526 CoinBigIndex
     526int
    527527ClpNetworkMatrix::countBasis( const int * whichColumn,
    528528                              int & numberColumnBasic)
     
    544544          }
    545545     }
    546      return numberElements;
     546#if COIN_BIG_INDEX
     547     if (numberElements>COIN_INT_MAX) {
     548       printf("Factorization too large\n");
     549       abort();
     550     }
     551#endif
     552     return static_cast<int>(numberElements);
    547553}
    548554void
     
    569575               elementU[numberElements+1] = 1.0;
    570576               numberElements += 2;
    571                start[i+1] = numberElements;
     577               start[i+1] = static_cast<int>(numberElements);
    572578               columnCount[i] = 2;
    573579          }
     
    588594                    elementU[numberElements++] = 1.0;
    589595               }
    590                start[i+1] = numberElements;
    591                columnCount[i] = numberElements - start[i];
    592           }
    593      }
     596               start[i+1] = static_cast<int>(numberElements);
     597               columnCount[i] = static_cast<int>(numberElements) - start[i];
     598          }
     599     }
     600#if COIN_BIG_INDEX
     601     if (numberElements>COIN_INT_MAX)
     602       abort();
     603#endif
    594604}
    595605/* Unpacks a column into an CoinIndexedvector
     
    11881198     int iVector;
    11891199     for (iVector = 0; iVector < number; iVector++) {
    1190           int iStart = starts[iVector];
     1200          CoinBigIndex iStart = starts[iVector];
    11911201          vectors[iVector] =
    1192                new CoinPackedVector(starts[iVector+1] - iStart,
     1202            new CoinPackedVector(static_cast<int>(starts[iVector+1] - iStart),
    11931203                                    index + iStart, element + iStart);
    11941204     }
  • trunk/Clp/src/ClpNetworkMatrix.hpp

    r1665 r2271  
    7979     virtual ClpMatrixBase * reverseOrderedCopy() const;
    8080     /// Returns number of elements in column part of basis
    81      virtual CoinBigIndex countBasis(
     81     virtual int countBasis(
    8282          const int * whichColumn,
    8383          int & numberColumnBasic);
  • trunk/Clp/src/ClpPESimplex.cpp

    r2150 r2271  
    113113coPrimalDegeneratesAvg_(0), coDualDegeneratesAvg_(0), coCompatibleColsAvg_(0), coCompatibleRowsAvg_(0),
    114114coUpdateDegenerates_(0), coIdentifyCompatibles_(0),
    115 coDegeneratePivots_(0), coCompatiblePivots_(0),  coDegeneratePivotsConsecutive_(0), coDegenerateCompatiblePivots_(0),
     115coDegeneratePivots_(0), coCompatiblePivots_(0),
     116coDegenerateCompatiblePivots_(0),coDegeneratePivotsConsecutive_(0),
    116117coPriorityPivots_(0),doStatistics_(0),
    117118lastObjectiveValue_(COIN_DBL_MAX), isLastPivotCompatible_(false),
     
    367368      if (jColumn<numberColumns_) {
    368369        if (!rowScale) {
    369           for (int i = columnStart[jColumn]; i < columnStart[jColumn] + columnLength[jColumn]; i++) {
     370          for (CoinBigIndex i = columnStart[jColumn]; i < columnStart[jColumn] + columnLength[jColumn]; i++) {
    370371              int iRow = row[i];
    371372              dotProduct += values[iRow]*elementByColumn[i];
     
    375376          // apply scaling
    376377          double scale = model_->columnScale()[jColumn];
    377           for (int i = columnStart[jColumn]; i < columnStart[jColumn] + columnLength[jColumn]; i++) {
     378          for (CoinBigIndex i = columnStart[jColumn]; i < columnStart[jColumn] + columnLength[jColumn]; i++) {
    378379            int iRow = row[i];
    379380            dotProduct += values[iRow]*elementByColumn[i] * rowScale[iRow];
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r2260 r2271  
    13521352#endif
    13531353#define COIN_SPARSE_MATRIX 2
    1354                int numberCovered=0;
     1354               CoinBigIndex numberCovered=0;
    13551355               int numberColumns = matrix_->getNumCols();
    13561356               bool sparse=true;
     
    16221622      CoinBigIndex end = columnStart[iColumn+1];
    16231623      jColumn = iColumn;
    1624       int n = end - start;
     1624      int n = static_cast<int>(end - start);
    16251625      bool odd = (n & 1) != 0;
    16261626      n = n >> 1;
     
    17021702               CoinBigIndex end = columnStart[iColumn+1];
    17031703               jColumn = iColumn;
    1704                int n = end - start;
     1704               int n = static_cast<int>(end - start);
    17051705               bool odd = (n & 1) != 0;
    17061706               n = n >> 1;
     
    17611761      CoinBigIndex start = columnStart[iColumn];
    17621762      CoinBigIndex end = columnStart[iColumn+1];
    1763       int n = end - start;
     1763      int n = static_cast<int>(end - start);
    17641764      bool odd = (n & 1) != 0;
    17651765      n = n >> 1;
     
    18751875               CoinBigIndex start = columnStart[iColumn];
    18761876               CoinBigIndex end = columnStart[iColumn+1];
    1877                int n = end - start;
     1877               int n = static_cast<int>(end - start);
    18781878#if 1
    18791879               bool odd = (n & 1) != 0;
     
    20832083          CoinBigIndex start = rowStart[iRow];
    20842084          CoinBigIndex end = rowStart[iRow+1];
    2085           int n = end - start;
     2085          int n = static_cast<int>(end - start);
    20862086          const int * COIN_RESTRICT columnThis = column + start;
    20872087          const double * COIN_RESTRICT elementThis = element + start;
     
    21812181          index[numberNonZero++] = iColumn;
    21822182     }
    2183      int numberOriginal = numberNonZero;
    21842183     value = pi1 * scalar;
    21852184     for (j = rowStart[iRow1]; j < rowStart[iRow1+1]; j++) {
     
    22002199     // get rid of tiny values and zero out marked
    22012200     int i;
    2202      int iFirst = numberNonZero;
    2203      for (i = 0; i < numberOriginal; i++) {
     2201     int n = numberNonZero;
     2202     numberNonZero=0;
     2203     for (i = 0; i < n; i++) {
    22042204          int iColumn = index[i];
    22052205          marked[iColumn] = 0;
    2206           if (fabs(array[i]) <= tolerance) {
    2207                if (numberNonZero > numberOriginal) {
    2208                     numberNonZero--;
    2209                     double value = array[numberNonZero];
    2210                     array[numberNonZero] = 0.0;
    2211                     array[i] = value;
    2212                     index[i] = index[numberNonZero];
    2213                } else {
    2214                     iFirst = i;
    2215                }
    2216           }
    2217      }
    2218 
    2219      if (iFirst < numberNonZero) {
    2220           int n = iFirst;
    2221           for (i = n; i < numberOriginal; i++) {
    2222                int iColumn = index[i];
    2223                double value = array[i];
    2224                array[i] = 0.0;
    2225                if (fabs(value) > tolerance) {
    2226                     array[n] = value;
    2227                     index[n++] = iColumn;
    2228                }
    2229           }
    2230           for (; i < numberNonZero; i++) {
    2231                int iColumn = index[i];
    2232                double value = array[i];
    2233                array[i] = 0.0;
    2234                array[n] = value;
    2235                index[n++] = iColumn;
    2236           }
    2237           numberNonZero = n;
    2238      }
     2206          if (fabs(array[i]) > tolerance) {
     2207            array[numberNonZero] = array[i];
     2208            index[numberNonZero++] = index[i];
     2209          }
     2210     }
     2211     memset(array+numberNonZero,0,(n-numberNonZero)*sizeof(double));
    22392212     output->setNumElements(numberNonZero);
    22402213     spareVector->setNumElements(0);
     
    24752448      CoinBigIndex start = columnStart[iColumn];
    24762449      CoinBigIndex end = columnStart[iColumn+1];
    2477       int n = end - start;
     2450      int n = static_cast<int>(end - start);
    24782451      const int * COIN_RESTRICT rowThis = row + start;
    24792452      const double * COIN_RESTRICT elementThis = elementByColumn + start;
     
    25762549      CoinBigIndex start = columnStart[iColumn];
    25772550      CoinBigIndex end = columnStart[iColumn+1];
    2578       int n = end - start;
     2551      int n = static_cast<int>(end - start);
    25792552      bool odd = (n & 1) != 0;
    25802553      n &= ~1;
     
    33553328}
    33563329/// returns number of elements in column part of basis,
    3357 CoinBigIndex
     3330int
    33583331ClpPackedMatrix::countBasis( const int * whichColumn,
    33593332                             int & numberColumnBasic)
     
    33673340          numberElements += columnLength[iColumn];
    33683341     }
    3369      return numberElements;
     3342#if COIN_BIG_INDEX
     3343     if (numberElements>COIN_INT_MAX) {
     3344       printf("Factorization too large\n");
     3345       abort();
     3346     }
     3347#endif
     3348     return static_cast<int>(numberElements);
    33703349}
    33713350void
     
    34113390                         elementU[numberElements++] = elementByColumn[j];
    34123391                    }
    3413                     start[i+1] = numberElements;
     3392                    start[i+1] = static_cast<int>(numberElements);
    34143393               }
    34153394          } else {
     
    34313410                              elementByColumn[j] * scale * rowScale[iRow];
    34323411                    }
    3433                     start[i+1] = numberElements;
     3412                    start[i+1] = static_cast<int>(numberElements);
    34343413               }
    34353414          }
     
    34513430                         }
    34523431                    }
    3453                     start[i+1] = numberElements;
    3454                     columnCount[i] = numberElements - start[i];
     3432                    start[i+1] = static_cast<int>(numberElements);
     3433                    columnCount[i] = static_cast<int>(numberElements) - start[i];
    34553434               }
    34563435          } else {
     
    34713450                         }
    34723451                    }
    3473                     start[i+1] = numberElements;
    3474                     columnCount[i] = numberElements - start[i];
    3475                }
    3476           }
    3477      }
     3452                    start[i+1] = static_cast<int>(numberElements);
     3453                    columnCount[i] = static_cast<int>(numberElements) - start[i];
     3454               }
     3455          }
     3456     }
     3457#if COIN_BIG_INDEX
     3458     if (numberElements>COIN_INT_MAX)
     3459       abort();
     3460#endif
    34783461}
    34793462#if 0
     
    42374220     int * COIN_RESTRICT columnLength = matrix_->getMutableVectorLengths();
    42384221     double * COIN_RESTRICT elementByColumn = matrix_->getMutableElements();
    4239      int deletedElements = 0;
     4222     CoinBigIndex deletedElements = 0;
    42404223     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    42414224          CoinBigIndex j;
    42424225          char useful = 0;
    42434226          bool deleteSome = false;
    4244           int start = columnStart[iColumn];
    4245           int end = start + columnLength[iColumn];
     4227          CoinBigIndex start = columnStart[iColumn];
     4228          CoinBigIndex end = start + columnLength[iColumn];
    42464229#ifndef LEAVE_FIXED
    42474230          if (columnUpper[iColumn] >
     
    42834266               }
    42844267               deletedElements += end - put;
    4285                columnLength[iColumn] = put - start;
     4268               columnLength[iColumn] = static_cast<int>(put - start);
    42864269          }
    42874270     }
     
    47674750                    double * COIN_RESTRICT elementsInThisRow = element + rowStart[iRow];
    47684751                    const int * COIN_RESTRICT columnsInThisRow = column + rowStart[iRow];
    4769                     int number = rowStart[iRow+1] - rowStart[iRow];
     4752                    int number = static_cast<int>(rowStart[iRow+1] - rowStart[iRow]);
    47704753                    assert (number <= numberColumns);
    47714754                    for (j = 0; j < number; j++) {
     
    50395022     assert (check == 15 || check == 11);
    50405023     if (check == 15) {
    5041           int * COIN_RESTRICT mark = new int [numberRows];
     5024          CoinBigIndex * COIN_RESTRICT mark = new CoinBigIndex [numberRows];
    50425025          int i;
    50435026          for (i = 0; i < numberRows; i++)
     
    56865669               double * COIN_RESTRICT elementsInThisRow = element + rowStart[iRow];
    56875670               const int * COIN_RESTRICT columnsInThisRow = column + rowStart[iRow];
    5688                int number = rowStart[iRow+1] - rowStart[iRow];
     5671               int number = static_cast<int>(rowStart[iRow+1] - rowStart[iRow]);
    56895672               assert (number <= numberColumns);
    56905673               for (j = 0; j < number; j++) {
     
    58715854{
    58725855     delete columnCopy_;
    5873      if (model->vectorMode()) {
     5856     if (model->vectorMode()==1) {
    58745857       flags_ |= 16;
    58755858       // go to exact devex (unless full steepest)
     
    62996282{
    63006283     int iWhich = 0;
    6301      int nextN = 0;
     6284     CoinBigIndex nextN = 0;
    63026285     CoinBigIndex nextStart = 0;
    63036286     double nextPi = 0.0;
     
    63156298          double value = nextPi;
    63166299          CoinBigIndex j =  nextStart;
    6317           int n = nextN;
     6300          CoinBigIndex n = nextN;
    63186301          // get next
    63196302          iWhich++;
     
    76777660    }
    76787661    int n = nBlock*COIN_AVX2;
    7679     int nSave=newValues-array;
     7662    int nSave=static_cast<int>(newValues-array);
    76807663    newValues = roundUpDouble((array+numberNonZero));
    76817664    for (int j=0;j<n;j++) {
     
    79547937    int n = block->firstBasic_;
    79557938    int nL = block->firstAtUpper_;
    7956     nMax = (newValues-array) + n;
     7939    nMax = static_cast<int>(newValues-array) + n;
    79577940    for (int j=0;j<nL;j++) {
    79587941      double value2=newValues[j];
  • trunk/Clp/src/ClpPackedMatrix.hpp

    r2259 r2271  
    114114     virtual ClpMatrixBase * reverseOrderedCopy() const;
    115115     /// Returns number of elements in column part of basis
    116      virtual CoinBigIndex countBasis(const int * whichColumn,
     116     virtual int countBasis(const int * whichColumn,
    117117                                     int & numberColumnBasic);
    118118     /// Fills in column part of basis
  • trunk/Clp/src/ClpParameters.hpp

    r2046 r2271  
    8282/// Copy (I don't like complexity of Coin version)
    8383template <class T> inline void
    84 ClpDisjointCopyN( const T * array, const int size, T * newArray)
     84ClpDisjointCopyN( const T * array, const CoinBigIndex size, T * newArray)
    8585{
    8686     memcpy(reinterpret_cast<void *> (newArray), array, size * sizeof(T));
     
    8888/// And set
    8989template <class T> inline void
    90 ClpFillN( T * array, const int size, T value)
     90ClpFillN( T * array, const CoinBigIndex size, T value)
    9191{
    92      int i;
     92     CoinBigIndex i;
    9393     for (i = 0; i < size; i++)
    9494          array[i] = value;
     
    9696/// This returns a non const array filled with input from scalar or actual array
    9797template <class T> inline T*
    98 ClpCopyOfArray( const T * array, const int size, T value)
     98ClpCopyOfArray( const T * array, const CoinBigIndex size, T value)
    9999{
    100100     T * arrayNew = new T[size];
     
    108108/// This returns a non const array filled with actual array (or NULL)
    109109template <class T> inline T*
    110 ClpCopyOfArray( const T * array, const int size)
     110ClpCopyOfArray( const T * array, const CoinBigIndex size)
    111111{
    112112     if (array) {
  • trunk/Clp/src/ClpPlusMinusOneMatrix.cpp

    r2235 r2271  
    107107#endif
    108108     int numberMajor = (columnOrdered_) ? numberColumns_ : numberRows_;
    109      int numberElements = startPositive[numberMajor];
     109     CoinBigIndex numberElements = startPositive[numberMajor];
    110110     startPositive_ = ClpCopyOfArray(startPositive, numberMajor + 1);
    111111     startNegative_ = ClpCopyOfArray(startNegative, numberMajor);
     
    457457     return newCopy;
    458458}
    459 static bool doPlusOnes=true;
     459//static bool doPlusOnes=true;
    460460//unscaled versions
    461461void
     
    705705          int i;
    706706          if (packed) {
    707                int numberCovered=0;
     707               CoinBigIndex numberCovered=0;
    708708               int numberColumns = getNumCols();
    709709               bool sparse=true;
     
    11521152}
    11531153/// returns number of elements in column part of basis,
    1154 CoinBigIndex
     1154int
    11551155ClpPlusMinusOneMatrix::countBasis(const int * whichColumn,
    11561156                                  int & numberColumnBasic)
     
    11621162          numberElements += startPositive_[iColumn+1] - startPositive_[iColumn];
    11631163     }
    1164      return numberElements;
     1164#if COIN_BIG_INDEX
     1165     if (numberElements>COIN_INT_MAX) {
     1166       printf("Factorization too large\n");
     1167       abort();
     1168     }
     1169#endif
     1170     return static_cast<int>(numberElements);
    11651171}
    11661172void
     
    11901196               elementU[numberElements++] = -1.0;
    11911197          }
    1192           start[i+1] = numberElements;
    1193           columnCount[i] = numberElements - start[i];
    1194      }
     1198          start[i+1] = static_cast<int>(numberElements);
     1199          columnCount[i] = static_cast<int>(numberElements - start[i]);
     1200     }
     1201#if COIN_BIG_INDEX
     1202     if (numberElements>COIN_INT_MAX)
     1203       abort();
     1204#endif
    11951205}
    11961206/* Unpacks a column into an CoinIndexedvector
     
    12761286          int numberMinor = (!columnOrdered_) ? numberColumns_ : numberRows_;
    12771287          int numberMajor = (columnOrdered_) ? numberColumns_ : numberRows_;
    1278           int numberElements = startPositive_[numberMajor];
     1288          CoinBigIndex numberElements = startPositive_[numberMajor];
    12791289          double * elements = new double [numberElements];
    12801290          CoinBigIndex j = 0;
     
    13241334          int i;
    13251335          for (i = 0; i < numberMajor; i++) {
    1326                lengths_[i] = startPositive_[i+1] - startPositive_[i];
     1336            lengths_[i] = static_cast<int>(startPositive_[i+1] - startPositive_[i]);
    13271337          }
    13281338     }
     
    14281438     delete matrix_;
    14291439     matrix_ = NULL;
     1440     // redo which
     1441     int numberRows=0;
     1442     for (iRow = 0; iRow < numberRows_; iRow++) {
     1443       if (which[iRow]) {
     1444         which[iRow]=-1; // not wanted
     1445       } else {
     1446         which[iRow]=numberRows;
     1447         numberRows++;
     1448       }
     1449     }
    14301450     int * newIndices = new int [newSize];
    14311451     newSize = 0;
     
    14381458          startPositive_[newNumber] = newSize;
    14391459          for (i = start; i < end; i++) {
    1440                iRow = indices_[i];
    1441                if (!which[iRow])
     1460               iRow = which[indices_[i]];
     1461               if (iRow>=0)
    14421462                    newIndices[newSize++] = iRow;
    14431463          }
     
    14461466          startNegative_[newNumber] = newSize;
    14471467          for (i = start; i < end; i++) {
    1448                iRow = indices_[i];
    1449                if (!which[iRow])
     1468               iRow = which[indices_[i]];
     1469               if (iRow>=0)
    14501470                    newIndices[newSize++] = iRow;
    14511471          }
     
    14971517     int minIndex = columnOrdered_ ? numberRows_ : numberColumns_;
    14981518     int number = !columnOrdered_ ? numberRows_ : numberColumns_;
    1499      int numberElements = getNumElements();
     1519     CoinBigIndex numberElements = getNumElements();
    15001520     CoinBigIndex last = -1;
    15011521     int bad = 0;
     
    15861606     delete matrix_;
    15871607     matrix_ = NULL;
    1588      int numberNow = startPositive_[numberColumns_];
     1608     CoinBigIndex numberNow = startPositive_[numberColumns_];
    15891609     CoinBigIndex * temp;
    15901610     temp = new CoinBigIndex [numberColumns_+1+number];
     
    16601680     delete matrix_;
    16611681     matrix_ = NULL;
    1662      int numberNow = startPositive_[numberColumns_];
     1682     CoinBigIndex numberNow = startPositive_[numberColumns_];
    16631683     int * newIndices = new int [numberNow+size];
    16641684     // Update starts and turn counts into positions
     
    16701690          CoinBigIndex now;
    16711691          now = startPositive_[iColumn];
    1672           move = startNegative_[iColumn] - now;
     1692          move = static_cast<int>(startNegative_[iColumn] - now);
    16731693          n = countPositive[iColumn];
    16741694          startPositive_[iColumn] += numberAdded;
    16751695          CoinMemcpyN(indices_+now, move, newIndices + startPositive_[iColumn]);
    1676           countPositive[iColumn] = startNegative_[iColumn] + numberAdded;
     1696          countPositive[iColumn] = static_cast<int>(startNegative_[iColumn] + numberAdded);
    16771697          numberAdded += n;
    16781698          now = startNegative_[iColumn];
    1679           move = startPositive_[iColumn+1] - now;
     1699          move = static_cast<int>(startPositive_[iColumn+1] - now);
    16801700          n = countNegative[iColumn];
    16811701          startNegative_[iColumn] += numberAdded;
    16821702          CoinMemcpyN(indices_+now, move, newIndices + startNegative_[iColumn]);
    1683           countNegative[iColumn] = startPositive_[iColumn+1] + numberAdded;
     1703          countNegative[iColumn] = static_cast<int>(startPositive_[iColumn+1] + numberAdded);
    16841704          numberAdded += n;
    16851705     }
     
    21992219     int iVector;
    22002220     for (iVector = 0; iVector < number; iVector++) {
    2201           int iStart = starts[iVector];
     2221          CoinBigIndex iStart = starts[iVector];
    22022222          vectors[iVector] =
    2203                new CoinPackedVector(starts[iVector+1] - iStart,
     2223            new CoinPackedVector(static_cast<int>(starts[iVector+1] - iStart),
    22042224                                    index + iStart, element + iStart);
    22052225     }
     
    22172237}
    22182238#endif
     2239#if CLP_POOL_MATRIX
     2240//#############################################################################
     2241// Constructors / Destructor / Assignment
     2242//#############################################################################
     2243
     2244//-------------------------------------------------------------------
     2245// Default Constructor
     2246//-------------------------------------------------------------------
     2247ClpPoolMatrix::ClpPoolMatrix ()
     2248  : ClpMatrixBase()
     2249{
     2250  setType(13);
     2251  matrix_ = NULL;
     2252  lengths_ = NULL;
     2253  elements_ = NULL;
     2254  columnStart_ = NULL;
     2255  stuff_ = NULL;
     2256  numberRows_ = 0;
     2257  numberColumns_ = 0;
     2258  numberDifferent_ = 0;
     2259}
     2260
     2261//-------------------------------------------------------------------
     2262// Copy constructor
     2263//-------------------------------------------------------------------
     2264ClpPoolMatrix::ClpPoolMatrix (const ClpPoolMatrix & rhs)
     2265  : ClpMatrixBase(rhs)
     2266{
     2267  setType(13);
     2268  matrix_ = NULL;
     2269  lengths_ = NULL;
     2270  elements_ = NULL;
     2271  columnStart_ = NULL;
     2272  stuff_ = NULL;
     2273  numberRows_ = rhs.numberRows_;
     2274  numberColumns_ = rhs.numberColumns_;
     2275  numberDifferent_ = rhs.numberDifferent_;
     2276  if (numberColumns_) {
     2277    columnStart_ = CoinCopyOfArray(rhs.columnStart_,numberColumns_+1);
     2278    CoinBigIndex numberElements = columnStart_[numberColumns_];
     2279    stuff_ = CoinCopyOfArray(rhs.stuff_,numberElements);
     2280    elements_ = CoinCopyOfArray(rhs.elements_,numberDifferent_);
     2281  }
     2282}
     2283static const int mmult[] = {
     2284  262139, 259459, 256889, 254291, 251701, 249133, 246709, 244247};
     2285inline int hashit(double value)
     2286{
     2287  const unsigned char * chars = reinterpret_cast<unsigned char *>(&value);
     2288  int n = 0;
     2289  for (int j=0;j<8;j++)
     2290    n += mmult[j]*chars[j];
     2291  n = n % (1<<CLP_POOL_SIZE);
     2292  return n;
     2293}
     2294ClpPoolMatrix::ClpPoolMatrix (const CoinPackedMatrix & rhs)
     2295  : ClpMatrixBase()
     2296{
     2297  setType(13);
     2298  matrix_ = NULL;
     2299  lengths_ = NULL;
     2300  numberDifferent_ = 0;
     2301  assert (rhs.isColOrdered());
     2302  // get matrix data pointers
     2303  const int * row = rhs.getIndices();
     2304  const CoinBigIndex * columnStart = rhs.getVectorStarts();
     2305  const int * columnLength = rhs.getVectorLengths();
     2306  const double * elementByColumn = rhs.getElements();
     2307  numberColumns_ = rhs.getNumCols();
     2308  numberRows_ = rhs.getNumRows();
     2309  assert (numberRows_<(1<<CLP_POOL_MATRIX));
     2310  elements_ = NULL;
     2311  columnStart_ = new CoinBigIndex [numberColumns_+1];
     2312  stuff_ = new poolInfo [rhs.getNumElements()];
     2313  int maxPool = 1<<CLP_POOL_SIZE;
     2314  double * tempDifferent  = new double [maxPool];
     2315#define HASH 2
     2316#if HASH > 1
     2317  // for hashing
     2318  typedef struct {
     2319    int index, next;
     2320  } CoinHashLink;
     2321  CoinHashLink * hashThis = new CoinHashLink[4*maxPool];
     2322  for ( int i = 0; i < 4*maxPool; i++ ) {
     2323    hashThis[i].index = -1;
     2324    hashThis[i].next = -1;
     2325  }
     2326#endif
     2327  int numberElements=0;
     2328  int hashDifferent=0;
     2329  for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2330    CoinBigIndex k;
     2331    columnStart_[iColumn]=numberElements;
     2332    for (k = columnStart[iColumn]; k < columnStart[iColumn] + columnLength[iColumn];
     2333         k++) {
     2334      int iRow=row[k];
     2335      double value = elementByColumn[k];
     2336      poolInfo stuff;
     2337      stuff.row_=iRow;
     2338#if HASH==1 || HASH ==3
     2339      int j;
     2340      for (j=0;j<numberDifferent_;j++) {
     2341        if (value==tempDifferent[j])
     2342          break;
     2343      }
     2344#endif
     2345#if HASH==2 || HASH ==3
     2346      int ipos = hashit(value);
     2347      int j1;
     2348      while ( true ) {
     2349        j1 = hashThis[ipos].index;
     2350        if (j1 == -1) {
     2351          hashThis[ipos].index=numberDifferent_;
     2352          j1=numberDifferent_;
     2353          break;
     2354        } else if (value==tempDifferent[j1]) {
     2355          break;
     2356        } else {
     2357          int k = hashThis[ipos].next;
     2358          if ( k == -1 ) {
     2359            j1 = numberDifferent_;
     2360            while ( true ) {
     2361              ++hashDifferent;
     2362              if ( hashThis[hashDifferent].index == -1 ) {
     2363                break;
     2364              }
     2365            }
     2366            hashThis[ipos].next = hashDifferent;
     2367            hashThis[hashDifferent].index = numberDifferent_;
     2368            break;
     2369          } else {
     2370            ipos = k;
     2371            /* nothing worked - try it again */
     2372          }
     2373        }
     2374      }
     2375#if HASH ==2
     2376      int j=j1;
     2377#endif
     2378#endif
     2379#if HASH ==3
     2380      assert (j==j1);
     2381#endif
     2382      if (j==numberDifferent_) {
     2383        if (j==maxPool)
     2384          break; // too many
     2385        tempDifferent[j]=value;
     2386        numberDifferent_++;
     2387      }
     2388      stuff.pool_=j;
     2389      stuff_[numberElements++]=stuff;
     2390    }
     2391  }
     2392  columnStart_[numberColumns_]=numberElements;
     2393#if HASH>1
     2394  delete [] hashThis;
     2395#endif
     2396  elements_ = new double [numberDifferent_];
     2397  memcpy(elements_,tempDifferent,numberDifferent_*sizeof(double));
     2398  delete [] tempDifferent;
     2399  if (numberDifferent_==maxPool) {
     2400    delete [] stuff_;
     2401    delete [] elements_;
     2402    delete [] columnStart_;
     2403    elements_ = NULL;
     2404    columnStart_ = NULL;
     2405    stuff_ = NULL;
     2406    numberRows_ = -1;
     2407    numberColumns_ = -1;
     2408    numberDifferent_ = -1;
     2409  }
     2410}
     2411
     2412//-------------------------------------------------------------------
     2413// Destructor
     2414//-------------------------------------------------------------------
     2415ClpPoolMatrix::~ClpPoolMatrix ()
     2416{
     2417  delete matrix_;
     2418  delete [] elements_;
     2419  delete [] columnStart_;
     2420  delete [] lengths_;
     2421  delete [] stuff_;
     2422}
     2423
     2424//----------------------------------------------------------------
     2425// Assignment operator
     2426//-------------------------------------------------------------------
     2427ClpPoolMatrix &
     2428ClpPoolMatrix::operator=(const ClpPoolMatrix& rhs)
     2429{
     2430  if (this != &rhs) {
     2431    ClpMatrixBase::operator=(rhs);
     2432    delete matrix_;
     2433    delete [] elements_;
     2434    delete [] columnStart_;
     2435    delete [] lengths_;
     2436    delete [] stuff_;
     2437    matrix_ = NULL;
     2438    lengths_ = NULL;
     2439    numberRows_ = rhs.numberRows_;
     2440    numberColumns_ = rhs.numberColumns_;
     2441    if (numberColumns_) {
     2442      columnStart_ = CoinCopyOfArray(rhs.columnStart_,numberColumns_+1);
     2443      CoinBigIndex numberElements = columnStart_[numberColumns_];
     2444      stuff_ = CoinCopyOfArray(rhs.stuff_,numberElements);
     2445      elements_ = CoinCopyOfArray(rhs.elements_,numberDifferent_);
     2446    }
     2447  }
     2448  return *this;
     2449}
     2450// Constructor from arrays - handing over ownership
     2451ClpPoolMatrix::ClpPoolMatrix(int numberColumns,CoinBigIndex * columnStart,
     2452                             poolInfo * stuff, double * elements)
     2453  : ClpMatrixBase()
     2454{
     2455  setType(13);
     2456  matrix_ = NULL;
     2457  lengths_ = NULL;
     2458  numberColumns_ = numberColumns;
     2459  numberDifferent_ = 0;
     2460  numberRows_ = 0;
     2461  columnStart_ = columnStart;
     2462  stuff_ = stuff;
     2463  elements_ = elements;
     2464  for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2465    CoinBigIndex k;
     2466    for (k = columnStart_[iColumn]; k < columnStart_[iColumn+1];
     2467         k++) {
     2468      int iRow=stuff_[k].row_;
     2469      int iPool=stuff_[k].pool_;
     2470      numberDifferent_ = CoinMax(numberDifferent_,iPool);
     2471      numberRows_ = CoinMax(numberRows_,iRow);
     2472    }
     2473  }
     2474  // adjust
     2475  numberDifferent_++;
     2476  numberRows_++;
     2477}
     2478//-------------------------------------------------------------------
     2479// Clone
     2480//-------------------------------------------------------------------
     2481ClpMatrixBase * ClpPoolMatrix::clone() const
     2482{
     2483  return new ClpPoolMatrix(*this);
     2484}
     2485/* Subset clone (without gaps).  Duplicates are allowed
     2486   and order is as given */
     2487ClpMatrixBase *
     2488ClpPoolMatrix::subsetClone (int numberRows, const int * whichRows,
     2489                            int numberColumns,
     2490                            const int * whichColumns) const
     2491{
     2492  return new ClpPoolMatrix(*this, numberRows, whichRows,
     2493                           numberColumns, whichColumns);
     2494}
     2495/* Subset constructor (without gaps).  Duplicates are allowed
     2496   and order is as given */
     2497ClpPoolMatrix::ClpPoolMatrix (
     2498                              const ClpPoolMatrix & rhs,
     2499                              int numberRows, const int * whichRow,
     2500                              int numberColumns, const int * whichColumn)
     2501  : ClpMatrixBase(rhs)
     2502{
     2503  setType(13);
     2504  matrix_ = NULL;
     2505  lengths_ = NULL;
     2506  elements_ = NULL;
     2507  columnStart_ = NULL;
     2508  stuff_ = NULL;
     2509  numberRows_ = numberRows;
     2510  numberColumns_ = numberColumns;
     2511  numberDifferent_ = 0;
     2512  if (!numberRows_||!numberColumns_)
     2513    return;
     2514  numberDifferent_ = rhs.numberDifferent_;
     2515  elements_ = CoinCopyOfArray(rhs.elements_,numberDifferent_);
     2516  int numberRowsOther = rhs.numberRows_;
     2517  int numberColumnsOther = rhs.numberColumns_;
     2518  int * newRow = new int [numberRowsOther+numberRows_];
     2519  int * duplicateRow = newRow+numberRowsOther;
     2520  for (int iRow = 0; iRow < numberRowsOther; iRow++)
     2521    newRow[iRow] = -1;
     2522  // and array for duplicating rows
     2523  int numberBad = 0;
     2524  for (int iRow = 0; iRow < numberRows_; iRow++) {
     2525    duplicateRow[iRow] = -1;
     2526    int kRow = whichRow[iRow];
     2527    if (kRow >= 0  && kRow < numberRowsOther) {
     2528      if (newRow[kRow] < 0) {
     2529        // first time
     2530        newRow[kRow] = iRow;
     2531      } else {
     2532        // duplicate
     2533        int lastRow = newRow[kRow];
     2534        newRow[kRow] = iRow;
     2535        duplicateRow[iRow] = lastRow;
     2536      }
     2537    } else {
     2538      // bad row
     2539      numberBad++;
     2540    }
     2541  }
     2542 
     2543  if (numberBad)
     2544    throw CoinError("bad row entries",
     2545                    "subset constructor", "ClpPoolMatrix");
     2546  // now get size and check columns
     2547  CoinBigIndex size = 0;
     2548  numberBad = 0;
     2549  const CoinBigIndex * starts = rhs.columnStart_;
     2550  const poolInfo * stuff = rhs.stuff_;
     2551  for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2552    int kColumn = whichColumn[iColumn];
     2553    if (kColumn >= 0  && kColumn < numberColumnsOther) {
     2554      CoinBigIndex i;
     2555      for (i = starts[kColumn]; i < starts[kColumn+1]; i++) {
     2556        int kRow = stuff[i].row_;
     2557        kRow = newRow[kRow];
     2558        while (kRow >= 0) {
     2559          size++;
     2560          kRow = duplicateRow[kRow];
     2561        }
     2562      }
     2563    } else {
     2564      // bad column
     2565      numberBad++;
     2566    }
     2567  }
     2568  if (numberBad)
     2569    throw CoinError("bad major entries",
     2570                    "subset constructor", "ClpPoolMatrix");
     2571  // now create arrays
     2572  stuff_ = new poolInfo[size];
     2573  columnStart_ = new CoinBigIndex [numberColumns_+1];
     2574  size=0;
     2575  for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2576    int kColumn = whichColumn[iColumn];
     2577    columnStart_[iColumn]=size;
     2578    CoinBigIndex i;
     2579    for (i = starts[kColumn]; i < starts[kColumn+1]; i++) {
     2580      int kRow = stuff[i].row_;
     2581      int iPool = stuff[i].pool_;
     2582      kRow = newRow[kRow];
     2583      while (kRow >= 0) {
     2584        stuff_[size].row_=kRow;
     2585        stuff_[size++].pool_=iPool;
     2586        kRow = duplicateRow[kRow];
     2587      }
     2588    }
     2589  }
     2590  columnStart_[numberColumns_]=size;
     2591  delete [] newRow;
     2592}
     2593// Create matrix_
     2594ClpPackedMatrix *
     2595ClpPoolMatrix::createMatrix() const
     2596{
     2597  if (!matrix_) {
     2598    CoinBigIndex numberElements = columnStart_[numberColumns_];
     2599    double * elements = new double [numberElements];
     2600    int * rows = new int [numberElements];
     2601    bool lengthsExist = lengths_!=NULL;
     2602    numberElements=0;
     2603    if (!lengthsExist)
     2604      lengths_ = new int[numberColumns_];
     2605    for (int i = 0; i < numberColumns_; i++) {
     2606      lengths_[i]=static_cast<int>(columnStart_[i+1]-columnStart_[i]);
     2607      for (CoinBigIndex j = columnStart_[i]; j < columnStart_[i+1]; j++) {
     2608        elements[numberElements] = elements_[stuff_[j].pool_];
     2609        rows[numberElements++] = stuff_[j].row_;
     2610      }
     2611    }
     2612    CoinPackedMatrix * matrix =  new CoinPackedMatrix(true, numberRows_, numberColumns_,
     2613                                                      numberElements,
     2614                                                      elements, rows,
     2615                                                      columnStart_, lengths_);
     2616    delete [] elements;
     2617    delete [] rows;
     2618    matrix_ = new ClpPackedMatrix(matrix);
     2619  }
     2620  return matrix_;
     2621}
     2622
     2623
     2624/* Returns a new matrix in reverse order without gaps */
     2625ClpMatrixBase *
     2626ClpPoolMatrix::reverseOrderedCopy() const
     2627{
     2628  // define to say no row copy
     2629#define BIG_MATRIX
     2630#ifndef BIG_MATRIX
     2631  printf("XcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2632  createMatrix();
     2633  return matrix_->reverseOrderedCopy();
     2634#else
     2635  return NULL;
     2636#endif
     2637}
     2638#undef ABOCA_LITE
     2639//unscaled versions
     2640void
     2641ClpPoolMatrix::times(double scalar,
     2642                     const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const
     2643{
     2644#if 0
     2645  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2646  createMatrix()->times(scalar,x,y);
     2647#else
     2648  for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2649    CoinBigIndex j;
     2650    double value = x[iColumn];
     2651    if (value) {
     2652      CoinBigIndex start = columnStart_[iColumn];
     2653      CoinBigIndex end = columnStart_[iColumn+1];
     2654      value *= scalar;
     2655      for (j = start; j < end; j++) {
     2656        int iRow = stuff_[j].row_;
     2657        y[iRow] += value * elements_[stuff_[j].pool_];
     2658      }
     2659    }
     2660  }
     2661#endif
     2662}
     2663void
     2664ClpPoolMatrix::transposeTimes(double scalar,
     2665                              const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const
     2666{
     2667#if 0
     2668  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2669  createMatrix()->transposeTimes(scalar,x,y);
     2670#else
     2671  int iColumn;
     2672  CoinBigIndex start = columnStart_[0];
     2673  if (scalar == -1.0) {
     2674    for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2675      CoinBigIndex j;
     2676      CoinBigIndex next = columnStart_[iColumn+1];
     2677      double value = 0.0;
     2678      // scaled
     2679      for (j = start; j < next; j++) {
     2680        int jRow = stuff_[j].row_;
     2681        value += x[jRow] * elements_[stuff_[j].pool_];
     2682      }
     2683      start = next;
     2684      y[iColumn] -= value;
     2685    }
     2686  } else {
     2687    for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2688      CoinBigIndex j;
     2689      CoinBigIndex next = columnStart_[iColumn+1];
     2690      double value = 0.0;
     2691      // scaled
     2692      for (j = start; j < next; j++) {
     2693        int jRow = stuff_[j].row_;
     2694        value += x[jRow] * elements_[stuff_[j].pool_];
     2695      }
     2696      start = next;
     2697      y[iColumn] += value * scalar;
     2698    }
     2699  }
     2700#endif
     2701}
     2702void
     2703ClpPoolMatrix::times(double scalar,
     2704                     const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
     2705                     const double * rowScale,
     2706                     const double * columnScale) const
     2707{
     2708  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     2709  createMatrix()->times(scalar,x,y);
     2710}
     2711void
     2712ClpPoolMatrix::transposeTimes( double scalar,
     2713                               const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
     2714                               const double * rowScale,
     2715                               const double * columnScale,
     2716                               double * spare) const
     2717{
     2718#if 0
     2719  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2720  createMatrix()->transposeTimes(scalar,x,y,rowScale,columnScale,spare);
     2721#else
     2722  if (rowScale) {
     2723    int iColumn;
     2724    if (!spare) {
     2725      CoinBigIndex start = columnStart_[0];
     2726      if (scalar == -1.0) {
     2727        for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2728          CoinBigIndex j;
     2729          CoinBigIndex next = columnStart_[iColumn+1];
     2730          double value = 0.0;
     2731          // scaled
     2732          for (j = start; j < next; j++) {
     2733            int jRow = stuff_[j].row_;
     2734            value += x[jRow] * elements_[stuff_[j].pool_] * rowScale[jRow];
     2735          }
     2736          start = next;
     2737          y[iColumn] -= value * columnScale[iColumn];
     2738        }
     2739      } else {
     2740        for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2741          CoinBigIndex j;
     2742          CoinBigIndex next = columnStart_[iColumn+1];
     2743          double value = 0.0;
     2744          // scaled
     2745          for (j = start; j < next; j++) {
     2746            int jRow = stuff_[j].row_;
     2747            value += x[jRow] * elements_[stuff_[j].pool_] * rowScale[jRow];
     2748          }
     2749          start = next;
     2750          y[iColumn] += value * scalar * columnScale[iColumn];
     2751        }
     2752      }
     2753    } else {
     2754      // can use spare region
     2755      int iRow;
     2756      int numberRows = matrix_->getNumRows();
     2757      for (iRow = 0; iRow < numberRows; iRow++) {
     2758        double value = x[iRow];
     2759        if (value)
     2760          spare[iRow] = value * rowScale[iRow];
     2761        else
     2762          spare[iRow] = 0.0;
     2763      }
     2764      CoinBigIndex start = columnStart_[0];
     2765      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2766        CoinBigIndex j;
     2767        CoinBigIndex next = columnStart_[iColumn+1];
     2768        double value = 0.0;
     2769        // scaled
     2770        for (j = start; j < next; j++) {
     2771          int jRow = stuff_[j].row_;
     2772          value += spare[jRow] * elements_[stuff_[j].pool_];
     2773        }
     2774        start = next;
     2775        y[iColumn] += value * scalar * columnScale[iColumn];
     2776      }
     2777    }
     2778  } else {
     2779    transposeTimes(scalar, x, y);
     2780  }
     2781#endif
     2782}
     2783/* Return <code>x * A + y</code> in <code>z</code>.
     2784   Squashes small elements and knows about ClpSimplex */
     2785void
     2786ClpPoolMatrix::transposeTimes(const ClpSimplex * model, double scalar,
     2787                              const CoinIndexedVector * rowArray,
     2788                              CoinIndexedVector * y,
     2789                              CoinIndexedVector * columnArray) const
     2790{
     2791#if 0
     2792  bool packed = rowArray->packedMode();
     2793  assert (packed);
     2794  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2795  createMatrix()->transposeTimes(model,scalar,rowArray,y,columnArray);
     2796#else
     2797  columnArray->clear();
     2798  // do by column
     2799  double * COIN_RESTRICT pi = rowArray->denseVector();
     2800  int numberNonZero = 0;
     2801  int * COIN_RESTRICT index = columnArray->getIndices();
     2802  double * COIN_RESTRICT array = columnArray->denseVector();
     2803  int numberInRowArray = rowArray->getNumElements();
     2804  // maybe I need one in OsiSimplex
     2805  double zeroTolerance = model->zeroTolerance();
     2806  bool packed = rowArray->packedMode();
     2807  assert (packed);
     2808  // do by column
     2809  const double * COIN_RESTRICT rowScale = model->rowScale();
     2810  assert (!y->getNumElements());
     2811  // need to expand pi into y
     2812  assert(y->capacity() >= model->numberRows());
     2813  double * COIN_RESTRICT piOld = pi;
     2814  pi = y->denseVector();
     2815  const int * COIN_RESTRICT whichRow = rowArray->getIndices();
     2816  int i;
     2817  // later combine phases
     2818  if (!rowScale) {
     2819    // modify pi so can collapse to one loop
     2820    for (i = 0; i < numberInRowArray; i++) {
     2821      int iRow = whichRow[i];
     2822      pi[iRow] = scalar * piOld[i];
     2823    }
     2824    double value = 0.0;
     2825    CoinBigIndex j;
     2826    CoinBigIndex end = columnStart_[1];
     2827    for (j = columnStart_[0]; j < end; j++) {
     2828      int iRow = stuff_[j].row_;
     2829      value += pi[iRow] * elements_[stuff_[j].pool_];
     2830    }
     2831    int iColumn;
     2832    for (iColumn = 0; iColumn < numberColumns_ - 1; iColumn++) {
     2833      CoinBigIndex start = end;
     2834      end = columnStart_[iColumn+2];
     2835      if (fabs(value) > zeroTolerance) {
     2836        array[numberNonZero] = value;
     2837        index[numberNonZero++] = iColumn;
     2838      }
     2839      value = 0.0;
     2840      for (j = start; j < end; j++) {
     2841        int iRow = stuff_[j].row_;
     2842        value += pi[iRow] * elements_[stuff_[j].pool_];
     2843      }
     2844    }
     2845    if (fabs(value) > zeroTolerance) {
     2846      array[numberNonZero] = value;
     2847      index[numberNonZero++] = iColumn;
     2848    }
     2849  } else {
     2850    // scaled
     2851    // modify pi so can collapse to one loop
     2852    for (i = 0; i < numberInRowArray; i++) {
     2853      int iRow = whichRow[i];
     2854      pi[iRow] = scalar * piOld[i] * rowScale[iRow];
     2855    }
     2856    const double * columnScale = model->columnScale();
     2857    double value = 0.0;
     2858    double scale = columnScale[0];
     2859    CoinBigIndex j;
     2860    CoinBigIndex end = columnStart_[1];
     2861    for (j = columnStart_[0]; j < end; j++) {
     2862      int iRow = stuff_[j].row_;
     2863      value += pi[iRow] * elements_[stuff_[j].pool_];
     2864    }
     2865    int iColumn;
     2866    for (iColumn = 0; iColumn < numberColumns_ - 1; iColumn++) {
     2867      value *= scale;
     2868      CoinBigIndex start = end;
     2869      scale = columnScale[iColumn+1];
     2870      end = columnStart_[iColumn+2];
     2871      if (fabs(value) > zeroTolerance) {
     2872        array[numberNonZero] = value;
     2873        index[numberNonZero++] = iColumn;
     2874      }
     2875      value = 0.0;
     2876      for (j = start; j < end; j++) {
     2877        int iRow = stuff_[j].row_;
     2878        value += pi[iRow] * elements_[stuff_[j].pool_];
     2879      }
     2880    }
     2881    value *= scale;
     2882    if (fabs(value) > zeroTolerance) {
     2883      array[numberNonZero] = value;
     2884      index[numberNonZero++] = iColumn;
     2885    }
     2886  }
     2887  // zero out
     2888  int numberRows = model->numberRows();
     2889  if (numberInRowArray * 4 < numberRows) {
     2890    for (i = 0; i < numberInRowArray; i++) {
     2891      int iRow = whichRow[i];
     2892      pi[iRow] = 0.0;
     2893    }
     2894  } else {
     2895    CoinZeroN(pi, numberRows);
     2896  }
     2897  columnArray->setNumElements(numberNonZero);
     2898  y->setNumElements(0);
     2899  columnArray->setPackedMode(true);
     2900#endif
     2901}
     2902/* Return <code>x * A + y</code> in <code>z</code>.
     2903   Squashes small elements and knows about ClpSimplex */
     2904void
     2905ClpPoolMatrix::transposeTimesByRow(const ClpSimplex * model, double scalar,
     2906                                   const CoinIndexedVector * rowArray,
     2907                                   CoinIndexedVector * y,
     2908                                   CoinIndexedVector * columnArray) const
     2909{
     2910  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     2911  createMatrix()->transposeTimesByRow(model,scalar,rowArray,y,columnArray);
     2912}
     2913/* Return <code>x *A in <code>z</code> but
     2914   just for indices in y. */
     2915void
     2916ClpPoolMatrix::subsetTransposeTimes(const ClpSimplex * model,
     2917                                    const CoinIndexedVector * rowArray,
     2918                                    const CoinIndexedVector * y,
     2919                                    CoinIndexedVector * columnArray) const
     2920{
     2921#if 0
     2922  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     2923  createMatrix()->subsetTransposeTimes(model,rowArray,y,columnArray);
     2924#else
     2925  columnArray->clear();
     2926  double * COIN_RESTRICT pi = rowArray->denseVector();
     2927  double * COIN_RESTRICT array = columnArray->denseVector();
     2928  int jColumn;
     2929  // get matrix data pointers
     2930  const double * COIN_RESTRICT rowScale = model->rowScale();
     2931  int numberToDo = y->getNumElements();
     2932  const int * COIN_RESTRICT which = y->getIndices();
     2933  assert (!rowArray->packedMode());
     2934  columnArray->setPacked();
     2935  if (!rowScale) {
     2936    for (jColumn = 0; jColumn < numberToDo; jColumn++) {
     2937      int iColumn=which[jColumn];
     2938      double value = 0.0;
     2939      CoinBigIndex start=columnStart_[iColumn];
     2940      CoinBigIndex end=columnStart_[iColumn+1];
     2941      array[jColumn] = value;
     2942      CoinBigIndex j;
     2943      for (j = start; j < end; j++) {
     2944        int iRow = stuff_[j].row_;
     2945        value += pi[iRow] * elements_[stuff_[j].pool_];
     2946      }
     2947      array[jColumn] = value;
     2948    }
     2949  } else {
     2950    // scaled
     2951    const double * columnScale = model->columnScale();
     2952    for (jColumn = 0; jColumn < numberToDo; jColumn++) {
     2953      int iColumn=which[jColumn];
     2954      double value = 0.0;
     2955      CoinBigIndex start=columnStart_[iColumn];
     2956      CoinBigIndex end=columnStart_[iColumn+1];
     2957      CoinBigIndex j;
     2958      for (j = start; j < end; j++) {
     2959        int iRow = stuff_[j].row_;
     2960        value += pi[iRow] * elements_[stuff_[j].pool_] * rowScale[iRow];
     2961      }
     2962      array[jColumn] = value*columnScale[iColumn];
     2963    }
     2964  }
     2965#endif
     2966}
     2967/// returns number of elements in column part of basis,
     2968int
     2969ClpPoolMatrix::countBasis(const int * whichColumn,
     2970                          int & numberColumnBasic)
     2971{
     2972  int i;
     2973  CoinBigIndex numberElements = 0;
     2974  for (i = 0; i < numberColumnBasic; i++) {
     2975    int iColumn = whichColumn[i];
     2976    numberElements += columnStart_[iColumn+1] - columnStart_[iColumn];
     2977  }
     2978#if COIN_BIG_INDEX
     2979  if (numberElements>COIN_INT_MAX) {
     2980    printf("Factorization too large\n");
     2981    abort();
     2982  }
     2983#endif
     2984  return static_cast<int>(numberElements);
     2985}
     2986void
     2987ClpPoolMatrix::fillBasis(ClpSimplex * ,
     2988                         const int * whichColumn,
     2989                         int & numberColumnBasic,
     2990                         int * indexRowU, int * start,
     2991                         int * rowCount, int * columnCount,
     2992                         CoinFactorizationDouble * elementU)
     2993{
     2994  CoinBigIndex numberElements = start[0];
     2995  for (int i = 0; i < numberColumnBasic; i++) {
     2996    int iColumn = whichColumn[i];
     2997    CoinBigIndex j = columnStart_[iColumn];
     2998    for (; j < columnStart_[iColumn+1]; j++) {
     2999      int iRow = stuff_[j].row_;
     3000      indexRowU[numberElements] = iRow;
     3001      rowCount[iRow]++;
     3002      elementU[numberElements++] = elements_[stuff_[j].pool_];;
     3003    }
     3004    start[i+1] = static_cast<int>(numberElements);
     3005    columnCount[i] = static_cast<int>(numberElements - start[i]);
     3006  }
     3007#if COIN_BIG_INDEX
     3008  if (numberElements>COIN_INT_MAX)
     3009    abort();
     3010#endif
     3011}
     3012/* Unpacks a column into an CoinIndexedvector
     3013 */
     3014void
     3015ClpPoolMatrix::unpack(const ClpSimplex * ,
     3016                      CoinIndexedVector * rowArray,
     3017                      int iColumn) const
     3018{
     3019  CoinBigIndex j = columnStart_[iColumn];
     3020  for (; j < columnStart_[iColumn+1]; j++) {
     3021    int iRow = stuff_[j].row_;
     3022    rowArray->add(iRow, elements_[stuff_[j].pool_]);
     3023  }
     3024}
     3025/* Unpacks a column into an CoinIndexedvector
     3026** in packed foramt
     3027Note that model is NOT const.  Bounds and objective could
     3028be modified if doing column generation (just for this variable) */
     3029void
     3030ClpPoolMatrix::unpackPacked(ClpSimplex * ,
     3031                            CoinIndexedVector * rowArray,
     3032                            int iColumn) const
     3033{
     3034  int * COIN_RESTRICT index = rowArray->getIndices();
     3035  double * COIN_RESTRICT array = rowArray->denseVector();
     3036  int number = 0;
     3037  CoinBigIndex j = columnStart_[iColumn];
     3038  for (; j < columnStart_[iColumn+1]; j++) {
     3039    int iRow = stuff_[j].row_;
     3040    array[number] = elements_[stuff_[j].pool_];
     3041    index[number++] = iRow;
     3042  }
     3043  rowArray->setNumElements(number);
     3044  rowArray->setPackedMode(true);
     3045}
     3046/* Adds multiple of a column into an CoinIndexedvector
     3047   You can use quickAdd to add to vector */
     3048void
     3049ClpPoolMatrix::add(const ClpSimplex * , CoinIndexedVector * rowArray,
     3050                   int iColumn, double multiplier) const
     3051{
     3052  CoinBigIndex j = columnStart_[iColumn];
     3053  for (; j < columnStart_[iColumn+1]; j++) {
     3054    int iRow = stuff_[j].row_;
     3055    rowArray->quickAdd(iRow, multiplier*elements_[stuff_[j].pool_]);
     3056  }
     3057}
     3058/* Adds multiple of a column into an array */
     3059void
     3060ClpPoolMatrix::add(const ClpSimplex * , double * array,
     3061                   int iColumn, double multiplier) const
     3062{
     3063  CoinBigIndex j = columnStart_[iColumn];
     3064  for (; j < columnStart_[iColumn+1]; j++) {
     3065    int iRow = stuff_[j].row_;
     3066    array[iRow] += multiplier*elements_[stuff_[j].pool_];
     3067  }
     3068}
     3069
     3070// Return a complete CoinPackedMatrix
     3071CoinPackedMatrix *
     3072ClpPoolMatrix::getPackedMatrix() const
     3073{
     3074  createMatrix();
     3075  return matrix_->matrix();
     3076}
     3077/* A vector containing the elements in the packed matrix. Note that there
     3078   might be gaps in this list, entries that do not belong to any
     3079   major-dimension vector. To get the actual elements one should look at
     3080   this vector together with vectorStarts and vectorLengths. */
     3081const double *
     3082ClpPoolMatrix::getElements() const
     3083{
     3084  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     3085  return createMatrix()->getElements();
     3086}
     3087
     3088/* A vector containing the minor indices of the elements in the packed
     3089   matrix. Note that there might be gaps in this list, entries that do not
     3090   belong to any major-dimension vector. To get the actual elements one
     3091   should look at this vector together with vectorStarts and
     3092   vectorLengths. */
     3093const int *
     3094ClpPoolMatrix::getIndices() const
     3095{
     3096  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     3097  return createMatrix()->getIndices();
     3098}
     3099const CoinBigIndex *
     3100ClpPoolMatrix::getVectorStarts() const
     3101{
     3102  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     3103  return createMatrix()->getVectorStarts();
     3104}
     3105/* The lengths of the major-dimension vectors. */
     3106const int *
     3107ClpPoolMatrix::getVectorLengths() const
     3108{
     3109#if 0
     3110  printf("XcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     3111  return createMatrix()->getVectorLengths();
     3112#else
     3113  if (!lengths_) {
     3114    lengths_ = new int[numberColumns_];
     3115    for (int i = 0; i < numberColumns_; i++)
     3116      lengths_[i]=static_cast<int>(columnStart_[i+1]-columnStart_[i]);
     3117  }
     3118  return lengths_;
     3119#endif
     3120}
     3121/* The length of a major-dimension vector. */
     3122int
     3123ClpPoolMatrix::getVectorLength(int index) const
     3124{
     3125  return static_cast<int>(columnStart_[index+1]-columnStart_[index]);
     3126}
     3127/* Delete the columns whose indices are listed in <code>indDel</code>. */
     3128void
     3129ClpPoolMatrix::deleteCols(const int numDel, const int * indDel)
     3130{
     3131  int iColumn;
     3132  CoinBigIndex newSize = columnStart_[numberColumns_];;
     3133  int numberBad = 0;
     3134  // Use array to make sure we can have duplicates
     3135  int * which = new int[numberColumns_];
     3136  memset(which, 0, numberColumns_ * sizeof(int));
     3137  int nDuplicate = 0;
     3138  for (iColumn = 0; iColumn < numDel; iColumn++) {
     3139    int jColumn = indDel[iColumn];
     3140    if (jColumn < 0 || jColumn >= numberColumns_) {
     3141      numberBad++;
     3142    } else {
     3143      newSize -= columnStart_[jColumn+1] - columnStart_[jColumn];
     3144      if (which[jColumn])
     3145        nDuplicate++;
     3146      else
     3147        which[jColumn] = 1;
     3148    }
     3149  }
     3150  if (numberBad)
     3151    throw CoinError("Indices out of range", "deleteCols", "ClpPoolMatrix");
     3152  int newNumber = numberColumns_ - numDel + nDuplicate;
     3153  // Get rid of temporary arrays
     3154  delete matrix_;
     3155  matrix_ = NULL;
     3156  CoinBigIndex * columnStart = new CoinBigIndex [newNumber+1];
     3157  poolInfo * stuff = new poolInfo [newSize];
     3158  newNumber = 0;
     3159  newSize = 0;
     3160  for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     3161    if (!which[iColumn]) {
     3162      CoinBigIndex start, end;
     3163      CoinBigIndex i;
     3164      start = columnStart_[iColumn];
     3165      end = columnStart_[iColumn+1];
     3166      columnStart[newNumber] = newSize;
     3167      for (i = start; i < end; i++)
     3168        stuff[newSize++] = stuff_[i];
     3169    }
     3170  }
     3171  columnStart[newNumber] = newSize;
     3172  delete [] which;
     3173  delete [] columnStart_;
     3174  columnStart_ = columnStart;
     3175  delete [] stuff_;
     3176  stuff_ = stuff;
     3177  numberColumns_ = newNumber;
     3178}
     3179/* Delete the rows whose indices are listed in <code>indDel</code>. */
     3180void
     3181ClpPoolMatrix::deleteRows(const int numDel, const int * indDel)
     3182{
     3183  int iRow;
     3184  int numberBad = 0;
     3185  // Use array to make sure we can have duplicates
     3186  int * which = new int[numberRows_];
     3187  memset(which, 0, numberRows_ * sizeof(int));
     3188  int nDuplicate = 0;
     3189  for (iRow = 0; iRow < numDel; iRow++) {
     3190    int jRow = indDel[iRow];
     3191    if (jRow < 0 || jRow >= numberRows_) {
     3192      numberBad++;
     3193    } else {
     3194      if (which[jRow])
     3195        nDuplicate++;
     3196      else
     3197        which[jRow] = 1;
     3198    }
     3199  }
     3200  if (numberBad)
     3201    throw CoinError("Indices out of range", "deleteRows", "ClpPoolMatrix");
     3202  CoinBigIndex iElement;
     3203  CoinBigIndex numberElements = columnStart_[numberColumns_];
     3204  CoinBigIndex newSize = 0;
     3205  for (iElement = 0; iElement < numberElements; iElement++) {
     3206    iRow = stuff_[iElement].row_;
     3207    if (!which[iRow])
     3208      newSize++;
     3209  }
     3210  int newNumber = numberRows_ - numDel + nDuplicate;
     3211  // Get rid of temporary arrays
     3212  delete matrix_;
     3213  matrix_ = NULL;
     3214  poolInfo * stuff = new poolInfo [newSize];
     3215  newSize = 0;
     3216  // redo which
     3217  int numberRows=0;
     3218  for (iRow = 0; iRow < numberRows_; iRow++) {
     3219    if (which[iRow]) {
     3220      which[iRow]=-1; // not wanted
     3221    } else {
     3222      which[iRow]=numberRows;
     3223      numberRows++;
     3224    }
     3225  }
     3226  int iColumn;
     3227  for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     3228    CoinBigIndex start, end;
     3229    CoinBigIndex i;
     3230    start = columnStart_[iColumn];
     3231    end = columnStart_[iColumn+1];
     3232    columnStart_[newNumber] = newSize;
     3233    for (i = start; i < end; i++) {
     3234      poolInfo newStuff=stuff_[i];
     3235      iRow = which[newStuff.row_];
     3236      if (iRow>=0) {
     3237        newStuff.row_=iRow;
     3238        stuff[newSize++] = newStuff;
     3239      }
     3240    }
     3241  }
     3242  columnStart_[numberColumns_] = newSize;
     3243  delete [] which;
     3244  delete [] stuff_;
     3245  stuff_ = stuff;
     3246  numberRows_ = newNumber;
     3247}
     3248bool
     3249ClpPoolMatrix::isColOrdered() const
     3250{
     3251  return true;
     3252}
     3253/* Number of entries in the packed matrix. */
     3254CoinBigIndex
     3255ClpPoolMatrix::getNumElements() const
     3256{
     3257  if (numberColumns_)
     3258    return columnStart_[numberColumns_];
     3259  else
     3260    return 0;
     3261}
     3262/* Returns largest and smallest elements of both signs.
     3263   Largest refers to largest absolute value.
     3264*/
     3265void
     3266ClpPoolMatrix::rangeOfElements(double & smallestNegative, double & largestNegative,
     3267                               double & smallestPositive, double & largestPositive)
     3268{
     3269  smallestNegative = -COIN_DBL_MAX;
     3270  largestNegative = 0.0;
     3271  smallestPositive = COIN_DBL_MAX;
     3272  largestPositive = 0.0;
     3273  for (int i = 0; i < numberDifferent_; i++) {
     3274    double value = elements_[i];
     3275    if (value > 0.0) {
     3276      smallestPositive = CoinMin(smallestPositive, value);
     3277      largestPositive = CoinMax(largestPositive, value);
     3278    } else if (value < 0.0) {
     3279      smallestNegative = CoinMax(smallestNegative, value);
     3280      largestNegative = CoinMin(largestNegative, value);
     3281    }
     3282  }
     3283}
     3284// Says whether it can do partial pricing
     3285bool
     3286ClpPoolMatrix::canDoPartialPricing() const
     3287{
     3288  return true;
     3289}
     3290// Partial pricing
     3291void
     3292ClpPoolMatrix::partialPricing(ClpSimplex * model, double startFraction, double endFraction,
     3293                              int & bestSequence, int & numberWanted)
     3294{
     3295  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     3296  createMatrix()->partialPricing(model,startFraction,
     3297                                 endFraction,bestSequence,
     3298                                 numberWanted);
     3299}
     3300// Allow any parts of a created CoinMatrix to be deleted
     3301void
     3302ClpPoolMatrix::releasePackedMatrix() const
     3303{
     3304  delete matrix_;
     3305  matrix_ = NULL;
     3306}
     3307// These have to match ClpPrimalColumnSteepest version
     3308#define reference(i)  (((reference[i>>5]>>(i&31))&1)!=0)
     3309/* Updates two arrays for steepest and does devex weights
     3310   Returns nonzero if updates reduced cost and infeas -
     3311   new infeas in dj1  - This does not at present*/
     3312int
     3313ClpPoolMatrix::transposeTimes2(const ClpSimplex * model,
     3314                               const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
     3315                               const CoinIndexedVector * pi2,
     3316                               CoinIndexedVector * spare,
     3317                               double * infeas, double * reducedCost,
     3318                               double referenceIn, double devex,
     3319                               // Array for exact devex to say what is in reference framework
     3320                               unsigned int * COIN_RESTRICT reference,
     3321                               double * COIN_RESTRICT weights, double scaleFactor)
     3322{
     3323#if 0
     3324  printf("CcreateMatrix at file %s line %d\n",__FILE__,__LINE__);
     3325  return createMatrix()->transposeTimes2(model,pi1,dj1,pi2,spare,
     3326                                         infeas,reducedCost,referenceIn,devex,
     3327                                         reference,weights,scaleFactor);
     3328#else
     3329  int returnCode=0;
     3330  // put row of tableau in dj1
     3331  double * COIN_RESTRICT pi = pi1->denseVector();
     3332  int numberNonZero = 0;
     3333  int * COIN_RESTRICT index = dj1->getIndices();
     3334  double * COIN_RESTRICT array = dj1->denseVector();
     3335  int numberInRowArray = pi1->getNumElements();
     3336  double zeroTolerance = model->zeroTolerance();
     3337  double dualTolerance = model->currentDualTolerance();
     3338  // we can't really trust infeasibilities if there is dual error
     3339  // this coding has to mimic coding in checkDualSolution
     3340  double error = CoinMin(1.0e-2, model->largestDualError());
     3341  // allow tolerance at least slightly bigger than standard
     3342  dualTolerance = dualTolerance +  error;
     3343  bool packed = pi1->packedMode();
     3344  assert (packed);
     3345  // do by column
     3346  int iColumn;
     3347  const double * COIN_RESTRICT rowScale = model->rowScale();
     3348  assert (!spare->getNumElements());
     3349  assert (numberColumns_ > 0);
     3350  double * COIN_RESTRICT piWeight = pi2->denseVector();
     3351  assert (!pi2->packedMode());
     3352  bool killDjs = (scaleFactor == 0.0);
     3353  if (!scaleFactor)
     3354    scaleFactor = 1.0;
     3355  // need to expand pi into y
     3356  assert(spare->capacity() >= model->numberRows());
     3357  double * COIN_RESTRICT piOld = pi;
     3358  pi = spare->denseVector();
     3359  const int * COIN_RESTRICT whichRow = pi1->getIndices();
     3360  int i;
     3361  if (!rowScale) {
     3362    // modify pi so can collapse to one loop
     3363    for (i = 0; i < numberInRowArray; i++) {
     3364      int iRow = whichRow[i];
     3365      pi[iRow] = piOld[i];
     3366    }
     3367    if (infeas)
     3368      returnCode=1;
     3369    CoinBigIndex j;
     3370    CoinBigIndex end = columnStart_[0];
     3371    for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     3372      CoinBigIndex start = end;
     3373      end = columnStart_[iColumn+1];
     3374      ClpSimplex::Status status = model->getStatus(iColumn);
     3375      if (status == ClpSimplex::basic || status == ClpSimplex::isFixed) continue;
     3376      double value = 0.0;
     3377      for (j = start; j < end; j++) {
     3378        int iRow = stuff_[j].row_;
     3379        value -= pi[iRow]*elements_[stuff_[j].pool_];
     3380      }
     3381      if (fabs(value) > zeroTolerance) {
     3382        // and do other array
     3383        double modification = 0.0;
     3384        for (j = start; j < end; j++) {
     3385          int iRow = stuff_[j].row_;
     3386          modification += piWeight[iRow]*elements_[stuff_[j].pool_];
     3387        }
     3388        double thisWeight = weights[iColumn];
     3389        double pivot = value * scaleFactor;
     3390        double pivotSquared = pivot * pivot;
     3391        thisWeight += pivotSquared * devex + pivot * modification;
     3392        if (thisWeight < DEVEX_TRY_NORM) {
     3393          if (referenceIn < 0.0) {
     3394            // steepest
     3395            thisWeight = CoinMax(DEVEX_TRY_NORM, DEVEX_ADD_ONE + pivotSquared);
     3396          } else {
     3397            // exact
     3398            thisWeight = referenceIn * pivotSquared;
     3399            if (reference(iColumn))
     3400              thisWeight += 1.0;
     3401            thisWeight = CoinMax(thisWeight, DEVEX_TRY_NORM);
     3402          }
     3403        }
     3404        weights[iColumn] = thisWeight;
     3405        if (!killDjs) {
     3406          value = reducedCost[iColumn]-value;
     3407          reducedCost[iColumn] = value;
     3408          // simplify status
     3409          ClpSimplex::Status status = model->getStatus(iColumn);
     3410         
     3411          switch(status) {
     3412           
     3413          case ClpSimplex::basic:
     3414          case ClpSimplex::isFixed:
     3415            break;
     3416          case ClpSimplex::isFree:
     3417          case ClpSimplex::superBasic:
     3418            if (fabs(value) > FREE_ACCEPT * dualTolerance) {
     3419              // we are going to bias towards free (but only if reasonable)
     3420              value *= FREE_BIAS;
     3421              value *= value;
     3422              // store square in list
     3423              if (infeas[iColumn]) {
     3424                infeas[iColumn] = value; // already there
     3425              } else {
     3426                array[numberNonZero]=value;
     3427                index[numberNonZero++]=iColumn;
     3428              }
     3429            } else {
     3430              array[numberNonZero]=0.0;
     3431              index[numberNonZero++]=iColumn;
     3432            }
     3433            break;
     3434          case ClpSimplex::atUpperBound:
     3435            if (value > dualTolerance) {
     3436              value *= value;
     3437              // store square in list
     3438              if (infeas[iColumn]) {
     3439                infeas[iColumn] = value; // already there
     3440              } else {
     3441                array[numberNonZero]=value;
     3442                index[numberNonZero++]=iColumn;
     3443              }
     3444            } else {
     3445              array[numberNonZero]=0.0;
     3446              index[numberNonZero++]=iColumn;
     3447            }
     3448            break;
     3449          case ClpSimplex::atLowerBound:
     3450            if (value < -dualTolerance) {
     3451              value *= value;
     3452              // store square in list
     3453              if (infeas[iColumn]) {
     3454                infeas[iColumn] = value; // already there
     3455              } else {
     3456                array[numberNonZero]=value;
     3457                index[numberNonZero++]=iColumn;
     3458              }
     3459            } else {
     3460              array[numberNonZero]=0.0;
     3461              index[numberNonZero++]=iColumn;
     3462            }
     3463          }
     3464        }
     3465      }
     3466    }
     3467  } else {
     3468    // scaled
     3469    // modify pi so can collapse to one loop
     3470    for (i = 0; i < numberInRowArray; i++) {
     3471      int iRow = whichRow[i];
     3472      pi[iRow] = piOld[i] * rowScale[iRow];
     3473    }
     3474    // can also scale piWeight as not used again
     3475    int numberWeight = pi2->getNumElements();
     3476    const int * indexWeight = pi2->getIndices();
     3477    for (i = 0; i < numberWeight; i++) {
     3478      int iRow = indexWeight[i];
     3479      piWeight[iRow] *= rowScale[iRow];
     3480    }
     3481    if (infeas)
     3482      returnCode=1;
     3483    const double * COIN_RESTRICT columnScale = model->columnScale();
     3484    CoinBigIndex j;
     3485    CoinBigIndex end = columnStart_[0];
     3486    for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     3487      CoinBigIndex start = end;
     3488      end = columnStart_[iColumn+1];
     3489      ClpSimplex::Status status = model->getStatus(iColumn);
     3490      if (status == ClpSimplex::basic || status == ClpSimplex::isFixed) continue;
     3491      double scale = columnScale[iColumn];
     3492      double value = 0.0;
     3493      for (j = start; j < end; j++) {
     3494        int iRow = stuff_[j].row_;
     3495        value -= pi[iRow]*elements_[stuff_[j].pool_];
     3496      }
     3497      value *= scale;
     3498      if (fabs(value) > zeroTolerance) {
     3499        double modification = 0.0;
     3500        for (j = start; j < end; j++) {
     3501          int iRow = stuff_[j].row_;
     3502          modification += piWeight[iRow]*elements_[stuff_[j].pool_];
     3503        }
     3504        modification *= scale;
     3505        double thisWeight = weights[iColumn];
     3506        double pivot = value * scaleFactor;
     3507        double pivotSquared = pivot * pivot;
     3508        thisWeight += pivotSquared * devex + pivot * modification;
     3509        if (thisWeight < DEVEX_TRY_NORM) {
     3510          if (referenceIn < 0.0) {
     3511            // steepest
     3512            thisWeight = CoinMax(DEVEX_TRY_NORM, DEVEX_ADD_ONE + pivotSquared);
     3513          } else {
     3514            // exact
     3515            thisWeight = referenceIn * pivotSquared;
     3516            if (reference(iColumn))
     3517              thisWeight += 1.0;
     3518            thisWeight = CoinMax(thisWeight, DEVEX_TRY_NORM);
     3519          }
     3520        }
     3521        weights[iColumn] = thisWeight;
     3522        if (!killDjs) {
     3523          value = reducedCost[iColumn]-value;
     3524          reducedCost[iColumn] = value;
     3525          // simplify status
     3526          ClpSimplex::Status status = model->getStatus(iColumn);
     3527         
     3528          switch(status) {
     3529           
     3530          case ClpSimplex::basic:
     3531          case ClpSimplex::isFixed:
     3532            break;
     3533          case ClpSimplex::isFree:
     3534          case ClpSimplex::superBasic:
     3535            if (fabs(value) > FREE_ACCEPT * dualTolerance) {
     3536              // we are going to bias towards free (but only if reasonable)
     3537              value *= FREE_BIAS;
     3538              value *= value;
     3539              // store square in list
     3540              if (infeas[iColumn]) {
     3541                infeas[iColumn] = value; // already there
     3542              } else {
     3543                array[numberNonZero]=value;
     3544                index[numberNonZero++]=iColumn;
     3545              }
     3546            } else {
     3547              array[numberNonZero]=0.0;
     3548              index[numberNonZero++]=iColumn;
     3549            }
     3550            break;
     3551          case ClpSimplex::atUpperBound:
     3552            if (value > dualTolerance) {
     3553              value *= value;
     3554              // store square in list
     3555              if (infeas[iColumn]) {
     3556                infeas[iColumn] = value; // already there
     3557              } else {
     3558                array[numberNonZero]=value;
     3559                index[numberNonZero++]=iColumn;
     3560              }
     3561            } else {
     3562              array[numberNonZero]=0.0;
     3563              index[numberNonZero++]=iColumn;
     3564            }
     3565            break;
     3566          case ClpSimplex::atLowerBound:
     3567            if (value < -dualTolerance) {
     3568              value *= value;
     3569              // store square in list
     3570              if (infeas[iColumn]) {
     3571                infeas[iColumn] = value; // already there
     3572              } else {
     3573                array[numberNonZero]=value;
     3574                index[numberNonZero++]=iColumn;
     3575              }
     3576            } else {
     3577              array[numberNonZero]=0.0;
     3578              index[numberNonZero++]=iColumn;
     3579            }
     3580          }
     3581        }
     3582      }
     3583    }
     3584  }
     3585  // zero out
     3586  int numberRows = model->numberRows();
     3587  if (numberInRowArray * 4 < numberRows) {
     3588    for (i = 0; i < numberInRowArray; i++) {
     3589      int iRow = whichRow[i];
     3590      pi[iRow] = 0.0;
     3591    }
     3592  } else {
     3593    CoinZeroN(pi, numberRows);
     3594  }
     3595  dj1->setNumElements(numberNonZero);
     3596  spare->setNumElements(0);
     3597  if (packed)
     3598    dj1->setPackedMode(true);
     3599  return returnCode;
     3600#endif
     3601}
     3602// Updates second array for steepest and does devex weights
     3603void
     3604ClpPoolMatrix::subsetTimes2(const ClpSimplex * model,
     3605                            CoinIndexedVector * dj1,
     3606                            const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     3607                            double referenceIn, double devex,
     3608                            // Array for exact devex to say what is in reference framework
     3609                            unsigned int * COIN_RESTRICT reference,
     3610                            double * COIN_RESTRICT weights, double scaleFactor)
     3611{
     3612  printf("createMatrix at file %s line %d\n",__FILE__,__LINE__);
     3613  createMatrix()->subsetTimes2(model,dj1,pi2,dj2,
     3614                               referenceIn,devex,
     3615                               reference,weights,scaleFactor);
     3616}
     3617/* Set the dimensions of the matrix. In effect, append new empty
     3618   columns/rows to the matrix. A negative number for either dimension
     3619   means that that dimension doesn't change. Otherwise the new dimensions
     3620   MUST be at least as large as the current ones otherwise an exception
     3621   is thrown. */
     3622void
     3623ClpPoolMatrix::setDimensions(int newnumrows, int newnumcols)
     3624{
     3625  // at present abort
     3626  abort();
     3627}
     3628#endif
  • trunk/Clp/src/ClpPlusMinusOneMatrix.hpp

    r2235 r2271  
    7878     virtual ClpMatrixBase * reverseOrderedCopy() const;
    7979     /// Returns number of elements in column part of basis
    80      virtual CoinBigIndex countBasis(
     80     virtual int countBasis(
    8181          const int * whichColumn,
    8282          int & numberColumnBasic);
     
    290290     //@}
    291291};
    292 
     292#if CLP_POOL_MATRIX
     293/** This implements a matrix with few different coefficients
     294    as derived from ClpMatrixBase.  This version only up to 65K rows
     295*/
     296#define CLP_POOL_SIZE 32-CLP_POOL_MATRIX
     297#if CLP_POOL_MATRIX==16
     298typedef struct {
     299  unsigned short row_;
     300  unsigned short pool_;
     301} poolInfo;
     302#else
     303typedef struct {
     304unsigned int row_:CLP_POOL_MATRIX;
     305unsigned short pool_:CLP_POOL_SIZE;
     306} poolInfo;
    293307#endif
     308#include "ClpPackedMatrix.hpp"
     309class ClpPoolMatrix : public ClpMatrixBase {
     310
     311public:
     312     /**@name Useful methods */
     313     //@{
     314     /// Return a complete CoinPackedMatrix
     315     virtual CoinPackedMatrix * getPackedMatrix() const;
     316     /** Whether the packed matrix is column major ordered or not. */
     317     virtual bool isColOrdered() const ;
     318     /** Number of entries in the packed matrix. */
     319     virtual  CoinBigIndex getNumElements() const;
     320     /** Number of different entries in the packed matrix. */
     321     inline int getNumDifferentElements() const
     322     { return numberDifferent_;}
     323     /** Number of columns. */
     324     virtual int getNumCols() const {
     325          return numberColumns_;
     326     }
     327     /** Number of rows. */
     328     virtual int getNumRows() const {
     329          return numberRows_;
     330     }
     331
     332     /** A vector containing the elements in the packed matrix. Note that there
     333      might be gaps in this list, entries that do not belong to any
     334      major-dimension vector. To get the actual elements one should look at
     335      this vector together with vectorStarts and vectorLengths. */
     336     virtual const double * getElements() const;
     337     /** A vector containing the minor indices of the elements in the packed
     338          matrix. Note that there might be gaps in this list, entries that do not
     339          belong to any major-dimension vector. To get the actual elements one
     340          should look at this vector together with vectorStarts and
     341          vectorLengths. */
     342     virtual const int * getIndices() const;
     343     // and for advanced use
     344     int * getMutableIndices() const;
     345     
     346     virtual const CoinBigIndex * getVectorStarts() const;
     347     /** The lengths of the major-dimension vectors. */
     348     virtual const int * getVectorLengths() const;
     349     /** The length of a major-dimension vector. */
     350     virtual int getVectorLength(int index) const;
     351     /** Delete the columns whose indices are listed in <code>indDel</code>. */
     352     virtual void deleteCols(const int numDel, const int * indDel);
     353     /** Delete the rows whose indices are listed in <code>indDel</code>. */
     354     virtual void deleteRows(const int numDel, const int * indDel);
     355     /** Returns a new matrix in reverse order without gaps */
     356     virtual ClpMatrixBase * reverseOrderedCopy() const;
     357     /// Returns number of elements in column part of basis
     358     virtual int countBasis(
     359          const int * whichColumn,
     360          int & numberColumnBasic);
     361     /// Fills in column part of basis
     362     virtual void fillBasis(ClpSimplex * model,
     363                            const int * whichColumn,
     364                            int & numberColumnBasic,
     365                            int * row, int * start,
     366                            int * rowCount, int * columnCount,
     367                            CoinFactorizationDouble * element);
     368     /** Returns largest and smallest elements of both signs.
     369         Largest refers to largest absolute value.
     370     */
     371     virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
     372                                  double & smallestPositive, double & largestPositive);
     373     /** Unpacks a column into an CoinIndexedvector
     374      */
     375     virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
     376                         int column) const ;
     377     /** Unpacks a column into an CoinIndexedvector
     378      ** in packed foramt
     379         Note that model is NOT const.  Bounds and objective could
     380         be modified if doing column generation (just for this variable) */
     381     virtual void unpackPacked(ClpSimplex * model,
     382                               CoinIndexedVector * rowArray,
     383                               int column) const;
     384     /** Adds multiple of a column into an CoinIndexedvector
     385         You can use quickAdd to add to vector */
     386     virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
     387                      int column, double multiplier) const ;
     388     /** Adds multiple of a column into an array */
     389     virtual void add(const ClpSimplex * model, double * array,
     390                      int column, double multiplier) const;
     391     /// Allow any parts of a created CoinMatrix to be deleted
     392     virtual void releasePackedMatrix() const;
     393     /** Set the dimensions of the matrix. In effect, append new empty
     394         columns/rows to the matrix. A negative number for either dimension
     395         means that that dimension doesn't change. Otherwise the new dimensions
     396         MUST be at least as large as the current ones otherwise an exception
     397         is thrown. */
     398     virtual void setDimensions(int numrows, int numcols);
     399     /// Just checks matrix valid - will say if dimensions not quite right if detail
     400     void checkValid(bool detail) const;
     401     //@}
     402
     403     /**@name Matrix times vector methods */
     404     //@{
     405     /** Return <code>y + A * scalar *x</code> in <code>y</code>.
     406         @pre <code>x</code> must be of size <code>numColumns()</code>
     407         @pre <code>y</code> must be of size <code>numRows()</code> */
     408     virtual void times(double scalar,
     409                        const double * x, double * y) const;
     410     /// And for scaling
     411     virtual void times(double scalar,
     412                        const double * x, double * y,
     413                        const double * rowScale,
     414                        const double * columnScale) const;
     415     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
     416         @pre <code>x</code> must be of size <code>numRows()</code>
     417         @pre <code>y</code> must be of size <code>numColumns()</code> */
     418     virtual void transposeTimes(double scalar,
     419                                 const double * x, double * y) const;
     420     /// And for scaling
     421     virtual void transposeTimes(double scalar,
     422                                 const double * x, double * y,
     423                                 const double * rowScale,
     424                                 const double * columnScale, double * spare = NULL) const;
     425     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
     426     Can use y as temporary array (will be empty at end)
     427     Note - If x packed mode - then z packed mode
     428     Squashes small elements and knows about ClpSimplex */
     429     virtual void transposeTimes(const ClpSimplex * model, double scalar,
     430                                 const CoinIndexedVector * x,
     431                                 CoinIndexedVector * y,
     432                                 CoinIndexedVector * z) const;
     433     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
     434     Can use y as temporary array (will be empty at end)
     435     Note - If x packed mode - then z packed mode
     436     Squashes small elements and knows about ClpSimplex.
     437     This version uses row copy*/
     438     virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
     439                                      const CoinIndexedVector * x,
     440                                      CoinIndexedVector * y,
     441                                      CoinIndexedVector * z) const;
     442     /** Return <code>x *A</code> in <code>z</code> but
     443     just for indices in y.
     444     Note - z always packed mode */
     445     virtual void subsetTransposeTimes(const ClpSimplex * model,
     446                                       const CoinIndexedVector * x,
     447                                       const CoinIndexedVector * y,
     448                                       CoinIndexedVector * z) const;
     449     /** Returns true if can combine transposeTimes and subsetTransposeTimes
     450         and if it would be faster */
     451     virtual bool canCombine(const ClpSimplex * model,
     452                             const CoinIndexedVector * pi) const
     453     { return true;}
     454     /** Updates two arrays for steepest and does devex weights
     455         Returns nonzero if updates reduced cost and infeas -
     456         new infeas in dj1 */
     457     virtual int transposeTimes2(const ClpSimplex * model,
     458                                 const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
     459                                 const CoinIndexedVector * pi2,
     460                                 CoinIndexedVector * spare,
     461                                 double * infeas, double * reducedCost,
     462                                  double referenceIn, double devex,
     463                                  // Array for exact devex to say what is in reference framework
     464                                  unsigned int * reference,
     465                                  double * weights, double scaleFactor);
     466     /// Updates second array for steepest and does devex weights
     467     virtual void subsetTimes2(const ClpSimplex * model,
     468                               CoinIndexedVector * dj1,
     469                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     470                               double referenceIn, double devex,
     471                               // Array for exact devex to say what is in reference framework
     472                               unsigned int * reference,
     473                               double * weights, double scaleFactor);
     474     //@}
     475
     476     /**@name Other */
     477     //@{
     478     /// Return column starts
     479     inline CoinBigIndex * columnStart() const {
     480          return columnStart_;
     481     }
     482     //@}
     483
     484
     485     /**@name Constructors, destructor */
     486     //@{
     487     /** Default constructor. */
     488     ClpPoolMatrix();
     489     /** Destructor */
     490     virtual ~ClpPoolMatrix();
     491     //@}
     492
     493     /**@name Copy method */
     494     //@{
     495     /** The copy constructor. */
     496     ClpPoolMatrix(const ClpPoolMatrix&);
     497     /** The copy constructor from an CoinPoolMatrix.
     498     */
     499     ClpPoolMatrix(const CoinPackedMatrix&);
     500     /// Constructor from arrays
     501     ClpPoolMatrix(int numberRows, int numberColumns,
     502                   const int * indices, const double * elements,
     503                           const CoinBigIndex * columnStart);
     504     /// Constructor from arrays - handing over ownership
     505     ClpPoolMatrix(int numberColumns,CoinBigIndex * columnStart,
     506                   poolInfo * stuff, double * elements);
     507     /** Subset constructor (without gaps).  Duplicates are allowed
     508         and order is as given */
     509     ClpPoolMatrix (const ClpPoolMatrix & wholeModel,
     510                            int numberRows, const int * whichRows,
     511                            int numberColumns, const int * whichColumns);
     512
     513     ClpPoolMatrix& operator=(const ClpPoolMatrix&);
     514     /// Clone
     515     virtual ClpMatrixBase * clone() const ;
     516     /** Subset clone (without gaps).  Duplicates are allowed
     517         and order is as given */
     518     virtual ClpMatrixBase * subsetClone (
     519          int numberRows, const int * whichRows,
     520          int numberColumns, const int * whichColumns) const ;
     521     /// Says whether it can do partial pricing
     522     virtual bool canDoPartialPricing() const;
     523     /// Partial pricing
     524     virtual void partialPricing(ClpSimplex * model, double start, double end,
     525                                 int & bestSequence, int & numberWanted);
     526     //@}
     527
     528
     529protected:
     530     /// Create matrix_
     531     ClpPackedMatrix * createMatrix() const;
     532     /**@name Data members
     533        The data members are protected to allow access for derived classes. */
     534     //@{
     535     /// For fake ClpPackedMatrix
     536     mutable ClpPackedMatrix * matrix_;
     537     mutable int * lengths_;
     538     /// Unique values
     539     double * COIN_RESTRICT elements_;
     540     /// Column starts
     541     CoinBigIndex * COIN_RESTRICT columnStart_;
     542     /// Rows and values
     543     poolInfo * COIN_RESTRICT stuff_;
     544     /// Number of rows
     545     int numberRows_;
     546     /// Number of columns
     547     int numberColumns_;
     548     /// Number of different elements
     549     int numberDifferent_;
     550
     551     //@}
     552};
     553#endif
     554#endif
  • trunk/Clp/src/ClpPresolve.cpp

    r2259 r2271  
    168168    return 0;
    169169  } else {
    170     int presolveStatus = - nelems_;
     170    int presolveStatus = - static_cast<int>(nelems_);
    171171    // If both infeasible and unbounded - say infeasible
    172172    if (presolveStatus>2)
     
    822822          clo[icol]=lowerX;
    823823          cup[icol]=upperX;
    824           int startCol[2];
    825           int endCol[2];
     824          CoinBigIndex startCol[2];
     825          CoinBigIndex endCol[2];
    826826          startCol[0]=mcstrt[icol];
    827827          endCol[0]=startCol[0]+2;
     
    14451445          CoinBigIndex *mcstrt          = prob.mcstrt_;
    14461446          int *hincol           = prob.hincol_;
    1447           int *link             = prob.link_;
     1447          CoinBigIndex *link            = prob.link_;
    14481448          int ncols             = prob.ncols_;
    14491449
     
    17671767     presolveOptions_(0)
    17681768{
    1769      const int bufsize = bulk0_;
     1769     const CoinBigIndex bufsize = bulk0_;
    17701770
    17711771     nrows_ = si->getNumRows() ;
     
    18001800          }
    18011801          mcstrt_[icol+1] = nel;
    1802           hincol_[icol] = nel - mcstrt_[icol];
     1802          hincol_[icol] = static_cast<int>(nel - mcstrt_[icol]);
    18031803     }
    18041804
     
    18491849               start = mrstrt_[irow+1];
    18501850               mrstrt_[irow+1] = nel;
    1851                hinrow_[irow] = nel - mrstrt_[irow];
     1851               hinrow_[irow] = static_cast<int>(nel - mrstrt_[irow]);
    18521852          }
    18531853     }
     
    18731873          anyProhibited_ = true;
    18741874          for (icol = 0; icol < ncols_; icol++) {
    1875                int j;
     1875               CoinBigIndex j;
    18761876               bool nonLinearColumn = false;
    18771877               if (cost_[icol] == nonLinearValue)
     
    20292029     // link, free_list, maxlink
    20302030     maxlink_(bulk0_),
    2031      link_(new int[/*maxlink*/ bulk0_]),
     2031     link_(new CoinBigIndex[/*maxlink*/ bulk0_]),
    20322032
    20332033     cdone_(new char[ncols0_]),
     
    21402140     }
    21412141     {
    2142           int ml = maxlink_;
     2142          CoinBigIndex ml = maxlink_;
    21432143          for (CoinBigIndex k = nelemsr; k < ml; ++k)
    21442144               link_[k] = k + 1;
     
    22802280               for (colx = 0; colx < ncols; ++colx) {
    22812281                    double solutionValue = csol[colx];
    2282                     for (int i = mcstrt[colx]; i < mcstrt[colx] + hincol[colx]; ++i) {
     2282                    for (CoinBigIndex i = mcstrt[colx]; i < mcstrt[colx] + hincol[colx]; ++i) {
    22832283                         int row = hrow[i];
    22842284                         double coeff = colels[i];
  • trunk/Clp/src/ClpSimplex.cpp

    r2259 r2271  
    72067206          length = 0;
    72077207          for (i = 0; i < numberColumns_; i++) {
    7208                int start = starts[i];
     7208               CoinBigIndex start = starts[i];
    72097209               starts[i] = length;
    72107210               for (CoinBigIndex j = start; j < start + lengths[i]; j++) {
     
    72127212                    indices[length++] = indices[j];
    72137213               }
    7214                lengths[i] = length - starts[i];
     7214               lengths[i] = static_cast<int>(length - starts[i]);
    72157215          }
    72167216          starts[numberColumns_] = length;
     
    75187518}
    75197519#ifndef SLIM_NOIO
     7520#if COIN_BIG_INDEX==0
    75207521// This loads a model from a coinModel object - returns number of errors
    75217522int
     
    75597560     return returnCode;
    75607561}
     7562#endif
    75617563#endif
    75627564void
     
    82578259                              if (getRowStatus(iRow) == basic) {
    82588260                                   // see if we can find a column to pivot on
    8259                                    int j;
     8261                                   CoinBigIndex j;
    82608262                                   // down is amount pi can go down
    82618263                                   double maximumDown = COIN_DBL_MAX;
  • trunk/Clp/src/ClpSimplex.hpp

    r2259 r2271  
    7777#define SHORT_REGION 2
    7878#endif
     79// for now keep simple
     80#undef LONG_REGION_2
     81#undef SHORT_REGION
     82#define SHORT_REGION 2
    7983#else
    8084//ABC_INHERIT
     
    12851289         131072 bit (*3) initial stateDualColumn
    12861290         524288 bit - stop when primal feasible
     1291         1048576 bit - stop when primal feasible after n-1000000 iterations
    12871292     */
    12881293     inline int moreSpecialOptions() const {
  • trunk/Clp/src/ClpSimplexNonlinear.cpp

    r2235 r2271  
    27512751    int iPass;
    27522752   
    2753     const int * start = this->clpMatrix()->getVectorStarts();
     2753    const CoinBigIndex * start = this->clpMatrix()->getVectorStarts();
    27542754    const int * length = this->clpMatrix()->getVectorLengths();
    27552755    const int * row = this->clpMatrix()->getIndices();
     
    37343734          numberArtificials *= SEGMENTS;
    37353735          numberColumns2 += numberArtificials;
    3736           int * addStarts = new int [numberArtificials+1];
     3736          CoinBigIndex * addStarts = new CoinBigIndex [numberArtificials+1];
    37373737          int * addRow = new int[numberArtificials];
    37383738          double * addElement = new double[numberArtificials];
  • trunk/Clp/src/ClpSimplexOther.cpp

    r2235 r2271  
    15131513               tightenBounds = false;
    15141514
    1515           int numberElements = getNumElements();
    1516           int numberElements2 = small->getNumElements();
     1515          CoinBigIndex numberElements = getNumElements();
     1516          CoinBigIndex numberElements2 = small->getNumElements();
    15171517          small->setObjectiveOffset(objectiveOffset() - offset);
    15181518          handler_->message(CLP_CRUNCH_STATS, messages_)
     
    59005900  for (iRow = 0 ; iRow < numberRows ; iRow++) {
    59015901    double sumFixed=0.0;
    5902     for (int j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
     5902    for (CoinBigIndex j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
    59035903      int iColumn = column[j];
    59045904      double value = columnLower[iColumn];
     
    59135913    double sumFixed=0.0;
    59145914    double gap = fixedRow[iRow]-1.0e-12;
    5915     for (int j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
     5915    for (CoinBigIndex j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
    59165916      int iColumn = column[j];
    59175917      if (columnIsGub[iColumn]!=-2) {
     
    59395939        smallestGubRow=iRow;
    59405940      }
    5941       for (int j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
     5941      for (CoinBigIndex j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
    59425942        int iColumn = column[j];
    59435943        if (columnIsGub[iColumn]!=-2)
     
    59755975      rowIsGub[smallestGubRow]=-1;
    59765976      whichRows[numberNonGub++] = smallestGubRow;
    5977       for (int j = rowStart[smallestGubRow];
     5977      for (CoinBigIndex j = rowStart[smallestGubRow];
    59785978           j < rowStart[smallestGubRow] + rowLength[smallestGubRow]; j++) {
    59795979        int iColumn = column[j];
     
    60006000        whichColumns[put2++] = iColumn;
    60016001        double value = columnLower[iColumn];
    6002         for (int j = columnStart[iColumn];
     6002        for (CoinBigIndex j = columnStart[iColumn];
    60036003             j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    60046004          int iRow = row[j];
     
    60206020        double largest = 1.0e-30;
    60216021        double smallest = 1.0e30;
    6022         for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
     6022        for (CoinBigIndex j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
    60236023          int iColumn = column[j];
    60246024          if (columnIsGub[iColumn]!=-2) {
     
    60446044      double * element = matrix->getMutableElements();
    60456045      for (int i=0;i<numberNormal;i++) {
    6046         for (int j = columnStart[i];
     6046        for (CoinBigIndex j = columnStart[i];
    60476047             j < columnStart[i] + columnLength[i]; j++) {
    60486048          int iRow = row[j];
     
    61046104    double * upperColumn2 = new double [numberGubColumnsPlus];
    61056105    CoinFillN(upperColumn2, numberGubColumnsPlus, COIN_DBL_MAX);
    6106     int * start2 = new int[numberGubColumnsPlus+1];
     6106    CoinBigIndex * start2 = new CoinBigIndex[numberGubColumnsPlus+1];
    61076107    int * row2 = new int[numberElements];
    61086108    double * element2 = new double[numberElements];
     
    61486148        upperColumn2[i] = columnUpper[iColumn];
    61496149        upperColumn2[i] = COIN_DBL_MAX;
    6150         for (int j = columnStart[iColumn]; j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     6150        for (CoinBigIndex j = columnStart[iColumn]; j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    61516151          int iRow = row[j];
    61526152          double scaleBy = scaleArray[iRow];
     
    65936593      int chosen=-1;
    65946594      for (int j=startSet[i];j<startSet[i+1];j++) {
    6595         int length=columnStart[j+1]-columnStart[j];
     6595        int length=static_cast<int>(columnStart[j+1]-columnStart[j]);
    65966596        int iOrig = whichColumns[j+numberNormal];
    65976597        double value;
     
    69276927        }
    69286928      }
    6929       int numberElements = matrix->getNumElements();
     6929      CoinBigIndex numberElements = matrix->getNumElements();
    69306930      assert (numberElements==columnStart[numberColumns_]);
    69316931      if (needed>0) {
     
    70167016        delete rowVector;
    70177017      for (int i=0;i<numberColumns_;i++) {
    7018         columnLength[i]=columnStart[i+1]-columnStart[i];
     7018        columnLength[i]=static_cast<int>(columnStart[i+1]-columnStart[i]);
    70197019      }
    70207020    }
     
    79227922        char line[520],temp[50];
    79237923#endif
    7924         int ishift = rowStart[iLast] - start;
     7924        CoinBigIndex ishift = rowStart[iLast] - start;
    79257925        CoinBigIndex k;
    79267926#ifdef PRINT_DUP
     
    84388438{
    84398439  char * put = where.putStuff;
    8440   int n = numberElements*static_cast<int>(sizeof(int)+sizeof(double))+static_cast<int>(sizeInfo);
     8440  CoinBigIndex n = numberElements*static_cast<int>(sizeof(int)+sizeof(double))+static_cast<int>(sizeInfo);
    84418441  if (n+(put-where.startStuff)>where.maxStuff) {
    84428442    where.maxStuff += CoinMax(where.maxStuff/2 + 10000, 2*n);
     
    85888588    // replace length (may mean copying uninitialized)
    85898589    columnLength[iColumn]=lengthNeeded;
    8590     int spare = (2*lastElement-put-(lengthNeeded-length)-numberElementsOriginal)/numberColumns;
     8590    CoinBigIndex spare = (2*lastElement-put-(lengthNeeded-length)-numberElementsOriginal)/numberColumns;
    85918591    assert (spare>=0);
    85928592    // copy back
     
    86698669  int numberTotal=numberRows_+numberColumns_;
    86708670  CoinBigIndex lastElement = matrix_->getNumElements();
    8671   int maxInfoStuff = 5*lastElement*static_cast<int>(sizeof(double))+numberTotal*static_cast<int>(sizeof(clpPresolveInfo2));
     8671  CoinBigIndex maxInfoStuff = 5*lastElement*static_cast<int>(sizeof(double))+numberTotal*static_cast<int>(sizeof(clpPresolveInfo2));
    86728672  clpPresolveInfo * infoA = new clpPresolveInfo[numberTotal];
    86738673  char * startStuff = new char [maxInfoStuff];
     
    87818781        double solValue=columnLower[iColumn];
    87828782        if (solValue) {
    8783           for (int j=start;j<start+length;j++) {
     8783          for (CoinBigIndex j=start;j<start+length;j++) {
    87848784            int iRow=row[j];
    87858785            double value = element[j]*solValue;
     
    88048804      }
    88058805    }
    8806     columnLength[iColumn]=put-columnStart[iColumn];
     8806    columnLength[iColumn]=static_cast<int>(put-columnStart[iColumn]);
    88078807  }
    88088808  int numberInitial=nActions;
     
    90059005        int n=0;
    90069006        start = columnStart[iColumn1];
    9007         for (int i=start;i<start+columnLength[iColumn1];
     9007        for (CoinBigIndex i=start;i<start+columnLength[iColumn1];
    90089008             i++) {
    90099009          int jRow=row[i];
     
    90159015        rowLength[iRow]=0;
    90169016        start = columnStart[iColumn2];
    9017         for (int i=start;i<start+columnLength[iColumn2];
     9017        for (CoinBigIndex i=start;i<start+columnLength[iColumn2];
    90189018             i++) {
    90199019          int jRow=row[i];
     
    90529052              }
    90539053            }
    9054             int numberElements = put-lastElement;
     9054            CoinBigIndex numberElements = put-lastElement;
    90559055            columnStart[numberColumns_]=numberElements;
    90569056            memcpy(row,row+lastElement,numberElements*sizeof(int));
     
    90839083          }
    90849084          // take out of row copy
    9085           int startR = rowStart[jRow];
    9086           int putR=startR;
    9087           for (int i=startR;i<startR+rowLength[jRow];i++) {
     9085          CoinBigIndex startR = rowStart[jRow];
     9086          CoinBigIndex putR=startR;
     9087          for (CoinBigIndex i=startR;i<startR+rowLength[jRow];i++) {
    90889088            int iColumn = column[i];
    90899089            if (iColumn!=iColumn1&&iColumn!=iColumn2) {
     
    90969096            }
    90979097          }
    9098           int rowLength2=putR-startR;
     9098          int rowLength2=static_cast<int>(putR-startR);
    90999099#ifndef CLP_NO_SUBS
    91009100          if (rowLength2<=1&&rowLength[jRow]>1&&jRow<iRow) {
     
    91109110          rowLength[jRow]=rowLength2;
    91119111        }
    9112         columnLength[iColumn1]=put-start;
     9112        columnLength[iColumn1]=static_cast<int>(put-start);
    91139113        lastElement=CoinMax(lastElement,put);
    91149114#endif
     
    92759275        }
    92769276      }
    9277       int put=start;
     9277      CoinBigIndex put=start;
    92789278      int iFlag=0;
    92799279      int nonFree=0;
     
    93919391      }
    93929392      double cost = objective[iColumn]*optimizationDirection_;
    9393       int length = put-columnStart[iColumn];
     9393      int length = static_cast<int>(put-columnStart[iColumn]);
    93949394      if (!length) {
    93959395        if (!cost) {
     
    94409440          int shortestNumber=numberColumns_;
    94419441          int shortest=-1;
    9442           for (int j=start;j<start+length;j++) {
     9442          for (CoinBigIndex j=start;j<start+length;j++) {
    94439443            int iRow=row[j];
    94449444            if (rowLength[iRow]<shortestNumber&&
     
    94579457            shortestNumber=numberColumns_;
    94589458            shortest=-1;
    9459             for (int j=start;j<start+length;j++) {
     9459            for (CoinBigIndex j=start;j<start+length;j++) {
    94609460              int iRow=row[j];
    94619461              if (rowLength[iRow]<shortestNumber) {
    9462                 int start = rowStart[iRow];
    9463                 for (int i=start;i<start+rowLength[iRow];i++) {
     9462                CoinBigIndex start = rowStart[iRow];
     9463                for (CoinBigIndex i=start;i<start+rowLength[iRow];i++) {
    94649464                  int jColumn = column[i];
    94659465                  if (iColumn!=jColumn&&
     
    95009500        columnLength[iColumn]=0;
    95019501        nChanged++;
    9502         for (int j=start;j<start+length;j++) {
     9502        for (CoinBigIndex j=start;j<start+length;j++) {
    95039503          int iRow=row[j];
    95049504          double value = element[j]*newValue;
     
    95179517            assert (numberRowsLook<=numberRows_);
    95189518          }
    9519           int start = rowStart[iRow];
    9520           int put=start;
    9521           for (int i=start;i<start+rowLength[iRow];i++) {
     9519          CoinBigIndex start = rowStart[iRow];
     9520          CoinBigIndex put=start;
     9521          for (CoinBigIndex i=start;i<start+rowLength[iRow];i++) {
    95229522            int jColumn = column[i];
    95239523            if (iColumn!=jColumn) {
     
    95269526            }
    95279527          }
    9528           rowLength[iRow]=put-start;
     9528          rowLength[iRow]=static_cast<int>(put-start);
    95299529        }
    95309530      }
     
    96189618        }
    96199619      }
    9620       int numberElements = put-lastElement;
     9620      CoinBigIndex numberElements = put-lastElement;
    96219621      columnStart[numberColumns_]=numberElements;
    96229622      memcpy(row,row+lastElement,numberElements*sizeof(int));
     
    98349834  assert (iGet==presolvedModel->numberRows());
    98359835  CoinPackedMatrix matrixX;
    9836   int numberElementsOriginal=matrix_->getNumElements();
     9836  CoinBigIndex numberElementsOriginal=matrix_->getNumElements();
    98379837  const int * rowY = presolvedModel->matrix()->getIndices();
    98389838  const CoinBigIndex * columnStartY = presolvedModel->matrix()->getVectorStarts();
     
    98499849    }
    98509850  }
    9851   int lastElement=2*(put+numberColumns_)+1000;
    9852   int spare = (lastElement-put)/numberColumns_;
     9851  CoinBigIndex lastElement=2*(put+numberColumns_)+1000;
     9852  int spare = static_cast<int>((lastElement-put)/numberColumns_);
    98539853  //printf("spare %d\n",spare);
    98549854  matrixX.reserve(numberColumns_,lastElement+2*numberElementsOriginal);
     
    1019310193        columnActivity_[iColumn]=solValue;
    1019410194        if (solValue) {
    10195           for (int j=columnStartX[iColumn];
     10195          for (CoinBigIndex j=columnStartX[iColumn];
    1019610196               j<columnStartX[iColumn]+columnLengthX[iColumn];j++) {
    1019710197            int jRow=rowX[j];
     
    1026110261        columnActivity_[iColumn]=solValue;
    1026210262        if (newLength&&solValue) {
    10263           for (int j=startOriginal;j<startOriginal+newLength;j++) {
     10263          for (CoinBigIndex j=startOriginal;j<startOriginal+newLength;j++) {
    1026410264            int iRow=row[j];
    1026510265            double value = element[j]*solValue;
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r2259 r2271  
    484484               // Say no pivot has occurred (for steepest edge and updates)
    485485               pivotRow_ = -2;
    486 
     486               // exit if feasible and done enough iterations
     487               if ((moreSpecialOptions_&1048576)!=0) {
     488                 int maxIterations=maximumIterations()-1000000;
     489                 if (maxIterations>0&&maxIterations<200000) {
     490                   if (!nonLinearCost_->numberInfeasibilities()&&
     491                       numberIterations_>=maxIterations) {
     492                     problemStatus_ = 3;
     493                     secondaryStatus_ = 10;
     494                   }
     495                 }
     496               }
    487497               // exit if victory declared
    488498               if (problemStatus_ >= 0) {
  • trunk/Clp/src/ClpSolve.cpp

    r2259 r2271  
    12501250     int primalStartup = 1;
    12511251     model2->eventHandler()->event(ClpEventHandler::presolveBeforeSolve);
     1252#if CLP_POOL_MATRIX
     1253     if (vectorMode()>=10) {
     1254       ClpPoolMatrix * poolMatrix = new ClpPoolMatrix(*model2->matrix());
     1255       char output[80];
     1256       int numberDifferent=poolMatrix->getNumDifferentElements();
     1257       if (numberDifferent>0) {
     1258         sprintf(output,"Pool matrix has %d different values",
     1259                 numberDifferent);
     1260         model2->replaceMatrix(poolMatrix,true);
     1261       } else {
     1262         delete poolMatrix;
     1263         sprintf(output,"Pool matrix has more than %d different values - no good",
     1264                 -numberDifferent);
     1265       }
     1266       handler_->message(CLP_GENERAL, messages_) << output
     1267         << CoinMessageEol;
     1268     }
     1269#endif
    12521270     int tryItSave = 0;
    12531271#if CLPSOLVE_ACTIONS
     
    14441462     // See if worth trying +- one matrix
    14451463     bool plusMinus = false;
    1446      int numberElements = model2->getNumElements();
     1464     CoinBigIndex numberElements = model2->getNumElements();
    14471465#ifndef SLIM_CLP
    14481466#ifndef NO_RTTI
     
    16791697          }
    16801698     }
     1699#if COIN_BIG_INDEX==0
    16811700     if (method == ClpSolve::tryBenders) {
    16821701       // Now build model
     
    17101729         abort();
    17111730     }
     1731#endif
    17121732     if (method == ClpSolve::usePrimalorSprint) {
    17131733          if (doSprint < 0) {
     
    26032623               nRow *= 2;
    26042624          }
    2605           int * addStarts = new int [nRow+1];
     2625          CoinBigIndex * addStarts = new CoinBigIndex [nRow+1];
    26062626          int * addRow = new int[nRow];
    26072627          double * addElement = new double[nRow];
     
    27172737          smallNumberColumns = CoinMax(smallNumberColumns, 3000);
    27182738          smallNumberColumns = CoinMin(smallNumberColumns, numberColumns);
     2739          int saveSmallNumber = smallNumberColumns;
     2740          bool emergencyMode=false;
    27192741          //int smallNumberColumns = CoinMin(12*numberRows/10,numberColumns);
    27202742          //smallNumberColumns = CoinMax(smallNumberColumns,3000);
     
    28192841                    currentModel = &small;
    28202842               small.defaultFactorizationFrequency();
     2843               if (emergencyMode) {
     2844                 // not much happening so big model
     2845                 int options=small.moreSpecialOptions();
     2846                 small.setMoreSpecialOptions(options|1048576);
     2847                 small.setMaximumIterations(1000400);
     2848                 small.setPerturbation(100);
     2849               }
    28212850               if (dynamic_cast< ClpPackedMatrix*>(matrix_)) {
    28222851                    // See if original wanted vector
     
    28422871                         small.dual(0);
    28432872#endif
     2873                      if (emergencyMode) {
     2874                        if (small.problemStatus()==3)
     2875                          small.setProblemStatus(0);
     2876                        smallNumberColumns=saveSmallNumber;
     2877                        emergencyMode=false;
     2878                        double * temp = new double [numberRows];
     2879                        memset(temp,0,numberRows*sizeof(double));
     2880                        double * solution = small.primalColumnSolution();
     2881                        small.matrix()->times(solution,temp);
     2882                        double sumInf=0.0;
     2883                        double * lower = small.rowLower();
     2884                        double * upper = small.rowUpper();
     2885                        for (int iRow=0;iRow<numberRows;iRow++) {
     2886                          if (temp[iRow]>upper[iRow])
     2887                            sumInf += temp[iRow]-upper[iRow];
     2888                          else if (temp[iRow]<lower[iRow])
     2889                            sumInf += lower[iRow]-temp[iRow];
     2890                        }
     2891                        printf("row inf %g\n",sumInf);
     2892                        sumInf=0.0;
     2893                        lower = small.columnLower();
     2894                        upper = small.columnUpper();
     2895                        for (int iColumn=0;iColumn<small.numberColumns();iColumn++) {
     2896                          if (solution[iColumn]>upper[iColumn])
     2897                            sumInf += solution[iColumn]-upper[iColumn];
     2898                          else if (solution[iColumn]<lower[iColumn])
     2899                            sumInf += lower[iColumn]-solution[iColumn];
     2900                        }
     2901                        printf("column inf %g\n",sumInf);
     2902                        delete [] temp;
     2903                      }
    28442904                      if (small.problemStatus()) {
    28452905                        int numberIterations=small.numberIterations();
     
    28862946                    small.primal(1);
    28872947               }
    2888                totalIterations += small.numberIterations();
     2948               int smallIterations=small.numberIterations();
     2949               totalIterations += smallIterations;
     2950               if (2*smallIterations<CoinMin(numberRows,1000) && iPass) {
     2951                 int oldNumber=smallNumberColumns;
     2952                 if (smallIterations<100)
     2953                   smallNumberColumns *= 1.2;
     2954                 else
     2955                   smallNumberColumns *= 1.1;
     2956                 smallNumberColumns = CoinMin(smallNumberColumns, numberColumns);
     2957                 if (smallIterations<200 && smallNumberColumns>2*saveSmallNumber) {
     2958                   // try kicking it
     2959                   emergencyMode=true;
     2960                   smallNumberColumns=numberColumns;
     2961                 }
     2962                 //              smallNumberColumns = CoinMin(smallNumberColumns, 3*saveSmallNumber);
     2963                 char line[100];
     2964                 sprintf(line,"sample size increased from %d to %d",
     2965                         oldNumber,smallNumberColumns); 
     2966                 handler_->message(CLP_GENERAL, messages_)
     2967                   << line
     2968                   << CoinMessageEol;
     2969               }
    28892970               // move solution back
    28902971               const double * solution = small.primalColumnSolution();
     
    29413022               if (iPass > 20)
    29423023                    sumArtificials = 0.0;
    2943                if ((small.objectiveValue()*optimizationDirection_ > lastObjective[1] - 1.0e-7 && iPass > 5 && sumArtificials < 1.0e-8 && maxSprintPass<200) ||
     3024               if ((small.objectiveValue()*optimizationDirection_ > lastObjective[1] - 1.0e-7 && iPass > 15 && sumArtificials < 1.0e-8 && maxSprintPass<200) ||
    29443025                         (!small.numberIterations() && iPass) ||
    29453026                         iPass == maxSprintPass - 1 || small.status() == 3) {
     
    29513032                    double tolerance;
    29523033                    double averageNegDj = sumNegative / static_cast<double> (numberNegative + 1);
    2953                     if (numberNegative + numberSort > smallNumberColumns)
     3034                    if (numberNegative + numberSort > smallNumberColumns && false)
    29543035                         tolerance = -dualTolerance_;
    29553036                    else
    29563037                         tolerance = 10.0 * averageNegDj;
     3038                    if (emergencyMode)
     3039                      tolerance=1.0e100;
    29573040                    int saveN = numberSort;
    29583041                    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     
    29763059                    // sort
    29773060                    CoinSort_2(weight + saveN, weight + numberSort, sort + saveN);
     3061                    if (numberSort<smallNumberColumns)
     3062                      printf("using %d columns not %d\n",numberSort,smallNumberColumns);
    29783063                    numberSort = CoinMin(smallNumberColumns, numberSort);
     3064                    // try singletons
     3065                    char * markX = new char[numberColumns];
     3066                    memset(markX,0,numberColumns);
     3067                    for (int i=0;i<numberSort;i++)
     3068                      markX[sort[i]]=1;
     3069                    int n=numberSort;
     3070                    for (int i=0;i<numberColumns;i++) {
     3071                      if (columnLength[i]==1&&!markX[i])
     3072                        sort[numberSort++]=i;
     3073                    }
     3074                    if (n<numberSort)
     3075                      printf("%d slacks added\n",numberSort-n);
     3076                    delete [] markX;
    29793077               }
    29803078          }
     
    45514649     return matched;
    45524650}
     4651#if COIN_BIG_INDEX==0
    45534652#include "CoinStructuredModel.hpp"
    45544653// Solve using structure of model and maybe in parallel
     
    49135012     return returnCode;
    49145013}
     5014#endif
    49155015/*  If input negative scales objective so maximum <= -value
    49165016    and returns scale factor used.  If positive unscales and also
     
    50235123}
    50245124#endif
     5125#if COIN_BIG_INDEX==0
    50255126// Solve using Dantzig-Wolfe decomposition and maybe in parallel
    50265127int
     
    52125313     double * elementAdd = new double[spaceNeeded];
    52135314     spaceNeeded = numberBlocks;
    5214      int * columnAdd = new int[spaceNeeded+1];
     5315     CoinBigIndex * columnAdd = new CoinBigIndex[spaceNeeded+1];
    52155316     double * objective = new double[spaceNeeded];
    52165317     // Add in costed slacks
     
    58585959  return model;
    58595960}
     5961#endif
    58605962#if defined(ABC_INHERIT) || defined(CBC_THREAD) || defined(THREADS_IN_ANALYZE)
    58615963CoinPthreadStuff::CoinPthreadStuff(int numberThreads,
     
    60036105}
    60046106#endif
     6107#if COIN_BIG_INDEX==0
    60056108// Solve using Benders decomposition and maybe in parallel
    60066109int
     
    79538056     return 0;
    79548057}
     8058#endif
  • trunk/Clp/src/ClpSolver.cpp

    r2254 r2271  
    130130              AbcSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
    131131#endif
     132#if COIN_BIG_INDEX==0
    132133static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
     134#endif
    133135static void generateCode(const char * fileName, int type);
    134136// Returns next valid field
     
    13401342                              break;
    13411343                         case CLP_PARAM_ACTION_STATISTICS:
     1344#if COIN_BIG_INDEX==0
    13421345                              if (goodModels[iModel]) {
    13431346                                   // If presolve on look at presolved
     
    13741377                                   std::cout << "** Current model not valid" << std::endl;
    13751378                              }
     1379#endif
    13761380                              break;
    13771381                         case CLP_PARAM_ACTION_TIGHTEN:
     
    30003004     return 0;
    30013005}
     3006#if COIN_BIG_INDEX==0
    30023007static void breakdown(const char * name, int numberLook, const double * region)
    30033008{
     
    30463051     delete [] numberExact;
    30473052}
     3053#endif
    30483054void sortOnOther(int * column,
    30493055                 const CoinBigIndex * rowStart,
     
    30873093     }
    30883094}
     3095#if COIN_BIG_INDEX==0
    30893096static void statistics(ClpSimplex * originalModel, ClpSimplex * model)
    30903097{
     
    44694476     }
    44704477}
     4478#endif
    44714479static bool maskMatches(const int * starts, char ** masks,
    44724480                        std::string & check)
  • trunk/Clp/src/Clp_C_Interface.cpp

    r2019 r2271  
    154154          int nInt = numberIntFields();
    155155          assert (nInt <= 10);
    156           int vInt[10];
     156          CoinBigIndex vInt[10];
    157157          for (i = 0; i < nInt; i++)
    158158               vInt[i] = intValue(i);
     
    321321Clp_addRows(Clp_Simplex * model, int number, const double * rowLower,
    322322            const double * rowUpper,
    323             const int * rowStarts, const int * columns,
     323            const CoinBigIndex * rowStarts, const int * columns,
    324324            const double * elements)
    325325{
     
    338338               const double * columnUpper,
    339339               const double * objective,
    340                const int * columnStarts, const int * rows,
     340               const CoinBigIndex * columnStarts, const int * rows,
    341341               const double * elements)
    342342{
     
    614614}
    615615/* Number of elements in matrix */
    616 COINLIBAPI int COINLINKAGE
     616COINLIBAPI CoinBigIndex COINLINKAGE
    617617Clp_getNumElements(Clp_Simplex * model)
    618618{
     
    11811181     int numrows    = clp_simplex->numberRows();
    11821182     int numcols    = clp_simplex->numberColumns();
    1183      int numelem    = clp_simplex->getNumElements();
     1183     CoinBigIndex numelem    = clp_simplex->getNumElements();
    11841184     const CoinBigIndex *start = clp_simplex->matrix()->getVectorStarts();
    11851185     const int *index     = clp_simplex->matrix()->getIndices();
  • trunk/Clp/src/Clp_C_Interface.h

    r2019 r2271  
    115115     COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex * model, int number, const double * rowLower,
    116116                                             const double * rowUpper,
    117                                              const int * rowStarts, const int * columns,
     117                                             const CoinBigIndex * rowStarts, const int * columns,
    118118                                             const double * elements);
    119119
     
    124124               const double * columnUpper,
    125125               const double * objective,
    126                const int * columnStarts, const int * rows,
     126               const CoinBigIndex * columnStarts, const int * rows,
    127127               const double * elements);
    128128     /** Change row lower bounds */
     
    218218     COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex * model);
    219219     /** Number of elements in matrix */
    220      COINLIBAPI int COINLINKAGE Clp_getNumElements(Clp_Simplex * model);
     220     COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex * model);
    221221     /* Column starts in matrix */
    222222     COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex * model);
  • trunk/Clp/src/IdiSolve.cpp

    r2078 r2271  
    143143{
    144144     IdiotResult result;
    145      int  i, j, k, iter;
     145     int  i, k, iter;
     146     CoinBigIndex j;
    146147     double value = 0.0, objvalue = 0.0, weightedObj = 0.0;
    147148     double tolerance = 1.0e-8;
  • trunk/Clp/src/Idiot.cpp

    r2206 r2271  
    752752                    rowsol[irow] *= multiplier;
    753753               }
    754                int length = columnStart[ncols-1] + columnLength[ncols-1];
     754               CoinBigIndex length = columnStart[ncols-1] + columnLength[ncols-1];
    755755               double * elemYY = new double[length];
    756756               for (i = 0; i < ncols; i++) {
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r2229 r2271  
    40984098void
    40994099OsiClpSolverInterface::addCols(const int numcols,
    4100                                const int * columnStarts, const int * rows, const double * elements,
     4100                               const CoinBigIndex * columnStarts, const int * rows, const double * elements,
    41014101                               const double* collb, const double* colub,   
    41024102                               const double* obj)
     
    43264326void
    43274327OsiClpSolverInterface::addRows(const int numrows,
    4328                                const int * rowStarts, const int * columns, const double * element,
     4328                               const CoinBigIndex * rowStarts, const int * columns, const double * element,
    43294329                               const double* rowlb, const double* rowub)
    43304330{
     
    57925792    // get quadratic part
    57935793    if (m.reader()->whichSection (  ) == COIN_QUAD_SECTION ) {
    5794       int * start=NULL;
     5794      CoinBigIndex * start=NULL;
    57955795      int * column = NULL;
    57965796      double * element = NULL;
    5797       int status=m.readQuadraticMps(NULL,start,column,element,2);
     5797      CoinBigIndex status=m.readQuadraticMps(NULL,start,column,element,2);
    57985798      if (!status)
    57995799        modelPtr_->loadQuadraticObjective(nCols,start,column,element);
     
    69816981  rowArray1->clear();
    69826982  columnArray0->clear();
     6983#if SHORT_REGION==2
    69836984  columnArray1->clear();
     6985#endif
    69846986  int numberRows = modelPtr_->numberRows();
    69856987  int numberColumns = modelPtr_->numberColumns();
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r2219 r2271  
    376376 
    377377  /// Get number of nonzero elements
    378   virtual int getNumElements() const {
    379     int retVal = 0;
     378  virtual CoinBigIndex getNumElements() const {
     379    CoinBigIndex retVal = 0;
    380380    const CoinPackedMatrix * matrix =modelPtr_->matrix();
    381381    if ( matrix != NULL ) retVal=matrix->getNumElements();
     
    753753  /**  */
    754754  virtual void addCols(const int numcols,
    755                        const int * columnStarts, const int * rows, const double * elements,
     755                       const CoinBigIndex * columnStarts, const int * rows, const double * elements,
    756756                       const double* collb, const double* colub,   
    757757                       const double* obj);
     
    794794  /** */
    795795  virtual void addRows(const int numrows,
    796                        const int * rowStarts, const int * columns, const double * element,
     796                       const CoinBigIndex * rowStarts, const int * columns, const double * element,
    797797                       const double* rowlb, const double* rowub);
    798798  ///
  • trunk/Clp/src/unitTest.cpp

    r2238 r2271  
    21722172               int * which = new int [numberRows+numberColumns];
    21732173
    2174                int numberElements = m.getMatrixByCol()->getNumElements();
    2175                int * starts = new int[numberRows+numberColumns];
     2174               CoinBigIndex numberElements = m.getMatrixByCol()->getNumElements();
     2175               CoinBigIndex * starts = new CoinBigIndex[numberRows+numberColumns];
    21762176               int * index = new int[numberElements];
    21772177               double * element = new double[numberElements];
     
    22012201                         saveLower[n] = lower[iColumn];
    22022202                         saveUpper[n] = upper[iColumn];
    2203                          int j;
     2203                         CoinBigIndex j;
    22042204                         for (j = startM[iColumn]; j < startM[iColumn] + lengthM[iColumn]; j++) {
    22052205                              index[nel] = indexM[j];
     
    22282228                    saveLower[n] = lower[iColumn];
    22292229                    saveUpper[n] = upper[iColumn];
    2230                     int j;
     2230                    CoinBigIndex j;
    22312231                    for (j = startM[iColumn]; j < startM[iColumn] + lengthM[iColumn]; j++) {
    22322232                         index[nel] = indexM[j];
     
    22622262                         saveLower[n] = lower[iRow];
    22632263                         saveUpper[n] = upper[iRow];
    2264                          int j;
     2264                         CoinBigIndex j;
    22652265                         for (j = startM[iRow]; j < startM[iRow] + lengthM[iRow]; j++) {
    22662266                              index[nel] = indexM[j];
     
    22882288                    saveLower[n] = lower[iRow];
    22892289                    saveUpper[n] = upper[iRow];
    2290                     int j;
     2290                    CoinBigIndex j;
    22912291                    for (j = startM[iRow]; j < startM[iRow] + lengthM[iRow]; j++) {
    22922292                         index[nel] = indexM[j];
     
    23492349     }
    23502350#endif
     2351#if COIN_BIG_INDEX==0
    23512352     // test network
    23522353#define QUADRATIC
     
    28022803          fullModel.writeMps("test2.mps");
    28032804     }
     2805#endif
    28042806}
Note: See TracChangeset for help on using the changeset viewer.