AbcNonLinearCost.hpp

Go to the documentation of this file.

/* $Id: AbcNonLinearCost.hpp 2024 2014-03-07 17:18:15Z forrest $ */
// 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