Changeset 719


Ignore:
Timestamp:
Feb 8, 2006 12:21:29 PM (15 years ago)
Author:
forrest
Message:

minor stuff

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpCholeskyUfl.cpp

    r486 r719  
    88#include "ClpCholeskyUfl.hpp"
    99#include "ClpMessage.hpp"
     10#include "ClpInterior.hpp"
     11#include "CoinHelperFunctions.hpp"
     12#include "ClpHelperFunctions.hpp"
    1013//#############################################################################
    1114// Constructors / Destructor / Assignment
     
    1922{
    2023  type_=14;
     24#ifdef CLP_USE_CHOLMOD
     25  L_= NULL;
     26  cholmod_start (&c_) ;
     27#endif
    2128}
    2229
     
    2734: ClpCholeskyBase(rhs)
    2835{
     36  abort();
    2937}
    3038
     
    3543ClpCholeskyUfl::~ClpCholeskyUfl ()
    3644{
     45  cholmod_free_factor (&L_, &c_) ;
     46  cholmod_finish (&c_) ;               
    3747}
    3848
     
    4555  if (this != &rhs) {
    4656    ClpCholeskyBase::operator=(rhs);
     57    abort();
    4758  }
    4859  return *this;
     
    5566  return new ClpCholeskyUfl(*this);
    5667}
     68#ifndef CLP_USE_CHOLMOD
    5769/* Orders rows and saves pointer to matrix.and model */
    5870int
     
    88100  return 0;
    89101}
     102#else
     103/* Orders rows and saves pointer to matrix.and model */
     104int
     105ClpCholeskyUfl::order(ClpInterior * model)
     106{
     107  numberRows_ = model->numberRows();
     108  rowsDropped_ = new char [numberRows_];
     109  memset(rowsDropped_,0,numberRows_);
     110  numberRowsDropped_=0;
     111  model_=model;
     112  rowCopy_ = model->clpMatrix()->reverseOrderedCopy();
     113  // Space for starts
     114  choleskyStart_ = new CoinBigIndex[numberRows_+1];
     115  const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
     116  const int * columnLength = model_->clpMatrix()->getVectorLengths();
     117  const int * row = model_->clpMatrix()->getIndices();
     118  const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
     119  const int * rowLength = rowCopy_->getVectorLengths();
     120  const int * column = rowCopy_->getIndices();
     121  // We need two arrays for counts
     122  int * which = new int [numberRows_];
     123  int * used = new int[numberRows_+1];
     124  CoinZeroN(used,numberRows_);
     125  int iRow;
     126  sizeFactor_=0;
     127  for (iRow=0;iRow<numberRows_;iRow++) {
     128    int number=1;
     129    // make sure diagonal exists
     130    which[0]=iRow;
     131    used[iRow]=1;
     132    if (!rowsDropped_[iRow]) {
     133      CoinBigIndex startRow=rowStart[iRow];
     134      CoinBigIndex endRow=rowStart[iRow]+rowLength[iRow];
     135      for (CoinBigIndex k=startRow;k<endRow;k++) {
     136        int iColumn=column[k];
     137        CoinBigIndex start=columnStart[iColumn];
     138        CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
     139        for (CoinBigIndex j=start;j<end;j++) {
     140          int jRow=row[j];
     141          if (jRow>=iRow&&!rowsDropped_[jRow]) {
     142            if (!used[jRow]) {
     143              used[jRow]=1;
     144              which[number++]=jRow;
     145            }
     146          }
     147        }
     148      }
     149      sizeFactor_ += number;
     150      int j;
     151      for (j=0;j<number;j++)
     152        used[which[j]]=0;
     153    }
     154  }
     155  delete [] which;
     156  // Now we have size - create arrays and fill in
     157  try {
     158    choleskyRow_ = new int [sizeFactor_];
     159  }
     160  catch (...) {
     161    // no memory
     162    delete [] choleskyStart_;
     163    choleskyStart_=NULL;
     164    return -1;
     165  }
     166  try {
     167    sparseFactor_ = new double[sizeFactor_];
     168  }
     169  catch (...) {
     170    // no memory
     171    delete [] choleskyRow_;
     172    choleskyRow_=NULL;
     173    delete [] choleskyStart_;
     174    choleskyStart_=NULL;
     175    return -1;
     176  }
     177 
     178  sizeFactor_=0;
     179  which = choleskyRow_;
     180  for (iRow=0;iRow<numberRows_;iRow++) {
     181    int number=1;
     182    // make sure diagonal exists
     183    which[0]=iRow;
     184    used[iRow]=1;
     185    choleskyStart_[iRow]=sizeFactor_;
     186    if (!rowsDropped_[iRow]) {
     187      CoinBigIndex startRow=rowStart[iRow];
     188      CoinBigIndex endRow=rowStart[iRow]+rowLength[iRow];
     189      for (CoinBigIndex k=startRow;k<endRow;k++) {
     190        int iColumn=column[k];
     191        CoinBigIndex start=columnStart[iColumn];
     192        CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
     193        for (CoinBigIndex j=start;j<end;j++) {
     194          int jRow=row[j];
     195          if (jRow>=iRow&&!rowsDropped_[jRow]) {
     196            if (!used[jRow]) {
     197              used[jRow]=1;
     198              which[number++]=jRow;
     199            }
     200          }
     201        }
     202      }
     203      sizeFactor_ += number;
     204      int j;
     205      for (j=0;j<number;j++)
     206        used[which[j]]=0;
     207      // Sort
     208      std::sort(which,which+number);
     209      // move which on
     210      which += number;
     211    }
     212  }
     213  choleskyStart_[numberRows_]=sizeFactor_;
     214  delete [] used;
     215  permuteInverse_ = new int [numberRows_];
     216  permute_ = new int[numberRows_];
     217  cholmod_sparse A ;
     218  A.nrow=numberRows_;
     219  A.ncol=numberRows_;
     220  A.nzmax=choleskyStart_[numberRows_];
     221  A.p = choleskyStart_;
     222  A.i = choleskyRow_;
     223  A.x=NULL;
     224  A.stype=-1;
     225  A.itype=CHOLMOD_INT;
     226  A.xtype=CHOLMOD_PATTERN;
     227  A.dtype=CHOLMOD_DOUBLE;
     228  A.sorted=1;
     229  A.packed=1;
     230  c_.nmethods=9;
     231  c_.postorder=true;
     232  //c_.dbound=1.0e-20;
     233  L_ = cholmod_analyze (&A, &c_) ;
     234  if (c_.status) {
     235    std::cout<<"CHOLMOD ordering failed"<<std::endl;
     236    return 1;
     237  } else {
     238    printf("%g nonzeros, flop count %g\n",c_.lnz,c_.fl);
     239  }
     240  for (iRow=0;iRow<numberRows_;iRow++) {
     241    permuteInverse_[iRow]=iRow;
     242    permute_[iRow]=iRow;
     243  }
     244  return 0;
     245}
     246/* Does Symbolic factorization given permutation.
     247   This is called immediately after order.  If user provides this then
     248   user must provide factorize and solve.  Otherwise the default factorization is used
     249   returns non-zero if not enough memory */
     250int
     251ClpCholeskyUfl::symbolic()
     252{
     253  return 0;
     254}
     255/* Factorize - filling in rowsDropped and returning number dropped */
     256int
     257ClpCholeskyUfl::factorize(const double * diagonal, int * rowsDropped)
     258{
     259  const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
     260  const int * columnLength = model_->clpMatrix()->getVectorLengths();
     261  const int * row = model_->clpMatrix()->getIndices();
     262  const double * element = model_->clpMatrix()->getElements();
     263  const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
     264  const int * rowLength = rowCopy_->getVectorLengths();
     265  const int * column = rowCopy_->getIndices();
     266  const double * elementByRow = rowCopy_->getElements();
     267  int numberColumns=model_->clpMatrix()->getNumCols();
     268  int iRow;
     269  double * work = new double[numberRows_];
     270  CoinZeroN(work,numberRows_);
     271  const double * diagonalSlack = diagonal + numberColumns;
     272  int newDropped=0;
     273  double largest;
     274  //double smallest;
     275  //perturbation
     276  double perturbation=model_->diagonalPerturbation()*model_->diagonalNorm();
     277  perturbation=0.0;
     278  perturbation=perturbation*perturbation;
     279  if (perturbation>1.0) {
     280    //if (model_->model()->logLevel()&4)
     281      std::cout <<"large perturbation "<<perturbation<<std::endl;
     282    perturbation=sqrt(perturbation);;
     283    perturbation=1.0;
     284  }
     285  double delta2 = model_->delta(); // add delta*delta to diagonal
     286  delta2 *= delta2;
     287  for (iRow=0;iRow<numberRows_;iRow++) {
     288    double * put = sparseFactor_+choleskyStart_[iRow];
     289    int * which = choleskyRow_+choleskyStart_[iRow];
     290    int number = choleskyStart_[iRow+1]-choleskyStart_[iRow];
     291    if (!rowLength[iRow])
     292      rowsDropped_[iRow]=1;
     293    if (!rowsDropped_[iRow]) {
     294      CoinBigIndex startRow=rowStart[iRow];
     295      CoinBigIndex endRow=rowStart[iRow]+rowLength[iRow];
     296      work[iRow] = diagonalSlack[iRow]+delta2;
     297      for (CoinBigIndex k=startRow;k<endRow;k++) {
     298        int iColumn=column[k];
     299        if (!whichDense_||!whichDense_[iColumn]) {
     300          CoinBigIndex start=columnStart[iColumn];
     301          CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
     302          double multiplier = diagonal[iColumn]*elementByRow[k];
     303          for (CoinBigIndex j=start;j<end;j++) {
     304            int jRow=row[j];
     305            if (jRow>=iRow&&!rowsDropped_[jRow]) {
     306              double value=element[j]*multiplier;
     307              work[jRow] += value;
     308            }
     309          }
     310        }
     311      }
     312      int j;
     313      for (j=0;j<number;j++) {
     314        int jRow = which[j];
     315        put[j]=work[jRow];
     316        work[jRow]=0.0;
     317      }
     318    } else {
     319      // dropped
     320      int j;
     321      for (j=1;j<number;j++) {
     322        put[j]=0.0;
     323      }
     324      put[0]=1.0;
     325    }
     326  }
     327  //check sizes
     328  double largest2=maximumAbsElement(sparseFactor_,sizeFactor_);
     329  largest2*=1.0e-20;
     330  largest = CoinMin(largest2,1.0e-11);
     331  int numberDroppedBefore=0;
     332  for (iRow=0;iRow<numberRows_;iRow++) {
     333    int dropped=rowsDropped_[iRow];
     334    // Move to int array
     335    rowsDropped[iRow]=dropped;
     336    if (!dropped) {
     337      CoinBigIndex start = choleskyStart_[iRow];
     338      double diagonal = sparseFactor_[start];
     339      if (diagonal>largest2) {
     340        sparseFactor_[start]=CoinMax(diagonal,1.0e-10);
     341      } else {
     342        sparseFactor_[start]=CoinMax(diagonal,1.0e-10);
     343        rowsDropped[iRow]=2;
     344        numberDroppedBefore++;
     345      }
     346    }
     347  }
     348  delete [] work;
     349  cholmod_sparse A ;
     350  A.nrow=numberRows_;
     351  A.ncol=numberRows_;
     352  A.nzmax=choleskyStart_[numberRows_];
     353  A.p = choleskyStart_;
     354  A.i = choleskyRow_;
     355  A.x=sparseFactor_;
     356  A.stype=-1;
     357  A.itype=CHOLMOD_INT;
     358  A.xtype=CHOLMOD_REAL;
     359  A.dtype=CHOLMOD_DOUBLE;
     360  A.sorted=1;
     361  A.packed=1;
     362  cholmod_factorize (&A, L_, &c_) ;                 /* factorize */
     363  choleskyCondition_=1.0;
     364  bool cleanCholesky;
     365  if (model_->numberIterations()<2000)
     366    cleanCholesky=true;
     367  else
     368    cleanCholesky=false;
     369  if (cleanCholesky) {
     370    //drop fresh makes some formADAT easier
     371    //int oldDropped=numberRowsDropped_;
     372    if (newDropped||numberRowsDropped_) {
     373      //std::cout <<"Rank "<<numberRows_-newDropped<<" ( "<<
     374      //  newDropped<<" dropped)";
     375      //if (newDropped>oldDropped)
     376      //std::cout<<" ( "<<newDropped-oldDropped<<" dropped this time)";
     377      //std::cout<<std::endl;
     378      newDropped=0;
     379      for (int i=0;i<numberRows_;i++) {
     380        char dropped = rowsDropped[i];
     381        rowsDropped_[i]=dropped;
     382        if (dropped==2) {
     383          //dropped this time
     384          rowsDropped[newDropped++]=i;
     385          rowsDropped_[i]=0;
     386        }
     387      }
     388      numberRowsDropped_=newDropped;
     389      newDropped=-(2+newDropped);
     390    }
     391  } else {
     392    if (newDropped) {
     393      newDropped=0;
     394      for (int i=0;i<numberRows_;i++) {
     395        char dropped = rowsDropped[i];
     396        rowsDropped_[i]=dropped;
     397        if (dropped==2) {
     398          //dropped this time
     399          rowsDropped[newDropped++]=i;
     400          rowsDropped_[i]=1;
     401        }
     402      }
     403    }
     404    numberRowsDropped_+=newDropped;
     405    if (numberRowsDropped_&&0) {
     406      std::cout <<"Rank "<<numberRows_-numberRowsDropped_<<" ( "<<
     407          numberRowsDropped_<<" dropped)";
     408      if (newDropped) {
     409        std::cout<<" ( "<<newDropped<<" dropped this time)";
     410      }
     411      std::cout<<std::endl;
     412    }
     413  }
     414  status_=0;
     415  return newDropped;
     416}
     417/* Uses factorization to solve. */
     418void
     419ClpCholeskyUfl::solve (double * region)
     420{
     421  cholmod_dense *x, *b;
     422  b = cholmod_allocate_dense (numberRows_, 1, numberRows_, CHOLMOD_REAL, &c_) ;
     423  CoinMemcpyN(region,numberRows_,(double *) b->x);
     424  x = cholmod_solve (CHOLMOD_A, L_, b, &c_) ;
     425  CoinMemcpyN((double *) x->x,numberRows_,region);
     426  cholmod_free_dense (&x, &c_) ;
     427  cholmod_free_dense (&b, &c_) ;
     428}
    90429#endif
     430#endif
  • trunk/ClpInterior.cpp

    r414 r719  
    11661166        if (fixedOrFree(i+numberColumns_)) {
    11671167          if (rowActivity_[i]-rowLower_[i]<rowUpper_[i]-rowActivity_[i]) {
    1168             rowUpper_[i]=rowLower_[i];
     1168            if (reallyFix)
     1169              rowUpper_[i]=rowLower_[i];
    11691170            rowActivity_[i]=rowLower_[i];
    11701171          } else {
    1171             rowLower_[i]=rowUpper_[i];
     1172            if (reallyFix)
     1173              rowLower_[i]=rowUpper_[i];
    11721174            rowActivity_[i]=rowUpper_[i];
    11731175          }
  • trunk/ClpSolve.cpp

    r716 r719  
    15381538      currentModel2 = &barrier;
    15391539    int barrierOptions = options.getSpecialOption(4);
    1540     bool aggressiveGamma=false;
     1540    int aggressiveGamma=0;
     1541    bool presolveInCrossover=false;
    15411542    bool scale=false;
    15421543    bool doKKT=false;
    1543     if (barrierOptions&32) {
    1544       barrierOptions &= ~32;
    1545       doKKT=true;
    1546     }
    15471544    if (barrierOptions&16) {
    15481545      barrierOptions &= ~16;
    1549       aggressiveGamma=true;
     1546      doKKT=true;
     1547    }
     1548    if (barrierOptions&(32+64+128)) {
     1549      aggressiveGamma=(barrierOptions&(32+64+128))>>5;
     1550      barrierOptions &= ~(32+64+128);
     1551    }
     1552    if (barrierOptions&256) {
     1553      barrierOptions &= ~256;
     1554      presolveInCrossover=true;
    15501555    }
    15511556    if (barrierOptions&8) {
     
    16331638    }
    16341639#ifndef SAVEIT
    1635     //barrier.setGamma(1.0e-8);
    1636     //barrier.setDelta(1.0e-8);
    1637     barrier.setDiagonalPerturbation(1.0e-14);
     1640    //barrier.setDiagonalPerturbation(1.0e-25);
    16381641    if (aggressiveGamma) {
    1639       barrier.setGamma(1.0e-3);
    1640       barrier.setDelta(1.0e-3);
     1642      switch (aggressiveGamma) {
     1643      case 1:
     1644        barrier.setGamma(1.0e-5);
     1645        barrier.setDelta(1.0e-5);
     1646        break;
     1647      case 2:
     1648        barrier.setGamma(1.0e-5);
     1649        break;
     1650      case 3:
     1651        barrier.setDelta(1.0e-5);
     1652        break;
     1653      case 4:
     1654        barrier.setGamma(1.0e-3);
     1655        barrier.setDelta(1.0e-3);
     1656        break;
     1657      case 5:
     1658        barrier.setGamma(1.0e-3);
     1659        break;
     1660      case 6:
     1661        barrier.setDelta(1.0e-3);
     1662        break;
     1663      }
    16411664    }
    16421665    if (scale)
     
    16731696    ClpPresolve pinfo2;
    16741697    ClpSimplex * saveModel2=NULL;
     1698    bool extraPresolve=false;
    16751699    int numberFixed = barrier.numberFixed();
    1676     if (numberFixed*20>barrier.numberRows()&&numberFixed>5000&&0) {
    1677       // may as well do presolve
     1700    if (numberFixed) {
    16781701      int numberRows = barrier.numberRows();
    16791702      int numberColumns = barrier.numberColumns();
     
    16851708      CoinMemcpyN(barrier.columnUpper(),numberColumns,saveUpper);
    16861709      CoinMemcpyN(barrier.rowUpper(),numberRows,saveUpper+numberColumns);
     1710    }
     1711    if (numberFixed*20>barrier.numberRows()&&numberFixed>5000&&
     1712        presolveInCrossover) {
     1713      // may as well do presolve
    16871714      barrier.fixFixed();
    16881715      saveModel2=model2;
     1716      extraPresolve=true;
    16891717    } else if (numberFixed) {
    16901718      // Set fixed to bounds (may have restored earlier solution)
     
    17281756        model2=saveModel2;
    17291757        saveModel2=NULL;
    1730         delete [] saveLower;
     1758        int numberRows = model2->numberRows();
     1759        int numberColumns = model2->numberColumns();
     1760        CoinMemcpyN(saveLower,numberColumns,model2->columnLower());
     1761        CoinMemcpyN(saveLower+numberColumns,numberRows,model2->rowLower());
     1762        delete [] saveLower;
     1763        CoinMemcpyN(saveUpper,numberColumns,model2->columnUpper());
     1764        CoinMemcpyN(saveUpper+numberColumns,numberRows,model2->rowUpper());
     1765        delete [] saveUpper;
    17311766        saveLower=NULL;
    1732         delete [] saveUpper;
    17331767        saveUpper=NULL;
    17341768      }
     
    17891823        }
    17901824        if (gap<1.0e-3*((double) (numberRows+numberColumns))) {
     1825          if (saveUpper) {
     1826            int numberRows = model2->numberRows();
     1827            int numberColumns = model2->numberColumns();
     1828            CoinMemcpyN(saveLower,numberColumns,model2->columnLower());
     1829            CoinMemcpyN(saveLower+numberColumns,numberRows,model2->rowLower());
     1830            delete [] saveLower;
     1831            CoinMemcpyN(saveUpper,numberColumns,model2->columnUpper());
     1832            CoinMemcpyN(saveUpper+numberColumns,numberRows,model2->rowUpper());
     1833            delete [] saveUpper;
     1834            saveLower=NULL;
     1835            saveUpper=NULL;
     1836          }
    17911837          int numberRows = model2->numberRows();
    17921838          int numberColumns = model2->numberColumns();
     
    18941940    delete [] columnDual;
    18951941#endif
    1896     if (saveLower) {
     1942    if (extraPresolve) {
    18971943      pinfo2.postsolve(true);
    18981944      delete model2;
    18991945      model2=saveModel2;
     1946    }
     1947    if (saveUpper) {
    19001948      int numberRows = model2->numberRows();
    19011949      int numberColumns = model2->numberColumns();
     
    19061954      CoinMemcpyN(saveUpper+numberColumns,numberRows,model2->rowUpper());
    19071955      delete [] saveUpper;
     1956      saveLower=NULL;
     1957      saveUpper=NULL;
    19081958      model2->primal(1);
    19091959    }
  • trunk/IdiSolve.cpp

    r399 r719  
    128128Idiot::IdiSolve(
    129129                    int nrows, int ncols, double * rowsol , double * colsol,
    130               double * pi, double * djs, const double * origcost , const double * rowlower,
     130              double * pi, double * djs, const double * origcost , double * rowlower,
    131131              double * rowupper, const double * lower,
    132132              const double * upper, const double * elemnt,
     
    241241    saveExtra=new double[extraBlock];
    242242    extraBlock=0;
     243    int nbad=0;
    243244    for (i=0;i<nrows;i++) {
    244245      if (rowupper[i]-rowlower[i]>tolerance) {
     
    254255        }
    255256        if (fabs(smaller)>1.0e10) {
    256           printf("Can't handle rows where both bounds >1.0e10 %d %g\n",
    257                  i,smaller);
    258           abort();
     257          if (!nbad)
     258            printf("Can't handle rows where both bounds >1.0e10 %d %g\n",
     259                   i,smaller);
     260          nbad++;
     261          if (rowupper[i]<0.0||rowlower[i]>0.0)
     262            abort();
     263          if (fabs(rowupper[i])>fabs(rowlower[i])) {
     264            rowlower[i]=-0.9e10;
     265            smaller = rowlower[i];
     266            value=-1.0;
     267          } else {
     268            rowupper[i]=0.9e10;
     269            saveExtra[extraBlock]=rowupper[i];
     270            smaller = rowupper[i];
     271            value=1.0;
     272          }
    259273        }
    260274        difference=rowupper[i]-rowlower[i];
     
    271285      }
    272286    }
     287    if (nbad)
     288      printf("%d bad values - results may be wrong\n",nbad);
    273289  }
    274290  for (i=0;i<nrows;i++) {
  • trunk/Idiot.cpp

    r619 r719  
    225225  double * lower = model_->columnLower();
    226226  double * upper = model_->columnUpper();
    227   double * rowlower= model_->rowLower();
    228227#else
    229228  double * cost = new double [ncols];
     
    231230  const double * lower = model_->getColLower();
    232231  const double * upper = model_->getColUpper();
    233   const double * rowlower= model_->getRowLower();
    234232#endif
    235233  const double *elemXX;
     
    237235  double * rowupper= new double[nrows]; // not const as modified
    238236  memcpy(rowupper,model_->getRowUpper(),nrows*sizeof(double));
     237  double * rowlower= new double[nrows]; // not const as modified
     238  memcpy(rowlower,model_->getRowLower(),nrows*sizeof(double));
    239239  int * whenUsed;
    240240  double * lambda;
     
    323323        cost[icol] *= columnScale[icol];
    324324      }
    325       rowlower = new double[nrows];
    326325      memcpy(rowlower,model_->rowLower(),nrows*sizeof(double));
    327326      for (irow=0;irow<nrows;irow++) {
     
    673672    upper = model_->columnUpper();
    674673    cost = model_->objective();
    675     rowlower = model_->rowLower();
     674    //rowlower = model_->rowLower();
    676675  }
    677676#endif
     
    787786  delete [] pi;
    788787  delete [] dj;
     788  delete [] rowlower;
     789  delete [] rowupper;
    789790  return ;
    790791}
  • trunk/Test/CbcOrClpParam.cpp

    r717 r719  
    12201220  parameters[numberParameters-1].append("off");
    12211221  parameters[numberParameters-1].append("maybe");
     1222  parameters[numberParameters-1].append("presolve");
    12221223  parameters[numberParameters-1].setLonghelp
    12231224    (
     
    14221423#endif
    14231424  parameters[numberParameters++]=
    1424     CbcOrClpParam("gamma","Whether to regularize barrier",
     1425    CbcOrClpParam("gamma!(Delta)","Whether to regularize barrier",
    14251426                  "off",GAMMA,0,false);
    14261427  parameters[numberParameters-1].append("on");
     1428  parameters[numberParameters-1].append("gamma");
     1429  parameters[numberParameters-1].append("delta");
     1430  parameters[numberParameters-1].append("onstrong");
     1431  parameters[numberParameters-1].append("gammastrong");
     1432  parameters[numberParameters-1].append("deltastrong");
    14271433#endif
    14281434#ifdef COIN_USE_CBC
     
    19641970     );
    19651971#ifdef COIN_USE_CLP
     1972  parameters[numberParameters++]=
     1973    CbcOrClpParam("reallyO!bjectiveScale","Scale factor to apply to objective in place",
     1974                  -1.0e20,1.0e20,OBJSCALE2,false);
     1975  parameters[numberParameters-1].setLonghelp
     1976    (
     1977     "You can set this to -1.0 to test maximization or other to stress code"
     1978     );
     1979  parameters[numberParameters-1].setDoubleValue(1.0);
    19661980  parameters[numberParameters++]=
    19671981    CbcOrClpParam("reallyS!cale","Scales model in place",
  • trunk/Test/CbcOrClpParam.hpp

    r717 r719  
    4848    TIMELIMIT_BAB,
    4949   
    50     DJFIX = 81, GAPRATIO,TIGHTENFACTOR,PRESOLVETOLERANCE,
     50    DJFIX = 81, GAPRATIO,TIGHTENFACTOR,PRESOLVETOLERANCE,OBJSCALE2,
    5151
    5252    SOLVERLOGLEVEL=101,
  • trunk/Test/ClpMain.cpp

    r707 r719  
    153153    std::cout<<"Coin LP version "<<CLPVERSION
    154154             <<", build "<<__DATE__<<std::endl;
     155    // Print command line
     156    if (argc>1) {
     157      printf("command line - ");
     158      for (int i=0;i<argc;i++)
     159        printf("%s ",argv[i]);
     160      printf("\n");
     161    }
    155162   
    156163    while (1) {
     
    457464          case BAB:
    458465            if (goodModels[iModel]) {
     466              double objScale =
     467                parameters[whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();
     468              if (objScale!=1.0) {
     469                int iColumn;
     470                int numberColumns=models[iModel].numberColumns();
     471                double * dualColumnSolution =
     472                  models[iModel].dualColumnSolution();
     473                ClpObjective * obj = models[iModel].objectiveAsObject();
     474                assert(dynamic_cast<ClpLinearObjective *> (obj));
     475                double offset;
     476                double * objective = obj->gradient(NULL,NULL,offset,true);
     477                for (iColumn=0;iColumn<numberColumns;iColumn++) {
     478                  dualColumnSolution[iColumn] *= objScale;
     479                  objective[iColumn] *= objScale;;
     480                }
     481                int iRow;
     482                int numberRows=models[iModel].numberRows();
     483                double * dualRowSolution =
     484                  models[iModel].dualRowSolution();
     485                for (iRow=0;iRow<numberRows;iRow++)
     486                  dualRowSolution[iRow] *= objScale;
     487                models[iModel].setObjectiveOffset(objScale*models[iModel].objectiveOffset());
     488              }
    459489              ClpSolve::SolveType method;
    460490              ClpSolve::PresolveType presolveType;
     
    557587                if (scaleBarrier)
    558588                  barrierOptions |= 8;
     589                if (doKKT)
     590                  barrierOptions |= 16;
    559591                if (gamma)
    560                   barrierOptions |= 16;
    561                 if (doKKT)
    562                   barrierOptions |= 32;
     592                  barrierOptions |= 32*gamma;
     593                if (crossover==3)
     594                  barrierOptions |= 256; // try presolve in crossover
    563595                solveOptions.setSpecialOption(4,barrierOptions);
    564596              }
     
    785817          case EXPORT:
    786818            if (goodModels[iModel]) {
     819              double objScale =
     820                parameters[whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();
     821              if (objScale!=1.0) {
     822                int iColumn;
     823                int numberColumns=models[iModel].numberColumns();
     824                double * dualColumnSolution =
     825                  models[iModel].dualColumnSolution();
     826                ClpObjective * obj = models[iModel].objectiveAsObject();
     827                assert(dynamic_cast<ClpLinearObjective *> (obj));
     828                double offset;
     829                double * objective = obj->gradient(NULL,NULL,offset,true);
     830                for (iColumn=0;iColumn<numberColumns;iColumn++) {
     831                  dualColumnSolution[iColumn] *= objScale;
     832                  objective[iColumn] *= objScale;;
     833                }
     834                int iRow;
     835                int numberRows=models[iModel].numberRows();
     836                double * dualRowSolution =
     837                  models[iModel].dualRowSolution();
     838                for (iRow=0;iRow<numberRows;iRow++)
     839                  dualRowSolution[iRow] *= objScale;
     840                models[iModel].setObjectiveOffset(objScale*models[iModel].objectiveOffset());
     841              }
    787842              // get next field
    788843              field = CoinReadGetString(argc,argv);
     
    11851240              double * objective = obj->gradient(NULL,NULL,offset,true);
    11861241              for (iColumn=0;iColumn<numberColumns;iColumn++) {
    1187                 dualColumnSolution[iColumn] = dualColumnSolution[iColumn];
     1242                dualColumnSolution[iColumn] = -dualColumnSolution[iColumn];
    11881243                objective[iColumn] = -objective[iColumn];
    11891244              }
     
    11931248                models[iModel].dualRowSolution();
    11941249              for (iRow=0;iRow<numberRows;iRow++)
    1195                 dualRowSolution[iRow] = dualRowSolution[iRow];
    1196               models[iModel].setObjectiveOffset(models[iModel].objectiveOffset());
     1250                dualRowSolution[iRow] = -dualRowSolution[iRow];
     1251              models[iModel].setObjectiveOffset(-models[iModel].objectiveOffset());
    11971252            }
    11981253            break;
  • trunk/include/ClpCholeskyUfl.hpp

    r664 r719  
    33#ifndef ClpCholeskyUfl_H
    44#define ClpCholeskyUfl_H
    5 
    65#include "ClpCholeskyBase.hpp"
    76#ifdef __cplusplus
    87extern "C"{
    98#endif
     9#ifndef CLP_USE_CHOLMOD
    1010#include "amd.h"
     11#else
     12#include "cholmod.h"
     13#endif
    1114#ifdef __cplusplus
    1215          }
     
    2326for terms of use
    2427
     28If  you wish to use CHOLMOD code from University of Florida see
     29
     30    http://www.cise.ufl.edu/research/sparse/cholmod
     31
     32for terms of use
     33
    2534*/
    2635class ClpCholeskyUfl : public ClpCholeskyBase {
     
    3241   Returns non-zero if not enough memory */
    3342  virtual int order(ClpInterior * model) ;
     43#ifdef CLP_USE_CHOLMOD
     44  /** Does Symbolic factorization given permutation.
     45      This is called immediately after order.  If user provides this then
     46      user must provide factorize and solve.  Otherwise the default factorization is used
     47      returns non-zero if not enough memory */
     48  virtual int symbolic();
     49  /** Factorize - filling in rowsDropped and returning number dropped.
     50      If return code negative then out of memory */
     51  virtual int factorize(const double * diagonal, int * rowsDropped) ;
     52  /** Uses factorization to solve. */
     53  virtual void solve (double * region) ;
     54#endif
    3455  //@}
    3556
     
    5273   
    5374private:
     75#ifdef CLP_USE_CHOLMOD
     76    cholmod_factor * L_ ;
     77    cholmod_common c_ ;
     78#endif
    5479};
    5580
  • trunk/include/Idiot.hpp

    r440 r719  
    179179                     int nrows, int ncols, double * rowsol , double * colsol,
    180180                     double * pi, double * djs, const double * origcost ,
    181                      const double * rowlower,
     181                     double * rowlower,
    182182                     double * rowupper, const double * lower,
    183183                     const double * upper, const double * element,
Note: See TracChangeset for help on using the changeset viewer.