casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonDiver.hpp

@@ -0,0 +1,424 @@
+// (C) Copyright International Business Machines Corporation 2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, International Business Machines Corporation
+//
+// Date : 09/01/2007
+
+#ifndef BonDiver_H
+#define BonDiver_H
+
+#include "BonminConfig.h"
+#include "CbcCompareBase.hpp"
+#include "CbcTree.hpp"
+#include "IpRegOptions.hpp"
+#include "IpOptionsList.hpp"
+#include "CbcCompareActual.hpp"
+#include "BonRegisteredOptions.hpp"
+#include <list>
+namespace Bonmin
+{
+  class BabSetupBase;
+  /** Class to do diving in the tree. Principle is that branch-and-bound follows current branch of the tree untill it
+      hits the bottom at which point it goes to the best candidate (according to CbcCompare) on the heap.*/
+  class CbcDiver : public CbcTree
+  {
+  public:
+    /// Default constructor.
+    CbcDiver();
+
+    ///Copy constructor.
+    CbcDiver(const CbcDiver &rhs);
+
+    /// Assignment operator.
+    CbcDiver & operator=(const CbcDiver &rhs);
+
+    /// Destructor.
+    virtual ~CbcDiver();
+
+    ///Virtual copy constructor.
+    virtual CbcTree * clone() const;
+
+    /** \name Heap access and maintenance methods.*/
+    /**@{*/
+    ///Return top node (next node to process.*/
+    virtual CbcNode * top() const;
+
+    /// Add node to the heap.
+    virtual void push(CbcNode * x);
+    /// Remove the top node of the heap.
+    virtual void pop();
+    /// Remove the best node from the heap and return it
+    virtual CbcNode * bestNode(double cutoff);
+    /** @} */
+
+    /// \name vector methods
+    /** @{ */
+    /** Test if empty. */
+    virtual bool empty();
+    /** Give size of the tree.*/
+    virtual int size()
+    {
+      return (static_cast<int>(nodes_.size()) + (nextOnBranch_ != NULL) );
+    }
+    /** @} */
+
+    /*! \brief Prune the tree using an objective function cutoff
+      
+    This routine removes all nodes with objective worst than the
+    specified cutoff value.
+    It also sets bestPossibleObjective to best
+    of all on tree before deleting.
+    */
+    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
+
+    /// Get best possible objective function in the tree
+    virtual double getBestPossibleObjective();
+
+
+    ///Don't know what this is yet?
+    virtual void endSearch()
+    {
+      nextOnBranch_ = NULL;
+    }
+
+    ///Register the options of the method.
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    /// Initialize the method (get options)
+    void initialize(BabSetupBase &b);
+
+  private:
+    /** Say if we are cleaning the tree (then only call CbcTree functions).*/
+    bool treeCleaning_;
+    /** Noext node on the branch.*/
+    CbcNode * nextOnBranch_;
+    /** Flag indicating if we want to stop diving based on the guessed
+    objective value and the cutoff value */
+    bool stop_diving_on_cutoff_;
+  };
+
+
+  /** Class to do probed diving in the tree.
+    * Principle is that branch-and-bound follows current branch of the tree by exploring the two children at each level
+    * and continuing the dive on the best one of the two. Untill it 
+    *  hits the bottom at which point it goes to the best candidate (according to CbcCompare) on the heap.*/
+  class CbcProbedDiver : public CbcTree
+  {
+  public:
+    /// Default constructor.
+    CbcProbedDiver();
+
+    ///Copy constructor.
+    CbcProbedDiver(const CbcProbedDiver &rhs);
+
+    /// Assignment operator.
+    CbcProbedDiver & operator=(const CbcProbedDiver &rhs);
+
+    /// Destructor.
+    virtual ~CbcProbedDiver();
+
+    ///Virtual copy constructor.
+    virtual CbcTree * clone() const;
+
+    /** \name Heap access and maintenance methods.*/
+    /**@{*/
+    ///Return top node (next node to process.*/
+    virtual CbcNode * top() const;
+
+    /// Add node to the heap.
+    virtual void push(CbcNode * x);
+    /// Remove the top node of the heap.
+    virtual void pop();
+    /// Remove the best node from the heap and return it
+    virtual CbcNode * bestNode(double cutoff);
+    /** @} */
+
+    /// \name vector methods
+    /** @{ */
+    /** Test if empty. */
+    virtual bool empty();
+    /** Give size of the tree.*/
+    virtual int size()
+    {
+      return (static_cast<int>(nodes_.size()) + (nextOnBranch_ != NULL) + (candidateChild_ != NULL) );
+    }
+    /** @} */
+
+    /*! \brief Prune the tree using an objective function cutoff
+      
+    This routine removes all nodes with objective worst than the
+    specified cutoff value.
+    It also sets bestPossibleObjective to best
+    of all on tree before deleting.
+    */
+    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
+
+    /// Get best possible objective function in the tree
+    virtual double getBestPossibleObjective();
+
+
+    ///Don't know what this is yet?
+    virtual void endSearch()
+    {
+      nextOnBranch_ = NULL;
+    }
+
+    /// Initialize the method (get options)
+    void initialize(BabSetupBase &b);
+
+  private:
+    /** Say if we are cleaning the tree (then only call CbcTree functions).*/
+    bool treeCleaning_;
+    /** Next node on the branch.*/
+    CbcNode * nextOnBranch_;
+    /** Candidate child explored.*/
+    CbcNode * candidateChild_;
+    /** Flag indicating if we want to stop diving based on the guessed
+    objective value and the cutoff value */
+    bool stop_diving_on_cutoff_;
+  };
+
+
+  /** A more elaborate diving class. First there are several modes which can be commanded by the Comparison class below.
+     In particular can command to dive to find solutions, to try to close the bound as possible or to limit the size of
+     the tree.
+
+     The diving goes into the tree doing depth-first search until one of the following happens:
+     \li A prescibed \c maxDiveBacktrack_ number of backtracking are performed.
+     \li The guessed objective value of the current node is worst than the best incumbent.
+     \li The depth of the dive is bigger than \c maxDiveDepth_
+
+     In the first case all the nodes are put on the tree and the next node on top will be the top of the heap, in the
+     two latter case we just put the node on the tree and backtrack in the list of depth-first search nodes.
+
+     \bug This won't work in a non-convex problem where objective does not decrease down branches.
+   */
+  class CbcDfsDiver :public CbcTree
+  {
+  public:
+    enum ComparisonModes{
+      Enlarge/** At the very beginning we might want to enlarge the tree just a bit*/,
+      FindSolutions,
+      CloseBound,
+      LimitTreeSize};
+    /// Default constructor.
+    CbcDfsDiver();
+
+    ///Copy constructor.
+    CbcDfsDiver(const CbcDfsDiver &rhs);
+
+    /// Assignment operator.
+    CbcDfsDiver & operator=(const CbcDfsDiver &rhs);
+
+    /// Destructor.
+    virtual ~CbcDfsDiver();
+
+    ///Virtual copy constructor.
+    virtual CbcTree * clone() const;
+
+    /** \name Heap access and maintenance methods.*/
+    /**@{*/
+    ///Return top node (next node to process.*/
+    virtual CbcNode * top() const;
+
+    /// Add node to the heap.
+    virtual void push(CbcNode * x);
+    /// Remove the top node of the heap.
+    virtual void pop();
+    /// Remove the best node from the heap and return it
+    virtual CbcNode * bestNode(double cutoff);
+    /** @} */
+
+    /// \name vector methods
+    /** @{ */
+    /** Test if empty. */
+    virtual bool empty();
+    /** Give size of the tree.*/
+    virtual int size()
+    {
+      return static_cast<int>(nodes_.size()) + diveListSize_;
+    }
+    /** @} */
+
+    /*! \brief Prune the tree using an objective function cutoff
+      
+    This routine removes all nodes with objective worst than the
+    specified cutoff value.
+    It also sets bestPossibleObjective to best
+    of all on tree before deleting.
+     \bug This won't work in a non-convex problem where objective does not decrease down branches.
+    */
+    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
+
+    /// Get best possible objective function in the tree
+    virtual double getBestPossibleObjective();
+
+//#ifdef COIN_HAS_BONMIN
+    ///Register the options of the method.
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    /// Initialize the method (get options)
+    void initialize(BabSetupBase &b);
+//#endif
+    ///Don't know what this is yet?
+    virtual void endSearch()
+    {}
+
+    /** Changes the mode of comparison of the tree for "safety reasons" if the mode really changes we always
+        finish the current dive and put all the node back onto the heap.*/
+    void setComparisonMode(ComparisonModes newMode);
+    /** get the mode of comparison of the tree.*/
+    ComparisonModes getComparisonMode()
+    {
+      return mode_;
+    }
+  protected:
+    /**Flag to say that we are currently cleaning the tree and should work only
+       on the heap.*/
+    int treeCleaning_;
+    /** List of the nodes in the current dive.*/
+    std::list<CbcNode *> dive_;
+    /** Record dive list size for constant time access.*/
+    int diveListSize_;
+    /** Depth of the node from which diving was started (we call this node the diving board).*/
+    int divingBoardDepth_;
+    /** Last reported cutoff.*/
+    double cutoff_;
+    /** number of backtracks done in current dive.*/
+    int nBacktracks_;
+    /** \name Parameters of the method.*/
+    /** @{ */
+    /** Maximum depth until which we'll do a bredth-first-search.*/
+    int maxDepthBFS_;
+    /** Maximum number of backtrack in one dive.*/
+    int maxDiveBacktracks_;
+    /** Maximum depth to go from divingBoard.*/
+    int maxDiveDepth_;
+    /** Current mode of the diving strategy.*/
+    ComparisonModes mode_;
+    /** @} */
+  private:
+    /** Pushes onto heap all the nodes with objective value > cutoff. */
+    void pushDiveOntoHeap(double cutoff);
+
+  };
+
+  class DiverCompare : public CbcCompareBase
+  {
+  public:
+    // Default Constructor
+    DiverCompare ():
+        CbcCompareBase(),
+        diver_(NULL),
+        numberSolToStopDive_(5),
+        numberNodesToLimitTreeSize_(1000000),
+        comparisonDive_(NULL),
+        comparisonBound_(NULL)
+    {}
+
+
+    virtual ~DiverCompare()
+    {
+      delete comparisonDive_;
+      delete comparisonBound_;
+    }
+
+    // Copy constructor
+    DiverCompare ( const DiverCompare & rhs):
+        CbcCompareBase(rhs),
+        diver_(rhs.diver_),
+        numberSolToStopDive_(rhs.numberSolToStopDive_),
+        numberNodesToLimitTreeSize_(rhs.numberNodesToLimitTreeSize_),
+        comparisonDive_(rhs.comparisonDive_->clone()),
+        comparisonBound_(rhs.comparisonBound_->clone())
+    {}
+
+    // Assignment operator
+    DiverCompare & operator=( const DiverCompare& rhs)
+    {
+      if (this != &rhs) {
+        CbcCompareBase::operator=(rhs);
+        diver_ = rhs.diver_;
+        numberSolToStopDive_ = rhs.numberSolToStopDive_;
+        numberNodesToLimitTreeSize_ = rhs.numberNodesToLimitTreeSize_;
+        delete comparisonDive_;
+        delete comparisonBound_;
+        comparisonDive_ = NULL;
+        comparisonBound_ = NULL;
+        if (rhs.comparisonDive_) comparisonDive_ = rhs.comparisonDive_->clone();
+        if (rhs.comparisonBound_) comparisonBound_ = rhs.comparisonBound_->clone();
+      }
+      return *this;
+    }
+
+    /// Clone
+    virtual CbcCompareBase * clone() const
+    {
+      return new DiverCompare(*this);
+    }
+
+    /// This is test function
+    virtual bool test (CbcNode * x, CbcNode * y);
+
+    ///  Called after each new solution
+    virtual bool newSolution(CbcModel * model);
+
+    ///  Called after each new solution
+    virtual bool newSolution(CbcModel * model,
+        double objectiveAtContinuous,
+        int numberInfeasibilitiesAtContinuous);
+
+    /** Called 1000 nodes.
+      * Return true if want tree re-sorted.*/
+    virtual bool every1000Nodes(CbcModel * model,int numberNodes);
+
+    /** Set the dfs diver to use.*/
+    void setDiver(CbcDfsDiver * diver)
+    {
+      diver_ = diver;
+    }
+
+    /** Set numberSolToStopDive_ */
+    void setNumberSolToStopDive(int val)
+    {
+      numberSolToStopDive_ = val;
+    }
+
+    /** Set numberNodesToLimitTreeSize_.*/
+    void setNumberNodesToLimitTreeSize(int val)
+    {
+      numberNodesToLimitTreeSize_ = val;
+    }
+
+    /** Set comparison method when diving.*/
+    void setComparisonDive(const CbcCompareBase & val)
+    {
+      comparisonDive_ = val.clone();
+    }
+    /** Set comparison method when closing bound.*/
+    void setComparisonBound(const CbcCompareBase & val)
+    {
+      comparisonBound_ = val.clone();
+    }
+  private:
+    /** Pointer to the CbcDfsDiver handling the tree.*/
+    CbcDfsDiver * diver_;
+    /** Number of solution before we command diver_ to stop diving.*/
+    int numberSolToStopDive_;
+    /** Number of nodes before we command diver_ to limit the tree size.*/
+    int numberNodesToLimitTreeSize_;
+    /** Comparison method used in diving mode*/
+    CbcCompareBase * comparisonDive_;
+    /** Comparison method used bound mode*/
+    CbcCompareBase * comparisonBound_;
+    /** Comparison method used when limit tree size.*/
+    CbcCompareDepth comparisonDepth_;
+  };
+
+}/* Ends bonmin namespace.*/
+
+#endif
+

casadi/include/coin/BonDummyHeuristic.hpp

@@ -0,0 +1,53 @@
+// (C) Copyright Carnegie Mellon University 2005
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// P. Bonami, Carnegie Mellon University
+//
+// Date :  05/26/2005
+
+#ifndef BonDummyHeuristic_HPP
+#define BonDummyHeuristic_HPP
+#include "BonOsiTMINLPInterface.hpp"
+
+#include "CbcHeuristic.hpp"
+namespace Bonmin
+{
+  class  DummyHeuristic : public CbcHeuristic
+  {
+  public:
+    /// Default constructor
+    DummyHeuristic(OsiTMINLPInterface * si = NULL);
+    /// Usefull constructor
+    DummyHeuristic(CbcModel &model, OsiTMINLPInterface * si = NULL);
+    ///Copy constructor
+    DummyHeuristic( const DummyHeuristic &copy):
+        CbcHeuristic(copy),
+        nlp_(copy.nlp_),
+        knowsSolution(copy.knowsSolution)
+    {}
+    /// Set nlp_
+    void setNlp(OsiTMINLPInterface * si);
+    /// heuristic method
+    virtual int solution(double &solutionValue, double *betterSolution);
+    virtual int solution(double &solutionValue, double *betterSolution, OsiCuts & cs)
+    {
+      return solution(solutionValue, betterSolution);
+    }
+    virtual CbcHeuristic * clone()const
+    {
+      return new DummyHeuristic(*this);
+    }
+    virtual void resetModel(CbcModel*)
+    {}
+  virtual bool shouldHeurRun(int whereFrom){
+     return true;}
+  private:
+    /// Pointer to the Ipopt interface
+    OsiTMINLPInterface * nlp_;
+    /// Do I have a solution?
+    bool knowsSolution;
+  };
+}
+#endif

casadi/include/coin/BonDummyPump.hpp

@@ -0,0 +1,43 @@
+// (C) Copyright CNRS
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, LIF Université de la Méditérannée-CNRS
+//
+// Date : 06/18/2008
+
+#ifndef BonDummyPump_H
+#define BonDummyPump_H
+#include "BonLocalSolverBasedHeuristic.hpp"
+
+namespace Bonmin {
+  class DummyPump:public LocalSolverBasedHeuristic {
+    public:
+     /** Default constructor*/
+     DummyPump();
+    /** Constructor with setup.*/
+    DummyPump(BonminSetup * setup);
+
+     /** Copy constructor.*/
+     DummyPump(const DummyPump &other);
+     /** Virtual constructor.*/
+     virtual CbcHeuristic * clone() const{
+      return new DummyPump(*this);
+     }
+
+     /** Destructor*/
+     virtual ~DummyPump();
+
+     /** Runs heuristic*/
+     int solution(double & objectiveValue,
+                  double * newSolution);
+   /** Register the options common to all local search based heuristics.*/
+   static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+   /** Initiaize using passed options.*/
+   void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+  };
+
+}/* Ends Bonmin namepace.*/
+#endif
+

casadi/include/coin/BonEcpCuts.hpp

@@ -0,0 +1,97 @@
+// (C) Copyright International Business Machines (IBM) 2006, 2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// P. Bonami, International Business Machines
+//
+// Date :  12/20/2006
+
+#ifndef BonECPCuts_HPP
+#define BonECPCuts_HPP
+
+#include "BonOaDecBase.hpp"
+#include "CglCutGenerator.hpp"
+namespace Bonmin
+{
+  class EcpCuts: public OaDecompositionBase
+  {
+  public:
+    EcpCuts(BabSetupBase & b);
+
+    /// Copy constructor
+    EcpCuts(const EcpCuts & copy):
+        OaDecompositionBase(copy),
+        objValue_(copy.objValue_),
+        numRounds_(copy.numRounds_),
+        abs_violation_tol_(copy.abs_violation_tol_),
+        rel_violation_tol_(copy.rel_violation_tol_),
+        beta_(copy.beta_)
+    {}
+
+    /// clone
+    CglCutGenerator * clone() const
+    {
+      return new EcpCuts(*this);
+    }
+
+    /// Destructor
+    virtual ~EcpCuts()
+    {}
+    /** Standard cut generation methods. */
+    virtual void generateCuts(const OsiSolverInterface &si,  OsiCuts & cs,
+        const CglTreeInfo info = CglTreeInfo());
+    double doEcpRounds(OsiSolverInterface &si,
+        bool leaveSiUnchanged,
+        double* violation = NULL);
+
+    void setNumRounds(int value)
+    {
+      numRounds_ = value;
+    }
+
+    void setPropabilityFactor(double value)
+    {
+      beta_ = value;
+    }
+
+    void setAbsViolationTolerance(double value)
+    {
+      abs_violation_tol_ = value;
+    }
+    void setRelViolationTolerance(double value)
+    {
+      rel_violation_tol_ = value;
+    }
+
+    /** Register ecp cuts options.*/
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+  protected:
+    /// virtual method which performs the OA algorithm by modifying lp and nlp.
+    virtual double performOa(OsiCuts & cs, solverManip &lpManip,
+                   BabInfo * babInfo, double &cutoff, const CglTreeInfo &info) const
+    {
+      throw -1;
+    }
+    /// virutal method to decide if local search is performed
+    virtual bool doLocalSearch(BabInfo * babInfo) const
+    {
+      return 0;
+    }
+  private:
+    /** Record obj value at final point of Ecp. */
+    mutable double objValue_;
+    /** Record NLP infeasibility at final point of Ecp */
+    mutable double violation_;
+    /** maximum number of iterations of generation. */
+    int numRounds_;
+    /** absolute tolerance for NLP constraint violation to stop ECP rounds */
+    double abs_violation_tol_;
+    /** relative tolerance for NLP constraint violation to stop ECP rounds */
+    double rel_violation_tol_;
+    /** Factor for probability for skipping cuts */
+    double beta_;
+  };
+} /* end namespace Bonmin.*/
+#endif

casadi/include/coin/BonExitCodes.hpp

@@ -0,0 +1,12 @@
+#ifndef BonExitCodes_H
+#define BonExitCodes_H
+
+
+namespace Bonmin{
+ /** Some error codes for uncatachable errors.*/
+enum ErrorCodes{
+ ERROR_IN_AMPL_SUFFIXES = 111,
+ UNSUPPORTED_CBC_OBJECT/** There is a CbcObject in the model which is not understood by Bonmin.*/
+};
+}
+#endif

casadi/include/coin/BonFixAndSolveHeuristic.hpp

@@ -0,0 +1,43 @@
+// (C) Copyright CNRS
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, LIF Université de la Méditérannée-CNRS
+//
+// Date : 06/18/2008
+
+#ifndef BonFixAndSolveHeuristic_H
+#define BonFixAndSolveHeuristic_H
+#include "BonLocalSolverBasedHeuristic.hpp"
+
+namespace Bonmin {
+  class FixAndSolveHeuristic:public LocalSolverBasedHeuristic {
+    public:
+     /** Default constructor*/
+     FixAndSolveHeuristic();
+    /** Constructor with setup.*/
+    FixAndSolveHeuristic(BonminSetup * setup);
+
+     /** Copy constructor.*/
+     FixAndSolveHeuristic(const FixAndSolveHeuristic &other);
+     /** Virtual constructor.*/
+     virtual CbcHeuristic * clone() const{
+      return new FixAndSolveHeuristic(*this);
+     }
+
+     /** Destructor*/
+     virtual ~FixAndSolveHeuristic();
+
+     /** Runs heuristic*/
+     int solution(double & objectiveValue,
+                  double * newSolution);
+   /** Register the options common to all local search based heuristics.*/
+   static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+   /** Initiaize using passed options.*/
+   void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+  };
+
+}/* Ends Bonmin namepace.*/
+#endif
+