Changeset 1660 for trunk


Ignore:
Timestamp:
Jan 4, 2011 5:17:43 AM (9 years ago)
Author:
forrest
Message:

for user hooks and ranging/parametrics

Location:
trunk/Clp/src
Files:
10 edited

Legend:

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

    r1643 r1660  
    27122712     parameters[numberParameters-1].append("all");
    27132713     parameters[numberParameters-1].append("csv");
     2714     parameters[numberParameters-1].append("bound!ranging");
     2715     parameters[numberParameters-1].append("rhs!ranging");
     2716     parameters[numberParameters-1].append("objective!ranging");
    27142717     parameters[numberParameters-1].setLonghelp
    27152718     (
  • trunk/Clp/src/ClpMain.cpp

    r1643 r1660  
    8989FILE * CbcOrClpReadCommand = stdin;
    9090extern int CbcOrClpEnvironmentIndex;
     91#ifdef CLP_USER_DRIVEN1
     92/* Returns true if variable sequenceOut can leave basis when
     93   model->sequenceIn() enters.
     94   This function may be entered several times for each sequenceOut. 
     95   The first time realAlpha will be positive if going to lower bound
     96   and negative if going to upper bound (scaled bounds in lower,upper) - then will be zero.
     97   currentValue is distance to bound.
     98   currentTheta is current theta.
     99   alpha is fabs(pivot element).
     100   Variable will change theta if currentValue - currentTheta*alpha < 0.0
     101*/
     102bool userChoiceValid1(const ClpSimplex * model,
     103                      int sequenceOut,
     104                      double currentValue,
     105                      double currentTheta,
     106                      double alpha,
     107                      double realAlpha)
     108{
     109  return true;
     110}
     111/* This returns true if chosen in/out pair valid.
     112   The main thing to check would be variable flipping bounds may be
     113   OK.  This would be signaled by reasonable theta_ and valueOut_.
     114   If you return false sequenceIn_ will be flagged as ineligible.
     115*/
     116bool userChoiceValid2(const ClpSimplex * model)
     117{
     118  return true;
     119}
     120/* If a good pivot then you may wish to unflag some variables.
     121 */
     122void userChoiceWasGood(ClpSimplex * model)
     123{
     124}
     125#endif
    91126
    92127int
     
    17231758                                   // get next field
    17241759                                   field = CoinReadGetString(argc, argv);
     1760                                   bool append = false;
     1761                                   if (field == "append$") {
     1762                                     field = "$";
     1763                                     append = true;
     1764                                   }
    17251765                                   if (field == "$") {
    17261766                                        field = parameters[iParam].stringValue();
     
    17561796                                             fileName = directory + field;
    17571797                                        }
    1758                                         fp = fopen(fileName.c_str(), "w");
     1798                                        if (!append)
     1799                                          fp = fopen(fileName.c_str(), "w");
     1800                                        else
     1801                                          fp = fopen(fileName.c_str(), "a");
    17591802                                   }
    17601803                                   if (fp) {
     
    18981941                                             delete [] newMasks;
    18991942                                        }
     1943                                        if (printMode > 5) {
     1944                                          int numberColumns = models[iModel].numberColumns();
     1945                                          // column length unless rhs ranging
     1946                                          int number = numberColumns;
     1947                                          switch (printMode) {
     1948                                            // bound ranging
     1949                                            case 6:
     1950                                              fprintf(fp,"Bound ranging");
     1951                                              break;
     1952                                            // rhs ranging
     1953                                            case 7:
     1954                                              fprintf(fp,"Rhs ranging");
     1955                                              number = numberRows;
     1956                                              break;
     1957                                            // objective ranging
     1958                                            case 8:
     1959                                              fprintf(fp,"Objective ranging");
     1960                                              break;
     1961                                          }
     1962                                          if (lengthName)
     1963                                            fprintf(fp,",name");
     1964                                          fprintf(fp,",increase,variable,decrease,variable\n");
     1965                                          int * which = new int [ number];
     1966                                          if (printMode != 7) {
     1967                                            if (!doMask) {
     1968                                              for (int i = 0; i < number;i ++)
     1969                                                which[i]=i;
     1970                                            } else {
     1971                                              int n = 0;
     1972                                              for (int i = 0; i < number;i ++) {
     1973                                                if (maskMatches(maskStarts,masks,columnNames[i]))
     1974                                                  which[n++]=i;
     1975                                              }
     1976                                              if (n) {
     1977                                                number=n;
     1978                                              } else {
     1979                                                printf("No names match - doing all\n");
     1980                                                for (int i = 0; i < number;i ++)
     1981                                                  which[i]=i;
     1982                                              }
     1983                                            }
     1984                                          } else {
     1985                                            if (!doMask) {
     1986                                              for (int i = 0; i < number;i ++)
     1987                                                which[i]=i+numberColumns;
     1988                                            } else {
     1989                                              int n = 0;
     1990                                              for (int i = 0; i < number;i ++) {
     1991                                                if (maskMatches(maskStarts,masks,rowNames[i]))
     1992                                                  which[n++]=i+numberColumns;
     1993                                              }
     1994                                              if (n) {
     1995                                                number=n;
     1996                                              } else {
     1997                                                printf("No names match - doing all\n");
     1998                                                for (int i = 0; i < number;i ++)
     1999                                                  which[i]=i+numberColumns;
     2000                                              }
     2001                                            }
     2002                                          }
     2003                                          double * valueIncrease = new double [ number];
     2004                                          int * sequenceIncrease = new int [ number];
     2005                                          double * valueDecrease = new double [ number];
     2006                                          int * sequenceDecrease = new int [ number];
     2007                                          switch (printMode) {
     2008                                            // bound or rhs ranging
     2009                                            case 6:
     2010                                            case 7:
     2011                                              models[iModel].primalRanging(numberRows,
     2012                                                                           which, valueIncrease, sequenceIncrease,
     2013                                                                           valueDecrease, sequenceDecrease);
     2014                                              break;
     2015                                            // objective ranging
     2016                                            case 8:
     2017                                              models[iModel].dualRanging(number,
     2018                                                                           which, valueIncrease, sequenceIncrease,
     2019                                                                           valueDecrease, sequenceDecrease);
     2020                                              break;
     2021                                          }
     2022                                          for (int i = 0; i < number; i++) {
     2023                                            int iWhich = which[i];
     2024                                            fprintf(fp, "%d,", (iWhich<numberColumns) ? iWhich : iWhich-numberColumns);
     2025                                            if (lengthName) {
     2026                                              const char * name = (printMode==7) ? rowNames[iWhich-numberColumns].c_str() : columnNames[iWhich].c_str();
     2027                                              fprintf(fp,"%s,",name);
     2028                                            }
     2029                                            if (valueIncrease[i]<1.0e30) {
     2030                                              fprintf(fp, "%.10g,", valueIncrease[i]);
     2031                                              int outSequence = sequenceIncrease[i];
     2032                                              if (outSequence<numberColumns) {
     2033                                                if (lengthName)
     2034                                                  fprintf(fp,"%s,",columnNames[outSequence].c_str());
     2035                                                else
     2036                                                  fprintf(fp,"C%7.7d,",outSequence);
     2037                                              } else {
     2038                                                outSequence -= numberColumns;
     2039                                                if (lengthName)
     2040                                                  fprintf(fp,"%s,",rowNames[outSequence].c_str());
     2041                                                else
     2042                                                  fprintf(fp,"R%7.7d,",outSequence);
     2043                                              }
     2044                                            } else {
     2045                                              fprintf(fp,"1.0e100,,");
     2046                                            }
     2047                                            if (valueDecrease[i]<1.0e30) {
     2048                                              fprintf(fp, "%.10g,", valueDecrease[i]);
     2049                                              int outSequence = sequenceDecrease[i];
     2050                                              if (outSequence<numberColumns) {
     2051                                                if (lengthName)
     2052                                                  fprintf(fp,"%s",columnNames[outSequence].c_str());
     2053                                                else
     2054                                                  fprintf(fp,"C%7.7d",outSequence);
     2055                                              } else {
     2056                                                outSequence -= numberColumns;
     2057                                                if (lengthName)
     2058                                                  fprintf(fp,"%s",rowNames[outSequence].c_str());
     2059                                                else
     2060                                                  fprintf(fp,"R%7.7d",outSequence);
     2061                                              }
     2062                                            } else {
     2063                                              fprintf(fp,"1.0e100,");
     2064                                            }
     2065                                            fprintf(fp,"\n");
     2066                                          }
     2067                                          if (fp != stdout)
     2068                                            fclose(fp);
     2069                                          delete [] which;
     2070                                          delete [] valueIncrease;
     2071                                          delete [] sequenceIncrease;
     2072                                          delete [] valueDecrease;
     2073                                          delete [] sequenceDecrease;
     2074                                          if (masks) {
     2075                                            delete [] maskStarts;
     2076                                            for (int i = 0; i < maxMasks; i++)
     2077                                              delete [] masks[i];
     2078                                            delete [] masks;
     2079                                          }
     2080                                          break;
     2081                                        }
    19002082                                        if (printMode > 2) {
    19012083                                             for (iRow = 0; iRow < numberRows; iRow++) {
  • trunk/Clp/src/ClpNonLinearCost.cpp

    r1525 r1660  
    782782#endif
    783783     if (CLP_METHOD2) {
     784       //#define CLP_NON_JUST_BASIC
     785#ifndef CLP_NON_JUST_BASIC
    784786          // nonbasic should be at a valid bound
    785787          for (iSequence = 0; iSequence < numberTotal; iSequence++) {
     788#else
     789          const int * pivotVariable = model_->pivotVariable();
     790          for (int i=0;i<numberRows_;i++) {
     791            int iSequence = pivotVariable[i];
     792#endif
    786793               double value = solution[iSequence];
    787794               unsigned char iStatus = status_[iSequence];
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1643 r1660  
    2020#include "ClpPackedMatrix.hpp"
    2121#include "ClpMessage.hpp"
    22 //#define COIN_PREFETCH
    23 #ifdef COIN_PREFETCH
    24 #if 1
    25 #define coin_prefetch(mem) \
    26          __asm__ __volatile__ ("prefetchnta %0" : : "m" (*((char *)(mem))))
    27 #else
    28 #define coin_prefetch(mem) \
    29          __asm__ __volatile__ ("prefetch %0" : : "m" (*((char *)(mem))))
    30 #endif
    31 #else
    32 // dummy
    33 #define coin_prefetch(mem)
    34 #endif
    3522#ifdef INTEL_MKL
    3623#include "mkl_spblas.h"
     
    6148     : ClpMatrixBase(rhs)
    6249{
     50#ifndef COIN_SPARSE_MATRIX
    6351     matrix_ = new CoinPackedMatrix(*(rhs.matrix_), -1, -1);
     52#else
     53     matrix_ = new CoinPackedMatrix(*(rhs.matrix_), -0, -0);
     54#endif
    6455     numberActiveColumns_ = rhs.numberActiveColumns_;
    6556     flags_ = rhs.flags_ & (~2);
     
    10192     : ClpMatrixBase()
    10293{
     94#ifndef COIN_SPARSE_MATRIX
    10395     matrix_ = new CoinPackedMatrix(rhs, -1, -1);
     96#else
     97     matrix_ = new CoinPackedMatrix(rhs, -0, -0);
     98#endif
    10499     numberActiveColumns_ = matrix_->getNumCols();
    105100     rowCopy_ = NULL;
     
    129124          ClpMatrixBase::operator=(rhs);
    130125          delete matrix_;
     126#ifndef COIN_SPARSE_MATRIX
    131127          matrix_ = new CoinPackedMatrix(*(rhs.matrix_));
     128#else
     129          matrix_ = new CoinPackedMatrix(*(rhs.matrix_), -0, -0);
     130#endif
    132131          numberActiveColumns_ = rhs.numberActiveColumns_;
    133132          flags_ = rhs.flags_;
     
    11491148               int * index = columnArray->getIndices();
    11501149               double * array = columnArray->denseVector();
    1151 #ifdef COIN_SPARSE_MATRIX
     1150#if 0
     1151               {
     1152                 double  * array2 = y->denseVector();
     1153                 int numberColumns = matrix_->getNumCols();
     1154                 for (int i=0;i<numberColumns;i++) {
     1155                   assert(!array[i]);
     1156                   assert(!array2[i]);
     1157                 }
     1158               }
     1159#endif
     1160               //#define COIN_SPARSE_MATRIX 1
     1161#if COIN_SPARSE_MATRIX
    11521162               assert (!y->getNumElements());
     1163#if COIN_SPARSE_MATRIX != 2
    11531164               // and set up mark as char array
    11541165               char * marked = reinterpret_cast<char *> (index+columnArray->capacity());
    11551166               int * lookup = y->getIndices();
    1156                //int numberRows = matrix_->getNumRows();
    11571167#ifndef NDEBUG
     1168               //int numberColumns = matrix_->getNumCols();
    11581169               //for (int i=0;i<numberColumns;i++)
    11591170               //assert(!marked[i]);
    11601171#endif
     1172               numberNonZero=gutsOfTransposeTimesByRowGE3a(rowArray,index,array,
     1173                                           lookup,marked,zeroTolerance,scalar);
     1174#else
     1175               double  * array2 = y->denseVector();
    11611176               numberNonZero=gutsOfTransposeTimesByRowGE3(rowArray,index,array,
    1162                                            lookup,marked,zeroTolerance,scalar);
     1177                                           array2,zeroTolerance,scalar);
     1178#endif
    11631179#else
    11641180               int numberColumns = matrix_->getNumCols();
     
    18331849          elementByColumn = scaledMatrix->getElements();
    18341850     }
    1835      if (!(flags & 2) && numberToDo) {
     1851     if (!(flags & 2) && numberToDo>2) {
    18361852          // no gaps
    18371853          if (!rowScale) {
     
    18391855               double value = 0.0;
    18401856               CoinBigIndex j;
     1857               int columnNext = which[1];
     1858               CoinBigIndex startNext=columnStart[columnNext];
     1859               coin_prefetch_const(row+startNext);
     1860               coin_prefetch_const(elementByColumn+startNext);
     1861               CoinBigIndex endNext=columnStart[columnNext+1];
    18411862               for (j = columnStart[iColumn];
    18421863                         j < columnStart[iColumn+1]; j++) {
     
    18441865                    value += pi[iRow] * elementByColumn[j];
    18451866               }
    1846                for (jColumn = 0; jColumn < numberToDo - 1; jColumn++) {
    1847                     int iColumn = which[jColumn+1];
    1848                     CoinBigIndex start = columnStart[iColumn];
    1849                     CoinBigIndex end = columnStart[iColumn+1];
     1867               for (jColumn = 0; jColumn < numberToDo - 2; jColumn++) {
     1868                    CoinBigIndex start = startNext;
     1869                    CoinBigIndex end = endNext;
     1870                    columnNext = which[jColumn+2];
     1871                    startNext=columnStart[columnNext];
     1872                    coin_prefetch_const(row+startNext);
     1873                    coin_prefetch_const(elementByColumn+startNext);
     1874                    endNext=columnStart[columnNext+1];
    18501875                    array[jColumn] = value;
    18511876                    value = 0.0;
     
    18551880                    }
    18561881               }
     1882               array[jColumn++] = value;
     1883               value = 0.0;
     1884               for (j = startNext; j < endNext; j++) {
     1885                 int iRow = row[j];
     1886                 value += pi[iRow] * elementByColumn[j];
     1887               }
    18571888               array[jColumn] = value;
    18581889          } else {
     
    41134144}
    41144145int
    4115 ClpPackedMatrix::gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector,
     4146ClpPackedMatrix::gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector * COIN_RESTRICT piVector,
    41164147          int * COIN_RESTRICT index,
    41174148          double * COIN_RESTRICT output,
     
    41284159     const double * COIN_RESTRICT element = matrix_->getElements();
    41294160     const int * COIN_RESTRICT whichRow = piVector->getIndices();
     4161     int * fakeRow = const_cast<int *> (whichRow);
     4162     fakeRow[numberInRowArray]=0; // so can touch
    41304163#ifndef NDEBUG
    41314164     int maxColumn = 0;
    41324165#endif
    41334166     // ** Row copy is already scaled
    4134      int iRow;
    4135      int i;
    4136      for (i = 0; i < numberInRowArray; i++) {
    4137           iRow = whichRow[i];
     4167     int nextRow=whichRow[0];
     4168     CoinBigIndex nextStart = rowStart[nextRow];
     4169     CoinBigIndex nextEnd = rowStart[nextRow+1];
     4170     for (int i = 0; i < numberInRowArray; i++) {
    41384171          double value = pi[i] * scalar;
     4172          CoinBigIndex start=nextStart;
     4173          CoinBigIndex end=nextEnd;
     4174          nextRow=whichRow[i+1];
     4175          nextStart = rowStart[nextRow];
     4176          coin_prefetch_const(column + nextStart);
     4177          coin_prefetch_const(element + nextStart);
     4178          nextEnd = rowStart[nextRow+1];
    41394179          CoinBigIndex j;
    4140           for (j = rowStart[iRow]; j < rowStart[iRow+1]; j++) {
     4180          for (j = start; j < end; j++) {
    41414181               int iColumn = column[j];
    41424182#ifndef NDEBUG
     
    41604200#endif
    41614201     // get rid of tiny values and zero out lookup
    4162      for (i = 0; i < numberNonZero; i++) {
     4202     for (int i = 0; i < numberNonZero; i++) {
    41634203          int iColumn = index[i];
    41644204          marked[iColumn] = 0;
     
    41824222     }
    41834223#ifndef NDEBUG
    4184      for (i = numberNonZero; i < saveN; i++)
     4224     for (int i = numberNonZero; i < saveN; i++)
    41854225          assert(!output[i]);
    4186      for (i = 0; i <= maxColumn; i++)
     4226     for (int i = 0; i <= maxColumn; i++)
    41874227          assert (!marked[i]);
    41884228#endif
     4229     return numberNonZero;
     4230}
     4231int
     4232ClpPackedMatrix::gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector,
     4233          int * COIN_RESTRICT index,
     4234          double * COIN_RESTRICT output,
     4235          double * COIN_RESTRICT array,
     4236          const double tolerance,
     4237          const double scalar) const
     4238{
     4239     const double * COIN_RESTRICT pi = piVector->denseVector();
     4240     int numberNonZero = 0;
     4241     int numberInRowArray = piVector->getNumElements();
     4242     const int * COIN_RESTRICT column = matrix_->getIndices();
     4243     const CoinBigIndex * COIN_RESTRICT rowStart = matrix_->getVectorStarts();
     4244     const double * COIN_RESTRICT element = matrix_->getElements();
     4245     const int * COIN_RESTRICT whichRow = piVector->getIndices();
     4246     // ** Row copy is already scaled
     4247     for (int i = 0; i < numberInRowArray; i++) {
     4248          int iRow = whichRow[i];
     4249          double value = pi[i] * scalar;
     4250          CoinBigIndex j;
     4251          for (j = rowStart[iRow]; j < rowStart[iRow+1]; j++) {
     4252               int iColumn = column[j];
     4253               double inValue = array[iColumn];
     4254               double elValue = element[j];
     4255               elValue *= value;
     4256               if (inValue) {
     4257                 double outValue = inValue + elValue;
     4258                 if (!outValue)
     4259                   outValue = COIN_INDEXED_REALLY_TINY_ELEMENT;
     4260                 array[iColumn] = outValue;
     4261               } else {
     4262                 array[iColumn] = elValue;
     4263                 assert (elValue);
     4264                 index[numberNonZero++] = iColumn;
     4265               }
     4266          }
     4267     }
     4268     int saveN = numberNonZero;
     4269     // get rid of tiny values
     4270     numberNonZero=0;
     4271     for (int i = 0; i < saveN; i++) {
     4272          int iColumn = index[i];
     4273          double value = array[iColumn];
     4274          array[iColumn] =0.0;
     4275          if (fabs(value) > tolerance) {
     4276            output[numberNonZero] = value;
     4277            index[numberNonZero++] = iColumn;
     4278          }
     4279     }
    41894280     return numberNonZero;
    41904281}
     
    51935284               rowStart++;
    51945285               if (nextN) {
    5195                     coin_prefetch(element + nextStart);
     5286                    coin_prefetch_const(element + nextStart);
    51965287                    nextPi = pi[iWhich];
    51975288                    break;
     
    51995290          }
    52005291          CoinBigIndex end = j + n;
    5201           //coin_prefetch(element+rowStart_[i+1]);
    5202           //coin_prefetch(column_+rowStart_[i+1]);
     5292          //coin_prefetch_const(element+rowStart_[i+1]);
     5293          //coin_prefetch_const(column_+rowStart_[i+1]);
    52035294          if (n < 100) {
    52045295               if ((n & 1) != 0) {
     
    52075298                    j++;
    52085299               }
    5209                coin_prefetch(column + nextStart);
     5300               coin_prefetch_const(column + nextStart);
    52105301               for (; j < end; j += 2) {
    52115302                    unsigned int jColumn0 = column[j];
     
    52465337                    j += 4;
    52475338               }
    5248                //coin_prefetch(column+nextStart);
     5339               //coin_prefetch_const(column+nextStart);
    52495340               for (; j < end; j += 8) {
    5250                     coin_prefetch(element + j + 16);
     5341                    coin_prefetch_const(element + j + 16);
    52515342                    unsigned int jColumn0 = column[j];
    52525343                    double value0 = value * element[j];
     
    52615352                    array[jColumn2] -= value2;
    52625353                    array[jColumn3] -= value3;
    5263                     coin_prefetch(column + j + 16);
     5354                    coin_prefetch_const(column + j + 16);
    52645355                    jColumn0 = column[j+4];
    52655356                    value0 = value * element[j+4];
  • trunk/Clp/src/ClpPackedMatrix.hpp

    r1525 r1660  
    420420                                      int * COIN_RESTRICT index,
    421421                                      double * COIN_RESTRICT output,
     422                                      double * COIN_RESTRICT array2,
     423                                      const double tolerance,
     424                                      const double scalar) const;
     425     /// Meat of transposeTimes by row n > 2 if packed - returns number nonzero
     426     int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector * COIN_RESTRICT piVector,
     427                                      int * COIN_RESTRICT index,
     428                                      double * COIN_RESTRICT output,
    422429                                      int * COIN_RESTRICT lookup,
    423430                                      char * COIN_RESTRICT marked,
  • trunk/Clp/src/ClpPresolve.cpp

    r1643 r1660  
    612612#endif
    613613
    614 
    615                     // set up for next pass
    616                     // later do faster if many changes i.e. memset and memcpy
    617                     prob->numberRowsToDo_ = prob->numberNextRowsToDo_;
    618                     //int kcheck;
    619                     //bool found=false;
    620                     //kcheck=-1;
    621                     for (i = 0; i < prob->numberNextRowsToDo_; i++) {
    622                          int index = prob->nextRowsToDo_[i];
    623                          prob->unsetRowChanged(index);
    624                          prob->rowsToDo_[i] = index;
    625                          //if (index==kcheck) {
    626                          //printf("row %d on list after pass %d\n",kcheck,
    627                          //   whichPass);
    628                          //found=true;
    629                          //}
    630                     }
    631                     //if (!found&&kcheck>=0)
    632                     //prob->rowsToDo_[prob->numberRowsToDo_++]=kcheck;
    633                     prob->numberNextRowsToDo_ = 0;
    634                     prob->numberColsToDo_ = prob->numberNextColsToDo_;
    635                     //kcheck=-1;
    636                     //found=false;
    637                     for (i = 0; i < prob->numberNextColsToDo_; i++) {
    638                          int index = prob->nextColsToDo_[i];
    639                          prob->unsetColChanged(index);
    640                          prob->colsToDo_[i] = index;
    641                          //if (index==kcheck) {
    642                          //printf("col %d on list after pass %d\n",kcheck,
    643                          //   whichPass);
    644                          //found=true;
    645                          //}
    646                     }
    647                     //if (!found&&kcheck>=0)
    648                     //prob->colsToDo_[prob->numberColsToDo_++]=kcheck;
    649                     prob->numberNextColsToDo_ = 0;
     614                    {
     615                      // set up for next pass
     616                      // later do faster if many changes i.e. memset and memcpy
     617                      const int * count = prob->hinrow_;
     618                      const int * nextToDo = prob->nextRowsToDo_;
     619                      int * toDo = prob->rowsToDo_;
     620                      int nNext = prob->numberNextRowsToDo_;
     621                      int n = 0;
     622                      for (int i = 0; i < nNext; i++) {
     623                        int index = nextToDo[i];
     624                        prob->unsetRowChanged(index);
     625                        if (count[index])
     626                          toDo[n++] = index;
     627                      }
     628                      prob->numberRowsToDo_ = n;
     629                      prob->numberNextRowsToDo_ = 0;
     630                      count = prob->hincol_;
     631                      nextToDo = prob->nextColsToDo_;
     632                      toDo = prob->colsToDo_;
     633                      nNext = prob->numberNextColsToDo_;
     634                      n = 0;
     635                      for (int i = 0; i < nNext; i++) {
     636                        int index = nextToDo[i];
     637                        prob->unsetColChanged(index);
     638                        if (count[index])
     639                          toDo[n++] = index;
     640                      }
     641                      prob->numberColsToDo_ = n;
     642                      prob->numberNextColsToDo_ = 0;
     643                    }
    650644                    if (paction_ == paction1 && fill_level > 0)
    651645                         break;
     
    654648               int i;
    655649               if (!prob->anyProhibited()) {
    656                     for (i = 0; i < nrows_; i++)
    657                          prob->rowsToDo_[i] = i;
    658                     prob->numberRowsToDo_ = nrows_;
    659                     for (i = 0; i < ncols_; i++)
    660                          prob->colsToDo_[i] = i;
    661                     prob->numberColsToDo_ = ncols_;
     650                 const int * count = prob->hinrow_;
     651                 int * toDo = prob->rowsToDo_;
     652                 int n = 0;
     653                 for (int i = 0; i < nrows_; i++) {
     654                   prob->unsetRowChanged(i);
     655                   if (count[i])
     656                     toDo[n++] = i;
     657                 }
     658                 prob->numberRowsToDo_ = n;
     659                 prob->numberNextRowsToDo_ = 0;
     660                 count = prob->hincol_;
     661                 toDo = prob->colsToDo_;
     662                 n = 0;
     663                 for (int i = 0; i < ncols_; i++) {
     664                   prob->unsetColChanged(i);
     665                   if (count[i])
     666                     toDo[n++] = i;
     667                 }
     668                 prob->numberColsToDo_ = n;
     669                 prob->numberNextColsToDo_ = 0;
    662670               } else {
    663671                    // some stuff must be left alone
  • trunk/Clp/src/ClpSimplex.cpp

    r1641 r1660  
    17371737     // get default value
    17381738     factorization_->sparseThreshold(0);
    1739      factorization_->goSparse();
     1739     if (!(moreSpecialOptions_&1024))
     1740       factorization_->goSparse();
    17401741     //}
    17411742
  • trunk/Clp/src/ClpSimplex.hpp

    r1551 r1660  
    10711071         256 bit - in primal from dual or vice versa
    10721072         512 bit - alternative use of solveType_
     1073         1024 bit - don't do row copy of factorization
    10731074     */
    10741075     inline int moreSpecialOptions() const {
     
    10861087         256 bit - in primal from dual or vice versa
    10871088         512 bit - alternative use of solveType_
     1089         1024 bit - don't do row copy of factorization
    10881090     */
    10891091     inline void setMoreSpecialOptions(int value) {
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1643 r1660  
    13081308     ClpSimplex * small = NULL;
    13091309     if (!returnCode) {
     1310       //printf("CRUNCH from (%d,%d) to (%d,%d)\n",
     1311       //     numberRows_,numberColumns_,numberRows2,numberColumns2);
    13101312          small = new ClpSimplex(this, numberRows2, whichRow,
    13111313                                 numberColumns2, whichColumn, true, false);
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1585 r1660  
    9696#include <stdio.h>
    9797#include <iostream>
     98#ifdef CLP_USER_DRIVEN1
     99/* Returns true if variable sequenceOut can leave basis when
     100   model->sequenceIn() enters.
     101   This function may be entered several times for each sequenceOut. 
     102   The first time realAlpha will be positive if going to lower bound
     103   and negative if going to upper bound (scaled bounds in lower,upper) - then will be zero.
     104   currentValue is distance to bound.
     105   currentTheta is current theta.
     106   alpha is fabs(pivot element).
     107   Variable will change theta if currentValue - currentTheta*alpha < 0.0
     108*/
     109bool userChoiceValid1(const ClpSimplex * model,
     110                      int sequenceOut,
     111                      double currentValue,
     112                      double currentTheta,
     113                      double alpha,
     114                      double realAlpha);
     115/* This returns true if chosen in/out pair valid.
     116   The main thing to check would be variable flipping bounds may be
     117   OK.  This would be signaled by reasonable theta_ and valueOut_.
     118   If you return false sequenceIn_ will be flagged as ineligible.
     119*/
     120bool userChoiceValid2(const ClpSimplex * model);
     121/* If a good pivot then you may wish to unflag some variables.
     122 */
     123void userChoiceWasGood(ClpSimplex * model);
     124#endif
    98125// primal
    99126int ClpSimplexPrimal::primal (int ifValuesPass , int startFinishOptions)
     
    16711698               if (possible) {
    16721699                    value = oldValue - upperTheta * alpha;
     1700#ifdef CLP_USER_DRIVEN1
     1701                    int sequenceOut=pivotVariable_[index[iIndex]];
     1702                    if(!userChoiceValid1(this,sequenceOut,oldValue,
     1703                                         upperTheta,alpha,work[iIndex]*way))
     1704                      value =0.0; // say can't use
     1705#endif
    16731706                    if (value < -primalTolerance_ && alpha >= acceptablePivot) {
    16741707                         upperTheta = (oldValue + primalTolerance_) / alpha;
     
    17351768                    double value = oldValue - upperTheta * alpha;
    17361769
     1770#ifdef CLP_USER_DRIVEN1
     1771                    int sequenceOut=pivotVariable_[index[iIndex]];
     1772                    if(!userChoiceValid1(this,sequenceOut,oldValue,
     1773                                         upperTheta,alpha, 0.0))
     1774                      value =0.0; // say can't use
     1775#endif
    17371776                    if (value < -primalTolerance_ && alpha >= acceptablePivot) {
    17381777                         upperTheta = (oldValue + primalTolerance_) / alpha;
     
    17621801                              theta_ = oldValue / bestPivot;
    17631802                              pivotRow_ = iIndex;
    1764                          } else if (alpha < acceptablePivot) {
     1803                         } else if (alpha < acceptablePivot
     1804#ifdef CLP_USER_DRIVEN1
     1805                      ||!userChoiceValid1(this,pivotVariable_[index[iIndex]],
     1806                                          oldValue,upperTheta,alpha,0.0)
     1807#endif
     1808                                    ) {
    17651809                              if (value < -primalTolerance_)
    17661810                                   sumInfeasibilities += -value - primalTolerance_;
     
    28662910          }
    28672911          if (pivotRow_ >= 0) {
     2912 #ifdef CLP_USER_DRIVEN1
     2913               // Got good pivot - may need to unflag stuff
     2914               userChoiceWasGood(this);
     2915 #endif
    28682916               if (solveType_ == 2 && (moreSpecialOptions_ & 512) == 0) {
    28692917                    // **** Coding for user interface
     
    30013049                    }
    30023050                    rowArray_[0]->clear();
     3051 #ifdef CLP_USER_DRIVEN1
     3052                    /* Note if valueOut_ < COIN_DBL_MAX and
     3053                       theta_ reasonable then this may be a valid sub flip */
     3054                    if(!userChoiceValid2(this)) {
     3055                      if (factorization_->pivots()<5) {
     3056                        // flag variable
     3057                        char x = isColumn(sequenceIn_) ? 'C' : 'R';
     3058                        handler_->message(CLP_SIMPLEX_FLAG, messages_)
     3059                          << x << sequenceWithin(sequenceIn_)
     3060                          << CoinMessageEol;
     3061                        setFlagged(sequenceIn_);
     3062                        progress_.clearBadTimes();
     3063                        roundAgain = true;
     3064                        continue;
     3065                      } else {
     3066                        // try refactorizing first
     3067                        returnCode = 4; //say looks odd but has iterated
     3068                        break;
     3069                      }
     3070                    }
     3071 #endif
    30033072                    if (!factorization_->pivots() && acceptablePivot_ <= 1.0e-8) {
    30043073                         returnCode = 2; //say looks unbounded
Note: See TracChangeset for help on using the changeset viewer.