casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcBranchToFixLots.hpp

@@ -0,0 +1,94 @@
+// $Id$
+// 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).
+
+// Edwin 11/13/2009-- carved out of CbcBranchCut
+
+#ifndef CbcBranchToFixLots_H
+#define CbcBranchToFixLots_H
+
+#include "CbcBranchCut.hpp"
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Define a branch class that branches so that one way variables are fixed
+    while the other way cuts off that solution.
+    a) On reduced cost
+    b) When enough ==1 or <=1 rows have been satisfied (not fixed - satisfied)
+*/
+
+class CbcBranchToFixLots : public CbcBranchCut {
+
+public:
+  // Default Constructor
+  CbcBranchToFixLots();
+
+  /** Useful constructor - passed reduced cost tolerance and fraction we would like fixed.
+        Also depth level to do at.
+        Also passed number of 1 rows which when clean triggers fix
+        Always does if all 1 rows cleaned up and number>0 or if fraction columns reached
+        Also whether to create branch if can't reach fraction.
+    */
+  CbcBranchToFixLots(CbcModel *model, double djTolerance,
+    double fractionFixed, int depth,
+    int numberClean = 0,
+    const char *mark = NULL,
+    bool alwaysCreate = false);
+
+  // Copy constructor
+  CbcBranchToFixLots(const CbcBranchToFixLots &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcBranchToFixLots &operator=(const CbcBranchToFixLots &rhs);
+
+  // Destructor
+  ~CbcBranchToFixLots();
+
+  /** Does a lot of the work,
+        Returns 0 if no good, 1 if dj, 2 if clean, 3 if both
+	FIXME: should use enum or equivalent to make these numbers clearer.
+    */
+  int shallWe() const;
+
+  /// Infeasibility for an integer variable - large is 0.5, but also can be infinity when known infeasible.
+  virtual double infeasibility(const OsiBranchingInformation *info,
+    int &preferredWay) const;
+  /** \brief Return true if object can take part in normal heuristics
+    */
+  virtual bool canDoHeuristics() const
+  {
+    return true;
+  }
+
+  /// Creates a branching object
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way);
+  /// Redoes data when sequence numbers change
+  virtual void redoSequenceEtc(CbcModel *model, int numberColumns, const int *originalColumns);
+
+protected:
+  /// data
+
+  /// Reduced cost tolerance i.e. dj has to be >= this before fixed
+  double djTolerance_;
+  /// We only need to make sure this fraction fixed
+  double fractionFixed_;
+  /// Never fix ones marked here
+  char *mark_;
+  /// Matrix by row
+  CoinPackedMatrix matrixByRow_;
+  /// Do if depth multiple of this
+  int depth_;
+  /// number of ==1 rows which need to be clean
+  int numberClean_;
+  /// If true then always create branch
+  bool alwaysCreate_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchingObject.hpp

@@ -0,0 +1,245 @@
+// $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 CbcBranchingObject_H
+#define CbcBranchingObject_H
+
+#include <string>
+#include <vector>
+#include "CbcBranchBase.hpp"
+#include "OsiBranchingObject.hpp"
+
+// The types of objects that will be derived from this class.
+enum CbcBranchObjType {
+  SimpleIntegerBranchObj = 100,
+  SimpleIntegerDynamicPseudoCostBranchObj = 101,
+  CliqueBranchObj = 102,
+  LongCliqueBranchObj = 103,
+  SoSBranchObj = 104,
+  NWayBranchObj = 105,
+  FollowOnBranchObj = 106,
+  DummyBranchObj = 107,
+  GeneralDepthBranchObj = 108,
+  OneGeneralBranchingObj = 110,
+  CutBranchingObj = 200,
+  LotsizeBranchObj = 300,
+  DynamicPseudoCostBranchObj = 400
+};
+
+/** \brief Abstract branching object base class
+    Now just difference with OsiBranchingObject
+
+  In the abstract, an CbcBranchingObject contains instructions for how to
+  branch. We want an abstract class so that we can describe how to branch on
+  simple objects (<i>e.g.</i>, integers) and more exotic objects
+  (<i>e.g.</i>, cliques or hyperplanes).
+
+  The #branch() method is the crucial routine: it is expected to be able to
+  step through a set of branch arms, executing the actions required to create
+  each subproblem in turn. The base class is primarily virtual to allow for
+  a wide range of problem modifications.
+
+  See CbcObject for an overview of the three classes (CbcObject,
+  CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching
+  model.
+*/
+
+class CbcBranchingObject : public OsiBranchingObject {
+
+public:
+  /// Default Constructor
+  CbcBranchingObject();
+
+  /// Constructor
+  CbcBranchingObject(CbcModel *model, int variable, int way, double value);
+
+  /// Copy constructor
+  CbcBranchingObject(const CbcBranchingObject &);
+
+  /// Assignment operator
+  CbcBranchingObject &operator=(const CbcBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const = 0;
+
+  /// Destructor
+  virtual ~CbcBranchingObject();
+
+  /** Some branchingObjects may claim to be able to skip
+        strong branching.  If so they have to fill in CbcStrongInfo.
+        The object mention in incoming CbcStrongInfo must match.
+        Returns nonzero if skip is wanted */
+  virtual int fillStrongInfo(CbcStrongInfo &)
+  {
+    return 0;
+  }
+  /// Reset number of branches left to original
+  inline void resetNumberBranchesLeft()
+  {
+    branchIndex_ = 0;
+  }
+  /// Set number of branches to do
+  inline void setNumberBranches(int value)
+  {
+    branchIndex_ = 0;
+    numberBranches_ = value;
+  }
+
+  /** \brief Execute the actions required to branch, as specified by the
+           current state of the branching object, and advance the object's
+           state.  Mainly for diagnostics, whether it is true branch or
+           strong branching is also passed.
+           Returns change in guessed objective on next branch
+    */
+  virtual double branch() = 0;
+  /** \brief Execute the actions required to branch, as specified by the
+           current state of the branching object, and advance the object's
+           state.  Mainly for diagnostics, whether it is true branch or
+           strong branching is also passed.
+           Returns change in guessed objective on next branch
+    */
+  virtual double branch(OsiSolverInterface *)
+  {
+    return branch();
+  }
+  /** Update bounds in solver as in 'branch' and update given bounds.
+        branchState is -1 for 'down' +1 for 'up' */
+  virtual void fix(OsiSolverInterface *,
+    double *, double *,
+    int) const {}
+
+  /** Change (tighten) bounds in object to reflect bounds in solver.
+	Return true if now fixed */
+  virtual bool tighten(OsiSolverInterface *) { return false; }
+
+  /** Reset every information so that the branching object appears to point to
+        the previous child. This method does not need to modify anything in any
+        solver. */
+  virtual void previousBranch()
+  {
+    assert(branchIndex_ > 0);
+    branchIndex_--;
+    way_ = -way_;
+  }
+
+  using OsiBranchingObject::print;
+  /** \brief Print something about branch - only if log level high
+    */
+  virtual void print() const {}
+
+  /** \brief Index identifying the associated CbcObject within its class.
+
+      The name is misleading, and typically the index will <i>not</i> refer
+      directly to a variable.
+      Rather, it identifies an CbcObject within the class of similar
+      CbcObjects
+
+      <i>E.g.</i>, for an CbcSimpleInteger, variable() is the index of the
+      integer variable in the set of integer variables (<i>not</i> the index of
+      the variable in the set of all variables).
+    */
+  inline int variable() const
+  {
+    return variable_;
+  }
+
+  /** Get the state of the branching object
+
+      Returns a code indicating the active arm of the branching object.
+      The precise meaning is defined in the derived class.
+
+      \sa #way_
+    */
+  inline int way() const
+  {
+    return way_;
+  }
+
+  /** Set the state of the branching object.
+
+      See #way()
+    */
+  inline void way(int way)
+  {
+    way_ = way;
+  }
+
+  /// update model
+  inline void setModel(CbcModel *model)
+  {
+    model_ = model;
+  }
+  /// Return model
+  inline CbcModel *model() const
+  {
+    return model_;
+  }
+
+  /// Return pointer back to object which created
+  inline CbcObject *object() const
+  {
+    return originalCbcObject_;
+  }
+  /// Set pointer back to object which created
+  inline void setOriginalObject(CbcObject *object)
+  {
+    originalCbcObject_ = object;
+  }
+
+  // Methods used in heuristics
+
+  /** Return the type (an integer identifier) of \c this.
+        See definition of CbcBranchObjType above for possibilities
+    */
+
+  virtual CbcBranchObjType type() const = 0;
+
+  /** 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
+  {
+    const CbcBranchingObject *br = dynamic_cast< const CbcBranchingObject * >(brObj);
+    return variable() - br->variable();
+  }
+
+  /** Compare the \c this with \c brObj. \c this and \c brObj must be of 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) = 0;
+
+protected:
+  /// The model that owns this branching object
+  CbcModel *model_;
+  /// Pointer back to object which created
+  CbcObject *originalCbcObject_;
+
+  /// Branching variable (0 is first integer)
+  int variable_;
+  // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second)
+  /** The state of the branching object.
+
+      Specifies the active arm of the branching object. Coded as -1 to take
+      the `down' arm, +1 for the `up' arm. `Down' and `up' are defined based on
+      the natural meaning (floor and ceiling, respectively) for a simple integer.
+      The precise meaning is defined in the derived class.
+    */
+  int way_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcClique.hpp

@@ -0,0 +1,309 @@
+// $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/9/2009-- carved out of CbcBranchActual
+
+#ifndef CbcClique_H
+#define CbcClique_H
+
+/** \brief Branching object for cliques
+
+  A clique is defined to be a set of binary variables where fixing any one
+  variable to its `strong' value fixes all other variables. An example is the
+  most common SOS1 construction: a set of binary variables x_j s.t.  SUM{j}
+  x_j = 1.  Setting any one variable to 1 forces all other variables to 0.
+  (See comments for CbcSOS below.)
+
+  Other configurations are possible, however: Consider x1-x2+x3 <= 0.
+  Setting x1 (x3) to 1 forces x2 to 1 and x3 (x1) to 0. Setting x2 to 0
+  forces x1 and x3 to 0.
+
+  The proper point of view to take when interpreting CbcClique is
+  `generalisation of SOS1 on binary variables.' To get into the proper frame
+  of mind, here's an example.
+  
+  Consider the following sequence, where x_j = (1-y_j):
+  \verbatim
+     x1 + x2 + x3 <=  1		all strong at 1
+     x1 - y2 + x3 <=  0		y2 strong at 0; x1, x3 strong at 1
+    -y1 - y2 + x3 <= -1		y1, y2 strong at 0, x3 strong at 1
+    -y1 - y2 - y3 <= -2		all strong at 0
+  \endverbatim
+  The first line is a standard SOS1 on binary variables.
+  
+  Variables with +1 coefficients are `SOS-style' and variables with -1
+  coefficients are `non-SOS-style'. So #numberNonSOSMembers_ simply tells you
+  how many variables have -1 coefficients. The implicit rhs for a clique is
+  1-numberNonSOSMembers_.
+*/
+class CbcClique : public CbcObject {
+
+public:
+  /// Default Constructor
+  CbcClique();
+
+  /** Useful constructor (which are integer indices) slack can denote a slack
+	in set.  If type == NULL then as if 1
+    */
+  CbcClique(CbcModel *model, int cliqueType, int numberMembers,
+    const int *which, const char *type,
+    int identifier, int slack = -1);
+
+  /// Copy constructor
+  CbcClique(const CbcClique &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  /// Assignment operator
+  CbcClique &operator=(const CbcClique &rhs);
+
+  /// Destructor
+  virtual ~CbcClique();
+
+  /// 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);
+  /// Number of members
+  inline int numberMembers() const
+  {
+    return numberMembers_;
+  }
+  /** \brief Number of variables with -1 coefficient
+      
+      Number of non-SOS members, i.e., fixing to zero is strong.
+      See comments at head of class, and comments for #type_.
+    */
+  inline int numberNonSOSMembers() const
+  {
+    return numberNonSOSMembers_;
+  }
+
+  /// Members (indices in range 0 ... numberIntegers_-1)
+  inline const int *members() const
+  {
+    return members_;
+  }
+
+  /*! \brief Type of each member, i.e., which way is strong.
+  
+      This also specifies whether a variable has a +1 or -1 coefficient.
+	- 0 => -1 coefficient, 0 is strong value
+	- 1 => +1 coefficient, 1 is strong value
+      If unspecified, all coefficients are assumed to be positive.
+      
+      Indexed as 0 .. numberMembers_-1
+    */
+  inline char type(int index) const
+  {
+    if (type_)
+      return type_[index];
+    else
+      return 1;
+  }
+
+  /// Clique type: 0 is <=, 1 is ==
+  inline int cliqueType() const
+  {
+    return cliqueType_;
+  }
+  /// Redoes data when sequence numbers change
+  virtual void redoSequenceEtc(CbcModel *model, int numberColumns, const int *originalColumns);
+
+protected:
+  /// data
+  /// Number of members
+  int numberMembers_;
+
+  /// Number of Non SOS members i.e. fixing to zero is strong
+  int numberNonSOSMembers_;
+
+  /// Members (indices in range 0 ... numberIntegers_-1)
+  int *members_;
+
+  /** \brief Strong value for each member.
+
+      This also specifies whether a variable has a +1 or -1 coefficient.
+        - 0 => -1 coefficient, 0 is strong value
+        - 1 => +1 coefficient, 1 is strong value
+      If unspecified, all coefficients are assumed to be positive.
+    
+      Indexed as 0 .. numberMembers_-1
+    */
+  char *type_;
+
+  /** \brief Clique type
+
+      0 defines a <= relation, 1 an equality. The assumed value of the rhs is
+      numberNonSOSMembers_+1. (See comments for the class.)
+    */
+  int cliqueType_;
+
+  /** \brief Slack variable for the clique
+  
+      Identifies the slack variable for the clique (typically added to convert
+      a <= relation to an equality). Value is sequence number within clique
+      menbers.
+    */
+  int slack_;
+};
+
+/** Branching object for unordered cliques
+
+    Intended for cliques which are long enough to make it worthwhile
+    but <= 64 members.  There will also be ones for long cliques.
+
+    Variable_ is the clique id number (redundant, as the object also holds a
+    pointer to the clique.
+ */
+class CbcCliqueBranchingObject : public CbcBranchingObject {
+
+public:
+  // Default Constructor
+  CbcCliqueBranchingObject();
+
+  // Useful constructor
+  CbcCliqueBranchingObject(CbcModel *model, const CbcClique *clique,
+    int way,
+    int numberOnDownSide, const int *down,
+    int numberOnUpSide, const int *up);
+
+  // Copy constructor
+  CbcCliqueBranchingObject(const CbcCliqueBranchingObject &);
+
+  // Assignment operator
+  CbcCliqueBranchingObject &operator=(const CbcCliqueBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  // Destructor
+  virtual ~CbcCliqueBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /// Does next branch and updates state
+  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 CliqueBranchObj;
+  }
+
+  /** 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 of 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);
+
+private:
+  /// data
+  const CbcClique *clique_;
+  /// downMask - bit set to fix to weak bounds, not set to leave unfixed
+  unsigned int downMask_[2];
+  /// upMask - bit set to fix to weak bounds, not set to leave unfixed
+  unsigned int upMask_[2];
+};
+
+/** Unordered Clique Branching Object class.
+    These are for cliques which are > 64 members
+    Variable is number of clique.
+ */
+class CbcLongCliqueBranchingObject : public CbcBranchingObject {
+
+public:
+  // Default Constructor
+  CbcLongCliqueBranchingObject();
+
+  // Useful constructor
+  CbcLongCliqueBranchingObject(CbcModel *model, const CbcClique *clique,
+    int way,
+    int numberOnDownSide, const int *down,
+    int numberOnUpSide, const int *up);
+
+  // Copy constructor
+  CbcLongCliqueBranchingObject(const CbcLongCliqueBranchingObject &);
+
+  // Assignment operator
+  CbcLongCliqueBranchingObject &operator=(const CbcLongCliqueBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  // Destructor
+  virtual ~CbcLongCliqueBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /// Does next branch and updates state
+  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 LongCliqueBranchObj;
+  }
+
+  /** 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);
+
+private:
+  /// data
+  const CbcClique *clique_;
+  /// downMask - bit set to fix to weak bounds, not set to leave unfixed
+  unsigned int *downMask_;
+  /// upMask - bit set to fix to weak bounds, not set to leave unfixed
+  unsigned int *upMask_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompare.hpp

@@ -0,0 +1,46 @@
+/* $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 CbcCompare_H
+#define CbcCompare_H
+
+class CbcCompareBase;
+
+class CbcCompare {
+public:
+  CbcCompareBase *test_;
+  // Default Constructor
+  CbcCompare()
+  {
+    test_ = NULL;
+  }
+
+  virtual ~CbcCompare() {}
+
+  bool operator()(CbcNode *x, CbcNode *y)
+  {
+    return test_->test(x, y);
+  }
+  bool compareNodes(CbcNode *x, CbcNode *y)
+  {
+    return test_->test(x, y);
+  }
+  /// This is alternate test function
+  inline bool alternateTest(CbcNode *x, CbcNode *y)
+  {
+    return test_->alternateTest(x, y);
+  }
+
+  /// return comparison object
+  inline CbcCompareBase *comparisonObject() const
+  {
+    return test_;
+  }
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCompareActual.hpp

@@ -0,0 +1,16 @@
+/* $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 CbcCompareActual_H
+#define CbcCompareActual_H
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+#include "CbcCompareDepth.hpp"
+#include "CbcCompareDefault.hpp"
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/