casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonHeuristicRINS.hpp

@@ -0,0 +1,55 @@
+// (C) Copyright CNRS and International Business Machines Corporation
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, LIF Université de la Méditérannée-CNRS
+// Joao Goncalves, International Business Machines Corporation
+//
+// Date : 06/18/2008
+
+#ifndef BonHeuristicRINS_H
+#define BonHeuristicRINS_H
+#include "BonLocalSolverBasedHeuristic.hpp"
+
+namespace Bonmin {
+  class HeuristicRINS:public LocalSolverBasedHeuristic {
+    public:
+     /** Default constructor*/
+     HeuristicRINS();
+    /** Constructor with setup.*/
+    HeuristicRINS(BonminSetup * setup);
+
+     /** Copy constructor.*/
+     HeuristicRINS(const HeuristicRINS &other);
+     /** Virtual constructor.*/
+     virtual CbcHeuristic * clone() const{
+      return new HeuristicRINS(*this);
+     }
+
+     /** Destructor*/
+     virtual ~HeuristicRINS();
+
+     /** 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);
+
+    /// Sets how often to do it
+    inline void setHowOften(int value)
+    { howOften_=value;}
+
+  private:
+    /// How often to do (code can change)
+    int howOften_;
+    /// Number of solutions so we can do something at solution
+    int numberSolutions_;
+
+  };
+
+}/* Ends Bonmin namepace.*/
+#endif

casadi/include/coin/BonIpoptInteriorWarmStarter.hpp

@@ -0,0 +1,103 @@
+// (C) Copyright International Business Machines Corporation 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id$
+//
+// Authors:  Andreas Waechter               IBM    2006-03-02
+
+#ifndef __IPOPTINTERIORWARMSTARTER_HPP__
+#define __IPOPTINTERIORWARMSTARTER_HPP__
+
+#include "IpSmartPtr.hpp"
+#include "IpNLP.hpp"
+#include <vector>
+
+namespace Bonmin
+{
+  class IpoptInteriorWarmStarter : public Ipopt::ReferencedObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Constructor. We give it the values of the current bounds so that
+     *  it can figure out which variables are fixed for this NLP. */
+    IpoptInteriorWarmStarter(Ipopt::Index n, const Ipopt::Number* x_L, const Ipopt::Number* x_u,
+        Ipopt::Number nlp_lower_bound_inf,
+        Ipopt::Number nlp_upper_bound_inf,
+        bool store_several_iterates);
+
+    /** Default destructor */
+    ~IpoptInteriorWarmStarter();
+    //@}
+
+    /** Method for possibly storing another iterate during the current
+     *  optimizatin for possible use for a warm start for a new
+     *  problem */
+    bool UpdateStoredIterates(Ipopt::AlgorithmMode mode,
+        const Ipopt::IpoptData& ip_data,
+        Ipopt::IpoptCalculatedQuantities& ip_cq);
+
+    /** Method for doing whatever needs to be done after the parent NLP
+     *  has been solved */
+    bool Finalize();
+
+    /** Method for computing the initial point based on the stored
+     *  information */
+    bool WarmStartIterate(Ipopt::Index n, const Ipopt::Number* x_l_new, const Ipopt::Number* x_u_new,
+        Ipopt::IteratesVector& warm_start_iterate);
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default constructor. */
+    IpoptInteriorWarmStarter();
+
+    /** Copy Constructor */
+    IpoptInteriorWarmStarter(const IpoptInteriorWarmStarter&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IpoptInteriorWarmStarter&);
+    //@}
+
+    //@{
+    /** Value for a lower bound that denotes -infinity */
+    Ipopt::Number nlp_lower_bound_inf_;
+    /** Value for a upper bound that denotes infinity */
+    Ipopt::Number nlp_upper_bound_inf_;
+    /** Flag indicating whether more than one iterate is to be
+     *  stored. */
+    bool store_several_iterates_;
+    //@}
+
+    /** @name Copy of the bounds for the previously solved NLP.  This is
+     *  required to find out the remapping for fixed variables, and it
+     *  might also help to see how large the perturbation of the new
+     *  problem is. */
+    //@{
+    Ipopt::Index n_;
+    Ipopt::Number* x_l_prev_;
+    Ipopt::Number* x_u_prev_;
+    //@}
+
+    /** @name Selected Iterates and quantities from the previous
+     *  optimization */
+    //@{
+    Ipopt::Index n_stored_iterates_;
+    std::vector<Ipopt::Index> stored_iter_;
+    std::vector<Ipopt::SmartPtr<const Ipopt::IteratesVector> > stored_iterates_;
+    std::vector<Ipopt::Number> stored_mu_;
+    std::vector<Ipopt::Number> stored_nlp_error_;
+    std::vector<Ipopt::Number> stored_primal_inf_;
+    std::vector<Ipopt::Number> stored_dual_inf_;
+    std::vector<Ipopt::Number> stored_compl_;
+    //@}
+  };
+}
+#endif

casadi/include/coin/BonIpoptSolver.hpp

@@ -0,0 +1,188 @@
+// (C) Copyright International Business Machines (IBM) 2005, 2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, IBM
+//
+// Date : 26/09/2006
+
+#ifndef IpoptSolver_HPP
+#define IpoptSolver_HPP
+#include "BonTNLPSolver.hpp"
+#include "IpIpoptApplication.hpp"
+
+
+namespace Bonmin
+{
+  class IpoptSolver: public TNLPSolver
+  {
+  public:
+  class UnsolvedIpoptError: public TNLPSolver::UnsolvedError
+    {
+    public:
+      UnsolvedIpoptError(int errorNum,
+          Ipopt::SmartPtr<TMINLP2TNLP> problem,
+          std::string name):
+          TNLPSolver::UnsolvedError(errorNum, problem, name)
+      {}
+      virtual const std::string& errorName() const;
+
+      virtual const std::string& solverName() const;
+      virtual ~UnsolvedIpoptError()
+      {}
+    private:
+      static std::string errorNames [17];
+      static std::string solverName_;
+    };
+
+    virtual UnsolvedError * newUnsolvedError(int num,
+        Ipopt::SmartPtr<TMINLP2TNLP> problem,
+        std::string name)
+    {
+      return new UnsolvedIpoptError(num, problem, name);
+    }
+
+
+
+    /// Constructor
+    IpoptSolver(bool createEmpty = false);
+
+/// Constructor with Passed in journalist, registered options, options
+    IpoptSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
+        Ipopt::SmartPtr<Ipopt::OptionsList> options,
+        Ipopt::SmartPtr<Ipopt::Journalist> journalist,
+        const std::string & prefix);
+
+/// Constructor with Passed in journalist, registered options, options
+    IpoptSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
+        Ipopt::SmartPtr<Ipopt::OptionsList> options,
+        Ipopt::SmartPtr<Ipopt::Journalist> journalist);
+
+    /// Copy constructor
+    IpoptSolver(const IpoptSolver &other);
+
+    ///virtual copy constructor
+    virtual Ipopt::SmartPtr<TNLPSolver> clone();
+
+    /// Virtual destructor
+    virtual ~IpoptSolver();
+
+    /** Initialize the TNLPSolver (read options from params_file)
+    */
+    virtual bool Initialize(std::string params_file);
+
+    /** Initialize the TNLPSolver (read options from istream is)
+    */
+    virtual bool Initialize(std::istream& is);
+
+    /** @name Solve methods */
+    //@{
+    /// Solves a problem expresses as a TNLP
+    virtual TNLPSolver::ReturnStatus OptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp);
+
+    /// Resolves a problem expresses as a TNLP
+    virtual TNLPSolver::ReturnStatus ReOptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp);
+
+    /// Set the warm start in the solver
+    virtual bool setWarmStart(const CoinWarmStart * warm,
+        Ipopt::SmartPtr<TMINLP2TNLP> tnlp);
+
+   /// Get warm start used in last optimization
+   virtual CoinWarmStart * getUsedWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const;
+
+
+    /// Get the warm start form the solver
+    virtual CoinWarmStart * getWarmStart(Ipopt::SmartPtr<Bonmin::TMINLP2TNLP> tnlp) const;
+
+    virtual CoinWarmStart * getEmptyWarmStart() const;
+
+    /** Check that warm start object is valid.*/
+    virtual bool warmStartIsValid(const CoinWarmStart * ws) const;
+
+    /// Enable the warm start options in the solver
+    virtual void enableWarmStart();
+
+    /// Disable the warm start options in the solver
+    virtual void disableWarmStart();
+
+    //@}
+
+    /// Get the CpuTime of the last optimization.
+    virtual double CPUTime();
+
+    /// Get the iteration count of the last optimization.
+    virtual int IterationCount();
+
+    /// turn off all output from the solver
+    virtual void setOutputToDefault();
+    /// turn on all output from the solver
+    virtual void forceSolverOutput(int log_level);
+
+    /// Get the solver name
+    virtual std::string & solverName()
+    {
+      return solverName_;
+    }
+
+    /// Register this solver options into passed roptions
+    static void RegisterOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions)
+    {
+      Ipopt::IpoptApplication::RegisterAllIpoptOptions(GetRawPtr(roptions));
+    }
+
+
+
+    /// Return status of last optimization
+    Ipopt::ApplicationReturnStatus getOptStatus() const
+    {
+      return optimizationStatus_;
+    }
+
+    Ipopt::IpoptApplication& getIpoptApp()
+    {
+      return *app_;
+    }
+
+    virtual int errorCode() const
+    {
+      return (int) optimizationStatus_;
+    }
+  private:
+    /** Set default Ipopt parameters for use in a MINLP */
+    void setMinlpDefaults(Ipopt::SmartPtr< Ipopt::OptionsList> Options);
+
+    /** get Bonmin return status from Ipopt one. */
+    TNLPSolver::ReturnStatus solverReturnStatus(Ipopt::ApplicationReturnStatus optimization_status) const;
+
+    /** Ipopt application */
+    Ipopt::SmartPtr<Ipopt::IpoptApplication> app_;
+    /** return status of last optimization.*/
+    Ipopt::ApplicationReturnStatus optimizationStatus_;
+    //@}
+
+
+    /** Flag to indicate if last problem solved had 0 dimension. (in this case Ipopt was not called).*/
+    bool problemHadZeroDimension_;
+
+    /** Warm start strategy :
+    <ol>
+    <li> no warm start,</li>
+    <li> simple warm start (optimal point),</li>
+    <li> more elaborate strategies (interior point...).</li>
+    </ol>
+    */
+    int warmStartStrategy_;
+
+    /** flag remembering if we want to use warm start option */
+    bool enable_warm_start_;
+
+    /** flag remembering if we have call the Optimize method of the
+        IpoptInterface before */
+    bool optimized_before_;
+    //name of solver (Ipopt)
+    static std::string  solverName_;
+  };
+}
+#endif
+

casadi/include/coin/BonIpoptWarmStart.hpp

@@ -0,0 +1,148 @@
+// (C) Copyright International Business Machines Corporation, Carnegie Mellon University 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, Carnegie Mellon University,
+// Andreas Waechter, International Business Machines Corporation
+//
+// Date : 02/15/2006
+
+
+#ifndef IpoptWarmStart_HPP
+#define IpoptWarmStart_HPP
+#include "CoinWarmStartBasis.hpp"
+#include "CoinWarmStartPrimalDual.hpp"
+#include "BonIpoptInteriorWarmStarter.hpp"
+
+
+namespace Bonmin
+{
+  class TMINLP2TNLP;
+
+  /** \brief Class for storing warm start informations for Ipopt.<br>
+   * This class inherits from CoinWarmStartPrimalDual, because that's what
+   * this warmstart really is. <br>
+   * For practical reason (integration in Cbc) this class also inherits from
+   * CoinWarmStartBasis. <br>
+   * This class stores a starting point (primal and dual values) for Ipopt.
+   * <br>
+   * <p>
+   * The primal part of the base class contains the value of each primal
+   * variable.
+   * <p>
+   * The dual part of the base class consists of three sections (the number of
+   * values is 2*numcols+numrows):
+     <UL>
+     <li> First, values for dual variables associated with the lower bound
+          constraints on structurals, i.e., primal variables (constraints
+	  \f$ l \leq x \f$); 
+     <li> Then values for dual variables associated with upper bound
+           constraints on structurals (constraints \f$ x \leq u\f$).
+     <li> the values for dual variables associated with regular constraints
+          (constraints \f$ g(x) \leq 0 \f$) 
+     </UL>
+   */
+  class IpoptWarmStart :
+    public virtual CoinWarmStartPrimalDual, public virtual CoinWarmStartBasis
+  {
+  public:
+
+    /// Default constructor
+    IpoptWarmStart(bool empty = 1, int numvars = 0, int numcont = 0);
+    /// Usefull constructor, stores the current optimum of ipopt
+    IpoptWarmStart(const Ipopt::SmartPtr<TMINLP2TNLP> tnlp,
+        Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter);
+    /// Another usefull constructor, stores the passed point
+    IpoptWarmStart(int primal_size, int dual_size,
+                   const double * primal, const double * dual);
+    /// Copy constructor
+    IpoptWarmStart( const IpoptWarmStart &other, bool ownValues = 1);
+    /// A constructor from a CoinWarmStartPrimalDual
+    IpoptWarmStart(const CoinWarmStartPrimalDual& pdws);
+    /// Abstract destructor
+    virtual ~IpoptWarmStart();
+
+    /// `Virtual constructor'
+    virtual CoinWarmStart *clone() const
+    {
+      return new IpoptWarmStart(*this,1);
+    }
+
+    /** Generate the "differences" between two IpoptWarmStart.*/
+    virtual CoinWarmStartDiff*
+    generateDiff(const CoinWarmStart *const oldCWS) const;
+    /** \brief Apply 'differences' to an Ipopt warm start.
+     * What this actually does is get a copy to the vector of values stored
+     in IpoptWarmStartDiff.*/
+    virtual void
+    applyDiff (const CoinWarmStartDiff *const cwsdDiff);
+
+    /** Accessor to warm start information obecjt */
+    Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter() const
+    {
+      return warm_starter_;
+    }
+
+    /// flush the starting point
+    void flushPoint();
+
+    ///Is this an empty warm start?
+    bool empty() const
+    {
+      return empty_;
+    }
+  private:
+    /** warm start information object */
+    mutable Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter_;
+    ///Say if warm start is empty
+    bool empty_;
+  };
+
+  //###########################################################################
+
+  /** \brief Diff class for IpoptWarmStart.
+   * Actually get the differences from CoinWarmStartBasis and stores the
+   whole vector of values.
+   \todo Find a way to free unused values.
+  */
+  class IpoptWarmStartDiff : public CoinWarmStartPrimalDualDiff
+  {
+  public:
+    friend class IpoptWarmStart;
+    /** Useful constructor; takes over the data in \c diff */
+    IpoptWarmStartDiff(CoinWarmStartPrimalDualDiff * diff,
+		       Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter):
+      CoinWarmStartPrimalDualDiff(),
+      warm_starter_(NULL)//(warm_starter)
+    {
+      CoinWarmStartPrimalDualDiff::swap(*diff);
+    }
+    /** Copy constructor. */
+    IpoptWarmStartDiff(const IpoptWarmStartDiff &other):
+        CoinWarmStartPrimalDualDiff(other),
+        warm_starter_(NULL /*other.warm_starter_*/) {}
+
+    /// Abstract destructor
+    virtual ~IpoptWarmStartDiff() {}
+
+    /// `Virtual constructor'
+    virtual CoinWarmStartDiff *clone() const
+    {
+      return new IpoptWarmStartDiff(*this);
+    }
+
+    /** Accessor to warm start information obecjt */
+    Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter() const
+    {
+      return warm_starter_;
+    }
+    void flushPoint();
+  private:
+
+    /** warm start information object */
+    Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter_;
+  };
+
+}
+#endif

casadi/include/coin/BonLinearCutsGenerator.hpp

@@ -0,0 +1,75 @@
+// (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 : 10/06/2007
+
+#ifndef BonLinearCutsGenerator_H
+#define BonLinearCutsGenerator_H
+
+#include "CglCutGenerator.hpp"
+#include "CoinSmartPtr.hpp"
+#include "BonOuterApprox.hpp"
+#include "BonBonminSetup.hpp"
+#include <list>
+
+namespace Bonmin {
+class LinearCutsGenerator : public CglCutGenerator {
+   public:
+    /** Type for cut generation method with its frequency and string identification. */
+    struct CuttingMethod : public Coin::ReferencedObject 
+    {
+      int frequency;
+      std::string id;
+      CglCutGenerator * cgl;
+      bool atSolution;
+      bool normal;
+      CuttingMethod():
+          atSolution(false),
+          normal(true)
+      {}
+
+      CuttingMethod(const CuttingMethod & other):
+          frequency(other.frequency),
+          id(other.id),
+          cgl(other.cgl),
+          atSolution(other.atSolution),
+          normal(other.normal)
+      {}
+    };
+   LinearCutsGenerator():
+     CglCutGenerator(),
+     methods_(){
+   }
+
+
+   LinearCutsGenerator(const LinearCutsGenerator & other):
+    CglCutGenerator(other),
+     methods_(other.methods_){
+   }
+
+   CglCutGenerator * clone() const {
+     return new LinearCutsGenerator(*this);
+   }
+
+   virtual ~LinearCutsGenerator(){
+   }
+
+   bool needsOptimalBasis() { return false;}
+
+   void initialize(BabSetupBase& s);
+
+   void generateCuts(const OsiSolverInterface &solver, OsiCuts &cs,
+		     const CglTreeInfo info = CglTreeInfo());
+
+   private:
+     std::list<Coin::SmartPtr<CuttingMethod> > methods_; 
+};
+
+}/* Ends Bonmin namespace.*/
+
+#endif
+

casadi/include/coin/BonLocalSolverBasedHeuristic.hpp

@@ -0,0 +1,102 @@
+// (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 BonLocalSolverBasedHeuristic_H
+#define BonLocalSolverBasedHeuristic_H
+#include "BonBonminSetup.hpp"
+#include "CbcHeuristic.hpp"
+
+namespace Bonmin {
+  class LocalSolverBasedHeuristic : public CbcHeuristic {
+  public:
+    /** Default constructor.*/
+    LocalSolverBasedHeuristic();
+
+    /** Constructor with setup.*/
+    LocalSolverBasedHeuristic(BonminSetup * setup);
+
+    /** Copy constructor.*/
+    LocalSolverBasedHeuristic(const LocalSolverBasedHeuristic & other);
+
+    /** Destructor.*/
+    ~LocalSolverBasedHeuristic();
+
+    /** Virtual copy constructor.*/
+    virtual CbcHeuristic * clone() const = 0;
+ 
+  /// Assignment operator 
+  LocalSolverBasedHeuristic & operator=(const LocalSolverBasedHeuristic& rhs);
+
+#if 0
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel * model){throw -1;}
+#endif
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel * model){
+   setModel(model);
+  }
+
+  /** Change setup used for heuristic.*/
+  void setSetup(BonminSetup * setup){
+    setup_ = setup;
+    Initialize(setup_->options());
+  }
+  /** Performs heuristic  */
+  virtual int solution(double & objectiveValue,
+		       double * newSolution)=0;
+
+  /** Performs heuristic which adds cuts  */
+  virtual int solution(double & objectiveValue,
+		       double * newSolution,
+		       OsiCuts & cs) {return 0;}
+
+
+   /** Do a local search based on setup and passed solver.*/
+   int doLocalSearch(OsiTMINLPInterface * solver, 
+                      double *solution, 
+                      double & solValue,
+                      double cutoff, std::string prefix = "local_solver.") const;
+
+   /** Register the options common to all local search based heuristics.*/
+   static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+   /** Setup the defaults.*/
+   virtual void setupDefaults(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+
+   /** Initiaize using passed options.*/
+   void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+   protected:
+   /** Setup to use for local searches (will make copies).*/
+   BonminSetup * setup_; 
+
+   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options, 
+                       std::string prefix,
+                       const std::string &option,
+                       const std::string &value);
+   
+   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options, 
+                       std::string prefix,
+                       const std::string &option,
+                       const double &value);
+   
+   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options,
+                       std::string prefix,
+                       const std::string &option,
+                       const int &value);
+   private:
+    /** Time limit in local search.*/
+    double time_limit_;
+    /** maximal number of nodes in local search.*/
+    int max_number_nodes_;
+    /** Maximal number of solutions in local search.*/
+    int max_number_solutions_;
+  };
+} /** ends namespace Bonmin.*/
+
+#endif
+