casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcCompareBase.hpp

@@ -0,0 +1,155 @@
+/* $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).
+
+#ifndef CbcCompareBase_H
+#define CbcCompareBase_H
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+    This is rather inflexible so if the comparison functions wants
+    it can signal to use alternative criterion on a complete pass
+    throgh tree.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcConfig.h"
+
+class CbcModel;
+class CbcTree;
+class CbcCompareBase {
+public:
+  // Default Constructor
+  CbcCompareBase()
+  {
+    test_ = NULL;
+    threaded_ = false;
+  }
+
+  /*! \brief Reconsider behaviour after discovering a new solution.
+    
+      This allows any method to change its behaviour. It is called
+      after each solution.
+
+      The method should return true if changes are made which will
+      alter the evaluation criteria applied to a node. (So that in
+      cases where the search tree is sorted, it can be properly
+      rebuilt.)
+    */
+  virtual bool newSolution(CbcModel *) { return (false); }
+
+  /*! \brief Reconsider behaviour after discovering a new solution.
+    
+      This allows any method to change its behaviour. It is called
+      after each solution.
+
+      The method should return true if changes are made which will
+      alter the evaluation criteria applied to a node. (So that in
+      cases where the search tree is sorted, it can be properly
+      rebuilt.)
+    */
+  virtual bool newSolution(CbcModel *,
+    double,
+    int) { return (false); }
+
+  // This allows any method to change behavior as it is called
+  // after every 1000 nodes.
+  // Return true if want tree re-sorted
+  virtual bool every1000Nodes(CbcModel *, int)
+  {
+    return false;
+  }
+
+  /** Returns true if wants code to do scan with alternate criterion
+        NOTE - this is temporarily disabled
+    */
+  virtual bool fullScan() const
+  {
+    return false;
+  }
+
+  virtual ~CbcCompareBase() {}
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *) {}
+
+  // Copy constructor
+  CbcCompareBase(const CbcCompareBase &rhs)
+  {
+    test_ = rhs.test_;
+    threaded_ = rhs.threaded_;
+  }
+
+  // Assignment operator
+  CbcCompareBase &operator=(const CbcCompareBase &rhs)
+  {
+    if (this != &rhs) {
+      test_ = rhs.test_;
+      threaded_ = rhs.threaded_;
+    }
+    return *this;
+  }
+
+  /// Clone
+  virtual CbcCompareBase *clone() const
+  {
+    abort();
+    return NULL;
+  }
+
+  /// This is test function
+  virtual bool test(CbcNode *, CbcNode *)
+  {
+    return true;
+  }
+
+  /// This is alternate test function
+  virtual bool alternateTest(CbcNode *x, CbcNode *y)
+  {
+    return test(x, y);
+  }
+
+  bool operator()(CbcNode *x, CbcNode *y)
+  {
+    return test(x, y);
+  }
+  /// Further test if everything else equal
+  inline bool equalityTest(CbcNode *x, CbcNode *y) const
+  {
+    assert(x);
+    assert(y);
+    if (!threaded_) {
+      CbcNodeInfo *infoX = x->nodeInfo();
+      assert(infoX);
+      int nodeNumberX = infoX->nodeNumber();
+      CbcNodeInfo *infoY = y->nodeInfo();
+      assert(infoY);
+      int nodeNumberY = infoY->nodeNumber();
+      assert(nodeNumberX != nodeNumberY);
+      return (nodeNumberX > nodeNumberY);
+    } else {
+      assert(x->nodeNumber() != y->nodeNumber());
+      return (x->nodeNumber() > y->nodeNumber());
+    }
+  }
+  /// Say threaded
+  inline void sayThreaded()
+  {
+    threaded_ = true;
+  }
+
+protected:
+  CbcCompareBase *test_;
+  // If not threaded we can use better way to break ties
+  bool threaded_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompareDefault.hpp

@@ -0,0 +1,129 @@
+// $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/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareDefault_H
+#define CbcCompareDefault_H
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+
+class CbcModel;
+
+/* This is an example of a more complex rule with data
+   It is default after first solution
+   If weight is 0.0 then it is computed to hit first solution
+   less 5%
+*/
+class CbcCompareDefault : public CbcCompareBase {
+public:
+  /// Default Constructor
+  CbcCompareDefault();
+  /// Constructor with weight
+  CbcCompareDefault(double weight);
+
+  /// Copy constructor
+  CbcCompareDefault(const CbcCompareDefault &rhs);
+
+  /// Assignment operator
+  CbcCompareDefault &operator=(const CbcCompareDefault &rhs);
+
+  /// Clone
+  virtual CbcCompareBase *clone() const;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  ~CbcCompareDefault();
+  /* This returns true if weighted value of node y is less than
+       weighted value of node x */
+  virtual bool test(CbcNode *x, CbcNode *y);
+
+  using CbcCompareBase::newSolution;
+  /// This allows method to change behavior as it is called
+  /// after each solution
+  virtual bool newSolution(CbcModel *model,
+    double objectiveAtContinuous,
+    int numberInfeasibilitiesAtContinuous);
+  /// This allows method to change behavior
+  /// Return true if want tree re-sorted
+  virtual bool every1000Nodes(CbcModel *model, int numberNodes);
+
+  /* if weight == -1.0 then fewest infeasibilities (before solution)
+       if -2.0 then do breadth first just for first 1000 nodes
+       if -3.0 then depth first before solution
+    */
+  inline double getWeight() const
+  {
+    return weight_;
+  }
+  inline void setWeight(double weight)
+  {
+    weight_ = weight;
+  }
+  /// Cutoff
+  inline double getCutoff() const
+  {
+    return cutoff_;
+  }
+  inline void setCutoff(double cutoff)
+  {
+    cutoff_ = cutoff;
+  }
+  /// Best possible solution
+  inline double getBestPossible() const
+  {
+    return bestPossible_;
+  }
+  inline void setBestPossible(double bestPossible)
+  {
+    bestPossible_ = bestPossible;
+  }
+  /// Depth above which want to explore first
+  inline void setBreadthDepth(int value)
+  {
+    breadthDepth_ = value;
+  }
+  /// Start dive
+  void startDive(CbcModel *model);
+  /// Clean up diving (i.e. switch off or prepare)
+  void cleanDive();
+
+protected:
+  /// Weight for each infeasibility
+  double weight_;
+  /// Weight for each infeasibility - computed from solution
+  double saveWeight_;
+  /// Cutoff
+  double cutoff_;
+  /// Best possible solution
+  double bestPossible_;
+  /// Number of solutions
+  int numberSolutions_;
+  /// Tree size (at last check)
+  int treeSize_;
+  /// Depth above which want to explore first
+  int breadthDepth_;
+  /// Chosen node from estimated (-1 is off)
+  int startNodeNumber_;
+  /// Node number when dive started
+  int afterNodeNumber_;
+  /// Indicates doing setup for diving
+  bool setupForDiving_;
+};
+
+#endif //CbcCompareDefault_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompareDepth.hpp

@@ -0,0 +1,48 @@
+// $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/24/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareDepth_H
+#define CbcCompareDepth_H
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+class CbcModel;
+// This is default before first solution
+class CbcCompareDepth : public CbcCompareBase {
+public:
+  // Default Constructor
+  CbcCompareDepth();
+
+  ~CbcCompareDepth();
+  // Copy constructor
+  CbcCompareDepth(const CbcCompareDepth &rhs);
+
+  // Assignment operator
+  CbcCompareDepth &operator=(const CbcCompareDepth &rhs);
+
+  /// Clone
+  virtual CbcCompareBase *clone() const;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  // This returns true if the depth of node y is greater than depth of node x
+  virtual bool test(CbcNode *x, CbcNode *y);
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompareEstimate.hpp

@@ -0,0 +1,48 @@
+// $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/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareEstimate_H
+#define CbcCompareEstimate_H
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+class CbcModel;
+
+/* This is when rounding is being done
+*/
+class CbcCompareEstimate : public CbcCompareBase {
+public:
+  // Default Constructor
+  CbcCompareEstimate();
+  ~CbcCompareEstimate();
+  // Copy constructor
+  CbcCompareEstimate(const CbcCompareEstimate &rhs);
+
+  // Assignment operator
+  CbcCompareEstimate &operator=(const CbcCompareEstimate &rhs);
+
+  /// Clone
+  virtual CbcCompareBase *clone() const;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  virtual bool test(CbcNode *x, CbcNode *y);
+};
+
+#endif //CbcCompareEstimate_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompareObjective.hpp

@@ -0,0 +1,50 @@
+// $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/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareObjective_H
+#define CbcCompareObjective_H
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+
+class CbcModel;
+
+class CbcCompareObjective : public CbcCompareBase {
+public:
+  // Default Constructor
+  CbcCompareObjective();
+
+  virtual ~CbcCompareObjective();
+  // Copy constructor
+  CbcCompareObjective(const CbcCompareObjective &rhs);
+
+  // Assignment operator
+  CbcCompareObjective &operator=(const CbcCompareObjective &rhs);
+
+  /// Clone
+  virtual CbcCompareBase *clone() const;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /* This returns true if objective value of node y is less than
+       objective value of node x */
+  virtual bool test(CbcNode *x, CbcNode *y);
+};
+
+#endif //CbcCompareObjective_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcConfig.h

@@ -0,0 +1,18 @@
+/* src/config_cbc.h.  Generated by configure.  */
+/* src/config_cbc.h.in. */
+
+#ifndef CBC_VERSION
+
+/* Version number of project */
+#define CBC_VERSION "2.10.11"
+
+/* Major Version number of project */
+#define CBC_VERSION_MAJOR 2
+
+/* Minor Version number of project */
+#define CBC_VERSION_MINOR 10
+
+/* Release Version number of project */
+#define CBC_VERSION_RELEASE 11
+
+#endif

casadi/include/coin/CbcConsequence.hpp

@@ -0,0 +1,50 @@
+// $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/12/2009 carved from CbcBranchBase
+
+#ifndef CbcConsequence_H
+#define CbcConsequence_H
+
+class OsiSolverInterface;
+
+/** Abstract base class for consequent bounds.
+    When a variable is branched on it normally interacts with other variables by
+    means of equations.  There are cases where we want to step outside LP and do something
+    more directly e.g. fix bounds.  This class is for that.
+
+    At present it need not be virtual as only instance is CbcFixVariable, but ...
+
+ */
+
+class CbcConsequence {
+
+public:
+  // Default Constructor
+  CbcConsequence();
+
+  // Copy constructor
+  CbcConsequence(const CbcConsequence &rhs);
+
+  // Assignment operator
+  CbcConsequence &operator=(const CbcConsequence &rhs);
+
+  /// Clone
+  virtual CbcConsequence *clone() const = 0;
+
+  /// Destructor
+  virtual ~CbcConsequence();
+
+  /** Apply to an LP solver.  Action depends on state
+     */
+  virtual void applyToSolver(OsiSolverInterface *solver, int state) const = 0;
+
+protected:
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCountRowCut.hpp

@@ -0,0 +1,176 @@
+/* $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).
+
+#ifndef CbcCountRowCut_H
+#define CbcCountRowCut_H
+
+class OsiCuts;
+class OsiRowCut;
+class CbcNodeInfo;
+
+//#############################################################################
+/** \brief OsiRowCut augmented with bookkeeping
+
+  CbcCountRowCut is an OsiRowCut object augmented with bookkeeping
+  information: a reference count and information that specifies the
+  the generator that created the cut and the node to which it's associated.
+
+  The general principles for handling the reference count are as follows:
+  <ul>
+    <li> Once it's determined how the node will branch, increment the
+	 reference count under the assumption that all children will use
+         all cuts currently tight at the node and will survive to be placed
+	 in the search tree.
+    <li> As this assumption is proven incorrect (a cut becomes loose, or a
+	 child is fathomed), decrement the reference count accordingly.
+  </ul>
+  When all possible uses of a cut have been demonstrated to be unnecessary,
+  the reference count (#numberPointingToThis_) will fall to zero. The
+  CbcCountRowCut object (and its included OsiRowCut object) are then deleted.
+*/
+
+class CbcCountRowCut : public OsiRowCut {
+
+public:
+  /** @name Constructors & destructors */
+  //@{
+
+  /// Default Constructor
+  CbcCountRowCut();
+
+  /// `Copy' constructor using an OsiRowCut
+  CbcCountRowCut(const OsiRowCut &);
+
+  /// `Copy' constructor using an OsiRowCut and an CbcNodeInfo
+  CbcCountRowCut(const OsiRowCut &, CbcNodeInfo *, int whichOne,
+    int whichGenerator = -1, int numberPointingToThis = 0);
+
+  /** Destructor
+
+      \note The destructor will reach out (via #owner_) and NULL the
+      reference to the cut in the owner's
+      \link CbcNodeInfo::cuts_ cuts_ \endlink list.
+    */
+  virtual ~CbcCountRowCut();
+  //@}
+
+  /// Increment the number of references
+  void increment(int change = 1);
+
+  /// Decrement the number of references and return the number left.
+  int decrement(int change = 1);
+
+  /** \brief Set the information associating this cut with a node
+
+      An CbcNodeInfo object and an index in the cut set of the node.
+      For locally valid cuts, the node will be the  search tree node where the
+      cut was generated. For globally valid cuts, it's the node where the cut
+      was activated.
+    */
+  void setInfo(CbcNodeInfo *, int whichOne);
+
+  /// Number of other CbcNodeInfo objects pointing to this row cut
+  inline int numberPointingToThis()
+  {
+    return numberPointingToThis_;
+  }
+
+  /// Which generator for cuts - as user order
+  inline int whichCutGenerator() const
+  {
+    return whichCutGenerator_;
+  }
+
+  /// Returns true if can drop cut if slack basic
+  bool canDropCut(const OsiSolverInterface *solver, int row) const;
+
+#ifdef CHECK_CUT_COUNTS
+  // Just for printing sanity checks
+  int tempNumber_;
+#endif
+
+private:
+  /// Standard copy is illegal (reference counts would be incorrect)
+  CbcCountRowCut(const CbcCountRowCut &);
+
+  /// Standard assignment is illegal (reference counts would be incorrect)
+  CbcCountRowCut &operator=(const CbcCountRowCut &rhs);
+
+  /// Backward pointer to owning CbcNodeInfo
+  CbcNodeInfo *owner_;
+
+  /// Index of cut in owner's cut set
+  /// (\link CbcNodeInfo::cuts_ cuts_ \endlink).
+  int ownerCut_;
+
+  /// Number of other CbcNodeInfo objects pointing to this cut
+  int numberPointingToThis_;
+
+  /** Which generator created this cut 
+	(add 10000 if globally valid)
+	if -1 then from global cut pool
+	-2 cut branch
+        -3 unknown
+    */
+  int whichCutGenerator_;
+};
+/**
+   Really for Conflict cuts to -
+   a) stop duplicates
+   b) allow half baked cuts
+   The whichRow_ field in OsiRowCut2 is used for a type
+   0 - normal 
+   1 - processed cut (conflict)
+   2 - unprocessed cut i.e. dual ray computation
+*/
+// for hashing
+typedef struct {
+  int index, next;
+} CoinHashLink;
+class CbcRowCuts {
+public:
+  CbcRowCuts(int initialMaxSize = 0, int hashMultiplier = 4);
+  ~CbcRowCuts();
+  CbcRowCuts(const CbcRowCuts &rhs);
+  CbcRowCuts &operator=(const CbcRowCuts &rhs);
+  inline OsiRowCut2 *cut(int sequence) const
+  {
+    return rowCut_[sequence];
+  }
+  inline int numberCuts() const
+  {
+    return numberCuts_;
+  }
+  inline int sizeRowCuts() const
+  {
+    return numberCuts_;
+  }
+  inline OsiRowCut *rowCutPtr(int sequence)
+  {
+    return rowCut_[sequence];
+  }
+  void eraseRowCut(int sequence);
+  // Return 0 if added, 1 if not, -1 if not added because of space
+  int addCutIfNotDuplicate(const OsiRowCut &cut, int whichType = 0);
+  // Return 0 if added, 1 if not, -1 if not added because of space
+  int addCutIfNotDuplicateWhenGreedy(const OsiRowCut &cut, int whichType = 0);
+  // Add in cuts as normal cuts (and delete)
+  void addCuts(OsiCuts &cs);
+  // Truncate
+  void truncate(int numberAfter);
+
+private:
+  OsiRowCut2 **rowCut_;
+  /// Hash table
+  CoinHashLink *hash_;
+  int size_;
+  int hashMultiplier_;
+  int numberCuts_;
+  int lastHash_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/