ruby-cbc 0.1.9

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

@@ -0,0 +1,148 @@
+/* $Id: CoinShallowPackedVector.hpp 1498 2011-11-02 15:25:35Z mjs $ */
+// 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 CoinShallowPackedVector_H
+#define CoinShallowPackedVector_H
+
+#if defined(_MSC_VER)
+// Turn off compiler warning about long names
+#  pragma warning(disable:4786)
+#endif
+
+#include "CoinError.hpp"
+#include "CoinPackedVectorBase.hpp"
+
+/** Shallow Sparse Vector
+ 
+This class is for sparse vectors where the indices and 
+elements are stored elsewhere.  This class only maintains
+pointers to the indices and elements.  Since this class
+does not own the index and element data it provides
+read only access to to the data.  An CoinSparsePackedVector
+must be used when the sparse vector's data will be altered.
+
+This class stores pointers to the vectors.
+It does not actually contain the vectors.
+
+Here is a sample usage:
+@verbatim
+   const int ne = 4; 
+   int inx[ne] =   {  1,   4,  0,   2 }; 
+   double el[ne] = { 10., 40., 1., 50. }; 
+ 
+   // Create vector and set its value 
+   CoinShallowPackedVector r(ne,inx,el); 
+ 
+   // access each index and element 
+   assert( r.indices ()[0]== 1  ); 
+   assert( r.elements()[0]==10. ); 
+   assert( r.indices ()[1]== 4  ); 
+   assert( r.elements()[1]==40. ); 
+   assert( r.indices ()[2]== 0  ); 
+   assert( r.elements()[2]== 1. ); 
+   assert( r.indices ()[3]== 2  ); 
+   assert( r.elements()[3]==50. ); 
+ 
+   // access as a full storage vector 
+   assert( r[ 0]==1. ); 
+   assert( r[ 1]==10.); 
+   assert( r[ 2]==50.); 
+   assert( r[ 3]==0. ); 
+   assert( r[ 4]==40.); 
+ 
+   // Tests for equality and equivalence
+   CoinShallowPackedVector r1; 
+   r1=r; 
+   assert( r==r1 ); 
+   r.sort(CoinIncrElementOrdered()); 
+   assert( r!=r1 ); 
+ 
+   // Add packed vectors. 
+   // Similarly for subtraction, multiplication, 
+   // and division. 
+   CoinPackedVector add = r + r1; 
+   assert( add[0] ==  1.+ 1. ); 
+   assert( add[1] == 10.+10. ); 
+   assert( add[2] == 50.+50. ); 
+   assert( add[3] ==  0.+ 0. ); 
+   assert( add[4] == 40.+40. ); 
+   assert( r.sum() == 10.+40.+1.+50. ); 
+@endverbatim
+*/
+class CoinShallowPackedVector : public CoinPackedVectorBase {
+   friend void CoinShallowPackedVectorUnitTest();
+
+public:
+  
+   /**@name Get methods */
+   //@{
+   /// Get length of indices and elements vectors
+   virtual int getNumElements() const { return nElements_; }
+   /// Get indices of elements
+   virtual const int * getIndices() const { return indices_; }
+   /// Get element values
+   virtual const double * getElements() const { return elements_; }
+   //@}
+
+   /**@name Set methods */
+   //@{
+   /// Reset the vector (as if were just created an empty vector)
+   void clear();
+   /** Assignment operator. */
+   CoinShallowPackedVector& operator=(const CoinShallowPackedVector & x);
+   /** Assignment operator from a CoinPackedVectorBase. */
+   CoinShallowPackedVector& operator=(const CoinPackedVectorBase & x);
+   /** just like the explicit constructor */
+   void setVector(int size, const int * indices, const double * elements,
+		  bool testForDuplicateIndex = true);
+   //@}
+
+   /**@name Methods to create, set and destroy */
+   //@{
+   /** Default constructor. */
+   CoinShallowPackedVector(bool testForDuplicateIndex = true);
+   /** Explicit Constructor.
+       Set vector size, indices, and elements. Size is the length of both the
+       indices and elements vectors. The indices and elements vectors are not
+       copied into this class instance. The ShallowPackedVector only maintains
+       the pointers to the indices and elements vectors. <br>
+       The last argument specifies whether the creator of the object knows in
+       advance that there are no duplicate indices.
+   */
+   CoinShallowPackedVector(int size,
+			  const int * indices, const double * elements,
+			  bool testForDuplicateIndex = true);
+   /** Copy constructor from the base class. */
+   CoinShallowPackedVector(const CoinPackedVectorBase &);
+   /** Copy constructor. */
+   CoinShallowPackedVector(const CoinShallowPackedVector &);
+   /** Destructor. */
+   virtual ~CoinShallowPackedVector() {}
+   /// Print vector information.
+   void print();
+   //@}
+
+private:
+   /**@name Private member data */
+   //@{
+   /// Vector indices
+   const int * indices_;
+   ///Vector elements
+   const double * elements_;
+   /// Size of indices and elements vectors
+   int nElements_;
+   //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CoinShallowPackedVector 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
+CoinShallowPackedVectorUnitTest();
+
+#endif

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

@@ -0,0 +1,117 @@
+/* $Id: CoinSignal.hpp 1810 2015-03-13 20:16:34Z tkr $ */
+// 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 _CoinSignal_hpp
+#define _CoinSignal_hpp
+
+// This file is fully docified.
+// There's nothing to docify...
+
+//#############################################################################
+
+#include <csignal>
+
+//#############################################################################
+
+#if defined(_MSC_VER)
+   typedef void (__cdecl *CoinSighandler_t) (int);
+#  define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if (defined(__GNUC__) && defined(__linux__))
+  typedef sighandler_t CoinSighandler_t;
+# define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__CYGWIN__) && defined(__GNUC__)
+   typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__MINGW32__) && defined(__GNUC__)
+   typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__FreeBSD__) && defined(__GNUC__)
+   typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__NetBSD__) && defined(__GNUC__)
+   typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(_AIX)
+#  if defined(__GNUC__)
+      typedef __decltype(SIG_DFL) CoinSighandler_t;
+#     define CoinSighandler_t_defined
+#  endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined (__hpux)
+#  define CoinSighandler_t_defined
+#  if defined(__GNUC__)
+      typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  else
+      extern "C" {
+         typedef void (*CoinSighandler_t) (int);
+      }
+#  endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__sun)
+#  if defined(__SUNPRO_CC)
+#     include <signal.h>
+      extern "C" {
+         typedef void (*CoinSighandler_t) (int);
+      }
+#     define CoinSighandler_t_defined
+#  endif
+#  if defined(__GNUC__)
+      typedef __decltype(SIG_DFL) CoinSighandler_t;
+#     define CoinSighandler_t_defined
+#  endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__MACH__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#  define CoinSighandler_t_defined
+#endif
+
+//#############################################################################
+
+#ifndef CoinSighandler_t_defined
+#  warning("OS and/or compiler is not recognized. Defaulting to:");
+#  warning("extern 'C' {")
+#  warning("   typedef void (*CoinSighandler_t) (int);")
+#  warning("}")
+   extern "C" {
+      typedef void (*CoinSighandler_t) (int);
+   }
+#endif
+
+//#############################################################################
+
+#endif

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

@@ -0,0 +1,431 @@
+/* $Id: CoinSimpFactorization.hpp 1416 2011-04-17 09:57:29Z stefan $ */
+// 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).
+
+/* 
+   This is a simple factorization of the LP Basis
+ */
+#ifndef CoinSimpFactorization_H
+#define CoinSimpFactorization_H
+
+#include <iostream>
+#include <string>
+#include <cassert>
+#include "CoinTypes.hpp"
+#include "CoinIndexedVector.hpp"
+#include "CoinDenseFactorization.hpp"
+class CoinPackedMatrix;
+
+
+/// pointers used during factorization
+class FactorPointers{
+public:
+    double *rowMax;
+    int *firstRowKnonzeros;
+    int *prevRow;
+    int *nextRow;
+    int *firstColKnonzeros;
+    int *prevColumn;
+    int *nextColumn;
+    int *newCols;
+    //constructor
+    FactorPointers( int numRows, int numCols, int *UrowLengths_, int *UcolLengths_ );
+    // destructor
+    ~ FactorPointers();
+};
+
+class CoinSimpFactorization : public CoinOtherFactorization {
+   friend void CoinSimpFactorizationUnitTest( const std::string & mpsDir );
+
+public:
+
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  CoinSimpFactorization (  );
+  /// Copy constructor 
+  CoinSimpFactorization ( const CoinSimpFactorization &other);
+  
+  /// Destructor
+  virtual ~CoinSimpFactorization (  );
+  /// = copy
+  CoinSimpFactorization & operator = ( const CoinSimpFactorization & other );
+  /// Clone
+  virtual CoinOtherFactorization * clone() const ;
+  //@}
+
+  /**@name Do factorization - public */
+  //@{
+  /// Gets space for a factorization
+  virtual void getAreas ( int numberRows,
+		  int numberColumns,
+		  CoinBigIndex maximumL,
+		  CoinBigIndex maximumU );
+  
+  /// PreProcesses column ordered copy of basis
+  virtual void preProcess ( );
+  /** Does most of factorization returning status
+      0 - OK
+      -99 - needs more memory
+      -1 - singular - use numberGoodColumns and redo
+  */
+  virtual int factor ( );
+  /// Does post processing on valid factorization - putting variables on correct rows
+  virtual void postProcess(const int * sequence, int * pivotVariable);
+  /// Makes a non-singular basis by replacing variables
+  virtual void makeNonSingular(int * sequence, int numberColumns);
+  //@}
+
+  /**@name general stuff such as status */
+  //@{ 
+  /// Total number of elements in factorization
+  virtual inline int numberElements (  ) const {
+    return numberRows_*(numberColumns_+numberPivots_);
+  }
+  /// Returns maximum absolute value in factorization
+  double maximumCoefficient() const;
+  //@}
+
+  /**@name rank one updates which do exist */
+  //@{
+
+  /** Replaces one Column to basis,
+   returns 0=OK, 1=Probably OK, 2=singular, 3=no room
+      If checkBeforeModifying is true will do all accuracy checks
+      before modifying factorization.  Whether to set this depends on
+      speed considerations.  You could just do this on first iteration
+      after factorization and thereafter re-factorize
+   partial update already in U */
+  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
+		      int pivotRow,
+		      double pivotCheck ,
+			      bool checkBeforeModifying=false,
+			      double acceptablePivot=1.0e-8);
+  //@}
+
+  /**@name various uses of factorization (return code number elements) 
+   which user may want to know about */
+  //@{
+  /** Updates one column (FTRAN) from regionSparse2
+      Tries to do FT update
+      number returned is negative if no room
+      regionSparse starts as zero and is zero at end.
+      Note - if regionSparse2 packed on input - will be packed on output
+  */
+
+    virtual int updateColumnFT ( CoinIndexedVector * regionSparse,
+			 CoinIndexedVector * regionSparse2,
+			 bool noPermute=false);
+    
+    /** This version has same effect as above with FTUpdate==false
+	so number returned is always >=0 */
+    virtual int updateColumn ( CoinIndexedVector * regionSparse,
+		       CoinIndexedVector * regionSparse2,
+		       bool noPermute=false) const;
+    /// does FTRAN on two columns
+    virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
+			   CoinIndexedVector * regionSparse2,
+			   CoinIndexedVector * regionSparse3,
+			   bool noPermute=false);
+    /// does updatecolumn if save==true keeps column for replace column
+    int upColumn ( CoinIndexedVector * regionSparse,
+		   CoinIndexedVector * regionSparse2,
+		   bool noPermute=false, bool save=false) const;
+    /** Updates one column (BTRAN) from regionSparse2
+	regionSparse starts as zero and is zero at end 
+	Note - if regionSparse2 packed on input - will be packed on output
+    */
+    virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
+				CoinIndexedVector * regionSparse2) const;
+    /// does updateColumnTranspose, the other is a wrapper
+    int upColumnTranspose ( CoinIndexedVector * regionSparse,
+				CoinIndexedVector * regionSparse2) const;
+    //@}
+    /// *** Below this user may not want to know about
+
+  /**@name various uses of factorization
+   which user may not want to know about (left over from my LP code) */
+  //@{
+  /// Get rid of all memory
+  inline void clearArrays()
+  { gutsOfDestructor();}
+  /// Returns array to put basis indices in
+  inline int * indices() const
+  { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
+  /// Returns permute in
+  virtual inline int * permute() const
+  { return pivotRow_;}
+  //@}
+
+  /// The real work of destructor 
+  void gutsOfDestructor();
+  /// The real work of constructor
+  void gutsOfInitialize();
+  /// The real work of copy
+  void gutsOfCopy(const CoinSimpFactorization &other);
+
+    
+    /// calls factorization
+  void factorize(int numberOfRows,
+		 int numberOfColumns,
+		 const int colStarts[],
+		 const int indicesRow[],
+		 const double elements[]);
+    /// main loop of factorization
+    int mainLoopFactor (FactorPointers &pointers );
+    /// copies L by rows
+    void copyLbyRows();
+    /// copies U by columns
+    void copyUbyColumns();
+    /// finds a pivot element using Markowitz count
+    int findPivot(FactorPointers &pointers, int &r, int &s, bool &ifSlack);
+    /// finds a pivot in a shortest column
+    int findPivotShCol(FactorPointers &pointers, int &r, int &s);
+    /// finds a pivot in the first column available
+    int findPivotSimp(FactorPointers &pointers, int &r, int &s);
+    /// does Gauss elimination
+    void GaussEliminate(FactorPointers &pointers, int &r, int &s);
+    /// finds short row that intersects a given column
+    int findShortRow(const int column, const int length, int &minRow, 
+		     int &minRowLength, FactorPointers &pointers);
+    /// finds short column that intersects a given row
+    int findShortColumn(const int row, const int length, int &minCol, 
+			int &minColLength, FactorPointers &pointers);
+    /// finds maximum absolute value in a row
+    double findMaxInRrow(const int row, FactorPointers &pointers);
+    /// does pivoting
+    void pivoting(const int pivotRow, const int pivotColumn,
+		  const double invPivot, FactorPointers &pointers);
+    /// part of pivoting
+    void updateCurrentRow(const int pivotRow, const int row, 
+			  const double multiplier, FactorPointers &pointers,
+			  int &newNonZeros);
+    /// allocates more space for L
+    void increaseLsize();
+    /// allocates more space for a row of U
+    void increaseRowSize(const int row, const int newSize);
+    /// allocates more space for a column of U
+    void increaseColSize(const int column, const int newSize, const bool b);
+    /// allocates more space for rows of U
+    void enlargeUrow(const int numNewElements);
+    /// allocates more space for columns of U
+    void enlargeUcol(const int numNewElements, const bool b);
+    /// finds a given row in a column
+    int findInRow(const int row, const int column);
+    /// finds a given column in a row
+    int findInColumn(const int column, const int row);
+    /// declares a row inactive
+    void removeRowFromActSet(const int row, FactorPointers &pointers);
+    /// declares a column inactive
+    void removeColumnFromActSet(const int column, FactorPointers &pointers);
+    /// allocates space for U
+    void allocateSpaceForU();
+    /// allocates several working arrays
+    void allocateSomeArrays();
+    /// initializes some numbers
+    void initialSomeNumbers();
+    /// solves L x = b
+    void Lxeqb(double *b) const;
+    /// same as above but with two rhs
+    void Lxeqb2(double *b1, double *b2) const;
+    /// solves U x = b
+    void Uxeqb(double *b, double *sol) const;
+    /// same as above but with two rhs
+    void Uxeqb2(double *b1, double *sol1, double *sol2, double *b2) const;
+    /// solves x L = b
+    void xLeqb(double *b) const;
+    /// solves x U = b
+    void xUeqb(double *b, double *sol) const;
+    /// updates factorization after a Simplex iteration
+    int LUupdate(int newBasicCol);
+    /// creates a new eta vector
+    void newEta(int row, int numNewElements);
+    /// makes a copy of row permutations
+    void copyRowPermutations();
+    /// solves H x = b, where H is a product of eta matrices
+    void Hxeqb(double *b) const;
+    /// same as above but with two rhs
+    void Hxeqb2(double *b1, double *b2) const;
+    /// solves x H = b
+    void xHeqb(double *b) const;
+    /// does FTRAN
+    void ftran(double *b, double *sol, bool save) const;
+    /// same as above but with two columns
+    void ftran2(double *b1, double *sol1, double *b2, double *sol2) const;
+    /// does BTRAN
+    void btran(double *b, double *sol) const;
+   ///---------------------------------------
+
+
+
+  //@}
+protected:
+  /** Returns accuracy status of replaceColumn
+      returns 0=OK, 1=Probably OK, 2=singular */
+  int checkPivot(double saveFromU, double oldPivot) const;
+////////////////// data //////////////////
+protected:
+
+  /**@name data */
+  //@{
+    /// work array (should be initialized to zero)
+    double *denseVector_;
+    /// work array 
+    double *workArea2_; 
+    /// work array 
+    double *workArea3_;
+    /// array of labels (should be initialized to zero)
+    int *vecLabels_;
+    /// array of indices
+    int *indVector_;
+
+    /// auxiliary vector 
+    double *auxVector_;
+    /// auxiliary vector 
+    int *auxInd_;
+
+    /// vector to keep for LUupdate
+    double *vecKeep_;
+    /// indices of this vector
+    int *indKeep_;
+    /// number of nonzeros
+    mutable int keepSize_;
+
+    
+
+    /// Starts of the rows of L
+    int *LrowStarts_;
+    /// Lengths of the rows of L
+    int *LrowLengths_;
+    /// L by rows
+    double *Lrows_;
+    /// indices in the rows of L
+    int *LrowInd_;
+    /// Size of Lrows_;
+    int LrowSize_; 
+    /// Capacity of Lrows_
+    int LrowCap_;
+
+    /// Starts of the columns of L
+    int *LcolStarts_;
+    /// Lengths of the columns of L
+    int *LcolLengths_;
+    /// L by columns
+    double *Lcolumns_;
+    /// indices in the columns of L
+    int *LcolInd_;
+    /// numbers of elements in L
+    int LcolSize_;
+    /// maximum capacity of L
+    int LcolCap_;
+   
+
+    /// Starts of the rows of U
+    int *UrowStarts_;
+    /// Lengths of the rows of U
+    int *UrowLengths_;
+#ifdef COIN_SIMP_CAPACITY
+    /// Capacities of the rows of U
+    int *UrowCapacities_;
+#endif
+    /// U by rows
+    double *Urows_;
+    /// Indices in the rows of U
+    int *UrowInd_;
+    /// maximum capacity of Urows
+    int UrowMaxCap_;
+    /// number of used places in Urows
+    int UrowEnd_;
+    /// first row in U
+    int firstRowInU_;
+    /// last row in U
+    int lastRowInU_;
+    /// previous row in U
+    int *prevRowInU_;
+    /// next row in U
+    int *nextRowInU_;
+
+    /// Starts of the columns of U
+    int *UcolStarts_;
+    /// Lengths of the columns of U
+    int *UcolLengths_;
+#ifdef COIN_SIMP_CAPACITY
+    /// Capacities of the columns of U
+    int *UcolCapacities_;
+#endif
+    /// U by columns
+    double *Ucolumns_;
+    /// Indices in the columns of U
+    int *UcolInd_;
+    /// previous column in U
+    int *prevColInU_;
+    /// next column in U
+    int *nextColInU_;
+    /// first column in U
+    int firstColInU_;
+    /// last column in U
+    int lastColInU_;
+    /// maximum capacity of Ucolumns_
+    int UcolMaxCap_;
+    /// last used position in Ucolumns_
+    int UcolEnd_;    
+    /// indicator of slack variables
+    int *colSlack_;
+ 
+    /// inverse values of the elements of diagonal of U
+    double *invOfPivots_;
+
+    /// permutation of columns 
+    int *colOfU_;
+    /// position of column after permutation
+    int *colPosition_;
+    /// permutations of rows
+    int *rowOfU_;
+    /// position of row after permutation
+    int *rowPosition_;
+    /// permutations of rows during LUupdate
+    int *secRowOfU_;
+    /// position of row after permutation during LUupdate
+    int *secRowPosition_;
+    
+    /// position of Eta vector
+    int *EtaPosition_;
+    /// Starts of eta vectors
+    int *EtaStarts_;
+    /// Lengths of eta vectors
+    int *EtaLengths_;
+    /// columns of eta vectors
+    int *EtaInd_;
+    /// elements of eta vectors
+    double *Eta_;
+    /// number of elements in Eta_
+    int EtaSize_;
+    /// last eta row
+    int lastEtaRow_;
+    /// maximum number of eta vectors
+    int maxEtaRows_;
+    /// Capacity of Eta_
+    int EtaMaxCap_;
+    
+    /// minimum storage increase
+    int minIncrease_;
+    /// maximum size for the diagonal of U after update
+    double updateTol_;
+    /// do Shul heuristic
+    bool doSuhlHeuristic_;
+    /// maximum of U
+    double maxU_;
+    /// bound on the growth rate
+    double maxGrowth_;
+    /// maximum of A
+    double maxA_;
+    /// maximum number of candidates for pivot
+    int pivotCandLimit_;    
+    /// number of slacks in basis
+    int numberSlacks_;    
+    /// number of slacks in irst basis
+    int firstNumberSlacks_;
+    //@}
+};
+#endif