casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonBranchingTQP.hpp

@@ -0,0 +1,197 @@
+// (C) Copyright International Business Machines Corporation and
+// Carnegie Mellon University 2006, 2008
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Andreas Waechter, International Business Machines Corporation
+//                   (derived from BonTMINLP2TNLP.hpp)            12/22/2006
+
+#ifndef __BONBRANCHINGTQP_HPP__
+#define __BONBRANCHINGTQP_HPP__
+
+#include "BonTMINLP2TNLP.hpp"
+
+namespace Bonmin
+{
+  /** This is an adapter class that converts a TMINLP2TNLP object into
+   *  a TNLP, which is now just a QP.  The QP is the linear quadratic
+   *  of the TNLP at the optimal point.  The purpose of the
+   *  BranchingTQP is that it is used in a strong-branching framework,
+   *  strong branching is only done for the QP approximation of the
+   *  TNLP, not on the TNLP itself.  The variables of the QP are the
+   *  displacement from the reference point.
+   */
+  class BranchingTQP : public Ipopt::TNLP
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    BranchingTQP(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp);
+
+    /** Default destructor */
+    virtual ~BranchingTQP();
+    //@}
+
+    /**@name methods to gather information about the NLP, only those
+     *  that need to be overloaded from TNLP */
+    //@{
+    virtual bool get_nlp_info(Ipopt::Index& n, Ipopt::Index& m, Ipopt::Index& nnz_jac_g,
+                              Ipopt::Index& nnz_h_lag, Ipopt::TNLP::IndexStyleEnum& index_style);
+    virtual bool get_bounds_info(Ipopt::Index n, Ipopt::Number* x_l, Ipopt::Number* x_u,
+                                 Ipopt::Index m, Ipopt::Number* g_l, Ipopt::Number* g_u);
+    /** Returns the constraint linearity.  array should be alocated
+     * with length at least n. Since this is a QP, all constraints are
+     * linear.*/
+    virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types);
+    /** Method called by Ipopt to get the starting point. The bools
+     *  init_x and init_lambda are both inputs and outputs. As inputs,
+     *  they indicate whether or not the algorithm wants you to
+     *  initialize x and lambda respectively. If, for some reason, the
+     *  algorithm wants you to initialize these and you cannot, set
+     *  the respective bool to false.
+     */
+    virtual bool get_starting_point(Ipopt::Index n, bool init_x, Ipopt::Number* x,
+        bool init_z, Ipopt::Number* z_L, Ipopt::Number* z_U,
+        Ipopt::Index m, bool init_lambda,
+        Ipopt::Number* lambda);
+
+    /** Returns the value of the objective function in x*/
+    virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Number& obj_value);
+
+    /** Returns the vector of the gradient of
+     *  the objective w.r.t. x */
+    virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Number* grad_f);
+
+    /** Returns the vector of constraint values in x*/
+    virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Index m, Ipopt::Number* g);
+
+    /** Returns the jacobian of the
+     *  constraints. The vectors iRow and jCol only need to be set
+     *  once. The first call is used to set the structure only (iRow
+     *  and jCol will be non-NULL, and values will be NULL) For
+     *  subsequent calls, iRow and jCol will be NULL. */
+    virtual bool eval_jac_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Index m, Ipopt::Index nele_jac, Ipopt::Index* iRow,
+        Ipopt::Index *jCol, Ipopt::Number* values);
+
+    /** Return the hessian of the
+     *  lagrangian. The vectors iRow and jCol only need to be set once
+     *  (during the first call). The first call is used to set the
+     *  structure only (iRow and jCol will be non-NULL, and values
+     *  will be NULL) For subsequent calls, iRow and jCol will be
+     *  NULL. This matrix is symmetric - specify the lower diagonal
+     *  only */
+    virtual bool eval_h(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Number obj_factor, Ipopt::Index m, const Ipopt::Number* lambda,
+        bool new_lambda, Ipopt::Index nele_hess,
+        Ipopt::Index* iRow, Ipopt::Index* jCol, Ipopt::Number* values);
+    virtual void finalize_solution(Ipopt::SolverReturn status,
+                                   Ipopt::Index n, const Ipopt::Number* x, const Ipopt::Number* z_L, const Ipopt::Number* z_U,
+                                   Ipopt::Index m, const Ipopt::Number* g, const Ipopt::Number* lambda,
+                                   Ipopt::Number obj_value,
+                                   const Ipopt::IpoptData* ip_data,
+                                   Ipopt::IpoptCalculatedQuantities* ip_cq);
+    //@}
+
+    /** Accessor Methods for QP data */
+    //@{
+    const Ipopt::Number ObjVal()
+    {
+      return obj_val_;
+    }
+    const Ipopt::Number* ObjGrad()
+    {
+      return obj_grad_;
+    }
+    const Ipopt::Number* ObjHessVals()
+    {
+      return obj_hess_;
+    }
+    const Ipopt::Index* ObjHessIRow()
+    {
+      return obj_hess_irow_;
+    }
+    const Ipopt::Index* ObjHessJCol()
+    {
+      return obj_hess_jcol_;
+    }
+    const Ipopt::Number* ConstrRhs()
+    {
+      return g_vals_;
+    }
+    const Ipopt::Number* ConstrJacVals()
+    {
+      return g_jac_;
+    }
+    const Ipopt::Index* ConstrJacIRow()
+    {
+      return g_jac_irow_;
+    }
+    const Ipopt::Index* ConstrJacJCol()
+    {
+      return g_jac_jcol_;
+    }
+    //@}
+
+  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 */
+    BranchingTQP();
+
+    /** Copy Constructor */
+    BranchingTQP(const BranchingTQP&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const BranchingTQP&);
+    //@}
+
+    /** @name static information about the QP's constraints and
+     *  objective function */
+    //@{
+    Ipopt::Number obj_val_;
+    Ipopt::Number* obj_grad_;
+    Ipopt::Number* obj_hess_;
+    Ipopt::Index* obj_hess_irow_;
+    Ipopt::Index* obj_hess_jcol_;
+    Ipopt::Number* g_vals_;
+    Ipopt::Number* g_jac_;
+    Ipopt::Index* g_jac_irow_;
+    Ipopt::Index* g_jac_jcol_;
+    //@}
+
+    /** @name Data from the MINLP */
+    //@{
+    Ipopt::Index n_;
+    Ipopt::Index m_;
+    Ipopt::Index nnz_jac_g_;
+    Ipopt::Index nnz_h_lag_;
+    Ipopt::TNLP::IndexStyleEnum index_style_;
+    //@}
+
+    /** Copy of original x_sol_.  x_sol_ is changed after the first QP
+     *  has been solved once. */
+    Ipopt::Number* x_sol_copy_;
+
+    /** Copy of original duals_sol_.  duals_sol_ is changed after the
+     *  first QP has been solved once. */
+    Ipopt::Number* duals_sol_copy_;
+
+    /** Pointer to the TMINLP2TNLP model which stores the bounds
+     *  information */
+    Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp_;
+  };
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin/BonCbc.hpp

@@ -0,0 +1,127 @@
+// (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/19/2007
+
+#ifndef BonCbc_H
+#define BonCbc_H
+
+//#include "BonBabSetupBase.hpp"
+#include "CbcModel.hpp"
+
+namespace Bonmin
+{
+  class BabSetupBase;
+  class Bab
+  {
+  public:
+    /** Integer optimization return codes.*/
+    enum MipStatuses {FeasibleOptimal /** Optimum solution has been found and its optimality proved.*/,
+        ProvenInfeasible /** Problem has been proven to be infeasible.*/,
+        Feasible /** An integer solution to the problem has been found.*/,
+        UnboundedOrInfeasible /*Coninuous relaxation is unbounded.*/,
+        NoSolutionKnown/** No feasible solution to the problem is known*/,
+        NumMipStats};
+
+
+    /** Constructor.*/
+    Bab();
+    /** destructor.*/
+    virtual ~Bab();
+    /** Perform a branch-and-bound using given setup.*/
+    virtual void branchAndBound(BabSetupBase & s);
+
+    /**operator() performs the branchAndBound*/
+    virtual void operator()(BabSetupBase & s);
+
+    /**operator() performs the branchAndBound*/
+    virtual void operator()(BabSetupBase * s){
+       operator()(*s);}
+
+    /** get the best solution known to the problem (is optimal if MipStatus is FeasibleOptimal).
+      if no solution is known returns NULL.*/
+    const double * bestSolution() const
+    {
+      return bestSolution_;
+    }
+    /** return objective value of the bestSolution */
+    double bestObj() const
+    {
+      return bestObj_;
+    }
+
+    /** return Mip Status */
+    MipStatuses mipStatus() const
+    {
+      return mipStatus_;
+    }
+
+    /** return the best known lower bound on the objective value*/
+    double bestBound();
+
+    /** return the total number of nodes explored.*/
+    int numNodes() const
+    {
+      return numNodes_;
+    }
+    /** return the total number of iterations in the last mip solved.*/
+    int iterationCount()
+    {
+      return mipIterationCount_;
+    }
+    /** returns the value of the continuous relaxation. */
+    double continuousRelaxation()
+    {
+      return continuousRelaxation_;
+    }
+
+    /** virtual callback function to eventually modify objects for integer variable
+      (replace with user set). This is called after CbcModel::findIntegers */
+    virtual void replaceIntegers(OsiObject ** objects, int numberObjects)
+    {}
+    /** Get cbc model used to solve. */
+    const CbcModel&  model() const
+    {
+      return model_;
+    }
+
+    /** Get cbc model used to solve as non-const, in case we want to
+        change options before things happen */
+    CbcModel&  model()
+    {
+      return model_;
+    }
+
+  protected:
+    /** Stores the solution of MIP. */
+    double * bestSolution_;
+
+    /** Status of the mip solved*/
+    MipStatuses mipStatus_;
+    /** objValue of MIP */
+    double bestObj_;
+    /** best known (lower) bound.*/
+    double bestBound_;
+    /** Continuous relaxation of the problem */
+    double continuousRelaxation_;
+    /** Number of nodes enumerated.*/
+    int numNodes_;
+    /** get total number of iterations in last mip solved.*/
+    int mipIterationCount_;
+    /** CbcModel used to solve problem.*/
+    CbcModel model_;
+    /** Message handler for CbcModel. */
+    CoinMessageHandler * modelHandler_;
+    /** \brief OsiObjects of the model.
+      * this is not null if and only if there are some non-simple-integer branching objects such as SOS constraints.
+      * It is up to Bab to pass them over to appropriate components of the algorithm. */
+    OsiObject** objects_;
+    /** number of objects.*/
+    int nObjects_;
+  };
+}
+#endif

casadi/include/coin/BonCbcLpStrategy.hpp

@@ -0,0 +1,45 @@
+// (C) Copyright Carnegie Mellon University 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, Carnegie Mellon University,
+//
+// Date : 03/15/2006
+
+
+#ifndef CbcOaStrategy_HPP
+#define CbcOaStrategy_HPP
+
+#include "CbcStrategy.hpp"
+#include <string>
+#include "BonBabSetupBase.hpp"
+namespace Bonmin
+{
+  /** A class to setup default strategy for Cbc specifying which cut generators to use.*/
+  class CbcStrategyChooseCuts : public CbcStrategyDefault {
+     public:
+     /** Default constructor.*/
+     CbcStrategyChooseCuts();
+     /** Constructor with a setup. */
+     CbcStrategyChooseCuts(BabSetupBase &s, const std::string & prefix);
+     /** Copy constructor.*/
+     CbcStrategyChooseCuts(const CbcStrategyChooseCuts &other);
+     /** Virtual copy constructor.*/
+     CbcStrategy * clone() const{
+       return new CbcStrategyChooseCuts(*this);
+     }
+     /** Setup strategy.*/
+     void setup(BabSetupBase &s, const std::string &prefix);
+    
+     /// Setup cut generators
+     virtual void setupCutGenerators(CbcModel & model);
+  
+     private:
+    /** Generators frequencies.*/
+    int gen_freqs_[6];
+       /** Flag to say which cut generators to use.*/
+       int genFlag_;
+  };
+}
+#endif

casadi/include/coin/BonCbcNlpStrategy.hpp

@@ -0,0 +1,98 @@
+// (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// John J. Forrest, International Business Machines Corporation
+// Pierre Bonami, Carnegie Mellon University,
+//
+// Date : 03/15/2006
+
+#ifndef BonCbcNlpStrategy_H
+#define BonCbcNlpStrategy_H
+
+#include "CbcStrategy.hpp"
+class CglPreProcess;
+class CbcNodeInfo;
+class CbcNode;
+class CoinWarmStartDiff;
+
+
+namespace Bonmin
+{
+  class CbcNlpStrategy : public CbcStrategy
+  {
+  public:
+
+    // Default Constructor
+    CbcNlpStrategy (int maxFailures,
+        int maxInfeasibles,
+        int pretendFailIsInfeasible);
+
+    // Copy constructor
+    CbcNlpStrategy ( const CbcNlpStrategy &);
+
+    // Destructor
+    virtual ~CbcNlpStrategy ();
+
+    /// Clone
+    virtual CbcStrategy * clone() const;
+
+    /// Return a new Full node information pointer (descendant of CbcFullNodeInfo)
+    virtual CbcNodeInfo * fullNodeInfo(CbcModel * model,int numberRowsAtContinuous) const;
+    /// Return a new Partial node information pointer (descendant of CbcPartialNodeInfo)
+    virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
+        int numberChangedBounds,const int * variables,
+        const double * boundChanges,
+        const CoinWarmStartDiff *basisDiff) const;
+    /** After a CbcModel::resolve this can return a status
+        -1 no effect
+        0 treat as optimal
+        1 as 0 but do not do any more resolves (i.e. no more cuts)
+        2 treat as infeasible
+    */
+    virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
+    /// set maximum number of consecutive failures in a branch before giving up
+    inline void setMaxFailure(int value)
+    {
+      maxFailure_ = value;
+    }
+    /// maximum number of consecutive infeasible nodes before giving up
+    inline void setMaxInfeasible(int value)
+    {
+      maxInfeasible_ = value;
+    }
+
+    /// Setup cut generators
+    virtual void setupCutGenerators(CbcModel & model);
+    /// Setup heuristics
+    virtual void setupHeuristics(CbcModel & model);
+    /// Do printing stuff
+    virtual void setupPrinting(CbcModel & model,int modelLogLevel);
+    /// Other stuff e.g. strong branching and preprocessing
+    virtual void setupOther(CbcModel & model);
+
+    bool hasFailed()
+    {
+      return hasFailed_;
+    }
+  protected:
+    // Data
+    /// did we fail?
+    bool hasFailed_;
+    /// maximum number of consecutive failures in a branch before giving up
+    int maxFailure_;
+    /// maximum number of consecutive infeasible nodes before giving up
+    int maxInfeasible_;
+    /** If yes when a problem is not solved (failed to be solved)
+        will pretend that it is infeasible. */
+    int pretendFailIsInfeasible_;
+
+  private:
+    /// Illegal Assignment operator
+    CbcNlpStrategy & operator=(const CbcNlpStrategy& rhs);
+
+  };
+}
+
+#endif

casadi/include/coin/BonCbcNode.hpp

@@ -0,0 +1,133 @@
+// (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2006
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// John J. Forrest, International Business Machines Corporation
+// Pierre Bonami, Carnegie Mellon University,
+//
+// Date : 03/15/2006
+
+#ifndef BonminCbcNode_H
+#define BonminCbcNode_H
+
+#include "CbcNode.hpp"
+#include "BonRegisteredOptions.hpp"
+
+
+namespace Bonmin
+{
+  /** \brief Holds information for recreating a subproblem by incremental change
+  	   from the parent for Bonmin
+
+    A BonminBonminCbcPartialNodeInfo object contains changes to the bounds and basis, and
+    additional cuts, required to recreate a subproblem by modifying and
+    augmenting the parent subproblem.
+  */
+
+  class BonCbcFullNodeInfo : public CbcFullNodeInfo
+  {
+
+  public:
+    friend class BonCbcPartialNodeInfo;
+    // Default Constructor
+    BonCbcFullNodeInfo ();
+
+    // Constructor from current state
+    BonCbcFullNodeInfo (CbcModel * model, int numberRowsAtContinuous);
+
+    // Copy constructor
+    BonCbcFullNodeInfo ( const BonCbcFullNodeInfo &);
+
+    // Destructor
+    ~BonCbcFullNodeInfo ();
+
+    /// Clone
+    virtual CbcNodeInfo * clone() const;
+
+    /**Method called when all direct sons have been explored to flush
+       useless warm start information.*/
+    virtual void allBranchesGone();
+
+    /** Number of consecutive infeasible parents only recorded if node is infeasible*/
+    inline int getSequenceOfInfeasiblesSize()
+    {
+      return sequenceOfInfeasiblesSize_;
+    }
+    /** Number of consecutive unsolved parents only recorded if node is infeasible*/
+    inline int getSequenceOfUnsolvedSize()
+    {
+      return sequenceOfUnsolvedSize_;
+    }
+    /** Register all the options for class instance.*/
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+  private:
+    /* Data values */
+    /** Number of consecutive infeasible parents only recorded if node is infeasible*/
+    int sequenceOfInfeasiblesSize_;
+    /** Number of consecutive unsolved parents only recorded if node is infeasible*/
+    int sequenceOfUnsolvedSize_;
+  private:
+
+    /// Illegal Assignment operator
+    BonCbcFullNodeInfo & operator=(const BonCbcFullNodeInfo& rhs);
+  };
+
+  /** \brief Holds information for recreating a subproblem by incremental change
+  	   from the parent for
+
+    A BonminCbcPartialNodeInfo object contains changes to the bounds and basis, and
+    additional cuts, required to recreate a subproblem by modifying and
+    augmenting the parent subproblem.
+  */
+
+  class BonCbcPartialNodeInfo : public CbcPartialNodeInfo
+  {
+
+  public:
+    // Default Constructor
+    BonCbcPartialNodeInfo ();
+
+    // Constructor from current state
+    BonCbcPartialNodeInfo (CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
+        int numberChangedBounds,const int * variables,
+        const double * boundChanges,
+        const CoinWarmStartDiff *basisDiff) ;
+
+    // Copy constructor
+    BonCbcPartialNodeInfo ( const BonCbcPartialNodeInfo &);
+
+    // Destructor
+    ~BonCbcPartialNodeInfo ();
+
+    /// Clone
+    virtual CbcNodeInfo * clone() const;
+
+    /**Method called when all direct sons have been explored to flush
+       useless warm start information.*/
+    virtual void allBranchesGone();
+
+    /** Number of consecutive infeasible parents only recorded if node is infeasible*/
+    inline int getSequenceOfInfeasiblesSize()
+    {
+      return sequenceOfInfeasiblesSize_;
+    }
+    /** Number of consecutive unsolved parents only recorded if node is infeasible*/
+    inline int getSequenceOfUnsolvedSize()
+    {
+      return sequenceOfUnsolvedSize_;
+    }
+  private:
+    /* Data values */
+    /** Number of consecutive infeasible parents only recorded if node is infeasible*/
+    int sequenceOfInfeasiblesSize_;
+    /** Number of consecutive unsolved parents only recorded if node is infeasible*/
+    int sequenceOfUnsolvedSize_;
+  private:
+
+    /// Illegal Assignment operator
+    BonCbcPartialNodeInfo & operator=(const Bonmin::BonCbcPartialNodeInfo& rhs);
+  };
+}
+#endif