/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpNonLinearCost.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#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 &= ~15;status |= value;}
inline void setCurrentStatus(unsigned char &status,int value) 
{ status &= ~(15<<4);status |= (value<<4);}
inline void setInitialStatus(unsigned char &status)
{ status = CLP_FEASIBLE | (CLP_SAME<<4);}
inline void setSameStatus(unsigned char &status)
{ status &= ~(15<<4);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();
  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
      int 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

---