casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CglMixedIntegerRounding2.hpp

@@ -0,0 +1,427 @@
+// LAST EDIT: 
+//-----------------------------------------------------------------------------
+// name: Mixed Integer Rounding Cut Generator
+// authors: Joao Goncalves (jog7@lehigh.edu) 
+//          Laszlo Ladanyi (ladanyi@us.ibm.com) 
+// date: August 11, 2004 
+//-----------------------------------------------------------------------------
+// Copyright (C) 2004, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglMixedIntegerRounding2_H
+#define CglMixedIntegerRounding2_H
+
+#include <iostream>
+#include <fstream>
+//#include <vector>
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+#include "CoinIndexedVector.hpp"
+
+//=============================================================================
+
+#ifndef CGL_DEBUG
+#define CGL_DEBUG 0
+#endif
+
+//=============================================================================
+
+// Class to store variable upper bounds (VUB)
+class CglMixIntRoundVUB2
+{
+  // Variable upper bounds have the form x_j <= a y_j, where x_j is
+  // a continuous variable and y_j is an integer variable
+
+protected:
+  int    var_;            // The index of y_j
+  double val_;            // The value of a 
+
+public:
+  // Default constructor
+  CglMixIntRoundVUB2() : var_(-1), val_(-1) {}
+
+  // Copy constructor
+  CglMixIntRoundVUB2(const CglMixIntRoundVUB2& source) { 
+    var_ = source.var_; 
+    val_ = source.val_; 
+  } 
+
+  // Assignment operator
+  CglMixIntRoundVUB2& operator=(const CglMixIntRoundVUB2& rhs) { 
+    if (this != &rhs) { 
+      var_ = rhs.var_; 
+      val_ = rhs.val_; 
+    }
+    return *this; 
+  }
+
+  // Destructor
+  ~CglMixIntRoundVUB2() {}
+
+  // Query and set functions
+  int    getVar() const          { return var_; }
+  double getVal() const          { return val_; }
+  void   setVar(const int v)     { var_ = v; }
+  void   setVal(const double v)  { val_ = v; }
+};
+
+//=============================================================================
+
+// Class to store variable lower bounds (VLB).
+// It is the same as the class to store variable upper bounds
+typedef CglMixIntRoundVUB2 CglMixIntRoundVLB2;
+
+//=============================================================================
+
+/** Mixed Integer Rounding Cut Generator Class */
+
+// Reference: 
+//    Hugues Marchand and Laurence A. Wolsey
+//    Aggregation and Mixed Integer Rounding to Solve MIPs
+//    Operations Research, 49(3), May-June 2001.
+//    Also published as CORE Dicusion Paper 9839, June 1998.
+
+class CglMixedIntegerRounding2 : public CglCutGenerator {
+
+  friend void CglMixedIntegerRounding2UnitTest(const OsiSolverInterface * siP,
+					       const std::string mpdDir);
+
+
+private:
+  //---------------------------------------------------------------------------
+  // Enumeration constants that describe the various types of rows
+  enum RowType {
+    // The row type of this row is NOT defined yet.
+    ROW_UNDEFINED,
+    /** After the row is flipped to 'L', the row has exactly two variables: 
+	one is negative binary and the other is a continous, 
+	and the RHS is zero.*/
+    ROW_VARUB,
+    /** After the row is flipped to 'L', the row has exactly two variables: 
+	one is positive binary and the other is a continous, 
+	and the RHS is zero.*/
+    ROW_VARLB,
+    /** The row sense is 'E', the row has exactly two variables: 
+	one is binary and the other is a continous, and the RHS is zero.*/ 
+    ROW_VAREQ,
+    // The row contains continuous and integer variables;
+    // the total number of variables is at least 2
+    ROW_MIX,
+    // The row contains only continuous variables
+    ROW_CONT,
+    // The row contains only integer variables
+    ROW_INT,
+    // The row contains other types of rows
+    ROW_OTHER
+  };
+
+
+public:
+
+  /**@name Generate Cuts */
+  //@{
+  /** Generate Mixed Integer Rounding cuts for the model data 
+      contained in si. The generated cuts are inserted 
+      in the collection of cuts cs. 
+  */
+  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+			    const CglTreeInfo info = CglTreeInfo());
+  //@}
+
+  //---------------------------------------------------------------------------
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglMixedIntegerRounding2 ();
+
+  /// Alternate Constructor 
+  CglMixedIntegerRounding2 (const int maxaggr,
+			    const bool multiply,
+			    const int criterion,
+			    const int preproc = -1);
+
+  /// Copy constructor 
+  CglMixedIntegerRounding2 (
+    const CglMixedIntegerRounding2 &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglMixedIntegerRounding2 &
+    operator=(
+    const CglMixedIntegerRounding2& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglMixedIntegerRounding2 ();
+  /// This can be used to refresh any inforamtion
+  virtual void refreshSolver(OsiSolverInterface * solver);
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+  //@}
+
+  //---------------------------------------------------------------------------
+  /**@name Set and get methods */
+  //@{
+  /// Set MAXAGGR_
+  inline void setMAXAGGR_ (int maxaggr) {
+    if (maxaggr > 0) {
+      MAXAGGR_ = maxaggr;
+    }
+    else {
+      throw CoinError("Unallowable value. maxaggr must be > 0",
+                      "gutsOfConstruct","CglMixedIntegerRounding2");
+    }
+  }
+
+  /// Get MAXAGGR_
+  inline int getMAXAGGR_ () const { return MAXAGGR_; }
+
+  /// Set MULTIPLY_
+  inline void setMULTIPLY_ (bool multiply) { MULTIPLY_ = multiply; }
+
+  /// Get MULTIPLY_
+  inline bool getMULTIPLY_ () const { return MULTIPLY_; }
+
+  /// Set CRITERION_
+  inline void setCRITERION_ (int criterion) {
+    if ((criterion >= 1) && (criterion <= 3)) {
+      CRITERION_ = criterion;
+    }
+    else {
+      throw CoinError("Unallowable value. criterion must be 1, 2 or 3",
+                      "gutsOfConstruct","CglMixedIntegerRounding2");
+    }
+  }
+
+  /// Get CRITERION_
+  inline int getCRITERION_ () const { return CRITERION_; }
+
+  /// Set doPreproc
+  void setDoPreproc(int value);
+  /// Get doPreproc
+  bool getDoPreproc() const;
+  //@}
+
+private:
+  //--------------------------------------------------------------------------
+  // Private member methods
+
+  // Construct
+  void gutsOfConstruct ( const int maxaggr,
+			 const bool multiply,
+			 const int criterion,
+			 const int preproc);
+
+  // Delete
+  void gutsOfDelete();
+
+  // Copy
+  void gutsOfCopy (const CglMixedIntegerRounding2& rhs);
+
+  // Do preprocessing.
+  // It determines the type of each row. It also identifies the variable
+  // upper bounds and variable lower bounds.
+  // It may change sense and RHS for ranged rows
+  void mixIntRoundPreprocess(const OsiSolverInterface& si);
+
+  // Determine the type of a given row.
+  RowType determineRowType(//const OsiSolverInterface& si,
+			   const int rowLen, const int* ind, 
+			   const double* coef, const char sense, 
+			   const double rhs) const;
+
+  // Generate MIR cuts
+  void generateMirCuts( const OsiSolverInterface& si,
+			const double* xlp,
+			const double* colUpperBound,
+			const double* colLowerBound,
+			const CoinPackedMatrix& matrixByRow,
+			const double* LHS,
+			//const double* coefByRow,
+			//const int* colInds,
+			//const int* rowStarts,
+			//const CoinPackedMatrix& matrixByCol,
+			const double* coefByCol,
+			const int* rowInds,
+			const CoinBigIndex* colStarts,
+			OsiCuts& cs ) const;
+
+  // Copy row selected to CoinIndexedVector
+  void copyRowSelected( const int iAggregate,
+			const int rowSelected,
+			CoinIndexedVector& setRowsAggregated,
+			int* listRowsAggregated,
+			double* xlpExtra,
+			const char sen,
+			const double rhs,
+			const double lhs,
+			const CoinPackedMatrix& matrixByRow,
+			CoinIndexedVector& rowToAggregate,
+			double& rhsToAggregate) const;
+
+  // Select a row to aggregate
+  bool selectRowToAggregate( //const OsiSolverInterface& si,
+			     const CoinIndexedVector& rowAggregated,
+			     const double* colUpperBound,
+			     const double* colLowerBound,
+			     const CoinIndexedVector& setRowsAggregated,
+			     const double* xlp, const double* coefByCol,
+			     const int* rowInds, const CoinBigIndex* colStarts,
+			     int& rowSelected,
+			     int& colSelected ) const;
+
+  // Aggregation heuristic. 
+  // Combines one or more rows of the original matrix 
+  void aggregateRow( const int colSelected,
+		     CoinIndexedVector& rowToAggregate, double rhs,
+		     CoinIndexedVector& rowAggregated, 
+		     double& rhsAggregated ) const;
+
+  // Choose the bound substitution based on the criteria defined by the user
+  inline bool isLowerSubst(const double inf, 
+			   const double aj,
+			   const double xlp, 
+			   const double LB, 
+			   const double UB) const;
+    
+  // Bound substitution heuristic
+  bool boundSubstitution( const OsiSolverInterface& si,
+			  const CoinIndexedVector& rowAggregated,
+			  const double* xlp,
+			  const double* xlpExtra,
+			  const double* colUpperBound,
+			  const double* colLowerBound,
+			  CoinIndexedVector& mixedKnapsack,
+			  double& rhsMixedKnapsack, double& sStar,
+			  CoinIndexedVector& contVariablesInS ) const;
+
+  // c-MIR separation heuristic
+  bool cMirSeparation ( const OsiSolverInterface& si,
+			const CoinPackedMatrix& matrixByRow,
+			const CoinIndexedVector& rowAggregated,
+			const int* listRowsAggregated,
+			const char* sense, const double* RHS,
+			//const double* coefByRow,
+			//const int* colInds, const int* rowStarts,
+			const double* xlp, const double sStar,
+			const double* colUpperBound,
+			const double* colLowerBound,
+			const CoinIndexedVector& mixedKnapsack,
+			const double& rhsMixedKnapsack,
+			const CoinIndexedVector& contVariablesInS,
+                        CoinIndexedVector * workVector,
+			OsiRowCut& flowCut ) const;
+
+  // function to create one c-MIR inequality
+  void cMirInequality( const int numInt, 
+		       const double delta,
+		       const double numeratorBeta,
+		       const int *knapsackIndices,
+		       const double* knapsackElements,
+		       const double* xlp, 
+		       const double sStar,	       
+		       const double* colUpperBound,
+		       const CoinIndexedVector& setC,
+		       CoinIndexedVector& cMIR,
+		       double& rhscMIR,
+		       double& sCoef,
+		       double& violation) const;
+
+  // function to compute G
+  inline double functionG( const double d, const double f ) const;
+
+  // function to print statistics (used only in debug mode)
+  void printStats(
+			    std::ofstream & fout,
+			    const bool hasCut,
+			    const OsiSolverInterface& si,
+			    const CoinIndexedVector& rowAggregated,
+			    const double& rhsAggregated, const double* xlp,
+			    const double* xlpExtra,
+			    const int* listRowsAggregated,
+			    const int* listColsSelected,
+			    const int level,
+			    const double* colUpperBound,
+			    const double* colLowerBound ) const;
+
+
+private:
+  //---------------------------------------------------------------------------
+  // Private member data
+  
+  // Maximum number of rows to aggregate
+  int MAXAGGR_;
+  // Flag that indicates if an aggregated row is also multiplied by -1
+  bool MULTIPLY_;
+  // The criterion to use in the bound substitution
+  int CRITERION_;
+  // Tolerance used for numerical purposes
+  double EPSILON_;
+  /// There is no variable upper bound or variable lower bound defined
+  int UNDEFINED_;
+  // If violation of a cut is greater that this number, the cut is accepted
+  double TOLERANCE_;
+  /** Controls the preprocessing of the matrix to identify rows suitable for
+      cut generation.<UL>
+      <LI> -1: preprocess according to solver settings;
+      <LI> 0: Do preprocessing only if it has not yet been done;
+      <LI> 1: Do preprocessing.
+      </UL>
+      Default value: -1 **/
+  int doPreproc_;
+  // The number of rows of the problem.
+  int numRows_;
+  // The number columns of the problem.
+  int numCols_;
+  // Indicates whether preprocessing has been done.
+  bool doneInitPre_;
+  // The array of CglMixIntRoundVUB2s.
+  CglMixIntRoundVUB2* vubs_;
+  // The array of CglMixIntRoundVLB2s.
+  CglMixIntRoundVLB2* vlbs_;
+  // Array with the row types of the rows in the model.
+  RowType* rowTypes_;
+  // The indices of the rows of the initial matrix
+  int* indRows_;
+  // The number of rows of type ROW_MIX
+  int numRowMix_;
+  // The indices of the rows of type ROW_MIX
+  int* indRowMix_;
+  // The number of rows of type ROW_CONT
+  int numRowCont_;
+  // The indices of the rows of type ROW_CONT
+  int* indRowCont_;
+  // The number of rows of type ROW_INT
+  int numRowInt_;
+  // The indices of the rows of type ROW_INT
+  int* indRowInt_;
+  // The number of rows of type ROW_CONT that have at least one variable
+  // with variable upper or lower bound
+  int numRowContVB_;
+  // The indices of the rows of type ROW_CONT that have at least one variable
+  // with variable upper or lower bound
+  int* indRowContVB_;
+  // If integer - for speed
+  char * integerType_;
+  // Sense of rows (modified if ranges)
+  char * sense_;
+  // RHS of rows (modified if ranges)
+  double * RHS_;
+  
+};
+
+//#############################################################################
+// A function that tests the methods in the CglMixedIntegerRounding2 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 CglMixedIntegerRounding2UnitTest(const OsiSolverInterface * siP,
+				      const std::string mpdDir);
+  
+#endif

casadi/include/coin/CglOddHole.hpp

@@ -0,0 +1,160 @@
+// $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 CglOddHole_H
+#define CglOddHole_H
+
+#include <string>
+
+#include "CglCutGenerator.hpp"
+
+/** Odd Hole Cut Generator Class */
+class CglOddHole : public CglCutGenerator {
+   friend void CglOddHoleUnitTest(const OsiSolverInterface * siP,
+				  const std::string mpdDir );
+ 
+public:
+    
+  
+  /**@name Generate Cuts */
+  //@{
+  /** Generate odd hole cuts for the model of the solver interface, si.
+      This looks at all rows of type sum x(i) <= 1 (or == 1) (x 0-1)
+      and sees if there is an odd cycle cut.  See Grotschel, Lovasz
+      and Schrijver (1988) for method.
+      This is then lifted by using the corresponding Chvatal cut i.e.
+      Take all rows in cycle and add them together. RHS will be odd so  
+      weaken all odd coefficients so 1.0 goes to 0.0 etc - then
+      constraint is  sum even(j)*x(j) <= odd which can be replaced by
+      sum (even(j)/2)*x(j) <= (odd-1.0)/2.
+      A similar cut can be generated for sum x(i) >= 1.
+
+      Insert the generated cuts into OsiCut, cs.
+
+      This is only done for rows with unsatisfied 0-1 variables.  If there
+      are many of these it will be slow.  Improvements would do a 
+      randomized subset and also speed up shortest path algorithm used.
+
+  */
+  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+			     const CglTreeInfo info = CglTreeInfo());
+  //@}
+
+  /**@name Create Row List */
+  //@{
+  /// Create a list of rows which might yield cuts
+  /// this is to speed up process
+  /// The possible parameter is a list to cut down search
+  void createRowList( const OsiSolverInterface & si,
+		      const int * possible=NULL);
+  /// This version passes in a list - 1 marks possible
+  void createRowList(int numberRows, const int * whichRow);
+  //@}
+
+  /**@name Create Clique List */
+  //@{
+  /// Create a list of extra row cliques which may not be in matrix
+  /// At present these are classical cliques
+  void createCliqueList(int numberCliques, const int * cliqueStart,
+		     const int * cliqueMember);
+  //@}
+
+  /**@name Number Possibilities */
+  //@{
+  /// Returns how many rows might give odd hole cuts
+  int numberPossible();
+  //@}
+  /**@name Gets and Sets */
+  //@{
+  /// Minimum violation
+  double getMinimumViolation() const;
+  void setMinimumViolation(double value);
+  /// Minimum violation per entry
+  double getMinimumViolationPer() const;
+  void setMinimumViolationPer(double value);
+  /// Maximum number of entries in a cut
+  int getMaximumEntries() const;
+  void setMaximumEntries(int value);
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglOddHole ();
+ 
+  /// Copy constructor 
+  CglOddHole (
+    const CglOddHole &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglOddHole &
+    operator=(
+    const CglOddHole& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglOddHole ();
+
+  /// This can be used to refresh any inforamtion
+  virtual void refreshSolver(OsiSolverInterface * solver);
+  //@}
+      
+private:
+  
+ // Private member methods
+
+
+  /**@name Private methods */
+  //@{
+  /// Generate cuts from matrix copy and solution
+  /// If packed true then <=1 rows, otherwise >=1 rows.
+  void generateCuts(const OsiRowCutDebugger * debugger, 
+		    const CoinPackedMatrix & rowCopy,
+		    const double * solution, const double * dj,
+		    OsiCuts & cs, const int * suitableRow,
+		    const int * fixedColumn,const CglTreeInfo info,
+		    bool packed);
+  //@}
+
+  // Private member data
+
+  /**@name Private member data */
+  //@{
+  /// list of suitableRows
+  int * suitableRows_;
+  /// start of each clique
+  int * startClique_;
+  /// clique members
+  int * member_;
+  /// epsilon
+  double epsilon_;  
+  /// 1-epsilon
+  double onetol_;
+  /// Minimum violation
+  double minimumViolation_;
+  /// Minimum violation per entry
+  double minimumViolationPer_;
+  /// Maximum number of entries in a cut
+  int maximumEntries_;
+  /// number of rows when suitability tested
+  int numberRows_;
+  /// number of cliques
+  int numberCliques_;
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglOddHole 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 CglOddHoleUnitTest(const OsiSolverInterface * siP,
+			const std::string mpdDir );
+  
+#endif

casadi/include/coin/CglParam.hpp

@@ -0,0 +1,93 @@
+// Name:     CglParam.hpp
+// Author:   Francois Margot
+//           Tepper School of Business
+//           Carnegie Mellon University, Pittsburgh, PA 15213
+//           email: fmargot@andrew.cmu.edu
+// Date:     11/24/06
+//
+// $Id$
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//-----------------------------------------------------------------------------
+// Copyright (C) 2006, Francois Margot and others.  All Rights Reserved.
+
+#ifndef CglParam_H
+#define CglParam_H
+#include "CglConfig.h"
+#include "CoinFinite.hpp"
+/** Class collecting parameters for all cut generators. Each generator
+    may have a derived class to add parameters. Each generator might
+    also set different default values for the parameters in CglParam.  */
+
+class CglParam {
+
+public:
+  /**@name Public Set/get methods */
+  //@{
+
+  /** Set INFINIT */
+  virtual void setINFINIT(const double inf);
+  /** Get value of INFINIT */
+  inline double getINFINIT() const { return INFINIT; }
+
+  /** Set EPS */
+  virtual void setEPS(const double eps);
+  /** Get value of EPS */
+  inline double getEPS() const { return EPS; }
+
+  /** Set EPS_COEFF */
+  virtual void setEPS_COEFF(const double eps_c);
+  /** Get value of EPS_COEFF */
+  inline double getEPS_COEFF() const { return EPS_COEFF; }
+
+  /** Set MAX_SUPPORT */
+  virtual void setMAX_SUPPORT(const int max_s);
+  /** Get value of MAX_SUPPORT */
+  inline int getMAX_SUPPORT() const { return MAX_SUPPORT; }
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor
+  CglParam(const double inf = COIN_DBL_MAX, const double eps = 1e-6,
+    const double eps_c = 1e-5, const int max_s = COIN_INT_MAX);
+
+  /// Copy constructor
+  CglParam(const CglParam &);
+
+  /// Clone
+  virtual CglParam *clone() const;
+
+  /// Assignment operator
+  CglParam &operator=(const CglParam &rhs);
+
+  /// Destructor
+  virtual ~CglParam();
+  //@}
+
+protected:
+  // Protected member data
+
+  /**@name Protected member data */
+
+  //@{
+  // Value for infinity. Default: COIN_DBL_MAX.
+  double INFINIT;
+
+  // EPSILON for double comparisons. Default: 1e-6.
+  double EPS;
+
+  // Returned cuts do not have coefficients with absolute value smaller
+  // than EPS_COEFF. Default: 1e-5.
+  double EPS_COEFF;
+
+  /** Maximum number of non zero coefficients in a generated cut;
+      Default: COIN_INT_MAX */
+  int MAX_SUPPORT;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/