ruby-cbc 0.1.9

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

@@ -0,0 +1,247 @@
+/* $Id: CoinStructuredModel.hpp 1691 2014-03-19 12:43:56Z forrest $ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinStructuredModel_H
+#define CoinStructuredModel_H
+
+#include "CoinModel.hpp"
+#include <vector>
+
+/** 
+    This is a model which is made up of Coin(Structured)Model blocks.
+*/
+  typedef struct CoinModelInfo2 {
+    int rowBlock; // Which row block
+    int columnBlock; // Which column block
+    char matrix; // nonzero if matrix exists
+    char rhs; // nonzero if non default rhs exists
+    char rowName; // nonzero if row names exists
+    char integer; // nonzero if integer information exists
+    char bounds; // nonzero if non default bounds/objective exists
+    char columnName; // nonzero if column names exists
+    CoinModelInfo2() : 
+      rowBlock(0),
+      columnBlock(0),
+      matrix(0),
+      rhs(0),
+      rowName(0),
+      integer(0),
+      bounds(0),
+      columnName(0)
+    {}
+} CoinModelBlockInfo;
+
+class CoinStructuredModel : public CoinBaseModel {
+  
+public:
+  /**@name Useful methods for building model */
+  //@{
+  /** add a block from a CoinModel using names given as parameters 
+      returns number of errors (e.g. both have objectives but not same)
+   */
+  int addBlock(const std::string & rowBlock,
+		const std::string & columnBlock,
+		const CoinBaseModel & block);
+  /** add a block from a CoinModel with names in model
+      returns number of errors (e.g. both have objectives but not same)
+ */
+  int addBlock(const CoinBaseModel & block);
+  /** add a block from a CoinModel using names given as parameters 
+      returns number of errors (e.g. both have objectives but not same)
+      This passes in block - structured model takes ownership
+   */
+  int addBlock(const std::string & rowBlock,
+		const std::string & columnBlock,
+		CoinBaseModel * block);
+  /** add a block using names 
+   */
+  int addBlock(const std::string & rowBlock,
+	       const std::string & columnBlock,
+	       const CoinPackedMatrix & matrix,
+	       const double * rowLower, const double * rowUpper,
+	       const double * columnLower, const double * columnUpper,
+	       const double * objective);
+
+  /** Write the problem in MPS format to a file with the given filename.
+      
+  \param compression can be set to three values to indicate what kind
+  of file should be written
+  <ul>
+  <li> 0: plain text (default)
+  <li> 1: gzip compressed (.gz is appended to \c filename)
+  <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO)
+  </ul>
+  If the library was not compiled with the requested compression then
+  writeMps falls back to writing a plain text file.
+  
+  \param formatType specifies the precision to used for values in the
+  MPS file
+  <ul>
+  <li> 0: normal precision (default)
+  <li> 1: extra accuracy
+  <li> 2: IEEE hex
+  </ul>
+  
+  \param numberAcross specifies whether 1 or 2 (default) values should be
+  specified on every data line in the MPS file.
+  
+  not const as may change model e.g. fill in default bounds
+  */
+  int writeMps(const char *filename, int compression = 0,
+               int formatType = 0, int numberAcross = 2, bool keepStrings=false) ;
+  /// Read SMPS model
+  int readSmps(const char *filename,
+                 bool keepNames = false,
+                 bool ignoreErrors = false);
+
+  /** Decompose a CoinModel
+      1 - try D-W
+      2 - try Benders
+      3 - try Staircase
+      Returns number of blocks or zero if no structure
+  */
+  int decompose(const CoinModel &model,int type,
+		int maxBlocks=50, const char ** starts=NULL);
+  /** Decompose a model specified as arrays + CoinPackedMatrix
+      1 - try D-W
+      2 - try Benders
+      3 - try Staircase
+      Returns number of blocks or zero if no structure
+  */
+  int decompose(const CoinPackedMatrix & matrix,
+		const double * rowLower, const double * rowUpper,
+		const double * columnLower, const double * columnUpper,
+		const double * objective, int type,int maxBlocks=50,
+		int * starts=NULL,
+		double objectiveOffset=0.0);
+  
+   //@}
+
+
+  /**@name For getting information */
+   //@{
+   /// Return number of row blocks
+  inline int numberRowBlocks() const
+  { return numberRowBlocks_;}
+   /// Return number of column blocks
+  inline int numberColumnBlocks() const
+  { return numberColumnBlocks_;}
+   /// Return number of elementBlocks
+  inline CoinBigIndex numberElementBlocks() const
+  { return numberElementBlocks_;}
+   /// Return number of elements
+  CoinBigIndex numberElements() const;
+  /// Return the i'th row block name
+  inline const std::string & getRowBlock(int i) const
+  { return rowBlockNames_[i];}
+  /// Set i'th row block name
+  inline void setRowBlock(int i,const std::string &name) 
+  { rowBlockNames_[i] = name;}
+  /// Add or check a row block name and number of rows
+  int addRowBlock(int numberRows,const std::string &name) ;
+  /// Return a row block index given a row block name
+  int rowBlock(const std::string &name) const;
+  /// Return i'th the column block name
+  inline const std::string & getColumnBlock(int i) const
+  { return columnBlockNames_[i];}
+  /// Set i'th column block name
+  inline void setColumnBlock(int i,const std::string &name) 
+  { columnBlockNames_[i] = name;}
+  /// Add or check a column block name and number of columns
+  int addColumnBlock(int numberColumns,const std::string &name) ;
+  /// Return a column block index given a column block name
+  int columnBlock(const std::string &name) const;
+  /// Return i'th block type
+  inline const CoinModelBlockInfo &  blockType(int i) const
+  { return blockType_[i];}
+  /// Return i'th block
+  inline CoinBaseModel * block(int i) const
+  { return blocks_[i];}
+  /// Return block corresponding to row and column
+  const CoinBaseModel *  block(int row,int column) const;
+  /// Return i'th block as CoinModel (or NULL)
+  CoinModel * coinBlock(int i) const;
+  /// Return block corresponding to row and column as CoinModel
+  const CoinBaseModel *  coinBlock(int row,int column) const;
+  /// Return block number corresponding to row and column
+  int  blockIndex(int row,int column) const;
+  /** Return model as a CoinModel block
+      and fill in info structure and update counts
+      */
+  CoinModel * coinModelBlock(CoinModelBlockInfo & info) ;
+  /// Sets given block into coinModelBlocks_
+  void setCoinModel(CoinModel * block, int iBlock);
+  /// Refresh info in blockType_
+  void refresh(int iBlock);
+  /** Fill pointers corresponding to row and column */
+
+  CoinModelBlockInfo block(int row,int column,
+	     const double * & rowLower, const double * & rowUpper,
+	     const double * & columnLower, const double * & columnUpper,
+	     const double * & objective) const;
+  /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline double optimizationDirection() const {
+    return  optimizationDirection_;
+  }
+  /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline void setOptimizationDirection(double value)
+  { optimizationDirection_=value;}
+   //@}
+
+  /**@name Constructors, destructor */
+   //@{
+   /** Default constructor. */
+  CoinStructuredModel();
+  /** Read a problem in MPS format from the given filename.
+      May try and decompose
+   */
+  CoinStructuredModel(const char *fileName,int decompose=0,
+		      int maxBlocks=50);
+   /** Destructor */
+   virtual ~CoinStructuredModel();
+   //@}
+
+   /**@name Copy method */
+   //@{
+   /** The copy constructor. */
+   CoinStructuredModel(const CoinStructuredModel&);
+  /// =
+   CoinStructuredModel& operator=(const CoinStructuredModel&);
+  /// Clone
+  virtual CoinBaseModel * clone() const;
+   //@}
+
+private:
+
+  /** Fill in info structure and update counts
+      Returns number of inconsistencies on border
+  */
+  int fillInfo(CoinModelBlockInfo & info,const CoinModel * block);
+  /** Fill in info structure and update counts
+  */
+  void fillInfo(CoinModelBlockInfo & info,const CoinStructuredModel * block);
+  /**@name Data members */
+   //@{
+  /// Current number of row blocks
+  int numberRowBlocks_;
+  /// Current number of column blocks
+  int numberColumnBlocks_;
+  /// Current number of element blocks
+  int numberElementBlocks_;
+  /// Maximum number of element blocks
+  int maximumElementBlocks_;
+  /// Rowblock name
+  std::vector<std::string> rowBlockNames_;
+  /// Columnblock name
+  std::vector<std::string> columnBlockNames_;
+  /// Blocks
+  CoinBaseModel ** blocks_;
+  /// CoinModel copies of blocks or NULL if original CoinModel
+  CoinModel ** coinModelBlocks_;
+  /// Which parts of model are set in block
+  CoinModelBlockInfo * blockType_;
+   //@}
+};
+#endif

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

@@ -0,0 +1,310 @@
+/* $Id: CoinTime.hpp 1372 2011-01-03 23:31:00Z lou $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _CoinTime_hpp
+#define _CoinTime_hpp
+
+// Uncomment the next three lines for thorough memory initialisation.
+// #ifndef ZEROFAULT
+// # define ZEROFAULT
+// #endif
+
+//#############################################################################
+
+#include <ctime>
+#if defined(_MSC_VER)
+// Turn off compiler warning about long names
+#  pragma warning(disable:4786)
+#else
+// MacOS-X and FreeBSD needs sys/time.h
+#if defined(__MACH__) || defined (__FreeBSD__)
+#include <sys/time.h>
+#endif
+#if !defined(__MSVCRT__)
+#include <sys/resource.h>
+#endif
+#endif
+
+//#############################################################################
+
+#if defined(_MSC_VER)
+
+#if 0 // change this to 1 if want to use the win32 API
+#include <windows.h>
+#ifdef small
+/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a
+   '#define small char' */
+#undef small
+#endif
+#define TWO_TO_THE_THIRTYTWO 4294967296.0
+#define DELTA_EPOCH_IN_SECS  11644473600.0
+inline double CoinGetTimeOfDay()
+{
+  FILETIME ft;
+ 
+  GetSystemTimeAsFileTime(&ft);
+  double t = ft.dwHighDateTime * TWO_TO_THE_THIRTYTWO + ft.dwLowDateTime;
+  t = t/10000000.0 - DELTA_EPOCH_IN_SECS;
+  return t;
+}
+#else
+#include <sys/types.h>
+#include <sys/timeb.h>
+inline double CoinGetTimeOfDay()
+{
+  struct _timeb timebuffer;
+#pragma warning(disable:4996)
+  _ftime( &timebuffer ); // C4996
+#pragma warning(default:4996)
+  return timebuffer.time + timebuffer.millitm/1000.0;
+}
+#endif
+
+#else
+
+#include <sys/time.h>
+
+inline double CoinGetTimeOfDay()
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return static_cast<double>(tv.tv_sec) + static_cast<int>(tv.tv_usec)/1000000.0;
+}
+
+#endif // _MSC_VER
+
+/**
+   Query the elapsed wallclock time since the first call to this function. If
+   a positive argument is passed to the function then the time of the first
+   call is set to that value (this kind of argument is allowed only at the
+   first call!). If a negative argument is passed to the function then it
+   returns the time when it was set.
+*/
+
+inline double CoinWallclockTime(double callType = 0)
+{
+    double callTime = CoinGetTimeOfDay();
+    static const double firstCall = callType > 0 ? callType : callTime;
+    return callType < 0 ? firstCall : callTime - firstCall;
+}
+
+//#############################################################################
+
+//#define HAVE_SDK // if SDK under Win32 is installed, for CPU instead of elapsed time under Win 
+#ifdef HAVE_SDK
+#include <windows.h>
+#ifdef small
+/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a
+   '#define small char' */
+#undef small
+#endif
+#define TWO_TO_THE_THIRTYTWO 4294967296.0
+#endif
+
+static inline double CoinCpuTime()
+{
+  double cpu_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+#ifdef HAVE_SDK
+  FILETIME creation;
+  FILETIME exit;
+  FILETIME kernel;
+  FILETIME user;
+  GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user);
+  double t = user.dwHighDateTime * TWO_TO_THE_THIRTYTWO + user.dwLowDateTime;
+  return t/10000000.0;
+#else
+  unsigned int ticksnow;        /* clock_t is same as int */
+  ticksnow = (unsigned int)clock();
+  cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC);
+#endif
+
+#else
+  struct rusage usage;
+# ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0 ;
+  usage.ru_utime.tv_usec = 0 ;
+# endif
+  getrusage(RUSAGE_SELF,&usage);
+  cpu_temp = static_cast<double>(usage.ru_utime.tv_sec);
+  cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec));
+#endif
+  return cpu_temp;
+}
+
+//#############################################################################
+
+
+
+static inline double CoinSysTime()
+{
+  double sys_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+  sys_temp = 0.0;
+#else
+  struct rusage usage;
+# ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0 ;
+  usage.ru_utime.tv_usec = 0 ;
+# endif
+  getrusage(RUSAGE_SELF,&usage);
+  sys_temp = static_cast<double>(usage.ru_stime.tv_sec);
+  sys_temp += 1.0e-6*(static_cast<double> (usage.ru_stime.tv_usec));
+#endif
+  return sys_temp;
+}
+
+//#############################################################################
+// On most systems SELF seems to include children threads, This is for when it doesn't
+static inline double CoinCpuTimeJustChildren()
+{
+  double cpu_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+  cpu_temp = 0.0;
+#else
+  struct rusage usage;
+# ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0 ;
+  usage.ru_utime.tv_usec = 0 ;
+# endif
+  getrusage(RUSAGE_CHILDREN,&usage);
+  cpu_temp = static_cast<double>(usage.ru_utime.tv_sec);
+  cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec));
+#endif
+  return cpu_temp;
+}
+//#############################################################################
+
+#include <fstream>
+
+/**
+ This class implements a timer that also implements a tracing functionality.
+
+ The timer stores the start time of the timer, for how much time it was set to
+ and when does it expire (start + limit = end). Queries can be made that tell
+ whether the timer is expired, is past an absolute time, is past a percentage
+ of the length of the timer. All times are given in seconds, but as double
+ numbers, so there can be fractional values.
+
+ The timer can also be initialized with a stream and a specification whether
+ to write to or read from the stream. In the former case the result of every
+ query is written into the stream, in the latter case timing is not tested at
+ all, rather the supposed result is read out from the stream. This makes it
+ possible to exactly retrace time sensitive program execution.
+*/
+class CoinTimer
+{
+private:
+   /// When the timer was initialized/reset/restarted
+   double start;
+   /// 
+   double limit;
+   double end;
+#ifdef COIN_COMPILE_WITH_TRACING
+   std::fstream* stream;
+   bool write_stream;
+#endif
+
+private:
+#ifdef COIN_COMPILE_WITH_TRACING
+   inline bool evaluate(bool b_tmp) const {
+      int i_tmp = b_tmp;
+      if (stream) {
+	 if (write_stream)
+	    (*stream) << i_tmp << "\n";
+	 else 
+	    (*stream) >> i_tmp;
+      }
+      return i_tmp;
+   }
+   inline double evaluate(double d_tmp) const {
+      if (stream) {
+	 if (write_stream)
+	    (*stream) << d_tmp << "\n";
+	 else 
+	    (*stream) >> d_tmp;
+      }
+      return d_tmp;
+   }
+#else
+   inline bool evaluate(const bool b_tmp) const {
+      return b_tmp;
+   }
+   inline double evaluate(const double d_tmp) const {
+      return d_tmp;
+   }
+#endif   
+
+public:
+   /// Default constructor creates a timer with no time limit and no tracing
+   CoinTimer() :
+      start(0), limit(1e100), end(1e100)
+#ifdef COIN_COMPILE_WITH_TRACING
+      , stream(0), write_stream(true)
+#endif
+   {}
+
+   /// Create a timer with the given time limit and with no tracing
+   CoinTimer(double lim) :
+      start(CoinCpuTime()), limit(lim), end(start+lim)
+#ifdef COIN_COMPILE_WITH_TRACING
+      , stream(0), write_stream(true)
+#endif
+   {}
+
+#ifdef COIN_COMPILE_WITH_TRACING
+   /** Create a timer with no time limit and with writing/reading the trace
+       to/from the given stream, depending on the argument \c write. */
+   CoinTimer(std::fstream* s, bool write) :
+      start(0), limit(1e100), end(1e100),
+      stream(s), write_stream(write) {}
+   
+   /** Create a timer with the given time limit and with writing/reading the
+       trace to/from the given stream, depending on the argument \c write. */
+   CoinTimer(double lim, std::fstream* s, bool w) :
+      start(CoinCpuTime()), limit(lim), end(start+lim),
+      stream(s), write_stream(w) {}
+#endif
+   
+   /// Restart the timer (keeping the same time limit)
+   inline void restart() { start=CoinCpuTime(); end=start+limit; }
+   /// An alternate name for \c restart()
+   inline void reset() { restart(); }
+   /// Reset (and restart) the timer and change its time limit
+   inline void reset(double lim) { limit=lim; restart(); }
+
+   /** Return whether the given percentage of the time limit has elapsed since
+       the timer was started */
+   inline bool isPastPercent(double pct) const {
+      return evaluate(start + limit * pct < CoinCpuTime());
+   }
+   /** Return whether the given amount of time has elapsed since the timer was
+       started */
+   inline bool isPast(double lim) const {
+      return evaluate(start + lim < CoinCpuTime());
+   }
+   /** Return whether the originally specified time limit has passed since the
+       timer was started */
+   inline bool isExpired() const {
+      return evaluate(end < CoinCpuTime());
+   }
+
+   /** Return how much time is left on the timer */
+   inline double timeLeft() const {
+      return evaluate(end - CoinCpuTime());
+   }
+
+   /** Return how much time has elapsed */
+   inline double timeElapsed() const {
+      return evaluate(CoinCpuTime() - start);
+   }
+
+   inline void setLimit(double l) {
+      limit = l;
+      return;
+   }
+};
+
+#endif

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

@@ -0,0 +1,64 @@
+/* $Id: CoinTypes.hpp 1762 2014-12-29 20:37:12Z tkr $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _CoinTypes_hpp
+#define _CoinTypes_hpp
+
+#include "CoinUtilsConfig.h"
+/* On some systems, we require stdint.h to have the 64bit integer type defined. */
+#ifdef COINUTILS_HAS_STDINT_H
+#include <stdint.h>
+#endif
+#ifdef COINUTILS_HAS_CSTDINT
+#include <cstdint>
+#endif
+
+#define CoinInt64 COIN_INT64_T
+#define CoinUInt64 COIN_UINT64_T
+#define CoinIntPtr COIN_INTPTR_T
+
+//=============================================================================
+#ifndef COIN_BIG_INDEX
+#define COIN_BIG_INDEX 0
+#endif
+
+#if COIN_BIG_INDEX==0
+typedef int CoinBigIndex;
+#elif COIN_BIG_INDEX==1
+typedef long CoinBigIndex;
+#else
+typedef long long CoinBigIndex;
+#endif
+
+//=============================================================================
+#ifndef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 0
+#endif
+
+// See if we want the ability to have long double work arrays
+#if COIN_BIG_DOUBLE==2
+#undef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 0
+#define COIN_LONG_WORK 1
+typedef long double CoinWorkDouble;
+#elif COIN_BIG_DOUBLE==3
+#undef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 1
+#define COIN_LONG_WORK 1
+typedef long double CoinWorkDouble;
+#else
+#define COIN_LONG_WORK 0
+typedef double CoinWorkDouble;
+#endif
+
+#if COIN_BIG_DOUBLE==0
+typedef double CoinFactorizationDouble;
+#elif COIN_BIG_DOUBLE==1
+typedef long double CoinFactorizationDouble;
+#else
+typedef double CoinFactorizationDouble;
+#endif
+
+#endif

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

@@ -0,0 +1,19 @@
+/* $Id: CoinUtility.hpp 1372 2011-01-03 23:31:00Z lou $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinUtility_h_
+#define CoinUtility_h_
+
+#include "CoinSort.hpp"
+
+template <typename S, typename T>
+CoinPair<S,T> CoinMakePair(const S& s, const T& t)
+{ return CoinPair<S,T>(s, t); }
+
+template <typename S, typename T, typename U>
+CoinTriple<S,T,U> CoinMakeTriple(const S& s, const T& t, const U& u)
+{ return CoinTriple<S,T,U>(s, t, u); }
+
+#endif

data/ext/ruby-cbc/install/include/coin/CoinUtilsConfig.h

@@ -0,0 +1,34 @@
+/* src/config_coinutils.h.  Generated by configure.  */
+/* inc/config_coinutils.h.in.  */
+
+#ifndef __CONFIG_COINUTILS_H__
+#define __CONFIG_COINUTILS_H__
+
+/* Define to 1 if stdint.h is available for CoinUtils */
+#define COINUTILS_HAS_STDINT_H 1
+
+/* Define to 1 if stdint.h is available for CoinUtils */
+/* #undef COINUTILS_HAS_CSTDINT */
+
+/* Version number of project */
+#define COINUTILS_VERSION "2.10.11"
+
+/* Major Version number of project */
+#define COINUTILS_VERSION_MAJOR 2
+
+/* Minor Version number of project */
+#define COINUTILS_VERSION_MINOR 10
+
+/* Release Version number of project */
+#define COINUTILS_VERSION_RELEASE 11
+
+/* Define to 64bit integer type */
+#define COIN_INT64_T int64_t
+
+/* Define to integer type capturing pointer */
+#define COIN_INTPTR_T intptr_t
+
+/* Define to 64bit unsigned integer type */
+#define COIN_UINT64_T int64_t
+
+#endif