ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/CglRedSplit.hpp

@@ -1,448 +0,0 @@
-// Last edit: 4/20/07
-//
-// Name:     CglRedSplit.hpp
-// Author:   Francois Margot
-//           Tepper School of Business
-//           Carnegie Mellon University, Pittsburgh, PA 15213
-//           email: fmargot@andrew.cmu.edu
-// Date:     2/6/05
-//
-// $Id: CglRedSplit.hpp 1119 2013-04-06 20:24:18Z stefan $
-//-----------------------------------------------------------------------------
-// Copyright (C) 2005, Francois Margot and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CglRedSplit_H
-#define CglRedSplit_H
-
-#include "CglCutGenerator.hpp"
-#include "CglRedSplitParam.hpp"
-
-/** Gomory Reduce-and-Split Cut Generator Class; See method generateCuts().
-    Based on the paper by K. Anderson, G. Cornuejols, Yanjun Li, 
-    "Reduce-and-Split Cuts: Improving the Performance of Mixed Integer 
-    Gomory Cuts", Management Science 51 (2005). */
-
-class CglRedSplit : public CglCutGenerator {
-
-  friend void CglRedSplitUnitTest(const OsiSolverInterface * siP,
-				  const std::string mpdDir);
-public:
-  /**@name generateCuts */
-  //@{
-  /** Generate Reduce-and-Split Mixed Integer Gomory cuts 
-      for the model of the solver interface si.
-
-      Insert the generated cuts into OsiCuts cs.
-
-      Warning: This generator currently works only with the Lp solvers Clp or 
-      Cplex9.0 or higher. It requires access to the optimal tableau and 
-      optimal basis inverse and makes assumptions on the way slack variables 
-      are added by the solver. The Osi implementations for Clp and Cplex 
-      verify these assumptions.
-
-      When calling the generator, the solver interface si 
-      must contain an optimized
-      problem and information related to the optimal basis must be available 
-      through the OsiSolverInterface methods (si->optimalBasisIsAvailable()
-      must return 'true'). It is also essential that the integrality of
-      structural variable i can be obtained using si->isInteger(i).
-
-      Reduce-and-Split cuts are variants of Gomory cuts: Starting from
-      the current optimal tableau, linear combinations of the rows of 
-      the current optimal simplex tableau are used for generating Gomory
-      cuts. The choice of the linear combinations is driven by the objective 
-      of reducing the coefficients of the non basic continuous variables
-      in the resulting row.
-      Note that this generator might not be able to generate cuts for some 
-      solutions violating integrality constraints. 
-
-  */
-  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
-			    const CglTreeInfo info = CglTreeInfo());
-
-  /// Return true if needs optimal basis to do cuts (will return true)
-  virtual bool needsOptimalBasis() const;
-  //@}
-  
-  
-  /**@name Public Methods */
-  //@{
-
-  // Set the parameters to the values of the given CglRedSplitParam object.
-  void setParam(const CglRedSplitParam &source); 
-  // Return the CglRedSplitParam object of the generator. 
-  inline CglRedSplitParam getParam() const {return param;}
-
-  // Compute entries of low_is_lub and up_is_lub.
-  void compute_is_lub();
-
-  // Compute entries of is_integer.
-  void compute_is_integer();
-
-  /// Set given_optsol to the given optimal solution given_sol.
-  /// If given_optsol is set using this method, 
-  /// the code will stop as soon as
-  /// a generated cut is violated by the given solution; exclusively 
-  /// for debugging purposes.
-  void set_given_optsol(const double *given_sol, const int card_sol);
-
-  /// Print some of the data members  
-  void print() const;
-
-  /// Print the current simplex tableau  
-  void printOptTab(OsiSolverInterface *solver) const;
-  
-  //@}
-
- /**@name Public Methods (soon to be obsolete)*/
-  //@{
-  //************************************************************
-  // TO BE REMOVED
-  /** Set limit, the maximum number of non zero coefficients in generated cut;
-      Default: 50 */
-  void setLimit(int limit);
-  /** Get value of limit */
-  int getLimit() const;
-
-  /** Set away, the minimum distance from being integer used for selecting 
-      rows for cut generation;  all rows whose pivot variable should be 
-      integer but is more than away from integrality will be selected; 
-      Default: 0.05 */
-  void setAway(double value);
-  /// Get value of away
-  double getAway() const;
- /** Set the value of LUB, value considered large for the absolute value of
-      a lower or upper bound on a variable;
-      Default: 1000 */
-  void setLUB(double value);
-  /** Get the value of LUB */
-  double getLUB() const;
-
-  /** Set the value of EPS, epsilon for double computations;
-      Default: 1e-7 */
-  void setEPS(double value);
-  /** Get the value of EPS */
-  double getEPS() const;
-
-  /** Set the value of EPS_COEFF, epsilon for values of coefficients;
-      Default: 1e-8 */
-  void setEPS_COEFF(double value);
-  /** Get the value of EPS_COEFF */
-  double getEPS_COEFF() const;
-
-  /** Set the value of EPS_COEFF_LUB, epsilon for values of coefficients for 
-      variables with absolute value of lower or upper bound larger than LUB;
-      Default: 1e-13 */
-  void setEPS_COEFF_LUB(double value);
-  /** Get the value of EPS_COEFF_LUB */
-  double getEPS_COEFF_LUB() const;
-
-  /** Set the value of EPS_RELAX, value used for relaxing the right hand side
-      of each generated cut;
-      Default: 1e-8 */
-  void setEPS_RELAX(double value);
-  /** Get the value of EPS_RELAX */
-  double getEPS_RELAX() const;
-
-  /** Set the value of normIsZero, the threshold for considering a norm to be 
-      0; Default: 1e-5 */
-  void setNormIsZero(double value);
-  /** Get the value of normIsZero */
-  double getNormIsZero() const;
-
-  /** Set the value of minReduc, threshold for relative norm improvement for
-   performing  a reduction; Default: 0.05 */
-  void setMinReduc(double value);
-  /// Get the value of minReduc
-  double getMinReduc() const;
-
-  /** Set the maximum allowed value for (mTab * mTab * CoinMax(mTab, nTab)) where 
-      mTab is the number of rows used in the combinations and nTab is the 
-      number of continuous non basic variables. The work of the generator is 
-      proportional to (mTab * mTab * CoinMax(mTab, nTab)). Reducing the value of 
-      maxTab makes the generator faster, but weaker. Default: 1e7. */
-  void setMaxTab(double value);
-  /// Get the value of maxTab
-  double getMaxTab() const;
-  // END TO BE REMOVED
-  //************************************************************
-
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglRedSplit();
-
-  /// Constructor with specified parameters 
-  CglRedSplit(const CglRedSplitParam &RS_param);
- 
-  /// Copy constructor 
-  CglRedSplit (const CglRedSplit &);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglRedSplit &
-    operator=(
-    const CglRedSplit& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglRedSplit ();
-  /// Create C++ lines to get to current state
-  virtual std::string generateCpp( FILE * fp);
-  //@}
-    
-private:
-  
-  // Private member methods
-
-/**@name Private member methods */
-
-  //@{
-
-  // Method generating the cuts after all CglRedSplit members are properly set.
-  void generateCuts(OsiCuts & cs);
-
-  /// Compute the fractional part of value, allowing for small error.
-  inline double rs_above_integer(double value); 
-
-  /// Perform row r1 of pi := row r1 of pi - step * row r2 of pi.
-  void update_pi_mat(int r1, int r2, int step);
-
-  /// Perform row r1 of tab := row r1 of tab - step * row r2 of tab.
-  void update_redTab(int r1, int r2, int step);
-
-  /// Find optimal integer step for changing row r1 by adding to it a 
-  /// multiple of another row r2.
-  void find_step(int r1, int r2, int *step, 
-		 double *reduc, double *norm);
-
-  /// Test if an ordered pair of rows yields a reduction. Perform the
-  /// reduction if it is acceptable.
-  int test_pair(int r1, int r2, double *norm);
-
-  /// Reduce rows of contNonBasicTab.
-  void reduce_contNonBasicTab();
-
-  /// Generate a row of the current LP tableau.
-  void generate_row(int index_row, double *row);
-
-  /// Generate a mixed integer Chvatal-Gomory cut, when all non basic 
-  /// variables are non negative and at their lower bound.
-  int generate_cgcut(double *row, double *rhs);
-
-  /// Generate a mixed integer Chvatal-Gomory cut, when all non basic 
-  /// variables are non negative and at their lower bound (different formula)
-  int generate_cgcut_2(int basic_ind, double *row, double *rhs);
-
-  /// Use multiples of the initial inequalities to cancel out the coefficients
-  /// of the slack variables.
-  void eliminate_slacks(double *row, 
-			const double *elements, 
-			const int *start,
-			const int *indices,
-			const int *rowLength,
-			const double *rhs, double *rowrhs);
-
-  /// Change the sign of the coefficients of the continuous non basic
-  /// variables at their upper bound.
-  void flip(double *row);
-
-  /// Change the sign of the coefficients of the continuous non basic
-  /// variables at their upper bound and do the translations restoring
-  /// the original bounds. Modify the right hand side
-  /// accordingly.
-  void unflip(double *row, double *rowrhs, double *slack_val);
-
-  /// Return the scale factor for the row. 
-  /// Compute max_coeff: maximum absolute value of the coefficients.
-  /// Compute min_coeff: minimum absolute value of the coefficients
-  /// larger than EPS_COEFF.
-  /// Return -1 if max_coeff < EPS_COEFF or if max_coeff/min_coeff > MAXDYN
-  /// or MAXDYN_LUB (depending if the row has a non zero coeff. for a variable
-  /// with large lower/upper bound) */.
-  double row_scale_factor(double *row);
-
-  /// Generate the packed cut from the row representation.
-  int generate_packed_row(const double *xlp, double *row,
-			  int *rowind, double *rowelem, 
-			  int *card_row, double & rhs);
-
-  /// Check that the generated cuts do not cut a given optimal solution.
-  void check_optsol(const int calling_place,
-		    const double *xlp, const double *slack_val,
-		    const int do_flip);
-
-  /// Check that the generated cuts do not cut a given optimal solution.
-  void check_optsol(const int calling_place,
-		    const double *xlp, const double *slack_val,
-		    const double *ck_row, const double ck_rhs, 
-		    const int cut_number, const int do_flip);
-
-  // Check that two vectors are different.
-  bool rs_are_different_vectors(const int *vect1, 
-				const int *vect2,
-				const int dim);
-
-  // Check that two vectors are different.
-  bool rs_are_different_vectors(const double *vect1, 
-				const double *vect2,
-				const int dim);
-
-  // Check that two matrices are different.
-  bool rs_are_different_matrices(const CoinPackedMatrix *mat1, 
-				 const CoinPackedMatrix *mat2,
-				 const int nmaj,
-				 const int nmin);
-  //@}
-
-  
-  // Private member data
-
-/**@name Private member data */
-
-  //@{
-
-  /// Object with CglRedSplitParam members. 
-  CglRedSplitParam param;
-
-  /// Number of rows ( = number of slack variables) in the current LP.
-  int nrow; 
-
-  /// Number of structural variables in the current LP.
-  int ncol;
-
-  /// Lower bounds for structural variables
-  const double *colLower;
-
-  /// Upper bounds for structural variables
-  const double *colUpper;
-  
-  /// Lower bounds for constraints
-  const double *rowLower;
-
-  /// Upper bounds for constraints
-  const double *rowUpper;
-
-  /// Righ hand side for constraints (upper bound for ranged constraints).
-  const double *rowRhs;
-
-  /// Number of integer basic structural variables that are fractional in the
-  /// current lp solution (at least param.away_ from being integer).  
-  int card_intBasicVar_frac;
-
-  /// Number of integer non basic structural variables in the
-  /// current lp solution.  
-  int card_intNonBasicVar; 
-
-  /// Number of continuous non basic variables (structural or slack) in the
-  /// current lp solution.  
-  int card_contNonBasicVar;
-
-  /// Number of non basic variables (structural or slack) at their
-  /// upper bound in the current lp solution.
-  int card_nonBasicAtUpper; 
-
-  /// Number of non basic variables (structural or slack) at their
-  /// lower bound in the current lp solution.
-  int card_nonBasicAtLower;
-
-  /// Characteristic vector for integer basic structural variables
-  /// with non integer value in the current lp solution.
-  int *cv_intBasicVar_frac;  
-
-  /// List of integer structural basic variables 
-  /// (in order of pivot in selected rows for cut generation).
-  int *intBasicVar_frac;
-
-  /// List of integer structural non basic variables.
-  int *intNonBasicVar; 
-
-  /// List of continuous non basic variables (structural or slack). 
-  // slacks are considered continuous (no harm if this is not the case).
-  int *contNonBasicVar;
-
-  /// List of non basic variables (structural or slack) at their 
-  /// upper bound. 
-  int *nonBasicAtUpper;
-
-  /// List of non basic variables (structural or slack) at their lower
-  /// bound.
-  int *nonBasicAtLower;
-
-  /// Number of rows in the reduced tableau (= card_intBasicVar_frac).
-  int mTab;
-
-  /// Number of columns in the reduced tableau (= card_contNonBasicVar)
-  int nTab;
-
-  /// Tableau of multipliers used to alter the rows used in generation.
-  /// Dimensions: mTab by mTab. Initially, pi_mat is the identity matrix.
-  int **pi_mat;
-
-  /// Current tableau for continuous non basic variables (structural or slack).
-  /// Only rows used for generation.
-  /// Dimensions: mTab by nTab.
-  double **contNonBasicTab;
-
-  /// Current tableau for integer non basic structural variables.
-  /// Only rows used for generation.
-  // Dimensions: mTab by card_intNonBasicVar.
-  double **intNonBasicTab;
-
-  /// Right hand side of the tableau.
-  /// Only rows used for generation.
-  double *rhsTab ;
-
-  /// Given optimal solution that should not be cut; only for debug. 
-  const double *given_optsol;
-
-  /// Number of entries in given_optsol.
-  int card_given_optsol;
-
-  /// Characteristic vectors of structural integer variables or continuous
-  /// variables currently fixed to integer values. 
-  int *is_integer;
-
-  /// Characteristic vector of the structural variables whose lower bound 
-  /// in absolute value is larger than LUB. 
-  int *low_is_lub;
-
-  /// Characteristic vector of the structural variables whose upper bound 
-  /// in absolute value is larger than LUB. 
-  int *up_is_lub;
-
-  /// Pointer on solver. Reset by each call to generateCuts().
-  OsiSolverInterface *solver;
-
-  /// Pointer on point to separate. Reset by each call to generateCuts().
-  const double *xlp;
-
-  /// Pointer on row activity. Reset by each call to generateCuts().
-  const double *rowActivity;
-
-  /// Pointer on column type. Reset by each call to generateCuts().
-  const char *colType;
-
-  /// Pointer on matrix of coefficient ordered by rows. 
-  /// Reset by each call to generateCuts().
-  const CoinPackedMatrix *byRow;
-
-  //@}
-};
-
-//#############################################################################
-/** A function that tests the methods in the CglRedSplit 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 CglRedSplitUnitTest(const OsiSolverInterface * siP,
-			 const std::string mpdDir );
-
-
-#endif

data/ext/ruby-cbc/install/include/coin/CglRedSplit2.hpp

@@ -1,494 +0,0 @@
-// Last edit: 04/03/10
-//
-// Name:     CglRedSplit2.hpp
-// Author:   Giacomo Nannicini
-//           Singapore University of Technology and Design
-//           Singapore
-//           email: nannicini@sutd.edu.sg
-//           based on CglRedSplit by Francois Margot
-// Date:     03/09/09
-//-----------------------------------------------------------------------------
-// Copyright (C) 2010, Giacomo Nannicini and others.  All Rights Reserved.
-
-#ifndef CglRedSplit2_H
-#define CglRedSplit2_H
-
-#include "CglCutGenerator.hpp"
-#include "CglRedSplit2Param.hpp"
-#include "CoinWarmStartBasis.hpp"
-#include "CoinHelperFunctions.hpp"
-#include "CoinTime.hpp"
-
-/** Reduce-and-Split Cut Generator Class; See method generateCuts().
-    Based on the papers "Practical strategies for generating rank-1
-    split cuts in mixed-integer linear programming" by G. Cornuejols
-    and G. Nannicini, published on Mathematical Programming
-    Computation, and "Combining Lift-and-Project and Reduce-and-Split"
-    by E. Balas, G. Cornuejols, T. Kis and G. Nannicini, published on
-    INFORMS Journal on Computing. Part of this code is based on
-    CglRedSplit by F. Margot. */
-
-class CglRedSplit2 : public CglCutGenerator {
-
-  friend void CglRedSplit2UnitTest(const OsiSolverInterface * siP,
-				  const std::string mpdDir);
-public:
-  /**@name generateCuts */
-  //@{
-  /** Generate Reduce-and-Split Mixed Integer Gomory cuts 
-      for the model of the solver interface si.
-
-      Insert the generated cuts into OsiCuts cs.
-
-      This generator currently works only with the Lp solvers Clp or
-      Cplex9.0 or higher. It requires access to the optimal tableau
-      and optimal basis inverse and makes assumptions on the way slack
-      variables are added by the solver. The Osi implementations for
-      Clp and Cplex verify these assumptions.
-
-      When calling the generator, the solver interface si must contain
-      an optimized problem and information related to the optimal
-      basis must be available through the OsiSolverInterface methods
-      (si->optimalBasisIsAvailable() must return 'true'). It is also
-      essential that the integrality of structural variable i can be
-      obtained using si->isInteger(i).
-
-      Reduce-and-Split cuts are a class of split cuts. We compute
-      linear combinations of the rows of the simplex tableau, trying
-      to reduce some of the coefficients on the nonbasic continuous
-      columns.  We have a large number of heuristics to choose which
-      coefficients should be reduced, and by using which rows. The
-      paper explains everything in detail.
-
-      Note that this generator can potentially generate a huge number
-      of cuts, depending on how it is parametered. Default parameters
-      should be good for most situations; if you want to go heavy on
-      split cuts, use more row selection strategies or a different
-      number of rows in the linear combinations. Again, look at the
-      paper for details. If you want to generate a small number of
-      cuts, default parameters are not the best choice.
-
-      A combination of Reduce-and-Split with Lift & Project is
-      described in the paper "Combining Lift-and-Project and
-      Reduce-and-Split". The Reduce-and-Split code for the
-      implementation used in that paper is included here.
-
-      This generator does not generate the same cuts as CglRedSplit,
-      therefore both generators can be used in conjunction.
-
-  */
-
-  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
-			    const CglTreeInfo info = CglTreeInfo());
-
-  /// Return true if needs optimal basis to do cuts (will return true)
-  virtual bool needsOptimalBasis() const;
-
-  // Generate the row multipliers computed by Reduce-and-Split from the
-  // given OsiSolverInterface. The multipliers are written in lambda;
-  // lambda should be of size nrow*maxNumMultipliers. We generate at most
-  // maxNumMultipliers m-vectors of row multipliers, and return the number
-  // of m-vectors that were generated.
-  // If the caller wants to know which variables are basic in each row 
-  // (same order as lambda), basicVariables should be non-NULL (size nrow).
-  // This method can also generate the cuts corresponding to the multipliers
-  // returned; it suffices to pass non-NULL OsiCuts.
-  // This method is not needed by the typical user; however, it is useful
-  // in the context of generating Lift & Project cuts.
-  int generateMultipliers(const OsiSolverInterface& si, int* lambda,
-			  int maxNumMultipliers, int* basicVariables = NULL,
-			  OsiCuts* cs = NULL);
-
-  // Try to improve a Lift & Project cut, by employing the
-  // Reduce-and-Split procedure. We start from a row of a L&P tableau,
-  // and generate a cut trying to reduce the coefficients on the
-  // nonbasic variables.  Note that this L&P tableau will in general
-  // have nonbasic variables which are nonzero in the point that we
-  // want to cut off, so we should be careful.  Arguments:
-  // OsiSolverInterface which contains the simplex tableau, initial
-  // row from which the cut is derived, row rhs, row number of the
-  // source row (if it is in the simplex tableau; otherwise, a
-  // negative number; needed to avoid using duplicate rows), point
-  // that we want to cut off (note: this is NOT a basic solution for
-  // the OsiSolverInterace!), list of variables which are basic in
-  // xbar but are nonbasic in the OsiSolverInterface. The computed cut
-  // is written in OsiRowCut* cs. Finally, if a starting disjunction
-  // is provided in the vector lambda (of size ncols, i.e. a
-  // disjunction on the structural variables), the disjunction is
-  // modified according to the cut which is produced.
-  int tiltLandPcut(const OsiSolverInterface* si, double* row, 
-		   double rowRhs, int rownumber, const double* xbar, 
-		   const int* newnonbasics, OsiRowCut* cs, int* lambda = NULL);
-
-  //@}
-  
-  
-  /**@name Public Methods */
-  //@{
-
-  // Set the parameters to the values of the given CglRedSplit2Param object.
-  void setParam(const CglRedSplit2Param &source); 
-  // Return the CglRedSplit2Param object of the generator. 
-  inline CglRedSplit2Param& getParam() {return param;}
-
-  /// Print some of the data members; used for debugging
-  void print() const;
-
-  /// Print the current simplex tableau  
-  void printOptTab(OsiSolverInterface *solver) const;
-  
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglRedSplit2();
-
-  /// Constructor with specified parameters 
-  CglRedSplit2(const CglRedSplit2Param &RS_param);
- 
-  /// Copy constructor 
-  CglRedSplit2(const CglRedSplit2 &);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglRedSplit2 & operator=(const CglRedSplit2& rhs);
-  
-  /// Destructor 
-  virtual ~CglRedSplit2 ();
-
-  //@}
-
-private:
-  
-  // Private member methods
-
-/**@name Private member methods */
-
-  //@{
-
-  // Method generating the cuts after all CglRedSplit2 members are 
-  // properly set. This does the actual work. Returns the number of
-  // generated cuts (or multipliers).
-  // Will generate cuts if cs != NULL, and will generate multipliers
-  // if lambda != NULL. 
-  int generateCuts(OsiCuts* cs, int maxNumCuts, int* lambda = NULL);
-
-  /// Compute the fractional part of value, allowing for small error.
-  inline double rs_above_integer(const double value) const; 
-
-  /// Fill workNonBasicTab, depending on the column selection strategy.
-  /// Accepts a list of variables indices that should be ignored; by
-  /// default, this list is empty (it is only used by Lift & Project).
-  /// The list ignore_list contains -1 as the last element.
-  /// Note that the implementation of the ignore_list is not very efficient
-  /// if the list is long, so it should be used only if its short.
-  void fill_workNonBasicTab(CglRedSplit2Param::ColumnSelectionStrategy 
-			    strategy, const int* ignore_list = NULL);
-
-  /// Fill workNonBasicTab, alternate version for Lift & Project: also
-  /// reduces columns which are now nonbasic but are basic in xbar.
-  /// This function should be called only when CglRedSplit2 is used in
-  /// conjunction with CglLandP to generate L&P+RS cuts.
-  void fill_workNonBasicTab(const int* newnonbasics, const double* xbar,
-			    CglRedSplit2Param::ColumnScalingStrategy scaling);
-
-  /// Reduce rows of workNonBasicTab, i.e. compute integral linear
-  /// combinations of the rows in order to reduce row coefficients on
-  /// workNonBasicTab
-  void reduce_workNonBasicTab(int numRows, 
-			      CglRedSplit2Param::RowSelectionStrategy 
-			      rowSelectionStrategy,
-			      int maxIterations);
-
-  /// Generate a linear combination of the rows of the current LP
-  /// tableau, using the row multipliers stored in the matrix pi_mat
-  /// on the row of index index_row
-  void generate_row(int index_row, double *row);
-
-  /// Generate a mixed integer Gomory cut, when all non basic 
-  /// variables are non negative and at their lower bound.
-  int generate_cgcut(double *row, double *rhs);
-
-  /// Use multiples of the initial inequalities to cancel out the coefficients
-  /// of the slack variables.
-  void eliminate_slacks(double *row, 
-			const double *elements, 
-			const int *start,
-			const int *indices,
-			const int *rowLength,
-			const double *rhs, double *rowrhs);
-
-  /// Change the sign of the coefficients of the continuous non basic
-  /// variables at their upper bound.
-  void flip(double *row);
-
-  /// Change the sign of the coefficients of the continuous non basic
-  /// variables at their upper bound and do the translations restoring
-  /// the original bounds. Modify the right hand side
-  /// accordingly.
-  void unflip(double *row, double *rowrhs);
-
-  /// Returns 1 if the row has acceptable max/min coeff ratio.
-  /// Compute max_coeff: maximum absolute value of the coefficients.
-  /// Compute min_coeff: minimum absolute value of the coefficients
-  /// larger than EPS_COEFF.
-  /// Return 0 if max_coeff/min_coeff > MAXDYN.
-  int check_dynamism(double *row);
-
-  /// Generate the packed cut from the row representation.
-  int generate_packed_row(const double *xlp, double *row,
-			  int *rowind, double *rowelem, 
-			  int *card_row, double & rhs);
-
-  // Compute entries of is_integer.
-  void compute_is_integer();
-
-  // Check that two vectors are different.
-  bool rs_are_different_vectors(const int *vect1, 
-				const int *vect2,
-				const int dim);
-
-  // allocate matrix of integers
-  void rs_allocmatINT(int ***v, int m, int n);
-  // deallocate matrix of integers
-  void rs_deallocmatINT(int ***v, int m);
-  // allocate matrix of doubles
-  void rs_allocmatDBL(double ***v, int m, int n);
-  // deallocate matrix of doubles
-  void rs_deallocmatDBL(double ***v, int m);
-  // print a vector of integers
-  void rs_printvecINT(const char *vecstr, const int *x, int n) const;
-  // print a vector of doubles
-  void rs_printvecDBL(const char *vecstr, const double *x, int n) const;
-  // print a matrix of integers
-  void rs_printmatINT(const char *vecstr, const int * const *x, int m, int n) const;
-  // print a matrix of doubles
-  void rs_printmatDBL(const char *vecstr, const double * const *x, int m, int n) const;
-  // dot product
-  double rs_dotProd(const double *u, const double *v, int dim) const;
-  double rs_dotProd(const int *u, const double *v, int dim) const;
-  // From Numerical Recipes in C: LU decomposition
-  int ludcmp(double **a, int n, int *indx, double *d, double* vv) const;
-  // from Numerical Recipes in C: backward substitution
-  void lubksb(double **a, int n, int *indx, double *b) const;
-
-  // Check if the linear combination given by listOfRows with given multipliers
-  // improves the norm of row #rowindex; note: multipliers are rounded!
-  // Returns the difference with respect to the old norm (if negative there is
-  // an improvement, if positive norm increases)
-  double compute_norm_change(double oldnorm, const int* listOfRows,
-			     int numElemList, const double* multipliers) const;
-
-  // Compute the list of rows that should be used to reduce row #rowIndex
-  int get_list_rows_reduction(int rowIndex, int numRowsReduction, 
-			      int* list, const double* norm, 
-			      CglRedSplit2Param::RowSelectionStrategy 
-			      rowSelectionStrategy) const;
-
-  // Sorts the rows by increasing number of nonzeroes with respect to a given
-  // row (rowIndex), on the nonbasic variables (whichTab == 0 means only
-  // integer, whichTab == 1 means only workTab, whichTab == 2 means both).
-  // The array for sorting must be allocated (and deleted) by caller.
-  // Corresponds to BRS1 in the paper.
-  int sort_rows_by_nonzeroes(struct sortElement* array, int rowIndex, 
-			     int maxRows, int whichTab) const;
-
-  // Greedy variant of the previous function; slower but typically
-  // more effective. Corresponds to BRS2 in the paper.
-  int sort_rows_by_nonzeroes_greedy(struct sortElement* array, int rowIndex, 
-				    int maxRows, int whichTab) const;
-
-  // Sorts the rows by decreasing absolute value of the cosine of the
-  // angle with respect to a given row (rowIndex), on the nonbasic
-  // variables (whichTab == 0 means only integer, whichTab == 1 means
-  // only workTab, whichTab == 2 means both).  The array for sorting
-  // must be allocated (and deleted) by caller. Very effective
-  // strategy in practice. Corresponds to BRS3 in the paper.
-  int sort_rows_by_cosine(struct sortElement* array, int rowIndex, 
-			  int maxRows, int whichTab) const;
-
-  // Did we hit the time limit?
-  inline bool checkTime() const{
-    if ((CoinCpuTime() - startTime) < param.getTimeLimit()){
-      return true;
-    }
-    return false;
-  }
-
-  //@}
-
-  
-  // Private member data
-
-  /**@name Private member data */
-  
-  //@{
-
-  /// Object with CglRedSplit2Param members. 
-  CglRedSplit2Param param;
-
-  /// Number of rows ( = number of slack variables) in the current LP.
-  int nrow; 
-
-  /// Number of structural variables in the current LP.
-  int ncol;
-
-  /// Number of rows which have been reduced
-  int numRedRows;
-
-  /// Lower bounds for structural variables
-  const double *colLower;
-
-  /// Upper bounds for structural variables
-  const double *colUpper;
-  
-  /// Lower bounds for constraints
-  const double *rowLower;
-
-  /// Upper bounds for constraints
-  const double *rowUpper;
-
-  /// Righ hand side for constraints (upper bound for ranged constraints).
-  const double *rowRhs;
-
-  /// Reduced costs for columns
-  const double *reducedCost;
-
-  /// Row price
-  const double *rowPrice;
-
-  /// Objective coefficients
-  const double* objective;
-
-  /// Number of integer basic structural variables 
-  int card_intBasicVar;
-
-  /// Number of integer basic structural variables that are fractional in the
-  /// current lp solution (at least param.away_ from being integer).  
-  int card_intBasicVar_frac;
-
-  /// Number of integer non basic structural variables in the
-  /// current lp solution.  
-  int card_intNonBasicVar; 
-
-  /// Number of continuous non basic variables (structural or slack) in the
-  /// current lp solution.  
-  int card_contNonBasicVar;
-
-  /// Number of continuous non basic variables (structural or slack) in the
-  /// current working set for coefficient reduction
-  int card_workNonBasicVar;
-
-  /// Number of non basic variables (structural or slack) at their
-  /// upper bound in the current lp solution.
-  int card_nonBasicAtUpper; 
-
-  /// Number of non basic variables (structural or slack) at their
-  /// lower bound in the current lp solution.
-  int card_nonBasicAtLower;
-
-  /// Characteristic vector for integer basic structural variables
-  int *cv_intBasicVar;  
-
-  /// Characteristic vector for integer basic structural variables
-  /// with non integer value in the current lp solution.
-  int *cv_intBasicVar_frac;  
-
-  /// Characteristic vector for rows of the tableau selected for reduction
-  /// with non integer value in the current lp solution
-  int *cv_fracRowsTab;  
-
-  /// List of integer structural basic variables 
-  /// (in order of pivot in selected rows for cut generation).
-  int *intBasicVar;
-
-  /// List of integer structural basic variables with fractional value
-  /// (in order of pivot in selected rows for cut generation).
-  int *intBasicVar_frac;
-
-  /// List of integer structural non basic variables.
-  int *intNonBasicVar; 
-
-  /// List of continuous non basic variables (structural or slack). 
-  // slacks are considered continuous (no harm if this is not the case).
-  int *contNonBasicVar;
-
-  /// List of non basic variables (structural or slack) at their 
-  /// upper bound. 
-  int *nonBasicAtUpper;
-
-  /// List of non basic variables (structural or slack) at their lower
-  /// bound.
-  int *nonBasicAtLower;
-
-  /// Number of rows in the reduced tableau (= card_intBasicVar).
-  int mTab;
-
-  /// Number of columns in the reduced tableau (= card_contNonBasicVar)
-  int nTab;
-
-  /// Tableau of multipliers used to alter the rows used in generation.
-  /// Dimensions: mTab by mTab. Initially, pi_mat is the identity matrix.
-  int **pi_mat;
-
-  /// Simplex tableau for continuous non basic variables (structural or slack).
-  /// Only rows used for generation.
-  /// Dimensions: mTab by card_contNonBasicVar.
-  double **contNonBasicTab;
-
-  /// Current tableau for continuous non basic variables (structural or slack).
-  /// Only columns used for coefficient reduction.
-  /// Dimensions: mTab by card_workNonBasicVar.
-  double **workNonBasicTab;
-
-  /// Simplex tableau for integer non basic structural variables.
-  /// Only rows used for generation.
-  // Dimensions: mTab by card_intNonBasicVar.
-  double **intNonBasicTab;
-
-  /// Right hand side of the tableau.
-  /// Only rows used for generation.
-  double *rhsTab;
-
-  /// Norm of rows in workNonBasicTab; needed for faster computations
-  double *norm;
-
-  /// Characteristic vectors of structural integer variables or continuous
-  /// variables currently fixed to integer values. 
-  int *is_integer;
-
-  /// Pointer on solver. Reset by each call to generateCuts().
-  OsiSolverInterface *solver;
-
-  /// Pointer on point to separate. Reset by each call to generateCuts().
-  const double *xlp;
-
-  /// Pointer on row activity. Reset by each call to generateCuts().
-  const double *rowActivity;
-
-  /// Pointer on matrix of coefficient ordered by rows. 
-  /// Reset by each call to generateCuts().
-  const CoinPackedMatrix *byRow;
-
-  /// Time at which cut computations began.
-  /// Reset by each call to generateCuts().
-  double startTime;
-
-  //@}
-};
-
-//#############################################################################
-/** A function that tests some of the methods in the CglRedSplit2
-    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 CglRedSplit2UnitTest(const OsiSolverInterface * siP,
-			 const std::string mpdDir );
-
-
-#endif