ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,126 +0,0 @@
-/* $Id: ClpParameters.hpp 2046 2014-08-14 04:13:10Z tkr $ */
-// Copyright (C) 2000, 2002, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef _ClpParameters_H
-#define _ClpParameters_H
-
-/** This is where to put any useful stuff.
-
-*/
-enum ClpIntParam {
-     /** The maximum number of iterations Clp can execute in the simplex methods
-      */
-     ClpMaxNumIteration = 0,
-     /** The maximum number of iterations Clp can execute in hotstart before
-         terminating */
-     ClpMaxNumIterationHotStart,
-     /** The name discipline; specifies how the solver will handle row and
-         column names.
-       - 0: Auto names: Names cannot be set by the client. Names of the form
-        Rnnnnnnn or Cnnnnnnn are generated on demand when a name for a
-        specific row or column is requested; nnnnnnn is derived from the row
-        or column index. Requests for a vector of names return a vector with
-        zero entries.
-       - 1: Lazy names: Names supplied by the client are retained. Names of the
-        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
-        supplied by the client. Requests for a vector of names return a
-        vector sized to the largest index of a name supplied by the client;
-        some entries in the vector may be null strings.
-       - 2: Full names: Names supplied by the client are retained. Names of the
-        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
-        supplied by the client. Requests for a vector of names return a
-        vector sized to match the constraint system, and all entries will
-        contain either the name specified by the client or a generated name.
-     */
-     ClpNameDiscipline,
-     /** Just a marker, so that we can allocate a static sized array to store
-         parameters. */
-     ClpLastIntParam
-};
-
-enum ClpDblParam {
-     /** Set Dual objective limit. This is to be used as a termination criteria
-         in methods where the dual objective monotonically changes (dual
-         simplex). */
-     ClpDualObjectiveLimit,
-     /** Primal objective limit. This is to be used as a termination
-         criteria in methods where the primal objective monotonically changes
-         (e.g., primal simplex) */
-     ClpPrimalObjectiveLimit,
-     /** The maximum amount the dual constraints can be violated and still be
-         considered feasible. */
-     ClpDualTolerance,
-     /** The maximum amount the primal constraints can be violated and still be
-         considered feasible. */
-     ClpPrimalTolerance,
-     /** Objective function constant. This the value of the constant term in
-         the objective function. */
-     ClpObjOffset,
-     /// Maximum time in seconds - after, this action is as max iterations
-     ClpMaxSeconds,
-     /// Maximum wallclock running time in seconds - after, this action is as max iterations
-     ClpMaxWallSeconds,
-     /// Tolerance to use in presolve
-     ClpPresolveTolerance,
-     /** Just a marker, so that we can allocate a static sized array to store
-         parameters. */
-     ClpLastDblParam
-};
-
-
-enum ClpStrParam {
-     /** Name of the problem. This is the found on the Name card of
-         an mps file. */
-     ClpProbName = 0,
-     /** Just a marker, so that we can allocate a static sized array to store
-         parameters. */
-     ClpLastStrParam
-};
-
-/// Copy (I don't like complexity of Coin version)
-template <class T> inline void
-ClpDisjointCopyN( const T * array, const int size, T * newArray)
-{
-     memcpy(reinterpret_cast<void *> (newArray), array, size * sizeof(T));
-}
-/// And set
-template <class T> inline void
-ClpFillN( T * array, const int size, T value)
-{
-     int i;
-     for (i = 0; i < size; i++)
-          array[i] = value;
-}
-/// This returns a non const array filled with input from scalar or actual array
-template <class T> inline T*
-ClpCopyOfArray( const T * array, const int size, T value)
-{
-     T * arrayNew = new T[size];
-     if (array)
-          ClpDisjointCopyN(array, size, arrayNew);
-     else
-          ClpFillN ( arrayNew, size, value);
-     return arrayNew;
-}
-
-/// This returns a non const array filled with actual array (or NULL)
-template <class T> inline T*
-ClpCopyOfArray( const T * array, const int size)
-{
-     if (array) {
-          T * arrayNew = new T[size];
-          ClpDisjointCopyN(array, size, arrayNew);
-          return arrayNew;
-     } else {
-          return NULL;
-     }
-}
-/// For a structure to be used by trusted code
-typedef struct {
-     int typeStruct; // allocated as 1,2 etc
-     int typeCall;
-     void * data;
-} ClpTrustedData;
-#endif

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

@@ -1,103 +0,0 @@
-/* $Id: ClpPdcoBase.hpp 1665 2011-01-04 17:55:54Z 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 ClpPdcoBase_H
-#define ClpPdcoBase_H
-
-#include "CoinPragma.hpp"
-
-#include "CoinPackedMatrix.hpp"
-#include "CoinDenseVector.hpp"
-class ClpInterior;
-
-/** Abstract base class for tailoring everything for Pcdo
-
-    Since this class is abstract, no object of this type can be created.
-
-    If a derived class provides all methods then all ClpPcdo algorithms
-    should work.
-
-    Eventually we should be able to use ClpObjective and ClpMatrixBase.
-*/
-
-class ClpPdcoBase  {
-
-public:
-     /**@name Virtual methods that the derived classes must provide */
-     //@{
-     virtual void matVecMult(ClpInterior * model, int mode, double * x, double * y) const = 0;
-
-     virtual void getGrad(ClpInterior * model, CoinDenseVector<double> &x, CoinDenseVector<double> &grad) const = 0;
-
-     virtual void getHessian(ClpInterior * model, CoinDenseVector<double> &x, CoinDenseVector<double> &H) const = 0;
-
-     virtual double getObj(ClpInterior * model, CoinDenseVector<double> &x) const = 0;
-
-     virtual void matPrecon(ClpInterior * model,  double delta, double * x, double * y) const = 0;
-
-     //@}
-     //@{
-     ///@name Other
-     /// Clone
-     virtual ClpPdcoBase * clone() const = 0;
-     /// Returns type
-     inline int type() const {
-          return type_;
-     };
-     /// Sets type
-     inline void setType(int type) {
-          type_ = type;
-     };
-     /// Returns size of d1
-     inline int sizeD1() const {
-          return 1;
-     };
-     /// Returns d1 as scalar
-     inline double getD1() const {
-          return d1_;
-     };
-     /// Returns size of d2
-     inline int sizeD2() const {
-          return 1;
-     };
-     /// Returns d2 as scalar
-     inline double getD2() const {
-          return d2_;
-     };
-     //@}
-
-
-protected:
-
-     /**@name Constructors, destructor<br>
-        <strong>NOTE</strong>: All constructors are protected. There's no need
-        to expose them, after all, this is an abstract class. */
-     //@{
-     /** Default constructor. */
-     ClpPdcoBase();
-     /** Destructor (has to be public) */
-public:
-     virtual ~ClpPdcoBase();
-protected:
-     // Copy
-     ClpPdcoBase(const ClpPdcoBase&);
-     // Assignment
-     ClpPdcoBase& operator=(const ClpPdcoBase&);
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Should be dense vectors
-     double d1_;
-     double d2_;
-     /// type (may be useful)
-     int type_;
-     //@}
-};
-
-#endif

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

@@ -1,290 +0,0 @@
-/* $Id: ClpPlusMinusOneMatrix.hpp 2078 2015-01-05 12:39:49Z forrest $ */
-// 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 ClpPlusMinusOneMatrix_H
-#define ClpPlusMinusOneMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpMatrixBase.hpp"
-
-/** This implements a simple +- one matrix as derived from ClpMatrixBase.
-
-*/
-
-class ClpPlusMinusOneMatrix : public ClpMatrixBase {
-
-public:
-     /**@name Useful methods */
-     //@{
-     /// Return a complete CoinPackedMatrix
-     virtual CoinPackedMatrix * getPackedMatrix() const;
-     /** Whether the packed matrix is column major ordered or not. */
-     virtual bool isColOrdered() const ;
-     /** Number of entries in the packed matrix. */
-     virtual  CoinBigIndex getNumElements() const;
-     /** Number of columns. */
-     virtual int getNumCols() const {
-          return numberColumns_;
-     }
-     /** Number of rows. */
-     virtual int getNumRows() const {
-          return numberRows_;
-     }
-
-     /** A vector containing the elements in the packed matrix. Note that there
-      might be gaps in this list, entries that do not belong to any
-      major-dimension vector. To get the actual elements one should look at
-      this vector together with vectorStarts and vectorLengths. */
-     virtual const double * getElements() const;
-     /** A vector containing the minor indices of the elements in the packed
-          matrix. Note that there might be gaps in this list, entries that do not
-          belong to any major-dimension vector. To get the actual elements one
-          should look at this vector together with vectorStarts and
-          vectorLengths. */
-     virtual const int * getIndices() const {
-          return indices_;
-     }
-     // and for advanced use
-     int * getMutableIndices() const {
-          return indices_;
-     }
-
-     virtual const CoinBigIndex * getVectorStarts() const;
-     /** The lengths of the major-dimension vectors. */
-     virtual const int * getVectorLengths() const;
-
-     /** Delete the columns whose indices are listed in <code>indDel</code>. */
-     virtual void deleteCols(const int numDel, const int * indDel);
-     /** Delete the rows whose indices are listed in <code>indDel</code>. */
-     virtual void deleteRows(const int numDel, const int * indDel);
-     /// Append Columns
-     virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
-     /// Append Rows
-     virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
-#ifndef SLIM_CLP
-     /** Append a set of rows/columns to the end of the matrix. Returns number of errors
-         i.e. if any of the new rows/columns contain an index that's larger than the
-         number of columns-1/rows-1 (if numberOther>0) or duplicates
-         If 0 then rows, 1 if columns */
-     virtual int appendMatrix(int number, int type,
-                              const CoinBigIndex * starts, const int * index,
-                              const double * element, int numberOther = -1);
-#endif
-     /** Returns a new matrix in reverse order without gaps */
-     virtual ClpMatrixBase * reverseOrderedCopy() const;
-     /// Returns number of elements in column part of basis
-     virtual CoinBigIndex countBasis(
-          const int * whichColumn,
-          int & numberColumnBasic);
-     /// Fills in column part of basis
-     virtual void fillBasis(ClpSimplex * model,
-                            const int * whichColumn,
-                            int & numberColumnBasic,
-                            int * row, int * start,
-                            int * rowCount, int * columnCount,
-                            CoinFactorizationDouble * element);
-     /** Given positive integer weights for each row fills in sum of weights
-         for each column (and slack).
-         Returns weights vector
-     */
-     virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
-     /** Returns largest and smallest elements of both signs.
-         Largest refers to largest absolute value.
-     */
-     virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
-                                  double & smallestPositive, double & largestPositive);
-     /** Unpacks a column into an CoinIndexedvector
-      */
-     virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
-                         int column) const ;
-     /** Unpacks a column into an CoinIndexedvector
-      ** in packed foramt
-         Note that model is NOT const.  Bounds and objective could
-         be modified if doing column generation (just for this variable) */
-     virtual void unpackPacked(ClpSimplex * model,
-                               CoinIndexedVector * rowArray,
-                               int column) const;
-     /** Adds multiple of a column into an CoinIndexedvector
-         You can use quickAdd to add to vector */
-     virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
-                      int column, double multiplier) const ;
-     /** Adds multiple of a column into an array */
-     virtual void add(const ClpSimplex * model, double * array,
-                      int column, double multiplier) const;
-     /// Allow any parts of a created CoinMatrix to be deleted
-     virtual void releasePackedMatrix() const;
-     /** Set the dimensions of the matrix. In effect, append new empty
-         columns/rows to the matrix. A negative number for either dimension
-         means that that dimension doesn't change. Otherwise the new dimensions
-         MUST be at least as large as the current ones otherwise an exception
-         is thrown. */
-     virtual void setDimensions(int numrows, int numcols);
-     /// Just checks matrix valid - will say if dimensions not quite right if detail
-     void checkValid(bool detail) const;
-     //@}
-
-     /**@name Matrix times vector methods */
-     //@{
-     /** Return <code>y + A * scalar *x</code> in <code>y</code>.
-         @pre <code>x</code> must be of size <code>numColumns()</code>
-         @pre <code>y</code> must be of size <code>numRows()</code> */
-     virtual void times(double scalar,
-                        const double * x, double * y) const;
-     /// And for scaling
-     virtual void times(double scalar,
-                        const double * x, double * y,
-                        const double * rowScale,
-                        const double * columnScale) const;
-     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
-         @pre <code>x</code> must be of size <code>numRows()</code>
-         @pre <code>y</code> must be of size <code>numColumns()</code> */
-     virtual void transposeTimes(double scalar,
-                                 const double * x, double * y) const;
-     /// And for scaling
-     virtual void transposeTimes(double scalar,
-                                 const double * x, double * y,
-                                 const double * rowScale,
-                                 const double * columnScale, double * spare = NULL) const;
-     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
-     Can use y as temporary array (will be empty at end)
-     Note - If x packed mode - then z packed mode
-     Squashes small elements and knows about ClpSimplex */
-     virtual void transposeTimes(const ClpSimplex * model, double scalar,
-                                 const CoinIndexedVector * x,
-                                 CoinIndexedVector * y,
-                                 CoinIndexedVector * z) const;
-     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
-     Can use y as temporary array (will be empty at end)
-     Note - If x packed mode - then z packed mode
-     Squashes small elements and knows about ClpSimplex.
-     This version uses row copy*/
-     virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
-                                      const CoinIndexedVector * x,
-                                      CoinIndexedVector * y,
-                                      CoinIndexedVector * z) const;
-     /** Return <code>x *A</code> in <code>z</code> but
-     just for indices in y.
-     Note - z always packed mode */
-     virtual void subsetTransposeTimes(const ClpSimplex * model,
-                                       const CoinIndexedVector * x,
-                                       const CoinIndexedVector * y,
-                                       CoinIndexedVector * z) const;
-     /** Returns true if can combine transposeTimes and subsetTransposeTimes
-         and if it would be faster */
-     virtual bool canCombine(const ClpSimplex * model,
-                             const CoinIndexedVector * pi) const;
-     /// Updates two arrays for steepest
-     virtual void transposeTimes2(const ClpSimplex * model,
-                                  const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
-                                  const CoinIndexedVector * pi2,
-                                  CoinIndexedVector * spare,
-                                  double referenceIn, double devex,
-                                  // Array for exact devex to say what is in reference framework
-                                  unsigned int * reference,
-                                  double * weights, double scaleFactor);
-     /// Updates second array for steepest and does devex weights
-     virtual void subsetTimes2(const ClpSimplex * model,
-                               CoinIndexedVector * dj1,
-                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
-                               double referenceIn, double devex,
-                               // Array for exact devex to say what is in reference framework
-                               unsigned int * reference,
-                               double * weights, double scaleFactor);
-     //@}
-
-     /**@name Other */
-     //@{
-     /// Return starts of +1s
-     inline CoinBigIndex * startPositive() const {
-          return startPositive_;
-     }
-     /// Return starts of -1s
-     inline CoinBigIndex * startNegative() const {
-          return startNegative_;
-     }
-     //@}
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpPlusMinusOneMatrix();
-     /** Destructor */
-     virtual ~ClpPlusMinusOneMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpPlusMinusOneMatrix(const ClpPlusMinusOneMatrix&);
-     /** The copy constructor from an CoinPlusMinusOneMatrix.
-         If not a valid matrix then getIndices will be NULL and
-         startPositive[0] will have number of +1,
-         startPositive[1] will have number of -1,
-         startPositive[2] will have number of others,
-     */
-     ClpPlusMinusOneMatrix(const CoinPackedMatrix&);
-     /// Constructor from arrays
-     ClpPlusMinusOneMatrix(int numberRows, int numberColumns,
-                           bool columnOrdered, const int * indices,
-                           const CoinBigIndex * startPositive, const CoinBigIndex * startNegative);
-     /** Subset constructor (without gaps).  Duplicates are allowed
-         and order is as given */
-     ClpPlusMinusOneMatrix (const ClpPlusMinusOneMatrix & wholeModel,
-                            int numberRows, const int * whichRows,
-                            int numberColumns, const int * whichColumns);
-
-     ClpPlusMinusOneMatrix& operator=(const ClpPlusMinusOneMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     /** Subset clone (without gaps).  Duplicates are allowed
-         and order is as given */
-     virtual ClpMatrixBase * subsetClone (
-          int numberRows, const int * whichRows,
-          int numberColumns, const int * whichColumns) const ;
-     /// pass in copy (object takes ownership)
-     void passInCopy(int numberRows, int numberColumns,
-                     bool columnOrdered, int * indices,
-                     CoinBigIndex * startPositive, CoinBigIndex * startNegative);
-     /// Says whether it can do partial pricing
-     virtual bool canDoPartialPricing() const;
-     /// Partial pricing
-     virtual void partialPricing(ClpSimplex * model, double start, double end,
-                                 int & bestSequence, int & numberWanted);
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// For fake CoinPackedMatrix
-     mutable CoinPackedMatrix * matrix_;
-     mutable int * lengths_;
-     /// Start of +1's for each
-     CoinBigIndex * COIN_RESTRICT startPositive_;
-     /// Start of -1's for each
-     CoinBigIndex * COIN_RESTRICT startNegative_;
-     /// Data -1, then +1 rows in pairs (row==-1 if one entry)
-     int * COIN_RESTRICT indices_;
-     /// Number of rows
-     int numberRows_;
-     /// Number of columns
-     int numberColumns_;
-#ifdef CLP_PLUS_ONE_MATRIX
-     /** Other flags (could have columnOrdered_?)
-	 1 bit - says just +1
-     */
-     mutable int otherFlags_;
-#endif
-     /// True if column ordered
-     bool columnOrdered_;
-
-     //@}
-};
-
-#endif