ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,229 +0,0 @@
-/* $Id: ClpNetworkMatrix.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 ClpNetworkMatrix_H
-#define ClpNetworkMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpMatrixBase.hpp"
-
-/** This implements a simple network matrix as derived from ClpMatrixBase.
-
-If you want more sophisticated version then you could inherit from this.
-Also you might want to allow networks with gain */
-
-class ClpNetworkMatrix : 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 {
-          return true;
-     }
-     /** Number of entries in the packed matrix. */
-     virtual  CoinBigIndex getNumElements() const {
-          return 2 * numberColumns_;
-     }
-     /** 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_;
-     }
-
-     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 format
-         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 ;
-     /// 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);
-     //@}
-
-     /**@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 *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;
-     //@}
-
-     /**@name Other */
-     //@{
-     /// Return true if really network, false if has slacks
-     inline bool trueNetwork() const {
-          return trueNetwork_;
-     }
-     //@}
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpNetworkMatrix();
-     /** Constructor from two arrays */
-     ClpNetworkMatrix(int numberColumns, const int * head,
-                      const int * tail);
-     /** Destructor */
-     virtual ~ClpNetworkMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpNetworkMatrix(const ClpNetworkMatrix&);
-     /** The copy constructor from an CoinNetworkMatrix. */
-     ClpNetworkMatrix(const CoinPackedMatrix&);
-
-     ClpNetworkMatrix& operator=(const ClpNetworkMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     /** Subset constructor (without gaps).  Duplicates are allowed
-         and order is as given */
-     ClpNetworkMatrix (const ClpNetworkMatrix & wholeModel,
-                       int numberRows, const int * whichRows,
-                       int numberColumns, const int * whichColumns);
-     /** 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 ;
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// For fake CoinPackedMatrix
-     mutable CoinPackedMatrix * matrix_;
-     mutable int * lengths_;
-     /// Data -1, then +1 rows in pairs (row==-1 if one entry)
-     int * indices_;
-     /// Number of rows
-     int numberRows_;
-     /// Number of columns
-     int numberColumns_;
-     /// True if all entries have two elements
-     bool trueNetwork_;
-
-     //@}
-};
-
-#endif

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

@@ -1,349 +0,0 @@
-/* $Id: ClpNode.hpp 1910 2013-01-27 02:00:13Z 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).
-
-#ifndef ClpNode_H
-#define ClpNode_H
-
-#include "CoinPragma.hpp"
-
-// This implements all stuff for Clp fathom
-/** This contains what is in a Clp "node"
-
- */
-
-class ClpFactorization;
-class ClpDualRowSteepest;
-class ClpNodeStuff;
-class ClpNode {
-
-public:
-     /**@name Useful methods */
-     //@{
-     /** Applies node to model
-         0 - just tree bounds
-         1 - tree bounds and basis etc
-         2 - saved bounds and basis etc
-     */
-     void applyNode(ClpSimplex * model, int doBoundsEtc );
-     /// Choose a new variable
-     void chooseVariable(ClpSimplex * model, ClpNodeStuff * info);
-     /// Fix on reduced costs
-     int fixOnReducedCosts(ClpSimplex * model);
-     /// Create odd arrays
-     void createArrays(ClpSimplex * model);
-     /// Clean up as crunch is different model
-     void cleanUpForCrunch();
-     //@}
-
-     /**@name Gets and sets */
-     //@{
-     /// Objective value
-     inline double objectiveValue() const {
-          return objectiveValue_;
-     }
-     /// Set objective value
-     inline void setObjectiveValue(double value) {
-          objectiveValue_ = value;
-     }
-     /// Primal solution
-     inline const double * primalSolution() const {
-          return primalSolution_;
-     }
-     /// Dual solution
-     inline const double * dualSolution() const {
-          return dualSolution_;
-     }
-     /// Initial value of integer variable
-     inline double branchingValue() const {
-          return branchingValue_;
-     }
-     /// Sum infeasibilities
-     inline double sumInfeasibilities() const {
-          return sumInfeasibilities_;
-     }
-     /// Number infeasibilities
-     inline int numberInfeasibilities() const {
-          return numberInfeasibilities_;
-     }
-     /// Relative depth
-     inline int depth() const {
-          return depth_;
-     }
-     /// Estimated solution value
-     inline double estimatedSolution() const {
-          return estimatedSolution_;
-     }
-     /** Way for integer variable -1 down , +1 up */
-     int way() const;
-     /// Return true if branch exhausted
-     bool fathomed() const;
-     /// Change state of variable i.e. go other way
-     void changeState();
-     /// Sequence number of integer variable (-1 if none)
-     inline int sequence() const {
-          return sequence_;
-     }
-     /// If odd arrays exist
-     inline bool oddArraysExist() const {
-          return lower_ != NULL;
-     }
-     /// Status array
-     inline const unsigned char * statusArray() const {
-          return status_;
-     }
-     //@}
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpNode();
-     /// Constructor from model
-     ClpNode (ClpSimplex * model, const ClpNodeStuff * stuff, int depth);
-     /// Does work of constructor (partly so gdb will work)
-     void gutsOfConstructor(ClpSimplex * model, const ClpNodeStuff * stuff,
-                            int arraysExist, int depth);
-     /** Destructor */
-     virtual ~ClpNode();
-     //@}
-
-     /**@name Copy methods (at present illegal - will abort) */
-     //@{
-     /** The copy constructor. */
-     ClpNode(const ClpNode&);
-     /// Operator =
-     ClpNode& operator=(const ClpNode&);
-     //@}
-
-protected:
-// For state of branch
-     typedef struct {
-          unsigned int firstBranch: 1; //  nonzero if first branch on variable is up
-          unsigned int branch: 2; //  0 means do first branch next, 1 second, 2 finished
-          unsigned int spare: 29;
-     } branchState;
-     /**@name Data */
-     //@{
-     /// Initial value of integer variable
-     double branchingValue_;
-     /// Value of objective
-     double objectiveValue_;
-     /// Sum of infeasibilities
-     double sumInfeasibilities_;
-     /// Estimated solution value
-     double estimatedSolution_;
-     /// Factorization
-     ClpFactorization * factorization_;
-     /// Steepest edge weights
-     ClpDualRowSteepest * weights_;
-     /// Status vector
-     unsigned char * status_;
-     /// Primal solution
-     double * primalSolution_;
-     /// Dual solution
-     double * dualSolution_;
-     /// Integer lower bounds (only used in fathomMany)
-     int * lower_;
-     /// Integer upper bounds (only used in fathomMany)
-     int * upper_;
-     /// Pivot variables for factorization
-     int * pivotVariables_;
-     /// Variables fixed by reduced costs (at end of branch) 0x10000000 added if fixed to UB
-     int * fixed_;
-     /// State of branch
-     branchState branchState_;
-     /// Sequence number of integer variable (-1 if none)
-     int sequence_;
-     /// Number of infeasibilities
-     int numberInfeasibilities_;
-     /// Relative depth
-     int depth_;
-     /// Number fixed by reduced cost
-     int numberFixed_;
-     /// Flags - 1 duals scaled
-     int flags_;
-     /// Maximum number fixed by reduced cost
-     int maximumFixed_;
-     /// Maximum rows so far
-     int maximumRows_;
-     /// Maximum columns so far
-     int maximumColumns_;
-     /// Maximum Integers so far
-     int maximumIntegers_;
-     //@}
-};
-class ClpNodeStuff {
-
-public:
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpNodeStuff();
-     /** Destructor */
-     virtual ~ClpNodeStuff();
-     //@}
-
-     /**@name Copy methods (only copies ints etc, nulls arrays) */
-     //@{
-     /** The copy constructor. */
-     ClpNodeStuff(const ClpNodeStuff&);
-     /// Operator =
-     ClpNodeStuff& operator=(const ClpNodeStuff&);
-     /// Zaps stuff 1 - arrays, 2 ints, 3 both
-     void zap(int type);
-     //@}
-
-
-     /**@name Fill methods */
-     //@{
-     /** Fill with pseudocosts */
-     void fillPseudoCosts(const double * down, const double * up,
-                          const int * priority,
-                          const int * numberDown, const int * numberUp,
-                          const int * numberDownInfeasible, const int * numberUpInfeasible,
-                          int number);
-     /// Update pseudo costs
-     void update(int way, int sequence, double change, bool feasible);
-     /// Return maximum number of nodes
-     int maximumNodes() const;
-     /// Return maximum space for nodes
-     int maximumSpace() const;
-     //@}
-
-public:
-     /**@name Data */
-     //@{
-     /// Integer tolerance
-     double integerTolerance_;
-     /// Integer increment
-     double integerIncrement_;
-     /// Small change in branch
-     double smallChange_;
-     /// Down pseudo costs
-     double * downPseudo_;
-     /// Up pseudo costs
-     double * upPseudo_;
-     /// Priority
-     int * priority_;
-     /// Number of times down
-     int * numberDown_;
-     /// Number of times up
-     int * numberUp_;
-     /// Number of times down infeasible
-     int * numberDownInfeasible_;
-     /// Number of times up infeasible
-     int * numberUpInfeasible_;
-     /// Copy of costs (local)
-     double * saveCosts_;
-     /// Array of ClpNodes
-     ClpNode ** nodeInfo_;
-     /// Large model if crunched
-     ClpSimplex * large_;
-     /// Which rows in large model
-     int * whichRow_;
-     /// Which columns in large model
-     int * whichColumn_;
-#ifndef NO_FATHOM_PRINT
-     /// Cbc's message handler
-     CoinMessageHandler * handler_;
-#endif
-     /// Number bounds in large model
-     int nBound_;
-     /// Save of specialOptions_ (local)
-     int saveOptions_;
-     /** Options to pass to solver
-         1 - create external reduced costs for columns
-         2 - create external reduced costs for rows
-         4 - create external row activity (columns always done)
-         Above only done if feasible
-         32 - just create up to nDepth_+1 nodes
-         65536 - set if activated
-     */
-     int solverOptions_;
-     /// Maximum number of nodes to do
-     int maximumNodes_;
-     /// Number before trust from CbcModel
-     int numberBeforeTrust_;
-     /// State of search from CbcModel
-     int stateOfSearch_;
-     /// Number deep
-     int nDepth_;
-     /// Number nodes returned (-1 if fathom aborted)
-     int nNodes_;
-     /// Number of nodes explored
-     int numberNodesExplored_;
-     /// Number of iterations
-     int numberIterations_;
-     /// Type of presolve - 0 none, 1 crunch
-     int presolveType_;
-#ifndef NO_FATHOM_PRINT
-     /// Depth passed in
-     int startingDepth_;
-     /// Node at which called
-     int nodeCalled_;
-#endif
-     //@}
-};
-class ClpHashValue {
-
-public:
-     /**@name Useful methods */
-     //@{
-     /// Return index or -1 if not found
-     int index(double value) const;
-     /// Add value to list and return index
-     int addValue(double value) ;
-     /// Number of different entries
-     inline int numberEntries() const {
-          return numberHash_;
-     }
-     //@}
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpHashValue();
-     /** Useful constructor. */
-     ClpHashValue(ClpSimplex * model);
-     /** Destructor */
-     virtual ~ClpHashValue();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpHashValue(const ClpHashValue&);
-     /// =
-     ClpHashValue& operator=(const ClpHashValue&);
-     //@}
-private:
-     /**@name private stuff */
-     //@{
-     /** returns hash */
-     int hash(double value) const;
-     /// Resizes
-     void resize(bool increaseMax);
-     //@}
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Data
-     // for hashing
-     typedef struct {
-          double value;
-          int index, next;
-     } CoinHashLink;
-     /// Hash table
-     mutable CoinHashLink *hash_;
-     /// Number of entries in hash table
-     int numberHash_;
-     /// Maximum number of entries in hash table i.e. size
-     int maxHash_;
-     /// Last used space
-     int lastUsed_;
-     //@}
-};
-#endif