1 files changed, 0 insertions, 279 deletions
diff --git a/build/Bonmin/include/coin/CbcGeneralDepth.hpp b/build/Bonmin/include/coin/CbcGeneralDepth.hpp
deleted file mode 100644
index 0d9f817..0000000
--- a/build/Bonmin/include/coin/CbcGeneralDepth.hpp
+++ /dev/null
@@ -1,279 +0,0 @@
-// $Id: CbcGeneralDepth.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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).
-
-// Edwin 11/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcGeneralDepth_H
-#define CbcGeneralDepth_H
-
-#include "CbcGeneral.hpp"
-#include "CbcBranchBase.hpp"
-#include "CbcSubProblem.hpp"
-
-#ifdef COIN_HAS_CLP
-
-/** Define a catch all class.
-    This will create a list of subproblems using partial evaluation
-*/
-#include "ClpSimplex.hpp"
-#include "ClpNode.hpp"
-
-
-class CbcGeneralDepth : public CbcGeneral {
-
-public:
-
-    // Default Constructor
-    CbcGeneralDepth ();
-
-    /** Useful constructor
-        Just needs to point to model.
-        Initial version does evaluation to depth N
-        This is stored in CbcModel but may be
-        better here
-    */
-    CbcGeneralDepth (CbcModel * model, int maximumDepth);
-
-    // Copy constructor
-    CbcGeneralDepth ( const CbcGeneralDepth &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcGeneralDepth & operator=( const CbcGeneralDepth& rhs);
-
-    // Destructor
-    ~CbcGeneralDepth ();
-
-    /// Infeasibility - large is 0.5
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    using CbcObject::feasibleRegion ;
-    /// This looks at solution and sets bounds to contain solution
-    virtual void feasibleRegion();
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-    /// Return maximum number of nodes
-    inline int maximumNodes() const {
-        return maximumNodes_;
-    }
-    /// Get maximum depth
-    inline int maximumDepth() const {
-        return maximumDepth_;
-    }
-    /// Set maximum depth
-    inline void setMaximumDepth(int value) {
-        maximumDepth_ = value;
-    }
-    /// Return number of nodes
-    inline int numberNodes() const {
-        return numberNodes_;
-    }
-    /// Get which solution
-    inline int whichSolution() const {
-        return whichSolution_;
-    }
-    /// Get ClpNode info
-    inline ClpNode * nodeInfo(int which) {
-        return nodeInfo_->nodeInfo_[which];
-    }
-
-    /// Redoes data when sequence numbers change
-    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
-
-protected:
-    /// data
-    /// Maximum depth
-    int maximumDepth_;
-    /// Maximum nodes
-    int maximumNodes_;
-    /// Which node has solution (or -1)
-    mutable int whichSolution_;
-    /// Number of valid nodes (including whichSolution_)
-    mutable int numberNodes_;
-    /// For solving nodes
-    mutable ClpNodeStuff * nodeInfo_;
-};
-/** Branching object for general objects
-
- */
-class CbcNode;
-class CbcGeneralBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcGeneralBranchingObject ();
-
-    // Useful constructor
-    CbcGeneralBranchingObject (CbcModel * model);
-
-    // Copy constructor
-    CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
-
-    // Assignment operator
-    CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcGeneralBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-    /** Double checks in case node can change its mind!
-        Can change objective etc */
-    virtual void checkIsCutoff(double cutoff);
-
-    using CbcBranchingObject::print ;
-    /** \brief Print something about branch - only if log level high
-    */
-    virtual void print();
-    /// Fill in current objective etc
-    void state(double & objectiveValue, double & sumInfeasibilities,
-               int & numberUnsatisfied, int which) const;
-    /// Set CbcNode
-    inline void setNode(CbcNode * node) {
-        node_ = node;
-    }
-    /** Return the type (an integer identifier) of \c this */
-    virtual CbcBranchObjType type() const {
-        return GeneralDepthBranchObj;
-    }
-
-    /** Compare the original object of \c this with the original object of \c
-        brObj. Assumes that there is an ordering of the original objects.
-        This method should be invoked only if \c this and brObj are of the same
-        type.
-        Return negative/0/positive depending on whether \c this is
-        smaller/same/larger than the argument.
-    */
-    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
-
-    /** 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);
-    /// Number of subproblems
-    inline int numberSubProblems() const {
-        return numberSubProblems_;
-    }
-    /// Decrement number left and return number
-    inline int decrementNumberLeft() {
-        numberSubLeft_--;
-        return numberSubLeft_;
-    }
-    /// Which node we want to use
-    inline int whichNode() const {
-        return whichNode_;
-    }
-    /// Set which node we want to use
-    inline void setWhichNode(int value) {
-        whichNode_ = value;
-    }
-    // Sub problem
-    const CbcSubProblem * subProblem(int which) const {
-        return subProblems_ + which;
-    }
-
-public:
-    /// data
-    // Sub problems
-    CbcSubProblem * subProblems_;
-    /// Node
-    CbcNode * node_;
-    /// Number of subproblems
-    int numberSubProblems_;
-    /// Number of subproblems left
-    int numberSubLeft_;
-    /// Which node we want to use (-1 for default)
-    int whichNode_;
-    /// Number of rows
-    int numberRows_;
-};
-/** Branching object for general objects - just one
-
- */
-class CbcOneGeneralBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcOneGeneralBranchingObject ();
-
-    // Useful constructor
-    CbcOneGeneralBranchingObject (CbcModel * model,
-                                  CbcGeneralBranchingObject * object,
-                                  int whichOne);
-
-    // Copy constructor
-    CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
-
-    // Assignment operator
-    CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcOneGeneralBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-    /** Double checks in case node can change its mind!
-        Can change objective etc */
-    virtual void checkIsCutoff(double cutoff);
-
-    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 OneGeneralBranchingObj;
-    }
-
-    /** Compare the original object of \c this with the original object of \c
-        brObj. Assumes that there is an ordering of the original objects.
-        This method should be invoked only if \c this and brObj are of the same
-        type.
-        Return negative/0/positive depending on whether \c this is
-        smaller/same/larger than the argument.
-    */
-    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
-
-    /** 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);
-
-public:
-    /// data
-    /// Object
-    CbcGeneralBranchingObject * object_;
-    /// Which one
-    int whichOne_;
-};
-#endif //COIN_HAS_CLP
-#endif
-