AbcNonLinearCost.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2002, International Business Machines
// Corporation and others, Copyright (C) 2012, FasterCoin.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef AbcNonLinearCost_H
#define AbcNonLinearCost_H
 
#include "CoinPragma.hpp"
#include "AbcCommon.hpp"
 
class AbcSimplex;
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
#ifndef ClpNonLinearCost_H
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));
}
#endif
class AbcNonLinearCost {
 
public:
  AbcNonLinearCost();
  AbcNonLinearCost(AbcSimplex *model);
  ~AbcNonLinearCost();
  // Copy
  AbcNonLinearCost(const AbcNonLinearCost &);
  // Assignment
  AbcNonLinearCost &operator=(const AbcNonLinearCost &);
 
  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 refreshFromPerturbed(double tolerance);
  double setOne(int sequence, double solutionValue);
  double setOneBasic(int iRow, double solutionValue);
  int setOneOutgoing(int sequence, double &solutionValue);
  double nearest(int iRow, double solutionValue);
  inline double changeInCost(int /*sequence*/, double alpha) const
  {
    return (alpha > 0.0) ? infeasibilityWeight_ : -infeasibilityWeight_;
  }
  inline double changeUpInCost(int /*sequence*/) const
  {
    return -infeasibilityWeight_;
  }
  inline double changeDownInCost(int /*sequence*/) const
  {
    return infeasibilityWeight_;
  }
  inline double changeInCost(int iRow, double alpha, double &rhs)
  {
    int sequence = model_->pivotVariable()[iRow];
    double returnValue = 0.0;
    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);
    returnValue = fabs(alpha) * infeasibilityWeight_;
    return returnValue;
  }
 
  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 unsigned char *statusArray() const
  {
    return status_;
  }
  inline int getCurrentStatus(int sequence)
  {
    return (status_[sequence] >> 4);
  }
  void validate();
 
private:
  double changeCost_;
  double feasibleCost_;
  double infeasibilityWeight_;
  double largestInfeasibility_;
  double sumInfeasibilities_;
  double averageTheta_;
  int numberRows_;
  int numberColumns_;
  AbcSimplex *model_;
  int numberInfeasibilities_;
  // new stuff
  unsigned char *status_;
  double *bound_;
  double *cost_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/