casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/BonChooseVariable.hpp

@@ -0,0 +1,345 @@
+// Copyright (C) 2006, 2008 International Business Machines
+// Corporation and others.  All Rights Reserved.
+#ifndef BonChooseVariable_H
+#define BonChooseVariable_H
+
+#include "OsiChooseVariable.hpp"
+#ifdef BONMIN_CURVATURE_BRANCHING
+#include "BonCurvatureEstimator.hpp"
+#endif
+#include "BonOsiTMINLPInterface.hpp"
+#include "CoinMessageHandler.hpp"
+#include "BonBabSetupBase.hpp"
+// Forward declaration
+class CbcModel;
+
+#define OLD_USEFULLNESS
+
+namespace Bonmin
+{
+
+  class HotInfo : public OsiHotInfo {
+    public:
+    /// Default constructor
+    HotInfo();
+
+    /// Constructor from usefull information
+    HotInfo( OsiSolverInterface * solver,
+             const OsiBranchingInformation *info,
+             const OsiObject * const * objects, int whichObject);
+
+    /// Copy constructor
+    HotInfo(const HotInfo & other);
+
+    /// Assignment operator
+    HotInfo & operator=(const HotInfo & rhs);
+
+    /// Clone
+    virtual OsiHotInfo * clone() const;
+
+    /// Destructor
+    virtual ~HotInfo();
+
+    /// Fill in some usefull information after a strong branching is done:
+    int updateInformation( const OsiSolverInterface * solver, const OsiBranchingInformation * info,
+	                   OsiChooseVariable * choose);
+
+    /// up infeasibility
+    double upInfeasibility() const{
+     return infeasibilities_[1];
+    }
+
+    /// down infeasibility
+    double downInfeasibility() const{
+     return infeasibilities_[0];
+    }
+
+
+    /// Set the down infeasibility
+    void setUpInfeasibility(double x){
+      assert(branchingObject_->numberBranches()==2);
+      infeasibilities_[1] = x;
+    }
+
+    /// Set the down infeasibility
+    void setDownInfeasibility(double x){
+      assert(branchingObject_->numberBranches()==2);
+      infeasibilities_[0] = x;
+    }
+    private:
+    /// infeasibilities of children
+    vector<double> infeasibilities_; 
+  };
+
+  /** This class chooses a variable to branch on
+
+      This is the base class for the branching rules in Bonmin (inherits
+      from OsiChooseVariable). This class implements a simple strong branching algorithm where the changes in the objective
+      value induced by branching on a specific object are estimated with the pure virtual function fill_changes.
+  */
+
+  class BonChooseVariable : public OsiChooseVariable
+  {
+  protected:
+  /**  This is a utility function which does strong branching on
+       a list of objects and stores the results in OsiHotInfo.objects.
+       On entry the object sequence is stored in the OsiHotInfo object
+       and maybe more.
+       It returns -
+       -1 - one branch was infeasible both ways
+       0 - all inspected - nothing can be fixed
+       1 - all inspected - some can be fixed (returnCriterion==0)
+       2 - may be returning early - one can be fixed (last one done) (returnCriterion==1) 
+       3 - returning because max time
+       
+  */
+  virtual int doStrongBranching( OsiSolverInterface * solver, 
+				 OsiBranchingInformation *info,
+				 int numberToDo, int returnCriterion);
+#ifndef OLD_USEFULLNESS
+    /** Criterion applied to sort candidates.*/
+    enum CandidateSortCriterion {
+      DecrPs = 0,
+      IncrPs,
+      DecrInfeas,
+      IncrInfeas};
+#endif
+
+    /** Statuses for strong branching candidates.*/
+    enum StrongStatus{
+      NotDone=-1,
+      Feasible/** Child is proven feasible.*/,
+      Infeasible /** Child is proven infeasible.*/,
+      NotFinished /** Child is not finished.*/};
+  public:
+    /** \name Message handling.*/
+    /** @{ */
+    enum Messages_Types {
+      PS_COST_HISTORY = 0,
+      PS_COST_MULT,
+      PS_COST_ESTIMATES,
+      CANDIDATE_LIST,
+      CANDIDATE_LIST2,
+      CANDIDATE_LIST3,
+      SB_START,
+      SB_HEADER,
+      SB_RES,
+      BRANCH_VAR,
+      CHOSEN_VAR,
+      UPDATE_PS_COST,
+      BON_CHOOSE_MESSAGES_DUMMY_END
+    };
+
+  class Messages : public CoinMessages
+    {
+    public:
+      Messages();
+    };
+
+    void passInMessageHandler(CoinMessageHandler * handler) {
+      int logLevel = handler_->logLevel();
+      delete handler_;
+      handler_ = handler->clone();
+      handler_->setLogLevel(logLevel);
+    }
+
+    CoinMessageHandler& message(Messages_Types type) const {
+      return handler_->message(type, messages_);
+    }
+    /** @} */
+
+
+
+    enum DoStrongReturnStatuses{
+      provenInfeasible = -1 /** One branch has two infeasible children.*/,
+      doneNoFixing /** All done no variable can be fixed.*/,
+      doneCanFix /** Several variable can be fixed.*/,
+      interuptedCanFix /** Interrupted and found a variable to fix.*/,
+      maxTime /** Interrupted because of time limit.*/};
+
+    /** Return statuses for chooseVariable.*/
+    enum chooseVariableReturnStatuses{
+      infeasibleNode = -1/** Node has been proven infeasible.*/,
+      hasCandidate /** Normal termination, found a variable to branch on.*/,
+      feasibleNode /** All variable are feasible, the node is feasible.*/,
+      canFixAndStrongBranch /** Found variable to fix and also has remaining candidate for strong branching.*/,
+      canFixAndBranch/** Found variable to fix and also has a (non-strong) branching candidate.*/,
+      canFixNoCandidate /** Can fix variables but does not have strong branching candidates.*/
+    };
+    /// Constructor from solver (so we can set up arrays etc)
+    BonChooseVariable (BabSetupBase& b, const OsiSolverInterface* solver);
+
+    /// Copy constructor
+    BonChooseVariable (const BonChooseVariable &);
+
+    /// Assignment operator
+    BonChooseVariable & operator= (const BonChooseVariable& rhs);
+
+    /// Clone
+    virtual OsiChooseVariable * clone() const;
+
+    /// Destructor
+    virtual ~BonChooseVariable ();
+
+    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    /** Helper functions for setupList and chooseVariable */
+    double maxminCrit(const OsiBranchingInformation* info) const;
+    void computeMultipliers(double& upMult, double& downMult) const;
+    double computeUsefulness(const double MAXMIN_CRITERION,
+        const double upMult, const double dowMult,
+        const double value,
+        const OsiObject* object, int i,
+        double& value2) const;
+
+    /** Sets up strong list and clears all if initialize is true.
+        Returns number of infeasibilities. */
+    virtual int setupList ( OsiBranchingInformation *info, bool initialize);
+
+    /** Choose a variable
+        Returns - 
+       -1 Node is infeasible
+       0  Normal termination - we have a candidate
+       1  All looks satisfied - no candidate
+       2  We can change the bound on a variable - but we also have a strong branching candidate
+       3  We can change the bound on a variable - but we have a non-strong branching candidate
+       4  We can change the bound on a variable - no other candidates
+       We can pick up branch from bestObjectIndex() and bestWhichWay()
+       We can pick up a forced branch (can change bound) from firstForcedObjectIndex() and firstForcedWhichWay()
+       If we have a solution then we can pick up from goodObjectiveValue() and goodSolution()
+       If fixVariables is true then 2,3,4 are all really same as problem changed
+    */
+    virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
+    /**  This is a utility function which does strong branching on
+         a list of objects and stores the results in OsiHotInfo.objects.
+         On entry the object sequence is stored in the OsiHotInfo object
+         and maybe more.
+         It returns -
+         -1 - one branch was infeasible both ways
+         0 - all inspected - nothing can be fixed
+         1 - all inspected - some can be fixed (returnCriterion==0)
+         2 - may be returning early - one can be fixed (last one done) (returnCriterion==1) 
+         3 - returning because max time
+      
+    */
+
+    /// Given a candidate fill in useful information e.g. estimates
+    virtual void updateInformation(const OsiBranchingInformation *info,
+        int branch, OsiHotInfo * hotInfo);
+#if 1
+    /// Given a branch fill in useful information e.g. estimates
+    virtual void updateInformation( int whichObject, int branch,
+        double changeInObjective, double changeInValue,
+        int status);
+#endif
+
+    /** Method for setting CbcModel, which is used to get statusOfSearch */
+    void setCbcModel(CbcModel* cbc_model)
+    {
+      cbc_model_ = cbc_model;
+    }
+
+    void setOnlyPseudoWhenTrusted(bool only_pseudo_when_trusted)
+    {
+      only_pseudo_when_trusted_ = only_pseudo_when_trusted;
+    }
+
+
+    /** Access to pseudo costs storage.*/
+    const OsiPseudoCosts & pseudoCosts() const{
+      return pseudoCosts_;}
+
+    /** Access to pseudo costs storage.*/
+    OsiPseudoCosts & pseudoCosts() {
+      return pseudoCosts_;}
+  protected:
+
+    /// Holding on the a pointer to the journalist
+    Ipopt::SmartPtr<Ipopt::Journalist> jnlst_;
+
+    /// verbosity level
+    int bb_log_level_;
+
+    /** Stores strong branching results.*/
+    vector<HotInfo> results_;
+
+    /** Determine status of strong branching solution.*/
+    int determineStatus(OsiSolverInterface * solver) const {
+      if (solver->isProvenOptimal())
+        return 0; // optimal
+      else if (solver->isIterationLimitReached()
+               &&!solver->isDualObjectiveLimitReached())
+        return 2; // unknown 
+      else
+        return 1; // infeasible
+    }
+
+  private:
+    /** Default Constructor, forbiden for some reason.*/
+    BonChooseVariable ();
+
+    /** Global time limit for algorithm. */
+    double time_limit_;
+
+    /** Starting time of algorithm.*/
+    double start_time_;
+  protected:
+    /// CbcModel, used to get status of search
+    CbcModel* cbc_model_;
+
+    /** Flag indicating whether we don't want to mix strong branching
+     *  and pseudo costs during the decision which variable to branch
+     *  on */
+    bool only_pseudo_when_trusted_;
+
+    /** Number of variables put into the list because there were not
+     *  trusted */
+    int number_not_trusted_;
+
+    /** Message handler.*/
+    CoinMessageHandler * handler_;
+
+    /** Messages.*/
+    Messages messages_;
+    // ToDo: Make this options
+    /** @name Algoirithmic options */
+    //@{
+    /** maxmin weight in branching decision when no solution has been
+     *  found yet */
+    double maxmin_crit_no_sol_;
+    /** maxmin weight in branching decision when no solution has been
+     *  found yet */
+    double maxmin_crit_have_sol_;
+    /** fraction of branching candidates that are not trusted yet */
+    double setup_pseudo_frac_;
+    /** number of times a branch has to happen so that it is trusted in
+     *  setupList */
+    int numberBeforeTrustedList_;
+    /** number of strong branching points at root node */
+    int numberStrongRoot_;
+    /** backup of numberStrong_ before Root node solve */
+    int numberStrongBackup_;
+    /** number of look-ahead strong-branching steps */
+    int numberLookAhead_;
+#ifndef OLD_USEFULLNESS
+    /** Criterion to use in setup list.*/
+    CandidateSortCriterion sortCrit_;
+#endif
+    /** Always strong branch that many first candidate in the list regardless of numberTrusted.*/
+    int minNumberStrongBranch_;
+    /** Stores the pseudo costs. */
+    OsiPseudoCosts pseudoCosts_;
+    /** Wether or not to trust strong branching results for updating pseudo costs.*/
+    int trustStrongForPseudoCosts_;
+   
+    //@}
+
+    /** detecting if this is root node */
+    bool isRootNode(const OsiBranchingInformation *info) const;
+
+    /** Stores the class name for throwing errors.*/
+    static const std::string CNAME;
+  };
+
+}
+#endif

casadi/include/coin/BonCurvBranchingSolver.hpp

@@ -0,0 +1,77 @@
+// Copyright (C) 2006, 2007 International Business Machines
+// Corporation and others.  All Rights Reserved.
+//
+//
+#error "BonCurvBranchingSolver not supported anymore"
+#ifndef BonCurvBranchingSolver_H
+#define BonCurvBranchingSolver_H
+
+#include "BonStrongBranchingSolver.hpp"
+#include "BonCurvatureEstimator.hpp"
+
+namespace Bonmin
+{
+
+  /** Implementation of BonChooseVariable for curvature-based braching.
+  */
+
+  class CurvBranchingSolver : public StrongBranchingSolver
+  {
+
+  public:
+
+    /// Constructor from solver (so we can set up arrays etc)
+    CurvBranchingSolver (OsiTMINLPInterface * solver);
+
+    /// Copy constructor
+    CurvBranchingSolver (const CurvBranchingSolver &);
+
+    /// Assignment operator
+    CurvBranchingSolver & operator= (const CurvBranchingSolver& rhs);
+
+    /// Destructor
+    virtual ~CurvBranchingSolver ();
+
+    /// Called to initialize solver before a bunch of strong branching
+    /// solves
+    virtual void markHotStart(OsiTMINLPInterface* tminlp_interface);
+
+    /// Called to solve the current TMINLP (with changed bound information)
+    virtual TNLPSolver::ReturnStatus solveFromHotStart(OsiTMINLPInterface* tminlp_interface);
+
+    /// Called after all strong branching solves in a node
+    virtual void unmarkHotStart(OsiTMINLPInterface* tminlp_interface);
+
+  private:
+    /// Default Constructor
+    CurvBranchingSolver ();
+
+    SmartPtr<CurvatureEstimator> cur_estimator_;
+
+    /** @name Stuff for the curvature estimator */
+    //@{
+    bool new_bounds_;
+    bool new_x_;
+    bool new_mults_;
+    double* orig_d_;
+    double* projected_d_;
+    Number* x_l_orig_;
+    Number* x_u_orig_;
+    Number* g_l_orig_;
+    Number* g_u_orig_;
+    //@}
+
+    /** @name Information about the problem */
+    //@{
+    int numCols_;
+    int numRows_;
+    const double* solution_;
+    const double* duals_;
+    double obj_value_;
+    //@}
+
+  };
+
+}
+
+#endif

casadi/include/coin/BonCutStrengthener.hpp

@@ -0,0 +1,244 @@
+// Copyright (C) 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id$
+//
+// Author:   Andreas Waechter                 IBM    2007-03-29
+
+#ifndef __BONCUTSTRENGTHENER_HPP__
+#define __BONCUTSTRENGTHENER_HPP__
+
+#include "BonTMINLP.hpp"
+#include "CoinPackedVector.hpp"
+#include "BonTNLPSolver.hpp"
+
+namespace Bonmin
+{
+  enum CutStrengtheningType{
+    CS_None=0,
+    CS_StrengthenedGlobal=1,
+    CS_UnstrengthenedGlobal_StrengthenedLocal=2,
+    CS_StrengthenedGlobal_StrengthenedLocal=3
+  };
+
+  enum DisjunctiveCutType{
+    DC_None=0,
+    DC_MostFractional=1
+  };
+
+  /** Class for strengthening OA cuts, and generating additional ones.
+   */
+  class CutStrengthener: public Ipopt::ReferencedObject
+  {
+    /** Class implementing the TNLP for strengthening one cut.  We
+     *  assume that the cut has a lower bound. */
+    class StrengtheningTNLP: public Ipopt::TNLP {
+    public:
+      /** Contructor */
+      StrengtheningTNLP(Ipopt::SmartPtr<TMINLP> tminlp,
+			const CoinPackedVector& cut,
+			bool lower_bound,
+			Ipopt::Index n,
+			const Ipopt::Number* starting_point,
+			const double* x_l_orig,
+			const double* x_u_orig,
+			Ipopt::Index constr_index,
+			Ipopt::Index nvar_constr /** Ipopt::Number of variables in constraint */,
+			const Ipopt::Index* jCol);
+
+      /** Destructor */
+      ~StrengtheningTNLP();
+
+      /**@name Overloaded from TNLP */
+      //@{
+      /** Method to return some info about the nlp */
+      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);
+
+      /** Method to return the bounds for my problem */
+      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);
+
+      /** Method to return the starting point for the algorithm */
+      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);
+
+      /** Method to return the objective value */
+      virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Number& obj_value);
+
+      /** Method to return the gradient of the objective */
+      virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Number* grad_f);
+
+      /** Method to return the constraint residuals */
+      virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Index m, Ipopt::Number* g);
+
+      /** Method to return:
+       *   1) The structure of the jacobian (if "values" is NULL)
+       *   2) The values of the jacobian (if "values" is not 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);
+
+      /** Method to return:
+       *   1) The structure of the hessian of the lagrangian (if "values" is NULL)
+       *   2) The values of the hessian of the lagrangian (if "values" is not NULL)
+       */
+      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);
+
+      //@}
+      /** @name Solution Methods */
+      //@{
+      /** This method is called when the algorithm is complete so the TNLP can store/write the solution */
+      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);
+      //@}
+
+      /** Method for asking for the strengthened bound. */
+      Ipopt::Number StrengthenedBound() const;
+      
+    private:
+      /**@name Methods to block default compiler methods. */
+      //@{
+      StrengtheningTNLP();
+      StrengtheningTNLP(const StrengtheningTNLP&);
+      StrengtheningTNLP& operator=(const StrengtheningTNLP&);
+      //@}
+
+      /** TMINLP (with current bounds) for which the cut it to be
+       *  generated */
+      const Ipopt::SmartPtr<TMINLP> tminlp_;
+
+      /** Gradient of the (linear) objective function */
+      Ipopt::Number* obj_grad_;
+
+      /** Dimension of original problem */
+      const Ipopt::Index n_orig_;
+
+      /** Ipopt::Number of constraints in original problem */
+      Ipopt::Index m_orig_;
+
+      /** Starting point */
+      Ipopt::Number* starting_point_;
+
+      /** Full dimentional x which is used to call the TMINLP
+       *  evaluation routines */
+      Ipopt::Number* x_full_;
+
+      /** Lower bounds for constraint variables */
+      Ipopt::Number* x_l_;
+
+      /** Upper bounds for constraint variables */
+      Ipopt::Number* x_u_;
+
+      /** Ipopt::Index of the constraint */
+      const Ipopt::Index constr_index_;
+
+      /** Ipopt::Number of variables appearing in the constraint */
+      const Ipopt::Index nvar_constr_;
+
+      /** List of variables appearing on the constraints */
+      Ipopt::Index* var_indices_;
+
+      /** Flag indicating if the cut has a lower or upper bound */
+      bool lower_bound_;
+
+      /** Flag indicating if we TNLP has been solved successfully */
+      bool have_final_bound_;
+
+      /** Final strengthened bound */
+      Ipopt::Number strengthened_bound_;
+
+      /** space for original gradient if objective function is handled */
+      Ipopt::Number* grad_f_;
+
+      /** Auxilliary method for updating the full x variable */
+      void update_x_full(const Ipopt::Number *x);
+    };
+
+  public:
+    /** @name Constructor/Destructor */
+    //@{
+    /** Constructor.  It is given a TNLP solver to solve the internal
+     *  NLPs. */
+    CutStrengthener(Ipopt::SmartPtr<TNLPSolver> tnlp_solver,
+		    Ipopt::SmartPtr<Ipopt::OptionsList> options);
+
+    /** Destructor */
+    virtual ~CutStrengthener();
+    //@}
+
+    /** Method for generating and strenghtening all desired cuts */
+    bool ComputeCuts(OsiCuts &cs,
+		     TMINLP* tminlp,
+		     TMINLP2TNLP* problem,
+		     const int gindex, CoinPackedVector& cut,
+		     double& cut_lb, double& cut_ub,
+		     const double g_val, const double g_lb,
+		     const double g_ub,
+		     int n, const double* x,
+		     double infty);
+
+  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 */
+    CutStrengthener();
+
+    /** Copy Constructor */
+    CutStrengthener(const CutStrengthener&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const CutStrengthener&);
+    //@}
+
+    /** Method for strengthening one cut. */
+    bool StrengthenCut(Ipopt::SmartPtr<TMINLP> tminlp /** current TMINLP */,
+		       int constr_index /** Ipopt::Index number of the constraint to be strengthened, -1 means objective function */,
+		       const CoinPackedVector& row /** Cut to be strengthened */,
+		       int n /** Ipopt::Number of variables */,
+		       const double* x /** solution from node */,
+		       const double* x_l /** Lower bounds for x in which should be valid. */,
+		       const double* x_u /** Upper bounds for x in which should be valid. */,
+		       double& lb,
+		       double& ub);
+
+    /** Method for generating one type of cut (strengthened or disjunctive) */
+    bool HandleOneCut(bool is_tight, TMINLP* tminlp,
+		      TMINLP2TNLP* problem,
+		      const double* minlp_lb,
+		      const double* minlp_ub,
+		      const int gindex, CoinPackedVector& cut,
+		      double& cut_lb, double& cut_ub,
+		      int n, const double* x,
+		      double infty);
+
+    /** Object for solving the TNLPs */
+    Ipopt::SmartPtr<TNLPSolver> tnlp_solver_;
+
+    /** Type of OA cut strengthener */
+    int cut_strengthening_type_;
+    /** What kind of disjuntion should be done */
+    int disjunctive_cut_type_;
+    /** verbosity level for OA-related output */
+    int oa_log_level_;
+  };
+
+} // namespace Ipopt
+#endif