ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,166 +0,0 @@
-/* $Id: CoinFileIO.hpp 1439 2011-06-13 16:31:21Z stefan $ */
-// Copyright (C) 2005, COIN-OR.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinFileIO_H
-#define CoinFileIO_H
-
-#include <string>
-
-/// Base class for FileIO classes.
-class CoinFileIOBase
-{
-public:
-  /// Constructor.
-  /// @param fileName The name of the file used by this object.
-  CoinFileIOBase (const std::string &fileName);
-
-  /// Destructor.
-  ~CoinFileIOBase ();
-
-  /// Return the name of the file used by this object.
-  const char *getFileName () const;
-
-  /// Return the method of reading being used
-  inline std::string getReadType () const
-  { return readType_.c_str();}
-protected:
-  std::string readType_;
-private:
-  CoinFileIOBase ();
-  CoinFileIOBase (const CoinFileIOBase &);
-
-  std::string fileName_;
-};
-
-/// Abstract base class for file input classes.
-class CoinFileInput: public CoinFileIOBase
-{
-public:
-  /// indicates whether CoinFileInput supports gzip'ed files
-  static bool haveGzipSupport();
-  /// indicates whether CoinFileInput supports bzip2'ed files
-  static bool haveBzip2Support();
-
-  /// Factory method, that creates a CoinFileInput (more precisely
-  /// a subclass of it) for the file specified. This method reads the 
-  /// first few bytes of the file and determines if this is a compressed
-  /// or a plain file and returns the correct subclass to handle it.
-  /// If the file does not exist or uses a compression not compiled in
-  /// an exception is thrown.
-  /// @param fileName The file that should be read.
-  static CoinFileInput *create (const std::string &fileName);
-
-  /// Constructor (don't use this, use the create method instead).
-  /// @param fileName The name of the file used by this object.
-  CoinFileInput (const std::string &fileName);
-
-  /// Destructor.
-  virtual ~CoinFileInput ();
-
-  /// Read a block of data from the file, similar to fread.
-  /// @param buffer Address of a buffer to store the data into.
-  /// @param size Number of bytes to read (buffer should be large enough).
-  /// @return Number of bytes read.
-  virtual int read (void *buffer, int size) = 0;
-
-  /// Reads up to (size-1) characters an stores them into the buffer, 
-  /// similar to fgets.
-  /// Reading ends, when EOF or a newline occurs or (size-1) characters have
-  /// been read. The resulting string is terminated with '\0'. If reading
-  /// ends due to an encoutered newline, the '\n' is put into the buffer, 
-  /// before the '\0' is appended.
-  /// @param buffer The buffer to put the string into.
-  /// @param size The size of the buffer in characters.
-  /// @return buffer on success, or 0 if no characters have been read.
-  virtual char *gets (char *buffer, int size) = 0;
-};
-
-/// Abstract base class for file output classes.
-class CoinFileOutput: public CoinFileIOBase
-{
-public:
-
-  /// The compression method.
-  enum Compression { 
-    COMPRESS_NONE = 0, ///< No compression.
-    COMPRESS_GZIP = 1, ///< gzip compression.
-    COMPRESS_BZIP2 = 2 ///< bzip2 compression.
-  };
-
-  /// Returns whether the specified compression method is supported 
-  /// (i.e. was compiled into COIN).
-  static bool compressionSupported (Compression compression);
-
-  /// Factory method, that creates a CoinFileOutput (more precisely
-  /// a subclass of it) for the file specified. If the compression method
-  /// is not supported an exception is thrown (so use compressionSupported
-  /// first, if this is a problem). The reason for not providing direct 
-  /// access to the subclasses (and using such a method instead) is that
-  /// depending on the build configuration some of the classes are not 
-  /// available (or functional). This way we can handle all required ifdefs
-  /// here instead of polluting other files.
-  /// @param fileName The file that should be read.
-  /// @param compression Compression method used.
-  static CoinFileOutput *create (const std::string &fileName, 
-				 Compression compression);
-
-  /// Constructor (don't use this, use the create method instead).
-  /// @param fileName The name of the file used by this object.
-  CoinFileOutput (const std::string &fileName);
-
-  /// Destructor.
-  virtual ~CoinFileOutput ();
-
-  /// Write a block of data to the file, similar to fwrite.
-  /// @param buffer Address of a buffer containing the data to be written.
-  /// @param size Number of bytes to write.
-  /// @return Number of bytes written.
-  virtual int write (const void * buffer, int size) = 0;
-
-  /// Write a string to the file (like fputs).
-  /// Just as with fputs no trailing newline is inserted!
-  /// The terminating '\0' is not written to the file.
-  /// The default implementation determines the length of the string
-  /// and calls write on it.
-  /// @param s The zero terminated string to be written.
-  /// @return true on success, false on error.
-  virtual bool puts (const char *s);
-
-  /// Convenience method: just a 'puts(s.c_str())'.
-  inline bool puts (const std::string &s)
-  {
-    return puts (s.c_str ());
-  } 
-};
-
-/*! \relates CoinFileInput
-    \brief Test if the given string looks like an absolute file path
-
-    The criteria are:
-    - unix: string begins with `/'
-    - windows: string begins with `\' or with `drv:' (drive specifier)
-*/
-bool fileAbsPath (const std::string &path) ;
-
-/*! \relates CoinFileInput
-    \brief Test if the file is readable, using likely versions of the file
-	   name, and return the name that worked.
-
-   The file name is constructed from \p name using the following rules:
-   <ul>
-     <li> An absolute path is not modified.
-     <li> If the name begins with `~', an attempt is made to replace `~'
-	  with the value of the environment variable HOME.
-     <li> If a default prefix (\p dfltPrefix) is provided, it is
-	  prepended to the name.
-   </ul>
-   If the constructed file name cannot be opened, and CoinUtils was built
-   with support for compressed files, fileCoinReadable will try any
-   standard extensions for supported compressed files.
-
-   The value returned in \p name is the file name that actually worked.
-*/
-bool fileCoinReadable(std::string &name,
-		      const std::string &dfltPrefix = std::string(""));
-#endif

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

@@ -1,34 +0,0 @@
-/* $Id: CoinFinite.hpp 1762 2014-12-29 20:37:12Z tkr $ */
-// 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).
-
-/* Defines COIN_DBL_MAX and relatives and provides CoinFinite and CoinIsnan. */
-
-#ifndef CoinFinite_H
-#define CoinFinite_H
-
-#include <limits>
-
-//=============================================================================
-// Smallest positive double value and Plus infinity (double and int)
-
-#if 1
-const double COIN_DBL_MIN = (std::numeric_limits<double>::min)();
-const double COIN_DBL_MAX = (std::numeric_limits<double>::max)();
-const int    COIN_INT_MAX = (std::numeric_limits<int>::max)();
-const double COIN_INT_MAX_AS_DOUBLE = (std::numeric_limits<int>::max)();
-#else
-#define COIN_DBL_MIN (std::numeric_limits<double>::min())
-#define COIN_DBL_MAX (std::numeric_limits<double>::max())
-#define COIN_INT_MAX (std::numeric_limits<int>::max())
-#define COIN_INT_MAX_AS_DOUBLE (std::numeric_limits<int>::max())
-#endif
-
-/** checks if a double value is finite (not infinity and not NaN) */
-extern bool CoinFinite(double val);
-
-/** checks if a double value is not a number */
-extern bool CoinIsnan(double val);
-
-#endif

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

@@ -1,177 +0,0 @@
-/* $Id: CoinFloatEqual.hpp 1416 2011-04-17 09:57:29Z stefan $ */
-// 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 CoinFloatEqual_H
-#define CoinFloatEqual_H
-
-#include <algorithm>
-#include <cmath>
-
-#include "CoinFinite.hpp"
-
-/*! \file CoinFloatEqual.hpp
-    \brief Function objects for testing equality of real numbers.
-
-  Two objects are provided; one tests for equality to an absolute tolerance,
-  one to a scaled tolerance. The tests will handle IEEE floating point, but
-  note that infinity == infinity. Mathematicians are rolling in their graves,
-  but this matches the behaviour for the common practice of using
-  <code>DBL_MAX</code> (<code>numeric_limits<double>::max()</code>, or similar
-  large finite number) as infinity.
-
-  <p>
-  Example usage:
-  @verbatim
-    double d1 = 3.14159 ;
-    double d2 = d1 ;
-    double d3 = d1+.0001 ;
-
-    CoinAbsFltEq eq1 ;
-    CoinAbsFltEq eq2(.001) ;
-
-    assert(  eq1(d1,d2) ) ;
-    assert( !eq1(d1,d3) ) ;
-    assert(  eq2(d1,d3) ) ;
-  @endverbatim
-  CoinRelFltEq follows the same pattern.  */
-
-/*! \brief Equality to an absolute tolerance
-
-  Operands are considered equal if their difference is within an epsilon ;
-  the test does not consider the relative magnitude of the operands.
-*/
-
-class CoinAbsFltEq
-{
-  public:
-
-  //! Compare function
-
-  inline bool operator() (const double f1, const double f2) const
-
-  { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ;
-    if (f1 == f2) return true ;
-    return (fabs(f1-f2) < epsilon_) ; } 
-
-  /*! \name Constructors and destructors */
-  //@{
-
-  /*! \brief Default constructor
-
-    Default tolerance is 1.0e-10.
-  */
-
-  CoinAbsFltEq () : epsilon_(1.e-10) {} 
-
-  //! Alternate constructor with epsilon as a parameter
-
-  CoinAbsFltEq (const double epsilon) : epsilon_(epsilon) {} 
-
-  //! Destructor
-
-  virtual ~CoinAbsFltEq () {} 
-
-  //! Copy constructor
-
-  CoinAbsFltEq (const CoinAbsFltEq& src) : epsilon_(src.epsilon_) {} 
-
-  //! Assignment
-
-  CoinAbsFltEq& operator= (const CoinAbsFltEq& rhs)
-
-  { if (this != &rhs) epsilon_ = rhs.epsilon_ ;
-    return (*this) ; } 
-
-  //@}
-
-  private:  
-
-  /*! \name Private member data */
-  //@{
-
-  //! Equality tolerance.
-
-  double epsilon_ ;
-
-  //@}
-
-} ;
-
-
-
-/*! \brief Equality to a scaled tolerance
-
-  Operands are considered equal if their difference is within a scaled
-  epsilon calculated as epsilon_*(1+CoinMax(|f1|,|f2|)).
-*/
-
-class CoinRelFltEq
-{
-  public:
-
-  //! Compare function
-
-  inline bool operator() (const double f1, const double f2) const
-
-  { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ;
-    if (f1 == f2) return true ;
-    if (!CoinFinite(f1) || !CoinFinite(f2)) return false ;
-
-    double tol = (fabs(f1)>fabs(f2))?fabs(f1):fabs(f2) ;
-
-    return (fabs(f1-f2) <= epsilon_*(1+tol)) ; }
-
-  /*! \name Constructors and destructors */
-  //@{
-
-#ifndef COIN_FLOAT
-  /*! Default constructor
-
-    Default tolerance is 1.0e-10.
-  */
-  CoinRelFltEq () : epsilon_(1.e-10) {} 
-#else
-  /*! Default constructor
-
-    Default tolerance is 1.0e-6.
-  */
-  CoinRelFltEq () : epsilon_(1.e-6) {} ; // as float
-#endif
-
-  //! Alternate constructor with epsilon as a parameter
-
-  CoinRelFltEq (const double epsilon) : epsilon_(epsilon) {} 
-
-  //! Destructor
-
-  virtual ~CoinRelFltEq () {} 
-
-  //! Copy constructor
-
-  CoinRelFltEq (const CoinRelFltEq & src) : epsilon_(src.epsilon_) {} 
-
-  //! Assignment
-
-  CoinRelFltEq& operator= (const CoinRelFltEq& rhs)
-
-  { if (this != &rhs) epsilon_ = rhs.epsilon_ ;
-    return (*this) ; } 
-
-  //@}
-
-private: 
-
-  /*! \name Private member data */
-  //@{
-
-  //! Base equality tolerance
-
-  double epsilon_ ;
-
-  //@}
-
-} ;
-
-#endif

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

@@ -1,1111 +0,0 @@
-/* $Id: CoinHelperFunctions.hpp 1679 2013-12-05 11:27:45Z forrest $ */
-// 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 CoinHelperFunctions_H
-#define CoinHelperFunctions_H
-
-#include "CoinUtilsConfig.h"
-
-#if defined(_MSC_VER)
-#  include <direct.h>
-#  include <cctype>
-#  define getcwd _getcwd
-#  include <cctype>
-#else
-#  include <unistd.h>
-#endif
-//#define USE_MEMCPY
-
-#include <cstdlib>
-#include <cstdio>
-#include <algorithm>
-#include "CoinTypes.hpp"
-#include "CoinError.hpp"
-
-// Compilers can produce better code if they know about __restrict
-#ifndef COIN_RESTRICT
-#ifdef COIN_USE_RESTRICT
-#define COIN_RESTRICT __restrict
-#else
-#define COIN_RESTRICT
-#endif
-#endif
-
-//#############################################################################
-
-/** This helper function copies an array to another location using Duff's
-    device (for a speedup of ~2). The arrays are given by pointers to their
-    first entries and by the size of the source array. Overlapping arrays are
-    handled correctly. */
-
-template <class T> inline void
-CoinCopyN(register const T* from, const int size, register T* to)
-{
-    if (size == 0 || from == to)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("trying to copy negative number of entries",
-			"CoinCopyN", "");
-#endif
-
-    register int n = (size + 7) / 8;
-    if (to > from) {
-	register const T* downfrom = from + size;
-	register T* downto = to + size;
-	// Use Duff's device to copy
-	switch (size % 8) {
-	case 0: do{     *--downto = *--downfrom;
-	case 7:         *--downto = *--downfrom;
-	case 6:         *--downto = *--downfrom;
-	case 5:         *--downto = *--downfrom;
-	case 4:         *--downto = *--downfrom;
-	case 3:         *--downto = *--downfrom;
-	case 2:         *--downto = *--downfrom;
-	case 1:         *--downto = *--downfrom;
-	}while(--n>0);
-	}
-    } else {
-	// Use Duff's device to copy
-	--from;
-	--to;
-	switch (size % 8) {
-	case 0: do{     *++to = *++from;
-	case 7:         *++to = *++from;
-	case 6:         *++to = *++from;
-	case 5:         *++to = *++from;
-	case 4:         *++to = *++from;
-	case 3:         *++to = *++from;
-	case 2:         *++to = *++from;
-	case 1:         *++to = *++from;
-	}while(--n>0);
-	}
-    }
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function copies an array to another location using Duff's
-    device (for a speedup of ~2). The source array is given by its first and
-    "after last" entry; the target array is given by its first entry.
-    Overlapping arrays are handled correctly.
-
-    All of the various CoinCopyN variants use an int for size. On 64-bit
-    architectures, the address diff last-first will be a 64-bit quantity.
-    Given that everything else uses an int, I'm going to choose to kick
-    the difference down to int.  -- lh, 100823 --
-*/
-template <class T> inline void
-CoinCopy(register const T* first, register const T* last, register T* to)
-{
-    CoinCopyN(first, static_cast<int>(last-first), to);
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function copies an array to another location. The two arrays
-    must not overlap (otherwise an exception is thrown). For speed 8 entries
-    are copied at a time. The arrays are given by pointers to their first
-    entries and by the size of the source array. 
-
-    Note JJF - the speed claim seems to be false on IA32 so I have added 
-    CoinMemcpyN which can be used for atomic data */
-template <class T> inline void
-CoinDisjointCopyN(register const T* from, const int size, register T* to)
-{
-#ifndef _MSC_VER
-    if (size == 0 || from == to)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("trying to copy negative number of entries",
-			"CoinDisjointCopyN", "");
-#endif
-
-#if 0
-    /* There is no point to do this test. If to and from are from different
-       blocks then dist is undefined, so this can crash correct code. It's
-       better to trust the user that the arrays are really disjoint. */
-    const long dist = to - from;
-    if (-size < dist && dist < size)
-	throw CoinError("overlapping arrays", "CoinDisjointCopyN", "");
-#endif
-
-    for (register int n = size / 8; n > 0; --n, from += 8, to += 8) {
-	to[0] = from[0];
-	to[1] = from[1];
-	to[2] = from[2];
-	to[3] = from[3];
-	to[4] = from[4];
-	to[5] = from[5];
-	to[6] = from[6];
-	to[7] = from[7];
-    }
-    switch (size % 8) {
-    case 7: to[6] = from[6];
-    case 6: to[5] = from[5];
-    case 5: to[4] = from[4];
-    case 4: to[3] = from[3];
-    case 3: to[2] = from[2];
-    case 2: to[1] = from[1];
-    case 1: to[0] = from[0];
-    case 0: break;
-    }
-#else
-    CoinCopyN(from, size, to);
-#endif
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function copies an array to another location. The two arrays
-    must not overlap (otherwise an exception is thrown). For speed 8 entries
-    are copied at a time. The source array is given by its first and "after
-    last" entry; the target array is given by its first entry. */
-template <class T> inline void
-CoinDisjointCopy(register const T* first, register const T* last,
-		 register T* to)
-{
-    CoinDisjointCopyN(first, static_cast<int>(last - first), to);
-}
-
-//-----------------------------------------------------------------------------
-
-/*! \brief Return an array of length \p size filled with input from \p array,
-  or null if \p array is null.
-*/
-
-template <class T> inline T*
-CoinCopyOfArray( const T * array, const int size)
-{
-    if (array) {
-	T * arrayNew = new T[size];
-	std::memcpy(arrayNew,array,size*sizeof(T));
-	return arrayNew;
-    } else {
-	return NULL;
-    }
-}
-
-
-/*! \brief Return an array of length \p size filled with first copySize from \p array,
-  or null if \p array is null.
-*/
-
-template <class T> inline T*
-CoinCopyOfArrayPartial( const T * array, const int size,const int copySize)
-{
-    if (array||size) {
-	T * arrayNew = new T[size];
-	assert (copySize<=size);
-	std::memcpy(arrayNew,array,copySize*sizeof(T));
-	return arrayNew;
-    } else {
-	return NULL;
-    }
-}
-
-/*! \brief Return an array of length \p size filled with input from \p array,
-  or filled with (scalar) \p value if \p array is null
-*/
-
-template <class T> inline T*
-CoinCopyOfArray( const T * array, const int size, T value)
-{
-    T * arrayNew = new T[size];
-    if (array) {
-        std::memcpy(arrayNew,array,size*sizeof(T));
-    } else {
-	int i;
-	for (i=0;i<size;i++) 
-	    arrayNew[i] = value;
-    }
-    return arrayNew;
-}
-
-
-/*! \brief Return an array of length \p size filled with input from \p array,
-  or filled with zero if \p array is null
-*/
-
-template <class T> inline T*
-CoinCopyOfArrayOrZero( const T * array , const int size)
-{
-    T * arrayNew = new T[size];
-    if (array) {
-      std::memcpy(arrayNew,array,size*sizeof(T));
-    } else {
-      std::memset(arrayNew,0,size*sizeof(T));
-    }
-    return arrayNew;
-}
-
-
-//-----------------------------------------------------------------------------
-
-/** This helper function copies an array to another location. The two arrays
-    must not overlap (otherwise an exception is thrown). For speed 8 entries
-    are copied at a time. The arrays are given by pointers to their first
-    entries and by the size of the source array. 
-
-    Note JJF - the speed claim seems to be false on IA32 so I have added 
-    alternative coding if USE_MEMCPY defined*/
-#ifndef COIN_USE_RESTRICT
-template <class T> inline void
-CoinMemcpyN(register const T* from, const int size, register T* to)
-{
-#ifndef _MSC_VER
-#ifdef USE_MEMCPY
-    // Use memcpy - seems a lot faster on Intel with gcc
-#ifndef NDEBUG
-    // Some debug so check
-    if (size < 0)
-	throw CoinError("trying to copy negative number of entries",
-			"CoinMemcpyN", "");
-  
-#if 0
-    /* There is no point to do this test. If to and from are from different
-       blocks then dist is undefined, so this can crash correct code. It's
-       better to trust the user that the arrays are really disjoint. */
-    const long dist = to - from;
-    if (-size < dist && dist < size)
-	throw CoinError("overlapping arrays", "CoinMemcpyN", "");
-#endif
-#endif
-    std::memcpy(to,from,size*sizeof(T));
-#else
-    if (size == 0 || from == to)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("trying to copy negative number of entries",
-			"CoinMemcpyN", "");
-#endif
-
-#if 0
-    /* There is no point to do this test. If to and from are from different
-       blocks then dist is undefined, so this can crash correct code. It's
-       better to trust the user that the arrays are really disjoint. */
-    const long dist = to - from;
-    if (-size < dist && dist < size)
-	throw CoinError("overlapping arrays", "CoinMemcpyN", "");
-#endif
-
-    for (register int n = size / 8; n > 0; --n, from += 8, to += 8) {
-	to[0] = from[0];
-	to[1] = from[1];
-	to[2] = from[2];
-	to[3] = from[3];
-	to[4] = from[4];
-	to[5] = from[5];
-	to[6] = from[6];
-	to[7] = from[7];
-    }
-    switch (size % 8) {
-    case 7: to[6] = from[6];
-    case 6: to[5] = from[5];
-    case 5: to[4] = from[4];
-    case 4: to[3] = from[3];
-    case 3: to[2] = from[2];
-    case 2: to[1] = from[1];
-    case 1: to[0] = from[0];
-    case 0: break;
-    }
-#endif
-#else
-    CoinCopyN(from, size, to);
-#endif
-}
-#else
-template <class T> inline void
-CoinMemcpyN(const T * COIN_RESTRICT from, int size, T* COIN_RESTRICT to)
-{
-#ifdef USE_MEMCPY
-  std::memcpy(to,from,size*sizeof(T));
-#else
-  T * COIN_RESTRICT put =  to;
-  const T * COIN_RESTRICT get = from;
-  for ( ; 0<size ; --size)
-    *put++ = *get++;
-#endif
-}
-#endif
-
-//-----------------------------------------------------------------------------
-
-/** This helper function copies an array to another location. The two arrays
-    must not overlap (otherwise an exception is thrown). For speed 8 entries
-    are copied at a time. The source array is given by its first and "after
-    last" entry; the target array is given by its first entry. */
-template <class T> inline void
-CoinMemcpy(register const T* first, register const T* last,
-	   register T* to)
-{
-    CoinMemcpyN(first, static_cast<int>(last - first), to);
-}
-
-//#############################################################################
-
-/** This helper function fills an array with a given value. For speed 8 entries
-    are filled at a time. The array is given by a pointer to its first entry
-    and its size. 
-
-    Note JJF - the speed claim seems to be false on IA32 so I have added 
-    CoinZero to allow for memset. */
-template <class T> inline void
-CoinFillN(register T* to, const int size, register const T value)
-{
-    if (size == 0)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("trying to fill negative number of entries",
-			"CoinFillN", "");
-#endif
-#if 1
-    for (register int n = size / 8; n > 0; --n, to += 8) {
-	to[0] = value;
-	to[1] = value;
-	to[2] = value;
-	to[3] = value;
-	to[4] = value;
-	to[5] = value;
-	to[6] = value;
-	to[7] = value;
-    }
-    switch (size % 8) {
-    case 7: to[6] = value;
-    case 6: to[5] = value;
-    case 5: to[4] = value;
-    case 4: to[3] = value;
-    case 3: to[2] = value;
-    case 2: to[1] = value;
-    case 1: to[0] = value;
-    case 0: break;
-    }
-#else
-    // Use Duff's device to fill
-    register int n = (size + 7) / 8;
-    --to;
-    switch (size % 8) {
-    case 0: do{     *++to = value;
-    case 7:         *++to = value;
-    case 6:         *++to = value;
-    case 5:         *++to = value;
-    case 4:         *++to = value;
-    case 3:         *++to = value;
-    case 2:         *++to = value;
-    case 1:         *++to = value;
-    }while(--n>0);
-    }
-#endif
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function fills an array with a given value. For speed 8
-    entries are filled at a time. The array is given by its first and "after
-    last" entry. */
-template <class T> inline void
-CoinFill(register T* first, register T* last, const T value)
-{
-    CoinFillN(first, last - first, value);
-}
-
-//#############################################################################
-
-/** This helper function fills an array with zero. For speed 8 entries
-    are filled at a time. The array is given by a pointer to its first entry
-    and its size.
-
-    Note JJF - the speed claim seems to be false on IA32 so I have allowed 
-    for memset as an alternative */
-template <class T> inline void
-CoinZeroN(register T* to, const int size)
-{
-#ifdef USE_MEMCPY
-    // Use memset - seems faster on Intel with gcc
-#ifndef NDEBUG
-    // Some debug so check
-    if (size < 0)
-	throw CoinError("trying to fill negative number of entries",
-			"CoinZeroN", "");
-#endif
-    memset(to,0,size*sizeof(T));
-#else
-    if (size == 0)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("trying to fill negative number of entries",
-			"CoinZeroN", "");
-#endif
-#if 1
-    for (register int n = size / 8; n > 0; --n, to += 8) {
-	to[0] = 0;
-	to[1] = 0;
-	to[2] = 0;
-	to[3] = 0;
-	to[4] = 0;
-	to[5] = 0;
-	to[6] = 0;
-	to[7] = 0;
-    }
-    switch (size % 8) {
-    case 7: to[6] = 0;
-    case 6: to[5] = 0;
-    case 5: to[4] = 0;
-    case 4: to[3] = 0;
-    case 3: to[2] = 0;
-    case 2: to[1] = 0;
-    case 1: to[0] = 0;
-    case 0: break;
-    }
-#else
-    // Use Duff's device to fill
-    register int n = (size + 7) / 8;
-    --to;
-    switch (size % 8) {
-    case 0: do{     *++to = 0;
-    case 7:         *++to = 0;
-    case 6:         *++to = 0;
-    case 5:         *++to = 0;
-    case 4:         *++to = 0;
-    case 3:         *++to = 0;
-    case 2:         *++to = 0;
-    case 1:         *++to = 0;
-    }while(--n>0);
-    }
-#endif
-#endif
-}
-/// This Debug helper function checks an array is all zero
-inline void
-CoinCheckDoubleZero(double * to, const int size)
-{
-    int n=0;
-    for (int j=0;j<size;j++) {
-	if (to[j]) 
-	    n++;
-    }
-    if (n) {
-	printf("array of length %d should be zero has %d nonzero\n",size,n);
-    }
-}
-/// This Debug helper function checks an array is all zero
-inline void
-CoinCheckIntZero(int * to, const int size)
-{
-    int n=0;
-    for (int j=0;j<size;j++) {
-	if (to[j]) 
-	    n++;
-    }
-    if (n) {
-	printf("array of length %d should be zero has %d nonzero\n",size,n);
-    }
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function fills an array with a given value. For speed 8
-    entries are filled at a time. The array is given by its first and "after
-    last" entry. */
-template <class T> inline void
-CoinZero(register T* first, register T* last)
-{
-    CoinZeroN(first, last - first);
-}
-
-//#############################################################################
-
-/** Returns strdup or NULL if original NULL */
-inline char * CoinStrdup(const char * name)
-{
-  char* dup = NULL;
-  if (name) {
-    const int len = static_cast<int>(strlen(name));
-    dup = static_cast<char*>(malloc(len+1));
-    CoinMemcpyN(name, len, dup);
-    dup[len] = 0;
-  }
-  return dup;
-}
-
-//#############################################################################
-
-/** Return the larger (according to <code>operator<()</code> of the arguments.
-    This function was introduced because for some reason compiler tend to
-    handle the <code>max()</code> function differently. */
-template <class T> inline T
-CoinMax(register const T x1, register const T x2)
-{
-    return (x1 > x2) ? x1 : x2;
-}
-
-//-----------------------------------------------------------------------------
-
-/** Return the smaller (according to <code>operator<()</code> of the arguments.
-    This function was introduced because for some reason compiler tend to
-    handle the min() function differently. */
-template <class T> inline T
-CoinMin(register const T x1, register const T x2)
-{
-    return (x1 < x2) ? x1 : x2;
-}
-
-//-----------------------------------------------------------------------------
-
-/** Return the absolute value of the argument. This function was introduced
-    because for some reason compiler tend to handle the abs() function
-    differently. */
-template <class T> inline T
-CoinAbs(const T value)
-{
-    return value<0 ? -value : value;
-}
-
-//#############################################################################
-
-/** This helper function tests whether the entries of an array are sorted
-    according to operator<. The array is given by a pointer to its first entry
-    and by its size. */
-template <class T> inline bool
-CoinIsSorted(register const T* first, const int size)
-{
-    if (size == 0)
-	return true;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("negative number of entries", "CoinIsSorted", "");
-#endif
-#if 1
-    // size1 is the number of comparisons to be made
-    const int size1 = size  - 1;
-    for (register int n = size1 / 8; n > 0; --n, first += 8) {
-	if (first[8] < first[7]) return false;
-	if (first[7] < first[6]) return false;
-	if (first[6] < first[5]) return false;
-	if (first[5] < first[4]) return false;
-	if (first[4] < first[3]) return false;
-	if (first[3] < first[2]) return false;
-	if (first[2] < first[1]) return false;
-	if (first[1] < first[0]) return false;
-    }
-
-    switch (size1 % 8) {
-    case 7: if (first[7] < first[6]) return false;
-    case 6: if (first[6] < first[5]) return false;
-    case 5: if (first[5] < first[4]) return false;
-    case 4: if (first[4] < first[3]) return false;
-    case 3: if (first[3] < first[2]) return false;
-    case 2: if (first[2] < first[1]) return false;
-    case 1: if (first[1] < first[0]) return false;
-    case 0: break;
-    }
-#else
-    register const T* next = first;
-    register const T* last = first + size;
-    for (++next; next != last; first = next, ++next)
-	if (*next < *first)
-	    return false;
-#endif   
-    return true;
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function tests whether the entries of an array are sorted
-    according to operator<. The array is given by its first and "after
-    last" entry. */
-template <class T> inline bool
-CoinIsSorted(register const T* first, register const T* last)
-{
-    return CoinIsSorted(first, static_cast<int>(last - first));
-}
-
-//#############################################################################
-
-/** This helper function fills an array with the values init, init+1, init+2,
-    etc. For speed 8 entries are filled at a time. The array is given by a
-    pointer to its first entry and its size. */
-template <class T> inline void
-CoinIotaN(register T* first, const int size, register T init)
-{
-    if (size == 0)
-	return;
-
-#ifndef NDEBUG
-    if (size < 0)
-	throw CoinError("negative number of entries", "CoinIotaN", "");
-#endif
-#if 1
-    for (register int n = size / 8; n > 0; --n, first += 8, init += 8) {
-	first[0] = init;
-	first[1] = init + 1;
-	first[2] = init + 2;
-	first[3] = init + 3;
-	first[4] = init + 4;
-	first[5] = init + 5;
-	first[6] = init + 6;
-	first[7] = init + 7;
-    }
-    switch (size % 8) {
-    case 7: first[6] = init + 6;
-    case 6: first[5] = init + 5;
-    case 5: first[4] = init + 4;
-    case 4: first[3] = init + 3;
-    case 3: first[2] = init + 2;
-    case 2: first[1] = init + 1;
-    case 1: first[0] = init;
-    case 0: break;
-    }
-#else
-    // Use Duff's device to fill
-    register int n = (size + 7) / 8;
-    --first;
-    --init;
-    switch (size % 8) {
-    case 0: do{     *++first = ++init;
-    case 7:         *++first = ++init;
-    case 6:         *++first = ++init;
-    case 5:         *++first = ++init;
-    case 4:         *++first = ++init;
-    case 3:         *++first = ++init;
-    case 2:         *++first = ++init;
-    case 1:         *++first = ++init;
-    }while(--n>0);
-    }
-#endif
-}
-
-//-----------------------------------------------------------------------------
-
-/** This helper function fills an array with the values init, init+1, init+2,
-    etc. For speed 8 entries are filled at a time. The array is given by its
-    first and "after last" entry. */
-template <class T> inline void
-CoinIota(T* first, const T* last, T init)
-{
-    CoinIotaN(first, last-first, init);
-}
-
-//#############################################################################
-
-/** This helper function deletes certain entries from an array. The array is
-    given by pointers to its first and "after last" entry (first two
-    arguments). The positions of the entries to be deleted are given in the
-    integer array specified by the last two arguments (again, first and "after
-    last" entry). */
-template <class T> inline T *
-CoinDeleteEntriesFromArray(register T * arrayFirst, register T * arrayLast,
-			   const int * firstDelPos, const int * lastDelPos)
-{
-    int delNum = static_cast<int>(lastDelPos - firstDelPos);
-    if (delNum == 0)
-	return arrayLast;
-
-    if (delNum < 0)
-	throw CoinError("trying to delete negative number of entries",
-			"CoinDeleteEntriesFromArray", "");
-
-    int * delSortedPos = NULL;
-    if (! (CoinIsSorted(firstDelPos, lastDelPos) &&
-	   std::adjacent_find(firstDelPos, lastDelPos) == lastDelPos)) {
-	// the positions of the to be deleted is either not sorted or not unique
-	delSortedPos = new int[delNum];
-	CoinDisjointCopy(firstDelPos, lastDelPos, delSortedPos);
-	std::sort(delSortedPos, delSortedPos + delNum);
-	delNum = static_cast<int>(std::unique(delSortedPos,
-				  delSortedPos+delNum) - delSortedPos);
-    }
-    const int * delSorted = delSortedPos ? delSortedPos : firstDelPos;
-
-    const int last = delNum - 1;
-    int size = delSorted[0];
-    for (int i = 0; i < last; ++i) {
-	const int copyFirst = delSorted[i] + 1;
-	const int copyLast = delSorted[i+1];
-	CoinCopy(arrayFirst + copyFirst, arrayFirst + copyLast,
-		 arrayFirst + size);
-	size += copyLast - copyFirst;
-    }
-    const int copyFirst = delSorted[last] + 1;
-    const int copyLast = static_cast<int>(arrayLast - arrayFirst);
-    CoinCopy(arrayFirst + copyFirst, arrayFirst + copyLast,
-	     arrayFirst + size);
-    size += copyLast - copyFirst;
-
-    if (delSortedPos)
-	delete[] delSortedPos;
-
-    return arrayFirst + size;
-}
-
-//#############################################################################
-
-#define COIN_OWN_RANDOM_32
-
-#if defined COIN_OWN_RANDOM_32
-/* Thanks to Stefano Gliozzi for providing an operating system
-   independent random number generator.  */
-
-/*! \brief Return a random number between 0 and 1
-
-  A platform-independent linear congruential generator. For a given seed, the
-  generated sequence is always the same regardless of the (32-bit)
-  architecture. This allows to build & test in different environments, getting
-  in most cases the same optimization path.
-
-  Set \p isSeed to true and supply an integer seed to set the seed
-  (vid. #CoinSeedRandom)
-
-  \todo Anyone want to volunteer an upgrade for 64-bit architectures?
-*/
-inline double CoinDrand48 (bool isSeed = false, unsigned int seed = 1)
-{
-  static unsigned int last = 123456;
-  if (isSeed) { 
-    last = seed;
-  } else {
-    last = 1664525*last+1013904223;
-    return ((static_cast<double> (last))/4294967296.0);
-  }
-  return (0.0);
-}
-
-/// Set the seed for the random number generator
-inline void CoinSeedRandom(int iseed)
-{
-  CoinDrand48(true, iseed);
-}
-
-#else // COIN_OWN_RANDOM_32
-
-#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN32__)
-
-/// Return a random number between 0 and 1
-inline double CoinDrand48() { return rand() / (double) RAND_MAX; }
-/// Set the seed for the random number generator
-inline void CoinSeedRandom(int iseed) { srand(iseed + 69822); }
-
-#else
-
-/// Return a random number between 0 and 1
-inline double CoinDrand48() { return drand48(); }
-/// Set the seed for the random number generator
-inline void CoinSeedRandom(int iseed) { srand48(iseed + 69822); }
-
-#endif
-
-#endif // COIN_OWN_RANDOM_32
-
-//#############################################################################
-
-/** This function figures out whether file names should contain slashes or 
-    backslashes as directory separator */
-inline char CoinFindDirSeparator()
-{
-    int size = 1000;
-    char* buf = 0;
-    while (true) {
-	buf = new char[size];
-	if (getcwd(buf, size))
-	    break;
-	delete[] buf;
-	buf = 0;
-	size = 2*size;
-    }
-    // if first char is '/' then it's unix and the dirsep is '/'. otherwise we 
-    // assume it's dos and the dirsep is '\'
-    char dirsep = buf[0] == '/' ? '/' : '\\';
-    delete[] buf;
-    return dirsep;
-}
-//#############################################################################
-
-inline int CoinStrNCaseCmp(const char* s0, const char* s1,
-			   const size_t len)
-{
-    for (size_t i = 0; i < len; ++i) {
-	if (s0[i] == 0) {
-	    return s1[i] == 0 ? 0 : -1;
-	}
-	if (s1[i] == 0) {
-	    return 1;
-	}
-	const int c0 = std::tolower(s0[i]);
-	const int c1 = std::tolower(s1[i]);
-	if (c0 < c1)
-	    return -1;
-	if (c0 > c1)
-	    return 1;
-    }
-    return 0;
-}
-
-//#############################################################################
-
-/// Swap the arguments.
-template <class T> inline void CoinSwap (T &x, T &y)
-{
-    T t = x;
-    x = y;
-    y = t;
-}
-
-//#############################################################################
-
-/** This helper function copies an array to file 
-    Returns 0 if OK, 1 if bad write.
-*/
-
-template <class T> inline int
-CoinToFile( const T* array, CoinBigIndex size, FILE * fp)
-{
-    CoinBigIndex numberWritten;
-    if (array&&size) {
-	numberWritten =
-	    static_cast<CoinBigIndex>(fwrite(&size,sizeof(int),1,fp));
-	if (numberWritten!=1)
-	    return 1;
-	numberWritten =
-	    static_cast<CoinBigIndex>(fwrite(array,sizeof(T),size_t(size),fp));
-	if (numberWritten!=size)
-	    return 1;
-    } else {
-	size = 0;
-	numberWritten = 
-	    static_cast<CoinBigIndex>(fwrite(&size,sizeof(int),1,fp));
-	if (numberWritten!=1)
-	    return 1;
-    }
-    return 0;
-}
-
-//#############################################################################
-
-/** This helper function copies an array from file and creates with new.
-    Passed in array is ignored i.e. not deleted.
-    But if NULL and size does not match and newSize 0 then leaves as NULL and 0
-    Returns 0 if OK, 1 if bad read, 2 if size did not match.
-*/
-
-template <class T> inline int
-CoinFromFile( T* &array, CoinBigIndex size, FILE * fp, CoinBigIndex & newSize)
-{
-    CoinBigIndex numberRead;
-    numberRead =
-        static_cast<CoinBigIndex>(fread(&newSize,sizeof(int),1,fp));
-    if (numberRead!=1)
-	return 1;
-    int returnCode=0;
-    if (size!=newSize&&(newSize||array))
-	returnCode=2;
-    if (newSize) {
-	array = new T [newSize];
-	numberRead =
-	    static_cast<CoinBigIndex>(fread(array,sizeof(T),newSize,fp));
-	if (numberRead!=newSize)
-	    returnCode=1;
-    } else {
-	array = NULL;
-    }
-    return returnCode;
-}
-
-//#############################################################################
-
-/// Cube Root
-#if 0
-inline double CoinCbrt(double x)
-{
-#if defined(_MSC_VER) 
-    return pow(x,(1./3.));
-#else
-    return cbrt(x);
-#endif
-}
-#endif
-
-//-----------------------------------------------------------------------------
-
-/// This helper returns "sizeof" as an int 
-#define CoinSizeofAsInt(type) (static_cast<int>(sizeof(type)))
-/// This helper returns "strlen" as an int 
-inline int
-CoinStrlenAsInt(const char * string)
-{
-    return static_cast<int>(strlen(string));
-}
-
-/** Class for thread specific random numbers
-*/
-#if defined COIN_OWN_RANDOM_32
-class CoinThreadRandom  {
-public:
-  /**@name Constructors, destructor */
-
-  //@{
-  /** Default constructor. */
-  CoinThreadRandom()
-  { seed_=12345678;}
-  /** Constructor wih seed. */
-  CoinThreadRandom(int seed)
-  { 
-    seed_ = seed;
-  }
-  /** Destructor */
-  ~CoinThreadRandom() {}
-  // Copy
-  CoinThreadRandom(const CoinThreadRandom & rhs)
-  { seed_ = rhs.seed_;}
-  // Assignment
-  CoinThreadRandom& operator=(const CoinThreadRandom & rhs)
-  {
-    if (this != &rhs) {
-      seed_ = rhs.seed_;
-    }
-    return *this;
-  }
-
-  //@}
-  
-  /**@name Sets/gets */
-
-  //@{
-  /** Set seed. */
-  inline void setSeed(int seed)
-  { 
-    seed_ = seed;
-  }
-  /** Get seed. */
-  inline unsigned int getSeed() const
-  { 
-    return seed_;
-  }
-  /// return a random number
-  inline double randomDouble() const
-  {
-    double retVal;
-    seed_ = 1664525*(seed_)+1013904223;
-    retVal = ((static_cast<double> (seed_))/4294967296.0);
-    return retVal;
-  }
-  /// make more random (i.e. for startup)
-  inline void randomize(int n=0)
-  {
-    if (!n) 
-      n=seed_ & 255;
-    for (int i=0;i<n;i++)
-      randomDouble();
-  }
-  //@}
-  
-  
-protected:
-  /**@name Data members
-     The data members are protected to allow access for derived classes. */
-  //@{
-  /// Current seed
-  mutable unsigned int seed_;
-  //@}
-};
-#else
-class CoinThreadRandom  {
-public:
-  /**@name Constructors, destructor */
-
-  //@{
-  /** Default constructor. */
-  CoinThreadRandom()
-  { seed_[0]=50000;seed_[1]=40000;seed_[2]=30000;}
-  /** Constructor wih seed. */
-  CoinThreadRandom(const unsigned short seed[3])
-  { memcpy(seed_,seed,3*sizeof(unsigned short));}
-  /** Constructor wih seed. */
-  CoinThreadRandom(int seed)
-  { 
-    union { int i[2]; unsigned short int s[4];} put;
-    put.i[0]=seed;
-    put.i[1]=seed;
-    memcpy(seed_,put.s,3*sizeof(unsigned short));
-  }
-  /** Destructor */
-  ~CoinThreadRandom() {}
-  // Copy
-  CoinThreadRandom(const CoinThreadRandom & rhs)
-  { memcpy(seed_,rhs.seed_,3*sizeof(unsigned short));}
-  // Assignment
-  CoinThreadRandom& operator=(const CoinThreadRandom & rhs)
-  {
-    if (this != &rhs) {
-      memcpy(seed_,rhs.seed_,3*sizeof(unsigned short));
-    }
-    return *this;
-  }
-
-  //@}
-  
-  /**@name Sets/gets */
-
-  //@{
-  /** Set seed. */
-  inline void setSeed(const unsigned short seed[3])
-  { memcpy(seed_,seed,3*sizeof(unsigned short));}
-  /** Set seed. */
-  inline void setSeed(int seed)
-  { 
-    union { int i[2]; unsigned short int s[4];} put;
-    put.i[0]=seed;
-    put.i[1]=seed;
-    memcpy(seed_,put.s,3*sizeof(unsigned short));
-  }
-  /// return a random number
-  inline double randomDouble() const
-  {
-    double retVal;
-#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN32__)
-    retVal=rand();
-    retVal=retVal/(double) RAND_MAX;
-#else
-    retVal = erand48(seed_);
-#endif
-    return retVal;
-  }
-  /// make more random (i.e. for startup)
-  inline void randomize(int n=0)
-  {
-    if (!n) {
-      n=seed_[0]+seed_[1]+seed_[2];
-      n &= 255;
-    }
-    for (int i=0;i<n;i++)
-      randomDouble();
-  }
-  //@}
-  
-  
-protected:
-  /**@name Data members
-     The data members are protected to allow access for derived classes. */
-  //@{
-  /// Current seed
-  mutable unsigned short seed_[3];
-  //@}
-};
-#endif
-#ifndef COIN_DETAIL
-#define COIN_DETAIL_PRINT(s) {}
-#else
-#define COIN_DETAIL_PRINT(s) s
-#endif
-#endif