ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,383 +0,0 @@
-/* $Id: CoinDenseVector.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// Copyright (C) 2003, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinDenseVector_H
-#define CoinDenseVector_H
-
-#if defined(_MSC_VER)
-// Turn off compiler warning about long names
-#  pragma warning(disable:4786)
-#endif
-
-#include <cassert>
-#include <cstdlib>
-#include <cmath>
-#include "CoinHelperFunctions.hpp"
-
-//#############################################################################
-/** A function that tests the methods in the CoinDenseVector 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. */
-    template <typename T> void
-    CoinDenseVectorUnitTest(T dummy);
-
-//#############################################################################
-/** Dense Vector
-
-Stores a dense (or expanded) vector of floating point values.
-Type of vector elements is controlled by templating.
-(Some working quantities such as accumulated sums
-are explicitly declared of type double). This allows the 
-components of the vector integer, single or double precision.
-
-Here is a sample usage:
-@verbatim
-    const int ne = 4;
-    double el[ne] = { 10., 40., 1., 50. }
-
-    // Create vector and set its value
-    CoinDenseVector<double> r(ne,el);
-
-    // access each element
-    assert( r.getElements()[0]==10. );
-    assert( r.getElements()[1]==40. );
-    assert( r.getElements()[2]== 1. );
-    assert( r.getElements()[3]==50. );
-
-    // Test for equality
-    CoinDenseVector<double> r1;
-    r1=r;
-
-    // Add dense vectors.
-    // Similarly for subtraction, multiplication,
-    // and division.
-    CoinDenseVector<double> add = r + r1;
-    assert( add[0] == 10.+10. );
-    assert( add[1] == 40.+40. );
-    assert( add[2] ==  1.+ 1. );
-    assert( add[3] == 50.+50. );
-
-    assert( r.sum() == 10.+40.+1.+50. );
-@endverbatim
-*/
-template <typename T> class CoinDenseVector {
-private:
-   /**@name Private member data */
-   //@{
-   /// Size of element vector
-   int nElements_;
-   ///Vector elements
-   T * elements_;
-   //@}
-  
-public:
-   /**@name Get methods. */
-   //@{
-   /// Get the size
-   inline int getNumElements() const { return nElements_; }
-   inline int size() const { return nElements_; }
-   /// Get element values
-   inline const T * getElements() const { return elements_; }
-   /// Get element values
-   inline T * getElements() { return elements_; }
-   //@}
- 
-   //-------------------------------------------------------------------
-   // Set indices and elements
-   //------------------------------------------------------------------- 
-   /**@name Set methods */
-   //@{
-   /// Reset the vector (i.e. set all elemenets to zero)
-   void clear();
-   /** Assignment operator */
-   CoinDenseVector & operator=(const CoinDenseVector &);
-   /** Member of array operator */
-   T & operator[](int index) const;
-
-   /** Set vector size, and elements.
-       Size is the length of the elements vector.
-       The element vector is copied into this class instance's
-       member data. */ 
-   void setVector(int size, const T * elems);
-
-  
-   /** Elements set to have the same scalar value */
-   void setConstant(int size, T elems);
-  
-
-   /** Set an existing element in the dense vector
-       The first argument is the "index" into the elements() array
-   */
-   void setElement(int index, T element);
-   /** Resize the dense vector to be the first newSize elements.
-       If length is decreased, vector is truncated. If increased
-       new entries, set to new default element */
-   void resize(int newSize, T fill=T()); 
-
-   /** Append a dense vector to this dense vector */
-   void append(const CoinDenseVector &);
-   //@}
-
-   /**@name norms, sum and scale */
-   //@{
-   /// 1-norm of vector
-   inline T oneNorm() const {
-     T norm = 0;
-     for (int i=0; i<nElements_; i++)
-       norm += CoinAbs(elements_[i]);
-     return norm;
-   }
-   /// 2-norm of vector
-   inline double twoNorm() const {
-     double norm = 0.;
-     for (int i=0; i<nElements_; i++)
-       norm += elements_[i] * elements_[i];
-     // std namespace removed because it was causing a compile
-     // problem with Microsoft Visual C++
-     return /*std::*/sqrt(norm);
-   }
-   /// infinity-norm of vector
-   inline T infNorm() const {
-     T norm = 0;
-     for (int i=0; i<nElements_; i++)
-       norm = CoinMax(norm, CoinAbs(elements_[i]));
-     return norm;
-   }
-   /// sum of vector elements
-   inline T sum() const {
-     T sume = 0;
-     for (int i=0; i<nElements_; i++)
-       sume += elements_[i];
-     return sume;
-   }
-   /// scale vector elements
-   inline void scale(T factor) {
-     for (int i=0; i<nElements_; i++)
-       elements_[i] *= factor;
-     return;
-   }
-   //@}
-
-   /**@name Arithmetic operators. */
-   //@{
-   /// add <code>value</code> to every entry
-   void operator+=(T value);
-   /// subtract <code>value</code> from every entry
-   void operator-=(T value);
-   /// multiply every entry by <code>value</code>
-   void operator*=(T value);
-   /// divide every entry by <code>value</code>
-   void operator/=(T value);
-   //@}
-
-   /**@name Constructors and destructors */
-   //@{
-   /** Default constructor */
-   CoinDenseVector();
-   /** Alternate Constructors - set elements to vector of Ts */
-   CoinDenseVector(int size, const T * elems);
-   /** Alternate Constructors - set elements to same scalar value */
-   CoinDenseVector(int size, T element=T());
-   /** Copy constructors */
-   CoinDenseVector(const CoinDenseVector &);
-
-    /** Destructor */
-   ~CoinDenseVector ();
-   //@}
-    
-private:
-   /**@name Private methods */
-   //@{  
-   /// Copy internal data
-   void gutsOfSetVector(int size, const T * elems);
-   /// Set all elements to a given value
-   void gutsOfSetConstant(int size, T value);
-   //@}
-};
-
-//#############################################################################
-
-/**@name Arithmetic operators on dense vectors.
-
-   <strong>NOTE</strong>: Because these methods return an object (they can't
-   return a reference, though they could return a pointer...) they are
-   <em>very</em> inefficient...
- */
-//@{
-/// Return the sum of two dense vectors
-template <typename T> inline
-CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1,
-			     const CoinDenseVector<T>& op2){
-  assert(op1.size() == op2.size());
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  const T *elements2 = op2.getElements();
-  T *elements3 = op3.getElements();
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] + elements2[i];
-  return op3;
-}
-
-/// Return the difference of two dense vectors
-template <typename T> inline
-CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1,
-			     const CoinDenseVector<T>& op2){
-  assert(op1.size() == op2.size());
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  const T *elements2 = op2.getElements();
-  T *elements3 = op3.getElements();
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] - elements2[i];
-  return op3;
-}
-
-
-/// Return the element-wise product of two dense vectors
-template <typename T> inline
-CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1,
-			  const CoinDenseVector<T>& op2){
-  assert(op1.size() == op2.size());
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  const T *elements2 = op2.getElements();
-  T *elements3 = op3.getElements();
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] * elements2[i];
-  return op3;
-}
-
-/// Return the element-wise ratio of two dense vectors
-template <typename T> inline
-CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1,
-			  const CoinDenseVector<T>& op2){
-  assert(op1.size() == op2.size());
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  const T *elements2 = op2.getElements();
-  T *elements3 = op3.getElements();
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] / elements2[i];
-  return op3;
-}
-//@}
-
-/**@name Arithmetic operators on dense vector and a constant. 
-   These functions create a dense vector as a result. That dense vector will
-   have the same indices as <code>op1</code> and the specified operation is
-   done entry-wise with the given value. */
-//@{
-/// Return the sum of a dense vector and a constant
-template <typename T> inline
-CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, T value){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] + dvalue;
-  return op3;
-}
-
-/// Return the difference of a dense vector and a constant
-template <typename T> inline
-CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, T value){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] - dvalue;
-  return op3;
-}
-
-/// Return the element-wise product of a dense vector and a constant
-template <typename T> inline
-CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, T value){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] * dvalue;
-  return op3;
-}
-
-/// Return the element-wise ratio of a dense vector and a constant
-template <typename T> inline
-CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, T value){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] / dvalue;
-  return op3;
-}
-
-/// Return the sum of a constant and a dense vector
-template <typename T> inline
-CoinDenseVector<T> operator+(T value, const CoinDenseVector<T>& op1){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] + dvalue;
-  return op3;
-}
-
-/// Return the difference of a constant and a dense vector
-template <typename T> inline
-CoinDenseVector<T> operator-(T value, const CoinDenseVector<T>& op1){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = dvalue - elements1[i];
-  return op3;
-}
-
-/// Return the element-wise product of a constant and a dense vector
-template <typename T> inline
-CoinDenseVector<T> operator*(T value, const CoinDenseVector<T>& op1){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = elements1[i] * dvalue;
-  return op3;
-}
-
-/// Return the element-wise ratio of a a constant and dense vector
-template <typename T> inline
-CoinDenseVector<T> operator/(T value, const CoinDenseVector<T>& op1){
-  int size = op1.size();
-  CoinDenseVector<T> op3(size);
-  const T *elements1 = op1.getElements();
-  T *elements3 = op3.getElements();
-  double dvalue = value;
-  for(int i=0; i<size; i++)
-    elements3[i] = dvalue / elements1[i];
-  return op3;
-}
-//@}
-
-#endif

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

@@ -1,48 +0,0 @@
-/* $Id: CoinDistance.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// 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 CoinDistance_H
-#define CoinDistance_H
-
-#include <iterator>
-
-//-------------------------------------------------------------------
-//
-// Attempt to provide an std::distance function
-// that will work on multiple platforms
-//
-//-------------------------------------------------------------------
-
-/** CoinDistance
-
-This is the Coin implementation of the std::function that is 
-designed to work on multiple platforms.
-*/
-template <class ForwardIterator, class Distance>
-void coinDistance(ForwardIterator first, ForwardIterator last,
-		  Distance& n)
-{
-#if defined(__SUNPRO_CC)
-   n = 0;
-   std::distance(first,last,n);
-#else
-   n = std::distance(first,last);
-#endif
-}
-
-template <class ForwardIterator>
-size_t coinDistance(ForwardIterator first, ForwardIterator last)
-{
-   size_t retVal;
-#if defined(__SUNPRO_CC)
-   retVal = 0;
-   std::distance(first,last,retVal);
-#else
-   retVal = std::distance(first,last);
-#endif
-  return retVal;
-}
-
-#endif

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

@@ -1,257 +0,0 @@
-/* $Id: CoinError.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// 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 CoinError_H
-#define CoinError_H
-
-#include <string>
-#include <iostream>
-#include <cassert>
-#include <cstring>
-
-#include "CoinUtilsConfig.h"
-#include "CoinPragma.hpp"
-
-/** A function to block the popup windows that windows creates when the code
-    crashes */
-void WindowsErrorPopupBlocker();
-
-//-------------------------------------------------------------------
-//
-// Error class used to throw exceptions
-//
-// Errors contain:
-//
-//-------------------------------------------------------------------
-
-/** Error Class thrown by an exception
-
-This class is used when exceptions are thrown.
-It contains:
-  <ul>
-  <li>message text
-  <li>name of method throwing exception
-  <li>name of class throwing exception or hint
-  <li>name of file if assert
-  <li>line number
-  </ul>
-  For asserts class=> optional hint
-*/
-class CoinError  {
-    friend void CoinErrorUnitTest();
-
-private:
-    CoinError()
-      :
-      message_(),
-      method_(),
-      class_(),
-      file_(),
-      lineNumber_()
-    {
-      // nothing to do here
-    }
-
-public:
-    
-  //-------------------------------------------------------------------
-  // Get methods
-  //-------------------------------------------------------------------   
-  /**@name Get error attributes */
-  //@{
-    /// get message text
-    inline const std::string & message() const 
-    { return message_; }
-    /// get name of method instantiating error
-    inline const std::string & methodName() const 
-    { return method_;  }
-    /// get name of class instantiating error (or hint for assert)
-    inline const std::string & className() const 
-    { return class_;   }
-    /// get name of file for assert
-    inline const std::string & fileName() const 
-    { return file_;  }
-    /// get line number of assert (-1 if not assert)
-    inline int lineNumber() const 
-    { return lineNumber_;   }
-    /// Just print (for asserts)
-    inline void print(bool doPrint = true) const
-    {
-      if (! doPrint)
-        return;
-      if (lineNumber_<0) {
-        std::cout<<message_<<" in "<<class_<<"::"<<method_<<std::endl;
-      } else {
-        std::cout<<file_<<":"<<lineNumber_<<" method "<<method_
-                 <<" : assertion \'"<<message_<<"\' failed."<<std::endl;
-        if(class_!="")
-          std::cout<<"Possible reason: "<<class_<<std::endl;
-      }
-    }
-  //@}
-  
-    
-  /**@name Constructors and destructors */
-  //@{
-    /// Alternate Constructor 
-    CoinError ( 
-      std::string message__, 
-      std::string methodName__, 
-      std::string className__,
-      std::string fileName_ = std::string(),
-      int line = -1)
-      :
-      message_(message__),
-      method_(methodName__),
-      class_(className__),
-      file_(fileName_),
-      lineNumber_(line)
-    {
-      print(printErrors_);
-    }
-
-    /// Copy constructor 
-    CoinError (const CoinError & source)
-      :
-      message_(source.message_),
-      method_(source.method_),
-      class_(source.class_),
-      file_(source.file_),
-      lineNumber_(source.lineNumber_)
-    {
-      // nothing to do here
-    }
-
-    /// Assignment operator 
-    CoinError & operator=(const CoinError& rhs)
-    {
-      if (this != &rhs) {
-	message_=rhs.message_;
-	method_=rhs.method_;
-	class_=rhs.class_;
-	file_=rhs.file_;
-	lineNumber_ = rhs.lineNumber_;
-      }
-      return *this;
-    }
-
-    /// Destructor 
-    virtual ~CoinError ()
-    {
-      // nothing to do here
-    }
-  //@}
-    
-private:
-    
-  /**@name Private member data */
-  //@{
-    /// message test
-    std::string message_;
-    /// method name
-    std::string method_;
-    /// class name or hint
-    std::string class_;
-    /// file name
-    std::string file_;
-    /// Line number
-    int lineNumber_;
-  //@}
-
-public:
-  /// Whether to print every error
-  static bool printErrors_;
-};
-
-#ifndef __STRING
-#define __STRING(x)	#x
-#endif
-
-#ifndef __GNUC_PREREQ
-# define __GNUC_PREREQ(maj, min) (0)
-#endif 
-
-#ifndef COIN_ASSERT
-#   define CoinAssertDebug(expression) assert(expression)
-#   define CoinAssertDebugHint(expression,hint) assert(expression)
-#   define CoinAssert(expression) assert(expression)
-#   define CoinAssertHint(expression,hint) assert(expression)
-#else
-#   ifdef NDEBUG
-#      define CoinAssertDebug(expression)		{}
-#      define CoinAssertDebugHint(expression,hint)	{}
-#   else
-#      if defined(__GNUC__) && __GNUC_PREREQ(2, 6)
-#         define CoinAssertDebug(expression) { 				   \
-             if (!(expression)) {					   \
-                throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
-                                "", __FILE__, __LINE__);		   \
-             }								   \
-          }
-#         define CoinAssertDebugHint(expression,hint) {			   \
-             if (!(expression)) {					   \
-                throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
-                                hint, __FILE__,__LINE__);		   \
-             }								   \
-          }
-#      else
-#         define CoinAssertDebug(expression) {				   \
-             if (!(expression)) {					   \
-                throw CoinError(__STRING(expression), "",		   \
-                                "", __FILE__,__LINE__);			   \
-             }								   \
-          }
-#         define CoinAssertDebugHint(expression,hint) {			   \
-             if (!(expression)) {					   \
-                throw CoinError(__STRING(expression), "",		   \
-                                hint, __FILE__,__LINE__);		   \
-             }								   \
-          }
-#      endif
-#   endif
-#   if defined(__GNUC__) && __GNUC_PREREQ(2, 6)
-#      define CoinAssert(expression) { 					\
-          if (!(expression)) {						\
-             throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
-                             "", __FILE__, __LINE__);			\
-          }								\
-       }
-#      define CoinAssertHint(expression,hint) {				\
-          if (!(expression)) {						\
-             throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
-                             hint, __FILE__,__LINE__);			\
-          }								\
-       }
-#   else
-#      define CoinAssert(expression) {					\
-          if (!(expression)) {						\
-             throw CoinError(__STRING(expression), "",			\
-                             "", __FILE__,__LINE__);			\
-          }								\
-       }
-#      define CoinAssertHint(expression,hint) {				\
-          if (!(expression)) {						\
-             throw CoinError(__STRING(expression), "",			\
-                             hint, __FILE__,__LINE__);			\
-          }								\
-       }
-#   endif
-#endif
-
-
-//#############################################################################
-/** A function that tests the methods in the CoinError 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
-CoinErrorUnitTest();
-
-#ifdef __LINE__
-#define CoinErrorFL(x, y, z) CoinError((x), (y), (z), __FILE__, __LINE__)
-#endif
-
-#endif