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

casadi/include/coin/BonOuterApprox.hpp

@@ -0,0 +1,123 @@
+// (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/16/2007
+#ifndef BonminOuterApprox_H
+#define BonminOuterApprox_H
+
+#include <cmath>
+
+namespace Bonmin{
+   class OsiTMINLPInterface;
+   class BabSetupBase;
+}
+class OsiSolverInterface;
+namespace Bonmin {
+  /** A class to build outer approximations.*/
+  class OuterApprox{
+
+  public:
+
+   /** Default constructor.*/
+   OuterApprox():
+    tiny_(-0.),
+    veryTiny_(-0.)
+   {}
+
+   /** Copy constructor.*/
+   OuterApprox(const OuterApprox & other):
+    tiny_(other.tiny_),
+    veryTiny_(other.veryTiny_){
+    }
+
+
+   /** Assignment operator.*/
+   OuterApprox & operator=(const OuterApprox& rhs){
+    if(this != & rhs){
+      tiny_ = rhs.tiny_;
+      veryTiny_ = rhs.veryTiny_;}
+    return (*this);
+   }
+
+   /** Destructor.*/
+   ~OuterApprox(){}
+
+   /** Initialize using options.*/
+   void initialize(Bonmin::BabSetupBase &b);
+
+   /** Build the Outer approximation in minlp and put it in si.*/
+   void extractLinearRelaxation(Bonmin::OsiTMINLPInterface &minlp,
+                                OsiSolverInterface *si, 
+                                const double * x, bool getObj);
+   /** Operator() calls extractLinearRelaxation*/
+   void operator()(Bonmin::OsiTMINLPInterface &minlp,
+                   OsiSolverInterface *si,
+                   const double * x, bool getObj){
+       extractLinearRelaxation(minlp, si, x, getObj);}
+
+   private:
+   /** Facilitator to clean up coefficient.*/
+  inline bool cleanNnz(double &value, double colLower, double colUpper,
+    double rowLower, double rowUpper, double colsol,
+    double & lb, double &ub, double tiny, double veryTiny);
+   /** If constraint coefficient is below this, we try to remove it.*/
+   double tiny_;
+   /** If constraint coefficient is below this, we neglect it.*/
+   double veryTiny_;
+   /** Count the number of linear outer approximations taken.*/
+   static int nTimesCalled;
+  };
+
+//A procedure to try to remove small coefficients in OA cuts (or make it non small
+inline
+bool 
+OuterApprox::cleanNnz(double &value, double colLower, double colUpper,
+    double rowLower, double rowUpper, double colsol,
+    double & lb, double &ub, double tiny, double veryTiny)
+{
+  if(fabs(value)>= tiny) return 1;
+
+  if(fabs(value)<veryTiny) return 0;//Take the risk?
+
+  //try and remove
+  double infty = 1e20;
+  bool colUpBounded = colUpper < 10000;
+  bool colLoBounded = colLower > -10000;
+  bool rowNotLoBounded =  rowLower <= - infty;
+  bool rowNotUpBounded = rowUpper >= infty;
+  bool pos =  value > 0;
+
+  if(colLoBounded && pos && rowNotUpBounded) {
+    lb += value * (colsol - colLower);
+    return 0;
+  }
+  else
+    if(colLoBounded && !pos && rowNotLoBounded) {
+      ub += value * (colsol - colLower);
+      return 0;
+    }
+    else
+      if(colUpBounded && !pos && rowNotUpBounded) {
+        lb += value * (colsol - colUpper);
+        return 0;
+      }
+      else
+        if(colUpBounded && pos && rowNotLoBounded) {
+          ub += value * (colsol - colUpper);
+          return 0;
+        }
+  //can not remove coefficient increase it to smallest non zero
+  if(pos) value = tiny;
+  else
+    value = - tiny;
+  return 1;
+}
+
+}
+
+#endif
+

casadi/include/coin/BonPseudoCosts.hpp

@@ -0,0 +1,91 @@
+// (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 : 04/12/2007
+
+#ifndef BonPseudoCosts_H
+#define BonPseudoCosts_H
+
+#include "OsiChooseVariable.hpp"
+namespace Bonmin
+{
+
+  class PseudoCosts: public OsiPseudoCosts
+  {
+  public:
+    /** Default constructor.*/
+    PseudoCosts();
+
+    /** Copy constructor.*/
+    PseudoCosts(const PseudoCosts & rhs);
+
+    /** Assignment operator const version.*/
+    PseudoCosts & operator=(const PseudoCosts&rhs);
+#if 0
+    /** Acces upTotalChange.*/
+    inline double * upTotalChange()
+    {
+      return upTotalChange_;
+    }
+
+    /** Acces downTotalChange.*/
+    inline double * downTotalChange()
+    {
+      return downTotalChange_;
+    }
+
+    /** Acces upNumber.*/
+    inline int * upNumber()
+    {
+      return upNumber_;
+    }
+
+    /** Acces downNumber.*/
+    inline int * downNumber()
+    {
+      return downNumber_;
+    }
+
+    /** Acces upTotalChange.*/
+    inline const double * upTotalChange() const
+    {
+      return upTotalChange_;
+    }
+
+    /** Acces downTotalChange.*/
+    inline const double * downTotalChange() const
+    {
+      return downTotalChange_;
+    }
+
+    /** Acces upNumber.*/
+    inline const int * upNumber() const
+    {
+      return upNumber_;
+    }
+
+    /** Acces downNumber.*/
+    inline const int * downNumber() const
+    {
+      return downNumber_;
+    }
+
+    /** Access number objects.*/
+    inline int numberObjects() const
+    {
+      return numberObjects_;
+    }
+#endif
+    /** Add a pseudo cost information.*/
+    void addInfo(int way, double originalObj, double originalInfeas,
+        double newObj, double newInfeas, int status);
+
+  };
+
+}/* End Bonmin namespace.*/
+
+#endif

casadi/include/coin/BonPumpForMinlp.hpp

@@ -0,0 +1,45 @@
+// (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 : 02/18/2009
+
+#ifndef BonPumpForMinlp_H
+#define BonPumpForMinlp_H
+#include "BonLocalSolverBasedHeuristic.hpp"
+
+namespace Bonmin {
+  class PumpForMinlp:public LocalSolverBasedHeuristic {
+    public:
+     /** Default constructor*/
+     PumpForMinlp();
+    /** Constructor with setup.*/
+    PumpForMinlp(BonminSetup * setup);
+
+     /** Copy constructor.*/
+     PumpForMinlp(const PumpForMinlp &other);
+     /** Virtual constructor.*/
+     virtual CbcHeuristic * clone() const{
+      return new PumpForMinlp(*this);
+     }
+
+     /** Destructor*/
+     virtual ~PumpForMinlp();
+
+     /** 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);
+
+   /** Setup the defaults.*/
+   virtual void setupDefaults(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+   /** Initiaize using passed options.*/
+   void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+  };
+
+}/* Ends Bonmin namepace.*/
+#endif
+

casadi/include/coin/BonQuadCut.hpp

@@ -0,0 +1,217 @@
+// (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 BonQuadCut_H
+#define BonQuadCut_H
+
+#include "CoinPackedMatrix.hpp"
+#include "OsiRowCut.hpp"
+#include "OsiCuts.hpp"
+#include "BonTypes.hpp"
+#include <list>
+
+
+namespace Bonmin {
+
+  enum MatrixStorageType {
+   Upper /** Stores only the upper triangle of a symetric Q.*/,
+   Lower /** Stores the lower triangle of a symetric Q.*/,
+   Full /** Stores the whole matrix of a non-symetric Q.*/};
+
+class QuadCut : public OsiRowCut {
+ public:
+
+  /// Default constructor
+  QuadCut();
+
+  /// Copy constructor
+  QuadCut(const QuadCut & other);
+
+  /// Assignment operator
+  QuadCut& operator=(const QuadCut & rhs);
+
+  /// Virtual copy
+  virtual OsiRowCut * clone() const;
+
+  /// Destructor
+  ~QuadCut(); 
+
+  /// Print
+  void print() const; 
+
+  ///Return the matrix stored
+  CoinPackedMatrix& Q(){
+   return Q_;
+  }
+
+  ///Return the matrix stored
+  const CoinPackedMatrix& Q() const{
+   return Q_;
+  }
+
+  /// Acces storage type
+  /// Acces storage type
+  MatrixStorageType& type(){
+    return type_;}
+
+  const MatrixStorageType& type() const{
+    return type_;}
+
+  /// Acces the constant
+  double & c(){return c_;}
+
+  /// Acces the constant
+  const double & c() const {return c_;}
+
+  /// Compute cut violation
+  double violated(const double * solution) const;
+
+ private:
+   /// Stores the constant part of the cut
+   double c_;
+   ///Stores quadratic part of cut
+   CoinPackedMatrix Q_;
+   ///Storage type
+   MatrixStorageType type_;
+
+   /** \name Arithmetic operators not implemented.*/
+  //@{
+    /// add <code>value</code> to every vector entry
+    void operator+=(double value);
+
+    /// subtract <code>value</code> from every vector entry
+    void operator-=(double value);
+
+    /// multiply every vector entry by <code>value</code>
+    void operator*=(double value);
+
+    /// divide every vector entry by <code>value</code>
+    void operator/=(double value);
+  //@}
+
+};
+
+/** Generalizes OsiCuts to handle quadratic cuts.*/
+class Cuts : public OsiCuts {
+ public:
+  typedef vector<QuadCut *> QuadCutPtrStorage;
+  /** Default constructor.*/
+  Cuts();
+
+  /** Copy constructor.*/
+  Cuts(const Cuts& other);
+
+  /** Assignment operator.*/
+  Cuts& operator=(const Cuts & rhs);
+
+ /** Destructor */
+ ~Cuts();
+
+ /** insert a quadratic cut into the collection. */
+ inline void insert(const QuadCut& c);
+
+ /** insert a quadratic cut into the collection (take control of the pointer and
+     put a NULL on return).
+     \warning c has to have been created with new (no malloc).
+   */
+  inline void insert(QuadCut* &c);
+
+ /** insert a set of Cuts.*/
+  inline void insert(const Cuts &cs);
+
+ /** Number of quadratic cuts in the collection.*/
+  inline int sizeQuadCuts() const;
+
+ /** Total number of cuts in the collection. */
+ inline int sizeCuts() const;
+
+ /** Print all cuts in the collection.*/
+ void printCuts() const;
+
+
+ /** Access to a quadratic cut by pointer.*/
+ inline QuadCut * quadCutPtr(int i);
+
+ /** Access to a quadratic cut by const pointer.*/
+ inline const QuadCut * quadCutPtr(int i) const;
+
+ /** Access to a quadratic cut by reference.*/
+ inline QuadCut& quadCut(int i);
+
+
+ /** Access to a quadratic cut by reference.*/
+ inline const QuadCut& quadCut(int i) const;
+
+ /** Erase quadratic cut from the collection.*/
+ inline void eraseQuadCut(int i);
+
+ private:
+   QuadCutPtrStorage quadCuts_;
+};
+
+void
+Cuts::insert(const QuadCut &c){
+  quadCuts_.push_back(new QuadCut(c));
+}
+
+void
+Cuts::insert(QuadCut * &c){
+  quadCuts_.push_back(c);
+  c = NULL;
+}
+
+void 
+Cuts::insert(const Cuts & cs){
+  OsiCuts::insert(cs);
+  for(unsigned int i = 0 ; i < cs.quadCuts_.size() ; i++){
+    quadCuts_.push_back(new QuadCut(*cs.quadCuts_[i]));
+  }
+}
+
+int 
+Cuts::sizeQuadCuts() const {
+  return static_cast<int>(quadCuts_.size());
+}
+
+int
+Cuts::sizeCuts() const {
+  return static_cast<int>(quadCuts_.size()) + OsiCuts::sizeCuts();
+}
+
+QuadCut *
+Cuts::quadCutPtr(int i) {
+  return quadCuts_[i];
+}
+
+const QuadCut *
+Cuts::quadCutPtr(int i) const {
+  return quadCuts_[i];
+}
+
+QuadCut &
+Cuts::quadCut(int i) {
+  return *quadCuts_[i];
+}
+
+const QuadCut &
+Cuts::quadCut(int i) const {
+  return *quadCuts_[i];
+}
+
+void
+Cuts::eraseQuadCut(int i){
+  delete quadCuts_[i];
+  quadCuts_.erase(quadCuts_.begin() + i);
+}
+typedef std::list<QuadCut*> list_QuadCut; 
+
+}// Ends Bonmin namespace
+#endif
+
+

casadi/include/coin/BonQuadRow.hpp

@@ -0,0 +1,122 @@
+/// (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 BonQuadRow_H
+#define BonQuadRow_H
+
+#include "CoinPackedVector.hpp"
+#include "BonTMatrix.hpp"
+#include "BonQuadCut.hpp"
+
+namespace Bonmin{
+
+  /** Store column and row of the entry.*/
+  typedef std::pair<int, int> matEntry;
+  /** Store the number of times entry is used and its index in the matrix.*/
+  typedef std::pair<int, int> matIdx;
+#if HAS_HASH_MAP
+  typedef std::has_map<matEntry, matIdx, std::hash< matEntry> > AdjustableMat;
+#else
+  typedef std::map<matEntry, matIdx> AdjustableMat;
+#endif
+
+/** Stores a quadratic row of the form l < c + ax + x^T Q x < u. 
+    Does computation usefull for nlp-solver.
+    It can only be initialized from a QuadCut.*/
+class QuadRow {
+ public:
+ /** Default constructor.*/
+ QuadRow();
+
+ /** Copy constructor.*/
+ QuadRow(const QuadRow & other);
+
+ /** Assignment operator.*/
+ QuadRow& operator=(const QuadRow& rhs);
+
+ /** Constructor from a quadratic cut.*/
+ QuadRow(const QuadCut &cut);
+
+ /** Assignment form a quadrattic &cut.*/
+ QuadRow& operator=(const QuadCut & rhs);
+
+ /** Constructor from a linear cut.*/
+ QuadRow(const OsiRowCut &cut);
+
+ /** Assignment form a linear &cut.*/
+ QuadRow& operator=(const OsiRowCut & rhs);
+
+ /** Evaluate quadratic form.*/
+ double eval_f(const double *x, bool new_x);
+
+ /** Get number of non-zeroes in the gradiant.*/
+ int nnz_grad();
+ /** Get structure of gradiant */
+  void gradiant_struct(const int nnz, int * indices, bool offset);
+ /** Evaluate gradiant of quadratic form.*/
+ void eval_grad(const int nnz, const double * x, bool new_x, double * values);
+
+ /** number of non-zeroes in hessian. */
+ int nnz_hessian(){
+   return Q_.nnz_;}
+
+ /** Says if the constraint is linear.*/
+ bool isLinear(){
+   return Q_.nnz_ == 0;}
+
+ /** Return hessian value (i.e. Q_).*/
+ void eval_hessian(double lambda, double * values);
+
+ /** Add row to a bigger hessian.*/
+  void add_to_hessian(AdjustableMat &H, bool offset); 
+
+ /** Remove row from a bigger hessian.*/ 
+  void remove_from_hessian(AdjustableMat &H);
+/** Print quadratic constraint.*/
+void print();
+
+ private:
+ /** Initialize once quadratic form is know.*/
+ void initialize();
+
+ /** Does internal work to evaluate gradiant of this in x.*/
+ void internal_eval_grad(const double *x);
+
+ /** lower bound.*/
+ double lb_;
+ /** upper bound.*/
+ double ub_;
+ /** Constant term.*/
+ double c_;
+ /** linear term in sparse storage.*/
+ CoinPackedVector a_;
+ /** Quadratic term.*/
+ TMat Q_;
+
+
+#if HAS_HASH_MAP
+  typedef  std::has_map<int, std::pair<double, double >, std::hash<int> > gStore;
+#else
+  typedef std::map<int, std::pair<double, double> > gStore;
+#endif
+
+ gStore g_;
+ /** To have fast access to gradiant entries for a_.*/
+ std::vector<gStore::iterator> a_grad_idx_;
+ /** To have fast access to gradient entries for rows Q_*/
+ std::vector<gStore::iterator> Q_row_grad_idx_;
+ /** To have fast access to gradient entries for cols Q_*/
+ std::vector<gStore::iterator> Q_col_grad_idx_;
+ /** To have fast access to entries in full hessian of Q_*/
+ std::vector<AdjustableMat::iterator> Q_hessian_idx_;
+ /** Flag indicating if gradiant has been evaluated.*/
+ bool grad_evaled_;
+};
+}//End Bonmin namespace
+#endif