# ClpNonLinearCost.hpp

Go to the documentation of this file.

    00001 /* $Id: ClpNonLinearCost.hpp 1769 2011-07-26 09:31:51Z forrest $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef ClpNonLinearCost_H
    00007 #define ClpNonLinearCost_H
    00008
    00009
    00010 #include "CoinPragma.hpp"
    00011
    00012 class ClpSimplex;
    00013 class CoinIndexedVector;
    00014
    00032 /* status has original status and current status
    00033    0 - below lower so stored is upper
    00034    1 - in range
    00035    2 - above upper so stored is lower
    00036    4 - (for current) - same as original
    00037 */
    00038 #define CLP_BELOW_LOWER 0
    00039 #define CLP_FEASIBLE 1
    00040 #define CLP_ABOVE_UPPER 2
    00041 #define CLP_SAME 4
    00042 inline int originalStatus(unsigned char status)
    00043 {
    00044      return (status & 15);
    00045 }
    00046 inline int currentStatus(unsigned char status)
    00047 {
    00048      return (status >> 4);
    00049 }
    00050 inline void setOriginalStatus(unsigned char & status, int value)
    00051 {
    00052      status = static_cast<unsigned char>(status & ~15);
    00053      status = static_cast<unsigned char>(status | value);
    00054 }
    00055 inline void setCurrentStatus(unsigned char &status, int value)
    00056 {
    00057      status = static_cast<unsigned char>(status & ~(15 << 4));
    00058      status = static_cast<unsigned char>(status | (value << 4));
    00059 }
    00060 inline void setInitialStatus(unsigned char &status)
    00061 {
    00062      status = static_cast<unsigned char>(CLP_FEASIBLE | (CLP_SAME << 4));
    00063 }
    00064 inline void setSameStatus(unsigned char &status)
    00065 {
    00066      status = static_cast<unsigned char>(status & ~(15 << 4));
    00067      status = static_cast<unsigned char>(status | (CLP_SAME << 4));
    00068 }
    00069 // Use second version to get more speed
    00070 //#define FAST_CLPNON
    00071 #ifndef FAST_CLPNON
    00072 #define CLP_METHOD1 ((method_&1)!=0)
    00073 #define CLP_METHOD2 ((method_&2)!=0)
    00074 #else
    00075 #define CLP_METHOD1 (false)
    00076 #define CLP_METHOD2 (true)
    00077 #endif
    00078 class ClpNonLinearCost  {
    00079
    00080 public:
    00081
    00082 public:
    00083
    00086
    00087      ClpNonLinearCost();
    00092      ClpNonLinearCost(ClpSimplex * model, int method = 1);
    00098      ClpNonLinearCost(ClpSimplex * model, const int * starts,
    00099                       const double * lower, const double * cost);
    00101      ~ClpNonLinearCost();
    00102      // Copy
    00103      ClpNonLinearCost(const ClpNonLinearCost&);
    00104      // Assignment
    00105      ClpNonLinearCost& operator=(const ClpNonLinearCost&);
    00107
    00108
    00115      void checkInfeasibilities(double oldTolerance = 0.0);
    00119      void checkInfeasibilities(int numberInArray, const int * index);
    00126      void checkChanged(int numberInArray, CoinIndexedVector * update);
    00133      void goThru(int numberInArray, double multiplier,
    00134                  const int * index, const double * work,
    00135                  double * rhs);
    00138      void goBack(int numberInArray, const int * index,
    00139                  double * rhs);
    00145      void goBackAll(const CoinIndexedVector * update);
    00147      void zapCosts();
    00149      void refreshCosts(const double * columnCosts);
    00151      void feasibleBounds();
    00153      void refresh();
    00157      double setOne(int sequence, double solutionValue);
    00160      void setOne(int sequence, double solutionValue, double lowerValue, double upperValue,
    00161                  double costValue = 0.0);
    00165      int setOneOutgoing(int sequence, double &solutionValue);
    00167      double nearest(int sequence, double solutionValue);
    00171      inline double changeInCost(int sequence, double alpha) const {
    00172           double returnValue = 0.0;
    00173           if (CLP_METHOD1) {
    00174                int iRange = whichRange_[sequence] + offset_[sequence];
    00175                if (alpha > 0.0)
    00176                     returnValue = cost_[iRange] - cost_[iRange-1];
    00177                else
    00178                     returnValue = cost_[iRange] - cost_[iRange+1];
    00179           }
    00180           if (CLP_METHOD2) {
    00181                returnValue = (alpha > 0.0) ? infeasibilityWeight_ : -infeasibilityWeight_;
    00182           }
    00183           return returnValue;
    00184      }
    00185      inline double changeUpInCost(int sequence) const {
    00186           double returnValue = 0.0;
    00187           if (CLP_METHOD1) {
    00188                int iRange = whichRange_[sequence] + offset_[sequence];
    00189                if (iRange + 1 != start_[sequence+1] && !infeasible(iRange + 1))
    00190                     returnValue = cost_[iRange] - cost_[iRange+1];
    00191                else
    00192                     returnValue = -1.0e100;
    00193           }
    00194           if (CLP_METHOD2) {
    00195                returnValue = -infeasibilityWeight_;
    00196           }
    00197           return returnValue;
    00198      }
    00199      inline double changeDownInCost(int sequence) const {
    00200           double returnValue = 0.0;
    00201           if (CLP_METHOD1) {
    00202                int iRange = whichRange_[sequence] + offset_[sequence];
    00203                if (iRange != start_[sequence] && !infeasible(iRange - 1))
    00204                     returnValue = cost_[iRange] - cost_[iRange-1];
    00205                else
    00206                     returnValue = 1.0e100;
    00207           }
    00208           if (CLP_METHOD2) {
    00209                returnValue = infeasibilityWeight_;
    00210           }
    00211           return returnValue;
    00212      }
    00214      inline double changeInCost(int sequence, double alpha, double &rhs) {
    00215           double returnValue = 0.0;
    00216 #ifdef NONLIN_DEBUG
    00217           double saveRhs = rhs;
    00218 #endif
    00219           if (CLP_METHOD1) {
    00220                int iRange = whichRange_[sequence] + offset_[sequence];
    00221                if (alpha > 0.0) {
    00222                     assert(iRange - 1 >= start_[sequence]);
    00223                     offset_[sequence]--;
    00224                     rhs += lower_[iRange] - lower_[iRange-1];
    00225                     returnValue = alpha * (cost_[iRange] - cost_[iRange-1]);
    00226                } else {
    00227                     assert(iRange + 1 < start_[sequence+1] - 1);
    00228                     offset_[sequence]++;
    00229                     rhs += lower_[iRange+2] - lower_[iRange+1];
    00230                     returnValue = alpha * (cost_[iRange] - cost_[iRange+1]);
    00231                }
    00232           }
    00233           if (CLP_METHOD2) {
    00234 #ifdef NONLIN_DEBUG
    00235                double saveRhs1 = rhs;
    00236                rhs = saveRhs;
    00237 #endif
    00238                unsigned char iStatus = status_[sequence];
    00239                int iWhere = currentStatus(iStatus);
    00240                if (iWhere == CLP_SAME)
    00241                     iWhere = originalStatus(iStatus);
    00242                // rhs always increases
    00243                if (iWhere == CLP_FEASIBLE) {
    00244                     if (alpha > 0.0) {
    00245                          // going below
    00246                          iWhere = CLP_BELOW_LOWER;
    00247                          rhs = COIN_DBL_MAX;
    00248                     } else {
    00249                          // going above
    00250                          iWhere = CLP_ABOVE_UPPER;
    00251                          rhs = COIN_DBL_MAX;
    00252                     }
    00253                } else if (iWhere == CLP_BELOW_LOWER) {
    00254                     assert (alpha < 0);
    00255                     // going feasible
    00256                     iWhere = CLP_FEASIBLE;
    00257                     rhs += bound_[sequence] - model_->upperRegion()[sequence];
    00258                } else {
    00259                     assert (iWhere == CLP_ABOVE_UPPER);
    00260                     // going feasible
    00261                     iWhere = CLP_FEASIBLE;
    00262                     rhs += model_->lowerRegion()[sequence] - bound_[sequence];
    00263                }
    00264                setCurrentStatus(status_[sequence], iWhere);
    00265 #ifdef NONLIN_DEBUG
    00266                assert(saveRhs1 == rhs);
    00267 #endif
    00268                returnValue = fabs(alpha) * infeasibilityWeight_;
    00269           }
    00270           return returnValue;
    00271      }
    00273      inline double lower(int sequence) const {
    00274           return lower_[whichRange_[sequence] + offset_[sequence]];
    00275      }
    00277      inline double upper(int sequence) const {
    00278           return lower_[whichRange_[sequence] + offset_[sequence] + 1];
    00279      }
    00281      inline double cost(int sequence) const {
    00282           return cost_[whichRange_[sequence] + offset_[sequence]];
    00283      }
    00285
    00286
    00289
    00290      inline int numberInfeasibilities() const {
    00291           return numberInfeasibilities_;
    00292      }
    00294      inline double changeInCost() const {
    00295           return changeCost_;
    00296      }
    00298      inline double feasibleCost() const {
    00299           return feasibleCost_;
    00300      }
    00302      double feasibleReportCost() const;
    00304      inline double sumInfeasibilities() const {
    00305           return sumInfeasibilities_;
    00306      }
    00308      inline double largestInfeasibility() const {
    00309           return largestInfeasibility_;
    00310      }
    00312      inline double averageTheta() const {
    00313           return averageTheta_;
    00314      }
    00315      inline void setAverageTheta(double value) {
    00316           averageTheta_ = value;
    00317      }
    00318      inline void setChangeInCost(double value) {
    00319           changeCost_ = value;
    00320      }
    00321      inline void setMethod(int value) {
    00322           method_ = value;
    00323      }
    00325      inline bool lookBothWays() const {
    00326           return bothWays_;
    00327      }
    00329
    00330      inline bool infeasible(int i) const {
    00331           return ((infeasible_[i>>5] >> (i & 31)) & 1) != 0;
    00332      }
    00333      inline void setInfeasible(int i, bool trueFalse) {
    00334           unsigned int & value = infeasible_[i>>5];
    00335           int bit = i & 31;
    00336           if (trueFalse)
    00337                value |= (1 << bit);
    00338           else
    00339                value &= ~(1 << bit);
    00340      }
    00341      inline unsigned char * statusArray() const {
    00342           return status_;
    00343      }
    00345      void validate();
    00347
    00348 private:
    00351
    00352      double changeCost_;
    00354      double feasibleCost_;
    00356      double infeasibilityWeight_;
    00358      double largestInfeasibility_;
    00360      double sumInfeasibilities_;
    00362      double averageTheta_;
    00364      int numberRows_;
    00366      int numberColumns_;
    00368      int * start_;
    00370      int * whichRange_;
    00372      int * offset_;
    00376      double * lower_;
    00378      double * cost_;
    00380      ClpSimplex * model_;
    00381      // Array to say which regions are infeasible
    00382      unsigned int * infeasible_;
    00384      int numberInfeasibilities_;
    00385      // new stuff
    00387      unsigned char * status_;
    00389      double * bound_;
    00391      double * cost2_;
    00393      int method_;
    00395      bool convex_;
    00397      bool bothWays_;
    00399 };
    00400
    00401 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines