casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonLpBranchingSolver.hpp

@@ -0,0 +1,80 @@
+// Copyright (C) 2006, 2007 International Business Machines
+// Corporation and others.  All Rights Reserved.
+#ifndef BonLpBranchingSolver_H
+#define BonLpBranchingSolver_H
+
+#include "BonStrongBranchingSolver.hpp"
+#include "BonEcpCuts.hpp"
+
+namespace Bonmin
+{
+
+  /** Implementation of BonChooseVariable for curvature-based braching.
+  */
+
+  class LpBranchingSolver : public StrongBranchingSolver
+  {
+
+  public:
+
+    /// Constructor from setup 
+    LpBranchingSolver (BabSetupBase *b);
+    /// Copy constructor
+    LpBranchingSolver (const LpBranchingSolver &);
+
+    /// Assignment operator
+    LpBranchingSolver & operator= (const LpBranchingSolver& rhs);
+
+    /// Destructor
+    virtual ~LpBranchingSolver ();
+
+    /// Called to initialize solver before a bunch of strong branching
+    /// solves
+    virtual void markHotStart(OsiTMINLPInterface* tminlp_interface);
+
+    /// Called to solve the current TMINLP (with changed bound information)
+    virtual TNLPSolver::ReturnStatus solveFromHotStart(OsiTMINLPInterface* tminlp_interface);
+
+    /// Called after all strong branching solves in a node
+    virtual void unmarkHotStart(OsiTMINLPInterface* tminlp_interface);
+
+    void setMaxCuttingPlaneIter(int num)
+    {
+      maxCuttingPlaneIterations_ = num;
+    }
+
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+  private:
+    /// Default Constructor
+    LpBranchingSolver ();
+
+    /// Linear solver
+    OsiSolverInterface* lin_;
+
+    /// Warm start object for linear solver
+    CoinWarmStart* warm_;
+
+    /// Ecp cut generate
+    EcpCuts* ecp_;
+
+    /// Number of maximal ECP cuts
+    int maxCuttingPlaneIterations_;
+
+    /// absolute tolerance for ECP cuts
+    double abs_ecp_tol_;
+
+    /// relative tolerance for ECP cuts
+    double rel_ecp_tol_;
+
+
+   enum WarmStartMethod {
+     Basis=0 /** Use basis*/,
+     Clone /** clone problem*/
+   };
+   /// Way problems are warm started
+   WarmStartMethod warm_start_mode_;
+  };
+
+}
+#endif

casadi/include/coin/BonMilpRounding.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2010, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami CNRS
+//
+// Date : May, 26 2010
+
+#ifndef BonMilpRounding_HPP
+#define BonMilpRounding_HPP
+#include "BonOsiTMINLPInterface.hpp"
+#include "BonBonminSetup.hpp"
+#include "CbcHeuristic.hpp"
+#include "CbcStrategy.hpp"
+#include "OsiCuts.hpp"
+
+namespace Bonmin
+{
+  class SubMipSolver;
+  class MilpRounding : public CbcHeuristic
+  {
+  public:
+
+    /// Constructor with setup
+    MilpRounding(BonminSetup * setup);
+
+    /// Copy constructor
+    MilpRounding(const MilpRounding &copy);
+
+    /// Destructor
+    ~MilpRounding();
+
+    /// Assignment operator
+    MilpRounding & operator=(const MilpRounding & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const{
+      return new MilpRounding(*this);
+    }
+
+    /// Initialize method 
+    void Initialize(BonminSetup * setup);
+
+    /// Resets stuff if model changes
+    virtual void resetModel(CbcModel * model){
+      setModel(model);
+    }
+
+    /** Change setup used for heuristic.*/
+    virtual void setSetup(BonminSetup * setup){
+      setup_ = setup;
+      //      Initialize(setup_->options());
+    }
+
+    /// Performs heuristic
+    virtual int solution(double &solutionValue, double *betterSolution);
+
+
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+  protected:
+    /** Setup to use for local searches (will make copies).*/
+    BonminSetup * setup_; 
+
+  private:
+    /// How often to do (code can change)
+    int howOften_;
+    /// A subsolver for MIP
+    SubMipSolver * mip_;
+
+    OsiCuts noGoods;
+  };
+}
+#endif

casadi/include/coin/BonOACutGenerator2.hpp

@@ -0,0 +1,56 @@
+// (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 BonOACutGenerator2_HPP
+#define BonOACutGenerator2_HPP
+#include "BonOaDecBase.hpp"
+
+namespace Bonmin
+{
+  /** Class to perform OA in its classical form.*/
+  class OACutGenerator2 : public OaDecompositionBase
+  {
+  public:
+    /// Constructor with basic setup
+    OACutGenerator2(BabSetupBase & b);
+
+    /// Copy constructor
+    OACutGenerator2(const OACutGenerator2 &copy)
+        :
+        OaDecompositionBase(copy),
+        subMip_(new SubMipSolver (*copy.subMip_))
+    {}
+    /// Destructor
+    ~OACutGenerator2();
+
+    void setStrategy(const CbcStrategy & strategy)
+    {
+      parameters_.setStrategy(strategy);
+    }
+
+    virtual CglCutGenerator * clone() const
+    {
+      return new OACutGenerator2(*this);
+    }
+    /** Register OA 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;
+    /// virutal method to decide if local search is performed
+    virtual bool doLocalSearch(BabInfo * babInfo) const;
+
+  private:
+    SubMipSolver * subMip_;
+  };
+}
+#endif

casadi/include/coin/BonOAMessages.hpp

@@ -0,0 +1,44 @@
+// (C) Copyright Carnegie Mellon University 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// P. Bonami, Carnegie Mellon University
+//
+// Date :  07/15/2005
+
+#ifndef OaMessages_H
+#define OaMessages_H
+#include "CoinMessage.hpp"
+
+namespace Bonmin
+{
+  enum OA_Message{
+    FEASIBLE_NLP,
+    INFEASIBLE_NLP,
+    UPDATE_UB,
+    SOLVED_LOCAL_SEARCH,
+    LOCAL_SEARCH_ABORT,
+    UPDATE_LB,
+    ABORT,
+    OASUCCESS,
+    OAABORT,
+    OA_STATS,
+    LP_ERROR,
+    PERIODIC_MSG,
+    FP_DISTANCE,
+    FP_MILP_VAL,
+    FP_MAJOR_ITERATION,
+    FP_MINOR_ITERATION,
+    DUMMY_END
+  };
+
+  /** Output messages for Outer approximation cutting planes */
+  class OaMessages : public CoinMessages
+  {
+  public:
+    OaMessages();
+  };
+
+} //end namespace Bonmin
+#endif

casadi/include/coin/BonOaDecBase.hpp

@@ -0,0 +1,297 @@
+// (C) Copyright International Business Machines (IBM) 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// P. Bonami, International Business Machines
+//
+// Date :  12/07/2006
+#ifndef BonOaDecBase_HPP
+#define BonOaDecBase_HPP
+#include "BonSubMipSolver.hpp"
+#include "CglCutGenerator.hpp"
+#include "BonBabSetupBase.hpp"
+#include "BonOAMessages.hpp"
+#include "CbcModel.hpp"
+
+#include "CbcStrategy.hpp"
+
+#include "CoinTime.hpp"
+#include "OsiAuxInfo.hpp"
+#include "OsiBranchingObject.hpp"
+#include <iostream>
+#include "BonBabInfos.hpp"
+namespace Bonmin
+{
+  /** Base class for OA algorithms.*/
+  class OaDecompositionBase : public CglCutGenerator
+  {
+  public:
+
+
+    /** Small class to manipulatee various things in an OsiSolverInterface and restore them.
+        The OsiSolverInterface manipulated may already exist or may be cloned from another one.*/
+    class solverManip
+    {
+    public:
+      /** Constructor. */
+      solverManip(OsiSolverInterface *si , bool saveNumRows=true,
+          bool saveBasis=true, bool saveBounds=false,
+          bool saveCutoff = false, bool resolve=true);
+
+      /** Constructor which clone an other interface. */
+      solverManip(const OsiSolverInterface & si);
+      /** Destructor. */
+      ~solverManip();
+      /** Restore solver. */
+      void restore();
+      
+      /** Get pointer to solver interface. */
+      OsiSolverInterface * si()
+      {
+        return si_;
+      }
+
+      /** Set objects.*/
+      void setObjects(OsiObject ** objects, int nObjects)
+      {
+        objects_ = objects;
+        nObjects_ = nObjects;
+      }
+
+    private:
+      /** Interface saved. */
+      OsiSolverInterface * si_;
+      /** Initial number of rows (-1 if don't save). */
+      int initialNumberRows_;
+
+      /** Initial lower bounds. */
+      double * colLower_;
+
+      /** Initial Upper bounds.*/
+      double * colUpper_;
+
+      /** Inital basis. */
+      CoinWarmStart * warm_;
+
+      /** Initial cutoff. */
+      double cutoff_;
+
+      /** delete si_ ? */
+      bool deleteSolver_;
+
+      /// Some objects the feasiblitiy of which to verify.
+      OsiObject * * objects_;
+      /// Number of objects.*/
+      int nObjects_;
+      /** \name Cached info from solver interface.*/
+      /** @{ */
+      /** Number of columns. */
+      int numcols_;
+      /** Number of rows. */
+      int numrows_;
+      /** Lower bounds on variables.*/
+      const double * siColLower_;
+      /** Upper bounds on variables. */
+      const double * siColUpper_;
+
+      void getCached();
+      /** @} */
+    };
+
+    /// New usefull constructor
+    OaDecompositionBase(BabSetupBase &b, bool leaveSiUnchanged,
+        bool reassignLpsolver);
+
+    /// Copy constructor
+    OaDecompositionBase(const OaDecompositionBase & copy);
+
+
+    /// Destructor
+    virtual ~OaDecompositionBase();
+
+    /** Standard cut generation methods. */
+    virtual void generateCuts(const OsiSolverInterface &si,  OsiCuts & cs,
+        const CglTreeInfo info = CglTreeInfo());
+
+    /// Assign an OsiTMINLPInterface
+    void assignNlpInterface(OsiTMINLPInterface * nlp)
+    {
+      nlp_ = nlp;
+    }
+
+    /// Assign an OsiTMINLPInterface
+    void assignLpInterface(OsiSolverInterface * si)
+    {
+      lp_ = si;
+    }
+
+    bool reassignLpsolver()
+    {
+      return reassignLpsolver_;
+    }
+    /** Set objects.*/
+    void setObjects(OsiObject ** objects, int nObjects)
+    {
+      objects_ = objects;
+      nObjects_ = nObjects;
+    }
+    /// Set whether to leave the solverinterface unchanged
+    inline void setLeaveSiUnchanged(bool yesno)
+    {
+      leaveSiUnchanged_ = yesno;
+    }
+
+    /** Parameters for algorithm. */
+    struct Parameters
+    {
+      /// Add cuts as global
+      bool global_;
+      /// Add only violated OA inequalities
+      bool addOnlyViolated_;
+      /// cutoff min increase (has to be intialized trhough Cbc)
+      double cbcCutoffIncrement_;
+      /// integer tolerance (has to be the same as Cbc's)
+      double cbcIntegerTolerance_; 
+      /** setting for gap tolerance.*/
+      double gap_tol_;
+      ///Total max number of local searches
+      int maxLocalSearch_;
+      /// maximum time for local searches
+      double maxLocalSearchTime_;
+      /** sub milp log level.*/
+      int subMilpLogLevel_;
+      /** maximum number of solutions*/
+      int maxSols_;
+      /** Frequency of log. */
+      double logFrequency_;
+     
+      
+      /** Constructor with default values */
+      Parameters();
+
+      /** Copy constructor */
+      Parameters(const Parameters & other);
+
+      /** Destructor */
+      ~Parameters()
+      {
+        if (strategy_) delete strategy_;
+      }
+
+      /** Strategy to apply when using Cbc as MILP sub-solver.*/
+      void setStrategy(const CbcStrategy & strategy)
+      {
+        if (strategy_) delete strategy_;
+        strategy_ = strategy.clone();
+      }
+
+      const CbcStrategy * strategy() const
+      {
+        return strategy_;
+      }
+
+private:
+      /** Strategy to apply when using Cbc as MILP sub-solver.*/
+      CbcStrategy * strategy_;
+
+    };
+
+    Parameters& parameter()
+    {
+      return parameters_;
+    }
+
+    const Parameters& parameter()const
+    {
+      return parameters_;
+    }
+
+    void setLogLevel(int level)
+    {
+      handler_->setLogLevel(level);
+    }
+
+    void setReassignLpSolver(bool v){
+      reassignLpsolver_ = v;
+    }
+    void passInMessageHandler(CoinMessageHandler * handler);
+  protected:
+      void setupMipSolver(BabSetupBase &b, const std::string &prefix);
+    /// \name Protected helper functions
+    /**@{ */
+
+    /** Solve the nlp and do output.
+        \return true if feasible*/
+    bool post_nlp_solve(BabInfo * babInfo, double cutoff) const;
+    /** @} */
+
+    /// virtual method which performs the OA algorithm by modifying lp and nlp.
+    virtual double performOa(OsiCuts &cs, solverManip &lpManip,
+                             BabInfo * babInfo, double &, const CglTreeInfo & info) const = 0;
+    /// virutal method to decide if local search is performed
+    virtual bool doLocalSearch(BabInfo * babInfo) const = 0;
+
+    /// \name Protected members
+    /** @{ */
+    /// Pointer to nlp interface
+    mutable OsiTMINLPInterface * nlp_;
+    /// Pointer to setup
+    BabSetupBase * s_;
+    ///Number of nlp solved done
+    mutable int nSolve_;
+    /// A linear solver
+    mutable OsiSolverInterface * lp_;
+    /// Some objects the feasiblitiy of which to verify.
+    OsiObject * * objects_;
+    /// Number of objects.*/
+    int nObjects_;
+    ///number of local searches performed
+    mutable int nLocalSearch_;
+    /** messages handler. */
+    CoinMessageHandler * handler_;
+    /** Messages for OA */
+    CoinMessages messages_;
+    /** Wether or not we should remove cuts at the end of the procedure */
+    bool leaveSiUnchanged_;
+    /** Do we need to reassign the lp solver with Cbc.*/
+    bool reassignLpsolver_;
+    /** time of construction*/
+    double timeBegin_;
+    /** number of solutions found by OA_decomposition.*/
+    mutable int numSols_;
+    
+    /** Parameters.*/
+    Parameters parameters_;
+
+      /** Saved cuts: in some cases when using OA to check feasible solution algorithm may loop because Cbc removes inactive cuts.
+          To overcome this we can impose that no OA cut can be discarded by Cbc but this consumes too much memory in some cases.
+          Here we do it another way: cuts generated at current node are saved if algorithm seems to enter a loop we impose the needed cuts to be kept.*/
+    mutable OsiCuts savedCuts_;
+      /** Store the current node number.*/
+    mutable int currentNodeNumber_;
+    /** @} */
+
+#ifdef OA_DEBUG
+    class OaDebug
+    {
+      public:
+      bool checkInteger(const OsiSolverInterface&nlp, std::ostream & os) const;
+
+      void printEndOfProcedureDebugMessage(const OsiCuts &cs,
+          bool foundSolution,
+          double solValue,
+          double milpBound,
+          bool isInteger,
+          bool feasible,
+          std::ostream & os) const;
+    };
+
+    /** debug object. */
+    OaDebug debug_;
+
+#endif
+  };
+}
+#endif
+

casadi/include/coin/BonOaFeasChecker.hpp

@@ -0,0 +1,73 @@
+// (C) Copyright International Business Machines 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// P. Bonami, Carnegie Mellon University
+//
+// Date :  12/26/2006
+
+
+#ifndef BonOaFeasibilityChecker_HPP
+#define BonOaFeasibilityChecker_HPP
+#include "BonOaDecBase.hpp"
+
+namespace Bonmin
+{
+  /** Class to perform OA in its classical form.*/
+  class OaFeasibilityChecker : public OaDecompositionBase
+  {
+  public:
+    /// New usefull constructor
+    OaFeasibilityChecker(BabSetupBase &b);
+    /// Copy constructor
+    OaFeasibilityChecker(const OaFeasibilityChecker &copy)
+        :
+        OaDecompositionBase(copy),
+        pol_(copy.pol_),
+        type_(copy.type_),
+        cut_count_(copy.cut_count_),
+        maximum_oa_cuts_(copy.maximum_oa_cuts_)
+    {}
+    /// Destructor
+    ~OaFeasibilityChecker();
+
+    /** Register OA options.*/
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    virtual CglCutGenerator * clone() const
+    {
+      return new OaFeasibilityChecker(*this);
+    }
+  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;
+    /// virutal method to decide if local search is performed
+    virtual bool doLocalSearch(BabInfo * babInfo) const
+    {
+      return 0;
+    }
+
+    /** See documentation for feas_check_discard_policy option.*/
+    enum CutsPolicies {
+      DetectCycles = 0,
+      KeepAll,
+      TreatAsNormal};
+    /** Policy for keeping cuts.*/
+    CutsPolicies pol_;
+ 
+    /** See documentation for feas_check_cut_types option.*/
+    enum CutsTypes {
+      OA = 0,
+      Benders};
+    /** Type of cuts.*/
+    CutsTypes type_;
+
+    /** Count the total number of cuts generated.*/
+    mutable unsigned int cut_count_;
+    /** maximum number of OA cuts.*/
+    unsigned int maximum_oa_cuts_;
+  };
+}
+#endif