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/MyMessageHandler.cpp

    r1726 r2385  
    66#if defined(_MSC_VER)
    77// move into CoinPragma.hpp ?
    8 #pragma warning(disable:4503)
     8#pragma warning(disable : 4503)
    99#endif
    1010
     
    1717#include "ClpMessage.hpp"
    1818
    19 
    2019//#############################################################################
    2120// Constructors / Destructor / Assignment
     
    2524// Default Constructor
    2625//-------------------------------------------------------------------
    27 MyMessageHandler::MyMessageHandler ()
    28      : CoinMessageHandler(),
    29        model_(NULL),
    30        feasibleExtremePoints_(),
    31       iterationNumber_(-1)
     26MyMessageHandler::MyMessageHandler()
     27  : CoinMessageHandler()
     28  , model_(NULL)
     29  , feasibleExtremePoints_()
     30  , iterationNumber_(-1)
    3231{
    3332}
     
    3635// Copy constructor
    3736//-------------------------------------------------------------------
    38 MyMessageHandler::MyMessageHandler (const MyMessageHandler & rhs)
    39      : CoinMessageHandler(rhs),
    40        model_(rhs.model_),
    41        feasibleExtremePoints_(rhs.feasibleExtremePoints_),
    42       iterationNumber_(rhs.iterationNumber_)
     37MyMessageHandler::MyMessageHandler(const MyMessageHandler &rhs)
     38  : CoinMessageHandler(rhs)
     39  , model_(rhs.model_)
     40  , feasibleExtremePoints_(rhs.feasibleExtremePoints_)
     41  , iterationNumber_(rhs.iterationNumber_)
    4342{
    4443}
    4544
    46 MyMessageHandler::MyMessageHandler (const CoinMessageHandler & rhs)
    47      : CoinMessageHandler(rhs),
    48        model_(NULL),
    49        feasibleExtremePoints_(),
    50       iterationNumber_(-1)
     45MyMessageHandler::MyMessageHandler(const CoinMessageHandler &rhs)
     46  : CoinMessageHandler(rhs)
     47  , model_(NULL)
     48  , feasibleExtremePoints_()
     49  , iterationNumber_(-1)
    5150{
    5251}
    5352
    5453// Constructor with pointer to model
    55 MyMessageHandler::MyMessageHandler(ClpSimplex * model,
    56                                    FILE * /*userPointer*/)
    57      : CoinMessageHandler(),
    58        model_(model),
    59        feasibleExtremePoints_(),
    60       iterationNumber_(-1)
     54MyMessageHandler::MyMessageHandler(ClpSimplex *model,
     55  FILE * /*userPointer*/)
     56  : CoinMessageHandler()
     57  , model_(model)
     58  , feasibleExtremePoints_()
     59  , iterationNumber_(-1)
    6160{
    6261}
     
    6564// Destructor
    6665//-------------------------------------------------------------------
    67 MyMessageHandler::~MyMessageHandler ()
     66MyMessageHandler::~MyMessageHandler()
    6867{
    6968}
     
    7372//-------------------------------------------------------------------
    7473MyMessageHandler &
    75 MyMessageHandler::operator=(const MyMessageHandler& rhs)
     74MyMessageHandler::operator=(const MyMessageHandler &rhs)
    7675{
    77      if (this != &rhs) {
    78           CoinMessageHandler::operator=(rhs);
    79           model_ = rhs.model_;
    80           feasibleExtremePoints_ = rhs.feasibleExtremePoints_;
    81           iterationNumber_ = rhs.iterationNumber_;
    82      }
    83      return *this;
     76  if (this != &rhs) {
     77    CoinMessageHandler::operator=(rhs);
     78    model_ = rhs.model_;
     79    feasibleExtremePoints_ = rhs.feasibleExtremePoints_;
     80    iterationNumber_ = rhs.iterationNumber_;
     81  }
     82  return *this;
    8483}
    8584//-------------------------------------------------------------------
    8685// Clone
    8786//-------------------------------------------------------------------
    88 CoinMessageHandler * MyMessageHandler::clone() const
     87CoinMessageHandler *MyMessageHandler::clone() const
    8988{
    90      return new MyMessageHandler(*this);
     89  return new MyMessageHandler(*this);
    9190}
    9291
    93 int
    94 MyMessageHandler::print()
     92int MyMessageHandler::print()
    9593{
    96      if (currentSource() == "Clp") {
    97           if (currentMessage().externalNumber() == 102) {
    98                printf("There are %d primal infeasibilities\n",
    99                       model_->nonLinearCost()->numberInfeasibilities());
    100                // Feasibility
    101                if (!model_->nonLinearCost()->numberInfeasibilities()) {
    102                     // Column solution
    103                     int numberColumns = model_->numberColumns();
    104                     const double * solution = model_->solutionRegion(1);
     94  if (currentSource() == "Clp") {
     95    if (currentMessage().externalNumber() == 102) {
     96      printf("There are %d primal infeasibilities\n",
     97        model_->nonLinearCost()->numberInfeasibilities());
     98      // Feasibility
     99      if (!model_->nonLinearCost()->numberInfeasibilities()) {
     100        // Column solution
     101        int numberColumns = model_->numberColumns();
     102        const double *solution = model_->solutionRegion(1);
    105103
    106                     // Create vector to contain solution
    107                     StdVectorDouble feasibleExtremePoint;
     104        // Create vector to contain solution
     105        StdVectorDouble feasibleExtremePoint;
    108106
    109                     const double *objective = model_->objective();
    110                     double objectiveValue = 0;
     107        const double *objective = model_->objective();
     108        double objectiveValue = 0;
    111109
    112                     if (!model_->columnScale()) {
    113                          // No scaling
    114                          for (int i = 0; i < numberColumns; i++) {
    115                               feasibleExtremePoint.push_back(solution[i]);
    116                               objectiveValue += solution[i] * objective[i];
    117                          }
    118                     } else {
    119                          // scaled
    120                          const double * columnScale = model_->columnScale();
    121                          for (int i = 0; i < numberColumns; i++) {
    122                               feasibleExtremePoint.push_back(solution[i]*columnScale[i]);
    123                               objectiveValue += solution[i] * objective[i] * columnScale[i];
    124                          }
    125                     }
    126                     std::cout << "Objective " << objectiveValue << std::endl;
    127                     // Save solution
    128                     feasibleExtremePoints_.push_front(feasibleExtremePoint);
     110        if (!model_->columnScale()) {
     111          // No scaling
     112          for (int i = 0; i < numberColumns; i++) {
     113            feasibleExtremePoint.push_back(solution[i]);
     114            objectiveValue += solution[i] * objective[i];
     115          }
     116        } else {
     117          // scaled
     118          const double *columnScale = model_->columnScale();
     119          for (int i = 0; i < numberColumns; i++) {
     120            feasibleExtremePoint.push_back(solution[i] * columnScale[i]);
     121            objectiveValue += solution[i] * objective[i] * columnScale[i];
     122          }
     123        }
     124        std::cout << "Objective " << objectiveValue << std::endl;
     125        // Save solution
     126        feasibleExtremePoints_.push_front(feasibleExtremePoint);
    129127
    130                     // Want maximum of 10 solutions, so if more then 10 get rid of oldest
    131                     size_t numExtremePointsSaved = feasibleExtremePoints_.size();
    132                     if ( numExtremePointsSaved >= 10 ) {
    133                          feasibleExtremePoints_.pop_back();
    134                          assert( feasibleExtremePoints_.size() == numExtremePointsSaved - 1 );
    135                     };
     128        // Want maximum of 10 solutions, so if more then 10 get rid of oldest
     129        size_t numExtremePointsSaved = feasibleExtremePoints_.size();
     130        if (numExtremePointsSaved >= 10) {
     131          feasibleExtremePoints_.pop_back();
     132          assert(feasibleExtremePoints_.size() == numExtremePointsSaved - 1);
     133        };
     134      }
     135      return 0; // skip printing
     136    }
     137  }
    136138
    137                }
    138                return 0; // skip printing
    139           }
    140      }
     139  // If one wants access to the message text,
     140  // it is available using method messageBuffer().
     141  // For example, one could code:
     142  // std::cout <<messageBuffer() <<std::endl;
    141143
    142      // If one wants access to the message text,
    143      // it is available using method messageBuffer().
    144      // For example, one could code:
    145      // std::cout <<messageBuffer() <<std::endl;
    146 
    147      return CoinMessageHandler::print();
     144  return CoinMessageHandler::print();
    148145}
    149146const ClpSimplex *
    150147MyMessageHandler::model() const
    151148{
    152      return model_;
     149  return model_;
    153150}
    154 void
    155 MyMessageHandler::setModel(ClpSimplex * model)
     151void MyMessageHandler::setModel(ClpSimplex *model)
    156152{
    157      model_ = model;
     153  model_ = model;
    158154}
    159155
    160 const std::deque<StdVectorDouble> & MyMessageHandler::getFeasibleExtremePoints() const
     156const std::deque< StdVectorDouble > &MyMessageHandler::getFeasibleExtremePoints() const
    161157{
    162      return feasibleExtremePoints_;
     158  return feasibleExtremePoints_;
    163159}
    164160void MyMessageHandler::clearFeasibleExtremePoints()
    165161{
    166      feasibleExtremePoints_.clear();
     162  feasibleExtremePoints_.clear();
    167163}
     164
     165/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     166*/
Note: See TracChangeset for help on using the changeset viewer.