Changeset 774


Ignore:
Timestamp:
Sep 1, 2007 7:13:46 AM (12 years ago)
Author:
forrest
Message:

heuristics and nonlinear

Location:
trunk/Cbc/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r759 r774  
    306306  bool exitAll=false;
    307307  double saveBestObjective = model_->getMinimizationObjValue();
     308  int numberSolutions=0;
    308309  while (!exitAll) {
    309310    int numberPasses=0;
     
    512513              }
    513514            }
    514             if ((accumulate_&1)!=0)
     515            if ((accumulate_&1)!=0) {
    515516              model_->incrementUsed(betterSolution); // for local search
     517              numberSolutions++;
     518            }
    516519            solutionValue=newSolutionValue;
    517520            solutionFound=true;
     
    733736                }
    734737              }
    735               if ((accumulate_&1)!=0)
     738              if ((accumulate_&1)!=0) {
    736739                model_->incrementUsed(betterSolution); // for local search
     740                numberSolutions++;
     741              }
    737742              solutionValue=newSolutionValue;
    738743              solutionFound=true;
     
    10251030          }
    10261031        }
    1027         if ((accumulate_&1)!=0)
     1032        if ((accumulate_&1)!=0) {
    10281033          model_->incrementUsed(betterSolution); // for local search
     1034          numberSolutions++;
     1035        }
    10291036        solutionValue=newSolutionValue;
    10301037        solutionFound=true;
     
    11411148    model_->setBestSolutionBasis(bestBasis);
    11421149  model_->setMinimizationObjValue(saveBestObjective);
     1150  if ((accumulate_&1)!=0&&numberSolutions>1&&!model_->getSolutionCount()) {
     1151    model_->setSolutionCount(1); // for local search
     1152    model_->setNumberHeuristicSolutions(1);
     1153  }
    11431154  return finalReturnCode;
    11441155}
  • trunk/Cbc/src/CbcLinked.cpp

    r771 r774  
    18501850        gap = CoinMax(gap,CoinMax(gapX,gapY));
    18511851#endif
    1852         obj->setXMeshSize(value);
    1853         obj->setYMeshSize(value);
     1852        obj->setMeshSizes(this,value,value);
    18541853      }
    18551854    }
     
    49084907  }
    49094908}
     4909// Set sizes and other stuff
     4910void
     4911OsiBiLinear::setMeshSizes(const OsiSolverInterface * solver, double x, double y)
     4912{
     4913  xMeshSize_ = x;
     4914  yMeshSize_ = y;
     4915  double xB[2];
     4916  double yB[2];
     4917  const double * lower = solver->getColLower();
     4918  const double * upper = solver->getColUpper();
     4919  xB[0]=lower[xColumn_];
     4920  xB[1]=upper[xColumn_];
     4921  yB[0]=lower[yColumn_];
     4922  yB[1]=upper[yColumn_];
     4923  if (xMeshSize_!=floor(xMeshSize_)) {
     4924    // not integral
     4925    xSatisfied_ = CoinMax(xSatisfied_,0.51*xMeshSize_);
     4926    if (!yMeshSize_) {
     4927      xySatisfied_ = CoinMax(xySatisfied_,xSatisfied_*CoinMax(fabs(yB[0]),fabs(yB[1])));
     4928    }
     4929  }
     4930  if (yMeshSize_!=floor(yMeshSize_)) {
     4931    // not integral
     4932    ySatisfied_ = CoinMax(ySatisfied_,0.51*yMeshSize_);
     4933    if (!xMeshSize_) {
     4934      xySatisfied_ = CoinMax(xySatisfied_,ySatisfied_*CoinMax(fabs(xB[0]),fabs(xB[1])));
     4935    }
     4936  }
     4937}
    49104938// Useful constructor
    49114939OsiBiLinear::OsiBiLinear (CoinModel * coinModel, int xColumn,
  • trunk/Cbc/src/CbcLinked.hpp

    r765 r774  
    819819  inline void setXYSatisfied(double value)
    820820  { xySatisfied_=value;}
     821  /// Set sizes and other stuff
     822  void setMeshSizes(const OsiSolverInterface * solver, double x, double y);
    821823  /** branching strategy etc
    822824      bottom 2 bits
  • trunk/Cbc/src/CbcModel.cpp

    r765 r774  
    10941094  // Do heuristics
    10951095  doHeuristicsAtRoot();
     1096  if ( intParam_[CbcMaxNumNode] < 0)
     1097    eventHappened_=true; // stop as fast as possible
    10961098  statistics_ = NULL;
    10971099  // Do on switch
  • trunk/Cbc/src/CbcSolver.cpp

    r771 r774  
    489489}
    490490#if 1
     491#include "ClpSimplexOther.hpp"
     492
     493// Crunch down model
     494static void
     495crunchIt(ClpSimplex * model)
     496{
     497#if 0
     498  model->dual();
     499#else
     500  int numberColumns = model->numberColumns();
     501  int numberRows = model->numberRows();
     502  // Use dual region
     503  double * rhs = model->dualRowSolution();
     504  int * whichRow = new int[3*numberRows];
     505  int * whichColumn = new int[2*numberColumns];
     506  int nBound;
     507  ClpSimplex * small = ((ClpSimplexOther *) model)->crunch(rhs,whichRow,whichColumn,
     508                                                               nBound,false,false);
     509  if (small) {
     510    small->dual();
     511    if (small->problemStatus()==0) {
     512      model->setProblemStatus(0);
     513      ((ClpSimplexOther *) model)->afterCrunch(*small,whichRow,whichColumn,nBound);
     514    } else if (small->problemStatus()!=3) {
     515      model->setProblemStatus(1);
     516    } else {
     517      if (small->problemStatus()==3) {
     518        // may be problems
     519        small->computeObjectiveValue();
     520        model->setObjectiveValue(small->objectiveValue());
     521        model->setProblemStatus(3);
     522      } else {
     523        model->setProblemStatus(3);
     524      }
     525    }
     526    delete small;
     527  } else {
     528    model->setProblemStatus(1);
     529  }
     530  delete [] whichRow;
     531  delete [] whichColumn;
     532#endif
     533}
    491534/*
    492535  On input
     
    496539             3 do heuristics and set best solution
    497540             4 do BAB and just set best solution
     541             10+ then use lastSolution and relax a few
    498542             -2 cleanup afterwards if using 2
    499543  On output - number fixed
    500544*/
    501 static OsiClpSolverInterface * fixVubs(CbcModel & model, int numberLevels,
    502                                        int & doAction, CoinMessageHandler * generalMessageHandler)
     545static OsiClpSolverInterface * fixVubs(CbcModel & model, int skipZero2,
     546                                       int & doAction, CoinMessageHandler * generalMessageHandler,
     547                                       const double * lastSolution, double dextra[5])
    503548{
     549  assert ((doAction==1&&!lastSolution)||(doAction==11&&lastSolution));
     550  double fractionIntFixed = dextra[3];
     551  double fractionFixed = dextra[4];
    504552  double time1 = CoinCpuTime();
     553  OsiClpSolverInterface * originalClpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     554  ClpSimplex * originalLpSolver = originalClpSolver->getModelPtr();
    505555  OsiSolverInterface * solver = model.solver()->clone();
    506556  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    833883    fixColumn2[iColumn+1]=numberOther;
    834884  }
    835   // Create other way and convert fixColumn to counts
     885  // Create other way
    836886  for ( iColumn=0;iColumn<numberColumns;iColumn++) {
    837887    for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     
    922972  }
    923973  delete [] counts;
    924   delete [] otherColumn2;
    925   delete [] fixColumn2;
    926974  // Now do fixing
    927975  {
     
    9531001    //double djTol=20.0;
    9541002    int iPass=0;
    955 #define MAXPROB 3
     1003#define MAXPROB 2
    9561004    ClpSimplex models[MAXPROB];
    9571005    int pass[MAXPROB];
    9581006    int kPass=-1;
    9591007    int kLayer=0;
     1008    int skipZero=0;
     1009    if (skipZero2==-1)
     1010      skipZero2=40; //-1;
     1011    /* 0 fixed to 0 by choice
     1012       1 lb of 1 by choice
     1013       2 fixed to 0 by another
     1014       3 as 2 but this go
     1015       -1 free
     1016    */
     1017    char * state = new char [numberColumns];
     1018    for (iColumn=0;iColumn<numberColumns;iColumn++)
     1019      state[iColumn]=-1;
    9601020    while (true) {
    9611021      double largest=-0.1;
     
    9721032      columnUpper = lpSolver->columnUpper();
    9731033      fullSolution = lpSolver->primalColumnSolution();
     1034      if (doAction==11) {
     1035        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1036          if (columnUpper[iColumn] > columnLower[iColumn]+1.0e-8) {
     1037            if (solver->isInteger(iColumn)) {
     1038              double value = lastSolution[iColumn];
     1039              int iValue = (int) (value+0.5);
     1040              assert (fabs(value-((double) iValue))<1.0e-3);
     1041              assert (iValue>=columnLower[iColumn]&&
     1042                      iValue<=columnUpper[iColumn]);
     1043              if (!fix[iColumn]) {
     1044                if (iValue==0) {
     1045                  state[iColumn]=0;
     1046                  assert (!columnLower[iColumn]);
     1047                  columnUpper[iColumn]=0.0;
     1048                } else if (iValue==1) {
     1049                  state[iColumn]=1;
     1050                  columnLower[iColumn]=1.0;
     1051                } else {
     1052                  // leave fixed
     1053                  columnLower[iColumn]=iValue;
     1054                  columnUpper[iColumn]=iValue;
     1055                }
     1056              } else if (iValue==0) {
     1057                state[iColumn]=10;
     1058                columnUpper[iColumn]=0.0;
     1059              } else {
     1060                // leave fixed
     1061                columnLower[iColumn]=iValue;
     1062                columnUpper[iColumn]=iValue;
     1063              }
     1064            }
     1065          }
     1066        }
     1067        int jLayer=0;
     1068        int nFixed=-1;
     1069        int nTotalFixed=0;
     1070        while (nFixed) {
     1071          nFixed=0;
     1072          for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1073            if (columnUpper[iColumn]==0.0&&fix[iColumn]==jLayer) {
     1074              for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     1075                int jColumn=otherColumn[i];
     1076                if (columnUpper[jColumn]) {
     1077                  bool canFix=true;
     1078                  for (int k=fixColumn2[jColumn];k<fixColumn2[jColumn+1];k++) {
     1079                    int kColumn=otherColumn2[k];
     1080                    if (state[kColumn]==1) {
     1081                      canFix=false;
     1082                      break;
     1083                    }
     1084                  }
     1085                  if (canFix) {
     1086                    columnUpper[jColumn]=0.0;
     1087                    nFixed++;
     1088                  }
     1089                }
     1090              }
     1091            }
     1092          }
     1093          nTotalFixed += nFixed;
     1094          jLayer += 100;
     1095        }
     1096        printf("This fixes %d variables in lower priorities\n",nTotalFixed);
     1097        break;
     1098      }
    9741099      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
    9751100        if (!solver->isInteger(iColumn)||fix[iColumn]>kLayer)
     1101          continue;
     1102        // skip if fixes nothing
     1103        if (fixColumn[iColumn+1]-fixColumn[iColumn]<=skipZero2)
    9761104          continue;
    9771105        double value = fullSolution[iColumn];
     
    9921120          toZero++;
    9931121          columnUpper[iColumn]=0.0;
     1122          state[iColumn]=10;
    9941123          continue;
    9951124        }
     
    9971126          toOne++;
    9981127          columnLower[iColumn]=1.0;
     1128          state[iColumn]=1;
    9991129          continue;
    10001130        }
    10011131        numberFree++;
     1132        // skip if fixes nothing
     1133        if (fixColumn[iColumn+1]-fixColumn[iColumn]<=skipZero)
     1134          continue;
    10021135        if (value<smallest) {
    10031136          smallest=value;
     
    10151148      if (numberGreater&&!iPass)
    10161149        printf("%d variables have value > 1.0\n",numberGreater);
     1150      //skipZero2=0; // leave 0 fixing
    10171151      int jLayer=0;
    10181152      int nFixed=-1;
     
    10241158            for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
    10251159              int jColumn=otherColumn[i];
    1026               columnUpper[jColumn]=0.0;
    1027               nFixed++;
     1160              if (columnUpper[jColumn]) {
     1161                bool canFix=true;
     1162                for (int k=fixColumn2[jColumn];k<fixColumn2[jColumn+1];k++) {
     1163                  int kColumn=otherColumn2[k];
     1164                  if (state[kColumn]==1) {
     1165                    canFix=false;
     1166                    break;
     1167                  }
     1168                }
     1169                if (canFix) {
     1170                  columnUpper[jColumn]=0.0;
     1171                  nFixed++;
     1172                }
     1173              }
    10281174            }
    10291175          }
    10301176        }
    10311177        nTotalFixed += nFixed;
    1032         jLayer++;
     1178        jLayer += 100;
    10331179      }
    10341180      printf("This fixes %d variables in lower priorities\n",nTotalFixed);
     
    10391185      if (smallest<=1.0-largest&&smallest<0.2) {
    10401186        columnUpper[iSmallest]=0.0;
     1187        state[iSmallest]=0;
    10411188        movement=smallest;
    10421189        way=-1;
    10431190      } else {
    10441191        columnLower[iLargest]=1.0;
     1192        state[iLargest]=1;
    10451193        movement=1.0-largest;
    10461194        way=1;
     
    10501198      kPass = iPass%MAXPROB;
    10511199      models[kPass]=*lpSolver;
     1200      if (way==-1) {
     1201        // fix others
     1202        for (int i=fixColumn[iSmallest];i<fixColumn[iSmallest+1];i++) {
     1203          int jColumn=otherColumn[i];
     1204          if (state[jColumn]==-1) {
     1205            columnUpper[jColumn]=0.0;
     1206            state[jColumn]=3;
     1207          }
     1208        }
     1209      }
    10521210      pass[kPass]=iPass;
    10531211      double maxCostUp = COIN_DBL_MAX;
     
    10551213        maxCostUp= (1.0-movement)*objective[iSmallest];
    10561214      lpSolver->setDualObjectiveLimit(saveObj+maxCostUp);
    1057       lpSolver->dual();
     1215      crunchIt(lpSolver);
    10581216      double moveObj = lpSolver->objectiveValue()-saveObj;
    10591217      printf("movement %s was %g costing %g\n",
     
    10641222        columnUpper = models[kPass].columnUpper();
    10651223        columnLower[iSmallest]=1.0;
    1066         columnUpper[iSmallest]=lpSolver->columnUpper()[iSmallest];
     1224        columnUpper[iSmallest]=originalLpSolver->columnUpper()[iSmallest];
    10671225        *lpSolver=models[kPass];
    10681226        columnLower = lpSolver->columnLower();
     
    10711229        dj = lpSolver->dualColumnSolution();
    10721230        columnLower[iSmallest]=1.0;
    1073         columnUpper[iSmallest]=lpSolver->columnUpper()[iSmallest];
    1074         lpSolver->dual();
     1231        columnUpper[iSmallest]=originalLpSolver->columnUpper()[iSmallest];
     1232        state[iSmallest]=1;
     1233        // unfix others
     1234        for (int i=fixColumn[iSmallest];i<fixColumn[iSmallest+1];i++) {
     1235          int jColumn=otherColumn[i];
     1236          if (state[jColumn]==3) {
     1237            columnUpper[jColumn]=originalLpSolver->columnUpper()[jColumn];
     1238            state[jColumn]=-1;
     1239          }
     1240        }
     1241        crunchIt(lpSolver);
    10751242      }
    10761243      models[kPass]=*lpSolver;
    10771244    }
     1245    lpSolver->dual();
     1246    printf("Fixing took %g seconds\n",CoinCpuTime()-time1);
     1247    columnLower = lpSolver->columnLower();
     1248    columnUpper = lpSolver->columnUpper();
     1249    fullSolution = lpSolver->primalColumnSolution();
     1250    dj = lpSolver->dualColumnSolution();
     1251    int * sort = new int[numberColumns];
     1252    double * dsort = new double[numberColumns];
     1253    int chunk=20;
     1254    //double fractionFixed=6.0/8.0;
     1255    // relax while lots fixed
     1256    while (true) {
     1257      if (skipZero2>10&&doAction<10)
     1258        break;
     1259      int n=0;
     1260      double sum0=0.0;
     1261      double sum00=0.0;
     1262      double sum1=0.0;
     1263      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1264        if (!solver->isInteger(iColumn)||fix[iColumn]>kLayer)
     1265          continue;
     1266        // skip if fixes nothing
     1267        if (fixColumn[iColumn+1]-fixColumn[iColumn]==0&&doAction<10)
     1268          continue;
     1269        double value = fullSolution[iColumn];
     1270        double djValue = dj[iColumn];
     1271        if (state[iColumn]==1) {
     1272          assert (columnLower[iColumn]);
     1273          assert (value>0.1);
     1274          if (djValue>0.0) {
     1275            //printf("YY dj of %d at %g is %g\n",iColumn,value,djValue);
     1276            sum1 += djValue;
     1277            sort[n]=iColumn;
     1278            dsort[n++]=-djValue;
     1279          } else {
     1280            //printf("dj of %d at %g is %g\n",iColumn,value,djValue);
     1281          }
     1282        } else if (state[iColumn]==0||state[iColumn]==10) {
     1283          assert (value<0.1);
     1284          assert (!columnUpper[iColumn]);
     1285          double otherValue=0.0;
     1286          int nn=0;
     1287          for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     1288            int jColumn=otherColumn[i];
     1289            if (columnUpper[jColumn]==0.0) {
     1290              if (dj[jColumn]<-1.0e-5) {
     1291                nn++;
     1292                otherValue += dj[jColumn]; // really need to look at rest
     1293              }
     1294            }
     1295          }
     1296          if (djValue<-1.0e-2||otherValue<-1.0e-2) {
     1297            //printf("XX dj of %d at %g is %g - %d out of %d contribute %g\n",iColumn,value,djValue,
     1298            // nn,fixColumn[iColumn+1]-fixColumn[iColumn],otherValue);
     1299            if (djValue<1.0e-8) {
     1300              sum0 -= djValue;
     1301              sum00 -= otherValue;
     1302              sort[n]=iColumn;
     1303              if (djValue<-1.0e-2)
     1304                dsort[n++]=djValue+otherValue;
     1305              else
     1306                dsort[n++]=djValue+0.001*otherValue;
     1307            }
     1308          } else {
     1309            //printf("dj of %d at %g is %g - no contribution from %d\n",iColumn,value,djValue,
     1310            //   fixColumn[iColumn+1]-fixColumn[iColumn]);
     1311          }
     1312        }
     1313      }
     1314      CoinSort_2(dsort,dsort+n,sort);
     1315      double * originalColumnLower = originalLpSolver->columnLower();
     1316      double * originalColumnUpper = originalLpSolver->columnUpper();
     1317      double * lo = CoinCopyOfArray(columnLower,numberColumns);
     1318      double * up = CoinCopyOfArray(columnUpper,numberColumns);
     1319      for (int k=0;k<CoinMin(chunk,n);k++) {
     1320        iColumn = sort[k];
     1321        state[iColumn]=-2;
     1322      }
     1323      memcpy(columnLower,originalColumnLower,numberColumns*sizeof(double));
     1324      memcpy(columnUpper,originalColumnUpper,numberColumns*sizeof(double));
     1325      int nFixed=0;
     1326      int nFixed0=0;
     1327      int nFixed1=0;
     1328      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1329        if (state[iColumn]==0||state[iColumn]==10) {
     1330          columnUpper[iColumn]=0.0;
     1331          assert (lo[iColumn]==0.0);
     1332          nFixed++;
     1333          nFixed0++;
     1334          for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     1335            int jColumn=otherColumn[i];
     1336            if (columnUpper[jColumn]) {
     1337              bool canFix=true;
     1338              for (int k=fixColumn2[jColumn];k<fixColumn2[jColumn+1];k++) {
     1339                int kColumn=otherColumn2[k];
     1340                if (state[kColumn]==1||state[kColumn]==-2) {
     1341                  canFix=false;
     1342                  break;
     1343                }
     1344              }
     1345              if (canFix) {
     1346                columnUpper[jColumn]=0.0;
     1347                assert (lo[jColumn]==0.0);
     1348                nFixed++;
     1349              }
     1350            }
     1351          }
     1352        } else if (state[iColumn]==1) {
     1353          columnLower[iColumn]=1.0;
     1354          nFixed1++;
     1355        }
     1356      }
     1357      printf("%d fixed %d orig 0 %d 1\n",nFixed,nFixed0,nFixed1);
     1358      int jLayer=0;
     1359      nFixed=-1;
     1360      int nTotalFixed=0;
     1361      while (nFixed) {
     1362        nFixed=0;
     1363        for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1364          if (columnUpper[iColumn]==0.0&&fix[iColumn]==jLayer) {
     1365            for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     1366              int jColumn=otherColumn[i];
     1367              if (columnUpper[jColumn]) {
     1368                bool canFix=true;
     1369                for (int k=fixColumn2[jColumn];k<fixColumn2[jColumn+1];k++) {
     1370                  int kColumn=otherColumn2[k];
     1371                  if (state[kColumn]==1||state[kColumn]==-2) {
     1372                    canFix=false;
     1373                    break;
     1374                  }
     1375                }
     1376                if (canFix) {
     1377                  columnUpper[jColumn]=0.0;
     1378                  assert (lo[jColumn]==0.0);
     1379                  nFixed++;
     1380                }
     1381              }
     1382            }
     1383          }
     1384        }
     1385        nTotalFixed += nFixed;
     1386        jLayer += 100;
     1387      }
     1388      nFixed=0;
     1389      int nFixedI=0;
     1390      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1391        if (columnLower[iColumn]==columnUpper[iColumn]) {
     1392          if (solver->isInteger(iColumn))
     1393            nFixedI++;
     1394          nFixed++;
     1395        }
     1396      }
     1397      printf("This fixes %d variables in lower priorities - total %d (%d integer) - all target %d, int target %d\n",
     1398             nTotalFixed,nFixed,nFixedI,(int)(fractionFixed*numberColumns),(int) (fractionIntFixed*numberInteger));
     1399      int nBad=0;
     1400      int nRelax=0;
     1401      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1402        if (lo[iColumn]<columnLower[iColumn]||
     1403            up[iColumn]>columnUpper[iColumn]) {
     1404          printf("bad %d old %g %g, new %g %g\n",iColumn,lo[iColumn],up[iColumn],
     1405                 columnLower[iColumn],columnUpper[iColumn]);
     1406          nBad++;
     1407        }
     1408        if (lo[iColumn]>columnLower[iColumn]||
     1409            up[iColumn]<columnUpper[iColumn]) {
     1410          nRelax++;
     1411        }
     1412      }
     1413      printf("%d relaxed\n",nRelax);
     1414      assert (!nBad);
     1415      delete [] lo;
     1416      delete [] up;
     1417      lpSolver->primal(1);
     1418      if (nFixed<fractionFixed*numberColumns||nFixedI<fractionIntFixed*numberInteger||!nRelax)
     1419        break;
     1420    }
     1421    delete [] state;
     1422    delete [] sort;
     1423    delete [] dsort;
    10781424  }
    1079   printf("Fixing took %g seconds\n",CoinCpuTime()-time1);
    10801425  delete [] fix;
    10811426  delete [] fixColumn;
    10821427  delete [] otherColumn;
     1428  delete [] otherColumn2;
     1429  delete [] fixColumn2;
     1430  // Basis
     1431  memcpy(originalLpSolver->statusArray(),lpSolver->statusArray(),numberRows+numberColumns);
     1432  memcpy(originalLpSolver->primalColumnSolution(),lpSolver->primalColumnSolution(),numberColumns*sizeof(double));
     1433  memcpy(originalLpSolver->primalRowSolution(),lpSolver->primalRowSolution(),numberRows*sizeof(double));
     1434  // Fix in solver
     1435  columnLower = lpSolver->columnLower();
     1436  columnUpper = lpSolver->columnUpper();
     1437  double * originalColumnLower = originalLpSolver->columnLower();
     1438  double * originalColumnUpper = originalLpSolver->columnUpper();
     1439  // number fixed
     1440  doAction=0;
     1441  for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1442    originalColumnLower[iColumn] = columnLower[iColumn];
     1443    originalColumnUpper[iColumn] = columnUpper[iColumn];
     1444    if (columnLower[iColumn]==columnUpper[iColumn])
     1445      doAction++;
     1446  }
     1447  printf("%d fixed by vub preprocessing\n",doAction);
    10831448  delete solver;
    10841449  return NULL;
     
    34283793                  assert (tempModel);
    34293794                  solution = CoinCopyOfArray(tempModel->primalColumnSolution(),coinModel.numberColumns());
     3795                  model2->setObjectiveValue(tempModel->objectiveValue());
     3796                  model2->setProblemStatus(tempModel->problemStatus());
     3797                  model2->setSecondaryStatus(tempModel->secondaryStatus());
    34303798                  delete tempModel;
    34313799                }
     
    37134081              if (vubAction!=-1) {
    37144082                // look at vubs
    3715                 OsiClpSolverInterface * newSolver = fixVubs(model,1,vubAction,generalMessageHandler);
     4083                // Just ones which affect >= extra3
     4084                int extra3 = parameters[whichParam(EXTRA3,numberParameters,parameters)].intValue();
     4085                /* 3 is fraction of integer variables fixed (0.97)
     4086                   4 is fraction of all variables fixed (0.0)
     4087                */
     4088                double dextra[5];
     4089                dextra[1] = parameters[whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();
     4090                dextra[2] = parameters[whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();
     4091                dextra[3] = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     4092                dextra[4] = parameters[whichParam(DEXTRA4,numberParameters,parameters)].doubleValue();
     4093                if (!dextra[3])
     4094                  dextra[3] = 0.97;
     4095                OsiClpSolverInterface * newSolver = fixVubs(model,extra3,vubAction,generalMessageHandler,
     4096                                                            debugValues,dextra);
    37164097                assert (!newSolver);
    37174098              }
  • trunk/Cbc/src/Cbc_ampl.cpp

    r723 r774  
    519519    else
    520520      info->direction=1.0;
     521    model->setOptimizationDirection(info->direction);
    521522    info->offset=objconst(0);
    522523    info->numberRows=n_con;
     
    10061007    rowLower = (double *) malloc(n_con*sizeof(double));
    10071008    rowUpper = (double *) malloc(n_con*sizeof(double));
    1008     int * column = new int [n_var];
    1009     double * element = new double [n_var];
     1009    CoinBigIndex * rowStart = new CoinBigIndex [n_con+1];
     1010    int * column = new int [nzc];
     1011    double * element = new double [nzc];
     1012    rowStart[0]=0;
     1013    numberElements=0;
    10101014    for (i=0;i<n_con;i++) {
    10111015      rowLower[i]=LUrhs[2*i];
     
    10151019      if (rowUpper[i]>= Infinity)
    10161020        rowUpper[i]=COIN_DBL_MAX;
    1017       int k=0;
    10181021      for(cgrad * cg = Cgrad[i]; cg; cg = cg->next) {
    1019         column[k]=cg->varno;
    1020         element[k++]=cg->coef;
    1021       }
    1022       matrixByRow.appendRow(k,column,element);
    1023     }
     1022        column[numberElements]=cg->varno;
     1023        element[numberElements++]=cg->coef;
     1024      }
     1025      rowStart[i+1]=numberElements;
     1026    }
     1027    assert (numberElements==nzc);
     1028    matrixByRow.appendRows(n_con,rowStart,column,element);
     1029    delete [] rowStart;
    10241030    delete [] column;
    10251031    delete [] element;
    10261032    numberRows=n_con;
    10271033    numberColumns=n_var;
    1028     numberElements=nzc;
     1034    //numberElements=nzc;
    10291035    numberBinary=nbv;
    10301036    numberIntegers=niv;
     
    11941200    // say row orderded
    11951201    matrixByRow.transpose();
     1202    CoinBigIndex * rowStart = new CoinBigIndex [n_con+1];
     1203    int * column = new int [nzc];
     1204    double * element = new double [nzc];
     1205    rowStart[0]=0;
     1206    numberElements=0;
    11961207    /* Row bounds*/
    11971208    rowLower = (double *) malloc(n_con*sizeof(double));
    11981209    rowUpper = (double *) malloc(n_con*sizeof(double));
    1199     int * column = new int [n_var];
    1200     double * element = new double [n_var];
    12011210    for (i=0;i<n_con;i++) {
    12021211      rowLower[i]=LUrhs[2*i];
     
    12061215      if (rowUpper[i]>= Infinity)
    12071216        rowUpper[i]=COIN_DBL_MAX;
    1208       int k=0;
    12091217      for(cgrad * cg = Cgrad[i]; cg; cg = cg->next) {
    1210         column[k]=cg->varno;
     1218        column[numberElements]=cg->varno;
    12111219        double value = cg->coef;
    12121220        if (!value)
    12131221          value = -1.2345e-29;
    1214         element[k++]=value;
    1215       }
    1216       matrixByRow.appendRow(k,column,element);
    1217     }
     1222        element[numberElements++]=value;
     1223      }
     1224      rowStart[i+1]=numberElements;
     1225    }
     1226    assert (numberElements==nzc);
     1227    matrixByRow.appendRows(n_con,rowStart,column,element);
     1228    delete [] rowStart;
    12181229    delete [] column;
    12191230    delete [] element;
Note: See TracChangeset for help on using the changeset viewer.