casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcDummyBranchingObject.hpp

@@ -0,0 +1,83 @@
+// $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).
+
+// Edwin 11/10/2009-- carved out of CbcBranchActual
+
+#ifndef CbcDummyBranchingObject_H
+#define CbcDummyBranchingObject_H
+
+#include "CbcBranchBase.hpp"
+/** Dummy branching object
+
+  This object specifies a one-way dummy branch.
+  This is so one can carry on branching even when it looks feasible
+*/
+
+class CbcDummyBranchingObject : public CbcBranchingObject {
+
+public:
+  /// Default constructor
+  CbcDummyBranchingObject(CbcModel *model = NULL);
+
+  /// Copy constructor
+  CbcDummyBranchingObject(const CbcDummyBranchingObject &);
+
+  /// Assignment operator
+  CbcDummyBranchingObject &operator=(const CbcDummyBranchingObject &rhs);
+
+  /// Clone
+  virtual CbcBranchingObject *clone() const;
+
+  /// Destructor
+  virtual ~CbcDummyBranchingObject();
+
+  using CbcBranchingObject::branch;
+  /** \brief Dummy branch
+    */
+  virtual double branch();
+
+#ifdef JJF_ZERO
+  // No need to override. Default works fine.
+  /** Reset every information so that the branching object appears to point to
+        the previous child. This method does not need to modify anything in any
+        solver. */
+  virtual void previousBranch();
+#endif
+
+  using CbcBranchingObject::print;
+  /** \brief Print something about branch - only if log level high
+    */
+  virtual void print();
+
+  /** Return the type (an integer identifier) of \c this */
+  virtual CbcBranchObjType type() const
+  {
+    return DummyBranchObj;
+  }
+
+  /** 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);
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcEventHandler.hpp

@@ -0,0 +1,250 @@
+/*
+  Copyright (C) 2006, International Business Machines Corporation and others.
+  All Rights Reserved.
+
+  This code is licensed under the terms of the Eclipse Public License (EPL).
+
+  $Id$
+*/
+
+#ifndef CbcEventHandler_H
+#define CbcEventHandler_H
+
+/*! \file CbcEventHandler.hpp
+    \brief Event handling for cbc
+
+  This file contains the declaration of CbcEventHandler, used for event
+  handling in cbc.
+
+  The central method is CbcEventHandler::event(). The default semantics of
+  this call are `ask for the action to take in reponse to this event'. The
+  call is made at the point in the code where the event occurs (<i>e.g.</i>,
+  when a solution is found, or when a node is added to or removed from the
+  search tree). The return value specifies the action to perform in response
+  to the event (<i>e.g.</i>, continue, or stop).
+
+  This is a lazy class. Initially, it knows nothing about specific events,
+  and returns dfltAction_ for any event. This makes for a trivial constructor
+  and fast startup. The only place where the list of known events or actions
+  is hardwired is in the enum definitions for CbcEvent and CbcAction,
+  respectively.
+
+  At the first call to setAction, a map is created to hold (Event,Action)
+  pairs, and this map will be consulted ever after. Events not in the map
+  will still return the default value.
+
+  For serious extensions, derive a subclass and replace event() with a
+  function that suits you better.  The function has access to the CbcModel
+  via a pointer held in the CbcEventHandler object, and can do as much
+  thinking as it likes before returning an answer.  You can also print as
+  much information as you want. The model is held as a const, however, so
+  you can't alter reality.
+
+  The design of the class deliberately matches ClpEventHandler, so that other
+  solvers can participate in cbc without breaking the patterns set by
+  clp-specific code.
+
+*/
+
+#include <cstddef>
+#include <map>
+
+/* May well already be declared, but can't hurt. */
+
+class CbcModel;
+
+/*
+  cvs/svn: $Id$
+*/
+
+/*! \class CbcEventHandler
+    \brief Base class for Cbc event handling.
+
+  Up front: We're not talking about unanticipated events here. We're talking
+  about anticipated events, in the sense that the code is going to make a call
+  to event() and is prepared to obey the return value that it receives.
+
+  The general pattern for usage is as follows:
+  <ol>
+    <li> Create a CbcEventHandler object. This will be initialised with a set
+	 of default actions for every recognised event.
+
+    <li> Attach the event handler to the CbcModel object.
+
+    <li> When execution reaches the point where an event occurs, call the
+	 event handler as CbcEventHandler::event(the event). The return value
+	 will specify what the code should do in response to the event.
+  </ol>
+
+  The return value associated with an event can be changed at any time.
+*/
+
+class CbcEventHandler {
+
+public:
+  /*! \brief Events known to cbc */
+
+  enum CbcEvent { /*! Processing of the current node is complete. */
+    node = 200,
+    /*! A tree status interval has arrived. */
+    treeStatus,
+    /*! A solution has been found. */
+    solution,
+    /*! A heuristic solution has been found. */
+    heuristicSolution,
+    /*! A solution will be found unless user takes action (first check). */
+    beforeSolution1,
+    /*! A solution will be found unless user takes action (thorough check). */
+    beforeSolution2,
+    /*! After failed heuristic. */
+    afterHeuristic,
+    /*! On entry to small branch and bound. */
+    smallBranchAndBound,
+    /*! After a pass of heuristic. */
+    heuristicPass,
+    /*! When converting constraints to cuts. */
+    convertToCuts,
+    /*! Having generated cuts, allows user to think. */
+    generatedCuts,
+    /*! End of search. */
+    endSearch,
+    /*! Just before starting branching i.e. after root cuts. */
+    afterRootCuts
+  };
+
+  /*! \brief Action codes returned by the event handler.
+
+        Specific values are chosen to match ClpEventHandler return codes.
+    */
+
+  enum CbcAction { /*! Continue --- no action required. */
+    noAction = -1,
+    /*! Stop --- abort the current run at the next opportunity. */
+    stop = 0,
+    /*! Restart --- restart branch-and-cut search; do not undo root node
+        processing.
+        */
+    restart,
+    /*! RestartRoot --- undo root node and start branch-and-cut afresh. */
+    restartRoot,
+    /*! Add special cuts. */
+    addCuts,
+    /*! Pretend solution never happened. */
+    killSolution,
+    /*! Take action on modified data. */
+    takeAction
+
+  };
+
+  /*! \brief Data type for event/action pairs */
+
+  typedef std::map< CbcEvent, CbcAction > eaMapPair;
+
+  /*! \name Event Processing */
+  //@{
+
+  /*! \brief Return the action to be taken for an event.
+
+      Return the action that should be taken in response to the event passed as
+      the parameter. The default implementation simply reads a return code
+      from a map.
+    */
+  virtual CbcAction event(CbcEvent whichEvent);
+
+  /*! \brief Return the action to be taken for an event - and modify data.
+
+      Return the action that should be taken in response to the event passed as
+      the parameter. The default implementation simply reads a return code
+      from a map.
+    */
+  virtual CbcAction event(CbcEvent whichEvent, void *data);
+
+  //@}
+
+  /*! \name Constructors and destructors */
+  //@{
+
+  /*! \brief Default constructor. */
+
+  CbcEventHandler(CbcModel *model = 0 /* was NULL but 4.6 complains */);
+
+  /*! \brief Copy constructor. */
+
+  CbcEventHandler(const CbcEventHandler &orig);
+
+  /*! \brief Assignment. */
+
+  CbcEventHandler &operator=(const CbcEventHandler &rhs);
+
+  /*! \brief Clone (virtual) constructor. */
+
+  virtual CbcEventHandler *clone() const;
+
+  /*! \brief Destructor. */
+
+  virtual ~CbcEventHandler();
+
+  //@}
+
+  /*! \name Set/Get methods */
+  //@{
+
+  /*! \brief Set model. */
+
+  inline void setModel(CbcModel *model)
+  {
+    model_ = model;
+  }
+
+  /*! \brief Get model. */
+
+  inline const CbcModel *getModel() const
+  {
+    return model_;
+  }
+
+  /*! \brief Set the default action */
+
+  inline void setDfltAction(CbcAction action)
+  {
+    dfltAction_ = action;
+  }
+
+  /*! \brief Set the action code associated with an event */
+
+  inline void setAction(CbcEvent event, CbcAction action)
+  {
+    if (eaMap_ == 0) {
+      eaMap_ = new eaMapPair;
+    }
+    (*eaMap_)[event] = action;
+  }
+
+  //@}
+
+protected:
+  /*! \name Data members
+
+       Protected (as opposed to private) to allow access by derived classes.
+    */
+  //@{
+
+  /*! \brief Pointer to associated CbcModel */
+
+  CbcModel *model_;
+
+  /*! \brief Default action */
+
+  CbcAction dfltAction_;
+
+  /*! \brief Pointer to a map that holds non-default event/action pairs */
+
+  eaMapPair *eaMap_;
+
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcFathom.hpp

@@ -0,0 +1,136 @@
+/* $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 CbcFathom_H
+#define CbcFathom_H
+#include "CbcConfig.h"
+
+/*
+  This file contains two classes, CbcFathom and CbcOsiSolver. It's unclear why
+  they're in the same file. CbcOsiSolver is a base class for CbcLinked.
+
+  --lh, 071031 --
+*/
+
+class CbcModel;
+
+//#############################################################################
+/** Fathom base class.
+
+    The idea is that after some branching the problem will be effectively smaller than
+    the original problem and maybe there will be a more specialized technique which can completely
+    fathom this branch quickly.
+
+    One method is to presolve the problem to give a much smaller new problem and then do branch
+    and cut on that.  Another might be dynamic programming.
+
+ */
+
+class CbcFathom {
+public:
+  // Default Constructor
+  CbcFathom();
+
+  // Constructor with model - assumed before cuts
+  CbcFathom(CbcModel &model);
+
+  virtual ~CbcFathom();
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  /// Clone
+  virtual CbcFathom *clone() const = 0;
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model) = 0;
+
+  /** returns 0 if no fathoming attempted, 1 fully fathomed,
+        2 incomplete search, 3 incomplete search but treat as complete.
+        If solution then newSolution will not be NULL and
+        will be freed by CbcModel.  It is expected that the solution is better
+        than best so far but CbcModel will double check.
+
+        If returns 3 then of course there is no guarantee of global optimum
+    */
+  virtual int fathom(double *&newSolution) = 0;
+
+  // Is this method possible
+  inline bool possible() const
+  {
+    return possible_;
+  }
+
+protected:
+  /// Model
+  CbcModel *model_;
+  /// Possible - if this method of fathoming can be used
+  bool possible_;
+
+private:
+  /// Illegal Assignment operator
+  CbcFathom &operator=(const CbcFathom &rhs);
+};
+
+#include "OsiClpSolverInterface.hpp"
+
+//#############################################################################
+
+/**
+
+This is for codes where solver needs to know about CbcModel
+  Seems to provide only one value-added feature, a CbcModel object.
+
+*/
+
+class CbcOsiSolver : public OsiClpSolverInterface {
+
+public:
+  /**@name Constructors and destructors */
+  //@{
+  /// Default Constructor
+  CbcOsiSolver();
+
+  /// Clone
+  virtual OsiSolverInterface *clone(bool copyData = true) const;
+
+  /// Copy constructor
+  CbcOsiSolver(const CbcOsiSolver &);
+
+  /// Assignment operator
+  CbcOsiSolver &operator=(const CbcOsiSolver &rhs);
+
+  /// Destructor
+  virtual ~CbcOsiSolver();
+
+  //@}
+
+  /**@name Sets and Gets */
+  //@{
+  /// Set Cbc Model
+  inline void setCbcModel(CbcModel *model)
+  {
+    cbcModel_ = model;
+  }
+  /// Return Cbc Model
+  inline CbcModel *cbcModel() const
+  {
+    return cbcModel_;
+  }
+  //@}
+
+  //---------------------------------------------------------------------------
+
+protected:
+  /**@name Private member data */
+  //@{
+  /// Pointer back to CbcModel
+  CbcModel *cbcModel_;
+  //@}
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcFathomDynamicProgramming.hpp

@@ -0,0 +1,177 @@
+/* $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 CbcFathomDynamicProgramming_H
+#define CbcFathomDynamicProgramming_H
+
+#include "CbcFathom.hpp"
+
+//#############################################################################
+/** FathomDynamicProgramming class.
+
+    The idea is that after some branching the problem will be effectively smaller than
+    the original problem and maybe there will be a more specialized technique which can completely
+    fathom this branch quickly.
+
+    This is a dynamic programming implementation which is very fast for some
+    specialized problems.  It expects small integral rhs, an all integer problem
+    and positive integral coefficients. At present it can not do general set covering
+    problems just set partitioning.  It can find multiple optima for various rhs
+    combinations.
+
+    The main limiting factor is size of state space.  Each 1 rhs doubles the size of the problem.
+    2 or 3 rhs quadruples, 4,5,6,7 by 8 etc.
+ */
+
+class CbcFathomDynamicProgramming : public CbcFathom {
+public:
+  // Default Constructor
+  CbcFathomDynamicProgramming();
+
+  // Constructor with model - assumed before cuts
+  CbcFathomDynamicProgramming(CbcModel &model);
+  // Copy constructor
+  CbcFathomDynamicProgramming(const CbcFathomDynamicProgramming &rhs);
+
+  virtual ~CbcFathomDynamicProgramming();
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  /// Clone
+  virtual CbcFathom *clone() const;
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /** returns 0 if no fathoming attempted, 1 fully fathomed ,
+        2 incomplete search, 3 incomplete search but treat as complete.
+        If solution then newSolution will not be NULL and
+        will be freed by CbcModel.  It is expected that the solution is better
+        than best so far but CbcModel will double check.
+
+        If returns 3 then of course there is no guarantee of global optimum
+    */
+  virtual int fathom(double *&newSolution);
+
+  /// Maximum size allowed
+  inline int maximumSize() const
+  {
+    return maximumSizeAllowed_;
+  }
+  inline void setMaximumSize(int value)
+  {
+    maximumSizeAllowed_ = value;
+  }
+  /// Returns type of algorithm and sets up arrays
+  int checkPossible(int allowableSize = 0);
+  // set algorithm
+  inline void setAlgorithm(int value)
+  {
+    algorithm_ = value;
+  }
+  /** Tries a column
+        returns true if was used in making any changes.
+    */
+  bool tryColumn(int numberElements, const int *rows,
+    const double *coefficients, double cost,
+    int upper = COIN_INT_MAX);
+  /// Returns cost array
+  inline const double *cost() const
+  {
+    return cost_;
+  }
+  /// Returns back array
+  inline const int *back() const
+  {
+    return back_;
+  }
+  /// Gets bit pattern for target result
+  inline int target() const
+  {
+    return target_;
+  }
+  /// Sets bit pattern for target result
+  inline void setTarget(int value)
+  {
+    target_ = value;
+  }
+
+private:
+  /// Does deleteions
+  void gutsOfDelete();
+
+  /** Adds one attempt of one column of type 0,
+        returns true if was used in making any changes
+    */
+  bool addOneColumn0(int numberElements, const int *rows,
+    double cost);
+  /** Adds one attempt of one column of type 1,
+        returns true if was used in making any changes.
+        At present the user has to call it once for each possible value
+    */
+  bool addOneColumn1(int numberElements, const int *rows,
+    const int *coefficients, double cost);
+  /** Adds one attempt of one column of type 1,
+        returns true if was used in making any changes.
+        At present the user has to call it once for each possible value.
+        This version is when there are enough 1 rhs to do faster
+    */
+  bool addOneColumn1A(int numberElements, const int *rows,
+    const int *coefficients, double cost);
+  /// Gets bit pattern from original column
+  int bitPattern(int numberElements, const int *rows,
+    const int *coefficients);
+  /// Gets bit pattern from original column
+  int bitPattern(int numberElements, const int *rows,
+    const double *coefficients);
+  /// Fills in original column (dense) from bit pattern - returning number nonzero
+  int decodeBitPattern(int bitPattern, int *values, int numberRows);
+
+protected:
+  /// Size of states (power of 2 unless just one constraint)
+  int size_;
+  /** Type - 0 coefficients and rhs all 1,
+        1 - coefficients > 1 or rhs > 1
+    */
+  int type_;
+  /// Space for states
+  double *cost_;
+  /// Which state produced this cheapest one
+  int *back_;
+  /// Some rows may be satisified so we need a lookup
+  int *lookup_;
+  /// Space for sorted indices
+  int *indices_;
+  /// Number of active rows
+  int numberActive_;
+  /// Maximum size allowed
+  int maximumSizeAllowed_;
+  /// Start bit for each active row
+  int *startBit_;
+  /// Number bits for each active row
+  int *numberBits_;
+  /// Effective rhs
+  int *rhs_;
+  /// Space for sorted coefficients
+  int *coefficients_;
+  /// Target pattern
+  int target_;
+  /// Number of Non 1 rhs
+  int numberNonOne_;
+  /// Current bit pattern
+  int bitPattern_;
+  /// Current algorithm
+  int algorithm_;
+
+private:
+  /// Illegal Assignment operator
+  CbcFathomDynamicProgramming &operator=(const CbcFathomDynamicProgramming &rhs);
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcFeasibilityBase.hpp

@@ -0,0 +1,60 @@
+/* $Id$ */
+// Copyright (C) 2005, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcFeasibilityBase_H
+#define CbcFeasibilityBase_H
+
+//#############################################################################
+/*  There are cases where the user wants to control how CBC sees the problems feasibility.
+    The user may want to examine the problem and say :
+    a) The default looks OK
+    b) Pretend this problem is Integer feasible
+    c) Pretend this problem is infeasible even though it looks feasible
+
+    This simple class allows user to do that.
+
+*/
+
+class CbcModel;
+class CbcFeasibilityBase {
+public:
+  // Default Constructor
+  CbcFeasibilityBase() {}
+
+  /**
+       On input mode:
+       0 - called after a solve but before any cuts
+       -1 - called after strong branching
+       Returns :
+       0 - no opinion
+       -1 pretend infeasible
+       1 pretend integer solution
+    */
+  virtual int feasible(CbcModel *, int)
+  {
+    return 0;
+  }
+
+  virtual ~CbcFeasibilityBase() {}
+
+  // Copy constructor
+  CbcFeasibilityBase(const CbcFeasibilityBase &) {}
+
+  // Assignment operator
+  CbcFeasibilityBase &operator=(const CbcFeasibilityBase &)
+  {
+    return *this;
+  }
+
+  /// Clone
+  virtual CbcFeasibilityBase *clone() const
+  {
+    return new CbcFeasibilityBase(*this);
+  }
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/