CglSimpleRounding.hpp

Go to the documentation of this file.

// $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 CglSimpleRounding_H
#define CglSimpleRounding_H
 
#include <string>
 
#include "CglCutGenerator.hpp"
#include "CoinPackedMatrix.hpp"
 
class CglSimpleRounding : public CglCutGenerator {
   friend void CglSimpleRoundingUnitTest(const OsiSolverInterface * siP,
                                         const std::string mpdDir );
 
public:
 
  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
                             const CglTreeInfo info = CglTreeInfo());
 
  CglSimpleRounding ();
 
  CglSimpleRounding (
    const CglSimpleRounding &);
 
  virtual CglCutGenerator * clone() const;
 
  CglSimpleRounding &
    operator=(
    const CglSimpleRounding& rhs);
  
  virtual
    ~CglSimpleRounding ();
  virtual std::string generateCpp( FILE * fp);
 
private:
  
  // Private member methods
   
  
  bool deriveAnIntegerRow(
                          const OsiSolverInterface & si,
                          int rowIndex,
                          const CoinShallowPackedVector & matrixRow, 
                          CoinPackedVector & irow,
                          double & b,
                          bool * negative) const;
  
 
  int power10ToMakeDoubleAnInt( 
       int size,               // the length of the vector x
       const double * x,   
       double dataTol ) const; // the precision of the data, i.e. the positive
                               // epsilon, which is equivalent to zero
 
  inline  int gcd(int a, int b) const; 
  
  inline  int gcdv(int n, const int * const vi) const; 
 
  
  double epsilon_;
};
 
 
//-------------------------------------------------------------------
// Returns the greatest common denominator of two 
// positive integers, a and b, found using Euclid's algorithm 
//-------------------------------------------------------------------
int 
CglSimpleRounding::gcd(int a, int b) const
{
  if(a > b) {
    // Swap a and b
    int temp = a;
    a = b;
    b = temp;
  }
  int remainder = b % a;
  if (remainder == 0) return a;
  else return gcd(remainder,a);
}
 
//-------------------------------------------------------------------
// Returns the greatest common denominator of a vector of
// positive integers, vi, of length n.
//-------------------------------------------------------------------
int 
CglSimpleRounding::gcdv(int n, const int* const vi) const
{
  if (n==0)
    abort();
 
  if (n==1)
    return vi[0];
 
  int retval=gcd(vi[0], vi[1]);
  for (int i=2; i<n; i++){
     retval=gcd(retval,vi[i]);
  }
  return retval;
}
 
//#############################################################################
void CglSimpleRoundingUnitTest(const OsiSolverInterface * siP,
                               const std::string mpdDir );
  
#endif