initial add

1 files changed, 242 insertions, 0 deletions

diff --git a/build/Bonmin/include/coin/CbcBranchLotsize.hpp b/build/Bonmin/include/coin/CbcBranchLotsize.hpp
new file mode 100644
index 0000000..4ba6510
--- /dev/null
+++ b/build/Bonmin/include/coin/CbcBranchLotsize.hpp
@@ -0,0 +1,242 @@
+/* $Id: CbcBranchLotsize.hpp 1573 2011-01-05 01:12:36Z lou $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcBranchLotsize_H
+#define CbcBranchLotsize_H
+
+#include "CbcBranchBase.hpp"
+/** Lotsize class */
+
+
+class CbcLotsize : public CbcObject {
+
+public:
+
+    // Default Constructor
+    CbcLotsize ();
+
+    /* Useful constructor - passed model index.
+       Also passed valid values - if range then pairs
+    */
+    CbcLotsize (CbcModel * model, int iColumn,
+                int numberPoints, const double * points, bool range = false);
+
+    // Copy constructor
+    CbcLotsize ( const CbcLotsize &);
+
+    /// Clone
+    virtual CbcObject * clone() const;
+
+    // Assignment operator
+    CbcLotsize & operator=( const CbcLotsize& rhs);
+
+    // Destructor
+    ~CbcLotsize ();
+
+    /// Infeasibility - large is 0.5
+    virtual double infeasibility(const OsiBranchingInformation * info,
+                                 int &preferredWay) const;
+
+    using CbcObject::feasibleRegion ;
+    /** Set bounds to contain the current solution.
+
+      More precisely, for the variable associated with this object, take the
+      value given in the current solution, force it within the current bounds
+      if required, then set the bounds to fix the variable at the integer
+      nearest the solution value.
+    */
+    virtual void feasibleRegion();
+
+    /// Creates a branching object
+    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in the good direction.
+
+      The preferred branching object will force the variable to be +/-1 from
+      its current value, depending on the reduced cost and objective sense.  If
+      movement in the direction which improves the objective is impossible due
+      to bounds on the variable, the branching object will move in the other
+      direction.  If no movement is possible, the method returns NULL.
+
+      Only the bounds on this variable are considered when determining if the new
+      point is feasible.
+    */
+    virtual CbcBranchingObject * preferredNewFeasible() const;
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a bad direction.
+
+      As for preferredNewFeasible(), but the preferred branching object will
+      force movement in a direction that degrades the objective.
+    */
+    virtual CbcBranchingObject * notPreferredNewFeasible() const ;
+
+    /** Reset original upper and lower bound values from the solver.
+
+      Handy for updating bounds held in this object after bounds held in the
+      solver have been tightened.
+     */
+    virtual void resetBounds(const OsiSolverInterface * solver);
+
+    /** Finds range of interest so value is feasible in range range_ or infeasible
+        between hi[range_] and lo[range_+1].  Returns true if feasible.
+    */
+    bool findRange(double value) const;
+
+    /** Returns floor and ceiling
+    */
+    virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
+                              double tolerance) const;
+
+    /// Model column number
+    inline int modelSequence() const {
+        return columnNumber_;
+    }
+    /// Set model column number
+    inline void setModelSequence(int value) {
+        columnNumber_ = value;
+    }
+
+    /** Column number if single column object -1 otherwise,
+        so returns >= 0
+        Used by heuristics
+    */
+    virtual int columnNumber() const;
+    /// Original variable bounds
+    inline double originalLowerBound() const {
+        return bound_[0];
+    }
+    inline double originalUpperBound() const {
+        return bound_[rangeType_*numberRanges_-1];
+    }
+    /// Type - 1 points, 2 ranges
+    inline int rangeType() const {
+        return rangeType_;
+    }
+    /// Number of points
+    inline int numberRanges() const {
+        return numberRanges_;
+    }
+    /// Ranges
+    inline double * bound() const {
+        return bound_;
+    }
+    /** \brief Return true if object can take part in normal heuristics
+    */
+    virtual bool canDoHeuristics() const {
+        return false;
+    }
+
+private:
+    /// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp)
+    void printLotsize(double value, bool condition, int type) const;
+
+private:
+    /// data
+
+    /// Column number in model
+    int columnNumber_;
+    /// Type - 1 points, 2 ranges
+    int rangeType_;
+    /// Number of points
+    int numberRanges_;
+    // largest gap
+    double largestGap_;
+    /// Ranges
+    double * bound_;
+    /// Current range
+    mutable int range_;
+};
+
+/** Lotsize branching object
+
+  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 CbcLotsizeBranchingObject : public CbcBranchingObject {
+
+public:
+
+    /// Default constructor
+    CbcLotsizeBranchingObject ();
+
+    /** Create a lotsize floor/ceiling branch object
+
+      Specifies a simple two-way branch. Let \p value = x*. One arm of the
+      branch will be is lb <= x <= valid range below(x*), the other valid range above(x*) <= x <= ub.
+      Specify way = -1 to set the object state to perform the down arm first,
+      way = 1 for the up arm.
+    */
+    CbcLotsizeBranchingObject (CbcModel *model, int variable,
+                               int way , double value, const CbcLotsize * lotsize) ;
+
+    /** 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 in valid range
+    */
+
+    CbcLotsizeBranchingObject (CbcModel *model, int variable, int way,
+                               double lowerValue, double upperValue) ;
+
+    /// Copy constructor
+    CbcLotsizeBranchingObject ( const CbcLotsizeBranchingObject &);
+
+    /// Assignment operator
+    CbcLotsizeBranchingObject & operator= (const CbcLotsizeBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    /// Destructor
+    virtual ~CbcLotsizeBranchingObject ();
+
+    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.
+    */
+    virtual double branch();
+
+    using CbcBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print();
+
+    /** Return the type (an integer identifier) of \c this */
+    virtual CbcBranchObjType type() const {
+        return LotsizeBranchObj;
+    }
+
+    // LL: compareOriginalObject can be inherited from the CbcBranchingObject
+    // since variable_ uniquely defines the lot sizing object.
+
+    /** 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:
+    /// Lower [0] and upper [1] bounds for the down arm (way_ = -1)
+    double down_[2];
+    /// Lower [0] and upper [1] bounds for the up arm (way_ = 1)
+    double up_[2];
+};
+
+#endif
+