ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,183 +0,0 @@
-/* $Id: ClpDummyMatrix.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 ClpDummyMatrix_H
-#define ClpDummyMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpMatrixBase.hpp"
-
-/** This implements a dummy matrix as derived from ClpMatrixBase.
-    This is so you can do ClpPdco but may come in useful elsewhere.
-    It just has dimensions but no data
-*/
-
-
-class ClpDummyMatrix : 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 numberElements_;
-     }
-     /** 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;
-
-     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);
-     /** 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);
-     /** 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
-     /// Allow any parts of a created CoinPackedMatrix to be deleted
-     virtual void releasePackedMatrix() 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) const;
-
-     using ClpMatrixBase::transposeTimes ;
-     /** 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 */
-     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 - If x packed mode - then z packed mode
-     Squashes small elements and knows about ClpSimplex */
-     virtual void subsetTransposeTimes(const ClpSimplex * model,
-                                       const CoinIndexedVector * x,
-                                       const CoinIndexedVector * y,
-                                       CoinIndexedVector * z) const;
-     //@}
-
-     /**@name Other */
-     //@{
-     //@}
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpDummyMatrix();
-     /// Constructor with data
-     ClpDummyMatrix(int numberColumns, int numberRows,
-                    int numberElements);
-     /** Destructor */
-     virtual ~ClpDummyMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpDummyMatrix(const ClpDummyMatrix&);
-     /** The copy constructor from an CoinDummyMatrix. */
-     ClpDummyMatrix(const CoinPackedMatrix&);
-
-     ClpDummyMatrix& operator=(const ClpDummyMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Number of rows
-     int numberRows_;
-     /// Number of columns
-     int numberColumns_;
-     /// Number of elements
-     int numberElements_;
-
-     //@}
-};
-
-#endif

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

@@ -1,186 +0,0 @@
-/* $Id: ClpDynamicExampleMatrix.hpp 1936 2013-04-09 10:29:27Z forrest $ */
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef ClpDynamicExampleMatrix_H
-#define ClpDynamicExampleMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpDynamicMatrix.hpp"
-class ClpSimplex;
-/** This implements a dynamic matrix when we have a limit on the number of
-    "interesting rows". This version inherits from ClpDynamicMatrix and knows that
-    the real matrix is gub.  This acts just like ClpDynamicMatrix but generates columns.
-    This "generates" columns by choosing from stored set.  It is maent as a starting point
-    as to how you could use shortest path to generate columns.
-
-    So it has its own copy of all data needed.  It populates ClpDynamicWatrix with enough
-    to allow for gub keys and active variables.  In turn ClpDynamicMatrix populates
-    a CoinPackedMatrix with active columns and rows.
-
-    As there is one copy here and one in ClpDynamicmatrix these names end in Gen_
-
-    It is obviously more efficient to just use ClpDynamicMatrix but the ideas is to
-    show how much code a user would have to write.
-
-    This does not work very well with bounds
-
-*/
-
-class ClpDynamicExampleMatrix : public ClpDynamicMatrix {
-
-public:
-     /**@name Main functions provided */
-     //@{
-     /// Partial pricing
-     virtual void partialPricing(ClpSimplex * model, double start, double end,
-                                 int & bestSequence, int & numberWanted);
-
-     /** Creates a variable.  This is called after partial pricing and will modify matrix.
-         Will update bestSequence.
-     */
-     virtual void createVariable(ClpSimplex * model, int & bestSequence);
-     /** If addColumn forces compression then this allows descendant to know what to do.
-         If >= then entry stayed in, if -1 then entry went out to lower bound.of zero.
-         Entries at upper bound (really nonzero) never go out (at present).
-     */
-     virtual void packDown(const int * in, int numberToPack);
-     //@}
-
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpDynamicExampleMatrix();
-     /** This is the real constructor.
-         It assumes factorization frequency will not be changed.
-         This resizes model !!!!
-         The contents of original matrix in model will be taken over and original matrix
-         will be sanitized so can be deleted (to avoid a very small memory leak)
-      */
-     ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
-                             int numberColumns, const int * starts,
-                             const double * lower, const double * upper,
-                             const int * startColumn, const int * row,
-                             const double * element, const double * cost,
-                             const double * columnLower = NULL, const double * columnUpper = NULL,
-                             const unsigned char * status = NULL,
-                             const unsigned char * dynamicStatus = NULL,
-                             int numberIds = 0, const int *ids = NULL);
-#if 0
-     /// This constructor just takes over ownership (except for lower, upper)
-     ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
-                             int numberColumns, int * starts,
-                             const double * lower, const double * upper,
-                             int * startColumn, int * row,
-                             double * element, double * cost,
-                             double * columnLower = NULL, double * columnUpper = NULL,
-                             const unsigned char * status = NULL,
-                             const unsigned char * dynamicStatus = NULL,
-                             int numberIds = 0, const int *ids = NULL);
-#endif
-     /** Destructor */
-     virtual ~ClpDynamicExampleMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpDynamicExampleMatrix(const ClpDynamicExampleMatrix&);
-     ClpDynamicExampleMatrix& operator=(const ClpDynamicExampleMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     //@}
-     /**@name gets and sets */
-     //@{
-     /// Starts of each column
-     inline CoinBigIndex * startColumnGen() const {
-          return startColumnGen_;
-     }
-     /// rows
-     inline int * rowGen() const {
-          return rowGen_;
-     }
-     /// elements
-     inline double * elementGen() const {
-          return elementGen_;
-     }
-     /// costs
-     inline double * costGen() const {
-          return costGen_;
-     }
-     /// full starts
-     inline int * fullStartGen() const {
-          return fullStartGen_;
-     }
-     /// ids in next level matrix
-     inline int * idGen() const {
-          return idGen_;
-     }
-     /// Optional lower bounds on columns
-     inline double * columnLowerGen() const {
-          return columnLowerGen_;
-     }
-     /// Optional upper bounds on columns
-     inline double * columnUpperGen() const {
-          return columnUpperGen_;
-     }
-     /// size
-     inline int numberColumns() const {
-          return numberColumns_;
-     }
-     inline void setDynamicStatusGen(int sequence, DynamicStatus status) {
-          unsigned char & st_byte = dynamicStatusGen_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | status);
-     }
-     inline DynamicStatus getDynamicStatusGen(int sequence) const {
-          return static_cast<DynamicStatus> (dynamicStatusGen_[sequence] & 7);
-     }
-     /// Whether flagged
-     inline bool flaggedGen(int i) const {
-          return (dynamicStatusGen_[i] & 8) != 0;
-     }
-     inline void setFlaggedGen(int i) {
-          dynamicStatusGen_[i] = static_cast<unsigned char>(dynamicStatusGen_[i] | 8);
-     }
-     inline void unsetFlagged(int i) {
-          dynamicStatusGen_[i] = static_cast<unsigned char>(dynamicStatusGen_[i] & ~8);
-     }
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// size
-     int numberColumns_;
-     /// Starts of each column
-     CoinBigIndex * startColumnGen_;
-     /// rows
-     int * rowGen_;
-     /// elements
-     double * elementGen_;
-     /// costs
-     double * costGen_;
-     /// start of each set
-     int * fullStartGen_;
-     /// for status and which bound
-     unsigned char * dynamicStatusGen_;
-     /** identifier for each variable up one level (startColumn_, etc).  This is
-         of length maximumGubColumns_.  For this version it is just sequence number
-         at this level */
-     int * idGen_;
-     /// Optional lower bounds on columns
-     double * columnLowerGen_;
-     /// Optional upper bounds on columns
-     double * columnUpperGen_;
-     //@}
-};
-
-#endif

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

@@ -1,381 +0,0 @@
-/* $Id: ClpDynamicMatrix.hpp 1755 2011-06-28 18:24:31Z lou $ */
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef ClpDynamicMatrix_H
-#define ClpDynamicMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpPackedMatrix.hpp"
-class ClpSimplex;
-/** This implements  a dynamic matrix when we have a limit on the number of
-    "interesting rows". This version inherits from ClpPackedMatrix and knows that
-    the real matrix is gub.  A later version could use shortest path to generate columns.
-
-*/
-
-class ClpDynamicMatrix : public ClpPackedMatrix {
-
-public:
-     /// enums for status of various sorts
-     enum DynamicStatus {
-          soloKey = 0x00,
-          inSmall = 0x01,
-          atUpperBound = 0x02,
-          atLowerBound = 0x03
-     };
-     /**@name Main functions provided */
-     //@{
-     /// Partial pricing
-     virtual void partialPricing(ClpSimplex * model, double start, double end,
-                                 int & bestSequence, int & numberWanted);
-
-     /**
-        update information for a pivot (and effective rhs)
-     */
-     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
-     /** Returns effective RHS offset if it is being used.  This is used for long problems
-         or big dynamic or anywhere where going through full columns is
-         expensive.  This may re-compute */
-     virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
-                                bool check = false);
-
-     using ClpPackedMatrix::times ;
-     /** 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;
-     /// Modifies rhs offset
-     void modifyOffset(int sequence, double amount);
-     /// Gets key value when none in small
-     double keyValue(int iSet) const;
-     /**
-         mode=0  - Set up before "updateTranspose" and "transposeTimes" for duals using extended
-                   updates array (and may use other if dual values pass)
-         mode=1  - Update dual solution after "transposeTimes" using extended rows.
-         mode=2  - Compute all djs and compute key dual infeasibilities
-         mode=3  - Report on key dual infeasibilities
-         mode=4  - Modify before updateTranspose in partial pricing
-     */
-     virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
-                               double * other, int mode);
-     /**
-         mode=0  - Create list of non-key basics in pivotVariable_ using
-                   number as numberBasic in and out
-         mode=1  - Set all key variables as basic
-         mode=2  - return number extra rows needed, number gives maximum number basic
-         mode=3  - before replaceColumn
-         mode=4  - return 1 if can do primal, 2 if dual, 3 if both
-         mode=5  - save any status stuff (when in good state)
-         mode=6  - restore status stuff
-         mode=7  - flag given variable (normally sequenceIn)
-         mode=8  - unflag all variables
-         mode=9  - synchronize costs
-         mode=10  - return 1 if there may be changing bounds on variable (column generation)
-         mode=11  - make sure set is clean (used when a variable rejected - but not flagged)
-         mode=12  - after factorize but before permute stuff
-         mode=13  - at end of simplex to delete stuff
-     */
-     virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
-     /** Purely for column generation and similar ideas.  Allows
-         matrix and any bounds or costs to be updated (sensibly).
-         Returns non-zero if any changes.
-     */
-     virtual int refresh(ClpSimplex * model);
-     /** Creates a variable.  This is called after partial pricing and will modify matrix.
-         Will update bestSequence.
-     */
-     virtual void createVariable(ClpSimplex * model, int & bestSequence);
-     /// Returns reduced cost of a variable
-     virtual double reducedCost( ClpSimplex * model, int sequence) const;
-     /// Does gub crash
-     void gubCrash();
-     /// Writes out model (without names)
-     void writeMps(const char * name);
-     /// Populates initial matrix from dynamic status
-     void initialProblem();
-     /** Adds in a column to gub structure (called from descendant) and returns sequence */
-     int addColumn(int numberEntries, const int * row, const double * element,
-                   double cost, double lower, double upper, int iSet,
-                   DynamicStatus status);
-     /** If addColumn forces compression then this allows descendant to know what to do.
-         If >=0 then entry stayed in, if -1 then entry went out to lower bound.of zero.
-         Entries at upper bound (really nonzero) never go out (at present).
-     */
-     virtual void packDown(const int * , int ) {}
-     /// Gets lower bound (to simplify coding)
-     inline double columnLower(int sequence) const {
-          if (columnLower_) return columnLower_[sequence];
-          else return 0.0;
-     }
-     /// Gets upper bound (to simplify coding)
-     inline double columnUpper(int sequence) const {
-          if (columnUpper_) return columnUpper_[sequence];
-          else return COIN_DBL_MAX;
-     }
-
-     //@}
-
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpDynamicMatrix();
-     /** This is the real constructor.
-         It assumes factorization frequency will not be changed.
-         This resizes model !!!!
-         The contents of original matrix in model will be taken over and original matrix
-         will be sanitized so can be deleted (to avoid a very small memory leak)
-      */
-     ClpDynamicMatrix(ClpSimplex * model, int numberSets,
-                      int numberColumns, const int * starts,
-                      const double * lower, const double * upper,
-                      const CoinBigIndex * startColumn, const int * row,
-                      const double * element, const double * cost,
-                      const double * columnLower = NULL, const double * columnUpper = NULL,
-                      const unsigned char * status = NULL,
-                      const unsigned char * dynamicStatus = NULL);
-
-     /** Destructor */
-     virtual ~ClpDynamicMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpDynamicMatrix(const ClpDynamicMatrix&);
-     /** The copy constructor from an CoinPackedMatrix. */
-     ClpDynamicMatrix(const CoinPackedMatrix&);
-
-     ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     //@}
-     /**@name gets and sets */
-     //@{
-     /// Status of row slacks
-     inline ClpSimplex::Status getStatus(int sequence) const {
-          return static_cast<ClpSimplex::Status> (status_[sequence] & 7);
-     }
-     inline void setStatus(int sequence, ClpSimplex::Status status) {
-          unsigned char & st_byte = status_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | status);
-     }
-     /// Whether flagged slack
-     inline bool flaggedSlack(int i) const {
-          return (status_[i] & 8) != 0;
-     }
-     inline void setFlaggedSlack(int i) {
-          status_[i] = static_cast<unsigned char>(status_[i] | 8);
-     }
-     inline void unsetFlaggedSlack(int i) {
-          status_[i] = static_cast<unsigned char>(status_[i] & ~8);
-     }
-     /// Number of sets (dynamic rows)
-     inline int numberSets() const {
-          return numberSets_;
-     }
-     /// Number of possible gub variables
-     inline int numberGubEntries() const
-     { return startSet_[numberSets_];}
-     /// Sets
-     inline int * startSets() const
-     { return startSet_;}
-     /// Whether flagged
-     inline bool flagged(int i) const {
-          return (dynamicStatus_[i] & 8) != 0;
-     }
-     inline void setFlagged(int i) {
-          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] | 8);
-     }
-     inline void unsetFlagged(int i) {
-          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8);
-     }
-     inline void setDynamicStatus(int sequence, DynamicStatus status) {
-          unsigned char & st_byte = dynamicStatus_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | status);
-     }
-     inline DynamicStatus getDynamicStatus(int sequence) const {
-          return static_cast<DynamicStatus> (dynamicStatus_[sequence] & 7);
-     }
-     /// Saved value of objective offset
-     inline double objectiveOffset() const {
-          return objectiveOffset_;
-     }
-     /// Starts of each column
-     inline CoinBigIndex * startColumn() const {
-          return startColumn_;
-     }
-     /// rows
-     inline int * row() const {
-          return row_;
-     }
-     /// elements
-     inline double * element() const {
-          return element_;
-     }
-     /// costs
-     inline double * cost() const {
-          return cost_;
-     }
-     /// ids of active columns (just index here)
-     inline int * id() const {
-          return id_;
-     }
-     /// Optional lower bounds on columns
-     inline double * columnLower() const {
-          return columnLower_;
-     }
-     /// Optional upper bounds on columns
-     inline double * columnUpper() const {
-          return columnUpper_;
-     }
-     /// Lower bounds on sets
-     inline double * lowerSet() const {
-          return lowerSet_;
-     }
-     /// Upper bounds on sets
-     inline double * upperSet() const {
-          return upperSet_;
-     }
-     /// size
-     inline int numberGubColumns() const {
-          return numberGubColumns_;
-     }
-     /// first free
-     inline int firstAvailable() const {
-          return firstAvailable_;
-     }
-     /// first dynamic
-     inline int firstDynamic() const {
-          return firstDynamic_;
-     }
-     /// number of columns in dynamic model
-     inline int lastDynamic() const {
-          return lastDynamic_;
-     }
-     /// number of rows in original model
-     inline int numberStaticRows() const {
-          return numberStaticRows_;
-     }
-     /// size of working matrix (max)
-     inline int numberElements() const {
-          return numberElements_;
-     }
-     inline int * keyVariable() const {
-          return keyVariable_;
-     }
-     /// Switches off dj checking each factorization (for BIG models)
-     void switchOffCheck();
-     /// Status region for gub slacks
-     inline unsigned char * gubRowStatus() const {
-          return status_;
-     }
-     /// Status region for gub variables
-     inline unsigned char * dynamicStatus() const {
-          return dynamicStatus_;
-     }
-     /// Returns which set a variable is in
-     int whichSet (int sequence) const;
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Sum of dual infeasibilities
-     double sumDualInfeasibilities_;
-     /// Sum of primal infeasibilities
-     double sumPrimalInfeasibilities_;
-     /// Sum of Dual infeasibilities using tolerance based on error in duals
-     double sumOfRelaxedDualInfeasibilities_;
-     /// Sum of Primal infeasibilities using tolerance based on error in primals
-     double sumOfRelaxedPrimalInfeasibilities_;
-     /// Saved best dual on gub row in pricing
-     double savedBestGubDual_;
-     /// Saved best set in pricing
-     int savedBestSet_;
-     /// Backward pointer to pivot row !!!
-     int * backToPivotRow_;
-     /// Key variable of set (only accurate if none in small problem)
-     mutable int * keyVariable_;
-     /// Backward pointer to extra row
-     int * toIndex_;
-     // Reverse pointer from index to set
-     int * fromIndex_;
-     /// Number of sets (dynamic rows)
-     int numberSets_;
-     /// Number of active sets
-     int numberActiveSets_;
-     /// Saved value of objective offset
-     double objectiveOffset_;
-     /// Lower bounds on sets
-     double * lowerSet_;
-     /// Upper bounds on sets
-     double * upperSet_;
-     /// Status of slack on set
-     unsigned char * status_;
-     /// Pointer back to model
-     ClpSimplex * model_;
-     /// first free
-     int firstAvailable_;
-     /// first free when iteration started
-     int firstAvailableBefore_;
-     /// first dynamic
-     int firstDynamic_;
-     /// number of columns in dynamic model
-     int lastDynamic_;
-     /// number of rows in original model
-     int numberStaticRows_;
-     /// size of working matrix (max)
-     int numberElements_;
-     /// Number of dual infeasibilities
-     int numberDualInfeasibilities_;
-     /// Number of primal infeasibilities
-     int numberPrimalInfeasibilities_;
-     /** If pricing will declare victory (i.e. no check every factorization).
-         -1 - always check
-         0  - don't check
-         1  - in don't check mode but looks optimal
-     */
-     int noCheck_;
-     /// Infeasibility weight when last full pass done
-     double infeasibilityWeight_;
-     /// size
-     int numberGubColumns_;
-     /// current maximum number of columns (then compress)
-     int maximumGubColumns_;
-     /// current maximum number of elemnts (then compress)
-     int maximumElements_;
-     /// Start of each set
-     int * startSet_;
-     /// next in chain
-     int * next_;
-     /// Starts of each column
-     CoinBigIndex * startColumn_;
-     /// rows
-     int * row_;
-     /// elements
-     double * element_;
-     /// costs
-     double * cost_;
-     /// ids of active columns (just index here)
-     int * id_;
-     /// for status and which bound
-     unsigned char * dynamicStatus_;
-     /// Optional lower bounds on columns
-     double * columnLower_;
-     /// Optional upper bounds on columns
-     double * columnUpper_;
-     //@}
-};
-
-#endif