casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/coin/BonRegisteredOptions.hpp

@@ -0,0 +1,225 @@
+// (C) Copyright International Business Machines Corporation 2007
+//
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, Carnegie Mellon University,
+//
+// Date : 27/08/2007
+
+#ifndef BonRegisteredOptions_H
+#define BonRegisteredOptions_H
+
+#include "IpRegOptions.hpp"
+#include "IpException.hpp"
+#include "CoinError.hpp"
+#include "IpTypes.hpp"
+#include <iostream>
+
+/* Forward declaration, the function will be defined in BonAmplTMINLP.cpp, if ASL is available */
+namespace Ipopt {
+  class AmplOptionsList;
+}
+
+namespace Bonmin {
+/** Class to add a few more information to Ipopt::RegisteredOptions.
+    In particular, it allows to store code to indicate in which algorithm
+    option is available. It also allows to table summing up all the options
+    both in LaTex and html.*/
+class RegisteredOptions: public Ipopt::RegisteredOptions{
+  public:
+    enum ExtraOptInfosBits{
+    validInHybrid=0/** Say that option is valid in Hybrid method (1).*/,
+    validInQG/** Say that option is valid in Quesada Grossmann method (2).*/,
+    validInOA/**Say that option is valid in outer approximation dec (4).*/,
+    validInBBB/** Say that option is valid in the pure branch-and-bound (8).*/,
+    validInEcp/** Say that option is valid in the Ecp (16).*/,
+    validIniFP/** Say that option is valid in the iFP (32).*/,
+    validInCbc/** Say that option is valid when using Cbc_Par (64).*/
+   };
+
+
+/* Table of values
+ * only B-Hyb 1
+ * B-Hyb & B-QG 3
+ * B-Hyb & B-OA 5
+ * B-Hyb & B-QG & B-OA & B-ECP 23
+ */
+
+
+
+   enum ExtraCategoriesInfo{
+    BonminCategory = 0/** Option category is for Bonmin.*/,
+    IpoptCategory /** Option category for Ipopt.*/,
+    FilterCategory /** Option category for FilterSqp.*/,
+    BqpdCategory /** Option category for Bqpd.*/,
+    CouenneCategory /** Option category for Couenne.*/,
+    UndocumentedCategory /**For undocumented options.*/
+   };
+    /** Standard constructor.*/
+    RegisteredOptions():
+       Ipopt::RegisteredOptions(){
+    }
+
+    /** Standard destructor.*/
+    ~RegisteredOptions(){
+    }
+
+   //DECLARE_STD_EXCEPTION(OPTION_NOT_REGISTERED); 
+   /** Set registering category with extra information.*/
+   void SetRegisteringCategory (const std::string &registering_category,
+                                const ExtraCategoriesInfo extra){
+      Ipopt::RegisteredOptions::SetRegisteringCategory(registering_category);
+      categoriesInfos_[registering_category] = extra;}
+ 
+   /** throw if option does not exists.*/
+   inline void optionExists(const std::string & option){
+     if(!IsValid(GetOption(option))){
+       std::string msg = "Try to access option: "+option;
+       msg += "\n Option is not registered.\n";
+       throw CoinError("Bonmin::RegisteredOption","optionExists",msg);
+     }
+   }
+
+   /**Set extra information for option.*/
+   inline void setOptionExtraInfo(const std::string & option, int code){
+      optionExists(option);
+      bonOptInfos_[option] = code;
+   }
+
+   /** Set that option is valid for hybrid.*/
+   inline void optionValidForHybrid(const std::string &option){
+      optionExists(option);
+     bonOptInfos_[option] |= 1 << validInHybrid;}
+
+   /** Set that option is valid for QuesadaGrossmann.*/
+   inline void optionValidForBQG(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validInQG;}
+   
+   /** Set that option is valid for Outer approximation.*/
+   inline void optionValidForBOA(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validInOA;}
+   
+   /** Set that option is valid for pure branch-and-bound.*/
+   inline void optionValidForBBB(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validInBBB;}
+   
+   /** Set that option is valid for B-Ecp.*/
+   inline void optionValidForBEcp(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validInEcp;}
+   
+   /** Set that option is valid for B-iFP.*/
+   inline void optionValidForBiFP(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validIniFP;}
+   
+   /** Set that option is valid for Cbc.*/
+   inline void optionValidForCbc(const std::string &option){
+     optionExists(option);
+     bonOptInfos_[option] |= 1 << validInCbc;}
+
+
+    /** Say if option is valid for hybrid.*/
+   inline bool isValidForHybrid(const std::string &option){
+      optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validInHybrid);
+     else return true;}
+
+   /** Say if option is valid for QuesadaGrossmann.*/
+   inline bool isValidForBQG(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+       return (i->second) & (1 << validInQG);
+     else return true;}
+   
+   /** Say if option is valid for Outer approximation.*/
+   inline bool isValidForBOA(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validInOA);
+     return true;}
+   
+   /** Say if option is valid for pure branch-and-bound.*/
+   inline bool isValidForBBB(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validInBBB);
+     return true;}
+
+   
+   /** Say if option is valid for B-Ecp.*/
+   inline bool isValidForBEcp(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validInEcp);
+     return true;}
+
+   
+   /** Say if option is valid for B-iFP.*/
+   inline bool isValidForBiFP(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validIniFP);
+     return true;}
+
+   
+   /** Say if option is valid for Cbc.*/
+   inline bool isValidForCbc(const std::string &option){
+     optionExists(option);
+     std::map<std::string, int>::iterator i = bonOptInfos_.find(option);
+     if(i != bonOptInfos_.end()) 
+     return (i->second) & (1 << validInCbc);
+     return true;}
+
+
+   /** Output Latex table of options.*/
+   void writeLatexOptionsTable(std::ostream &of, ExtraCategoriesInfo which);
+
+   /** Output html table of options.*/
+   void writeHtmlOptionsTable(std::ostream &of, ExtraCategoriesInfo which);
+
+
+   /** Output Latex/Html ooptions documentation.*/
+   void writeLatexHtmlDoc(std::ostream &of, ExtraCategoriesInfo which);
+  /** Ouptut a bonmin.opt file with options default values and short descriptions.*/
+  void writeBonminOpt(std::ostream &os, ExtraCategoriesInfo which);
+
+   /** Get info about what a category is taking care of (e.g., Ipopt, Bonmin, FilterSQP,...) .*/
+   ExtraCategoriesInfo categoriesInfo(const std::string &s)
+   {
+      std::map<std::string, ExtraCategoriesInfo>::iterator i = categoriesInfos_.find(s);
+      if(i == categoriesInfos_.end())
+        return IpoptCategory;
+      return i->second;
+   }
+  
+   /* Forward declaration, the function will be defined in BonAmplTMINLP.cpp*/
+   void fillAmplOptionList(ExtraCategoriesInfo which, Ipopt::AmplOptionsList * amplOptList);
+
+   private:
+   /** Output Latex table of options.*/
+   void chooseOptions(ExtraCategoriesInfo which, std::list<Ipopt::RegisteredOption *> &options);
+   /** Output html table of options.*/
+   void writeHtmlOptionsTable(std::ostream & os, std::list<Ipopt::RegisteredOption *> &options);
+   /** Store extra Informations on Bonmin options.*/
+   std::map<std::string, int> bonOptInfos_;
+   /** Store extra Informations on Registering categories
+       (is bonmin, filterSqp...).*/
+   std::map<std::string, ExtraCategoriesInfo> categoriesInfos_;
+};
+
+}/*Ends namespace Bonmin.*/
+#endif
+

casadi/include/coin/BonStrongBranchingSolver.hpp

@@ -0,0 +1,69 @@
+// Copyright (C) 2007, International Business Machines
+// Corporation and others.  All Rights Reserved.
+//
+// Author:  Andreas Waechter      2007-08-20    IBM
+//
+#ifndef BonStrongBranchingSolver_H
+#define BonStrongBranchingSolver_H
+
+#include "BonOsiTMINLPInterface.hpp"
+#include "BonRegisteredOptions.hpp"
+namespace Bonmin {
+
+/** This class is the base class for a solver that can be used in
+ *  BonOsiSolverInterface to perform the strong branching solves.
+*/
+
+class StrongBranchingSolver : public Ipopt::ReferencedObject  {
+ 
+public:
+
+  /// Constructor from solver
+  StrongBranchingSolver (OsiTMINLPInterface * solver);
+
+  /// Assignment operator 
+  StrongBranchingSolver & operator= (const StrongBranchingSolver& rhs);
+  /// Copy constructor
+  StrongBranchingSolver(const StrongBranchingSolver& rhs);
+
+  /// Destructor
+  virtual ~StrongBranchingSolver ();
+
+  /// Called to initialize solver before a bunch of strong branching
+  /// solves
+  virtual void markHotStart(OsiTMINLPInterface* tminlp_interface) = 0;
+
+  /// Called to solve the current TMINLP (with changed bound information)
+  virtual TNLPSolver::ReturnStatus solveFromHotStart(OsiTMINLPInterface* tminlp_interface) = 0;
+
+  /// Called after all strong branching solves in a node
+  virtual void unmarkHotStart(OsiTMINLPInterface* tminlp_interface) = 0;
+
+protected:
+
+  inline Ipopt::SmartPtr<Ipopt::Journalist>& Jnlst()
+  {
+    return jnlst_;
+  }
+  inline Ipopt::SmartPtr<Ipopt::OptionsList>& Options()
+  {
+    return options_;
+  }
+  inline Ipopt::SmartPtr<RegisteredOptions>& RegOptions()
+  {
+    return reg_options_;
+  }
+private:
+  /** Default Constructor, forbiden for some reason.*/
+  StrongBranchingSolver ();
+
+  Ipopt::SmartPtr<Ipopt::Journalist> jnlst_;
+  Ipopt::SmartPtr<Ipopt::OptionsList> options_;
+  Ipopt::SmartPtr<Bonmin::RegisteredOptions> reg_options_;
+
+  int bb_log_level_;
+
+};
+
+}
+#endif

casadi/include/coin/BonSubMipSolver.hpp

@@ -0,0 +1,143 @@
+// (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
+
+
+// Code separated from BonOaDecBase to try to clarify OAs
+#ifndef BonSubMipSolver_HPP
+#define BonSubMipSolver_HPP
+#include "IpSmartPtr.hpp"
+#include <string>
+/* forward declarations.*/
+class OsiSolverInterface;
+class OsiClpSolverInterface;
+class OsiCpxSolverInterface;
+class CbcStrategy;
+class CbcStrategyDefault;
+
+#include "OsiCuts.hpp"
+
+namespace Bonmin {
+    class RegisteredOptions;
+    class BabSetupBase; 
+    /** A very simple class to provide a common interface for solving MIPs with Cplex and Cbc.*/
+    class SubMipSolver
+    {
+    public:
+      enum MILP_solve_strategy{
+         FindGoodSolution,
+         GetOptimum};
+      /** Constructor */
+      SubMipSolver(BabSetupBase &b, const std::string &prefix);
+
+      /** Copy Constructor */
+      SubMipSolver(const SubMipSolver &copy);
+
+      ~SubMipSolver();
+
+      /** Assign lp solver. */
+      void setLpSolver(OsiSolverInterface * lp);
+
+      /** Assign a strategy. */
+      void setStrategy(CbcStrategyDefault * strategy);
+
+      /** get the solution found in last local search (return NULL if no solution). */
+      const double * getLastSolution()
+      {
+        return integerSolution_;
+      }
+
+      double getLowerBound()
+      {
+        return lowBound_;
+      }
+
+      void solve(double cutoff,
+          int loglevel,
+          double maxTime){
+         if(milp_strat_ == FindGoodSolution){
+            find_good_sol(cutoff, loglevel, maxTime);
+         }
+         else
+            optimize(cutoff, loglevel, maxTime);
+      }
+ 
+
+      /** update cutoff and perform a local search to a good solution. */
+      void find_good_sol(double cutoff,
+          int loglevel,
+          double maxTime);
+
+      /** update cutoff and optimize MIP. */
+      void optimize(double cutoff,
+          int loglevel,
+          double maxTime);
+
+      /** update cutoff, put OA constraints in cs as lazy constraints and optimize MIP. */
+      void optimize_with_lazy_constraints(double cutoff,
+          int loglevel,
+          double maxTime, const OsiCuts & cs);
+
+      /** Returns lower bound. */
+      inline double lowBound()
+      {
+        return lowBound_;
+      }
+
+      /** returns optimality status. */
+      inline bool optimal()
+      {
+        return optimal_;
+      }
+
+      /** Returns number of nodes in last solve.*/
+      inline int nodeCount()
+      {
+        return nodeCount_;
+      }
+
+      /** Returns number of simplex iterations in last solve.*/
+      inline int iterationCount()
+      {
+        return iterationCount_;
+      }
+
+
+      OsiSolverInterface * solver();
+
+     /** Register options for that Oa based cut generation method. */
+     static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+    private:
+      /** If lp solver is clp (then have to use Cbc) (not owned).*/
+      OsiClpSolverInterface *clp_;
+      /** If mip solver is cpx this is it (owned). */
+      OsiCpxSolverInterface * cpx_;
+      /** lower bound obtained */
+      double lowBound_;
+      /** Is optimality proven? */
+      bool optimal_;
+      /** Has an integer solution? then it is here*/
+      double * integerSolution_;
+      /** Strategy for solving sub mips with cbc. */
+      CbcStrategyDefault * strategy_;
+      /** number of nodes in last mip solved.*/
+      int nodeCount_;
+      /** number of simplex iteration in last mip solved.*/
+      int iterationCount_;
+      /** MILP search strategy.*/
+      MILP_solve_strategy milp_strat_;
+      /** setting for gap tolerance.*/
+      double gap_tol_;
+      /** say if owns copy of clp_.*/
+      bool ownClp_;
+    };
+
+}
+
+#endif
+