Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (4 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

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

    r1732 r2385  
    2121// Default Constructor
    2222//-------------------------------------------------------------------
    23 ClpDualRowDantzig::ClpDualRowDantzig ()
    24      : ClpDualRowPivot()
     23ClpDualRowDantzig::ClpDualRowDantzig()
     24  : ClpDualRowPivot()
    2525{
    26      type_ = 1;
     26  type_ = 1;
    2727}
    2828
     
    3030// Copy constructor
    3131//-------------------------------------------------------------------
    32 ClpDualRowDantzig::ClpDualRowDantzig (const ClpDualRowDantzig & source)
    33      : ClpDualRowPivot(source)
     32ClpDualRowDantzig::ClpDualRowDantzig(const ClpDualRowDantzig &source)
     33  : ClpDualRowPivot(source)
    3434{
    35 
    3635}
    3736
     
    3938// Destructor
    4039//-------------------------------------------------------------------
    41 ClpDualRowDantzig::~ClpDualRowDantzig ()
     40ClpDualRowDantzig::~ClpDualRowDantzig()
    4241{
    43 
    4442}
    4543
     
    4846//-------------------------------------------------------------------
    4947ClpDualRowDantzig &
    50 ClpDualRowDantzig::operator=(const ClpDualRowDantzig& rhs)
     48ClpDualRowDantzig::operator=(const ClpDualRowDantzig &rhs)
    5149{
    52      if (this != &rhs) {
    53           ClpDualRowPivot::operator=(rhs);
    54      }
    55      return *this;
     50  if (this != &rhs) {
     51    ClpDualRowPivot::operator=(rhs);
     52  }
     53  return *this;
    5654}
    5755
    5856// Returns pivot row, -1 if none
    59 int
    60 ClpDualRowDantzig::pivotRow()
     57int ClpDualRowDantzig::pivotRow()
    6158{
    62      assert(model_);
    63      int iRow;
    64      const int * pivotVariable = model_->pivotVariable();
    65      double tolerance = model_->currentPrimalTolerance();
    66      // we can't really trust infeasibilities if there is primal error
    67      if (model_->largestPrimalError() > 1.0e-8)
    68           tolerance *= model_->largestPrimalError() / 1.0e-8;
    69      double largest = 0.0;
    70      int chosenRow = -1;
    71      int numberRows = model_->numberRows();
     59  assert(model_);
     60  int iRow;
     61  const int *pivotVariable = model_->pivotVariable();
     62  double tolerance = model_->currentPrimalTolerance();
     63  // we can't really trust infeasibilities if there is primal error
     64  if (model_->largestPrimalError() > 1.0e-8)
     65    tolerance *= model_->largestPrimalError() / 1.0e-8;
     66  double largest = 0.0;
     67  int chosenRow = -1;
     68  int numberRows = model_->numberRows();
    7269#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    73      int numberColumns = model_->numberColumns();
     70  int numberColumns = model_->numberColumns();
    7471#endif
    75      for (iRow = 0; iRow < numberRows; iRow++) {
    76           int iSequence = pivotVariable[iRow];
    77           double value = model_->solution(iSequence);
    78           double lower = model_->lower(iSequence);
    79           double upper = model_->upper(iSequence);
    80           double infeas = CoinMax(value - upper , lower - value);
    81           if (infeas > tolerance) {
     72  for (iRow = 0; iRow < numberRows; iRow++) {
     73    int iSequence = pivotVariable[iRow];
     74    double value = model_->solution(iSequence);
     75    double lower = model_->lower(iSequence);
     76    double upper = model_->upper(iSequence);
     77    double infeas = CoinMax(value - upper, lower - value);
     78    if (infeas > tolerance) {
    8279#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    83               if (iSequence < numberColumns)
    84                 infeas *= CLP_DUAL_COLUMN_MULTIPLIER;
     80      if (iSequence < numberColumns)
     81        infeas *= CLP_DUAL_COLUMN_MULTIPLIER;
    8582#endif
    86               if (infeas > largest) {
    87                 if (!model_->flagged(iSequence)) {
    88                   chosenRow = iRow;
    89                   largest = infeas;
    90                 }
    91               }
    92           }
    93      }
    94      return chosenRow;
     83      if (infeas > largest) {
     84        if (!model_->flagged(iSequence)) {
     85          chosenRow = iRow;
     86          largest = infeas;
     87        }
     88      }
     89    }
     90  }
     91  return chosenRow;
    9592}
    9693// FT update and returns pivot alpha
    9794double
    9895ClpDualRowDantzig::updateWeights(CoinIndexedVector * /*input*/,
    99                                  CoinIndexedVector * spare,
    100                                  CoinIndexedVector * /*spare2*/,
    101                                  CoinIndexedVector * updatedColumn)
     96  CoinIndexedVector *spare,
     97  CoinIndexedVector * /*spare2*/,
     98  CoinIndexedVector *updatedColumn)
    10299{
    103      // Do FT update
    104      model_->factorization()->updateColumnFT(spare, updatedColumn);
    105      // pivot element
    106      double alpha = 0.0;
    107      // look at updated column
    108      double * work = updatedColumn->denseVector();
    109      int number = updatedColumn->getNumElements();
    110      int * which = updatedColumn->getIndices();
    111      int i;
    112      int pivotRow = model_->pivotRow();
     100  // Do FT update
     101  model_->factorization()->updateColumnFT(spare, updatedColumn);
     102  // pivot element
     103  double alpha = 0.0;
     104  // look at updated column
     105  double *work = updatedColumn->denseVector();
     106  int number = updatedColumn->getNumElements();
     107  int *which = updatedColumn->getIndices();
     108  int i;
     109  int pivotRow = model_->pivotRow();
    113110
    114      if (updatedColumn->packedMode()) {
    115           for (i = 0; i < number; i++) {
    116                int iRow = which[i];
    117                if (iRow == pivotRow) {
    118                     alpha = work[i];
    119                     break;
    120                }
    121           }
    122      } else {
    123           alpha = work[pivotRow];
    124      }
    125      return alpha;
     111  if (updatedColumn->packedMode()) {
     112    for (i = 0; i < number; i++) {
     113      int iRow = which[i];
     114      if (iRow == pivotRow) {
     115        alpha = work[i];
     116        break;
     117      }
     118    }
     119  } else {
     120    alpha = work[pivotRow];
     121  }
     122  return alpha;
    126123}
    127124
     
    130127   Computes change in objective function
    131128*/
    132 void
    133 ClpDualRowDantzig::updatePrimalSolution(CoinIndexedVector * primalUpdate,
    134                                         double primalRatio,
    135                                         double & objectiveChange)
     129void ClpDualRowDantzig::updatePrimalSolution(CoinIndexedVector *primalUpdate,
     130  double primalRatio,
     131  double &objectiveChange)
    136132{
    137      double * work = primalUpdate->denseVector();
    138      int number = primalUpdate->getNumElements();
    139      int * which = primalUpdate->getIndices();
    140      int i;
    141      double changeObj = 0.0;
    142      const int * pivotVariable = model_->pivotVariable();
    143      if (primalUpdate->packedMode()) {
    144           for (i = 0; i < number; i++) {
    145                int iRow = which[i];
    146                int iPivot = pivotVariable[iRow];
    147                double & value = model_->solutionAddress(iPivot);
    148                double cost = model_->cost(iPivot);
    149                double change = primalRatio * work[i];
    150                value -= change;
    151                changeObj -= change * cost;
    152                work[i] = 0.0;
    153           }
    154      } else {
    155           for (i = 0; i < number; i++) {
    156                int iRow = which[i];
    157                int iPivot = pivotVariable[iRow];
    158                double & value = model_->solutionAddress(iPivot);
    159                double cost = model_->cost(iPivot);
    160                double change = primalRatio * work[iRow];
    161                value -= change;
    162                changeObj -= change * cost;
    163                work[iRow] = 0.0;
    164           }
    165      }
    166      primalUpdate->setNumElements(0);
    167      objectiveChange += changeObj;
     133  double *work = primalUpdate->denseVector();
     134  int number = primalUpdate->getNumElements();
     135  int *which = primalUpdate->getIndices();
     136  int i;
     137  double changeObj = 0.0;
     138  const int *pivotVariable = model_->pivotVariable();
     139  if (primalUpdate->packedMode()) {
     140    for (i = 0; i < number; i++) {
     141      int iRow = which[i];
     142      int iPivot = pivotVariable[iRow];
     143      double &value = model_->solutionAddress(iPivot);
     144      double cost = model_->cost(iPivot);
     145      double change = primalRatio * work[i];
     146      value -= change;
     147      changeObj -= change * cost;
     148      work[i] = 0.0;
     149    }
     150  } else {
     151    for (i = 0; i < number; i++) {
     152      int iRow = which[i];
     153      int iPivot = pivotVariable[iRow];
     154      double &value = model_->solutionAddress(iPivot);
     155      double cost = model_->cost(iPivot);
     156      double change = primalRatio * work[iRow];
     157      value -= change;
     158      changeObj -= change * cost;
     159      work[iRow] = 0.0;
     160    }
     161  }
     162  primalUpdate->setNumElements(0);
     163  objectiveChange += changeObj;
    168164}
    169165//-------------------------------------------------------------------
    170166// Clone
    171167//-------------------------------------------------------------------
    172 ClpDualRowPivot * ClpDualRowDantzig::clone(bool CopyData) const
     168ClpDualRowPivot *ClpDualRowDantzig::clone(bool CopyData) const
    173169{
    174      if (CopyData) {
    175           return new ClpDualRowDantzig(*this);
    176      } else {
    177           return new ClpDualRowDantzig();
    178      }
     170  if (CopyData) {
     171    return new ClpDualRowDantzig(*this);
     172  } else {
     173    return new ClpDualRowDantzig();
     174  }
    179175}
    180176
     177/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     178*/
Note: See TracChangeset for help on using the changeset viewer.