casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcCutGenerator.hpp

@@ -0,0 +1,550 @@
+/* $Id$ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcCutGenerator_H
+#define CbcCutGenerator_H
+
+#include "OsiSolverInterface.hpp"
+#include "OsiCuts.hpp"
+#include "CglCutGenerator.hpp"
+#include "CbcCutModifier.hpp"
+
+class CbcModel;
+class OsiRowCut;
+class OsiRowCutDebugger;
+
+//#############################################################################
+
+/** Interface between Cbc and Cut Generation Library.
+
+  \c CbcCutGenerator is intended to provide an intelligent interface between
+  Cbc and the cutting plane algorithms in the CGL. A \c CbcCutGenerator is
+  bound to a \c CglCutGenerator and to an \c CbcModel. It contains parameters
+  which control when and how the \c generateCuts method of the
+  \c CglCutGenerator will be called.
+
+  The builtin decision criteria available to use when deciding whether to
+  generate cuts are limited: every <i>X</i> nodes, when a solution is found,
+  and when a subproblem is found to be infeasible. The idea is that the class
+  will grow more intelligent with time.
+
+  \todo Add a pointer to function member which will allow a client to install
+	their own decision algorithm to decide whether or not to call the CGL
+	\p generateCuts method. Create a default decision method that looks
+	at the builtin criteria.
+
+  \todo It strikes me as not good that generateCuts contains code specific to
+	individual CGL algorithms. Another set of pointer to function members,
+	so that the client can specify the cut generation method as well as
+	pre- and post-generation methods? Taken a bit further, should this
+	class contain a bunch of pointer to function members, one for each
+	of the places where the cut generator might be referenced?
+	Initialization, root node, search tree node, discovery of solution,
+	and termination all come to mind. Initialization and termination would
+	also be useful for instrumenting cbc.
+*/
+
+class CbcCutGenerator {
+
+public:
+  /** \name Generate Cuts */
+  //@{
+  /** Generate cuts for the client model.
+
+      Evaluate the state of the client model and decide whether to generate cuts.
+      The generated cuts are inserted into and returned in the collection of cuts
+      \p cs.
+
+      If \p fullScan is !=0, the generator is obliged to call the CGL
+      \c generateCuts routine.  Otherwise, it is free to make a local decision.
+      Negative fullScan says things like at integer solution
+      The current implementation uses \c whenCutGenerator_ to decide.
+
+      The routine returns true if reoptimisation is needed (because the state of
+      the solver interface has been modified).
+
+      If node then can find out depth
+    */
+  bool generateCuts(OsiCuts &cs, int fullScan, OsiSolverInterface *solver,
+    CbcNode *node);
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor
+  CbcCutGenerator();
+
+  /// Normal constructor
+  CbcCutGenerator(CbcModel *model, CglCutGenerator *generator,
+    int howOften = 1, const char *name = NULL,
+    bool normal = true, bool atSolution = false,
+    bool infeasible = false, int howOftenInsub = -100,
+    int whatDepth = -1, int whatDepthInSub = -1, int switchOffIfLessThan = 0);
+
+  /// Copy constructor
+  CbcCutGenerator(const CbcCutGenerator &);
+
+  /// Assignment operator
+  CbcCutGenerator &operator=(const CbcCutGenerator &rhs);
+
+  /// Destructor
+  ~CbcCutGenerator();
+  //@}
+
+  /**@name Gets and sets */
+  //@{
+  /** Set the client model.
+
+      In addition to setting the client model, refreshModel also calls
+      the \c refreshSolver method of the CglCutGenerator object.
+    */
+  void refreshModel(CbcModel *model);
+
+  /// return name of generator
+  inline const char *cutGeneratorName() const
+  {
+    return generatorName_;
+  }
+
+  /// Create C++ lines to show how to tune
+  void generateTuning(FILE *fp);
+  /** Set the cut generation interval
+
+      Set the number of nodes evaluated between calls to the Cgl object's
+      \p generateCuts routine.
+
+      If \p value is positive, cuts will always be generated at the specified
+      interval.
+      If \p value is negative, cuts will initially be generated at the specified
+      interval, but Cbc may adjust the value depending on the success of cuts
+      produced by this generator.
+
+      A value of -100 disables the generator, while a value of -99 means
+      just at root.
+    */
+  void setHowOften(int value);
+
+  /// Get the cut generation interval.
+  inline int howOften() const
+  {
+    return whenCutGenerator_;
+  }
+  /// Get the cut generation interval.in sub tree
+  inline int howOftenInSub() const
+  {
+    return whenCutGeneratorInSub_;
+  }
+  /// Get level of cut inaccuracy (0 means exact e.g. cliques)
+  inline int inaccuracy() const
+  {
+    return inaccuracy_;
+  }
+  /// Set level of cut inaccuracy (0 means exact e.g. cliques)
+  inline void setInaccuracy(int level)
+  {
+    inaccuracy_ = level;
+  }
+
+  /** Set the cut generation depth
+
+      Set the depth criterion for calls to the Cgl object's
+      \p generateCuts routine.  Only active if > 0.
+
+      If whenCutGenerator is positive and this is positive then this overrides.
+      If whenCutGenerator is -1 then this is used as criterion if any cuts
+      were generated at root node.
+      If whenCutGenerator is anything else this is ignored.
+    */
+  void setWhatDepth(int value);
+  /// Set the cut generation depth in sub tree
+  void setWhatDepthInSub(int value);
+  /// Get the cut generation depth criterion.
+  inline int whatDepth() const
+  {
+    return depthCutGenerator_;
+  }
+  /// Get the cut generation depth criterion.in sub tree
+  inline int whatDepthInSub() const
+  {
+    return depthCutGeneratorInSub_;
+  }
+  /// Set maximum number of times to enter
+  inline void setMaximumTries(int value)
+  {
+    maximumTries_ = value;
+  }
+  /// Get maximum number of times to enter
+  inline int maximumTries() const
+  {
+    return maximumTries_;
+  }
+
+  /// Get switches
+  inline int switches() const
+  {
+    return switches_;
+  }
+  /// Set switches (for copying from virgin state)
+  inline void setSwitches(int value)
+  {
+    switches_ = value;
+  }
+  /// Get whether the cut generator should be called in the normal place
+  inline bool normal() const
+  {
+    return (switches_ & 1) != 0;
+  }
+  /// Set whether the cut generator should be called in the normal place
+  inline void setNormal(bool value)
+  {
+    switches_ &= ~1;
+    switches_ |= value ? 1 : 0;
+  }
+  /// Get whether the cut generator should be called when a solution is found
+  inline bool atSolution() const
+  {
+    return (switches_ & 2) != 0;
+  }
+  /// Set whether the cut generator should be called when a solution is found
+  inline void setAtSolution(bool value)
+  {
+    switches_ &= ~2;
+    switches_ |= value ? 2 : 0;
+  }
+  /** Get whether the cut generator should be called when the subproblem is
+        found to be infeasible.
+    */
+  inline bool whenInfeasible() const
+  {
+    return (switches_ & 4) != 0;
+  }
+  /** Set whether the cut generator should be called when the subproblem is
+        found to be infeasible.
+    */
+  inline void setWhenInfeasible(bool value)
+  {
+    switches_ &= ~4;
+    switches_ |= value ? 4 : 0;
+  }
+  /// Get whether the cut generator is being timed
+  inline bool timing() const
+  {
+    return (switches_ & 64) != 0;
+  }
+  /// Set whether the cut generator is being timed
+  inline void setTiming(bool value)
+  {
+    switches_ &= ~64;
+    switches_ |= value ? 64 : 0;
+    timeInCutGenerator_ = 0.0;
+  }
+  /// Return time taken in cut generator
+  inline double timeInCutGenerator() const
+  {
+    return timeInCutGenerator_;
+  }
+  inline void incrementTimeInCutGenerator(double value)
+  {
+    timeInCutGenerator_ += value;
+  }
+  /// Get the \c CglCutGenerator corresponding to this \c CbcCutGenerator.
+  inline CglCutGenerator *generator() const
+  {
+    return generator_;
+  }
+  /// Number times cut generator entered
+  inline int numberTimesEntered() const
+  {
+    return numberTimes_;
+  }
+  inline void setNumberTimesEntered(int value)
+  {
+    numberTimes_ = value;
+  }
+  inline void incrementNumberTimesEntered(int value = 1)
+  {
+    numberTimes_ += value;
+  }
+  /// Total number of cuts added
+  inline int numberCutsInTotal() const
+  {
+    return numberCuts_;
+  }
+  inline void setNumberCutsInTotal(int value)
+  {
+    numberCuts_ = value;
+  }
+  inline void incrementNumberCutsInTotal(int value = 1)
+  {
+    numberCuts_ += value;
+  }
+  /// Total number of elements added
+  inline int numberElementsInTotal() const
+  {
+    return numberElements_;
+  }
+  inline void setNumberElementsInTotal(int value)
+  {
+    numberElements_ = value;
+  }
+  inline void incrementNumberElementsInTotal(int value = 1)
+  {
+    numberElements_ += value;
+  }
+  /// Total number of column cuts
+  inline int numberColumnCuts() const
+  {
+    return numberColumnCuts_;
+  }
+  inline void setNumberColumnCuts(int value)
+  {
+    numberColumnCuts_ = value;
+  }
+  inline void incrementNumberColumnCuts(int value = 1)
+  {
+    numberColumnCuts_ += value;
+  }
+  /// Total number of cuts active after (at end of n cut passes at each node)
+  inline int numberCutsActive() const
+  {
+    return numberCutsActive_;
+  }
+  inline void setNumberCutsActive(int value)
+  {
+    numberCutsActive_ = value;
+  }
+  inline void incrementNumberCutsActive(int value = 1)
+  {
+    numberCutsActive_ += value;
+  }
+  inline void setSwitchOffIfLessThan(int value)
+  {
+    switchOffIfLessThan_ = value;
+  }
+  inline int switchOffIfLessThan() const
+  {
+    return switchOffIfLessThan_;
+  }
+  /// Say if optimal basis needed
+  inline bool needsOptimalBasis() const
+  {
+    return (switches_ & 128) != 0;
+  }
+  /// Set if optimal basis needed
+  inline void setNeedsOptimalBasis(bool yesNo)
+  {
+    switches_ &= ~128;
+    switches_ |= yesNo ? 128 : 0;
+  }
+  /// Whether generator MUST be called again if any cuts (i.e. ignore break from loop)
+  inline bool mustCallAgain() const
+  {
+    return (switches_ & 8) != 0;
+  }
+  /// Set whether generator MUST be called again if any cuts (i.e. ignore break from loop)
+  inline void setMustCallAgain(bool yesNo)
+  {
+    switches_ &= ~8;
+    switches_ |= yesNo ? 8 : 0;
+  }
+  /// Whether generator switched off for moment
+  inline bool switchedOff() const
+  {
+    return (switches_ & 16) != 0;
+  }
+  /// Set whether generator switched off for moment
+  inline void setSwitchedOff(bool yesNo)
+  {
+    switches_ &= ~16;
+    switches_ |= yesNo ? 16 : 0;
+  }
+  /// Whether last round of cuts did little
+  inline bool ineffectualCuts() const
+  {
+    return (switches_ & 512) != 0;
+  }
+  /// Set whether last round of cuts did little
+  inline void setIneffectualCuts(bool yesNo)
+  {
+    switches_ &= ~512;
+    switches_ |= yesNo ? 512 : 0;
+  }
+  /// Whether to use if any cuts generated
+  inline bool whetherToUse() const
+  {
+    return (switches_ & 1024) != 0;
+  }
+  /// Set whether to use if any cuts generated
+  inline void setWhetherToUse(bool yesNo)
+  {
+    switches_ &= ~1024;
+    switches_ |= yesNo ? 1024 : 0;
+  }
+  /// Whether in must call again mode (or after others)
+  inline bool whetherInMustCallAgainMode() const
+  {
+    return (switches_ & 2048) != 0;
+  }
+  /// Set whether in must call again mode (or after others)
+  inline void setWhetherInMustCallAgainMode(bool yesNo)
+  {
+    switches_ &= ~2048;
+    switches_ |= yesNo ? 2048 : 0;
+  }
+  /// Whether to call at end
+  inline bool whetherCallAtEnd() const
+  {
+    return (switches_ & 4096) != 0;
+  }
+  /// Set whether to call at end
+  inline void setWhetherCallAtEnd(bool yesNo)
+  {
+    switches_ &= ~4096;
+    switches_ |= yesNo ? 4096 : 0;
+  }
+  /// Whether needs refresh on copy
+  inline bool needsRefresh() const
+  {
+    return (switches_ & 8192) != 0;
+  }
+  /// Set whether needs refresh on copy
+  inline void setNeedsRefresh(bool yesNo)
+  {
+    switches_ &= ~8192;
+    switches_ |= yesNo ? 8192 : 0;
+  }
+  /// Number of cuts generated at root
+  inline int numberCutsAtRoot() const
+  {
+    return numberCutsAtRoot_;
+  }
+  inline void setNumberCutsAtRoot(int value)
+  {
+    numberCutsAtRoot_ = value;
+  }
+  /// Number of cuts active at root
+  inline int numberActiveCutsAtRoot() const
+  {
+    return numberActiveCutsAtRoot_;
+  }
+  inline void setNumberActiveCutsAtRoot(int value)
+  {
+    numberActiveCutsAtRoot_ = value;
+  }
+  /// Number of short cuts at root
+  inline int numberShortCutsAtRoot() const
+  {
+    return numberShortCutsAtRoot_;
+  }
+  inline void setNumberShortCutsAtRoot(int value)
+  {
+    numberShortCutsAtRoot_ = value;
+  }
+  /// Set model
+  inline void setModel(CbcModel *model)
+  {
+    model_ = model;
+  }
+  /// Whether global cuts at root
+  inline bool globalCutsAtRoot() const
+  {
+    return (switches_ & 32) != 0;
+  }
+  /// Set whether global cuts at root
+  inline void setGlobalCutsAtRoot(bool yesNo)
+  {
+    switches_ &= ~32;
+    switches_ |= yesNo ? 32 : 0;
+  }
+  /// Whether global cuts
+  inline bool globalCuts() const
+  {
+    return (switches_ & 256) != 0;
+  }
+  /// Set whether global cuts
+  inline void setGlobalCuts(bool yesNo)
+  {
+    switches_ &= ~256;
+    switches_ |= yesNo ? 256 : 0;
+  }
+  /// Add in statistics from other
+  void addStatistics(const CbcCutGenerator *other);
+  /// Scale back statistics by factor
+  void scaleBackStatistics(int factor);
+  //@}
+
+private:
+  /**@name Private gets and sets */
+  //@{
+  //@}
+  /// Saved cuts
+  OsiCuts savedCuts_;
+  /// Time in cut generator
+  double timeInCutGenerator_;
+  /// The client model
+  CbcModel *model_;
+
+  // The CglCutGenerator object
+  CglCutGenerator *generator_;
+
+  /// Name of generator
+  char *generatorName_;
+
+  /** Number of nodes between calls to the CglCutGenerator::generateCuts
+       routine.
+    */
+  int whenCutGenerator_;
+  /** Number of nodes between calls to the CglCutGenerator::generateCuts
+       routine in sub tree.
+    */
+  int whenCutGeneratorInSub_;
+  /** If first pass at root produces fewer than this cuts then switch off
+     */
+  int switchOffIfLessThan_;
+
+  /** Depth at which to call the CglCutGenerator::generateCuts
+       routine (If >0 then overrides when and is called if depth%depthCutGenerator==0).
+    */
+  int depthCutGenerator_;
+
+  /** Depth at which to call the CglCutGenerator::generateCuts
+       routine (If >0 then overrides when and is called if depth%depthCutGenerator==0).
+       In sub tree.
+    */
+  int depthCutGeneratorInSub_;
+
+  /// Level of cut inaccuracy (0 means exact e.g. cliques)
+  int inaccuracy_;
+  /// Number times cut generator entered
+  int numberTimes_;
+  /// Total number of cuts added
+  int numberCuts_;
+  /// Total number of elements added
+  int numberElements_;
+  /// Total number of column cuts added
+  int numberColumnCuts_;
+  /// Total number of cuts active after (at end of n cut passes at each node)
+  int numberCutsActive_;
+  /// Number of cuts generated at root
+  int numberCutsAtRoot_;
+  /// Number of cuts active at root
+  int numberActiveCutsAtRoot_;
+  /// Number of short cuts at root
+  int numberShortCutsAtRoot_;
+  /// Switches - see gets and sets
+  int switches_;
+  /// Maximum number of times to enter
+  int maximumTries_;
+};
+
+// How often to do if mostly switched off (A)
+#define SCANCUTS 1000
+// How often to do if mostly switched off (probing B)
+#define SCANCUTS_PROBING 1000
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCutModifier.hpp

@@ -0,0 +1,59 @@
+// $Id$
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+//Edwin 11/25/09 carved out of CbcCutGenerator
+
+#ifndef CbcCutModifier_H
+#define CbcCutModifier_H
+
+#include "OsiSolverInterface.hpp"
+#include "OsiCuts.hpp"
+#include "CglCutGenerator.hpp"
+
+class CbcModel;
+class OsiRowCut;
+class OsiRowCutDebugger;
+/** Abstract cut modifier base class
+
+    In exotic circumstances - cuts may need to be modified
+    a) strengthened - changed
+    b) weakened - changed
+    c) deleted - set to NULL
+    d) unchanged
+*/
+
+class CbcCutModifier {
+public:
+  /// Default Constructor
+  CbcCutModifier();
+
+  // Copy constructor
+  CbcCutModifier(const CbcCutModifier &);
+
+  /// Destructor
+  virtual ~CbcCutModifier();
+
+  /// Assignment
+  CbcCutModifier &operator=(const CbcCutModifier &rhs);
+  /// Clone
+  virtual CbcCutModifier *clone() const = 0;
+
+  /** Returns
+        0 unchanged
+        1 strengthened
+        2 weakened
+        3 deleted
+    */
+  virtual int modify(const OsiSolverInterface *solver, OsiRowCut &cut) = 0;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *) {}
+
+protected:
+};
+
+#endif //CbcCutModifier_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcCutSubsetModifier.hpp

@@ -0,0 +1,69 @@
+// $Id$
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+//Edwin 11/25/09 carved out of CbcCutGenerator
+
+#ifndef CbcCutSubsetModifier_H
+#define CbcCutSubsetModifier_H
+
+#include "OsiSolverInterface.hpp"
+#include "OsiCuts.hpp"
+#include "CglCutGenerator.hpp"
+#include "CbcCutModifier.hpp"
+
+class CbcModel;
+class OsiRowCut;
+class OsiRowCutDebugger;
+/** Simple cut modifier base class
+
+    In exotic circumstances - cuts may need to be modified
+    a) strengthened - changed
+    b) weakened - changed
+    c) deleted - set to NULL
+    d) unchanged
+
+    initially get rid of cuts with variables >= k
+    could weaken
+*/
+
+class CbcCutSubsetModifier : public CbcCutModifier {
+public:
+  /// Default Constructor
+  CbcCutSubsetModifier();
+
+  /// Useful Constructor
+  CbcCutSubsetModifier(int firstOdd);
+
+  // Copy constructor
+  CbcCutSubsetModifier(const CbcCutSubsetModifier &);
+
+  /// Destructor
+  virtual ~CbcCutSubsetModifier();
+
+  /// Assignment
+  CbcCutSubsetModifier &operator=(const CbcCutSubsetModifier &rhs);
+  /// Clone
+  virtual CbcCutModifier *clone() const;
+
+  /** Returns
+        0 unchanged
+        1 strengthened
+        2 weakened
+        3 deleted
+    */
+  virtual int modify(const OsiSolverInterface *solver, OsiRowCut &cut);
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *) {}
+
+protected:
+  /// data
+  /// First odd variable
+  int firstOdd_;
+};
+
+#endif //CbcCutSubsetModifier_H
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/