ClpNonLinearCost.hpp

Go to the documentation of this file.

/* $Id$ */
// 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();
  void refresh(int iSequence);
  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 fullStatus(int sequence) const
  {
    return status_[sequence];
  }
  inline bool changed(int sequence) const
  {
    return (status_[sequence] & 64) == 0;
  }
 
 
  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/