ClpNonLinearCost.hpp

Go to the documentation of this file.

/* $Id: ClpNonLinearCost.hpp 1769 2011-07-26 09:31:51Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef ClpNonLinearCost_H
#define ClpNonLinearCost_H
 
 
#include "CoinPragma.hpp"
 
class ClpSimplex;
class CoinIndexedVector;
 
/* status has original status and current status
   0 - below lower so stored is upper
   1 - in range
   2 - above upper so stored is lower
   4 - (for current) - same as original
*/
#define CLP_BELOW_LOWER 0
#define CLP_FEASIBLE 1
#define CLP_ABOVE_UPPER 2
#define CLP_SAME 4
inline int originalStatus(unsigned char status)
{
     return (status & 15);
}
inline int currentStatus(unsigned char status)
{
     return (status >> 4);
}
inline void setOriginalStatus(unsigned char & status, int value)
{
     status = static_cast<unsigned char>(status & ~15);
     status = static_cast<unsigned char>(status | value);
}
inline void setCurrentStatus(unsigned char &status, int value)
{
     status = static_cast<unsigned char>(status & ~(15 << 4));
     status = static_cast<unsigned char>(status | (value << 4));
}
inline void setInitialStatus(unsigned char &status)
{
     status = static_cast<unsigned char>(CLP_FEASIBLE | (CLP_SAME << 4));
}
inline void setSameStatus(unsigned char &status)
{
     status = static_cast<unsigned char>(status & ~(15 << 4));
     status = static_cast<unsigned char>(status | (CLP_SAME << 4));
}
// Use second version to get more speed
//#define FAST_CLPNON
#ifndef FAST_CLPNON
#define CLP_METHOD1 ((method_&1)!=0)
#define CLP_METHOD2 ((method_&2)!=0)
#else
#define CLP_METHOD1 (false)
#define CLP_METHOD2 (true)
#endif
class ClpNonLinearCost  {
 
public:
 
public:
 
     ClpNonLinearCost();
     ClpNonLinearCost(ClpSimplex * model, int method = 1);
     ClpNonLinearCost(ClpSimplex * model, const int * starts,
                      const double * lower, const double * cost);
     ~ClpNonLinearCost();
     // Copy
     ClpNonLinearCost(const ClpNonLinearCost&);
     // Assignment
     ClpNonLinearCost& operator=(const ClpNonLinearCost&);
 
 
     void checkInfeasibilities(double oldTolerance = 0.0);
     void checkInfeasibilities(int numberInArray, const int * index);
     void checkChanged(int numberInArray, CoinIndexedVector * update);
     void goThru(int numberInArray, double multiplier,
                 const int * index, const double * work,
                 double * rhs);
     void goBack(int numberInArray, const int * index,
                 double * rhs);
     void goBackAll(const CoinIndexedVector * update);
     void zapCosts();
     void refreshCosts(const double * columnCosts);
     void feasibleBounds();
     void refresh();
     double setOne(int sequence, double solutionValue);
     void setOne(int sequence, double solutionValue, double lowerValue, double upperValue,
                 double costValue = 0.0);
     int setOneOutgoing(int sequence, double &solutionValue);
     double nearest(int sequence, double solutionValue);
     inline double changeInCost(int sequence, double alpha) const {
          double returnValue = 0.0;
          if (CLP_METHOD1) {
               int iRange = whichRange_[sequence] + offset_[sequence];
               if (alpha > 0.0)
                    returnValue = cost_[iRange] - cost_[iRange-1];
               else
                    returnValue = cost_[iRange] - cost_[iRange+1];
          }
          if (CLP_METHOD2) {
               returnValue = (alpha > 0.0) ? infeasibilityWeight_ : -infeasibilityWeight_;
          }
          return returnValue;
     }
     inline double changeUpInCost(int sequence) const {
          double returnValue = 0.0;
          if (CLP_METHOD1) {
               int iRange = whichRange_[sequence] + offset_[sequence];
               if (iRange + 1 != start_[sequence+1] && !infeasible(iRange + 1))
                    returnValue = cost_[iRange] - cost_[iRange+1];
               else
                    returnValue = -1.0e100;
          }
          if (CLP_METHOD2) {
               returnValue = -infeasibilityWeight_;
          }
          return returnValue;
     }
     inline double changeDownInCost(int sequence) const {
          double returnValue = 0.0;
          if (CLP_METHOD1) {
               int iRange = whichRange_[sequence] + offset_[sequence];
               if (iRange != start_[sequence] && !infeasible(iRange - 1))
                    returnValue = cost_[iRange] - cost_[iRange-1];
               else
                    returnValue = 1.0e100;
          }
          if (CLP_METHOD2) {
               returnValue = infeasibilityWeight_;
          }
          return returnValue;
     }
     inline double changeInCost(int sequence, double alpha, double &rhs) {
          double returnValue = 0.0;
#ifdef NONLIN_DEBUG
          double saveRhs = rhs;
#endif
          if (CLP_METHOD1) {
               int iRange = whichRange_[sequence] + offset_[sequence];
               if (alpha > 0.0) {
                    assert(iRange - 1 >= start_[sequence]);
                    offset_[sequence]--;
                    rhs += lower_[iRange] - lower_[iRange-1];
                    returnValue = alpha * (cost_[iRange] - cost_[iRange-1]);
               } else {
                    assert(iRange + 1 < start_[sequence+1] - 1);
                    offset_[sequence]++;
                    rhs += lower_[iRange+2] - lower_[iRange+1];
                    returnValue = alpha * (cost_[iRange] - cost_[iRange+1]);
               }
          }
          if (CLP_METHOD2) {
#ifdef NONLIN_DEBUG
               double saveRhs1 = rhs;
               rhs = saveRhs;
#endif
               unsigned char iStatus = status_[sequence];
               int iWhere = currentStatus(iStatus);
               if (iWhere == CLP_SAME)
                    iWhere = originalStatus(iStatus);
               // rhs always increases
               if (iWhere == CLP_FEASIBLE) {
                    if (alpha > 0.0) {
                         // going below
                         iWhere = CLP_BELOW_LOWER;
                         rhs = COIN_DBL_MAX;
                    } else {
                         // going above
                         iWhere = CLP_ABOVE_UPPER;
                         rhs = COIN_DBL_MAX;
                    }
               } else if (iWhere == CLP_BELOW_LOWER) {
                    assert (alpha < 0);
                    // going feasible
                    iWhere = CLP_FEASIBLE;
                    rhs += bound_[sequence] - model_->upperRegion()[sequence];
               } else {
                    assert (iWhere == CLP_ABOVE_UPPER);
                    // going feasible
                    iWhere = CLP_FEASIBLE;
                    rhs += model_->lowerRegion()[sequence] - bound_[sequence];
               }
               setCurrentStatus(status_[sequence], iWhere);
#ifdef NONLIN_DEBUG
               assert(saveRhs1 == rhs);
#endif
               returnValue = fabs(alpha) * infeasibilityWeight_;
          }
          return returnValue;
     }
     inline double lower(int sequence) const {
          return lower_[whichRange_[sequence] + offset_[sequence]];
     }
     inline double upper(int sequence) const {
          return lower_[whichRange_[sequence] + offset_[sequence] + 1];
     }
     inline double cost(int sequence) const {
          return cost_[whichRange_[sequence] + offset_[sequence]];
     }
 
 
     inline int numberInfeasibilities() const {
          return numberInfeasibilities_;
     }
     inline double changeInCost() const {
          return changeCost_;
     }
     inline double feasibleCost() const {
          return feasibleCost_;
     }
     double feasibleReportCost() const;
     inline double sumInfeasibilities() const {
          return sumInfeasibilities_;
     }
     inline double largestInfeasibility() const {
          return largestInfeasibility_;
     }
     inline double averageTheta() const {
          return averageTheta_;
     }
     inline void setAverageTheta(double value) {
          averageTheta_ = value;
     }
     inline void setChangeInCost(double value) {
          changeCost_ = value;
     }
     inline void setMethod(int value) {
          method_ = value;
     }
     inline bool lookBothWays() const {
          return bothWays_;
     }
 
     inline bool infeasible(int i) const {
          return ((infeasible_[i>>5] >> (i & 31)) & 1) != 0;
     }
     inline void setInfeasible(int i, bool trueFalse) {
          unsigned int & value = infeasible_[i>>5];
          int bit = i & 31;
          if (trueFalse)
               value |= (1 << bit);
          else
               value &= ~(1 << bit);
     }
     inline unsigned char * statusArray() const {
          return status_;
     }
     void validate();
 
private:
     double changeCost_;
     double feasibleCost_;
     double infeasibilityWeight_;
     double largestInfeasibility_;
     double sumInfeasibilities_;
     double averageTheta_;
     int numberRows_;
     int numberColumns_;
     int * start_;
     int * whichRange_;
     int * offset_;
     double * lower_;
     double * cost_;
     ClpSimplex * model_;
     // Array to say which regions are infeasible
     unsigned int * infeasible_;
     int numberInfeasibilities_;
     // new stuff
     unsigned char * status_;
     double * bound_;
     double * cost2_;
     int method_;
     bool convex_;
     bool bothWays_;
};
 
#endif