Changeset 461


Ignore:
Timestamp:
Oct 1, 2004 4:01:01 PM (16 years ago)
Author:
forrest
Message:

Trying to make faster

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpDummyMatrix.cpp

    r451 r461  
    148148  abort();
    149149}
    150 /* If element NULL returns number of elements in column part of basis,
    151    If not NULL fills in as well */
     150/// returns number of elements in column part of basis,
    152151CoinBigIndex
    153 ClpDummyMatrix::fillBasis(ClpSimplex * model,
     152ClpDummyMatrix::countBasis(ClpSimplex * model,
    154153                                 const int * whichColumn,
    155154                                 int numberBasic,
    156                                  int & numberColumnBasic,
    157                                  int * indexRowU, int * indexColumnU,
    158                                  double * elementU)
     155                           int & numberColumnBasic)
     156{
     157  std::cerr<<"countBasis not supported - ClpDummyMatrix"<<std::endl;
     158  abort();
     159  return 0;
     160}
     161void
     162ClpDummyMatrix::fillBasis(ClpSimplex * model,
     163                         const int * whichColumn,
     164                         int & numberColumnBasic,
     165                         int * row, int * start,
     166                         int * rowCount, int * columnCount,
     167                         double * element)
    159168{
    160169  std::cerr<<"fillBasis not supported - ClpDummyMatrix"<<std::endl;
    161170  abort();
    162   return 0;
    163171}
    164172/* Unpacks a column into an CoinIndexedvector
  • trunk/ClpFactorization.cpp

    r454 r461  
    176176        int numberColumnBasic = numberBasic-numberRowBasic;
    177177
    178         numberElements +=matrix->fillBasis(model,
     178        numberElements +=matrix->countBasis(model,
    179179                                           pivotTemp+numberRowBasic,
    180180                                           numberRowBasic,
    181                                            numberColumnBasic,
    182                                            NULL,NULL,NULL);
     181                                            numberColumnBasic);
    183182        // and recompute as network side say different
    184183        if (model->numberIterations())
     
    196195#endif
    197196        //fill
    198         //copy
    199         numberElements=numberRowBasic;
     197        // Fill in counts so we can skip part of preProcess
     198        CoinZeroN ( numberInRow_, numberRows_ + 1 );
     199        CoinZeroN ( numberInColumn_, maximumColumnsExtra_ + 1 );
    200200        for (i=0;i<numberRowBasic;i++) {
    201201          int iRow = pivotTemp[i];
    202202          indexRowU_[i]=iRow;
    203           indexColumnU_[i]=i;
     203          startColumnU_[i]=i;
    204204          elementU_[i]=slackValue_;
    205         }
     205          numberInRow_[iRow]=1;
     206          numberInColumn_[i]=1;
     207        }
     208        startColumnU_[numberRowBasic]=numberRowBasic;
    206209        // can change for gub so redo
    207210        numberColumnBasic = numberBasic-numberRowBasic;
    208         numberElements +=matrix->fillBasis(model,
    209                                            pivotTemp+numberRowBasic,
    210                                            numberRowBasic,
    211                                            numberColumnBasic,
    212                                            indexRowU_+numberElements,
    213                                            indexColumnU_+numberElements,
    214                                            elementU_+numberElements);
     211        matrix->fillBasis(model,
     212                          pivotTemp+numberRowBasic,
     213                          numberColumnBasic,
     214                          indexRowU_,
     215                          startColumnU_+numberRowBasic,
     216                          numberInRow_,
     217                          numberInColumn_+numberRowBasic,
     218                          elementU_);
    215219#if 0
    216220        {
     
    223227        // recompute number basic
    224228        numberBasic = numberRowBasic+numberColumnBasic;
     229        numberElements = startColumnU_[numberBasic-1]
     230          +numberInColumn_[numberBasic-1];
    225231        lengthU_ = numberElements;
    226 
    227         preProcess ( 0 );
     232        //CoinFillN(indexColumnU_,numberElements,-1);
     233        preProcess ( 2 );
    228234        factor (  );
    229235        if (status_==-99) {
  • trunk/ClpGubMatrix.cpp

    r451 r461  
    889889  }
    890890}
    891 /* If element NULL returns number of elements in column part of basis,
    892    If not NULL fills in as well */
     891/// returns number of elements in column part of basis,
    893892CoinBigIndex
    894 ClpGubMatrix::fillBasis(ClpSimplex * model,
     893ClpGubMatrix::countBasis(ClpSimplex * model,
    895894                           const int * whichColumn,
    896895                           int numberBasic,
    897                            int & numberColumnBasic,
    898                            int * indexRowU, int * indexColumnU,
    899                            double * elementU)
     896                         int & numberColumnBasic)
    900897{
    901898  int i;
     
    904901  int numberRows = getNumRows();
    905902  int saveNumberBasic=numberBasic;
    906   assert (next_ ||!elementU) ;
    907903  CoinBigIndex numberElements=0;
    908904  int lastSet=-1;
     
    916912  const int * row = matrix_->getIndices();
    917913  const double * elementByColumn = matrix_->getElements();
    918   const double * rowScale = model->rowScale();
    919   if (elementU!=NULL) {
    920     if (0) {
    921       printf("%d basic, %d columns\n",numberBasic,numberColumnBasic);
    922       int i;
    923       for (i=0;i<numberSets_;i++) {
    924         int k=keyVariable_[i];
    925         if (k<numberColumns) {
    926           printf("key %d on set %d, %d elements\n",k,i,columnStart[k+1]-columnStart[k]);
    927           for (int j=columnStart[k];j<columnStart[k+1];j++)
    928             printf("row %d el %g\n",row[j],elementByColumn[j]);
    929         } else {
    930           printf("slack key on set %d\n",i);
    931         }
    932       }
    933     }
    934     // fill
    935     if (!rowScale) {
    936       // no scaling
    937       for (i=0;i<numberColumnBasic;i++) {
    938         int iColumn = whichColumn[i];
    939         int iSet = backward_[iColumn];
    940         int length = columnLength[iColumn];
    941         if (0) {
    942           int k=iColumn;
    943           printf("column %d in set %d, %d elements\n",k,iSet,columnStart[k+1]-columnStart[k]);
    944           for (int j=columnStart[k];j<columnStart[k+1];j++)
    945             printf("row %d el %g\n",row[j],elementByColumn[j]);
    946         }
     914  // just count
     915  for (i=0;i<numberColumnBasic;i++) {
     916    int iColumn = whichColumn[i];
     917    int iSet = backward_[iColumn];
     918    int length = columnLength[iColumn];
     919    if (iSet<0||keyVariable_[iSet]>=numberColumns) {
     920      numberElements += length;
     921      numberBasic++;
     922    } else {
     923      // in gub set
     924      if (iColumn!=keyVariable_[iSet]) {
     925        numberBasic++;
    947926        CoinBigIndex j;
    948         if (iSet<0||keyVariable_[iSet]>=numberColumns) {
    949           for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
    950             double value = elementByColumn[j];
    951             if (fabs(value)>1.0e-20) {
    952               int iRow = row[j];
    953               indexRowU[numberElements]=iRow;
    954               indexColumnU[numberElements]=numberBasic;
    955               elementU[numberElements++]=value;
    956             }
    957           }
    958           numberBasic++;
    959         } else {
    960           // in gub set
    961           if (iColumn!=keyVariable_[iSet]) {
    962             // not key
    963             if (lastSet!=iSet) {
    964               // erase work
    965               if (key>=0) {
    966                 for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    967                   int iRow=row[j];
    968                   work[iRow]=0.0;
    969                   mark[iRow]=0;
    970                 }
    971               }
    972               key=keyVariable_[iSet];
    973               lastSet=iSet;
    974               keyLength = columnLength[key];
    975               for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    976                 int iRow=row[j];
    977                 work[iRow]=elementByColumn[j];
    978                 mark[iRow]=1;
    979               }
    980             }
    981             for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
    982               int iRow = row[j];
    983               double value=elementByColumn[j];
    984               if (mark[iRow]) {
    985                 mark[iRow]=0;
    986                 double keyValue = work[iRow];
    987                 value -= keyValue;
    988               }
    989               if (fabs(value)>1.0e-20) {
    990                 indexRowU[numberElements]=iRow;
    991                 indexColumnU[numberElements]=numberBasic;
    992                 elementU[numberElements++]=value;
    993               }
    994             }
    995             for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    996               int iRow = row[j];
    997               if (mark[iRow]) {
    998                 double value = -work[iRow];
    999                 if (fabs(value)>1.0e-20) {
    1000                   indexRowU[numberElements]=iRow;
    1001                   indexColumnU[numberElements]=numberBasic;
    1002                   elementU[numberElements++]=value;
    1003                 }
    1004               } else {
    1005                 // just put back mark
    1006                 mark[iRow]=1;
    1007               }
    1008             }
    1009             numberBasic++;
    1010           }
    1011         }
    1012       }
    1013     } else {
    1014       // scaling
    1015       const double * columnScale = model->columnScale();
    1016       for (i=0;i<numberColumnBasic;i++) {
    1017         int iColumn = whichColumn[i];
    1018         int iSet = backward_[iColumn];
    1019         int length = columnLength[iColumn];
    1020         CoinBigIndex j;
    1021         if (iSet<0||keyVariable_[iSet]>=numberColumns) {
    1022           double scale = columnScale[iColumn];
    1023           for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
    1024             int iRow = row[j];
    1025             double value = elementByColumn[j]*scale*rowScale[iRow];
    1026             if (fabs(value)>1.0e-20) {
    1027               indexRowU[numberElements]=iRow;
    1028               indexColumnU[numberElements]=numberBasic;
    1029               elementU[numberElements++]=value;
    1030             }
    1031           }
    1032           numberBasic++;
    1033         } else {
    1034           // in gub set
    1035           if (iColumn!=keyVariable_[iSet]) {
    1036             double scale = columnScale[iColumn];
    1037             // not key
    1038             if (lastSet<iSet) {
    1039               // erase work
    1040               if (key>=0) {
    1041                 for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    1042                   int iRow=row[j];
    1043                   work[iRow]=0.0;
    1044                   mark[iRow]=0;
    1045                 }
    1046               }
    1047               key=keyVariable_[iSet];
    1048               lastSet=iSet;
    1049               keyLength = columnLength[key];
    1050               double scale = columnScale[key];
    1051               for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    1052                 int iRow=row[j];
    1053                 work[iRow]=elementByColumn[j]*scale*rowScale[iRow];
    1054                 mark[iRow]=1;
    1055               }
    1056             }
    1057             for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
    1058               int iRow = row[j];
    1059               double value=elementByColumn[j]*scale*rowScale[iRow];
    1060               if (mark[iRow]) {
    1061                 mark[iRow]=0;
    1062                 double keyValue = work[iRow];
    1063                 value -= keyValue;
    1064               }
    1065               if (fabs(value)>1.0e-20) {
    1066                 indexRowU[numberElements]=iRow;
    1067                 indexColumnU[numberElements]=numberBasic;
    1068                 elementU[numberElements++]=value;
    1069               }
    1070             }
    1071             for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    1072               int iRow = row[j];
    1073               if (mark[iRow]) {
    1074                 double value = -work[iRow];
    1075                 if (fabs(value)>1.0e-20) {
    1076                   indexRowU[numberElements]=iRow;
    1077                   indexColumnU[numberElements]=numberBasic;
    1078                   elementU[numberElements++]=value;
    1079                 }
    1080               } else {
    1081                 // just put back mark
    1082                 mark[iRow]=1;
    1083               }
    1084             }
    1085             numberBasic++;
    1086           }
    1087         }
    1088       }
    1089     }
    1090   } else {
    1091     // just count
    1092     if (!rowScale) {
    1093       for (i=0;i<numberColumnBasic;i++) {
    1094         int iColumn = whichColumn[i];
    1095         int iSet = backward_[iColumn];
    1096         int length = columnLength[iColumn];
    1097         if (iSet<0||keyVariable_[iSet]>=numberColumns) {
    1098           numberElements += length;
    1099           numberBasic++;
    1100         } else {
    1101           // in gub set
    1102           if (iColumn!=keyVariable_[iSet]) {
    1103             numberBasic++;
    1104             CoinBigIndex j;
    1105             // not key
    1106             if (lastSet<iSet) {
    1107               // erase work
    1108               if (key>=0) {
    1109                 for (j=columnStart[key];j<columnStart[key]+keyLength;j++)
    1110                   work[row[j]]=0.0;
    1111               }
    1112               key=keyVariable_[iSet];
    1113               lastSet=iSet;
    1114               keyLength = columnLength[key];
    1115               for (j=columnStart[key];j<columnStart[key]+keyLength;j++)
    1116                 work[row[j]]=elementByColumn[j];
    1117             }
    1118             int extra=keyLength;
    1119             for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
    1120               int iRow = row[j];
    1121               double keyValue = work[iRow];
    1122               double value=elementByColumn[j];
    1123               if (!keyValue) {
    1124                 if (fabs(value)>1.0e-20)
    1125                   extra++;
    1126               } else {
    1127                 value -= keyValue;
    1128                 if (fabs(value)<=1.0e-20)
    1129                   extra--;
    1130               }
    1131             }
    1132             numberElements+=extra;
    1133           }
    1134         }
    1135       }
    1136     } else {
    1137       // scaled
    1138       const double * columnScale = model->columnScale();
    1139       for (i=0;i<numberColumnBasic;i++) {
    1140         int iColumn = whichColumn[i];
    1141         int iSet = backward_[iColumn];
    1142         int length = columnLength[iColumn];
    1143         if (iSet<0||keyVariable_[iSet]>=numberColumns) {
    1144           numberElements += length;
    1145           numberBasic++;
    1146         } else {
    1147           // in gub set
    1148           if (iColumn!=keyVariable_[iSet]) {
    1149             numberBasic++;
    1150             CoinBigIndex j;
    1151             double scale = columnScale[iColumn];
    1152             // not key
    1153             if (lastSet<iSet) {
    1154               // erase work
    1155               if (key>=0) {
    1156                 for (j=columnStart[key];j<columnStart[key]+keyLength;j++)
    1157                   work[row[j]]=0.0;
    1158               }
    1159               key=keyVariable_[iSet];
    1160               lastSet=iSet;
    1161               keyLength = columnLength[key];
    1162               double scale = columnScale[key];
    1163               for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
    1164                 int iRow = row[j];
    1165                 work[iRow]=elementByColumn[j]*scale*rowScale[iRow];
    1166               }
    1167             }
    1168             int extra=keyLength;
    1169             for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
    1170               int iRow = row[j];
    1171               double keyValue = work[iRow];
    1172               double value=elementByColumn[j]*scale*rowScale[iRow];
    1173               if (!keyValue) {
    1174                 if (fabs(value)>1.0e-20)
    1175                   extra++;
    1176               } else {
    1177                 value -= keyValue;
    1178                 if (fabs(value)<=1.0e-20)
    1179                   extra--;
    1180               }
    1181             }
    1182             numberElements+=extra;
    1183           }
    1184         }
     927        // not key
     928        if (lastSet<iSet) {
     929          // erase work
     930          if (key>=0) {
     931            for (j=columnStart[key];j<columnStart[key]+keyLength;j++)
     932              work[row[j]]=0.0;
     933          }
     934          key=keyVariable_[iSet];
     935          lastSet=iSet;
     936          keyLength = columnLength[key];
     937          for (j=columnStart[key];j<columnStart[key]+keyLength;j++)
     938            work[row[j]]=elementByColumn[j];
     939        }
     940        int extra=keyLength;
     941        for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
     942          int iRow = row[j];
     943          double keyValue = work[iRow];
     944          double value=elementByColumn[j];
     945          if (!keyValue) {
     946            if (fabs(value)>1.0e-20)
     947              extra++;
     948          } else {
     949            value -= keyValue;
     950            if (fabs(value)<=1.0e-20)
     951              extra--;
     952          }
     953        }
     954        numberElements+=extra;
    1185955      }
    1186956    }
     
    1191961  numberColumnBasic = numberBasic-saveNumberBasic;
    1192962  return numberElements;
     963}
     964void
     965ClpGubMatrix::fillBasis(ClpSimplex * model,
     966                         const int * whichColumn,
     967                         int & numberColumnBasic,
     968                         int * indexRowU, int * start,
     969                         int * rowCount, int * columnCount,
     970                         double * elementU)
     971{
     972  int i;
     973  int numberColumns = getNumCols();
     974  const int * columnLength = matrix_->getVectorLengths();
     975  int numberRows = getNumRows();
     976  assert (next_ ||!elementU) ;
     977  CoinBigIndex numberElements=start[0];
     978  int lastSet=-1;
     979  int key=-1;
     980  int keyLength=-1;
     981  double * work = new double[numberRows];
     982  CoinZeroN(work,numberRows);
     983  char * mark = new char[numberRows];
     984  CoinZeroN(mark,numberRows);
     985  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     986  const int * row = matrix_->getIndices();
     987  const double * elementByColumn = matrix_->getElements();
     988  const double * rowScale = model->rowScale();
     989  int numberBasic=0;
     990  if (0) {
     991    printf("%d basiccolumns\n",numberColumnBasic);
     992    int i;
     993    for (i=0;i<numberSets_;i++) {
     994      int k=keyVariable_[i];
     995      if (k<numberColumns) {
     996        printf("key %d on set %d, %d elements\n",k,i,columnStart[k+1]-columnStart[k]);
     997        for (int j=columnStart[k];j<columnStart[k+1];j++)
     998          printf("row %d el %g\n",row[j],elementByColumn[j]);
     999      } else {
     1000        printf("slack key on set %d\n",i);
     1001      }
     1002    }
     1003  }
     1004  // fill
     1005  if (!rowScale) {
     1006    // no scaling
     1007    for (i=0;i<numberColumnBasic;i++) {
     1008      int iColumn = whichColumn[i];
     1009      int iSet = backward_[iColumn];
     1010      int length = columnLength[iColumn];
     1011      if (0) {
     1012        int k=iColumn;
     1013        printf("column %d in set %d, %d elements\n",k,iSet,columnStart[k+1]-columnStart[k]);
     1014        for (int j=columnStart[k];j<columnStart[k+1];j++)
     1015          printf("row %d el %g\n",row[j],elementByColumn[j]);
     1016      }
     1017      CoinBigIndex j;
     1018      if (iSet<0||keyVariable_[iSet]>=numberColumns) {
     1019        for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1020          double value = elementByColumn[j];
     1021          if (fabs(value)>1.0e-20) {
     1022            int iRow = row[j];
     1023            indexRowU[numberElements]=iRow;
     1024            rowCount[iRow]++;
     1025            elementU[numberElements++]=value;
     1026          }
     1027        }
     1028        // end of column
     1029        columnCount[numberBasic]=numberElements-start[numberBasic];
     1030        numberBasic++;
     1031        start[numberBasic]=numberElements;
     1032      } else {
     1033        // in gub set
     1034        if (iColumn!=keyVariable_[iSet]) {
     1035          // not key
     1036          if (lastSet!=iSet) {
     1037            // erase work
     1038            if (key>=0) {
     1039              for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1040                int iRow=row[j];
     1041                work[iRow]=0.0;
     1042                mark[iRow]=0;
     1043              }
     1044            }
     1045            key=keyVariable_[iSet];
     1046            lastSet=iSet;
     1047            keyLength = columnLength[key];
     1048            for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1049              int iRow=row[j];
     1050              work[iRow]=elementByColumn[j];
     1051              mark[iRow]=1;
     1052            }
     1053          }
     1054          for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
     1055            int iRow = row[j];
     1056            double value=elementByColumn[j];
     1057            if (mark[iRow]) {
     1058              mark[iRow]=0;
     1059              double keyValue = work[iRow];
     1060              value -= keyValue;
     1061            }
     1062            if (fabs(value)>1.0e-20) {
     1063              indexRowU[numberElements]=iRow;
     1064              rowCount[iRow]++;
     1065              elementU[numberElements++]=value;
     1066            }
     1067          }
     1068          for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1069            int iRow = row[j];
     1070            if (mark[iRow]) {
     1071              double value = -work[iRow];
     1072              if (fabs(value)>1.0e-20) {
     1073                indexRowU[numberElements]=iRow;
     1074                rowCount[iRow]++;
     1075                elementU[numberElements++]=value;
     1076              }
     1077            } else {
     1078              // just put back mark
     1079              mark[iRow]=1;
     1080            }
     1081          }
     1082          // end of column
     1083          columnCount[numberBasic]=numberElements-start[numberBasic];
     1084          numberBasic++;
     1085          start[numberBasic]=numberElements;
     1086        }
     1087      }
     1088    }
     1089  } else {
     1090    // scaling
     1091    const double * columnScale = model->columnScale();
     1092    for (i=0;i<numberColumnBasic;i++) {
     1093      int iColumn = whichColumn[i];
     1094      int iSet = backward_[iColumn];
     1095      int length = columnLength[iColumn];
     1096      CoinBigIndex j;
     1097      if (iSet<0||keyVariable_[iSet]>=numberColumns) {
     1098        double scale = columnScale[iColumn];
     1099        for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1100          int iRow = row[j];
     1101          double value = elementByColumn[j]*scale*rowScale[iRow];
     1102          if (fabs(value)>1.0e-20) {
     1103            indexRowU[numberElements]=iRow;
     1104            rowCount[iRow]++;
     1105            elementU[numberElements++]=value;
     1106          }
     1107        }
     1108        // end of column
     1109        columnCount[numberBasic]=numberElements-start[numberBasic];
     1110        numberBasic++;
     1111        start[numberBasic]=numberElements;
     1112      } else {
     1113        // in gub set
     1114        if (iColumn!=keyVariable_[iSet]) {
     1115          double scale = columnScale[iColumn];
     1116          // not key
     1117          if (lastSet<iSet) {
     1118            // erase work
     1119            if (key>=0) {
     1120              for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1121                int iRow=row[j];
     1122                work[iRow]=0.0;
     1123                mark[iRow]=0;
     1124              }
     1125            }
     1126            key=keyVariable_[iSet];
     1127            lastSet=iSet;
     1128            keyLength = columnLength[key];
     1129            double scale = columnScale[key];
     1130            for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1131              int iRow=row[j];
     1132              work[iRow]=elementByColumn[j]*scale*rowScale[iRow];
     1133              mark[iRow]=1;
     1134            }
     1135          }
     1136          for (j=columnStart[iColumn];j<columnStart[iColumn]+length;j++) {
     1137            int iRow = row[j];
     1138            double value=elementByColumn[j]*scale*rowScale[iRow];
     1139            if (mark[iRow]) {
     1140              mark[iRow]=0;
     1141              double keyValue = work[iRow];
     1142              value -= keyValue;
     1143            }
     1144            if (fabs(value)>1.0e-20) {
     1145              indexRowU[numberElements]=iRow;
     1146              rowCount[iRow]++;
     1147              elementU[numberElements++]=value;
     1148            }
     1149          }
     1150          for (j=columnStart[key];j<columnStart[key]+keyLength;j++) {
     1151            int iRow = row[j];
     1152            if (mark[iRow]) {
     1153              double value = -work[iRow];
     1154              if (fabs(value)>1.0e-20) {
     1155                indexRowU[numberElements]=iRow;
     1156                rowCount[iRow]++;
     1157                elementU[numberElements++]=value;
     1158              }
     1159            } else {
     1160              // just put back mark
     1161              mark[iRow]=1;
     1162            }
     1163          }
     1164          // end of column
     1165          columnCount[numberBasic]=numberElements-start[numberBasic];
     1166          numberBasic++;
     1167          start[numberBasic]=numberElements;
     1168        }
     1169      }
     1170    }
     1171  }
     1172  delete [] work;
     1173  delete [] mark;
     1174  // update number of column basic
     1175  numberColumnBasic = numberBasic;
    11931176}
    11941177/* Unpacks a column into an CoinIndexedvector
  • trunk/ClpNetworkMatrix.cpp

    r451 r461  
    525525  }
    526526}
    527 /* If element NULL returns number of elements in column part of basis,
    528    If not NULL fills in as well */
     527/// returns number of elements in column part of basis,
    529528CoinBigIndex
    530 ClpNetworkMatrix::fillBasis(ClpSimplex * model,
     529ClpNetworkMatrix::countBasis(ClpSimplex * model,
    531530                                 const int * whichColumn,
    532531                                 int numberBasic,
    533                                  int & numberColumnBasic,
    534                                  int * indexRowU, int * indexColumnU,
    535                                  double * elementU) 
     532                             int & numberColumnBasic)
    536533{
    537534  int i;
    538535  CoinBigIndex numberElements=0;
    539   if (elementU!=NULL) {
    540     if (trueNetwork_) {
    541       for (i=0;i<numberColumnBasic;i++) {
    542         int iColumn = whichColumn[i];
    543         CoinBigIndex j=iColumn<<1;
    544         int iRowM = indices_[j];
    545         int iRowP = indices_[j+1];
     536  if (trueNetwork_) {
     537    numberElements = 2*numberColumnBasic;
     538  } else {
     539    for (i=0;i<numberColumnBasic;i++) {
     540      int iColumn = whichColumn[i];
     541      CoinBigIndex j=iColumn<<1;
     542      int iRowM = indices_[j];
     543      int iRowP = indices_[j+1];
     544      if (iRowM>=0)
     545        numberElements ++;
     546      if (iRowP>=0)
     547        numberElements ++;
     548    }
     549  }
     550  return numberElements;
     551}
     552void
     553ClpNetworkMatrix::fillBasis(ClpSimplex * model,
     554                         const int * whichColumn,
     555                         int & numberColumnBasic,
     556                         int * indexRowU, int * start,
     557                         int * rowCount, int * columnCount,
     558                         double * elementU)
     559{
     560  int i;
     561  CoinBigIndex numberElements=start[0];
     562  if (trueNetwork_) {
     563    for (i=0;i<numberColumnBasic;i++) {
     564      int iColumn = whichColumn[i];
     565      CoinBigIndex j=iColumn<<1;
     566      int iRowM = indices_[j];
     567      int iRowP = indices_[j+1];
     568      indexRowU[numberElements]=iRowM;
     569      rowCount[iRowM++];
     570      elementU[numberElements]=-1.0;
     571      indexRowU[numberElements+1]=iRowP;
     572      rowCount[iRowP++];
     573      elementU[numberElements+1]=1.0;
     574      numberElements+=2;
     575      start[i+1]=numberElements;
     576      columnCount[i]=2;
     577    }
     578  } else {
     579    for (i=0;i<numberColumnBasic;i++) {
     580      int iColumn = whichColumn[i];
     581      CoinBigIndex j=iColumn<<1;
     582      int iRowM = indices_[j];
     583      int iRowP = indices_[j+1];
     584      if (iRowM>=0) {
    546585        indexRowU[numberElements]=iRowM;
    547         indexColumnU[numberElements]=numberBasic;
    548         elementU[numberElements]=-1.0;
    549         indexRowU[numberElements+1]=iRowP;
    550         indexColumnU[numberElements+1]=numberBasic;
    551         elementU[numberElements+1]=1.0;
    552         numberElements+=2;
    553         numberBasic++;
    554       }
    555     } else {
    556       for (i=0;i<numberColumnBasic;i++) {
    557         int iColumn = whichColumn[i];
    558         CoinBigIndex j=iColumn<<1;
    559         int iRowM = indices_[j];
    560         int iRowP = indices_[j+1];
    561         if (iRowM>=0) {
    562           indexRowU[numberElements]=iRowM;
    563           indexColumnU[numberElements]=numberBasic;
    564           elementU[numberElements++]=-1.0;
    565         }
    566         if (iRowP>=0) {
    567           indexRowU[numberElements]=iRowP;
    568           indexColumnU[numberElements]=numberBasic;
    569           elementU[numberElements++]=1.0;
    570         }
    571         numberBasic++;
    572       }
    573     }
    574   } else {
    575     if (trueNetwork_) {
    576       numberElements = 2*numberColumnBasic;
    577     } else {
    578       for (i=0;i<numberColumnBasic;i++) {
    579         int iColumn = whichColumn[i];
    580         CoinBigIndex j=iColumn<<1;
    581         int iRowM = indices_[j];
    582         int iRowP = indices_[j+1];
    583         if (iRowM>=0)
    584           numberElements ++;
    585         if (iRowP>=0)
    586           numberElements ++;
    587       }
    588     }
    589   }
    590   return numberElements;
     586        rowCount[iRowM++];
     587        elementU[numberElements++]=-1.0;
     588      }
     589      if (iRowP>=0) {
     590        indexRowU[numberElements]=iRowP;
     591        rowCount[iRowP++];
     592        elementU[numberElements++]=1.0;
     593      }
     594      start[i+1]=numberElements;
     595      columnCount[i]=numberElements-start[i];
     596    }
     597  }
    591598}
    592599/* Unpacks a column into an CoinIndexedvector
  • trunk/ClpNonLinearCost.cpp

    r448 r461  
    2222  changeCost_(0.0),
    2323  feasibleCost_(0.0),
     24  infeasibilityWeight_(-1.0),
    2425  largestInfeasibility_(0.0),
    2526  sumInfeasibilities_(0.0),
     
    6364  changeCost_=0.0;
    6465  feasibleCost_=0.0;
     66  infeasibilityWeight_ = -1.0;
    6567  double infeasibilityCost = model_->infeasibilityCost();
    6668  sumInfeasibilities_=0.0;
     
    173175  feasibleCost_=0.0;
    174176  double infeasibilityCost = model_->infeasibilityCost();
     177  infeasibilityWeight_ = infeasibilityCost;;
    175178  largestInfeasibility_=0.0;
    176179  sumInfeasibilities_=0.0;
     
    280283  changeCost_(0.0),
    281284  feasibleCost_(0.0),
     285  infeasibilityWeight_(-1.0),
    282286  largestInfeasibility_(0.0),
    283287  sumInfeasibilities_(0.0),
     
    313317    changeCost_ = rhs.changeCost_;
    314318    feasibleCost_ = rhs.feasibleCost_;
     319    infeasibilityWeight_ = rhs.infeasibilityWeight_;
    315320    largestInfeasibility_ = rhs.largestInfeasibility_;
    316321    sumInfeasibilities_ = rhs.sumInfeasibilities_;
     
    377382    changeCost_ = rhs.changeCost_;
    378383    feasibleCost_ = rhs.feasibleCost_;
     384    infeasibilityWeight_ = rhs.infeasibilityWeight_;
    379385    largestInfeasibility_ = rhs.largestInfeasibility_;
    380386    sumInfeasibilities_ = rhs.sumInfeasibilities_;
     
    405411  bool toNearest = oldTolerance<=0.0;
    406412  feasibleCost_=0.0;
     413  //bool checkCosts = (infeasibilityWeight_ != infeasibilityCost);
     414  infeasibilityWeight_ = infeasibilityCost;
    407415   
    408416  // nonbasic should be at a valid bound
  • trunk/ClpPackedMatrix.cpp

    r426 r461  
    11341134  }
    11351135}
    1136 /* If element NULL returns number of elements in column part of basis,
    1137    If not NULL fills in as well */
     1136/// returns number of elements in column part of basis,
    11381137CoinBigIndex
    1139 ClpPackedMatrix::fillBasis(ClpSimplex * model,
     1138ClpPackedMatrix::countBasis(ClpSimplex * model,
    11401139                           const int * whichColumn,
    11411140                           int numberBasic,
    1142                            int & numberColumnBasic,
    1143                            int * indexRowU, int * indexColumnU,
    1144                            double * elementU)
     1141                            int & numberColumnBasic)
    11451142{
    11461143  const int * columnLength = matrix_->getVectorLengths();
    11471144  int i;
    11481145  CoinBigIndex numberElements=0;
    1149   if (elementU!=NULL) {
    1150     // fill
    1151     const CoinBigIndex * columnStart = matrix_->getVectorStarts();
    1152     const double * rowScale = model->rowScale();
    1153     const int * row = matrix_->getIndices();
    1154     const double * elementByColumn = matrix_->getElements();
    1155     if (!zeroElements_) {
    1156       if (!rowScale) {
    1157         // no scaling
    1158         for (i=0;i<numberColumnBasic;i++) {
    1159           int iColumn = whichColumn[i];
    1160           CoinBigIndex j;
    1161           for (j=columnStart[iColumn];
    1162                j<columnStart[iColumn]+columnLength[iColumn];j++) {
    1163             indexRowU[numberElements]=row[j];
    1164             indexColumnU[numberElements]=numberBasic;
    1165             elementU[numberElements++]=elementByColumn[j];
    1166           }
    1167           numberBasic++;
    1168         }
    1169       } else {
    1170         // scaling
    1171         const double * columnScale = model->columnScale();
    1172         for (i=0;i<numberColumnBasic;i++) {
    1173           int iColumn = whichColumn[i];
    1174           CoinBigIndex j;
    1175           double scale = columnScale[iColumn];
    1176           for (j=columnStart[iColumn];
    1177                j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1146  // just count - can be over so ignore zero problem
     1147  for (i=0;i<numberColumnBasic;i++) {
     1148    int iColumn = whichColumn[i];
     1149    numberElements += columnLength[iColumn];
     1150  }
     1151  return numberElements;
     1152}
     1153void
     1154ClpPackedMatrix::fillBasis(ClpSimplex * model,
     1155                         const int * whichColumn,
     1156                         int & numberColumnBasic,
     1157                         int * indexRowU, int * start,
     1158                         int * rowCount, int * columnCount,
     1159                         double * elementU)
     1160{
     1161  const int * columnLength = matrix_->getVectorLengths();
     1162  int i;
     1163  CoinBigIndex numberElements=start[0];
     1164  // fill
     1165  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     1166  const double * rowScale = model->rowScale();
     1167  const int * row = matrix_->getIndices();
     1168  const double * elementByColumn = matrix_->getElements();
     1169  if (!zeroElements_) {
     1170    if (!rowScale) {
     1171      // no scaling
     1172      for (i=0;i<numberColumnBasic;i++) {
     1173        int iColumn = whichColumn[i];
     1174        CoinBigIndex j;
     1175        for (j=columnStart[iColumn];
     1176             j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1177          int iRow=row[j];
     1178          indexRowU[numberElements]=iRow;
     1179          rowCount[iRow]++;
     1180          elementU[numberElements++]=elementByColumn[j];
     1181        }
     1182        start[i+1]=numberElements;
     1183        columnCount[i]=columnLength[iColumn];
     1184      }
     1185    } else {
     1186      // scaling
     1187      const double * columnScale = model->columnScale();
     1188      for (i=0;i<numberColumnBasic;i++) {
     1189        int iColumn = whichColumn[i];
     1190        CoinBigIndex j;
     1191        double scale = columnScale[iColumn];
     1192        for (j=columnStart[iColumn];
     1193             j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1194          int iRow = row[j];
     1195          indexRowU[numberElements]=iRow;
     1196          rowCount[iRow]++;
     1197          elementU[numberElements++]=
     1198            elementByColumn[j]*scale*rowScale[iRow];
     1199        }
     1200        start[i+1]=numberElements;
     1201        columnCount[i]=columnLength[iColumn];
     1202      }
     1203    }
     1204  } else {
     1205    // there are zero elements so need to look more closely
     1206    if (!rowScale) {
     1207      // no scaling
     1208      for (i=0;i<numberColumnBasic;i++) {
     1209        int iColumn = whichColumn[i];
     1210        CoinBigIndex j;
     1211        for (j=columnStart[iColumn];
     1212             j<columnStart[iColumn]+columnLength[iColumn];j++) {
     1213          double value = elementByColumn[j];
     1214          if (value) {
    11781215            int iRow = row[j];
    11791216            indexRowU[numberElements]=iRow;
    1180             indexColumnU[numberElements]=numberBasic;
    1181             elementU[numberElements++]=
    1182               elementByColumn[j]*scale*rowScale[iRow];
    1183           }
    1184           numberBasic++;
    1185         }
     1217            rowCount[iRow]++;
     1218            elementU[numberElements++]=value;
     1219          }
     1220        }
     1221        start[i+1]=numberElements;
     1222        columnCount[i]=numberElements-start[i];
    11861223      }
    11871224    } else {
    1188       // there are zero elements so need to look more closely
    1189       if (!rowScale) {
    1190         // no scaling
    1191         for (i=0;i<numberColumnBasic;i++) {
    1192           int iColumn = whichColumn[i];
    1193           CoinBigIndex j;
    1194           for (j=columnStart[iColumn];
    1195                j<columnStart[iColumn]+columnLength[iColumn];j++) {
    1196             double value = elementByColumn[j];
    1197             if (value) {
    1198               indexRowU[numberElements]=row[j];
    1199               indexColumnU[numberElements]=numberBasic;
    1200               elementU[numberElements++]=value;
    1201             }
    1202           }
    1203           numberBasic++;
    1204         }
    1205       } else {
    1206         // scaling
    1207         const double * columnScale = model->columnScale();
    1208         for (i=0;i<numberColumnBasic;i++) {
    1209           int iColumn = whichColumn[i];
    1210           CoinBigIndex j;
    1211           double scale = columnScale[iColumn];
    1212           for (j=columnStart[iColumn];
    1213                j<columnStart[iColumn]+columnLength[i];j++) {
    1214             double value = elementByColumn[j];
    1215             if (value) {
    1216               int iRow = row[j];
    1217               indexRowU[numberElements]=iRow;
    1218               indexColumnU[numberElements]=numberBasic;
    1219               elementU[numberElements++]=value*scale*rowScale[iRow];
    1220             }
    1221           }
    1222           numberBasic++;
    1223         }
    1224       }
    1225     }
    1226   } else {
    1227     // just count - can be over so ignore zero problem
    1228     for (i=0;i<numberColumnBasic;i++) {
    1229       int iColumn = whichColumn[i];
    1230       numberElements += columnLength[iColumn];
    1231     }
    1232   }
    1233   return numberElements;
     1225      // scaling
     1226      const double * columnScale = model->columnScale();
     1227      for (i=0;i<numberColumnBasic;i++) {
     1228        int iColumn = whichColumn[i];
     1229        CoinBigIndex j;
     1230        double scale = columnScale[iColumn];
     1231        for (j=columnStart[iColumn];
     1232             j<columnStart[iColumn]+columnLength[i];j++) {
     1233          double value = elementByColumn[j];
     1234          if (value) {
     1235            int iRow = row[j];
     1236            indexRowU[numberElements]=iRow;
     1237            rowCount[iRow]++;
     1238            elementU[numberElements++]=value*scale*rowScale[iRow];
     1239          }
     1240        }
     1241        start[i+1]=numberElements;
     1242        columnCount[i]=numberElements-start[i];
     1243      }
     1244    }
     1245  }
    12341246}
    12351247// Creates scales for column copy (rowCopy in model may be modified)
  • trunk/ClpPlusMinusOneMatrix.cpp

    r451 r461  
    904904  }
    905905}
    906 /* If element NULL returns number of elements in column part of basis,
    907    If not NULL fills in as well */
     906/// returns number of elements in column part of basis,
    908907CoinBigIndex
    909 ClpPlusMinusOneMatrix::fillBasis(ClpSimplex * model,
     908ClpPlusMinusOneMatrix::countBasis(ClpSimplex * model,
    910909                                 const int * whichColumn,
    911910                                 int numberBasic,
    912                                  int & numberColumnBasic,
    913                                  int * indexRowU, int * indexColumnU,
    914                                  double * elementU)
     911                                  int & numberColumnBasic)
    915912{
    916913  int i;
    917914  CoinBigIndex numberElements=0;
    918   if (elementU!=NULL) {
    919     assert (columnOrdered_);
    920     for (i=0;i<numberColumnBasic;i++) {
    921       int iColumn = whichColumn[i];
    922       CoinBigIndex j=startPositive_[iColumn];
    923       for (;j<startNegative_[iColumn];j++) {
    924         int iRow = indices_[j];
    925         indexRowU[numberElements]=iRow;
    926         indexColumnU[numberElements]=numberBasic;
    927         elementU[numberElements++]=1.0;
    928       }
    929       for (;j<startPositive_[iColumn+1];j++) {
    930         int iRow = indices_[j];
    931         indexRowU[numberElements]=iRow;
    932         indexColumnU[numberElements]=numberBasic;
    933         elementU[numberElements++]=-1.0;
    934       }
    935       numberBasic++;
    936     }
    937   } else {
    938     for (i=0;i<numberColumnBasic;i++) {
    939       int iColumn = whichColumn[i];
    940       numberElements += startPositive_[iColumn+1]-startPositive_[iColumn];
    941     }
     915  for (i=0;i<numberColumnBasic;i++) {
     916    int iColumn = whichColumn[i];
     917    numberElements += startPositive_[iColumn+1]-startPositive_[iColumn];
    942918  }
    943919  return numberElements;
     920}
     921void
     922ClpPlusMinusOneMatrix::fillBasis(ClpSimplex * model,
     923                         const int * whichColumn,
     924                         int & numberColumnBasic,
     925                         int * indexRowU, int * start,
     926                         int * rowCount, int * columnCount,
     927                         double * elementU)
     928{
     929  int i;
     930  CoinBigIndex numberElements=start[0];
     931  assert (columnOrdered_);
     932  for (i=0;i<numberColumnBasic;i++) {
     933    int iColumn = whichColumn[i];
     934    CoinBigIndex j=startPositive_[iColumn];
     935    for (;j<startNegative_[iColumn];j++) {
     936      int iRow = indices_[j];
     937      indexRowU[numberElements]=iRow;
     938      rowCount[iRow]++;
     939      elementU[numberElements++]=1.0;
     940    }
     941    for (;j<startPositive_[iColumn+1];j++) {
     942      int iRow = indices_[j];
     943      indexRowU[numberElements]=iRow;
     944      rowCount[iRow]++;
     945      elementU[numberElements++]=-1.0;
     946    }
     947    start[i+1]=numberElements;
     948    columnCount[i]=numberElements-start[i];
     949  }
    944950}
    945951/* Unpacks a column into an CoinIndexedvector
  • trunk/ClpPresolve.cpp

    r458 r461  
    390390  if (prob->anyProhibited())
    391391    doDualStuff=false;
    392   if ((presolveActions_&1)!=0)
     392  if (!doDual())
    393393    doDualStuff=false;
    394394#if     PRESOLVE_CONSISTENCY
     
    398398
    399399  if (!prob->status_) {
    400 #if 0
    401     const bool slackd = ATOI("SLACKD")!=0;
    402     //const bool forcing = ATOI("FORCING")!=0;
    403     const bool doubleton = ATOI("DOUBLETON")!=0;
    404     const bool forcing = ATOI("off")!=0;
    405     const bool ifree = ATOI("off")!=0;
    406     const bool zerocost = ATOI("off")!=0;
    407     const bool dupcol = ATOI("off")!=0;
    408     const bool duprow = ATOI("off")!=0;
    409     const bool dual = ATOI("off")!=0;
    410 #else
    411     // normal
    412 #if 0
    413     const bool slackd = true;
    414     const bool doubleton = false;
    415     const bool tripleton = true;
    416     const bool forcing = false;
    417     const bool ifree = true;
    418     const bool zerocost = true;
    419     const bool dupcol = false;
    420     const bool duprow = false;
     400    const bool slackd = doSingleton();
     401    const bool doubleton = doDoubleton();
     402    const bool tripleton = doTripleton();
     403    const bool forcing = doForcing();
     404    const bool ifree = doImpliedFree();
     405    const bool zerocost = doTighten();
     406    const bool dupcol = doDupcol();
     407    const bool duprow = doDuprow();
    421408    const bool dual = doDualStuff;
    422 #else
    423     const bool slackd = true;
    424     const bool doubleton = true;
    425     const bool tripleton = true;
    426     const bool forcing = true;
    427     const bool ifree = true;
    428     const bool zerocost = true;
    429     const bool dupcol = true;
    430     const bool duprow = true;
    431     const bool dual = doDualStuff;
    432 #endif
    433 #endif
    434409   
    435410    // some things are expensive so just do once (normally)
     
    469444    prob->pass_=0;
    470445    for (iLoop=0;iLoop<numberPasses_;iLoop++) {
     446    // See if we want statistics
     447    if ((presolveActions_&0x80000000)!=0)
     448      printf("Starting major pass %d after %g seconds\n",iLoop+1,CoinCpuTime()-prob->startTime_);
    471449#ifdef PRESOLVE_SUMMARY
    472450      printf("Starting major pass %d\n",iLoop+1);
     
    480458      while (1) {
    481459        whichPass++;
     460        prob->pass_++;
    482461        const CoinPresolveAction * const paction1 = paction_;
    483462
     
    521500        }
    522501
    523         if (ifree) {
    524           paction_ = implied_free_action::presolve(prob, paction_,fill_level);
    525           if (prob->status_)
    526             break;
     502        if (ifree&&(whichPass%5)==1) {
     503        paction_ = implied_free_action::presolve(prob, paction_,fill_level);
     504        if (prob->status_)
     505          break;
    527506        }
    528507
     
    617596        int itry;
    618597        for (itry=0;itry<5;itry++) {
    619           const CoinPresolveAction * const paction2 = paction_;
    620598          paction_ = remove_dual_action::presolve(prob, paction_);
    621599          if (prob->status_)
    622600            break;
     601          const CoinPresolveAction * const paction2 = paction_;
    623602          if (ifree) {
    624             int fill_level=0; // switches off substitution
     603            //int fill_level=0; // switches off substitution
    625604            paction_ = implied_free_action::presolve(prob, paction_,fill_level);
    626605            if (prob->status_)
     
    630609            break;
    631610        }
     611      } else if (ifree) {
     612        // just free
     613        int fill_level=0; // switches off substitution
     614        paction_ = implied_free_action::presolve(prob, paction_,fill_level);
     615        if (prob->status_)
     616          break;
    632617      }
    633618#if     PRESOLVE_DEBUG
     
    972957  hcol_(new int[2*nelems_in]),
    973958  integerType_(new unsigned char[ncols0_in]),
     959  tuning_(false),
     960  startTime_(0.0),
    974961  feasibilityTolerance_(0.0),
    975962  status_(-1),
     
    13331320                        presolvedModel_,
    13341321                        nrows_, nelems_,true,nonLinearValue_);
     1322    // See if we want statistics
     1323    if ((presolveActions_&0x80000000)!=0)
     1324      prob.statistics();
    13351325    // make sure row solution correct
    13361326    {
  • trunk/ClpSolve.cpp

    r460 r461  
    9292  }
    9393  ClpPresolve pinfo;
     94  int presolveOptions = options.getSpecialOption(4);
     95  if ((presolveOptions&0xffff)!=0)
     96    pinfo.setPresolveActions(presolveOptions);
     97  int printOptions = options.getSpecialOption(5);
     98  if ((printOptions&1)!=0)
     99    pinfo.statistics();
    94100  double timePresolve=0.0;
    95101  double timeIdiot=0.0;
     
    14451451  numberPasses_=5;
    14461452  int i;
    1447   for (i=0;i<4;i++)
     1453  for (i=0;i<6;i++)
    14481454    options_[i]=0;
    1449   for (i=0;i<4;i++)
     1455  for (i=0;i<6;i++)
    14501456    extraInfo_[i]=-1;
    14511457}
     
    14581464  numberPasses_=rhs.numberPasses_;
    14591465  int i;
    1460   for ( i=0;i<4;i++)
     1466  for ( i=0;i<6;i++)
    14611467    options_[i]=rhs.options_[i];
    1462   for ( i=0;i<4;i++)
     1468  for ( i=0;i<6;i++)
    14631469    extraInfo_[i]=rhs.extraInfo_[i];
    14641470}
     
    14721478    numberPasses_=rhs.numberPasses_;
    14731479    int i;
    1474     for (i=0;i<4;i++)
     1480    for (i=0;i<6;i++)
    14751481      options_[i]=rhs.options_[i];
    1476     for (i=0;i<4;i++)
     1482    for (i=0;i<6;i++)
    14771483      extraInfo_[i]=rhs.extraInfo_[i];
    14781484  }
     
    14841490{
    14851491}
    1486 /*   which translation is:
    1487      which:
    1488      0 - startup in Dual  (nothing if basis exists).:
    1489              0 - no basis, 1 crash
    1490      1 - startup in Primal (nothing if basis exists):
    1491         0 - use initiative
    1492         1 - use crash
    1493         2 - use idiot and look at further info
    1494         3 - use sprint and look at further info
    1495         4 - use all slack
    1496         5 - use initiative but no idiot
    1497         6 - use initiative but no sprint
    1498         7 - use initiative but no crash
    1499         8 - do allslack or idiot
    1500         9 - do allslack or sprint
    1501      2 - interrupt handling - 0 yes, 1 no (for threadsafe)
    1502      3 - whether to make +- 1matrix - 0 yes, 1 no
    1503 */
     1492// See header file for deatils
    15041493void
    15051494ClpSolve::setSpecialOption(int which,int value,int extraInfo)
  • trunk/include/ClpDummyMatrix.hpp

    r451 r461  
    5454  /** Returns a new matrix in reverse order without gaps */
    5555  virtual ClpMatrixBase * reverseOrderedCopy() const;
    56   /** If element NULL returns number of elements in column part of basis,
    57       If not NULL fills in as well */
    58   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     56  /// Returns number of elements in column part of basis
     57  virtual CoinBigIndex countBasis(ClpSimplex * model,
    5958                                 const int * whichColumn,
    6059                                 int numberRowBasic,
     60                                  int & numberColumnBasic);
     61  /// Fills in column part of basis
     62  virtual void fillBasis(ClpSimplex * model,
     63                                 const int * whichColumn,
    6164                                 int & numberColumnBasic,
    62                                  int * row, int * column,
    63                                  double * element)  ;
     65                                 int * row, int * start,
     66                                 int * rowCount, int * columnCount,
     67                                 double * element);
    6468  /** Unpacks a column into an CoinIndexedvector
    6569   */
  • trunk/include/ClpGubMatrix.hpp

    r452 r461  
    2424  /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */
    2525  virtual ClpMatrixBase * reverseOrderedCopy() const;
    26   /** If element NULL returns number of elements in column part of basis,
    27       If not NULL fills in as well */
    28   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     26  /// Returns number of elements in column part of basis
     27  virtual CoinBigIndex countBasis(ClpSimplex * model,
    2928                                 const int * whichColumn,
    3029                                 int numberRowBasic,
     30                                  int & numberColumnBasic);
     31  /// Fills in column part of basis
     32  virtual void fillBasis(ClpSimplex * model,
     33                                 const int * whichColumn,
    3134                                 int & numberColumnBasic,
    32                                  int * row, int * column,
    33                                  double * element)  ;
     35                                 int * row, int * start,
     36                                 int * rowCount, int * columnCount,
     37                                 double * element);
    3438  /** Unpacks a column into an CoinIndexedvector
    3539   */
  • trunk/include/ClpMatrixBase.hpp

    r451 r461  
    6868  virtual ClpMatrixBase * reverseOrderedCopy() const {return NULL;};
    6969 
    70   /** If element NULL returns number of elements in column part of basis,
    71       If not NULL fills in as well */
    72   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     70  /// Returns number of elements in column part of basis
     71  virtual CoinBigIndex countBasis(ClpSimplex * model,
    7372                                 const int * whichColumn,
    7473                                 int numberRowBasic,
     74                                  int & numberColumnBasic)=0;
     75  /// Fills in column part of basis
     76  virtual void fillBasis(ClpSimplex * model,
     77                                 const int * whichColumn,
    7578                                 int & numberColumnBasic,
    76                                  int * row, int * column,
    77                                  double * element)  = 0;
     79                                 int * row, int * start,
     80                                 int * rowCount, int * columnCount,
     81                                 double * element)=0;
    7882  /** Creates scales for column copy (rowCopy in model may be modified)
    7983      default does not allow scaling
  • trunk/include/ClpNetworkMatrix.hpp

    r451 r461  
    5454  /** Returns a new matrix in reverse order without gaps */
    5555  virtual ClpMatrixBase * reverseOrderedCopy() const;
    56   /** If element NULL returns number of elements in column part of basis,
    57       If not NULL fills in as well */
    58   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     56  /// Returns number of elements in column part of basis
     57  virtual CoinBigIndex countBasis(ClpSimplex * model,
    5958                                 const int * whichColumn,
    6059                                 int numberRowBasic,
     60                                  int & numberColumnBasic);
     61  /// Fills in column part of basis
     62  virtual void fillBasis(ClpSimplex * model,
     63                                 const int * whichColumn,
    6164                                 int & numberColumnBasic,
    62                                  int * row, int * column,
    63                                  double * element)  ;
     65                                 int * row, int * start,
     66                                 int * rowCount, int * columnCount,
     67                                 double * element);
    6468  /** Given positive integer weights for each row fills in sum of weights
    6569      for each column (and slack).
  • trunk/include/ClpNonLinearCost.hpp

    r308 r461  
    218218  /// Feasible cost
    219219  double feasibleCost_;
     220  /// Current infeasibility weight
     221  double infeasibilityWeight_;
    220222  /// Largest infeasibility
    221223  double largestInfeasibility_;
  • trunk/include/ClpPackedMatrix.hpp

    r451 r461  
    7373  /** Returns a new matrix in reverse order without gaps */
    7474  virtual ClpMatrixBase * reverseOrderedCopy() const;
    75   /** If element NULL returns number of elements in column part of basis,
    76       If not NULL fills in as well */
    77   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     75  /// Returns number of elements in column part of basis
     76  virtual CoinBigIndex countBasis(ClpSimplex * model,
    7877                                 const int * whichColumn,
    7978                                 int numberRowBasic,
     79                                  int & numberColumnBasic);
     80  /// Fills in column part of basis
     81  virtual void fillBasis(ClpSimplex * model,
     82                                 const int * whichColumn,
    8083                                 int & numberColumnBasic,
    81                                  int * row, int * column,
    82                                  double * element)  ;
     84                                 int * row, int * start,
     85                                 int * rowCount, int * columnCount,
     86                                 double * element);
    8387  /** Creates scales for column copy (rowCopy in model may be modified)
    8488      returns non-zero if no scaling done */
  • trunk/include/ClpPlusMinusOneMatrix.hpp

    r451 r461  
    5656  /** Returns a new matrix in reverse order without gaps */
    5757  virtual ClpMatrixBase * reverseOrderedCopy() const;
    58   /** If element NULL returns number of elements in column part of basis,
    59       If not NULL fills in as well */
    60   virtual CoinBigIndex fillBasis(ClpSimplex * model,
     58  /// Returns number of elements in column part of basis
     59  virtual CoinBigIndex countBasis(ClpSimplex * model,
    6160                                 const int * whichColumn,
    6261                                 int numberRowBasic,
     62                                  int & numberColumnBasic);
     63  /// Fills in column part of basis
     64  virtual void fillBasis(ClpSimplex * model,
     65                                 const int * whichColumn,
    6366                                 int & numberColumnBasic,
    64                                  int * row, int * column,
    65                                  double * element) ;
     67                                 int * row, int * start,
     68                                 int * rowCount, int * columnCount,
     69                                 double * element);
    6670  /** Given positive integer weights for each row fills in sum of weights
    6771      for each column (and slack).
  • trunk/include/ClpPresolve.hpp

    r458 r461  
    7070    { return nonLinearValue_;};
    7171  /// Whether we want to do dual part of presolve
    72   inline bool doDualPresolve() const
     72  inline bool doDual() const
    7373  { return (presolveActions_&1)==0;};
    74   inline void setDoDualPresolve(bool doDual)
     74  inline void setDoDual(bool doDual)
    7575  { if (doDual) presolveActions_  &= ~1; else presolveActions_ |= 1;};
     76  /// Whether we want to do singleton part of presolve
     77  inline bool doSingleton() const
     78  { return (presolveActions_&2)==0;};
     79  inline void setDoSingleton(bool doSingleton)
     80  { if (doSingleton) presolveActions_  &= ~2; else presolveActions_ |= 2;};
     81  /// Whether we want to do doubleton part of presolve
     82  inline bool doDoubleton() const
     83  { return (presolveActions_&4)==0;};
     84  inline void setDoDoubleton(bool doDoubleton)
     85  { if (doDoubleton) presolveActions_  &= ~4; else presolveActions_ |= 4;};
     86  /// Whether we want to do tripleton part of presolve
     87  inline bool doTripleton() const
     88  { return (presolveActions_&8)==0;};
     89  inline void setDoTripleton(bool doTripleton)
     90  { if (doTripleton) presolveActions_  &= ~8; else presolveActions_ |= 8;};
     91  /// Whether we want to do tighten part of presolve
     92  inline bool doTighten() const
     93  { return (presolveActions_&16)==0;};
     94  inline void setDoTighten(bool doTighten)
     95  { if (doTighten) presolveActions_  &= ~16; else presolveActions_ |= 16;};
     96  /// Whether we want to do forcing part of presolve
     97  inline bool doForcing() const
     98  { return (presolveActions_&32)==0;};
     99  inline void setDoForcing(bool doForcing)
     100  { if (doForcing) presolveActions_  &= ~32; else presolveActions_ |= 32;};
     101  /// Whether we want to do impliedfree part of presolve
     102  inline bool doImpliedFree() const
     103  { return (presolveActions_&64)==0;};
     104  inline void setDoImpliedFree(bool doImpliedfree)
     105  { if (doImpliedfree) presolveActions_  &= ~64; else presolveActions_ |= 64;};
     106  /// Whether we want to do dupcol part of presolve
     107  inline bool doDupcol() const
     108  { return (presolveActions_&128)==0;};
     109  inline void setDoDupcol(bool doDupcol)
     110  { if (doDupcol) presolveActions_  &= ~128; else presolveActions_ |= 128;};
     111  /// Whether we want to do duprow part of presolve
     112  inline bool doDuprow() const
     113  { return (presolveActions_&256)==0;};
     114  inline void setDoDuprow(bool doDuprow)
     115  { if (doDuprow) presolveActions_  &= ~256; else presolveActions_ |= 256;};
     116  /// Set whole group
     117  inline bool presolveActions() const
     118  { return presolveActions_&0xffff;};
     119  inline void setPresolveActions(int action)
     120  { presolveActions_  = (presolveActions_&0xffff0000)|(action&0xffff);};
     121  /// Asks for statistics
     122  inline void statistics()
     123  { presolveActions_ |= 0x80000000;};
    76124
    77125  /**@name postsolve - postsolve the problem.  If the problem
  • trunk/include/ClpSolve.hpp

    r414 r461  
    8585                   4 - bit set to do scaling
    8686                   8 - set to be aggressive with gamma/delta?
     87      5 - for presolve
     88                   1 - switch off dual stuff
     89      6 - for detailed printout (initially just presolve)
     90                   1 - presolve statistics
    8791  */
    8892  void setSpecialOption(int which,int value,int extraInfo=-1);
     
    114118  int numberPasses_;
    115119  /// Options
    116   int options_[4];
     120  int options_[6];
    117121  /// Extra information
    118   int extraInfo_[4];
     122  int extraInfo_[6];
    119123  //@}
    120124};
Note: See TracChangeset for help on using the changeset viewer.