ClpNonLinearCost.hpp

// 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;

class ClpNonLinearCost  {
  
public:
  
public:


  ClpNonLinearCost();
  ClpNonLinearCost(ClpSimplex * model);
  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();
  double setOne(int sequence, double solutionValue);
  int setOneOutgoing(int sequence, double &solutionValue);
  double nearest(int sequence, double solutionValue);
  inline double changeInCost(int sequence, double alpha) const
  {
    int iRange = whichRange_[sequence]+offset_[sequence];
    if (alpha>0.0)
      return cost_[iRange]-cost_[iRange-1];
    else
      return cost_[iRange]-cost_[iRange+1];
  }
  inline double changeUpInCost(int sequence) const
  {
    int iRange = whichRange_[sequence]+offset_[sequence];
    if (iRange+1!=start_[sequence+1]&&!infeasible(iRange+1))
      return cost_[iRange]-cost_[iRange+1];
    else
      return -1.0e100;
  }
  inline double changeDownInCost(int sequence) const
  {
    int iRange = whichRange_[sequence]+offset_[sequence];
    if (iRange!=start_[sequence]&&!infeasible(iRange-1))
      return cost_[iRange]-cost_[iRange-1];
    else
      return 1.0e100;
  }
  inline double changeInCost(int sequence, double alpha, double &rhs)
  {
    int iRange = whichRange_[sequence]+offset_[sequence];
    if (alpha>0.0) {
      assert(iRange-1>=start_[sequence]);
      offset_[sequence]--;
      rhs += lower_[iRange]-lower_[iRange-1];
      return alpha*(cost_[iRange]-cost_[iRange-1]);
    } else {
      assert(iRange+1<start_[sequence+1]-1);
      offset_[sequence]++;
      rhs += lower_[iRange+2]-lower_[iRange+1];
      return alpha*(cost_[iRange]-cost_[iRange+1]);
    }
  }
  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 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);
  }
    
private:

  double changeCost_;
  double feasibleCost_;
  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_;
  bool convex_;
  bool bothWays_;
};

#endif

---