casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcBranchDecision.hpp

@@ -0,0 +1,135 @@
+// $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 CbcBranchDecision_H
+#define CbcBranchDecision_H
+
+#include "CbcBranchBase.hpp"
+
+/** Abstract branching decision base class
+
+  In the abstract, an CbcBranchDecision object is expected to be able to
+  compare two possible branching choices.
+
+  The #betterBranch() method is the crucial routine. It is expected to be able
+  to compare two \link CbcBranchingObject CbcBranchingObjects \endlink.
+
+  See CbcObject for an overview of the three classes (CbcObject,
+  CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching
+  model.
+*/
+class CbcModel;
+class OsiChooseVariable;
+
+class CbcBranchDecision {
+public:
+  /// Default Constructor
+  CbcBranchDecision();
+
+  // Copy constructor
+  CbcBranchDecision(const CbcBranchDecision &);
+
+  /// Destructor
+  virtual ~CbcBranchDecision();
+
+  /// Clone
+  virtual CbcBranchDecision *clone() const = 0;
+
+  /// Initialize <i>e.g.</i> before starting to choose a branch at a node
+  virtual void initialize(CbcModel *model) = 0;
+
+  /** \brief Compare two branching objects. Return nonzero if branching
+           using \p thisOne is better than branching using \p bestSoFar.
+
+      If \p bestSoFar is NULL, the routine should return a nonzero value.
+      This routine is used only after strong branching.
+      Either this or bestBranch is used depending which user wants.
+
+    */
+
+  virtual int
+  betterBranch(CbcBranchingObject *thisOne,
+    CbcBranchingObject *bestSoFar,
+    double changeUp, int numberInfeasibilitiesUp,
+    double changeDown, int numberInfeasibilitiesDown)
+    = 0;
+
+  /** \brief Compare N branching objects. Return index of best
+        and sets way of branching in chosen object.
+
+      Either this or betterBranch is used depending which user wants.
+    */
+
+  virtual int
+  bestBranch(CbcBranchingObject **objects, int numberObjects, int numberUnsatisfied,
+    double *changeUp, int *numberInfeasibilitiesUp,
+    double *changeDown, int *numberInfeasibilitiesDown,
+    double objectiveValue);
+
+  /** Says whether this method can handle both methods -
+        1 better, 2 best, 3 both */
+  virtual int whichMethod()
+  {
+    return 2;
+  }
+
+  /** Saves a clone of current branching object.  Can be used to update
+        information on object causing branch - after branch */
+  virtual void saveBranchingObject(OsiBranchingObject *) {}
+  /** Pass in information on branch just done.
+        assumes object can get information from solver */
+  virtual void updateInformation(OsiSolverInterface *,
+    const CbcNode *) {}
+  /** Sets or gets best criterion so far */
+  virtual void setBestCriterion(double) {}
+  virtual double getBestCriterion() const
+  {
+    return 0.0;
+  }
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *) {}
+  /// Model
+  inline CbcModel *cbcModel() const
+  {
+    return model_;
+  }
+  /* If chooseMethod_ id non-null then the rest is fairly pointless
+       as choosemethod_ will be doing all work
+     This comment makes more sense if you realise that there's a conversion in
+     process from the Cbc branching classes to Osi branching classes. The test
+     for use of the Osi branching classes is CbcModel::branchingMethod_
+     non-null (i.e., it points to one of these CbcBranchDecision objects) and
+     that branch decision object has an OsiChooseVariable method set. In which
+     case, we'll use it, rather than the choose[*]Variable methods defined in
+     CbcNode.
+	*/
+
+  OsiChooseVariable *chooseMethod() const
+  {
+    return chooseMethod_;
+  }
+  /// Set (clone) chooseMethod
+  void setChooseMethod(const OsiChooseVariable &method);
+
+protected:
+  // Clone of branching object
+  CbcBranchingObject *object_;
+  /// Pointer to model
+  CbcModel *model_;
+  /* If chooseMethod_ id non-null then the rest is fairly pointless
+       as choosemethod_ will be doing all work
+    */
+  OsiChooseVariable *chooseMethod_;
+
+private:
+  /// Assignment is illegal
+  CbcBranchDecision &operator=(const CbcBranchDecision &rhs);
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchDefaultDecision.hpp

@@ -0,0 +1,101 @@
+// $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 CbcBranchDefaultDecision_H
+#define CbcBranchDefaultDecision_H
+
+#include "CbcBranchBase.hpp"
+/** Branching decision default class
+
+  This class implements a simple default algorithm
+  (betterBranch()) for choosing a branching variable.
+*/
+
+class CbcBranchDefaultDecision : public CbcBranchDecision {
+public:
+  // Default Constructor
+  CbcBranchDefaultDecision();
+
+  // Copy constructor
+  CbcBranchDefaultDecision(const CbcBranchDefaultDecision &);
+
+  virtual ~CbcBranchDefaultDecision();
+
+  /// Clone
+  virtual CbcBranchDecision *clone() const;
+
+  /// Initialize, <i>e.g.</i> before the start of branch selection at a node
+  virtual void initialize(CbcModel *model);
+
+  /** \brief Compare two branching objects. Return nonzero if \p thisOne is
+           better than \p bestSoFar.
+
+      The routine compares branches using the values supplied in \p numInfUp and
+      \p numInfDn until a solution is found by search, after which it uses the
+      values supplied in \p changeUp and \p changeDn. The best branching object
+      seen so far and the associated parameter values are remembered in the
+      \c CbcBranchDefaultDecision object. The nonzero return value is +1 if the
+      up branch is preferred, -1 if the down branch is preferred.
+
+      As the names imply, the assumption is that the values supplied for
+      \p numInfUp and \p numInfDn will be the number of infeasibilities reported
+      by the branching object, and \p changeUp and \p changeDn will be the
+      estimated change in objective. Other measures can be used if desired.
+
+      Because an \c CbcBranchDefaultDecision object remembers the current best
+      branching candidate (#bestObject_) as well as the values used in the
+      comparison, the parameter \p bestSoFar is redundant, hence unused.
+    */
+  virtual int betterBranch(CbcBranchingObject *thisOne,
+    CbcBranchingObject *bestSoFar,
+    double changeUp, int numInfUp,
+    double changeDn, int numInfDn);
+  /** Sets or gets best criterion so far */
+  virtual void setBestCriterion(double value);
+  virtual double getBestCriterion() const;
+
+  /** \brief Compare N branching objects. Return index of best
+        and sets way of branching in chosen object.
+
+      This routine is used only after strong branching.
+    */
+
+  virtual int
+  bestBranch(CbcBranchingObject **objects, int numberObjects, int numberUnsatisfied,
+    double *changeUp, int *numberInfeasibilitiesUp,
+    double *changeDown, int *numberInfeasibilitiesDown,
+    double objectiveValue);
+
+private:
+  /// Illegal Assignment operator
+  CbcBranchDefaultDecision &operator=(const CbcBranchDefaultDecision &rhs);
+
+  /// data
+
+  /// "best" so far
+  double bestCriterion_;
+
+  /// Change up for best
+  double bestChangeUp_;
+
+  /// Number of infeasibilities for up
+  int bestNumberUp_;
+
+  /// Change down for best
+  double bestChangeDown_;
+
+  /// Pointer to best branching object
+  CbcBranchingObject *bestObject_;
+
+  /// Number of infeasibilities for down
+  int bestNumberDown_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchDynamic.hpp

@@ -0,0 +1,210 @@
+/* $Id$ */
+// Copyright (C) 2005, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcBranchDynamic_H
+#define CbcBranchDynamic_H
+
+#include "CoinPackedMatrix.hpp"
+#include "CbcSimpleIntegerDynamicPseudoCost.hpp"
+#include "CbcBranchActual.hpp"
+
+/** Branching decision dynamic class
+
+  This class implements a simple algorithm
+  (betterBranch()) for choosing a branching variable when dynamic pseudo costs.
+*/
+
+class CbcBranchDynamicDecision : public CbcBranchDecision {
+public:
+  // Default Constructor
+  CbcBranchDynamicDecision();
+
+  // Copy constructor
+  CbcBranchDynamicDecision(const CbcBranchDynamicDecision &);
+
+  virtual ~CbcBranchDynamicDecision();
+
+  /// Clone
+  virtual CbcBranchDecision *clone() const;
+
+  /// Initialize, <i>e.g.</i> before the start of branch selection at a node
+  virtual void initialize(CbcModel *model);
+
+  /** \brief Compare two branching objects. Return nonzero if \p thisOne is
+           better than \p bestSoFar.
+
+      The routine compares branches using the values supplied in \p numInfUp and
+      \p numInfDn until a solution is found by search, after which it uses the
+      values supplied in \p changeUp and \p changeDn. The best branching object
+      seen so far and the associated parameter values are remembered in the
+      \c CbcBranchDynamicDecision object. The nonzero return value is +1 if the
+      up branch is preferred, -1 if the down branch is preferred.
+
+      As the names imply, the assumption is that the values supplied for
+      \p numInfUp and \p numInfDn will be the number of infeasibilities reported
+      by the branching object, and \p changeUp and \p changeDn will be the
+      estimated change in objective. Other measures can be used if desired.
+
+      Because an \c CbcBranchDynamicDecision object remembers the current best
+      branching candidate (#bestObject_) as well as the values used in the
+      comparison, the parameter \p bestSoFar is redundant, hence unused.
+    */
+  virtual int betterBranch(CbcBranchingObject *thisOne,
+    CbcBranchingObject *bestSoFar,
+    double changeUp, int numInfUp,
+    double changeDn, int numInfDn);
+  /** Sets or gets best criterion so far */
+  virtual void setBestCriterion(double value);
+  virtual double getBestCriterion() const;
+  /** Says whether this method can handle both methods -
+        1 better, 2 best, 3 both */
+  virtual int whichMethod()
+  {
+    return 3;
+  }
+
+  /** Saves a clone of current branching object.  Can be used to update
+        information on object causing branch - after branch */
+  virtual void saveBranchingObject(OsiBranchingObject *object);
+  /** Pass in information on branch just done.
+        assumes object can get information from solver */
+  virtual void updateInformation(OsiSolverInterface *solver,
+    const CbcNode *node);
+
+private:
+  /// Illegal Assignment operator
+  CbcBranchDynamicDecision &operator=(const CbcBranchDynamicDecision &rhs);
+
+  /// data
+
+  /// "best" so far
+  double bestCriterion_;
+
+  /// Change up for best
+  double bestChangeUp_;
+
+  /// Number of infeasibilities for up
+  int bestNumberUp_;
+
+  /// Change down for best
+  double bestChangeDown_;
+
+  /// Number of infeasibilities for down
+  int bestNumberDown_;
+
+  /// Pointer to best branching object
+  CbcBranchingObject *bestObject_;
+};
+/** Simple branching object for an integer variable with pseudo costs
+
+  This object can specify a two-way branch on an integer variable. For each
+  arm of the branch, the upper and lower bounds on the variable can be
+  independently specified.
+
+  Variable_ holds the index of the integer variable in the integerVariable_
+  array of the model.
+*/
+
+class CbcDynamicPseudoCostBranchingObject : public CbcIntegerBranchingObject {
+
+public:
+  /// Default constructor
+  CbcDynamicPseudoCostBranchingObject();
+
+  /** Create a standard floor/ceiling branch object
+
+      Specifies a simple two-way branch. Let \p value = x*. One arm of the
+      branch will be is lb <= x <= floor(x*), the other ceil(x*) <= x <= ub.
+      Specify way = -1 to set the object state to perform the down arm first,
+      way = 1 for the up arm.
+    */
+  CbcDynamicPseudoCostBranchingObject(CbcModel *model, int variable,
+    int way, double value,
+    CbcSimpleIntegerDynamicPseudoCost *object);
+
+  /** Create a degenerate branch object
+
+      Specifies a `one-way branch'. Calling branch() for this object will
+      always result in lowerValue <= x <= upperValue. Used to fix a variable
+      when lowerValue = upperValue.
+    */
+
+  CbcDynamicPseudoCostBranchingObject(CbcModel *model, int variable, int way,
+    double lowerValue, double upperValue);
+
+  /// Copy constructor
+  CbcDynamicPseudoCostBranchingObject(const CbcDynamicPseudoCostBranchingObject &);
+
+  /// Assignment operator
+  CbcDynamicPseudoCostBranchingObject &operator=(const CbcDynamicPseudoCostBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  /// Destructor
+  virtual ~CbcDynamicPseudoCostBranchingObject();
+
+  /// Does part of constructor
+  void fillPart(int variable,
+    int way, double value,
+    CbcSimpleIntegerDynamicPseudoCost *object);
+
+  using CbcBranchingObject::branch;
+  /** \brief Sets the bounds for the variable according to the current arm
+           of the branch and advances the object state to the next arm.
+           This version also changes guessed objective value
+    */
+  virtual double branch();
+
+  /** 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 &info);
+
+  /// Change in guessed
+  inline double changeInGuessed() const
+  {
+    return changeInGuessed_;
+  }
+  /// Set change in guessed
+  inline void setChangeInGuessed(double value)
+  {
+    changeInGuessed_ = value;
+  }
+  /// Return object
+  inline CbcSimpleIntegerDynamicPseudoCost *object() const
+  {
+    return object_;
+  }
+  /// Set object
+  inline void setObject(CbcSimpleIntegerDynamicPseudoCost *object)
+  {
+    object_ = object;
+  }
+
+  /** Return the type (an integer identifier) of \c this */
+  virtual CbcBranchObjType type() const
+  {
+    return DynamicPseudoCostBranchObj;
+  }
+
+  // LL: compareOriginalObject and compareBranchingObject are inherited from
+  // CbcIntegerBranchingObject thus need not be declared/defined here. After
+  // all, this kind of branching object is simply using pseudocosts to make
+  // decisions, but once the decisions are made they are the same kind as in
+  // the underlying class.
+
+protected:
+  /// Change in guessed objective value for next branch
+  double changeInGuessed_;
+  /// Pointer back to object
+  CbcSimpleIntegerDynamicPseudoCost *object_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchLotsize.hpp

@@ -0,0 +1,249 @@
+/* $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).
+
+#ifndef CbcBranchLotsize_H
+#define CbcBranchLotsize_H
+
+#include "CbcBranchBase.hpp"
+/** Lotsize class */
+
+class CbcLotsize : public CbcObject {
+
+public:
+  // Default Constructor
+  CbcLotsize();
+
+  /* Useful constructor - passed model index.
+       Also passed valid values - if range then pairs
+    */
+  CbcLotsize(CbcModel *model, int iColumn,
+    int numberPoints, const double *points, bool range = false);
+
+  // Copy constructor
+  CbcLotsize(const CbcLotsize &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcLotsize &operator=(const CbcLotsize &rhs);
+
+  // Destructor
+  ~CbcLotsize();
+
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation *info,
+    int &preferredWay) const;
+
+  using CbcObject::feasibleRegion;
+  /** Set bounds to contain the current solution.
+
+      More precisely, for the variable associated with this object, take the
+      value given in the current solution, force it within the current bounds
+      if required, then set the bounds to fix the variable at the integer
+      nearest the solution value.
+    */
+  virtual void feasibleRegion();
+
+  /// Creates a branching object
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way);
+
+  /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in the good direction.
+
+      The preferred branching object will force the variable to be +/-1 from
+      its current value, depending on the reduced cost and objective sense.  If
+      movement in the direction which improves the objective is impossible due
+      to bounds on the variable, the branching object will move in the other
+      direction.  If no movement is possible, the method returns NULL.
+
+      Only the bounds on this variable are considered when determining if the new
+      point is feasible.
+    */
+  virtual CbcBranchingObject *preferredNewFeasible() const;
+
+  /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a bad direction.
+
+      As for preferredNewFeasible(), but the preferred branching object will
+      force movement in a direction that degrades the objective.
+    */
+  virtual CbcBranchingObject *notPreferredNewFeasible() const;
+
+  /** Reset original upper and lower bound values from the solver.
+
+      Handy for updating bounds held in this object after bounds held in the
+      solver have been tightened.
+     */
+  virtual void resetBounds(const OsiSolverInterface *solver);
+
+  /** Finds range of interest so value is feasible in range range_ or infeasible
+        between hi[range_] and lo[range_+1].  Returns true if feasible.
+    */
+  bool findRange(double value) const;
+
+  /** Returns floor and ceiling
+    */
+  virtual void floorCeiling(double &floorLotsize, double &ceilingLotsize, double value,
+    double tolerance) const;
+
+  /// Model column number
+  inline int modelSequence() const
+  {
+    return columnNumber_;
+  }
+  /// Set model column number
+  inline void setModelSequence(int value)
+  {
+    columnNumber_ = value;
+  }
+
+  /** Column number if single column object -1 otherwise,
+        so returns >= 0
+        Used by heuristics
+    */
+  virtual int columnNumber() const;
+  /// Original variable bounds
+  inline double originalLowerBound() const
+  {
+    return bound_[0];
+  }
+  inline double originalUpperBound() const
+  {
+    return bound_[rangeType_ * numberRanges_ - 1];
+  }
+  /// Type - 1 points, 2 ranges
+  inline int rangeType() const
+  {
+    return rangeType_;
+  }
+  /// Number of points
+  inline int numberRanges() const
+  {
+    return numberRanges_;
+  }
+  /// Ranges
+  inline double *bound() const
+  {
+    return bound_;
+  }
+  /** \brief Return true if object can take part in normal heuristics
+    */
+  virtual bool canDoHeuristics() const
+  {
+    return false;
+  }
+
+private:
+  /// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp)
+  void printLotsize(double value, bool condition, int type) const;
+
+protected:
+  /// data
+
+  /// Column number in model
+  int columnNumber_;
+  /// Type - 1 points, 2 ranges
+  int rangeType_;
+  /// Number of points
+  int numberRanges_;
+  // largest gap
+  double largestGap_;
+  /// Ranges
+  double *bound_;
+  /// Current range
+  mutable int range_;
+};
+
+/** Lotsize branching object
+
+  This object can specify a two-way branch on an integer variable. For each
+  arm of the branch, the upper and lower bounds on the variable can be
+  independently specified.
+
+  Variable_ holds the index of the integer variable in the integerVariable_
+  array of the model.
+*/
+
+class CbcLotsizeBranchingObject : public CbcBranchingObject {
+
+public:
+  /// Default constructor
+  CbcLotsizeBranchingObject();
+
+  /** Create a lotsize floor/ceiling branch object
+
+      Specifies a simple two-way branch. Let \p value = x*. One arm of the
+      branch will be is lb <= x <= valid range below(x*), the other valid range above(x*) <= x <= ub.
+      Specify way = -1 to set the object state to perform the down arm first,
+      way = 1 for the up arm.
+    */
+  CbcLotsizeBranchingObject(CbcModel *model, int variable,
+    int way, double value, const CbcLotsize *lotsize);
+
+  /** Create a degenerate branch object
+
+      Specifies a `one-way branch'. Calling branch() for this object will
+      always result in lowerValue <= x <= upperValue. Used to fix in valid range
+    */
+
+  CbcLotsizeBranchingObject(CbcModel *model, int variable, int way,
+    double lowerValue, double upperValue);
+
+  /// Copy constructor
+  CbcLotsizeBranchingObject(const CbcLotsizeBranchingObject &);
+
+  /// Assignment operator
+  CbcLotsizeBranchingObject &operator=(const CbcLotsizeBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  /// Destructor
+  virtual ~CbcLotsizeBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /** \brief Sets the bounds for the variable according to the current arm
+           of the branch and advances the object state to the next arm.
+    */
+  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 LotsizeBranchObj;
+  }
+
+  // LL: compareOriginalObject can be inherited from the CbcBranchingObject
+  // since variable_ uniquely defines the lot sizing object.
+
+  /** 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);
+
+protected:
+  /// Lower [0] and upper [1] bounds for the down arm (way_ = -1)
+  double down_[2];
+  /// Lower [0] and upper [1] bounds for the up arm (way_ = 1)
+  double up_[2];
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/