casadi 3.6.3__cp35-none-manylinux2010_x86_64.whl → 3.6.5__cp35-none-manylinux2010_x86_64.whl

casadi/include/coin/CbcStrategy.hpp

@@ -0,0 +1,269 @@
+/* $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 CbcStrategy_H
+#define CbcStrategy_H
+
+#include "CbcModel.hpp"
+class CglPreProcess;
+class CbcNodeInfo;
+class CbcNode;
+class CoinWarmStartDiff;
+
+//#############################################################################
+/** Strategy base class */
+
+class CbcStrategy {
+public:
+  // Default Constructor
+  CbcStrategy();
+
+  virtual ~CbcStrategy();
+
+  /// Clone
+  virtual CbcStrategy *clone() const = 0;
+
+  /// Setup cut generators
+  virtual void setupCutGenerators(CbcModel &model) = 0;
+  /// Setup heuristics
+  virtual void setupHeuristics(CbcModel &model) = 0;
+  /// Do printing stuff
+  virtual void setupPrinting(CbcModel &model, int modelLogLevel) = 0;
+  /// Other stuff e.g. strong branching and preprocessing
+  virtual void setupOther(CbcModel &model) = 0;
+  /// Set model depth (i.e. how nested)
+  inline void setNested(int depth)
+  {
+    depth_ = depth;
+  }
+  /// Get model depth (i.e. how nested)
+  inline int getNested() const
+  {
+    return depth_;
+  }
+  /// Say preProcessing done
+  inline void setPreProcessState(int state)
+  {
+    preProcessState_ = state;
+  }
+  /// See what sort of preprocessing was done
+  inline int preProcessState() const
+  {
+    return preProcessState_;
+  }
+  /// Pre-processing object
+  inline CglPreProcess *process() const
+  {
+    return process_;
+  }
+  /// Delete pre-processing object to save memory
+  void deletePreProcess();
+  /// 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;
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *) {}
+  /** 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);
+
+private:
+  /// Illegal Assignment operator
+  CbcStrategy &operator=(const CbcStrategy &rhs);
+
+protected:
+  // Data
+  /// Model depth
+  int depth_;
+  /** PreProcessing state -
+        -1 infeasible
+        0 off
+        1 was done (so need post-processing)
+    */
+  int preProcessState_;
+  /// If preprocessing then this is object
+  CglPreProcess *process_;
+};
+
+/** Null class
+ */
+
+class CbcStrategyNull : public CbcStrategy {
+public:
+  // Default Constructor
+  CbcStrategyNull() {}
+
+  // Copy constructor
+  CbcStrategyNull(const CbcStrategyNull &rhs)
+    : CbcStrategy(rhs)
+  {
+  }
+
+  // Destructor
+  ~CbcStrategyNull() {}
+
+  /// Clone
+  virtual CbcStrategy *clone() const
+  {
+    return new CbcStrategyNull(*this);
+  }
+
+  /// Setup cut generators
+  virtual void setupCutGenerators(CbcModel &) {}
+  /// Setup heuristics
+  virtual void setupHeuristics(CbcModel &) {}
+  /// Do printing stuff
+  virtual void setupPrinting(CbcModel &, int) {}
+  /// Other stuff e.g. strong branching
+  virtual void setupOther(CbcModel &) {}
+
+protected:
+  // Data
+private:
+  /// Illegal Assignment operator
+  CbcStrategyNull &operator=(const CbcStrategyNull &rhs);
+};
+
+/** Default class
+ */
+
+class CbcStrategyDefault : public CbcStrategy {
+public:
+  // Default Constructor
+  CbcStrategyDefault(int cutsOnlyAtRoot = 1,
+    int numberStrong = 5,
+    int numberBeforeTrust = 0,
+    int printLevel = 0);
+
+  // Copy constructor
+  CbcStrategyDefault(const CbcStrategyDefault &);
+
+  // Destructor
+  ~CbcStrategyDefault();
+
+  /// Clone
+  virtual CbcStrategy *clone() const;
+
+  /// 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
+  virtual void setupOther(CbcModel &model);
+  /// Set up preProcessing - see below
+  inline void setupPreProcessing(int desired = 1, int passes = 10)
+  {
+    desiredPreProcess_ = desired;
+    preProcessPasses_ = passes;
+  }
+  /// See what sort of preprocessing wanted
+  inline int desiredPreProcess() const
+  {
+    return desiredPreProcess_;
+  }
+  /// See how many passes wanted
+  inline int preProcessPasses() const
+  {
+    return preProcessPasses_;
+  }
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+protected:
+  // Data
+
+  // Whether to do cuts only at root (-1 -> switch off totally)
+  int cutsOnlyAtRoot_;
+
+  // How much strong branching to do
+  int numberStrong_;
+
+  // Number branches needed to trust with dynamic pseudo costs
+  int numberBeforeTrust_;
+
+  // Print level 0 little, 1 medium
+  int printLevel_;
+
+  /** Desired pre-processing
+        0 - none
+        1 - ordinary
+        2 - find sos
+        3 - find cliques
+        4 - more aggressive sos
+        5 - add integer slacks
+    */
+  int desiredPreProcess_;
+  /// Number of pre-processing passes
+  int preProcessPasses_;
+
+private:
+  /// Illegal Assignment operator
+  CbcStrategyDefault &operator=(const CbcStrategyDefault &rhs);
+};
+
+/** Default class for sub trees
+ */
+
+class CbcStrategyDefaultSubTree : public CbcStrategy {
+public:
+  // Default Constructor
+  CbcStrategyDefaultSubTree(CbcModel *parent = NULL, int cutsOnlyAtRoot = 1,
+    int numberStrong = 5,
+    int numberBeforeTrust = 0,
+    int printLevel = 0);
+
+  // Copy constructor
+  CbcStrategyDefaultSubTree(const CbcStrategyDefaultSubTree &);
+
+  // Destructor
+  ~CbcStrategyDefaultSubTree();
+
+  /// Clone
+  virtual CbcStrategy *clone() const;
+
+  /// 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
+  virtual void setupOther(CbcModel &model);
+
+protected:
+  // Data
+  // Parent model
+  CbcModel *parentModel_;
+  // Whether to do cuts only at root (-1 -> switch off totally)
+  int cutsOnlyAtRoot_;
+
+  // How much strong branching to do
+  int numberStrong_;
+
+  // Number branches needed to trust with dynamic pseudo costs
+  int numberBeforeTrust_;
+
+  // Print level 0 little, 1 medium
+  int printLevel_;
+
+private:
+  /// Illegal Assignment operator
+  CbcStrategyDefaultSubTree &operator=(const CbcStrategyDefaultSubTree &rhs);
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcSubProblem.hpp

@@ -0,0 +1,84 @@
+// $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 CbcSubProblem_H
+#define CbcSubProblem_H
+
+#ifdef COIN_HAS_CLP
+#include "ClpSimplex.hpp"
+#include "ClpNode.hpp"
+
+/** Defines a general subproblem
+    Basis will be made more compact later
+*/
+class CoinWarmStartDiff;
+class CbcSubProblem {
+
+public:
+  /// Default constructor
+  CbcSubProblem();
+
+  /// Constructor from model
+  CbcSubProblem(const OsiSolverInterface *solver,
+    const double *lowerBefore,
+    const double *upperBefore,
+    const unsigned char *status,
+    int depth);
+
+  /// Copy constructor
+  CbcSubProblem(const CbcSubProblem &);
+
+  /// Assignment operator
+  CbcSubProblem &operator=(const CbcSubProblem &rhs);
+
+  /// Destructor
+  virtual ~CbcSubProblem();
+
+  /// Take over
+  void takeOver(CbcSubProblem &, bool cleanup);
+  /// Apply subproblem (1=bounds, 2=basis, 3=both)
+  void apply(OsiSolverInterface *model, int what = 3) const;
+
+public:
+  /// Value of objective
+  double objectiveValue_;
+  /// Sum of infeasibilities
+  double sumInfeasibilities_;
+  /// Branch value
+  double branchValue_;
+  /// Dj on branching variable at end
+  double djValue_;
+  /** Which variable (top bit if upper bound changing)
+        next bit if changing on down branch only */
+  int *variables_;
+  /// New bound
+  double *newBounds_;
+  /// Status
+  mutable CoinWarmStartBasis *status_;
+  /// Depth
+  int depth_;
+  /// Number of Extra bound changes
+  int numberChangedBounds_;
+  /// Number of infeasibilities
+  int numberInfeasibilities_;
+  /** Status 1 bit going up on first, 2 bit set first branch infeasible on second, 4 bit redundant branch,
+	bits after 256 give reason for stopping (just last node)
+	0 - solution
+	1 - infeasible
+	2 - maximum depth
+	>2 - error or max time or something
+    */
+  int problemStatus_;
+  /// Variable branched on
+  int branchVariable_;
+};
+
+#endif //COIN_HAS_CLP
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/