Changeset 1103


Ignore:
Timestamp:
Sep 7, 2007 10:16:08 AM (12 years ago)
Author:
forrest
Message:

scale binvrow

Location:
trunk/Clp/src
Files:
3 edited

Legend:

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

    r1093 r1103  
    83988398  // But swap if pivot variable was slack as clp stores slack as -1.0
    83998399  double value = (pivotVariable_[row]<numberColumns_) ? 1.0 : -1.0;
    8400   // What about scaling ?
     8400  // but scale
     8401  if (rowScale_) {
     8402    int pivot = pivotVariable_[row];
     8403    if (pivot<numberColumns_)
     8404      value *= columnScale_[pivot];
     8405    else
     8406      value /= rowScale_[pivot-numberColumns_];
     8407  }
    84018408  rowArray1->insert(row,value);
    84028409  factorization->updateColumnTranspose(rowArray0,rowArray1);
    8403   memcpy(z,rowArray1->denseVector(),numberRows()*sizeof(double));
     8410  if (!rowScale_) {
     8411    memcpy(z,rowArray1->denseVector(),numberRows_*sizeof(double));
     8412  } else {
     8413    double * array = rowArray1->denseVector();
     8414    for (int i=0;i<numberRows_;i++) {
     8415      z[i] = array[i] * rowScale_[i];
     8416    }
     8417  }
    84048418  rowArray1->clear();
    84058419}
     
    84758489    abort();
    84768490  }
    8477   ClpFactorization * factorization = factorization_;
    84788491  CoinIndexedVector * rowArray0 = rowArray(0);
    84798492  CoinIndexedVector * rowArray1 = rowArray(1);
     
    84878500#endif
    84888501  // put +1 in row
     8502  // but scale
     8503  double value;
     8504  if (!rowScale_) {
     8505    value=1.0;
     8506  } else {
     8507    value = rowScale_[col];
     8508  }
     8509  rowArray1->insert(col,value);
     8510  factorization_->updateColumn(rowArray0,rowArray1,false);
    84898511  // But swap if pivot variable was slack as clp stores slack as -1.0
    8490   double value = (pivotVariable_[col]<numberColumns_) ? 1.0 : -1.0;
    8491   // What about scaling ?
    8492   rowArray1->insert(col,value);
    8493   factorization->updateColumn(rowArray0,rowArray1,false);
    8494   memcpy(vec,rowArray1->denseVector(),numberRows()*sizeof(double));
     8512  double * array = rowArray1->denseVector();
     8513  if (!rowScale_) {
     8514    for (int i=0;i<numberRows_;i++) {
     8515      double multiplier = (pivotVariable_[i]<numberColumns_) ? 1.0 : -1.0;
     8516      vec[i] = multiplier * array[i];
     8517    }
     8518  } else {
     8519    for (int i=0;i<numberRows_;i++) {
     8520      int pivot = pivotVariable_[i];
     8521      double value = array[i];
     8522      if (pivot<numberColumns_)
     8523        vec[i] = value * columnScale_[pivot];
     8524      else
     8525        vec[i] = - value / rowScale_[pivot-numberColumns_];
     8526    }
     8527  }
    84958528  rowArray1->clear();
    84968529}
     
    92859318    factorization_->setPersistenceFlag(value);
    92869319}
     9320// Move status and solution across
     9321void
     9322ClpSimplex::moveInfo(const ClpSimplex & rhs, bool justStatus)
     9323{
     9324  objectiveValue_ = rhs.objectiveValue_;
     9325  numberIterations_ = rhs. numberIterations_;
     9326  problemStatus_ = rhs. problemStatus_;
     9327  secondaryStatus_ = rhs. secondaryStatus_;
     9328  assert (numberRows_ == rhs.numberRows_);
     9329  assert (numberColumns_ == rhs.numberColumns_);
     9330  if (!justStatus) {
     9331    delete [] status_;
     9332    if (rhs.status_) {
     9333      status_ = CoinCopyOfArray(rhs.status_,numberRows_+numberColumns_);
     9334    } else {
     9335      status_ = NULL;
     9336    }
     9337    memcpy(columnActivity_,rhs.columnActivity_,numberColumns_*sizeof(double));
     9338    memcpy(reducedCost_,rhs.reducedCost_,numberColumns_*sizeof(double));
     9339    memcpy(rowActivity_,rhs.rowActivity_,numberRows_*sizeof(double));
     9340    memcpy(dual_,rhs.dual_,numberRows_*sizeof(double));
     9341  }
     9342}
    92879343// Create C++ lines to get to current state
    92889344void
  • trunk/Clp/src/ClpSimplex.hpp

    r1090 r1103  
    964964  /// May delete or may make clean and emptyish factorization
    965965  void setEmptyFactorization();
     966  /// Move status and solution across
     967  void moveInfo(const ClpSimplex & rhs, bool justStatus=false);
    966968  //@}
    967969
  • trunk/Clp/src/unitTest.cpp

    r1090 r1103  
    984984      printf("\n");
    985985    }
     986    /* Do twice -
     987       without and with scaling
     988    */
     989    // set scaling off
     990    model.scaling(0);
     991    for (int iPass=0;iPass<2;iPass++) {
     992      model.primal(0,3+4); // keep factorization
     993      const double * rowScale = model.rowScale();
     994      const double * columnScale = model.columnScale();
     995      if (!iPass)
     996        assert (!rowScale);
     997      else
     998        assert (rowScale); // only true for this example
     999      /* has to be exactly correct as in OsiClpsolverInterface.cpp
     1000         (also redo each pass as may change
     1001      */
     1002      printf("B-1 A");
     1003      for( i = 0; i < n_rows; i++){
     1004        model.getBInvARow(i, binvA,binvA+n_cols);
     1005        printf("\nrow: %d -> ",i);
     1006        int j;
     1007        // First columns
     1008        for(j=0; j < n_cols; j++){
     1009          if (binvA[j]) {
     1010            printf("(%d %g), ", j, binvA[j]);
     1011          }
     1012        }
     1013        // now rows
     1014        for(j=0; j < n_rows; j++){
     1015          if (binvA[j+n_cols]) {
     1016            printf("(%d %g), ", j+n_cols, binvA[j+n_cols]);
     1017          }
     1018        }
     1019      }
     1020      printf("\n");
     1021      printf("And by column (trickier)");
     1022      const int * pivotVariable = model.pivotVariable();
     1023      for( i = 0; i < n_cols+n_rows; i++){
     1024        model.getBInvACol(i, binvA);
     1025        printf("\ncolumn: %d -> ",i);
     1026        for(int j=0; j < n_rows; j++){
     1027          if (binvA[j]) {
     1028            // need to know pivot variable for +1/-1 (slack) and row/column scaling
     1029            int pivot = pivotVariable[j];
     1030            if (pivot<n_cols) {
     1031              // scaled coding is in just in case
     1032              if (!columnScale) {
     1033                printf("(%d %g), ", j, binvA[j]);
     1034              } else {
     1035                printf("(%d %g), ", j, binvA[j]*columnScale[pivot]);
     1036              }
     1037            } else {
     1038              if (!rowScale) {
     1039                printf("(%d %g), ", j, binvA[j]);
     1040              } else {
     1041                printf("(%d %g), ", j, binvA[j]/rowScale[pivot-n_cols]);
     1042              }
     1043            }
     1044          }
     1045        }
     1046      }
     1047      printf("\n");
     1048      printf("binvrow");
     1049      for( i = 0; i < n_rows; i++){
     1050        model.getBInvRow(i, binvA);
     1051        printf("\nrow: %d -> ",i);
     1052        int j;
     1053        for (j=0;j<n_rows;j++) {
     1054          if (binvA[j])
     1055            printf("(%d %g), ", j, binvA[j]);
     1056        }
     1057      }
     1058      printf("\n");
     1059      printf("And by column ");
     1060      for( i = 0; i < n_rows; i++){
     1061        model.getBInvCol(i, binvA);
     1062        printf("\ncol: %d -> ",i);
     1063        int j;
     1064        for (j=0;j<n_rows;j++) {
     1065          if (binvA[j])
     1066            printf("(%d %g), ", j, binvA[j]);
     1067        }
     1068      }
     1069      printf("\n");
     1070      // now deal with next pass
     1071      if (!iPass) {
     1072        // get scaling for testing
     1073        model.scaling(1);
     1074      }
     1075    }
    9861076    free(binvA);
    9871077    model.setColUpper(1,2.0);
Note: See TracChangeset for help on using the changeset viewer.