casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonGuessHeuristic.hpp

@@ -0,0 +1,46 @@
+// (C) Copyright International Business Machines  2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Andreas Waechter          IBM       2007-09-01
+
+#ifndef BonGuessHeuristic_HPP
+#define BonGuessHeuristic_HPP
+#include "BonOsiTMINLPInterface.hpp"
+
+#include "CbcHeuristic.hpp"
+
+namespace Bonmin
+{
+  class  GuessHeuristic : public CbcHeuristic
+  {
+  public:
+    /// Usefull constructor
+    GuessHeuristic(CbcModel &model);
+    ///Copy constructor
+    GuessHeuristic( const GuessHeuristic &copy):
+        CbcHeuristic(copy)
+    {}
+
+    /// heuristic method providing guess, based on pseudo costs
+    virtual int solution(double &solutionValue, double *betterSolution);
+    virtual int solution(double &solutionValue, double *betterSolution, OsiCuts & cs)
+    {
+      return solution(solutionValue, betterSolution);
+    }
+    virtual CbcHeuristic * clone()const
+    {
+      return new GuessHeuristic(*this);
+    }
+    virtual void resetModel(CbcModel*)
+    {}
+  private:
+    /// Default constructor
+    GuessHeuristic();
+
+    /// Assignment operator
+    GuessHeuristic & operator=(const GuessHeuristic& rhs);
+  };
+}
+#endif

casadi/include/coin/BonHeuristicDive.hpp

@@ -0,0 +1,88 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDive_HPP
+#define BonHeuristicDive_HPP
+#include "BonOsiTMINLPInterface.hpp"
+#include "BonBonminSetup.hpp"
+#include "CbcHeuristic.hpp"
+
+namespace Bonmin
+{
+  class HeuristicDive : public CbcHeuristic
+  {
+  public:
+    /// Default constructor
+    HeuristicDive();
+
+    /// Constructor with setup
+    HeuristicDive(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDive(const HeuristicDive &copy);
+
+    /// Destructor
+    ~HeuristicDive() {}
+
+    /// Assignment operator
+    HeuristicDive & operator=(const HeuristicDive & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const = 0;
+
+    /// 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());
+    }
+
+    /// Set percentage of integer variables to fix at bounds
+    void setPercentageToFix(double value)
+    { percentageToFix_ = value; }
+
+    /// Performs heuristic
+    virtual int solution(double &solutionValue, double *betterSolution);
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp) = 0;
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound) = 0;
+
+  protected:
+    /** Setup to use for local searches (will make copies).*/
+    BonminSetup * setup_; 
+
+    /// Percentage of integer variables to fix at bounds
+    double percentageToFix_;
+
+  private:
+    /// How often to do (code can change)
+    int howOften_;
+
+  };
+
+  /// checks if the NLP relaxation of the problem is feasible
+  bool isNlpFeasible(TMINLP2TNLP* minlp, const double primalTolerance);
+  
+  /// Adjusts the primalTolerance in case some of the constraints are violated
+  void adjustPrimalTolerance(TMINLP2TNLP* minlp, double & primalTolerance);
+}
+#endif

casadi/include/coin/BonHeuristicDiveFractional.hpp

@@ -0,0 +1,67 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDiveFractional_H
+#define BonHeuristicDiveFractional_H
+
+#include "BonBonminSetup.hpp"
+#include "BonHeuristicDive.hpp"
+
+/** DiveFractional class
+ */
+
+namespace Bonmin
+{
+  class HeuristicDiveFractional : public HeuristicDive {
+  public:
+    /// Default Constructor 
+    HeuristicDiveFractional ();
+
+    /// Constructor with setup
+    HeuristicDiveFractional(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDiveFractional(const HeuristicDiveFractional &copy);
+
+    /// Destructor
+    ~HeuristicDiveFractional() {}
+
+    /// Assignment operator
+    HeuristicDiveFractional & operator=(const HeuristicDiveFractional & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+    /** Change setup used for heuristic.*/
+    virtual void setSetup(BonminSetup * setup){
+      HeuristicDive::setSetup(setup);
+      Initialize(setup->options());
+    }
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp);
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound);
+
+    /** 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);
+
+  };
+}
+#endif

casadi/include/coin/BonHeuristicDiveMIP.hpp

@@ -0,0 +1,83 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDiveMIP_HPP
+#define BonHeuristicDiveMIP_HPP
+#include "BonOsiTMINLPInterface.hpp"
+#include "BonBonminSetup.hpp"
+#include "CbcHeuristic.hpp"
+#include "CbcStrategy.hpp"
+namespace Bonmin
+{
+  class SubMipSolver;
+  class HeuristicDiveMIP : public CbcHeuristic
+  {
+  public:
+#if 0
+    /// Default constructor
+    HeuristicDiveMIP();
+#endif
+
+    /// Constructor with setup
+    HeuristicDiveMIP(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDiveMIP(const HeuristicDiveMIP &copy);
+
+    /// Destructor
+    ~HeuristicDiveMIP();
+
+    /// Assignment operator
+    HeuristicDiveMIP & operator=(const HeuristicDiveMIP & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const = 0;
+
+    /// 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);
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp) = 0;
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound) = 0;
+
+  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_;
+
+  };
+}
+#endif

casadi/include/coin/BonHeuristicDiveMIPFractional.hpp

@@ -0,0 +1,67 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDiveMIPFractional_H
+#define BonHeuristicDiveMIPFractional_H
+
+#include "BonBonminSetup.hpp"
+#include "BonHeuristicDiveMIP.hpp"
+
+/** DiveMIPFractional class
+ */
+
+namespace Bonmin
+{
+  class HeuristicDiveMIPFractional : public HeuristicDiveMIP {
+  public:
+    /// Default Constructor 
+    HeuristicDiveMIPFractional ();
+
+    /// Constructor with setup
+    HeuristicDiveMIPFractional(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDiveMIPFractional(const HeuristicDiveMIPFractional &copy);
+
+    /// Destructor
+    ~HeuristicDiveMIPFractional() {}
+
+    /// Assignment operator
+    HeuristicDiveMIPFractional & operator=(const HeuristicDiveMIPFractional & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+    /** Change setup used for heuristic.*/
+    virtual void setSetup(BonminSetup * setup){
+      HeuristicDiveMIP::setSetup(setup);
+      Initialize(setup->options());
+    }
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp);
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound);
+
+    /** 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);
+
+  };
+}
+#endif

casadi/include/coin/BonHeuristicDiveMIPVectorLength.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDiveMIPVectorLength_H
+#define BonHeuristicDiveMIPVectorLength_H
+
+#include "BonBonminSetup.hpp"
+#include "BonHeuristicDiveMIP.hpp"
+
+/** DiveMIPVectorLength class
+ */
+
+namespace Bonmin
+{
+  class HeuristicDiveMIPVectorLength : public HeuristicDiveMIP {
+  public:
+    /// Default Constructor 
+    HeuristicDiveMIPVectorLength ();
+
+    /// Constructor with setup
+    HeuristicDiveMIPVectorLength(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDiveMIPVectorLength(const HeuristicDiveMIPVectorLength &copy);
+
+    /// Destructor
+    ~HeuristicDiveMIPVectorLength() 
+    {
+      delete [] columnLength_;
+    }
+
+    /// Assignment operator
+    HeuristicDiveMIPVectorLength & operator=(const HeuristicDiveMIPVectorLength & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+    /** Change setup used for heuristic.*/
+    virtual void setSetup(BonminSetup * setup){
+      HeuristicDiveMIP::setSetup(setup);
+      Initialize(setup->options());
+    }
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp);
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound);
+
+    /** 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);
+
+  private:
+    /// the number of nonzero elements in each column
+    int* columnLength_;
+
+  };
+}
+#endif

casadi/include/coin/BonHeuristicDiveVectorLength.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicDiveVectorLength_H
+#define BonHeuristicDiveVectorLength_H
+
+#include "BonBonminSetup.hpp"
+#include "BonHeuristicDive.hpp"
+
+/** DiveVectorLength class
+ */
+
+namespace Bonmin
+{
+  class HeuristicDiveVectorLength : public HeuristicDive {
+  public:
+    /// Default Constructor 
+    HeuristicDiveVectorLength ();
+
+    /// Constructor with setup
+    HeuristicDiveVectorLength(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicDiveVectorLength(const HeuristicDiveVectorLength &copy);
+
+    /// Destructor
+    ~HeuristicDiveVectorLength() 
+    {
+      delete [] columnLength_;
+    }
+
+    /// Assignment operator
+    HeuristicDiveVectorLength & operator=(const HeuristicDiveVectorLength & rhs);
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+    /** Change setup used for heuristic.*/
+    virtual void setSetup(BonminSetup * setup){
+      HeuristicDive::setSetup(setup);
+      Initialize(setup->options());
+    }
+
+    /// sets internal variables
+    virtual void setInternalVariables(TMINLP2TNLP* minlp);
+
+    /// Selects the next variable to branch on
+    /** If bestColumn = -1, it means that no variable was found
+    */
+    virtual void selectVariableToBranch(TMINLP2TNLP* minlp,
+					const vector<int> & integerColumns,
+					const double* newSolution,
+					int& bestColumn,
+					int& bestRound);
+
+    /** 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);
+
+  private:
+    /// the number of nonzero elements in each column
+    int* columnLength_;
+
+  };
+}
+#endif

casadi/include/coin/BonHeuristicFPump.hpp

@@ -0,0 +1,111 @@
+// Copyright (C) 2007, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Joao P. Goncalves, International Business Machines Corporation
+//
+// Date : November 12, 2007
+
+#ifndef BonHeuristicFPump_HPP
+#define BonHeuristicFPump_HPP
+#include "BonOsiTMINLPInterface.hpp"
+#include "BonBonminSetup.hpp"
+#include "CbcHeuristic.hpp"
+
+namespace Bonmin
+{
+  class  HeuristicFPump : public CbcHeuristic
+  {
+  public:
+    /// Default constructor
+    HeuristicFPump();
+
+    /// Constructor with setup
+    HeuristicFPump(BonminSetup * setup);
+
+    /// Copy constructor
+    HeuristicFPump(const HeuristicFPump &copy);
+
+    /// Destructor
+    ~HeuristicFPump() {}
+
+    /// Assignment operator
+    HeuristicFPump & operator=(const HeuristicFPump & rhs);
+
+    /** Virtual constructor.*/
+    virtual CbcHeuristic * clone() const{
+      return new HeuristicFPump(*this);
+    }
+
+    /// 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 &solutionValue, double *betterSolution);
+
+    /// Performs heuristic with add cust
+    virtual int solution(double &solutionValue, double *betterSolution, OsiCuts & cs)
+    {
+      return solution(solutionValue, betterSolution);
+    }
+
+    /** Register the options for this heuristic */
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    /** Initiaize using passed options.*/
+    void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+
+  private:
+    /** Setup to use for local searches (will make copies).*/
+    BonminSetup * setup_; 
+
+    /** Norm of the objective function - either 1 or 2 */
+    int objective_norm_;
+
+    /// To enable advanced unstable stuff
+    int enableAdvanced_;
+  };
+
+  class RoundingFPump
+  {
+  public:
+    /// Default constructor
+    RoundingFPump(TMINLP2TNLP* minlp);
+
+    /// Destructor
+    ~RoundingFPump();
+
+    /// Rounds the solution
+    void round(const double integerTolerance, 
+	       const double primalTolerance,
+	       double* solution);
+
+  private:
+    /// gutsOfConstructor
+    void gutsOfConstructor();
+
+    /// Pointer to problem
+    TMINLP2TNLP* minlp_;
+
+    /// Number of rows
+    int numberRows_;
+
+    /// Number of columns
+    int numberColumns_;
+
+    /// Jacobian of g
+    std::vector<std::pair<int, int> >* col_and_jac_g_;
+
+  };
+
+}
+#endif

casadi/include/coin/BonHeuristicLocalBranching.hpp

@@ -0,0 +1,59 @@
+// (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 BonHeuristicLocalBranching_H
+#define BonHeuristicLocalBranching_H
+#include "BonLocalSolverBasedHeuristic.hpp"
+
+namespace Bonmin {
+  class HeuristicLocalBranching:public LocalSolverBasedHeuristic {
+    public:
+     /** Default constructor*/
+     HeuristicLocalBranching();
+    /** Constructor with setup.*/
+    HeuristicLocalBranching(BonminSetup * setup);
+
+     /** Copy constructor.*/
+     HeuristicLocalBranching(const HeuristicLocalBranching &other);
+     /** Virtual constructor.*/
+     virtual CbcHeuristic * clone() const{
+      return new HeuristicLocalBranching(*this);
+     }
+
+     /** Destructor*/
+     virtual ~HeuristicLocalBranching();
+    
+    /// Update model
+    virtual void setModel(CbcModel * model);
+
+    /// Validate model i.e. sets when_ to 0 if necessary
+    virtual void validate();
+
+     /** 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);
+
+  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
+