casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcFixVariable.hpp

@@ -0,0 +1,68 @@
+// $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 CbcFixVariable_H
+#define CbcFixVariable_H
+
+#include "CbcBranchBase.hpp"
+/** 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.
+
+    A state of -9999 means at LB, +9999 means at UB,
+    others mean if fixed to that value.
+
+ */
+
+class CbcFixVariable : public CbcConsequence {
+
+public:
+  // Default Constructor
+  CbcFixVariable();
+
+  // One useful Constructor
+  CbcFixVariable(int numberStates, const int *states, const int *numberNewLower, const int **newLowerValue,
+    const int **lowerColumn,
+    const int *numberNewUpper, const int **newUpperValue,
+    const int **upperColumn);
+
+  // Copy constructor
+  CbcFixVariable(const CbcFixVariable &rhs);
+
+  // Assignment operator
+  CbcFixVariable &operator=(const CbcFixVariable &rhs);
+
+  /// Clone
+  virtual CbcConsequence *clone() const;
+
+  /// Destructor
+  virtual ~CbcFixVariable();
+
+  /** Apply to an LP solver.  Action depends on state
+     */
+  virtual void applyToSolver(OsiSolverInterface *solver, int state) const;
+
+protected:
+  /// Number of states
+  int numberStates_;
+  /// Values of integers for various states
+  int *states_;
+  /// Start of information for each state (setting new lower)
+  int *startLower_;
+  /// Start of information for each state (setting new upper)
+  int *startUpper_;
+  /// For each variable new bounds
+  double *newBound_;
+  /// Variable
+  int *variable_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcFollowOn.hpp

@@ -0,0 +1,207 @@
+// $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 CbcFollowOn_H
+#define CbcFollowOn_H
+
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinHelperFunctions.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Define a follow on class.
+    The idea of this is that in air-crew scheduling problems crew may fly in on flight A
+    and out on flight B or on some other flight.  A useful branch is one which on one side
+    fixes all which go out on flight B to 0, while the other branch fixes all those that do NOT
+    go out on flight B to 0.
+
+    This branching rule should be in addition to normal rules and have a high priority.
+*/
+
+class CbcFollowOn : public CbcObject {
+
+public:
+  // Default Constructor
+  CbcFollowOn();
+
+  /** Useful constructor
+    */
+  CbcFollowOn(CbcModel *model);
+
+  // Copy constructor
+  CbcFollowOn(const CbcFollowOn &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcFollowOn &operator=(const CbcFollowOn &rhs);
+
+  // Destructor
+  ~CbcFollowOn();
+
+  /// 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);
+  /// As some computation is needed in more than one place - returns row
+  virtual int gutsOfFollowOn(int &otherRow, int &preferredWay) const;
+
+protected:
+  /// data
+  /// Matrix
+  CoinPackedMatrix matrix_;
+  /// Matrix by row
+  CoinPackedMatrix matrixByRow_;
+  /// Possible rhs (if 0 then not possible)
+  int *rhs_;
+};
+
+/** General Branching Object class.
+    Each way fixes some variables to lower bound
+ */
+class CbcFixingBranchingObject : public CbcBranchingObject {
+
+public:
+  // Default Constructor
+  CbcFixingBranchingObject();
+
+  // Useful constructor
+  CbcFixingBranchingObject(CbcModel *model,
+    int way,
+    int numberOnDownSide, const int *down,
+    int numberOnUpSide, const int *up);
+
+  // Copy constructor
+  CbcFixingBranchingObject(const CbcFixingBranchingObject &);
+
+  // Assignment operator
+  CbcFixingBranchingObject &operator=(const CbcFixingBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  // Destructor
+  virtual ~CbcFixingBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /// Does next branch and updates state
+  virtual double branch();
+
+#ifdef JJF_ZERO
+  // No need to override. Default works fine.
+  /** 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();
+#endif
+
+  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 FollowOnBranchObj;
+  }
+
+  /** 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
+  /// Number on down list
+  int numberDown_;
+  /// Number on up list
+  int numberUp_;
+  /// downList - variables to fix to lb on down branch
+  int *downList_;
+  /// upList - variables to fix to lb on up branch
+  int *upList_;
+};
+
+/** Define an idiotic idea class.
+    The idea of this is that we take some integer variables away from integer and
+    sum them with some randomness to get signed sum close to 0.5.  We then can
+    branch to exclude that gap.
+
+    This branching rule should be in addition to normal rules and have a high priority.
+*/
+
+class CbcIdiotBranch : public CbcObject {
+
+public:
+  // Default Constructor
+  CbcIdiotBranch();
+
+  /** Useful constructor
+    */
+  CbcIdiotBranch(CbcModel *model);
+
+  // Copy constructor
+  CbcIdiotBranch(const CbcIdiotBranch &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcIdiotBranch &operator=(const CbcIdiotBranch &rhs);
+
+  // Destructor
+  ~CbcIdiotBranch();
+
+  /// 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);
+  /// Initialize for branching
+  virtual void initializeForBranching(CbcModel *);
+
+protected:
+  /// Build "cut"
+  OsiRowCut buildCut(const OsiBranchingInformation *info, int type, int &preferredWay) const;
+  /// data
+  /// Thread specific random number generator
+  mutable CoinThreadRandom randomNumberGenerator_;
+  /// Saved version of thread specific random number generator
+  mutable CoinThreadRandom savedRandomNumberGenerator_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcFullNodeInfo.hpp

@@ -0,0 +1,171 @@
+// $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 from CbcNode
+
+#ifndef CbcFullNodeInfo_H
+#define CbcFullNodeInfo_H
+
+#include <string>
+#include <vector>
+
+#include "CoinWarmStartBasis.hpp"
+#include "CoinSearchTree.hpp"
+#include "CbcBranchBase.hpp"
+#include "CbcNodeInfo.hpp"
+
+class OsiSolverInterface;
+class OsiSolverBranch;
+
+class OsiCuts;
+class OsiRowCut;
+class OsiRowCutDebugger;
+class CoinWarmStartBasis;
+class CbcCountRowCut;
+class CbcModel;
+class CbcNode;
+class CbcSubProblem;
+class CbcGeneralBranchingObject;
+
+//#############################################################################
+/** Information required to recreate the subproblem at this node
+
+  When a subproblem is initially created, it is represented by a CbcNode
+  object and an attached CbcNodeInfo object.
+
+  The CbcNode contains information needed while the subproblem remains live.
+  The CbcNode is deleted when the last branch arm has been evaluated.
+
+  The CbcNodeInfo contains information required to maintain the branch-and-cut
+  search tree structure (links and reference counts) and to recreate the
+  subproblem for this node (basis, variable bounds, cutting planes). A
+  CbcNodeInfo object remains in existence until all nodes have been pruned from
+  the subtree rooted at this node.
+
+  The principle used to maintain the reference count is that the reference
+  count is always the sum of all potential and actual children of the node.
+  Specifically,
+  <ul>
+    <li> Once it's determined how the node will branch, the reference count
+	 is set to the number of potential children (<i>i.e.</i>, the number
+	 of arms of the branch).
+    <li> As each child is created by CbcNode::branch() (converting a potential
+	 child to the active subproblem), the reference count is decremented.
+    <li> If the child survives and will become a node in the search tree
+	 (converting the active subproblem into an actual child), increment the
+	 reference count.
+  </ul>
+  Notice that the active subproblem lives in a sort of limbo, neither a
+  potential or an actual node in the branch-and-cut tree.
+
+  CbcNodeInfo objects come in two flavours. A CbcFullNodeInfo object contains
+  a full record of the information required to recreate a subproblem.
+  A CbcPartialNodeInfo object expresses this information in terms of
+  differences from the parent.
+*/
+
+/** \brief Holds complete information for recreating a subproblem.
+
+  A CbcFullNodeInfo object contains all necessary information (bounds, basis,
+  and cuts) required to recreate a subproblem.
+
+  \todo While there's no explicit statement, the code often makes the implicit
+	assumption that an CbcFullNodeInfo structure will appear only at the
+	root node of the search tree. Things will break if this assumption
+	is violated.
+*/
+
+class CbcFullNodeInfo : public CbcNodeInfo {
+
+public:
+  /** \brief Modify model according to information at node
+
+        The routine modifies the model according to bound information at node,
+        creates a new basis according to information at node, but with the size
+        passed in through basis, and adds any cuts to the addCuts array.
+
+      \note The basis passed in via basis is solely a vehicle for passing in
+        the desired basis size. It will be deleted and a new basis returned.
+    */
+  virtual void applyToModel(CbcModel *model, CoinWarmStartBasis *&basis,
+    CbcCountRowCut **addCuts,
+    int &currentNumberCuts) const;
+
+  /// Just apply bounds to one variable - force means overwrite by lower,upper (1=>infeasible)
+  virtual int applyBounds(int iColumn, double &lower, double &upper, int force);
+
+  /** Builds up row basis backwards (until original model).
+        Returns NULL or previous one to apply .
+        Depends on Free being 0 and impossible for cuts
+    */
+  virtual CbcNodeInfo *buildRowBasis(CoinWarmStartBasis &basis) const;
+  // Default Constructor
+  CbcFullNodeInfo();
+
+  /** Constructor from continuous or satisfied
+    */
+  CbcFullNodeInfo(CbcModel *model,
+    int numberRowsAtContinuous);
+
+  // Copy constructor
+  CbcFullNodeInfo(const CbcFullNodeInfo &);
+
+  // Destructor
+  ~CbcFullNodeInfo();
+
+  /// Clone
+  virtual CbcNodeInfo *clone() const;
+  /// Lower bounds
+  inline const double *lower() const
+  {
+    return lower_;
+  }
+  /// Set a bound
+  inline void setColLower(int sequence, double value)
+  {
+    lower_[sequence] = value;
+  }
+  /// Mutable lower bounds
+  inline double *mutableLower() const
+  {
+    return lower_;
+  }
+  /// Upper bounds
+  inline const double *upper() const
+  {
+    return upper_;
+  }
+  /// Set a bound
+  inline void setColUpper(int sequence, double value)
+  {
+    upper_[sequence] = value;
+  }
+  /// Mutable upper bounds
+  inline double *mutableUpper() const
+  {
+    return upper_;
+  }
+
+protected:
+  // Data
+  /** Full basis
+
+      This MUST BE A POINTER to avoid cutting extra information in derived
+      warm start classes.
+    */
+  CoinWarmStartBasis *basis_;
+  int numberIntegers_;
+  // Bounds stored in full
+  double *lower_;
+  double *upper_;
+
+private:
+  /// Illegal Assignment operator
+  CbcFullNodeInfo &operator=(const CbcFullNodeInfo &rhs);
+};
+#endif //CbcFullNodeInfo_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcGeneral.hpp

@@ -0,0 +1,60 @@
+// $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 CbcGeneral_H
+#define CbcGeneral_H
+
+#include "CbcBranchBase.hpp"
+/** Define a catch all class.
+    This will create a list of subproblems
+*/
+
+class CbcGeneral : public CbcObject {
+
+public:
+  // Default Constructor
+  CbcGeneral();
+
+  /** Useful constructor
+        Just needs to point to model.
+    */
+  CbcGeneral(CbcModel *model);
+
+  // Copy constructor
+  CbcGeneral(const CbcGeneral &);
+
+  /// Clone
+  virtual CbcObject *clone() const = 0;
+
+  // Assignment operator
+  CbcGeneral &operator=(const CbcGeneral &rhs);
+
+  // Destructor
+  ~CbcGeneral();
+
+  /// 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() = 0;
+
+  /// 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) = 0;
+
+protected:
+  /// data
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/