ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,148 +0,0 @@
-/* $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

@@ -1,117 +0,0 @@
-/* $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

@@ -1,431 +0,0 @@
-/* $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