casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonTNLPSolver.hpp

@@ -0,0 +1,241 @@
+// (C) Copyright International Business Machines (IBM) 2006, 2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, IBM
+//
+// Date : 26/09/2006
+
+
+#ifndef TNLPSolver_H
+#define TNLPSolver_H
+#include "IpTNLP.hpp"
+#include "BonTMINLP2TNLP.hpp"
+
+//Some declarations
+#include "IpOptionsList.hpp"
+#include "CoinWarmStart.hpp"
+#include "BonRegisteredOptions.hpp"
+#include "CoinTime.hpp"
+namespace Bonmin  {
+/** This is a generic class for calling an NLP solver to solve a TNLP.
+    A TNLPSolver is able to solve and resolve a problem, it has some options (stored
+    with Ipopt OptionList structure and registeredOptions) it produces some statistics (in SolveStatisctics and sometimes some errorCodes.
+*/
+class TNLPSolver: public Ipopt::ReferencedObject{
+ public:
+
+  enum ReturnStatus /** Standard return statuses for a solver*/{
+    iterationLimit = -3/** Solver reached iteration limit. */,
+    timeLimit = 5/** Solver reached iteration limit. */,
+    doesNotConverge = -8/** Algorithm does not converge.*/,
+    computationError = -2/** Some error was made in the computations. */,
+    notEnoughFreedom = -1/** not enough degrees of freedom.*/,
+    illDefinedProblem = -4/** The solver finds that the problem is not well defined. */,
+    illegalOption =-5/** An option is not valid. */,
+    externalException =-6/** Some unrecovered exception occurred in an external tool used by the solver. */,
+    exception =-7/** Some unrocevered exception */,
+    solvedOptimal = 1/** Problem solved to an optimal solution.*/,
+    solvedOptimalTol =2/** Problem solved to "acceptable level of tolerance. */,
+    provenInfeasible =3/** Infeasibility Proven. */,
+    unbounded = 4/** Problem is unbounded.*/,
+    numReturnCodes/**Fake member to know size*/
+  };
+
+
+
+//#############################################################################
+
+  /** We will throw this error when a problem is not solved.
+      Eventually store the error code from solver*/
+  class UnsolvedError
+  {
+  public:
+    /** Constructor */
+    UnsolvedError(int errorNum = -10000, 
+                  Ipopt::SmartPtr<TMINLP2TNLP> model = NULL,
+                  std::string name="")
+    :
+     errorNum_(errorNum),
+     model_(model),
+     name_(name)
+    {if(name_=="") 
+{
+#ifndef NDEBUG
+	std::cerr<<"FIXME"<<std::endl;
+#endif
+}}
+    /** Print error message.*/
+    void printError(std::ostream & os);
+    /** Get the string corresponding to error.*/
+    virtual const std::string& errorName() const = 0;
+    /** Return the name of the solver. */
+    virtual const std::string& solverName() const = 0;
+    /** Return error number. */
+    int errorNum() const{
+    return errorNum_;}
+    /** destructor. */
+    virtual ~UnsolvedError(){}
+    /** write files with differences between input model and
+        this one */
+    void writeDiffFiles(const std::string prefix=std::string()) const;
+  private:
+    /** Error code (solver dependent). */
+    int errorNum_;
+
+    /** model_ on which error occured*/
+    Ipopt::SmartPtr< TMINLP2TNLP > model_;
+
+    /** name of the model on which error occured. */
+    std::string name_;
+  }
+  ;
+
+  virtual UnsolvedError * newUnsolvedError(int num,
+					   Ipopt::SmartPtr<TMINLP2TNLP> problem,
+					   std::string name) = 0;
+ 
+
+
+  /// default Constructor
+   TNLPSolver();
+
+  ///Constructor with options initialization
+TNLPSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
+           Ipopt::SmartPtr<Ipopt::OptionsList> options,
+           Ipopt::SmartPtr<Ipopt::Journalist> journalist,
+           const std::string & prefix);
+
+  ///virtual copy constructor
+  virtual Ipopt::SmartPtr<TNLPSolver> clone() = 0;
+
+   /// Virtual destructor
+   virtual ~TNLPSolver();
+
+   /** Initialize the TNLPSolver (read options from params_file)
+   */
+   virtual bool Initialize(std::string params_file) = 0;
+
+   /** Initialize the TNLPSolver (read options from istream is)
+   */
+   virtual bool Initialize(std::istream& is) = 0;
+
+   /** @name Solve methods */
+   //@{
+   /// Solves a problem expresses as a TNLP 
+   virtual ReturnStatus OptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp) = 0;
+
+   /// Resolves a problem expresses as a TNLP 
+   virtual ReturnStatus ReOptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp) = 0;
+
+  /// Set the warm start in the solver
+  virtual bool setWarmStart(const CoinWarmStart * warm, 
+                            Ipopt::SmartPtr<TMINLP2TNLP> tnlp) = 0;
+
+/// Get warm start used in last optimization
+  virtual CoinWarmStart * getUsedWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const = 0;
+
+  /// Get the warm start form the solver
+  virtual CoinWarmStart * getWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const = 0;
+
+  virtual CoinWarmStart * getEmptyWarmStart() const = 0;
+
+  /** Check that warm start object is valid.*/
+  virtual bool warmStartIsValid(const CoinWarmStart * ws) const = 0;  
+
+  /// Enable the warm start options in the solver
+  virtual void enableWarmStart() = 0;
+
+  /// Disable the warm start options in the solver
+  virtual void disableWarmStart() = 0;
+   //@}
+
+  ///Get a pointer to a journalist
+  Ipopt::SmartPtr<Ipopt::Journalist> journalist(){
+    return journalist_;}
+
+   ///Get a pointer to RegisteredOptions (generally used to add new ones)
+   Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions(){
+     return roptions_;}
+
+   /// Get the options (for getting their values).
+   Ipopt::SmartPtr<const Ipopt::OptionsList> options() const {
+     return ConstPtr(options_);}
+
+   /// Get the options (for getting and setting their values).
+   Ipopt::SmartPtr<Ipopt::OptionsList> options() {
+     return options_;}
+
+  /// Get the prefix
+  const char * prefix(){
+    return prefix_.c_str();
+  }
+   /// Register this solver options into passed roptions
+static void RegisterOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions){}
+
+   /// Get the CpuTime of the last optimization.
+   virtual double CPUTime() = 0;
+
+   /// Get the iteration count of the last optimization.
+   virtual int IterationCount() = 0;
+
+
+  /// turn off all output from the solver 
+  virtual void setOutputToDefault() = 0 ;
+  /// turn on all output from the solver
+  virtual void forceSolverOutput(int log_level) = 0;
+  /// Get the solver name
+  virtual std::string & solverName() = 0;
+
+    /** Say if an optimization status for a problem which failed is recoverable
+        (problem may be solvable).*/
+  bool isRecoverable(ReturnStatus &r);
+
+  /** Setup for a global time limit for solver.*/
+  void setup_global_time_limit(double time_limit){
+    time_limit_ = time_limit + 5;
+    start_time_ = CoinCpuTime();
+  }
+
+  /** Say if return status is an error.*/
+  bool isError(ReturnStatus &r){
+    return r < 0;}
+  /** Error code (solver specific).*/
+virtual int errorCode() const = 0;
+protected:
+   /** Determine if problem is of dimension zero and if it is check if solution
+       is feasible.*/
+   bool zeroDimension(const Ipopt::SmartPtr<Ipopt::TNLP> &tnlp, 
+		     ReturnStatus &optimization_status);
+
+   /** Initializes options and journalist.*/
+   void initializeOptionsAndJournalist();
+
+    /** Storage of Journalist for output */
+    Ipopt::SmartPtr<Ipopt::Journalist> journalist_;
+    
+    /** List of Options */
+    Ipopt::SmartPtr<Ipopt::OptionsList> options_;
+    
+    /** Registered Options */
+    Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions_;
+   
+    /** Prefix to use for reading bonmin's options.*/
+   std::string prefix_;
+   /** Global start time.*/
+   double start_time_;
+
+   /** Global time limit.*/
+   double time_limit_;
+
+   /** To record default log level.*/
+   int default_log_level_;
+  /// Copy Constructor
+  TNLPSolver(const TNLPSolver & other);
+
+};
+}
+#endif
+
+

casadi/include/coin/BonTypes.hpp

@@ -0,0 +1,95 @@
+#ifndef __BonTypes_H_
+#define __BonTypes_H_
+#include<vector>
+#include "CoinSmartPtr.hpp"
+
+namespace Bonmin {
+/** A small wrap around std::vector to give easy access to array for interfacing with fortran code.*/
+template<typename T>
+class vector : public std::vector<T>{
+public:
+  /** Default constructor.*/
+  vector(): std::vector<T>(){}
+  /** Constructor with initialization.*/
+  vector(size_t n, const T& v): std::vector<T>(n,v){}
+  /** Copy constructor.*/
+  vector(const vector<T>& other): std::vector<T>(other){}
+  /** Copy constructor.*/
+  vector(const std::vector<T>& other): std::vector<T>(other){}
+  /** constructor with size.*/
+  vector(size_t n): std::vector<T>(n){}
+  /** Assignment.*/
+  vector<T>& operator=(const vector<T>& other){
+     std::vector<T>::operator=(other);
+     return (*this);}
+  /** Assignment.*/
+  vector<T>& operator=(const std::vector<T>& other){
+     return std::vector<T>::operator=(other);
+     return (*this);}
+
+/** Access pointer to first element of storage.*/
+inline T* operator()(){
+  return &(*std::vector<T>::begin());
+}
+/** Access pointer to first element of storage.*/
+inline const T* operator()() const {
+  return &(*std::vector<T>::begin());
+}
+};
+
+//structure to store an object of class X in a Coin::ReferencedObject
+template<class X>
+struct SimpleReferenced : public Coin::ReferencedObject {
+ /** The object.*/
+ X object;
+
+ const X& operator()() const{
+   return object;}
+
+ X& operator()() {
+   return object;}
+
+};
+//structure to store a pointer to an object of class X in a 
+// Coin::ReferencedObject
+template<class X>
+struct SimpleReferencedPtr : public Coin::ReferencedObject {
+ /** The object.*/
+ X * object;
+
+ SimpleReferencedPtr():
+   object(NULL){}
+
+ ~SimpleReferencedPtr(){
+   delete object;}
+
+ const X& operator()() const{
+   return *object;}
+
+ X& operator()() {
+   return *object;}
+
+ const X* ptr() const{
+    return object;}
+
+ X* ptr(){
+    return object;}
+};
+
+template <class X>
+SimpleReferenced<X> * make_referenced(X other){
+  SimpleReferenced<X> * ret_val = new SimpleReferenced<X>;
+  ret_val->object = other;
+  return ret_val;
+}
+template <class X>
+SimpleReferencedPtr<X> * make_referenced(X* other){
+  SimpleReferencedPtr <X> * ret_val = new SimpleReferencedPtr<X>;
+  ret_val->object = other;
+  return ret_val;
+}
+
+
+}
+#endif
+

casadi/include/coin/BonminConfig.h

@@ -0,0 +1,19 @@
+/* src/Interfaces/config_bonmin.h.  Generated by configure.  */
+/* src/Interfaces/config_bonmin.h.in. */
+
+#ifndef __CONFIG_BONMIN_H__
+#define __CONFIG_BONMIN_H__
+
+/* Version number of project */
+#define BONMIN_VERSION "1.8.9"
+
+/* Major Version number of project */
+#define BONMIN_VERSION_MAJOR 1
+
+/* Minor Version number of project */
+#define BONMIN_VERSION_MINOR 8
+
+/* Release Version number of project */
+#define BONMIN_VERSION_RELEASE 9
+
+#endif

casadi/include/coin/CbcBranchActual.hpp

@@ -0,0 +1,26 @@
+/* $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).
+
+#ifndef CbcBranchActual_H
+#define CbcBranchActual_H
+
+#include "CbcBranchBase.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CbcClique.hpp"
+#include "CbcSOS.hpp"
+#include "CbcSimpleInteger.hpp"
+#include "CbcNWay.hpp"
+#include "CbcSimpleIntegerPseudoCost.hpp"
+#include "CbcBranchDefaultDecision.hpp"
+#include "CbcFollowOn.hpp"
+#include "CbcFixVariable.hpp"
+#include "CbcDummyBranchingObject.hpp"
+#include "CbcGeneral.hpp"
+#include "CbcGeneralDepth.hpp"
+#include "CbcSubProblem.hpp"
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchAllDifferent.hpp

@@ -0,0 +1,61 @@
+// $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).
+
+// Edwin 11/13/2009-- carved out of CbcBranchCut
+
+#ifndef CbcBranchAllDifferent_H
+#define CbcBranchAllDifferent_H
+
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CbcBranchCut.hpp"
+
+/** Define a branch class that branches so that it is only satsified if all
+    members have different values
+    So cut is x <= y-1 or x >= y+1
+*/
+
+class CbcBranchAllDifferent : public CbcBranchCut {
+
+public:
+  // Default Constructor
+  CbcBranchAllDifferent();
+
+  /** Useful constructor - passed set of integer variables which must all be different
+    */
+  CbcBranchAllDifferent(CbcModel *model, int number, const int *which);
+
+  // Copy constructor
+  CbcBranchAllDifferent(const CbcBranchAllDifferent &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcBranchAllDifferent &operator=(const CbcBranchAllDifferent &rhs);
+
+  // Destructor
+  ~CbcBranchAllDifferent();
+
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation *info,
+    int &preferredWay) const;
+
+  /// Creates a branching object
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way);
+
+protected:
+  /// data
+
+  /// Number of entries
+  int numberInSet_;
+  /// Which variables
+  int *which_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchBase.hpp

@@ -0,0 +1,79 @@
+/* $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).
+
+#ifndef CbcBranchBase_H
+#define CbcBranchBase_H
+
+#include <string>
+#include <vector>
+#include "OsiBranchingObject.hpp"
+
+enum CbcRangeCompare {
+  CbcRangeSame,
+  CbcRangeDisjoint,
+  CbcRangeSubset,
+  CbcRangeSuperset,
+  CbcRangeOverlap
+};
+
+#include "CbcObject.hpp"
+#include "CbcBranchingObject.hpp"
+#include "CbcBranchDecision.hpp"
+#include "CbcConsequence.hpp"
+#include "CbcObjectUpdateData.hpp"
+
+//##############################################################################
+
+/** Compare two ranges. The two bounds arrays are both of size two and
+    describe closed intervals. 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 content of thisBd
+    with the intersection of the ranges.
+*/
+static inline CbcRangeCompare
+CbcCompareRanges(double *thisBd, const double *otherBd,
+  const bool replaceIfOverlap)
+{
+  const double lbDiff = thisBd[0] - otherBd[0];
+  if (lbDiff < 0) { // lb of this < lb of other
+    if (thisBd[1] >= otherBd[1]) { // ub of this >= ub of other
+      return CbcRangeSuperset;
+    } else if (thisBd[1] < otherBd[0]) {
+      return CbcRangeDisjoint;
+    } else {
+      // overlap
+      if (replaceIfOverlap) {
+        thisBd[0] = otherBd[0];
+      }
+      return CbcRangeOverlap;
+    }
+  } else if (lbDiff > 0) { // lb of this > lb of other
+    if (thisBd[1] <= otherBd[1]) { // ub of this <= ub of other
+      return CbcRangeSubset;
+    } else if (thisBd[0] > otherBd[1]) {
+      return CbcRangeDisjoint;
+    } else {
+      // overlap
+      if (replaceIfOverlap) {
+        thisBd[1] = otherBd[1];
+      }
+      return CbcRangeOverlap;
+    }
+  } else { // lb of this == lb of other
+    if (thisBd[1] == otherBd[1]) {
+      return CbcRangeSame;
+    }
+    return thisBd[1] < otherBd[1] ? CbcRangeSubset : CbcRangeSuperset;
+  }
+
+  return CbcRangeSame; // fake return
+}
+
+//#############################################################################
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcBranchCut.hpp

@@ -0,0 +1,182 @@
+/* $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 CbcBranchCut_H
+#define CbcBranchCut_H
+
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Define a cut branching class.
+    At present empty - all stuff in descendants
+*/
+
+class CbcBranchCut : public CbcObject {
+
+public:
+  // Default Constructor
+  CbcBranchCut();
+
+  /** In to maintain normal methods
+    */
+  CbcBranchCut(CbcModel *model);
+  // Copy constructor
+  CbcBranchCut(const CbcBranchCut &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcBranchCut &operator=(const CbcBranchCut &rhs);
+
+  // Destructor
+  ~CbcBranchCut();
+
+  /// Infeasibility
+  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.
+
+      At present this will do nothing
+    */
+  virtual void feasibleRegion();
+
+  /** \brief Return true if branch created by object should fix variables
+    */
+  virtual bool boundBranch() const;
+
+  /// 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.
+
+      At present this does nothing
+    */
+  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.
+
+      At present this does nothing
+    */
+  virtual CbcBranchingObject *notPreferredNewFeasible() const;
+
+  using CbcObject::resetBounds;
+  /** 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();
+
+protected:
+  /// data
+};
+/** Cut branching object
+
+  This object can specify a two-way branch in terms of two cuts
+*/
+
+class CbcCutBranchingObject : public CbcBranchingObject {
+
+public:
+  /// Default constructor
+  CbcCutBranchingObject();
+
+  /** Create a cut branching object
+
+        Cut down will applied on way=-1, up on way==1
+        Assumed down will be first so way_ set to -1
+    */
+  CbcCutBranchingObject(CbcModel *model, OsiRowCut &down, OsiRowCut &up, bool canFix);
+
+  /// Copy constructor
+  CbcCutBranchingObject(const CbcCutBranchingObject &);
+
+  /// Assignment operator
+  CbcCutBranchingObject &operator=(const CbcCutBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  /// Destructor
+  virtual ~CbcCutBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /** \brief Sets the bounds for variables or adds a cut depending on the
+               current arm of the branch and advances the object state to the next arm.
+           Returns change in guessed objective on next branch
+    */
+  virtual double branch();
+
+  using CbcBranchingObject::print;
+  /** \brief Print something about branch - only if log level high
+    */
+  virtual void print();
+
+  /** \brief Return true if branch should fix variables
+    */
+  virtual bool boundBranch() const;
+
+  /** Return the type (an integer identifier) of \c this */
+  virtual CbcBranchObjType type() const
+  {
+    return CutBranchingObj;
+  }
+
+  /** Compare the original object of \c this with the original object of \c
+        brObj. Assumes that there is an ordering of the original objects.
+        This method should be invoked only if \c this and brObj are of the same
+        type.
+        Return negative/0/positive depending on whether \c this is
+        smaller/same/larger than the argument.
+    */
+  virtual int compareOriginalObject(const CbcBranchingObject *brObj) const;
+
+  /** 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:
+  /// Cut for the down arm (way_ = -1)
+  OsiRowCut down_;
+  /// Cut for the up arm (way_ = 1)
+  OsiRowCut up_;
+  /// True if one way can fix variables
+  bool canFix_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/