summaryrefslogtreecommitdiff
path: root/build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp')
-rw-r--r--build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp564
1 files changed, 564 insertions, 0 deletions
diff --git a/build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp b/build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp
new file mode 100644
index 0000000..7952d57
--- /dev/null
+++ b/build/Bonmin/include/coin/CbcSimpleIntegerDynamicPseudoCost.hpp
@@ -0,0 +1,564 @@
+// $Id: CbcSimpleIntegerDynamicPseudoCost.hpp 2094 2014-11-18 11:15:36Z forrest $
+// Copyright (C) 2005, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+// Edwin 11/17/2009 - carved out of CbcBranchDynamic
+
+#ifndef CbcSimpleIntegerDynamicPseudoCost_H
+#define CbcSimpleIntegerDynamicPseudoCost_H
+
+#include "CbcSimpleInteger.hpp"
+
+#define TYPERATIO 0.9
+#define MINIMUM_MOVEMENT 0.1
+#define TYPE2 0
+// was 1 - but that looks flakey
+#define INFEAS 1
+#define MOD_SHADOW 1
+// weight at 1.0 is max min
+#define WEIGHT_AFTER 0.8
+#define WEIGHT_BEFORE 0.1
+//Stolen from Constraint Integer Programming book (with epsilon change)
+#define WEIGHT_PRODUCT
+
+
+/** Define a single integer class but with dynamic pseudo costs.
+ Based on work by Achterberg, Koch and Martin.
+
+ It is wild overkill but to keep design all twiddly things are in each.
+ This could be used for fine tuning.
+
+ */
+
+
+class CbcSimpleIntegerDynamicPseudoCost : public CbcSimpleInteger {
+
+public:
+
+ // Default Constructor
+ CbcSimpleIntegerDynamicPseudoCost ();
+
+ // Useful constructor - passed model index
+ CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int iColumn, double breakEven = 0.5);
+
+ // Useful constructor - passed model index and pseudo costs
+ CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int iColumn,
+ double downDynamicPseudoCost, double upDynamicPseudoCost);
+
+ // Useful constructor - passed model index and pseudo costs
+ CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int dummy, int iColumn,
+ double downDynamicPseudoCost, double upDynamicPseudoCost);
+
+ // Copy constructor
+ CbcSimpleIntegerDynamicPseudoCost ( const CbcSimpleIntegerDynamicPseudoCost &);
+
+ /// Clone
+ virtual CbcObject * clone() const;
+
+ // Assignment operator
+ CbcSimpleIntegerDynamicPseudoCost & operator=( const CbcSimpleIntegerDynamicPseudoCost& rhs);
+
+ // Destructor
+ virtual ~CbcSimpleIntegerDynamicPseudoCost ();
+
+ /// Infeasibility - large is 0.5
+ virtual double infeasibility(const OsiBranchingInformation * info,
+ int &preferredWay) const;
+
+ /// Creates a branching object
+ virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
+
+
+ /// Fills in a created branching object
+ // void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ;
+
+
+ /** Pass in information on branch just done and create CbcObjectUpdateData instance.
+ If object does not need data then backward pointer will be NULL.
+ Assumes can get information from solver */
+ virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver,
+ const CbcNode * node,
+ const CbcBranchingObject * branchingObject);
+ /// Update object by CbcObjectUpdateData
+ virtual void updateInformation(const CbcObjectUpdateData & data) ;
+ /// Copy some information i.e. just variable stuff
+ void copySome(const CbcSimpleIntegerDynamicPseudoCost * otherObject);
+ /// Updates stuff like pseudocosts before threads
+ virtual void updateBefore(const OsiObject * rhs) ;
+ /// Updates stuff like pseudocosts after threads finished
+ virtual void updateAfter(const OsiObject * rhs, const OsiObject * baseObject) ;
+ /// Updates stuff like pseudocosts after mini branch and bound
+ void updateAfterMini(int numberDown, int numberDownInfeasible, double sumDown,
+ int numberUp, int numberUpInfeasible, double sumUp);
+
+ using CbcSimpleInteger::solverBranch ;
+ /** Create an OsiSolverBranch object
+
+ This returns NULL if branch not represented by bound changes
+ */
+ virtual OsiSolverBranch * solverBranch() const;
+
+ /// Down pseudo cost
+ inline double downDynamicPseudoCost() const {
+ return downDynamicPseudoCost_;
+ }
+ /// Set down pseudo cost
+ void setDownDynamicPseudoCost(double value) ;
+ /// Modify down pseudo cost in a slightly different way
+ void updateDownDynamicPseudoCost(double value);
+
+ /// Up pseudo cost
+ inline double upDynamicPseudoCost() const {
+ return upDynamicPseudoCost_;
+ }
+ /// Set up pseudo cost
+ void setUpDynamicPseudoCost(double value);
+ /// Modify up pseudo cost in a slightly different way
+ void updateUpDynamicPseudoCost(double value);
+
+ /// Down pseudo shadow price cost
+ inline double downShadowPrice() const {
+ return downShadowPrice_;
+ }
+ /// Set down pseudo shadow price cost
+ inline void setDownShadowPrice(double value) {
+ downShadowPrice_ = value;
+ }
+ /// Up pseudo shadow price cost
+ inline double upShadowPrice() const {
+ return upShadowPrice_;
+ }
+ /// Set up pseudo shadow price cost
+ inline void setUpShadowPrice(double value) {
+ upShadowPrice_ = value;
+ }
+
+ /// Up down separator
+ inline double upDownSeparator() const {
+ return upDownSeparator_;
+ }
+ /// Set up down separator
+ inline void setUpDownSeparator(double value) {
+ upDownSeparator_ = value;
+ }
+
+ /// Down sum cost
+ inline double sumDownCost() const {
+ return sumDownCost_;
+ }
+ /// Set down sum cost
+ inline void setSumDownCost(double value) {
+ sumDownCost_ = value;
+ }
+ /// Add to down sum cost and set last and square
+ inline void addToSumDownCost(double value) {
+ sumDownCost_ += value;
+ lastDownCost_ = value;
+ }
+
+ /// Up sum cost
+ inline double sumUpCost() const {
+ return sumUpCost_;
+ }
+ /// Set up sum cost
+ inline void setSumUpCost(double value) {
+ sumUpCost_ = value;
+ }
+ /// Add to up sum cost and set last and square
+ inline void addToSumUpCost(double value) {
+ sumUpCost_ += value;
+ lastUpCost_ = value;
+ }
+
+ /// Down sum change
+ inline double sumDownChange() const {
+ return sumDownChange_;
+ }
+ /// Set down sum change
+ inline void setSumDownChange(double value) {
+ sumDownChange_ = value;
+ }
+ /// Add to down sum change
+ inline void addToSumDownChange(double value) {
+ sumDownChange_ += value;
+ }
+
+ /// Up sum change
+ inline double sumUpChange() const {
+ return sumUpChange_;
+ }
+ /// Set up sum change
+ inline void setSumUpChange(double value) {
+ sumUpChange_ = value;
+ }
+ /// Add to up sum change and set last and square
+ inline void addToSumUpChange(double value) {
+ sumUpChange_ += value;
+ }
+
+ /// Sum down decrease number infeasibilities from strong or actual
+ inline double sumDownDecrease() const {
+ return sumDownDecrease_;
+ }
+ /// Set sum down decrease number infeasibilities from strong or actual
+ inline void setSumDownDecrease(double value) {
+ sumDownDecrease_ = value;
+ }
+ /// Add to sum down decrease number infeasibilities from strong or actual
+ inline void addToSumDownDecrease(double value) {
+ sumDownDecrease_ += value;/*lastDownDecrease_ = (int) value;*/
+ }
+
+ /// Sum up decrease number infeasibilities from strong or actual
+ inline double sumUpDecrease() const {
+ return sumUpDecrease_;
+ }
+ /// Set sum up decrease number infeasibilities from strong or actual
+ inline void setSumUpDecrease(double value) {
+ sumUpDecrease_ = value;
+ }
+ /// Add to sum up decrease number infeasibilities from strong or actual
+ inline void addToSumUpDecrease(double value) {
+ sumUpDecrease_ += value;/*lastUpDecrease_ = (int) value;*/
+ }
+
+ /// Down number times
+ inline int numberTimesDown() const {
+ return numberTimesDown_;
+ }
+ /// Set down number times
+ inline void setNumberTimesDown(int value) {
+ numberTimesDown_ = value;
+ }
+ /// Increment down number times
+ inline void incrementNumberTimesDown() {
+ numberTimesDown_++;
+ }
+
+ /// Up number times
+ inline int numberTimesUp() const {
+ return numberTimesUp_;
+ }
+ /// Set up number times
+ inline void setNumberTimesUp(int value) {
+ numberTimesUp_ = value;
+ }
+ /// Increment up number times
+ inline void incrementNumberTimesUp() {
+ numberTimesUp_++;
+ }
+
+ /// Number times branched
+ inline int numberTimesBranched() const {
+ return numberTimesDown_ + numberTimesUp_;
+ }
+ /// Down number times infeasible
+ inline int numberTimesDownInfeasible() const {
+ return numberTimesDownInfeasible_;
+ }
+ /// Set down number times infeasible
+ inline void setNumberTimesDownInfeasible(int value) {
+ numberTimesDownInfeasible_ = value;
+ }
+ /// Increment down number times infeasible
+ inline void incrementNumberTimesDownInfeasible() {
+ numberTimesDownInfeasible_++;
+ }
+
+ /// Up number times infeasible
+ inline int numberTimesUpInfeasible() const {
+ return numberTimesUpInfeasible_;
+ }
+ /// Set up number times infeasible
+ inline void setNumberTimesUpInfeasible(int value) {
+ numberTimesUpInfeasible_ = value;
+ }
+ /// Increment up number times infeasible
+ inline void incrementNumberTimesUpInfeasible() {
+ numberTimesUpInfeasible_++;
+ }
+
+ /// Number of times before trusted
+ inline int numberBeforeTrust() const {
+ return numberBeforeTrust_;
+ }
+ /// Set number of times before trusted
+ inline void setNumberBeforeTrust(int value) {
+ numberBeforeTrust_ = value;
+ }
+ /// Increment number of times before trusted
+ inline void incrementNumberBeforeTrust() {
+ numberBeforeTrust_++;
+ }
+
+ /// Return "up" estimate
+ virtual double upEstimate() const;
+ /// Return "down" estimate (default 1.0e-5)
+ virtual double downEstimate() const;
+
+ /// method - see below for details
+ inline int method() const {
+ return method_;
+ }
+ /// Set method
+ inline void setMethod(int value) {
+ method_ = value;
+ }
+
+ /// Pass in information on a down branch
+ void setDownInformation(double changeObjectiveDown, int changeInfeasibilityDown);
+ /// Pass in information on a up branch
+ void setUpInformation(double changeObjectiveUp, int changeInfeasibilityUp);
+ /// Pass in probing information
+ void setProbingInformation(int fixedDown, int fixedUp);
+
+ /// Print - 0 -summary, 1 just before strong
+ void print(int type = 0, double value = 0.0) const;
+ /// Same - returns true if contents match(ish)
+ bool same(const CbcSimpleIntegerDynamicPseudoCost * obj) const;
+protected:
+ /// data
+
+ /// Down pseudo cost
+ double downDynamicPseudoCost_;
+ /// Up pseudo cost
+ double upDynamicPseudoCost_;
+ /** Up/down separator
+ If >0.0 then do first branch up if value-floor(value)
+ >= this value
+ */
+ double upDownSeparator_;
+ /// Sum down cost from strong or actual
+ double sumDownCost_;
+ /// Sum up cost from strong or actual
+ double sumUpCost_;
+ /// Sum of all changes to x when going down
+ double sumDownChange_;
+ /// Sum of all changes to x when going up
+ double sumUpChange_;
+ /// Current pseudo-shadow price estimate down
+ mutable double downShadowPrice_;
+ /// Current pseudo-shadow price estimate up
+ mutable double upShadowPrice_;
+ /// Sum down decrease number infeasibilities from strong or actual
+ double sumDownDecrease_;
+ /// Sum up decrease number infeasibilities from strong or actual
+ double sumUpDecrease_;
+ /// Last down cost from strong (i.e. as computed by last strong)
+ double lastDownCost_;
+ /// Last up cost from strong (i.e. as computed by last strong)
+ double lastUpCost_;
+ /// Last down decrease number infeasibilities from strong (i.e. as computed by last strong)
+ mutable int lastDownDecrease_;
+ /// Last up decrease number infeasibilities from strong (i.e. as computed by last strong)
+ mutable int lastUpDecrease_;
+ /// Number of times we have gone down
+ int numberTimesDown_;
+ /// Number of times we have gone up
+ int numberTimesUp_;
+ /// Number of times we have been infeasible going down
+ int numberTimesDownInfeasible_;
+ /// Number of times we have been infeasible going up
+ int numberTimesUpInfeasible_;
+ /// Number of branches before we trust
+ int numberBeforeTrust_;
+ /// Number of local probing fixings going down
+ int numberTimesDownLocalFixed_;
+ /// Number of local probing fixings going up
+ int numberTimesUpLocalFixed_;
+ /// Number of total probing fixings going down
+ double numberTimesDownTotalFixed_;
+ /// Number of total probing fixings going up
+ double numberTimesUpTotalFixed_;
+ /// Number of times probing done
+ int numberTimesProbingTotal_;
+ /// Number of times infeasible when tested
+ /** Method -
+ 0 - pseudo costs
+ 1 - probing
+ */
+ int method_;
+};
+/** Simple branching object for an integer variable with pseudo costs
+
+ This object can specify a two-way branch on an integer variable. For each
+ arm of the branch, the upper and lower bounds on the variable can be
+ independently specified.
+
+ Variable_ holds the index of the integer variable in the integerVariable_
+ array of the model.
+*/
+
+class CbcIntegerPseudoCostBranchingObject : public CbcIntegerBranchingObject {
+
+public:
+
+ /// Default constructor
+ CbcIntegerPseudoCostBranchingObject ();
+
+ /** Create a standard floor/ceiling branch object
+
+ Specifies a simple two-way branch. Let \p value = x*. One arm of the
+ branch will be is lb <= x <= floor(x*), the other ceil(x*) <= x <= ub.
+ Specify way = -1 to set the object state to perform the down arm first,
+ way = 1 for the up arm.
+ */
+ CbcIntegerPseudoCostBranchingObject (CbcModel *model, int variable,
+ int way , double value) ;
+
+ /** Create a degenerate branch object
+
+ Specifies a `one-way branch'. Calling branch() for this object will
+ always result in lowerValue <= x <= upperValue. Used to fix a variable
+ when lowerValue = upperValue.
+ */
+
+ CbcIntegerPseudoCostBranchingObject (CbcModel *model, int variable, int way,
+ double lowerValue, double upperValue) ;
+
+ /// Copy constructor
+ CbcIntegerPseudoCostBranchingObject ( const CbcIntegerPseudoCostBranchingObject &);
+
+ /// Assignment operator
+ CbcIntegerPseudoCostBranchingObject & operator= (const CbcIntegerPseudoCostBranchingObject& rhs);
+
+ /// Clone
+ virtual CbcBranchingObject * clone() const;
+
+ /// Destructor
+ virtual ~CbcIntegerPseudoCostBranchingObject ();
+
+ using CbcBranchingObject::branch ;
+ /** \brief Sets the bounds for the variable according to the current arm
+ of the branch and advances the object state to the next arm.
+ This version also changes guessed objective value
+ */
+ virtual double branch();
+
+ /// Change in guessed
+ inline double changeInGuessed() const {
+ return changeInGuessed_;
+ }
+ /// Set change in guessed
+ inline void setChangeInGuessed(double value) {
+ changeInGuessed_ = value;
+ }
+
+ /** Return the type (an integer identifier) of \c this */
+ virtual CbcBranchObjType type() const {
+ return SimpleIntegerDynamicPseudoCostBranchObj;
+ }
+
+ /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
+ same type and must have the same original object, but they may have
+ different feasible regions.
+ Return the appropriate CbcRangeCompare value (first argument being the
+ sub/superset if that's the case). In case of overlap (and if \c
+ replaceIfOverlap is true) replace the current branching object with one
+ whose feasible region is the overlap.
+ */
+ virtual CbcRangeCompare compareBranchingObject
+ (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
+
+protected:
+ /// Change in guessed objective value for next branch
+ double changeInGuessed_;
+};
+#ifdef SWITCH_VARIABLES
+/** Define a single integer class but with associated switched variable
+ So Binary variable switches on/off a continuous variable
+ designed for badly scaled problems
+ */
+
+
+class CbcSwitchingBinary : public CbcSimpleIntegerDynamicPseudoCost {
+
+public:
+
+ // Default Constructor
+ CbcSwitchingBinary ();
+
+ // Useful constructor
+ CbcSwitchingBinary (CbcSimpleIntegerDynamicPseudoCost * oldObject,
+ int nOdd,const int * other, const int * otherRow);
+
+
+ // Copy constructor
+ CbcSwitchingBinary ( const CbcSwitchingBinary &);
+
+ /// Clone
+ virtual CbcObject * clone() const;
+
+ // Assignment operator
+ CbcSwitchingBinary & operator=( const CbcSwitchingBinary& rhs);
+
+ // Destructor
+ virtual ~CbcSwitchingBinary ();
+
+ /// Add in zero switches
+ void addZeroSwitches(int nAdd,const int * columns);
+ /// Infeasibility - large is 0.5
+ virtual double infeasibility(const OsiBranchingInformation * info,
+ int &preferredWay) const;
+
+ /// Same - returns true if contents match(ish)
+ bool same(const CbcSwitchingBinary * obj) const;
+ /// Set associated bounds
+ virtual int setAssociatedBounds(OsiSolverInterface * solver=NULL,
+ int cleanBasis=0) const;
+ /// Check associated bounds
+ int checkAssociatedBounds(const OsiSolverInterface * solver,const double * solution,
+ int printLevel, int state[3], int & nBadFixed) const;
+ /// Lower bound when binary zero
+ inline const double * zeroLowerBound() const
+ { return zeroLowerBound_; }
+ /// Lower bound when binary one
+ inline const double * oneLowerBound() const
+ { return oneLowerBound_; }
+ /// Upper bound when binary zero
+ inline const double * zeroUpperBound() const
+ { return zeroUpperBound_; }
+ /// Upper bound when binary one
+ inline const double * oneUpperBound() const
+ { return oneUpperBound_; }
+ /** Continuous variable -
+ */
+ inline const int * otherVariable() const
+ { return otherVariable_;}
+ /// Number of other variables
+ inline int numberOther() const
+ { return numberOther_;}
+ /** Type
+ 1 - single switch
+ 2 - double switch
+ 3 - both
+ */
+ inline int type() const
+ { return type_;}
+protected:
+ /// data
+
+ /// Lower bound when binary zero
+ double * zeroLowerBound_;
+ /// Lower bound when binary one
+ double * oneLowerBound_;
+ /// Upper bound when binary zero
+ double * zeroUpperBound_;
+ /// Upper bound when binary one
+ double * oneUpperBound_;
+ /** Continuous variable -
+ */
+ int * otherVariable_;
+ /// Number of other variables
+ int numberOther_;
+ /** Type
+ 1 - single switch
+ 2 - double switch
+ 3 - both
+ */
+ int type_;
+};
+#endif
+#endif
+
generated by cgit (git 2.34.1) at 2024-12-19 12:03:09 +0000