casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CglGomory.hpp

@@ -0,0 +1,204 @@
+// 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 CglGomory_H
+#define CglGomory_H
+
+#include <string>
+
+#include "CglCutGenerator.hpp"
+
+class CoinWarmStartBasis;
+/** Gomory Cut Generator Class */
+class CglGomory : public CglCutGenerator {
+   friend void CglGomoryUnitTest(const OsiSolverInterface * siP,
+				  const std::string mpdDir );
+ 
+public:
+    
+  
+  /**@name Generate Cuts */
+  //@{
+  /** Generate Mixed Integer Gomory cuts for the model of the 
+      solver interface, si.
+
+      Insert the generated cuts into OsiCut, cs.
+
+      There is a limit option, which will only generate cuts with
+      less than this number of entries.
+
+      We can also only look at 0-1 variables a certain distance
+      from integer.
+  */
+  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+			     const CglTreeInfo info = CglTreeInfo());
+  /** Generates cuts given matrix and solution etc,
+      returns number of cuts generated */
+  int generateCuts( const OsiRowCutDebugger * debugger, 
+		    OsiCuts & cs,
+		    const CoinPackedMatrix & columnCopy,
+		    const CoinPackedMatrix & rowCopy,
+		    const double * colsol,
+		    const double * colLower, const double * colUpper,
+		    const double * rowLower, const double * rowUpper,
+		    const char * intVar ,
+		    const CoinWarmStartBasis* warm,
+                    const CglTreeInfo info = CglTreeInfo());
+  /** Generates cuts given matrix and solution etc,
+      returns number of cuts generated (no row copy passed in) */
+  int generateCuts( const OsiRowCutDebugger * debugger, 
+		    OsiCuts & cs,
+		    const CoinPackedMatrix & columnCopy,
+		    const double * colsol,
+		    const double * colLower, const double * colUpper,
+		    const double * rowLower, const double * rowUpper,
+		    const char * intVar ,
+		    const CoinWarmStartBasis* warm,
+                    const CglTreeInfo info = CglTreeInfo());
+
+  /// Return true if needs optimal basis to do cuts (will return true)
+  virtual bool needsOptimalBasis() const { return true; }
+  //@}
+
+  /**@name Change way Gomory works */
+  //@{
+  /// Pass in a copy of original solver (clone it)
+  void passInOriginalSolver(OsiSolverInterface * solver);
+  /// Returns original solver
+  inline OsiSolverInterface * originalSolver() const
+  { return originalSolver_;}
+  /// Set type - 0 normal, 1 add original matrix one, 2 replace
+  inline void setGomoryType(int type)
+  { gomoryType_=type;}
+  /// Return type
+  inline int gomoryType() const
+  { return gomoryType_;}
+  //@}
+
+  /**@name Change limit on how many variables in cut (default 50) */
+  //@{
+  /// Set
+  void setLimit(int limit);
+  /// Get
+  int getLimit() const;
+  /// Set at root (if <normal then use normal)
+  void setLimitAtRoot(int limit);
+  /// Get at root
+  int getLimitAtRoot() const;
+  /// Return maximum length of cut in tree
+  virtual int maximumLengthOfCutInTree() const;
+  //@}
+
+  /**@name Change criterion on which variables to look at.  All ones
+   more than "away" away from integrality will be investigated 
+  (default 0.05) */
+  //@{
+  /// Set away
+  void setAway(double value);
+  /// Get away
+  double getAway() const;
+  /// Set away at root
+  void setAwayAtRoot(double value);
+  /// Get away at root
+  double getAwayAtRoot() const;
+  //@}
+
+  /**@name Change criterion on which the cut id relaxed if the code
+           thinks the factorization has inaccuracies.  The relaxation to
+	   RHS is smallest of -
+	   1) 1.0e-4
+	   2) conditionNumberMultiplier * condition number of factorization
+	   3) largestFactorMultiplier * largest (dual*element) forming tableau
+	      row
+  */
+  //@{
+  /// Set ConditionNumberMultiplier
+  void setConditionNumberMultiplier(double value);
+  /// Get ConditionNumberMultiplier
+  double getConditionNumberMultiplier() const;
+  /// Set LargestFactorMultiplier
+  void setLargestFactorMultiplier(double value);
+  /// Get LargestFactorMultiplier
+  double getLargestFactorMultiplier() const;
+  //@}
+
+  /**@name change factorization */
+  //@{
+   /// Set/unset alternative factorization
+   inline void useAlternativeFactorization(bool yes=true)
+   { alternateFactorization_= (yes) ? 1 : 0;} 
+   /// Get whether alternative factorization being used
+   inline bool alternativeFactorization() const
+   { return (alternateFactorization_!=0);} 
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglGomory ();
+ 
+  /// Copy constructor 
+  CglGomory (
+    const CglGomory &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglGomory &
+    operator=(
+    const CglGomory& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglGomory ();
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+  /// This can be used to refresh any inforamtion
+  virtual void refreshSolver(OsiSolverInterface * solver);
+  //@}
+      
+private:
+  
+ // Private member methods
+
+  // Private member data
+
+  /**@name Private member data */
+  //@{
+  /// Only investigate if more than this away from integrality
+  double away_;
+  /// Only investigate if more than this away from integrality (at root)
+  double awayAtRoot_;
+  /// Multiplier for conditionNumber cut relaxation
+  double conditionNumberMultiplier_;
+  /// Multiplier for largest factor cut relaxation
+  double largestFactorMultiplier_;
+  /// Original solver
+  OsiSolverInterface * originalSolver_;
+  /// Limit - only generate if fewer than this in cut
+  int limit_;
+  /// Limit - only generate if fewer than this in cut (at root)
+  int limitAtRoot_;
+  /// Dynamic limit in tree
+  int dynamicLimitInTree_;
+  /// Number of times stalled
+  int numberTimesStalled_;
+  /// nonzero to use alternative factorization
+  int alternateFactorization_;
+  /// Type - 0 normal, 1 add original matrix one, 2 replace
+  int gomoryType_; // note could add in cutoff as constraint
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglGomory class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglGomoryUnitTest(const OsiSolverInterface * siP,
+			const std::string mpdDir );
+  
+#endif

casadi/include/coin/CglKnapsackCover.hpp

@@ -0,0 +1,310 @@
+// $Id$
+// Copyright (C) 2000, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglKnapsackCover_H
+#define CglKnapsackCover_H
+
+#include <string>
+
+#include "CglCutGenerator.hpp"
+#include "CglTreeInfo.hpp"
+
+/** Knapsack Cover Cut Generator Class */
+class CglKnapsackCover : public CglCutGenerator {
+   friend void CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
+					const std::string mpdDir );
+
+public:
+   /** A method to set which rows should be tested for knapsack covers */
+   void setTestedRowIndices(int num, const int* ind);
+
+   /**@name Generate Cuts */
+  //@{
+  /** Generate knapsack cover cuts for the model of the solver interface, si. 
+      Insert the generated cuts into OsiCut, cs.
+  */
+  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+			    const CglTreeInfo info = CglTreeInfo());
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglKnapsackCover ();
+ 
+  /// Copy constructor 
+  CglKnapsackCover (
+    const CglKnapsackCover &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglKnapsackCover &
+    operator=(
+    const CglKnapsackCover& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglKnapsackCover ();
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+  /// This can be used to refresh any information
+  virtual void refreshSolver(OsiSolverInterface * solver);
+  //@}
+
+
+  /**@name Sets and gets */
+  //@{
+  /// Set limit on number in knapsack
+  inline void setMaxInKnapsack(int value)
+           { if (value>0) maxInKnapsack_ = value;}
+  /// get limit on number in knapsack
+  inline int getMaxInKnapsack() const
+           {return maxInKnapsack_;}
+  /// Switch off expensive cuts
+  inline void switchOffExpensive()
+  { expensiveCuts_=false;}
+  /// Switch on expensive cuts
+  inline void switchOnExpensive()
+  { expensiveCuts_=true;}
+private:
+  
+ // Private member methods
+
+
+  /**@name Private methods */
+  //@{
+
+  /** deriveAKnapsack 
+                 returns 1 if it is able to derive
+                 a (canonical) knapsack inequality
+                in binary variables of the form ax<=b 
+                 from the rowIndex-th  row in the model, 
+                returns 0 otherwise.
+  */
+  int deriveAKnapsack(
+    const OsiSolverInterface & si, 
+    OsiCuts & cs,
+    CoinPackedVector & krow,
+    bool treatAsLRow,
+    double & b,
+    int *  complement,
+    double *  xstar,
+    int rowIndex,
+    int numberElements,
+    const int * index,
+    const double * element);
+
+  int deriveAKnapsack(
+    const OsiSolverInterface & si, 
+    OsiCuts & cs,
+    CoinPackedVector & krow,
+    double & b,
+    int *  complement,
+    double *  xstar,
+    int rowIndex,
+    const CoinPackedVectorBase & matrixRow);
+
+  /** Find a violated minimal cover from 
+ a canonical form knapsack inequality by
+ solving the -most- violated cover problem
+ and postprocess to ensure minimality
+  */
+  int findExactMostViolatedMinCover(
+      int nCols, 
+      int row,
+      CoinPackedVector & krow,
+      double b, 
+      double *  xstar, 
+      CoinPackedVector & cover,
+      CoinPackedVector & remainder);
+
+  /** Find the most violate minimum cover by solving the lp-relaxation of the
+      most-violate-min-cover problem 
+  */
+  int findLPMostViolatedMinCover(
+      int nCols,
+      int row,
+      CoinPackedVector & krow,
+      double & b,
+      double * xstar, 
+      CoinPackedVector & cover,
+      CoinPackedVector & remainder);
+  
+/// find a minimum cover by a simple greedy approach
+  int findGreedyCover(
+      int row,
+      CoinPackedVector & krow,
+      double & b,
+      double * xstar,
+      CoinPackedVector & cover,
+      CoinPackedVector & remainder
+      );
+
+  /// lift the cover inequality
+  int liftCoverCut(
+     double & b,
+     int nRowElem,
+     CoinPackedVector & cover,
+     CoinPackedVector & remainder,
+     CoinPackedVector & cut );
+ 
+  /// sequence-independent lift and uncomplement and add the resulting cut to the cut set
+  int liftAndUncomplementAndAdd(
+     double rowub,
+     CoinPackedVector & krow,
+     double & b,
+     int * complement,
+     int row,
+     CoinPackedVector & cover,
+     CoinPackedVector & remainder,
+     OsiCuts & cs );
+
+  /// sequence-dependent lift, uncomplement and add the resulting cut to the cut set
+void seqLiftAndUncomplementAndAdd(
+      int nCols,
+      double * xstar, 
+      int * complement,
+      int row,
+      int nRowElem,
+      double & b,
+      CoinPackedVector & cover,      // need not be violated
+      CoinPackedVector & remainder,
+      OsiCuts & cs );
+
+  /// sequence-dependent lift binary variables either up or down, uncomplement and add to the cut set
+void liftUpDownAndUncomplementAndAdd(
+         int nCols,
+         double * xstar, 
+         int * complement,
+         int row,
+         int nRowElem,
+         double & b,
+
+         // the following 3 packed vectors partition the krow:
+         CoinPackedVector & fracCover, // vars have frac soln values in lp relaxation
+                                       // and form cover with the vars atOne
+         CoinPackedVector & atOne,     // vars have soln value of 1 in lp relaxation
+                                       // and together with fracCover form minimal (?) cover. 
+         CoinPackedVector & remainder,
+         OsiCuts & cs );
+
+  /// find a cover using a variation of the logic found in OSL (w/o SOS)
+  int findPseudoJohnAndEllisCover (
+     int row,
+     CoinPackedVector & krow,
+     double & b,
+     double * xstar,                     
+     CoinPackedVector & cover,  
+     CoinPackedVector & remainder);
+
+  /// find a cover using the basic logic found in OSL (w/o SOS)
+  int findJohnAndEllisCover (
+     int row,
+     CoinPackedVector & krow,
+     double & b,
+     double * xstar,                     
+     CoinPackedVector & fracCover,  
+     CoinPackedVector & atOnes,  
+     CoinPackedVector & remainder);
+
+
+  /** A C-style implementation of the Horowitz-Sahni exact solution 
+   procedure for solving knapsack problem. 
+   
+   (ToDo: implement the more efficient dynamic programming approach)
+
+   (Reference: Martello and Toth, Knapsack Problems, Wiley, 1990, p30.)
+  */
+  int exactSolveKnapsack(
+      int n, 
+      double c, 
+      double const *pp, 
+      double const *ww,
+      double & z, 
+      int * x);
+  /// For testing gub stuff
+  int gubifyCut(CoinPackedVector & cut);
+public:
+  /** Creates cliques for use by probing.
+      Only cliques >= minimumSize and < maximumSize created
+      Can also try and extend cliques as a result of probing (root node).
+      Returns number of cliques found.
+  */
+  int createCliques( OsiSolverInterface & si, 
+		    int minimumSize=2, int maximumSize=100, bool extendCliques=false);
+private:
+  /// Delete all clique information
+  void deleteCliques();
+  //@}
+
+  // Private member data
+
+  /**@name Private member data */
+  //@{
+  /// epsilon
+  double epsilon_;  
+  /// Tolerance to use for violation - bigger than epsilon_
+  double epsilon2_;
+  /// 1-epsilon
+  double onetol_;  
+  /// Maximum in knapsack
+  int maxInKnapsack_;
+  /** which rows to look at. If specified, only these rows will be considered
+      for generating knapsack covers. Otherwise all rows will be tried */
+  int numRowsToCheck_;
+  int* rowsToCheck_;
+  /// exactKnapsack can be expensive - this switches off some
+  bool expensiveCuts_;
+  /// Cliques
+  /// **** TEMP so can reference from listing
+  const OsiSolverInterface * solver_;
+  int whichRow_;
+  int * complement_;
+  double * elements_;
+  /// Number of cliques
+  int numberCliques_;
+  /// Clique type
+  typedef struct {
+    unsigned int equality:1; //  nonzero if clique is ==
+  } CliqueType;
+  CliqueType * cliqueType_;
+  /// Start of each clique
+  int * cliqueStart_;
+  /// Entries for clique
+  CliqueEntry * cliqueEntry_;
+  /** Start of oneFixes cliques for a column in matrix or -1 if not
+      in any clique */
+  int * oneFixStart_;
+  /** Start of zeroFixes cliques for a column in matrix or -1 if not
+      in any clique */
+  int * zeroFixStart_;
+  /// End of fixes for a column
+  int * endFixStart_;
+  /// Clique numbers for one or zero fixes
+  int * whichClique_;
+  /// Number of columns
+  int numberColumns_;
+  /** For each column with nonzero in row copy this gives a clique "number".
+      So first clique mentioned in row is always 0.  If no entries for row
+      then no cliques.  If sequence > numberColumns then not in clique.
+  */
+  //CliqueEntry * cliqueRow_;
+  /// cliqueRow_ starts for each row
+  //int * cliqueRowStart_;
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglKnapsackCover class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
+			      const std::string mpdDir );
+  
+#endif