Changeset 183 for branches


Ignore:
Timestamp:
Jul 21, 2003 1:16:14 PM (16 years ago)
Author:
forrest
Message:

Quadratic changes

Location:
branches/pre
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpModel.cpp

    r180 r183  
    12251225  quadraticObjective_ = NULL;
    12261226}
     1227void
     1228ClpModel::setObjective(const ClpObjective * objective)
     1229{
     1230  delete objective_;
     1231  objective_=objective->clone();
     1232}
    12271233// Returns resized array and updates size
    12281234double * whichDouble(double * array , int number, const int * which)
  • branches/pre/ClpPrimalQuadraticDantzig.cpp

    r181 r183  
    2525{
    2626  type_=1;
    27   originalNumberRows_ = 0;
     27  quadraticInfo_=NULL;
    2828}
    2929
     
    3434: ClpPrimalColumnPivot(source)
    3535
    36   originalNumberRows_ = source.originalNumberRows_;
     36  quadraticInfo_=source.quadraticInfo_;
    3737
    3838}
    3939// Constructor from model
    4040ClpPrimalQuadraticDantzig::ClpPrimalQuadraticDantzig(
    41                   ClpSimplexPrimalQuadratic * model, int originalNumberRows)
     41                  ClpSimplexPrimalQuadratic * model,
     42                  ClpQuadraticInfo * info)
    4243  :ClpPrimalColumnPivot()
    4344{
     
    4546  // Safe as has no extra data
    4647  model_=(ClpSimplex *) model;
    47   originalNumberRows_ = originalNumberRows;
     48  quadraticInfo_ = info;
    4849}
    4950
     
    6465  if (this != &rhs) {
    6566    ClpPrimalColumnPivot::operator=(rhs);
    66     originalNumberRows_ = rhs.originalNumberRows_;
     67    quadraticInfo_ = rhs.quadraticInfo_;
    6768  }
    6869  return *this;
     
    7980  assert(model_);
    8081  // Find out where stuff is
    81   int originalNumberColumns = model_->numberRows()-originalNumberRows_;
     82  int originalNumberColumns = quadraticInfo_->numberXColumns();
    8283  int start = model_->numberRows();
    8384  double * solution = model_->solutionRegion();
     
    9697  int iSequence;
    9798  assert (!model_->scalingFlag());
    98 
     99  const double * pi = solution+quadraticInfo_->numberXColumns();
     100  // Matrix for linear stuff
     101  CoinPackedMatrix * matrix = model_->matrix();
     102  const int * row = matrix->getIndices();
     103  const int * columnStart = matrix->getVectorStarts();
     104  const double * element =  matrix->getElements();
     105  const int * columnLength = matrix->getVectorLengths();
     106  const int * which = quadraticInfo_->quadraticSequence();
     107  const double * objective = quadraticInfo_->originalObjective();
    99108  for (iSequence=0;iSequence<originalNumberColumns;iSequence++) {
    100     int jSequence = iSequence + start;
    101     double value = solution[jSequence];
     109    int jSequence = which[iSequence];
     110    double value;
     111    if (jSequence>=0) {
     112      jSequence += start;
     113      value = solution[jSequence];
     114    } else {
     115      value=objective[iSequence];
     116      int j;
     117      for (j=columnStart[iSequence];j<columnStart[iSequence]+columnLength[iSequence]; j++) {
     118        int iRow = row[j];
     119        value -= element[j]*pi[iRow];
     120      }
     121    }
    102122    ClpSimplex::Status status = model_->getStatus(iSequence);
    103123   
     
    140160  double * upper = model_->upperRegion()+model_->numberColumns();
    141161  int jSequence;
    142   for (jSequence=0;jSequence<originalNumberRows_;jSequence++) {
     162  int originalNumberRows = quadraticInfo_->numberXRows();
     163  for (jSequence=0;jSequence<originalNumberRows;jSequence++) {
    143164    int iSequence  = jSequence + firstSlack;
    144165    int iPi = jSequence+originalNumberColumns;
  • branches/pre/ClpSimplexPrimalQuadratic.cpp

    r182 r183  
    1111#include "ClpFactorization.hpp"
    1212#include "ClpNonLinearCost.hpp"
    13 #include "CoinPackedMatrix.hpp"
     13#include "ClpPackedMatrix.hpp"
    1414#include "CoinIndexedVector.hpp"
    1515#include "CoinWarmStartBasis.hpp"
     
    881881#endif 
    882882  // Now do quadratic
    883   ClpPrimalQuadraticDantzig dantzigP(model2,numberRows_);
     883  ClpPrimalQuadraticDantzig dantzigP(model2,&info);
    884884  model2->setPrimalColumnPivotAlgorithm(dantzigP);
    885885  model2->messageHandler()->setLogLevel(63);
    886   model2->primalQuadratic2(this,phase);
     886  model2->primalQuadratic2(&info,phase);
    887887  endQuadratic(model2,info);
    888888  return 0;
    889889#endif
    890890}
    891 int ClpSimplexPrimalQuadratic::primalQuadratic2 (const ClpSimplexPrimalQuadratic * originalModel,int phase)
     891int ClpSimplexPrimalQuadratic::primalQuadratic2 (ClpQuadraticInfo * info,
     892                                                 int phase)
    892893{
    893894
     
    896897  // save data
    897898  ClpDataSave data = saveData();
     899  // Only ClpPackedMatrix at present
     900  assert ((dynamic_cast< ClpPackedMatrix*>(matrix_)));
    898901 
    899902  // Assume problem is feasible
    900903  // Stuff below will be moved into a class
    901   int numberXColumns = originalModel->numberColumns();
    902   int numberXRows = originalModel->numberRows();
    903   int baseS = numberXColumns+numberXRows;
    904   int * pair = new int [numberColumns_];
    905   int iColumn;
    906   for (iColumn=0;iColumn<numberXColumns;iColumn++) {
    907     int iS = iColumn+baseS;
    908     pair[iColumn]=iS;
    909     pair[iS]=iColumn;
    910   }
    911 #if 0
    912   // Throw out all x variables whose dj is nonzero
    913   for (iColumn=0;iColumn<numberXColumns;iColumn++) {
    914     if (getColumnStatus(iColumn)==basic) {
    915       int jColumn = iColumn+numberRows_;
    916       if (getColumnStatus(jColumn)==basic)
    917         setColumnStatus(iColumn,superBasic);
    918     }
    919   } 
    920   int originalNumberRows = originalModel->numberRows();
    921   for (int i=0;i<originalNumberRows;i++) {
    922     int jSequence = i+numberXColumns;
    923     if (getRowStatus(i)==basic)
    924       setColumnStatus(jSequence,superBasic);
    925   }
    926 #endif
     904  int numberXColumns = info->numberXColumns();
     905  int numberXRows = info->numberXRows();
     906  const int * which = info->quadraticSequence();
     907  //const int * back = info->backSequence();
    927908  // Save solution
    928909  double * saveSolution = new double [numberRows_+numberColumns_];
     
    934915
    935916    // Setup useful stuff
    936     ClpQuadraticInfo info(originalModel);
     917    //ClpQuadraticInfo info(originalModel);
    937918    if (phase)
    938919      memcpy(solution_,saveSolution,
     
    940921    int lastCleaned=0; // last time objective or bounds cleaned up
    941922    int sequenceIn=-1;
    942     int crucialSj=-1;
     923    info->setCrucialSj(-1);
    943924   
    944925    // special nonlinear cost
    945926    delete nonLinearCost_;
    946     nonLinearCost_ = new ClpNonLinearCost(this,originalModel->numberColumns());
     927    nonLinearCost_ = new ClpNonLinearCost(this,info->numberXColumns());
    947928    // Say no pivot has occurred (for steepest edge and updates)
    948929    pivotRow_=-2;
     
    995976     
    996977      // Compute objective function from scratch
    997       const CoinPackedMatrix * quadratic = originalModel->quadraticObjective();
     978      const CoinPackedMatrix * quadratic =
     979        info->originalModel()->quadraticObjective();
    998980      const int * columnQuadratic = quadratic->getIndices();
    999981      const int * columnQuadraticStart = quadratic->getVectorStarts();
    1000982      const int * columnQuadraticLength = quadratic->getVectorLengths();
    1001983      const double * quadraticElement = quadratic->getElements();
    1002       const double * originalCost = originalModel->objective();
     984      const double * originalCost = info->originalObjective();
    1003985      objectiveValue_=0.0;
    1004986      for (iColumn=0;iColumn<numberXColumns;iColumn++) {
     
    10261008        sequenceIn=-1;
    10271009        for (iColumn=0;iColumn<numberXColumns;iColumn++) {
    1028           double value = solution_[iColumn];
    1029           double lower = lower_[iColumn];
    1030           double upper = upper_[iColumn];
    1031           if (value>lower+primalTolerance_&&value<upper-primalTolerance_) {
    1032             if (getColumnStatus(iColumn)!=basic) {
    1033               if (phase!=2) {
    1034                 phase=2;
    1035                 sequenceIn=iColumn;
     1010          if (which[iColumn]>=0) {
     1011            double value = solution_[iColumn];
     1012            double lower = lower_[iColumn];
     1013            double upper = upper_[iColumn];
     1014            if (value>lower+primalTolerance_&&value<upper-primalTolerance_) {
     1015              if (getColumnStatus(iColumn)!=basic) {
     1016                if (phase!=2) {
     1017                  phase=2;
     1018                  sequenceIn=iColumn;
     1019                }
    10361020              }
    10371021            }
    1038           }
    1039           if (getColumnStatus(iColumn)==basic) {
    1040             int iS = pair[iColumn];
    1041             assert (iS>=0&&getColumnStatus(iS)!=basic);
    1042             if(fabs(solution_[iS])>dualTolerance_) {
    1043               if (phase==0) {
    1044                 phase=1;
    1045                 sequenceIn=iS;
     1022            if (getColumnStatus(iColumn)==basic) {
     1023              int iS = which[iColumn]+numberRows_;
     1024              assert (getColumnStatus(iS)!=basic);
     1025              if(fabs(solution_[iS])>dualTolerance_) {
     1026                if (phase==0) {
     1027                  phase=1;
     1028                  sequenceIn=iS;
     1029                }
    10461030              }
    10471031            }
     
    10891073      // Iterate
    10901074      problemStatus_=-1;
    1091       whileIterating(originalModel,sequenceIn,&info,crucialSj,phase);
     1075      whileIterating(sequenceIn,info,phase);
    10921076    }
    10931077  }
    10941078  // clean up
    10951079  delete [] saveSolution;
    1096   delete [] pair;
    10971080  finish();
    10981081  restoreData(data);
     
    11101093*/
    11111094int
    1112 ClpSimplexPrimalQuadratic::whileIterating(
    1113                       const ClpSimplexPrimalQuadratic * originalModel,
    1114                       int & sequenceIn,
     1095ClpSimplexPrimalQuadratic::whileIterating(int & sequenceIn,
    11151096                      ClpQuadraticInfo * info,
    1116                       int & crucialSj,
    11171097                      int phase)
    11181098{
    11191099  checkComplementary (info);
    1120 
     1100  int crucialSj = info->crucialSj();
    11211101  int returnCode=-1;
    11221102  double saveObjective = objectiveValue_;
    1123   int numberXColumns = originalModel->numberColumns();
     1103  int numberXColumns = info->numberXColumns();
     1104  const int * which = info->quadraticSequence();
     1105  const double * pi = solution_+numberXColumns;
     1106  // Matrix for linear stuff
     1107  const int * row = matrix_->getIndices();
     1108  const int * columnStart = matrix_->getVectorStarts();
     1109  const double * element =  matrix_->getElements();
     1110  const int * columnLength = matrix_->getVectorLengths();
    11241111  int oldSequenceIn=sequenceIn;
    11251112  // status stays at -1 while iterating, >=0 finished, -2 to invert
     
    11661153        if (sequenceIn<0) {
    11671154          iStart=max(iStart,numberColumns_);
    1168           int numberXRows = originalModel->numberRows();
     1155          int numberXRows = info->numberXRows();
    11691156          for (iColumn=numberColumns_;iColumn<numberColumns_+numberXRows;
    11701157               iColumn++) {
     
    11841171      sequenceIn_ = sequenceIn;
    11851172      cleanupIteration=false;
    1186       dualIn_ = solution_[sequenceIn_+numberRows_];
     1173      if (sequenceIn_<numberXColumns) {
     1174        int jSequence = which[sequenceIn_];
     1175        if (jSequence>=0) {
     1176          dualIn_ = solution_[jSequence+numberRows_];
     1177        } else {
     1178          // need coding
     1179          dualIn_=cost_[sequenceIn_];
     1180          int j;
     1181          for (j=columnStart[sequenceIn_];j<columnStart[sequenceIn_]+columnLength[sequenceIn_]; j++) {
     1182            int iRow = row[j];
     1183            dualIn_ -= element[j]*pi[iRow];
     1184          }
     1185        }
     1186      } else {
     1187        dualIn_ = - solution_[sequenceIn_-numberColumns_+numberXColumns];
     1188      }
    11871189      valueIn_=solution_[sequenceIn_];
    11881190      if (dualIn_>0.0)
     
    12871289          if (sequenceIn_<numberColumns_) {
    12881290            // Set dj as value of slack
    1289             crucialSj = sequenceIn_+numberRows_; // sj which should go to 0.0
    1290             //dualIn_=solution_[crucialSj];
     1291            const int * which = info->quadraticSequence();
     1292            crucialSj = which[sequenceIn_];
     1293            if (crucialSj>=0)
     1294              crucialSj += numberRows_; // sj which should go to 0.0
    12911295          } else {
    12921296            // Set dj as value of pi
     
    12941298            //dualIn_=solution_[crucialSj];
    12951299          }
     1300          info->setCrucialSj(crucialSj);
    12961301        }
    12971302        // save reduced cost
     
    12991304        // do ratio test and re-compute dj
    13001305        // Note second parameter long enough for columns
    1301         int result=primalRow(rowArray_[1],rowArray_[3],rowArray_[2],rowArray_[0],
     1306        int result=primalRow(rowArray_[1],rowArray_[3],
     1307                             rowArray_[2],rowArray_[0],
    13021308                             info,
    1303                              originalModel,crucialSj,cleanupIteration);
     1309                             cleanupIteration);
    13041310        saveObjective = objectiveValue_;
    13051311        if (pivotRow_>=0) {
     
    14561462        // may need to go round again
    14571463        cleanupIteration = true;
    1458         double newDj;
    14591464        // may not be correct on second time
    1460         if (sequenceIn_<numberXColumns)
    1461           newDj = solution_[sequenceIn_+numberRows_];
    1462         else
    1463           newDj = solution_[sequenceIn_-numberColumns_+numberXColumns];
    1464         newDj=1.0; // force
    1465         if (result&&fabs(newDj)>dualTolerance_) {
     1465        if (result) {
    14661466          assert(sequenceOut_<numberXColumns||
    14671467                 sequenceOut_>=numberColumns_);
     
    15241524                                     CoinIndexedVector * spareArray2,
    15251525                                     ClpQuadraticInfo * info,
    1526                                      const ClpSimplexPrimalQuadratic * originalModel,
    1527                                      int crucialSj,
    15281526                                     bool cleanupIteration)
    15291527{
    15301528  int result=1;
     1529 
    15311530  // sequence stays as row number until end
    15321531  pivotRow_=-1;
    15331532  int numberSwapped=0;
    15341533  int numberRemaining=0;
    1535 
     1534  int crucialSj = info->crucialSj();
     1535  if (crucialSj<0)
     1536    result=0; // linear
    15361537  int numberThru =0; // number gone thru a barrier
    15371538  int lastThru =0; // number gone thru a barrier on last time
     
    16041605  const int * columnQuadraticLength = quadratic->getVectorLengths();
    16051606  const double * quadraticElement = quadratic->getElements();
    1606   const double * originalCost = originalModel->objective();
     1607  const double * originalCost = info->originalObjective();
    16071608  // Use rhsArray
    16081609  rhsArray->clear();
    16091610  int * index2 = rhsArray->getIndices();
    1610   int numberXColumns = originalModel->numberColumns();
     1611  int numberXColumns = info->numberXColumns();
    16111612  int number2=0;
    1612   //int numberOriginalRows = originalModel->numberRows();
     1613  //int numberOriginalRows = info->numberXRows();
    16131614  // sj
    16141615  int iSjRow=-1;
     
    16651666    const double * element = matrix_->getElements();
    16661667    int j;
    1667     int jRow = sequenceIn_+originalModel->numberRows();
     1668    int jRow = sequenceIn_+info->numberXRows();
    16681669    printf("sequence in %d, cost %g\n",sequenceIn_,
    16691670           upper_[jRow+numberColumns_]);
     
    20832084    int iColumn;
    20842085    objectiveValue_ =0.0;
    2085     CoinPackedMatrix * quadratic = originalModel->quadraticObjective();
     2086    CoinPackedMatrix * quadratic =
     2087      info->originalModel()->quadraticObjective();
    20862088    const int * columnQuadratic = quadratic->getIndices();
    20872089    const int * columnQuadraticStart = quadratic->getVectorStarts();
    20882090    const int * columnQuadraticLength = quadratic->getVectorLengths();
    20892091    const double * quadraticElement = quadratic->getElements();
    2090     int numberColumns = originalModel->numberColumns();
    2091     const double * objective = originalModel->objective();
     2092    int numberColumns = info->numberXColumns();
     2093    const double * objective = info->originalObjective();
    20922094    for (iColumn=0;iColumn<numberColumns;iColumn++)
    20932095      objectiveValue_ += objective[iColumn]*solution_[iColumn];
     
    21122114                                               ClpQuadraticInfo * info)
    21132115{
    2114   const ClpSimplex * originalModel= info->originalModel();
    2115   int numberXColumns = originalModel->numberColumns();
     2116  //const ClpSimplex * originalModel= info->originalModel();
     2117  int numberXColumns = info->numberXColumns();
    21162118  int i;
     2119  const int * which = info->quadraticSequence();
    21172120  for (i=0;i<numberXColumns;i++) {
    2118     int jSequence = i+ numberRows_;
    2119     if (getColumnStatus(i)==basic) {
    2120       if (getColumnStatus(jSequence)==basic)
    2121         printf("Struct %d (%g) and %d (%g) both basic\n",
    2122                i,solution_[i],jSequence,solution_[jSequence]);
    2123     }
    2124   }
    2125   int originalNumberRows = originalModel->numberRows();
     2121    if (which[i]>=0) {
     2122      int jSequence = i+ numberRows_;
     2123      if (getColumnStatus(i)==basic) {
     2124        if (getColumnStatus(jSequence)==basic)
     2125          printf("Struct %d (%g) and %d (%g) both basic\n",
     2126                 i,solution_[i],jSequence,solution_[jSequence]);
     2127      }
     2128    }
     2129  }
     2130  int originalNumberRows = info->numberXRows();
    21262131  int offset = numberXColumns;
    21272132  for (i=0;i<originalNumberRows;i++) {
     
    25022507  double objValue = -objectiveOffset;
    25032508  double * objective = this->objective();
     2509  const double * pi = dualRowSolution();
    25042510  for (iColumn=0;iColumn<numberColumns_;iColumn++)
    25052511    objValue += objective[iColumn]*solution2[iColumn];
    25062512  CoinPackedMatrix * quadratic = quadraticObjective();
     2513  double * dj = dualColumnSolution();
     2514  // Matrix for linear stuff
     2515  const int * row = matrix_->getIndices();
     2516  const int * columnStart = matrix_->getVectorStarts();
     2517  const double * element =  matrix_->getElements();
     2518  const int * columnLength = matrix_->getVectorLengths();
    25072519  if (quadratic) {
    25082520    const int * columnQuadratic = quadratic->getIndices();
     
    25102522    const int * columnQuadraticLength = quadratic->getVectorLengths();
    25112523    const double * quadraticElement = quadratic->getElements();
     2524    const int * which = info.quadraticSequence();
     2525    int start = numberRows_+numberColumns_;
    25122526    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2513       double valueI = solution2[iColumn];
    2514       if (fabs(valueI)>1.0e-5) {
    2515         int djColumn = iColumn+numberRows_+numberColumns_;
    2516         assert(solution2[djColumn]<1.0e-7);
     2527      int jColumn = which[iColumn];
     2528      double valueI=solution2[iColumn];
     2529      double value;
     2530      if (jColumn>=0) {
     2531        jColumn += start;
     2532        value = solution2[jColumn];
     2533      } else {
     2534        value=objective[iColumn];
     2535        int j;
     2536        for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn]; j++) {
     2537          int iRow = row[j];
     2538          value -= element[j]*pi[iRow];
     2539        }
     2540      }
     2541      dj[iColumn]=value;
     2542      Status status = quadraticModel->getColumnStatus(iColumn);
     2543      setColumnStatus(iColumn,status);
     2544      if (status==basic) {
     2545        assert(fabs(value)<1.0e-7);
    25172546      }
    25182547      int j;
     
    25262555    }
    25272556    objectiveValue_ = objValue + objectiveOffset;
     2557  } else {
     2558    // Do linear bit anyway
     2559    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     2560      double value=objective[iColumn];
     2561      int j;
     2562      for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn]; j++) {
     2563        int iRow = row[j];
     2564        value -= element[j]*pi[iRow];
     2565      }
     2566      dj[iColumn]=value;
     2567      Status status = quadraticModel->getColumnStatus(iColumn);
     2568      setColumnStatus(iColumn,status);
     2569    }
     2570  }
     2571  // and row status
     2572  int iRow;
     2573  for (iRow=0;iRow<numberRows_;iRow++) {
     2574    Status status = quadraticModel->getRowStatus(iRow);
     2575    setRowStatus(iRow,status);
    25282576  }
    25292577  printf("Objective value %g\n",objValue);
  • branches/pre/Makefile.Clp

    r182 r183  
    66# between then specify the exact level you want, e.g., -O1 or -O2
    77OptLevel := -g
    8 OptLevel := -O3
     8#OptLevel := -O3
    99
    1010
  • branches/pre/Test/unitTest.cpp

    r180 r183  
    929929  }
    930930  // test network
     931#define QUADRATIC
    931932#ifndef QUADRATIC
    932933  if (1) {   
     
    936937   
    937938    FILE * fp = fopen(fn.c_str(),"r");
    938 
    939939    if (!fp) {
    940       fprintf(stderr,"Unable to open file input.130 in mpsDir directory\n");
     940      // Try in Samples
     941      fn = "Samples/input.130";
     942      fp = fopen(fn.c_str(),"r");
     943    }
     944    if (!fp) {
     945      fprintf(stderr,"Unable to open file input.130 in mpsDir or Samples directory\n");
    941946    } else {
    942947      int problem;
     
    10961101  if (1) {   
    10971102    CoinMpsIO m;
    1098     std::string fn = "tiny2a";
     1103    std::string fn = mpsDir+"exmip1";
    10991104    m.readMps(fn.c_str(),"mps");
    11001105    ClpSimplex solution;
     
    11281133    solution.quadraticPrimal(1);
    11291134    objValue = solution.getObjValue();
    1130     assert(eq(objValue,820.0));
     1135    assert(eq(objValue,3.2368421));
    11311136    //exit(77);
    11321137  }
  • branches/pre/include/ClpModel.hpp

    r180 r183  
    368368      return columnNames_[iColumn];
    369369   }
     370  /// Objective methods
     371  inline ClpObjective * objectiveAsObject() const
     372  { return objective_;};
     373  void setObjective(const ClpObjective * objective);
    370374  //@}
    371375
  • branches/pre/include/ClpPrimalQuadraticDantzig.hpp

    r181 r183  
    66#include "ClpPrimalColumnPivot.hpp"
    77class ClpSimplexPrimalQuadratic;
     8class ClpQuadraticInfo;
    89//#############################################################################
    910
     
    4748 
    4849  /// Constructor from model
    49   ClpPrimalQuadraticDantzig(ClpSimplexPrimalQuadratic * model, 
    50                             int originalNumberRows);
     50  ClpPrimalQuadraticDantzig(ClpSimplexPrimalQuadratic * model,
     51                            ClpQuadraticInfo * info);
    5152 
    5253  /// Assignment operator
     
    6566private:
    6667  ///@name Private member data
    67   /// Number of rows in original problem
    68   int originalNumberRows_;
     68  /// Pointer to info
     69  ClpQuadraticInfo * quadraticInfo_;
    6970  //@}
    7071};
  • branches/pre/include/ClpSimplexPrimalQuadratic.hpp

    r180 r183  
    4848      phase - 0 normal, 1 getting complementary solution,
    4949      2 getting basic solution. */
    50   int primalQuadratic2 (const ClpSimplexPrimalQuadratic * originalModel,
    51                     int phase=2);
     50  int primalQuadratic2 (ClpQuadraticInfo * info,
     51                        int phase=2);
    5252  /** This creates the large version of QP and
    5353      fills in quadratic information.
     
    6464      phase - 0 normal, 1 getting complementary solution,
    6565      2 getting basic solution. */
    66   int whileIterating (const ClpSimplexPrimalQuadratic * originalModel,
    67                       int & sequenceIn,
     66  int whileIterating (int & sequenceIn,
    6867                      ClpQuadraticInfo * info,
    69                       int & crucialSj,
    7068                      int phase);
    7169  /**
     
    8583                CoinIndexedVector * spareArray2,
    8684                ClpQuadraticInfo * info,
    87                 const ClpSimplexPrimalQuadratic * originalModel,
    88                 int crucialSj,bool cleanupIteration);
     85                bool cleanupIteration);
    8986  //@}
    9087
Note: See TracChangeset for help on using the changeset viewer.