Changeset 1424


Ignore:
Timestamp:
Aug 21, 2009 12:15:31 PM (10 years ago)
Author:
forrest
Message:

fixes for various things

Location:
trunk/Clp/src
Files:
8 edited

Legend:

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

    r1412 r1424  
    10111011static char * where=NULL;
    10121012extern int CbcOrClpRead_mode;
     1013int CbcOrClpEnvironmentIndex=-1;
     1014static int fillEnv()
     1015{
     1016  char * environ = getenv("CBC_CLP_ENVIRONMENT");
     1017  int length=0;
     1018  if (environ) {
     1019    length = strlen(environ);
     1020    if (CbcOrClpEnvironmentIndex<length) {
     1021      // find next non blank
     1022      char * whereEnv = environ+ CbcOrClpEnvironmentIndex;
     1023      // munch white space
     1024      while(*whereEnv==' '||*whereEnv=='\t'||*whereEnv<' ')
     1025        whereEnv++;
     1026      // copy
     1027      char * put = line;
     1028      while ( *whereEnv != '\0' ) {
     1029        if ( *whereEnv == ' '||*whereEnv == '\t' || *whereEnv < ' ' ) {
     1030          break;
     1031        }
     1032        *put=*whereEnv;
     1033        put++;
     1034        assert (put-line<1000);
     1035        whereEnv++;
     1036      }
     1037      CbcOrClpEnvironmentIndex=whereEnv-environ;
     1038      *put='\0';
     1039      length=strlen(line);
     1040    } else {
     1041      length=0;
     1042    }
     1043  }
     1044  if (!length)
     1045    CbcOrClpEnvironmentIndex=-1;
     1046  return length;
     1047}
    10131048extern FILE * CbcOrClpReadCommand;
    10141049// Simple read stuff
     
    10841119  while (field=="EOL") {
    10851120    if (CbcOrClpRead_mode>0) {
    1086       if (CbcOrClpRead_mode<argc&&argv[CbcOrClpRead_mode]) {
    1087         field = argv[CbcOrClpRead_mode++];
     1121      if ((CbcOrClpRead_mode<argc&&argv[CbcOrClpRead_mode])||
     1122          CbcOrClpEnvironmentIndex>=0) {
     1123        if(CbcOrClpEnvironmentIndex<0) {
     1124          field = argv[CbcOrClpRead_mode++];
     1125        } else {
     1126          if (fillEnv()) {
     1127            field=line;
     1128          } else {
     1129            // not there
     1130            continue;
     1131          }
     1132        }
    10881133        if (field=="-") {
    10891134          std::cout<<"Switching to line mode"<<std::endl;
     
    10941139            // now allow std::cout<<"skipping non-command "<<field<<std::endl;
    10951140            // field="EOL"; // skip
    1096           } else {
     1141          } else if (CbcOrClpEnvironmentIndex<0) {
    10971142            // special dispensation - taken as -import name
    10981143            CbcOrClpRead_mode--;
     
    11311176  if (afterEquals=="") {
    11321177    if (CbcOrClpRead_mode>0) {
    1133       if (CbcOrClpRead_mode<argc) {
    1134         if (argv[CbcOrClpRead_mode][0]!='-') {
    1135           field = argv[CbcOrClpRead_mode++];
    1136         } else if (!strcmp(argv[CbcOrClpRead_mode],"--")) {
    1137           field = argv[CbcOrClpRead_mode++];
    1138           // -- means import from stdin
    1139           field = "-";
    1140         }
     1178      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
     1179        if(CbcOrClpEnvironmentIndex<0) {
     1180          if (argv[CbcOrClpRead_mode][0]!='-') {
     1181            field = argv[CbcOrClpRead_mode++];
     1182          } else if (!strcmp(argv[CbcOrClpRead_mode],"--")) {
     1183            field = argv[CbcOrClpRead_mode++];
     1184            // -- means import from stdin
     1185            field = "-";
     1186          }
     1187        } else {
     1188          fillEnv();
     1189          field=line;
     1190        }
    11411191      }
    11421192    } else {
     
    11571207  if (afterEquals=="") {
    11581208    if (CbcOrClpRead_mode>0) {
    1159       if (CbcOrClpRead_mode<argc) {
    1160         // may be negative value so do not check for -
    1161         field = argv[CbcOrClpRead_mode++];
     1209      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
     1210        if(CbcOrClpEnvironmentIndex<0) {
     1211          // may be negative value so do not check for -
     1212          field = argv[CbcOrClpRead_mode++];
     1213        } else {
     1214          fillEnv();
     1215          field=line;
     1216        }
    11621217      }
    11631218    } else {
     
    11921247  if (afterEquals=="") {
    11931248    if (CbcOrClpRead_mode>0) {
    1194       if (CbcOrClpRead_mode<argc) {
    1195         // may be negative value so do not check for -
    1196         field = argv[CbcOrClpRead_mode++];
     1249      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
     1250        if(CbcOrClpEnvironmentIndex<0) {
     1251          // may be negative value so do not check for -
     1252          field = argv[CbcOrClpRead_mode++];
     1253        } else {
     1254          fillEnv();
     1255          field=line;
     1256        }
    11971257      }
    11981258    } else {
     
    14221482     );
    14231483  parameters[numberParameters++]=
     1484    CbcOrClpParam("combine2!Solutions","Whether to use crossover solution heuristic",
     1485                  "off",CROSSOVER2);
     1486  parameters[numberParameters-1].append("on");
     1487  parameters[numberParameters-1].append("both");
     1488  parameters[numberParameters-1].append("before");
     1489  parameters[numberParameters-1].setLonghelp
     1490    (
     1491     "This switches on a heuristic which does branch and cut on the problem given by \
     1492fixing variables which have same value in two or more solutions. \
     1493It obviously only tries after two or more solutions. \
     1494See Rounding for meaning of on,both,before"
     1495     );
     1496  parameters[numberParameters++]=
    14241497    CbcOrClpParam("cost!Strategy","How to use costs as priorities",
    14251498                  "off",COSTSTRATEGY);
     
    18141887     );
    18151888  parameters[numberParameters++]=
     1889    CbcOrClpParam("environ!ment","Read commands from environment",
     1890                  ENVIRONMENT,7,0);
     1891  parameters[numberParameters-1].setLonghelp
     1892    (
     1893     "This starts reading from environment variable CBC_CLP_ENVIRONMENT."
     1894     );
     1895  parameters[numberParameters++]=
    18161896    CbcOrClpParam("error!sAllowed","Whether to allow import errors",
    18171897                  "off",ERRORSALLOWED,3);
     
    28292909  parameters[numberParameters-1].append("geo!metric");
    28302910  parameters[numberParameters-1].append("auto!matic");
     2911  parameters[numberParameters-1].append("dynamic");
     2912  parameters[numberParameters-1].append("rows!only");
    28312913  parameters[numberParameters-1].setLonghelp
    28322914    (
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1412 r1424  
    8585    LANDPCUTS,RINS,RESIDCUTS,RENS,DIVINGS,DIVINGC,DIVINGF,DIVINGG,DIVINGL,
    8686    DIVINGP,DIVINGV,DINS,PIVOTANDFIX,RANDROUND,NAIVE,ZEROHALFCUTS,CPX,
     87    CROSSOVER2,
    8788   
    8889    DIRECTORY=301,DIRSAMPLE,DIRNETLIB,DIRMIPLIB,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
     
    9091    TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,NETLIB_TUNE,
    9192    REALLY_SCALE,BASISIN,BASISOUT,SOLVECONTINUOUS,CLEARCUTS,VERSION,STATISTICS,DEBUG,DUMMY,PRINTMASK,
    92     OUTDUPROWS,USERCLP,MODELIN,CSVSTATISTICS,STOREDFILE,
     93    OUTDUPROWS,USERCLP,MODELIN,CSVSTATISTICS,STOREDFILE,ENVIRONMENT,
    9394
    9495    BAB=351,MIPLIB,STRENGTHEN,PRIORITYIN,USERCBC,DOHEURISTIC,
  • trunk/Clp/src/ClpMain.cpp

    r1421 r1424  
    8787int CbcOrClpRead_mode=1;
    8888FILE * CbcOrClpReadCommand=stdin;
     89extern int CbcOrClpEnvironmentIndex;
    8990
    9091int
     
    19411942             
    19421943            }
     1944            break;
     1945          case ENVIRONMENT:
     1946            CbcOrClpEnvironmentIndex=0;
    19431947            break;
    19441948          default:
  • trunk/Clp/src/ClpModel.cpp

    r1422 r1424  
    681681    if (scalingMode&&!matrix_->scale(this)) {
    682682      // scaling worked - now apply
     683      inverseRowScale_ = rowScale_+numberRows_;
     684      inverseColumnScale_ = columnScale_+numberColumns_;
    683685      gutsOfScaling();
    684686      // pretend not scaled
     
    37323734  if (mode!=scalingFlag_)
    37333735    whatsChanged_ &= ~(2+4+8);
    3734   if (mode>0&&mode<5) {
     3736  if (mode>0&&mode<6) {
    37353737    scalingFlag_=mode;
    37363738  } else if (!mode) {
  • trunk/Clp/src/ClpModel.hpp

    r1407 r1424  
    970970  /// Inverse column scale factors for matrix (end of columnScale_)
    971971  double * inverseColumnScale_;
    972   /// Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic
     972  /** Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic,
     973      5 geometric on rows */
    973974  int scalingFlag_;
    974975  /** Status (i.e. basis) Region.  I know that not all algorithms need a status
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1402 r1424  
    14591459      CoinBigIndex end = columnStart[iColumn+1];
    14601460      int n=end-start;
     1461#if 1
    14611462      bool odd = (n&1)!=0;
    14621463      n = n>>1;
     
    14751476        value += pi[iRow]*(*elementThis);
    14761477      }
     1478#else
     1479      const int * COIN_RESTRICT rowThis=&row[end-16];
     1480      const double * COIN_RESTRICT elementThis=&elementByColumn[end-16];
     1481      bool odd = (n&1)!=0;
     1482      n = n>>1;
     1483      double value2=0.0;
     1484      if (odd) {
     1485        int iRow = row[start];
     1486        value2 = pi[iRow]*elementByColumn[start];
     1487      }
     1488      switch (n) {
     1489      default:
     1490        {
     1491          if (odd) {
     1492            start++;
     1493          }
     1494          n -= 8;
     1495          for (;n;n--) {
     1496            int iRow0 = row[start];
     1497            int iRow1 = row[start+1];
     1498            value += pi[iRow0]*elementByColumn[start];
     1499            value2 += pi[iRow1]*elementByColumn[start+1];
     1500            start+=2;
     1501          }
     1502        case 8:
     1503          {
     1504            int iRow0 = rowThis[16-16];
     1505            int iRow1 = rowThis[16-15];
     1506            value += pi[iRow0]*elementThis[16-16];
     1507            value2 += pi[iRow1]*elementThis[16-15];
     1508          }
     1509        case 7:
     1510          {
     1511            int iRow0 = rowThis[16-14];
     1512            int iRow1 = rowThis[16-13];
     1513            value += pi[iRow0]*elementThis[16-14];
     1514            value2 += pi[iRow1]*elementThis[16-13];
     1515          }
     1516        case 6:
     1517          {
     1518            int iRow0 = rowThis[16-12];
     1519            int iRow1 = rowThis[16-11];
     1520            value += pi[iRow0]*elementThis[16-12];
     1521            value2 += pi[iRow1]*elementThis[16-11];
     1522          }
     1523        case 5:
     1524          {
     1525            int iRow0 = rowThis[16-10];
     1526            int iRow1 = rowThis[16-9];
     1527            value += pi[iRow0]*elementThis[16-10];
     1528            value2 += pi[iRow1]*elementThis[16-9];
     1529          }
     1530        case 4:
     1531          {
     1532            int iRow0 = rowThis[16-8];
     1533            int iRow1 = rowThis[16-7];
     1534            value += pi[iRow0]*elementThis[16-8];
     1535            value2 += pi[iRow1]*elementThis[16-7];
     1536          }
     1537        case 3:
     1538          {
     1539            int iRow0 = rowThis[16-6];
     1540            int iRow1 = rowThis[16-5];
     1541            value += pi[iRow0]*elementThis[16-6];
     1542            value2 += pi[iRow1]*elementThis[16-5];
     1543          }
     1544        case 2:
     1545          {
     1546            int iRow0 = rowThis[16-4];
     1547            int iRow1 = rowThis[16-3];
     1548            value += pi[iRow0]*elementThis[16-4];
     1549            value2 += pi[iRow1]*elementThis[16-3];
     1550          }
     1551        case 1:
     1552          {
     1553            int iRow0 = rowThis[16-2];
     1554            int iRow1 = rowThis[16-1];
     1555            value += pi[iRow0]*elementThis[16-2];
     1556            value2 += pi[iRow1]*elementThis[16-1];
     1557          }
     1558        case 0:
     1559          ;
     1560        }
     1561      }
     1562      value += value2;
     1563#endif
    14771564      if (fabs(value)>zeroTolerance) {
    14781565        double mult=multiplier[wanted-1];
     
    31433230  // mark empty and fixed columns
    31443231  // also see if worth scaling
    3145   assert (model->scalingFlag()<=4);
     3232  assert (model->scalingFlag()<=5);
    31463233  //  scale_stats[model->scalingFlag()]++;
    31473234  double largest=0.0;
     
    32553342      // As auto
    32563343      scalingMethod=3;
     3344    } else if (scalingMethod==5) {
     3345      // As geometric
     3346      scalingMethod=2;
    32573347    }
    32583348    double savedOverallRatio=0.0;
     
    33273417            }
    33283418          }
     3419          if (model->scalingFlag()==5)
     3420            break; // just scale rows
    33293421#ifdef SQRT_ARRAY
    33303422          doSqrts(rowScale,numberRows);
     
    34023494      // final pass to scale columns so largest is reasonable
    34033495      // See what smallest will be if largest is 1.0
    3404       overallSmallest=1.0e50;
    3405       for (iColumn=0;iColumn<numberColumns;iColumn++) {
    3406         if (usefulColumn[iColumn]) {
    3407           CoinBigIndex j;
    3408           largest=1.0e-20;
    3409           smallest=1.0e50;
    3410           for (j=columnStart[iColumn];
    3411                j<columnStart[iColumn]+columnLength[iColumn];j++) {
    3412             iRow=row[j];
    3413             double value = fabs(elementByColumn[j]*rowScale[iRow]);
    3414             largest = CoinMax(largest,value);
    3415             smallest = CoinMin(smallest,value);
    3416           }
    3417           if (overallSmallest*largest>smallest)
     3496      if (model->scalingFlag()!=5) {
     3497        overallSmallest=1.0e50;
     3498        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     3499          if (usefulColumn[iColumn]) {
     3500            CoinBigIndex j;
     3501            largest=1.0e-20;
     3502            smallest=1.0e50;
     3503            for (j=columnStart[iColumn];
     3504                 j<columnStart[iColumn]+columnLength[iColumn];j++) {
     3505              iRow=row[j];
     3506              double value = fabs(elementByColumn[j]*rowScale[iRow]);
     3507              largest = CoinMax(largest,value);
     3508              smallest = CoinMin(smallest,value);
     3509            }
     3510            if (overallSmallest*largest>smallest)
    34183511            overallSmallest = smallest/largest;
    3419         }
     3512          }
     3513        }
    34203514      }
    34213515      if (scalingMethod==1||scalingMethod==2) {
     
    34713565    memset(usedRow,0,numberRows);
    34723566    //printf("scaling %d\n",model->scalingFlag());
    3473     for (iColumn=0;iColumn<numberColumns;iColumn++) {
    3474       if (columnUpper[iColumn]>
    3475           columnLower[iColumn]+1.0e-12) {
    3476         //if (usefulColumn[iColumn]) {
    3477         CoinBigIndex j;
    3478         largest=1.0e-20;
    3479         smallest=1.0e50;
    3480         for (j=columnStart[iColumn];
    3481              j<columnStart[iColumn]+columnLength[iColumn];j++) {
    3482           iRow=row[j];
    3483           usedRow[iRow]=1;
    3484           double value = fabs(elementByColumn[j]*rowScale[iRow]);
    3485           largest = CoinMax(largest,value);
    3486           smallest = CoinMin(smallest,value);
    3487         }
    3488         columnScale[iColumn]=overallLargest/largest;
    3489         //columnScale[iColumn]=CoinMax(1.0e-10,CoinMin(1.0e10,columnScale[iColumn]));
     3567    if (model->scalingFlag()!=5) {
     3568      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     3569        if (columnUpper[iColumn]>
     3570            columnLower[iColumn]+1.0e-12) {
     3571          //if (usefulColumn[iColumn]) {
     3572          CoinBigIndex j;
     3573          largest=1.0e-20;
     3574          smallest=1.0e50;
     3575          for (j=columnStart[iColumn];
     3576               j<columnStart[iColumn]+columnLength[iColumn];j++) {
     3577            iRow=row[j];
     3578            usedRow[iRow]=1;
     3579            double value = fabs(elementByColumn[j]*rowScale[iRow]);
     3580            largest = CoinMax(largest,value);
     3581            smallest = CoinMin(smallest,value);
     3582          }
     3583          columnScale[iColumn]=overallLargest/largest;
     3584          //columnScale[iColumn]=CoinMax(1.0e-10,CoinMin(1.0e10,columnScale[iColumn]));
    34903585#ifdef RANDOMIZE
    3491         double value = 0.5-randomNumberGenerator_.randomDouble();//between -0.5 to + 0.5
    3492         columnScale[iColumn] *= (1.0+0.1*value);
    3493 #endif
    3494         double difference = columnUpper[iColumn]-columnLower[iColumn];
    3495         if (difference<1.0e-5*columnScale[iColumn]) {
    3496           // make gap larger
    3497           columnScale[iColumn] = difference/1.0e-5;
    3498           //printf("Column %d difference %g scaled diff %g => %g\n",iColumn,difference,
    3499           // scaledDifference,difference*columnScale[iColumn]);
    3500         }
    3501         double value = smallest*columnScale[iColumn];
    3502         if (overallSmallest>value)
    3503           overallSmallest = value;
    3504         //overallSmallest = CoinMin(overallSmallest,smallest*columnScale[iColumn]);
    3505       } else {
    3506         assert(columnScale[iColumn]==1.0);
    3507         //columnScale[iColumn]=1.0;
    3508       }
    3509     }
    3510     for (iRow=0;iRow<numberRows;iRow++) {
    3511       if (!usedRow[iRow]) {
    3512         rowScale[iRow] = 1.0;
     3586          double value = 0.5-randomNumberGenerator_.randomDouble();//between -0.5 to + 0.5
     3587          columnScale[iColumn] *= (1.0+0.1*value);
     3588#endif
     3589          double difference = columnUpper[iColumn]-columnLower[iColumn];
     3590          if (difference<1.0e-5*columnScale[iColumn]) {
     3591            // make gap larger
     3592            columnScale[iColumn] = difference/1.0e-5;
     3593            //printf("Column %d difference %g scaled diff %g => %g\n",iColumn,difference,
     3594            // scaledDifference,difference*columnScale[iColumn]);
     3595          }
     3596          double value = smallest*columnScale[iColumn];
     3597          if (overallSmallest>value)
     3598            overallSmallest = value;
     3599          //overallSmallest = CoinMin(overallSmallest,smallest*columnScale[iColumn]);
     3600        } else {
     3601          assert(columnScale[iColumn]==1.0);
     3602          //columnScale[iColumn]=1.0;
     3603        }
     3604      }
     3605      for (iRow=0;iRow<numberRows;iRow++) {
     3606        if (!usedRow[iRow]) {
     3607          rowScale[iRow] = 1.0;
     3608        }
    35133609      }
    35143610    }
  • trunk/Clp/src/ClpSimplex.cpp

    r1412 r1424  
    1025310253          setDblParam(ClpDualObjectiveLimit,bestObjective*optimizationDirection_);
    1025410254        } else {
     10255          //#define CLP_INVESTIGATE
     10256#ifdef CLP_INVESTIGATE
    1025510257          printf("why bad solution feasible\n");
     10258#endif
    1025610259        }
    1025710260        //delete node;
     
    1082810831          setDblParam(ClpDualObjectiveLimit,bestObjective*optimizationDirection_);
    1082910832        } else {
     10833#ifdef CLP_INVESTIGATE
    1083010834          printf("why bad solution feasible\n");
     10835          abort();
     10836#endif
    1083110837        }
    1083210838        backtrack=true;
     
    1126711273  return small;
    1126811274}
     11275// Resizes rim part of model
     11276void
     11277ClpSimplex::resize (int newNumberRows, int newNumberColumns)
     11278{
     11279  ClpModel::resize(newNumberRows,newNumberColumns);
     11280  if (saveStatus_) {
     11281    // delete arrays
     11282    int saveOptions = specialOptions_;
     11283    specialOptions_=0;
     11284    gutsOfDelete(2);
     11285    specialOptions_=saveOptions;
     11286  }
     11287}
    1126911288// Return true if the objective limit test can be relied upon
    1127011289bool
  • trunk/Clp/src/ClpSimplex.hpp

    r1412 r1424  
    11641164                                   const int* indexLast,
    11651165                                   const double* boundList);
     1166  /// Resizes rim part of model
     1167  void resize (int newNumberRows, int newNumberColumns);
    11661168   
    11671169    //@}
Note: See TracChangeset for help on using the changeset viewer.