casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcNodeInfo.hpp

@@ -0,0 +1,377 @@
+// $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 CbcNodeInfo_H
+#define CbcNodeInfo_H
+
+#include <string>
+#include <vector>
+
+#include "CoinWarmStartBasis.hpp"
+#include "CoinSearchTree.hpp"
+#include "CbcBranchBase.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.
+*/
+
+class CbcNodeInfo {
+
+public:
+  /** \name Constructors & destructors */
+  //@{
+  /** Default Constructor
+
+      Creates an empty NodeInfo object.
+    */
+  CbcNodeInfo();
+
+  /// Copy constructor
+  CbcNodeInfo(const CbcNodeInfo &);
+
+#ifdef JJF_ZERO
+  /** Construct with parent
+
+      Creates a NodeInfo object which knows its parent and assumes it will
+      in turn have two children.
+    */
+  CbcNodeInfo(CbcNodeInfo *parent);
+#endif
+
+  /** Construct with parent and owner
+
+      As for `construct with parent', and attached to \p owner.
+    */
+  CbcNodeInfo(CbcNodeInfo *parent, CbcNode *owner);
+
+  /** Destructor
+
+      Note that the destructor will recursively delete the parent if this
+      nodeInfo is the last child.
+    */
+  virtual ~CbcNodeInfo();
+  //@}
+
+  /** \brief Modify model according to information at node
+
+        The routine modifies the model according to bound and basis
+        information at node and adds any cuts to the addCuts array.
+    */
+  virtual void applyToModel(CbcModel *model, CoinWarmStartBasis *&basis,
+    CbcCountRowCut **addCuts,
+    int &currentNumberCuts) const = 0;
+  /// 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) = 0;
+
+  /** 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 = 0;
+  /// Clone
+  virtual CbcNodeInfo *clone() const = 0;
+  /// Called when number branches left down to zero
+  virtual void allBranchesGone() {}
+#ifndef JJF_ONE
+  /// Increment number of references
+  inline void increment(int amount = 1)
+  {
+    numberPointingToThis_ += amount; /*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/
+  }
+
+  /// Decrement number of references and return number left
+  inline int decrement(int amount = 1)
+  {
+    numberPointingToThis_ -= amount; /*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/
+    return numberPointingToThis_;
+  }
+#else
+  /// Increment number of references
+  void increment(int amount = 1);
+  /// Decrement number of references and return number left
+  int decrement(int amount = 1);
+#endif
+  /** Initialize reference counts
+
+      Initialize the reference counts used for tree maintenance.
+    */
+
+  inline void initializeInfo(int number)
+  {
+    numberPointingToThis_ = number;
+    numberBranchesLeft_ = number;
+  }
+
+  /// Return number of branches left in object
+  inline int numberBranchesLeft() const
+  {
+    return numberBranchesLeft_;
+  }
+
+  /// Set number of branches left in object
+  inline void setNumberBranchesLeft(int value)
+  {
+    numberBranchesLeft_ = value;
+  }
+
+  /// Return number of objects pointing to this
+  inline int numberPointingToThis() const
+  {
+    return numberPointingToThis_;
+  }
+
+  /// Set number of objects pointing to this
+  inline void setNumberPointingToThis(int number)
+  {
+    numberPointingToThis_ = number;
+  }
+
+  /// Increment number of objects pointing to this
+  inline void incrementNumberPointingToThis()
+  {
+    numberPointingToThis_++;
+  }
+
+  /// Say one branch taken
+  inline int branchedOn()
+  {
+    numberPointingToThis_--;
+    numberBranchesLeft_--;
+    return numberBranchesLeft_;
+  }
+
+  /// Say thrown away
+  inline void throwAway()
+  {
+    numberPointingToThis_ -= numberBranchesLeft_;
+    numberBranchesLeft_ = 0;
+  }
+
+  /// Parent of this
+  CbcNodeInfo *parent() const
+  {
+    return parent_;
+  }
+  /// Set parent null
+  inline void nullParent()
+  {
+    parent_ = NULL;
+  }
+
+  void addCuts(OsiCuts &cuts, int numberToBranch, //int * whichGenerator,
+    int numberPointingToThis);
+  void addCuts(int numberCuts, CbcCountRowCut **cuts, int numberToBranch);
+  /** Delete cuts (decrements counts)
+        Slow unless cuts in same order as saved
+    */
+  void deleteCuts(int numberToDelete, CbcCountRowCut **cuts);
+  void deleteCuts(int numberToDelete, int *which);
+
+  /// Really delete a cut
+  void deleteCut(int whichOne);
+
+  /// Decrement active cut counts
+  void decrementCuts(int change = 1);
+
+  /// Increment active cut counts
+  void incrementCuts(int change = 1);
+
+  /// Decrement all active cut counts in chain starting at parent
+  void decrementParentCuts(CbcModel *model, int change = 1);
+
+  /// Increment all active cut counts in parent chain
+  void incrementParentCuts(CbcModel *model, int change = 1);
+
+  /// Array of pointers to cuts
+  inline CbcCountRowCut **cuts() const
+  {
+    return cuts_;
+  }
+
+  /// Number of row cuts (this node)
+  inline int numberCuts() const
+  {
+    return numberCuts_;
+  }
+  inline void setNumberCuts(int value)
+  {
+    numberCuts_ = value;
+  }
+
+  /// Set owner null
+  inline void nullOwner()
+  {
+    owner_ = NULL;
+  }
+  const inline CbcNode *owner() const
+  {
+    return owner_;
+  }
+  inline CbcNode *mutableOwner() const
+  {
+    return owner_;
+  }
+  /// The node number
+  inline int nodeNumber() const
+  {
+    return nodeNumber_;
+  }
+  inline void setNodeNumber(int node)
+  {
+    nodeNumber_ = node;
+  }
+  /** Deactivate node information.
+        1 - bounds
+        2 - cuts
+        4 - basis!
+	8 - just marked
+	16 - symmetry branching worked
+    */
+  void deactivate(int mode = 3);
+  /// Say if normal
+  inline bool allActivated() const
+  {
+    return ((active_ & 7) == 7);
+  }
+  /// Say if marked
+  inline bool marked() const
+  {
+    return ((active_ & 8) != 0);
+  }
+  /// Mark
+  inline void mark()
+  {
+    active_ |= 8;
+  }
+  /// Unmark
+  inline void unmark()
+  {
+    active_ &= ~8;
+  }
+  /// Get symmetry value (true worked at this node)
+  inline bool symmetryWorked() const
+  {
+    return (active_ & 16) != 0;
+  }
+  /// Say symmetry worked at this node)
+  inline void setSymmetryWorked()
+  {
+    active_ |= 16;
+  }
+
+  /// Branching object for the parent
+  inline const OsiBranchingObject *parentBranch() const
+  {
+    return parentBranch_;
+  }
+  /// If we need to take off parent based data
+  void unsetParentBasedData();
+
+protected:
+  /** Number of other nodes pointing to this node.
+
+      Number of existing and potential search tree nodes pointing to this node.
+      `Existing' means referenced by #parent_ of some other CbcNodeInfo.
+      `Potential' means children still to be created (#numberBranchesLeft_ of
+      this CbcNodeInfo).
+    */
+  int numberPointingToThis_;
+
+  /// parent
+  CbcNodeInfo *parent_;
+
+  /// Copy of the branching object of the parent when the node is created
+  OsiBranchingObject *parentBranch_;
+
+  /// Owner
+  CbcNode *owner_;
+
+  /// Number of row cuts (this node)
+  int numberCuts_;
+
+  /// The node number
+  int nodeNumber_;
+
+  /// Array of pointers to cuts
+  CbcCountRowCut **cuts_;
+
+  /** Number of rows in problem (before these cuts).  This
+        means that for top of chain it must be rows at continuous */
+  int numberRows_;
+
+  /** Number of branch arms left to explore at this node
+
+      \todo There seems to be redundancy between this field and
+        CbcBranchingObject::numberBranchesLeft_. It'd be good to sort out if
+        both are necessary.
+    */
+  int numberBranchesLeft_;
+  /** Active node information.
+        1 - bounds
+        2 - cuts
+        4 - basis!
+    */
+  int active_;
+
+private:
+  /// Illegal Assignment operator
+  CbcNodeInfo &operator=(const CbcNodeInfo &rhs);
+
+  /// routine common to constructors
+  void setParentBasedData();
+};
+
+#endif // CbcNodeInfo_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcObject.hpp

@@ -0,0 +1,288 @@
+// $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 CbcObject_H
+#define CbcObject_H
+
+#include <string>
+#include <vector>
+#include "OsiBranchingObject.hpp"
+class OsiSolverInterface;
+class OsiSolverBranch;
+
+class CbcModel;
+class CbcNode;
+class CbcNodeInfo;
+class CbcBranchingObject;
+class OsiChooseVariable;
+class CbcObjectUpdateData;
+//#############################################################################
+
+/** Abstract base class for `objects'.
+    It now just has stuff that OsiObject does not have
+
+  The branching model used in Cbc is based on the idea of an <i>object</i>.
+  In the abstract, an object is something that has a feasible region, can be
+  evaluated for infeasibility, can be branched on (<i>i.e.</i>, there's some
+  constructive action to be taken to move toward feasibility), and allows
+  comparison of the effect of branching.
+
+  This class (CbcObject) is the base class for an object. To round out the
+  branching model, the class CbcBranchingObject describes how to perform a
+  branch, and the class CbcBranchDecision describes how to compare two
+  CbcBranchingObjects.
+
+  To create a new type of object you need to provide three methods:
+  #infeasibility(), #feasibleRegion(), and #createCbcBranch(), described below.
+
+  This base class is primarily virtual to allow for any form of structure.
+  Any form of discontinuity is allowed.
+
+  \todo The notion that all branches are binary (two arms) is wired into the
+	implementation of CbcObject, CbcBranchingObject, and
+	CbcBranchDecision. Changing this will require a moderate amount of
+	recoding.
+ */
+// This can be used if object wants to skip strong branching
+typedef struct {
+  CbcBranchingObject *possibleBranch; // what a branch would do
+  double upMovement; // cost going up (and initial away from feasible)
+  double downMovement; // cost going down
+  int numIntInfeasUp; // without odd ones
+  int numObjInfeasUp; // just odd ones
+  bool finishedUp; // true if solver finished
+  int numItersUp; // number of iterations in solver
+  int numIntInfeasDown; // without odd ones
+  int numObjInfeasDown; // just odd ones
+  bool finishedDown; // true if solver finished
+  int numItersDown; // number of iterations in solver
+  int objectNumber; // Which object it is
+  int fix; // 0 if no fix, 1 if we can fix up, -1 if we can fix down
+} CbcStrongInfo;
+
+class CbcObject : public OsiObject {
+
+public:
+  // Default Constructor
+  CbcObject();
+
+  // Useful constructor
+  CbcObject(CbcModel *model);
+
+  // Copy constructor
+  CbcObject(const CbcObject &);
+
+  // Assignment operator
+  CbcObject &operator=(const CbcObject &rhs);
+
+  /// Clone
+  virtual CbcObject *clone() const = 0;
+
+  /// Destructor
+  virtual ~CbcObject();
+
+  /** Infeasibility of the object
+
+        This is some measure of the infeasibility of the object. It should be
+        scaled to be in the range [0.0, 0.5], with 0.0 indicating the object
+        is satisfied.
+
+        The preferred branching direction is returned in preferredWay,
+
+        This is used to prepare for strong branching but should also think of
+        case when no strong branching
+
+        The object may also compute an estimate of cost of going "up" or "down".
+        This will probably be based on pseudo-cost ideas
+    */
+#ifdef CBC_NEW_STYLE_BRANCH
+  virtual double infeasibility(const OsiBranchingInformation *info,
+    int &preferredWay) const = 0;
+#else
+  virtual double infeasibility(const OsiBranchingInformation * /*info*/,
+    int &preferredWay) const
+  {
+    return infeasibility(preferredWay);
+  }
+  virtual double infeasibility(int & /*preferredWay*/) const
+  {
+    throw CoinError("Need code", "infeasibility", "CbcBranchBase");
+  }
+#endif
+
+  /** For the variable(s) referenced by the object,
+        look at the current solution and set bounds to match the solution.
+    */
+  virtual void feasibleRegion() = 0;
+  /// Dummy one for compatibility
+  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const;
+
+  /** For the variable(s) referenced by the object,
+        look at the current solution and set bounds to match the solution.
+        Returns measure of how much it had to move solution to make feasible
+    */
+  virtual double feasibleRegion(OsiSolverInterface *solver) const;
+
+  /** Create a branching object and indicate which way to branch first.
+
+        The branching object has to know how to create branches (fix
+        variables, etc.)
+    */
+#ifdef CBC_NEW_STYLE_BRANCH
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) = 0;
+#else
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *
+    /* solver */,
+    const OsiBranchingInformation *
+    /* info */,
+    int /* way */)
+  {
+    // return createBranch(solver, info, way);
+    return NULL;
+  }
+  virtual OsiBranchingObject *createBranch(OsiSolverInterface * /*solver*/,
+    const OsiBranchingInformation * /*info*/, int /*way*/) const
+  {
+    throw CoinError("Need code", "createBranch", "CbcBranchBase");
+  }
+#endif
+  /** Create an Osibranching object and indicate which way to branch first.
+
+        The branching object has to know how to create branches (fix
+        variables, etc.)
+    */
+  virtual OsiBranchingObject *createOsiBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) const;
+  /** Create an OsiSolverBranch object
+
+        This returns NULL if branch not represented by bound changes
+    */
+  virtual OsiSolverBranch *solverBranch() const;
+
+  /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a good direction.
+
+        If the method cannot generate a feasible point (because there aren't
+        any, or because it isn't bright enough to find one), it should
+        return null.
+    */
+  virtual CbcBranchingObject *preferredNewFeasible() const
+  {
+    return NULL;
+  }
+
+  /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a bad direction.
+
+        If the method cannot generate a feasible point (because there aren't
+        any, or because it isn't bright enough to find one), it should
+        return null.
+    */
+  virtual CbcBranchingObject *notPreferredNewFeasible() const
+  {
+    return NULL;
+  }
+
+  /** Reset variable bounds to their original values.
+
+      Bounds may be tightened, so it may be good to be able to set this info in object.
+     */
+  virtual void resetBounds(const OsiSolverInterface *) {}
+
+  /** Returns floor and ceiling i.e. closest valid points
+    */
+  virtual void floorCeiling(double &floorValue, double &ceilingValue, double value,
+    double tolerance) const;
+
+  /** Pass in information on branch just done and create CbcObjectUpdateData instance.
+        If object does not need data then backward pointer will be NULL.
+        Assumes can get information from solver */
+  virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface *solver,
+    const CbcNode *node,
+    const CbcBranchingObject *branchingObject);
+
+  /// Update object by CbcObjectUpdateData
+  virtual void updateInformation(const CbcObjectUpdateData &) {}
+
+  /// Identifier (normally column number in matrix)
+  inline int id() const
+  {
+    return id_;
+  }
+
+  /** Set identifier (normally column number in matrix)
+        but 1000000000 to 1100000000 means optional branching object
+        i.e. code would work without it */
+  inline void setId(int value)
+  {
+    id_ = value;
+  }
+
+  /** Return true if optional branching object
+        i.e. code would work without it */
+  inline bool optionalObject() const
+  {
+    return (id_ >= 1000000000 && id_ < 1100000000);
+  }
+
+  /// Get position in object_ list
+  inline int position() const
+  {
+    return position_;
+  }
+
+  /// Set position in object_ list
+  inline void setPosition(int position)
+  {
+    position_ = position;
+  }
+
+  /// update model
+  inline void setModel(CbcModel *model)
+  {
+    model_ = model;
+  }
+
+  /// Return model
+  inline CbcModel *model() const
+  {
+    return model_;
+  }
+
+  /// If -1 down always chosen first, +1 up always, 0 normal
+  inline int preferredWay() const
+  {
+    return preferredWay_;
+  }
+  /// Set -1 down always chosen first, +1 up always, 0 normal
+  inline void setPreferredWay(int value)
+  {
+    preferredWay_ = value;
+  }
+  /// Redoes data when sequence numbers change
+  virtual void redoSequenceEtc(CbcModel *, int, const int *) {}
+  /// Initialize for branching
+  virtual void initializeForBranching(CbcModel *) {}
+
+protected:
+  /// data
+
+  /// Model
+  CbcModel *model_;
+  /// Identifier (normally column number in matrix)
+  int id_;
+  /// Position in object list
+  int position_;
+  /// If -1 down always chosen first, +1 up always, 0 normal
+  int preferredWay_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/