casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CbcHeuristicGreedy.hpp

@@ -0,0 +1,289 @@
+/* $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 CbcHeuristicGreedy_H
+#define CbcHeuristicGreedy_H
+
+#include "CbcHeuristic.hpp"
+/** Greedy heuristic classes
+ */
+
+class CbcHeuristicGreedyCover : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicGreedyCover();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicGreedyCover(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicGreedyCover(const CbcHeuristicGreedyCover &);
+
+  // Destructor
+  ~CbcHeuristicGreedyCover();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+  /// Assignment operator
+  CbcHeuristicGreedyCover &operator=(const CbcHeuristicGreedyCover &rhs);
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        We leave all variables which are at one at this node of the
+        tree to that value and will
+        initially set all others to zero.  We then sort all variables in order of their cost
+        divided by the number of entries in rows which are not yet covered.  We randomize that
+        value a bit so that ties will be broken in different ways on different runs of the heuristic.
+        We then choose the best one and set it to one and repeat the exercise.
+
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
+  virtual void validate();
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+  /* Algorithm
+       0 - use current upper bounds
+       1 - use original upper bounds
+       If 10 added perturb ratios more
+       if 100 added round up all >=0.5
+    */
+  inline int algorithm() const
+  {
+    return algorithm_;
+  }
+  inline void setAlgorithm(int value)
+  {
+    algorithm_ = value;
+  }
+  // Only do this many times
+  inline int numberTimes() const
+  {
+    return numberTimes_;
+  }
+  inline void setNumberTimes(int value)
+  {
+    numberTimes_ = value;
+  }
+
+protected:
+  /// Guts of constructor from a CbcModel
+  void gutsOfConstructor(CbcModel *model);
+  // Data
+
+  // Original matrix by column
+  CoinPackedMatrix matrix_;
+  // original number of rows
+  int originalNumberRows_;
+  /* Algorithm
+       0 - use current upper bounds
+       1 - use original upper bounds
+       If 10 added perturb ratios more
+    */
+  int algorithm_;
+  /// Do this many times
+  int numberTimes_;
+};
+
+class CbcHeuristicGreedyEquality : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicGreedyEquality();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicGreedyEquality(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicGreedyEquality(const CbcHeuristicGreedyEquality &);
+
+  // Destructor
+  ~CbcHeuristicGreedyEquality();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+  /// Assignment operator
+  CbcHeuristicGreedyEquality &operator=(const CbcHeuristicGreedyEquality &rhs);
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        We leave all variables which are at one at this node of the
+        tree to that value and will
+        initially set all others to zero.  We then sort all variables in order of their cost
+        divided by the number of entries in rows which are not yet covered.  We randomize that
+        value a bit so that ties will be broken in different ways on different runs of the heuristic.
+        We then choose the best one and set it to one and repeat the exercise.
+
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
+  virtual void validate();
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+  /* Algorithm
+       0 - use current upper bounds
+       1 - use original upper bounds
+       If 10 added perturb ratios more
+       if 100 added round up all >=0.5
+    */
+  inline int algorithm() const
+  {
+    return algorithm_;
+  }
+  inline void setAlgorithm(int value)
+  {
+    algorithm_ = value;
+  }
+  // Fraction of rhs to cover before branch and cut
+  inline void setFraction(double value)
+  {
+    fraction_ = value;
+  }
+  inline double fraction() const
+  {
+    return fraction_;
+  }
+  // Only do this many times
+  inline int numberTimes() const
+  {
+    return numberTimes_;
+  }
+  inline void setNumberTimes(int value)
+  {
+    numberTimes_ = value;
+  }
+
+protected:
+  /// Guts of constructor from a CbcModel
+  void gutsOfConstructor(CbcModel *model);
+  // Data
+
+  // Original matrix by column
+  CoinPackedMatrix matrix_;
+  // Fraction of rhs to cover before branch and cut
+  double fraction_;
+  // original number of rows
+  int originalNumberRows_;
+  /* Algorithm
+       0 - use current upper bounds
+       1 - use original upper bounds
+       If 10 added perturb ratios more
+    */
+  int algorithm_;
+  /// Do this many times
+  int numberTimes_;
+};
+
+/** Greedy heuristic for SOS and L rows (and positive elements)
+ */
+
+class CbcHeuristicGreedySOS : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicGreedySOS();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicGreedySOS(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicGreedySOS(const CbcHeuristicGreedySOS &);
+
+  // Destructor
+  ~CbcHeuristicGreedySOS();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+  /// Assignment operator
+  CbcHeuristicGreedySOS &operator=(const CbcHeuristicGreedySOS &rhs);
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        We leave all variables which are at one at this node of the
+        tree to that value and will
+        initially set all others to zero.  We then sort all variables in order of their cost
+        divided by the number of entries in rows which are not yet covered.  We randomize that
+        value a bit so that ties will be broken in different ways on different runs of the heuristic.
+        We then choose the best one and set it to one and repeat the exercise.
+
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
+  virtual void validate();
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+  /* Algorithm
+       Bits
+       1 bit - use current model, otherwise original
+       2 - use current solution as starting point, otherwise pure greedy
+       4 - as 2 but use merit not merit/size
+       8 - use duals to modify greedy
+       16 - use duals on GUB/SOS in special way
+    */
+  inline int algorithm() const
+  {
+    return algorithm_;
+  }
+  inline void setAlgorithm(int value)
+  {
+    algorithm_ = value;
+  }
+  // Only do this many times
+  inline int numberTimes() const
+  {
+    return numberTimes_;
+  }
+  inline void setNumberTimes(int value)
+  {
+    numberTimes_ = value;
+  }
+
+protected:
+  /// Guts of constructor from a CbcModel
+  void gutsOfConstructor(CbcModel *model);
+  // Data
+
+  // Original RHS - if -1.0 then SOS otherwise <= value
+  double *originalRhs_;
+  // Original matrix by column
+  CoinPackedMatrix matrix_;
+  // original number of rows
+  int originalNumberRows_;
+  /* Algorithm
+    */
+  int algorithm_;
+  /// Do this many times
+  int numberTimes_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcHeuristicLocal.hpp

@@ -0,0 +1,276 @@
+/* $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).
+
+#ifndef CbcHeuristicLocal_H
+#define CbcHeuristicLocal_H
+
+#include "CbcHeuristic.hpp"
+/** LocalSearch class
+ */
+
+class CbcHeuristicLocal : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicLocal();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicLocal(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicLocal(const CbcHeuristicLocal &);
+
+  // Destructor
+  ~CbcHeuristicLocal();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicLocal &operator=(const CbcHeuristicLocal &rhs);
+
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        This is called after cuts have been added - so can not add cuts
+        First tries setting a variable to better value.  If feasible then
+        tries setting others.  If not feasible then tries swaps
+
+        ********
+
+        This first version does not do LP's and does swaps of two integer
+        variables.  Later versions could do Lps.
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+  /// This version fixes stuff and does IP
+  int solutionFix(double &objectiveValue,
+    double *newSolution,
+    const int *keep);
+
+  /// Sets type of search
+  inline void setSearchType(int value)
+  {
+    swap_ = value;
+  }
+  /// Used array so we can set
+  inline int *used() const
+  {
+    return used_;
+  }
+
+protected:
+  // Data
+
+  // Original matrix by column
+  CoinPackedMatrix matrix_;
+
+  // Number of solutions so we only do after new solution
+  int numberSolutions_;
+  // Type of search 0=normal, 1=BAB
+  int swap_;
+  /// Whether a variable has been in a solution (also when)
+  int *used_;
+};
+
+/** Proximity Search class
+ */
+class CbcHeuristicFPump;
+class CbcHeuristicProximity : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicProximity();
+
+  /* Constructor with model - assumed before cuts
+    */
+  CbcHeuristicProximity(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicProximity(const CbcHeuristicProximity &);
+
+  // Destructor
+  ~CbcHeuristicProximity();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicProximity &operator=(const CbcHeuristicProximity &rhs);
+
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+  /// Set extra increment
+  inline void setIncrement(double value)
+  {
+    increment_ = value;
+  }
+  /// Used array so we can set
+  inline int *used() const
+  {
+    return used_;
+  }
+
+protected:
+  // Data
+  /// Increment to use if no change
+  double increment_;
+  /// Copy of Feasibility pump
+  CbcHeuristicFPump *feasibilityPump_;
+  /// Number of solutions so we only do after new solution
+  int numberSolutions_;
+  /// Whether a variable has been in a solution (also when)
+  int *used_;
+};
+
+/** Naive class
+    a) Fix all ints as close to zero as possible
+    b) Fix all ints with nonzero costs and < large to zero
+    c) Put bounds round continuous and UIs and maximize
+ */
+
+class CbcHeuristicNaive : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicNaive();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicNaive(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicNaive(const CbcHeuristicNaive &);
+
+  // Destructor
+  ~CbcHeuristicNaive();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicNaive &operator=(const CbcHeuristicNaive &rhs);
+
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+
+  /// Sets large cost value
+  inline void setLargeValue(double value)
+  {
+    large_ = value;
+  }
+  /// Gets large cost value
+  inline double largeValue() const
+  {
+    return large_;
+  }
+
+protected:
+  /// Data
+  /// Large value
+  double large_;
+};
+
+/** Crossover Search class
+ */
+
+class CbcHeuristicCrossover : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicCrossover();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicCrossover(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicCrossover(const CbcHeuristicCrossover &);
+
+  // Destructor
+  ~CbcHeuristicCrossover();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicCrossover &operator=(const CbcHeuristicCrossover &rhs);
+
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Fix variables if agree in useNumber_ solutions
+        when_ 0 off, 1 only at new solutions, 2 also every now and then
+        add 10 to make only if agree at lower bound
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+
+  /// Sets number of solutions to use
+  inline void setNumberSolutions(int value)
+  {
+    if (value > 0 && value <= 10)
+      useNumber_ = value;
+  }
+
+protected:
+  // Data
+  /// Attempts
+  std::vector< double > attempts_;
+  /// Random numbers to stop same search happening
+  double random_[10];
+  /// Number of solutions so we only do after new solution
+  int numberSolutions_;
+  /// Number of solutions to use
+  int useNumber_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcHeuristicPivotAndFix.hpp

@@ -0,0 +1,58 @@
+/* $Id$ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcHeuristicPivotAndFix_H
+#define CbcHeuristicPivotAndFix_H
+
+#include "CbcHeuristic.hpp"
+/** LocalSearch class
+ */
+
+class CbcHeuristicPivotAndFix : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicPivotAndFix();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicPivotAndFix(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicPivotAndFix(const CbcHeuristicPivotAndFix &);
+
+  // Destructor
+  ~CbcHeuristicPivotAndFix();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicPivotAndFix &operator=(const CbcHeuristicPivotAndFix &rhs);
+
+  /// Create C++ lines to get to current state
+  virtual void generateCpp(FILE *fp);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        needs comments
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+
+protected:
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CbcHeuristicRENS.hpp

@@ -0,0 +1,79 @@
+// $Id$
+// 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).
+
+// edwin 12/5/09 carved out of CbcHeuristicRINS
+
+#ifndef CbcHeuristicRENS_H
+#define CbcHeuristicRENS_H
+
+#include "CbcHeuristic.hpp"
+
+/** LocalSearch class
+ */
+
+class CbcHeuristicRENS : public CbcHeuristic {
+public:
+  // Default Constructor
+  CbcHeuristicRENS();
+
+  /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+  CbcHeuristicRENS(CbcModel &model);
+
+  // Copy constructor
+  CbcHeuristicRENS(const CbcHeuristicRENS &);
+
+  // Destructor
+  ~CbcHeuristicRENS();
+
+  /// Clone
+  virtual CbcHeuristic *clone() const;
+
+  /// Assignment operator
+  CbcHeuristicRENS &operator=(const CbcHeuristicRENS &rhs);
+
+  /// Resets stuff if model changes
+  virtual void resetModel(CbcModel *model);
+
+  /// update model (This is needed if cliques update matrix etc)
+  virtual void setModel(CbcModel *model);
+
+  using CbcHeuristic::solution;
+  /** returns 0 if no solution, 1 if valid solution.
+        Sets solution values if good, sets objective value (only if good)
+        This does Relaxation Extension Neighborhood Search
+        Does not run if when_<2 and a solution exists
+    */
+  virtual int solution(double &objectiveValue,
+    double *newSolution);
+
+  /// Set type
+  inline void setRensType(int value)
+  {
+    rensType_ = value;
+  }
+
+protected:
+  // Data
+  /// Number of tries
+  int numberTries_;
+  /** Type
+        0 - fix at LB
+        1 - fix on dj
+        2 - fix at UB as well
+	3 - fix on 0.01*average dj
+	add 16 to allow two tries
+	32 - if solution exists use to keep more variables
+	64 - if priorities keep high priority
+	128 - if priorities keep low priority
+    */
+  int rensType_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/