casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/coin/CbcGeneralDepth.hpp

@@ -0,0 +1,289 @@
+// $Id$
+// 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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/