Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (4 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpDynamicMatrix.hpp

    r2271 r2385  
    66#ifndef ClpDynamicMatrix_H
    77#define ClpDynamicMatrix_H
    8 
    98
    109#include "CoinPragma.hpp"
     
    2120
    2221public:
    23      /// enums for status of various sorts
    24      enum DynamicStatus {
    25           soloKey = 0x00,
    26           inSmall = 0x01,
    27           atUpperBound = 0x02,
    28           atLowerBound = 0x03
    29      };
    30      /**@name Main functions provided */
    31      //@{
    32      /// Partial pricing
    33      virtual void partialPricing(ClpSimplex * model, double start, double end,
    34                                  int & bestSequence, int & numberWanted);
    35 
    36      /**
     22  /// enums for status of various sorts
     23  enum DynamicStatus {
     24    soloKey = 0x00,
     25    inSmall = 0x01,
     26    atUpperBound = 0x02,
     27    atLowerBound = 0x03
     28  };
     29  /**@name Main functions provided */
     30  //@{
     31  /// Partial pricing
     32  virtual void partialPricing(ClpSimplex *model, double start, double end,
     33    int &bestSequence, int &numberWanted);
     34
     35  /**
    3736        update information for a pivot (and effective rhs)
    3837     */
    39      virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
    40      /** Returns effective RHS offset if it is being used.  This is used for long problems
     38  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
     39  /** Returns effective RHS offset if it is being used.  This is used for long problems
    4140         or big dynamic or anywhere where going through full columns is
    4241         expensive.  This may re-compute */
    43      virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
    44                                 bool check = false);
    45 
    46      using ClpPackedMatrix::times ;
    47      /** Return <code>y + A * scalar *x</code> in <code>y</code>.
     42  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
     43    bool check = false);
     44
     45  using ClpPackedMatrix::times;
     46  /** Return <code>y + A * scalar *x</code> in <code>y</code>.
    4847         @pre <code>x</code> must be of size <code>numColumns()</code>
    4948         @pre <code>y</code> must be of size <code>numRows()</code> */
    50      virtual void times(double scalar,
    51                         const double * x, double * y) const;
    52      /// Modifies rhs offset
    53      void modifyOffset(int sequence, double amount);
    54      /// Gets key value when none in small
    55      double keyValue(int iSet) const;
    56      /**
     49  virtual void times(double scalar,
     50    const double *x, double *y) const;
     51  /// Modifies rhs offset
     52  void modifyOffset(int sequence, double amount);
     53  /// Gets key value when none in small
     54  double keyValue(int iSet) const;
     55  /**
    5756         mode=0  - Set up before "updateTranspose" and "transposeTimes" for duals using extended
    5857                   updates array (and may use other if dual values pass)
     
    6261         mode=4  - Modify before updateTranspose in partial pricing
    6362     */
    64      virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
    65                                double * other, int mode);
    66      /**
     63  virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array,
     64    double *other, int mode);
     65  /**
    6766         mode=0  - Create list of non-key basics in pivotVariable_ using
    6867                   number as numberBasic in and out
     
    8180         mode=13  - at end of simplex to delete stuff
    8281     */
    83      virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
    84      /** Purely for column generation and similar ideas.  Allows
     82  virtual int generalExpanded(ClpSimplex *model, int mode, int &number);
     83  /** Purely for column generation and similar ideas.  Allows
    8584         matrix and any bounds or costs to be updated (sensibly).
    8685         Returns non-zero if any changes.
    8786     */
    88      virtual int refresh(ClpSimplex * model);
    89      /** Creates a variable.  This is called after partial pricing and will modify matrix.
     87  virtual int refresh(ClpSimplex *model);
     88  /** Creates a variable.  This is called after partial pricing and will modify matrix.
    9089         Will update bestSequence.
    9190     */
    92      virtual void createVariable(ClpSimplex * model, int & bestSequence);
    93      /// Returns reduced cost of a variable
    94      virtual double reducedCost( ClpSimplex * model, int sequence) const;
    95      /// Does gub crash
    96      void gubCrash();
    97      /// Writes out model (without names)
    98      void writeMps(const char * name);
    99      /// Populates initial matrix from dynamic status
    100      void initialProblem();
    101      /** Adds in a column to gub structure (called from descendant) and returns sequence */
    102      int addColumn(CoinBigIndex numberEntries, const int * row, const double * element,
    103                    double cost, double lower, double upper, int iSet,
    104                    DynamicStatus status);
    105      /** If addColumn forces compression then this allows descendant to know what to do.
     91  virtual void createVariable(ClpSimplex *model, int &bestSequence);
     92  /// Returns reduced cost of a variable
     93  virtual double reducedCost(ClpSimplex *model, int sequence) const;
     94  /// Does gub crash
     95  void gubCrash();
     96  /// Writes out model (without names)
     97  void writeMps(const char *name);
     98  /// Populates initial matrix from dynamic status
     99  void initialProblem();
     100  /** Adds in a column to gub structure (called from descendant) and returns sequence */
     101  int addColumn(CoinBigIndex numberEntries, const int *row, const double *element,
     102    double cost, double lower, double upper, int iSet,
     103    DynamicStatus status);
     104  /** If addColumn forces compression then this allows descendant to know what to do.
    106105         If >=0 then entry stayed in, if -1 then entry went out to lower bound.of zero.
    107106         Entries at upper bound (really nonzero) never go out (at present).
    108107     */
    109      virtual void packDown(const int * , int ) {}
    110      /// Gets lower bound (to simplify coding)
    111      inline double columnLower(int sequence) const {
    112           if (columnLower_) return columnLower_[sequence];
    113           else return 0.0;
    114      }
    115      /// Gets upper bound (to simplify coding)
    116      inline double columnUpper(int sequence) const {
    117           if (columnUpper_) return columnUpper_[sequence];
    118           else return COIN_DBL_MAX;
    119      }
    120 
    121      //@}
    122 
    123 
    124 
    125      /**@name Constructors, destructor */
    126      //@{
    127      /** Default constructor. */
    128      ClpDynamicMatrix();
    129      /** This is the real constructor.
     108  virtual void packDown(const int *, int) {}
     109  /// Gets lower bound (to simplify coding)
     110  inline double columnLower(int sequence) const
     111  {
     112    if (columnLower_)
     113      return columnLower_[sequence];
     114    else
     115      return 0.0;
     116  }
     117  /// Gets upper bound (to simplify coding)
     118  inline double columnUpper(int sequence) const
     119  {
     120    if (columnUpper_)
     121      return columnUpper_[sequence];
     122    else
     123      return COIN_DBL_MAX;
     124  }
     125
     126  //@}
     127
     128  /**@name Constructors, destructor */
     129  //@{
     130  /** Default constructor. */
     131  ClpDynamicMatrix();
     132  /** This is the real constructor.
    130133         It assumes factorization frequency will not be changed.
    131134         This resizes model !!!!
     
    133136         will be sanitized so can be deleted (to avoid a very small memory leak)
    134137      */
    135      ClpDynamicMatrix(ClpSimplex * model, int numberSets,
    136                       int numberColumns, const int * starts,
    137                       const double * lower, const double * upper,
    138                       const CoinBigIndex * startColumn, const int * row,
    139                       const double * element, const double * cost,
    140                       const double * columnLower = NULL, const double * columnUpper = NULL,
    141                       const unsigned char * status = NULL,
    142                       const unsigned char * dynamicStatus = NULL);
    143 
    144      /** Destructor */
    145      virtual ~ClpDynamicMatrix();
    146      //@}
    147 
    148      /**@name Copy method */
    149      //@{
    150      /** The copy constructor. */
    151      ClpDynamicMatrix(const ClpDynamicMatrix&);
    152      /** The copy constructor from an CoinPackedMatrix. */
    153      ClpDynamicMatrix(const CoinPackedMatrix&);
    154 
    155      ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
    156      /// Clone
    157      virtual ClpMatrixBase * clone() const ;
    158      //@}
    159      /**@name gets and sets */
    160      //@{
    161      /// Status of row slacks
    162      inline ClpSimplex::Status getStatus(int sequence) const {
    163           return static_cast<ClpSimplex::Status> (status_[sequence] & 7);
    164      }
    165      inline void setStatus(int sequence, ClpSimplex::Status status) {
    166           unsigned char & st_byte = status_[sequence];
    167           st_byte = static_cast<unsigned char>(st_byte & ~7);
    168           st_byte = static_cast<unsigned char>(st_byte | status);
    169      }
    170      /// Whether flagged slack
    171      inline bool flaggedSlack(int i) const {
    172           return (status_[i] & 8) != 0;
    173      }
    174      inline void setFlaggedSlack(int i) {
    175           status_[i] = static_cast<unsigned char>(status_[i] | 8);
    176      }
    177      inline void unsetFlaggedSlack(int i) {
    178           status_[i] = static_cast<unsigned char>(status_[i] & ~8);
    179      }
    180      /// Number of sets (dynamic rows)
    181      inline int numberSets() const {
    182           return numberSets_;
    183      }
    184      /// Number of possible gub variables
    185      inline int numberGubEntries() const
    186      { return startSet_[numberSets_];}
    187      /// Sets
    188      inline int * startSets() const
    189      { return startSet_;}
    190      /// Whether flagged
    191      inline bool flagged(int i) const {
    192           return (dynamicStatus_[i] & 8) != 0;
    193      }
    194      inline void setFlagged(int i) {
    195           dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] | 8);
    196      }
    197      inline void unsetFlagged(int i) {
    198           dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8);
    199      }
    200      inline void setDynamicStatus(int sequence, DynamicStatus status) {
    201           unsigned char & st_byte = dynamicStatus_[sequence];
    202           st_byte = static_cast<unsigned char>(st_byte & ~7);
    203           st_byte = static_cast<unsigned char>(st_byte | status);
    204      }
    205      inline DynamicStatus getDynamicStatus(int sequence) const {
    206           return static_cast<DynamicStatus> (dynamicStatus_[sequence] & 7);
    207      }
    208      /// Saved value of objective offset
    209      inline double objectiveOffset() const {
    210           return objectiveOffset_;
    211      }
    212      /// Starts of each column
    213      inline CoinBigIndex * startColumn() const {
    214           return startColumn_;
    215      }
    216      /// rows
    217      inline int * row() const {
    218           return row_;
    219      }
    220      /// elements
    221      inline double * element() const {
    222           return element_;
    223      }
    224      /// costs
    225      inline double * cost() const {
    226           return cost_;
    227      }
    228      /// ids of active columns (just index here)
    229      inline int * id() const {
    230           return id_;
    231      }
    232      /// Optional lower bounds on columns
    233      inline double * columnLower() const {
    234           return columnLower_;
    235      }
    236      /// Optional upper bounds on columns
    237      inline double * columnUpper() const {
    238           return columnUpper_;
    239      }
    240      /// Lower bounds on sets
    241      inline double * lowerSet() const {
    242           return lowerSet_;
    243      }
    244      /// Upper bounds on sets
    245      inline double * upperSet() const {
    246           return upperSet_;
    247      }
    248      /// size
    249      inline int numberGubColumns() const {
    250           return numberGubColumns_;
    251      }
    252      /// first free
    253      inline int firstAvailable() const {
    254           return firstAvailable_;
    255      }
    256      /// first dynamic
    257      inline int firstDynamic() const {
    258           return firstDynamic_;
    259      }
    260      /// number of columns in dynamic model
    261      inline int lastDynamic() const {
    262           return lastDynamic_;
    263      }
    264      /// number of rows in original model
    265      inline int numberStaticRows() const {
    266           return numberStaticRows_;
    267      }
    268      /// size of working matrix (max)
    269      inline CoinBigIndex numberElements() const {
    270           return numberElements_;
    271      }
    272      inline int * keyVariable() const {
    273           return keyVariable_;
    274      }
    275      /// Switches off dj checking each factorization (for BIG models)
    276      void switchOffCheck();
    277      /// Status region for gub slacks
    278      inline unsigned char * gubRowStatus() const {
    279           return status_;
    280      }
    281      /// Status region for gub variables
    282      inline unsigned char * dynamicStatus() const {
    283           return dynamicStatus_;
    284      }
    285      /// Returns which set a variable is in
    286      int whichSet (int sequence) const;
    287      //@}
    288 
     138  ClpDynamicMatrix(ClpSimplex *model, int numberSets,
     139    int numberColumns, const int *starts,
     140    const double *lower, const double *upper,
     141    const CoinBigIndex *startColumn, const int *row,
     142    const double *element, const double *cost,
     143    const double *columnLower = NULL, const double *columnUpper = NULL,
     144    const unsigned char *status = NULL,
     145    const unsigned char *dynamicStatus = NULL);
     146
     147  /** Destructor */
     148  virtual ~ClpDynamicMatrix();
     149  //@}
     150
     151  /**@name Copy method */
     152  //@{
     153  /** The copy constructor. */
     154  ClpDynamicMatrix(const ClpDynamicMatrix &);
     155  /** The copy constructor from an CoinPackedMatrix. */
     156  ClpDynamicMatrix(const CoinPackedMatrix &);
     157
     158  ClpDynamicMatrix &operator=(const ClpDynamicMatrix &);
     159  /// Clone
     160  virtual ClpMatrixBase *clone() const;
     161  //@}
     162  /**@name gets and sets */
     163  //@{
     164  /// Status of row slacks
     165  inline ClpSimplex::Status getStatus(int sequence) const
     166  {
     167    return static_cast< ClpSimplex::Status >(status_[sequence] & 7);
     168  }
     169  inline void setStatus(int sequence, ClpSimplex::Status status)
     170  {
     171    unsigned char &st_byte = status_[sequence];
     172    st_byte = static_cast< unsigned char >(st_byte & ~7);
     173    st_byte = static_cast< unsigned char >(st_byte | status);
     174  }
     175  /// Whether flagged slack
     176  inline bool flaggedSlack(int i) const
     177  {
     178    return (status_[i] & 8) != 0;
     179  }
     180  inline void setFlaggedSlack(int i)
     181  {
     182    status_[i] = static_cast< unsigned char >(status_[i] | 8);
     183  }
     184  inline void unsetFlaggedSlack(int i)
     185  {
     186    status_[i] = static_cast< unsigned char >(status_[i] & ~8);
     187  }
     188  /// Number of sets (dynamic rows)
     189  inline int numberSets() const
     190  {
     191    return numberSets_;
     192  }
     193  /// Number of possible gub variables
     194  inline int numberGubEntries() const
     195  {
     196    return startSet_[numberSets_];
     197  }
     198  /// Sets
     199  inline int *startSets() const
     200  {
     201    return startSet_;
     202  }
     203  /// Whether flagged
     204  inline bool flagged(int i) const
     205  {
     206    return (dynamicStatus_[i] & 8) != 0;
     207  }
     208  inline void setFlagged(int i)
     209  {
     210    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] | 8);
     211  }
     212  inline void unsetFlagged(int i)
     213  {
     214    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] & ~8);
     215  }
     216  inline void setDynamicStatus(int sequence, DynamicStatus status)
     217  {
     218    unsigned char &st_byte = dynamicStatus_[sequence];
     219    st_byte = static_cast< unsigned char >(st_byte & ~7);
     220    st_byte = static_cast< unsigned char >(st_byte | status);
     221  }
     222  inline DynamicStatus getDynamicStatus(int sequence) const
     223  {
     224    return static_cast< DynamicStatus >(dynamicStatus_[sequence] & 7);
     225  }
     226  /// Saved value of objective offset
     227  inline double objectiveOffset() const
     228  {
     229    return objectiveOffset_;
     230  }
     231  /// Starts of each column
     232  inline CoinBigIndex *startColumn() const
     233  {
     234    return startColumn_;
     235  }
     236  /// rows
     237  inline int *row() const
     238  {
     239    return row_;
     240  }
     241  /// elements
     242  inline double *element() const
     243  {
     244    return element_;
     245  }
     246  /// costs
     247  inline double *cost() const
     248  {
     249    return cost_;
     250  }
     251  /// ids of active columns (just index here)
     252  inline int *id() const
     253  {
     254    return id_;
     255  }
     256  /// Optional lower bounds on columns
     257  inline double *columnLower() const
     258  {
     259    return columnLower_;
     260  }
     261  /// Optional upper bounds on columns
     262  inline double *columnUpper() const
     263  {
     264    return columnUpper_;
     265  }
     266  /// Lower bounds on sets
     267  inline double *lowerSet() const
     268  {
     269    return lowerSet_;
     270  }
     271  /// Upper bounds on sets
     272  inline double *upperSet() const
     273  {
     274    return upperSet_;
     275  }
     276  /// size
     277  inline int numberGubColumns() const
     278  {
     279    return numberGubColumns_;
     280  }
     281  /// first free
     282  inline int firstAvailable() const
     283  {
     284    return firstAvailable_;
     285  }
     286  /// first dynamic
     287  inline int firstDynamic() const
     288  {
     289    return firstDynamic_;
     290  }
     291  /// number of columns in dynamic model
     292  inline int lastDynamic() const
     293  {
     294    return lastDynamic_;
     295  }
     296  /// number of rows in original model
     297  inline int numberStaticRows() const
     298  {
     299    return numberStaticRows_;
     300  }
     301  /// size of working matrix (max)
     302  inline CoinBigIndex numberElements() const
     303  {
     304    return numberElements_;
     305  }
     306  inline int *keyVariable() const
     307  {
     308    return keyVariable_;
     309  }
     310  /// Switches off dj checking each factorization (for BIG models)
     311  void switchOffCheck();
     312  /// Status region for gub slacks
     313  inline unsigned char *gubRowStatus() const
     314  {
     315    return status_;
     316  }
     317  /// Status region for gub variables
     318  inline unsigned char *dynamicStatus() const
     319  {
     320    return dynamicStatus_;
     321  }
     322  /// Returns which set a variable is in
     323  int whichSet(int sequence) const;
     324  //@}
    289325
    290326protected:
    291      /**@name Data members
     327  /**@name Data members
    292328        The data members are protected to allow access for derived classes. */
    293      //@{
    294      /// Sum of dual infeasibilities
    295      double sumDualInfeasibilities_;
    296      /// Sum of primal infeasibilities
    297      double sumPrimalInfeasibilities_;
    298      /// Sum of Dual infeasibilities using tolerance based on error in duals
    299      double sumOfRelaxedDualInfeasibilities_;
    300      /// Sum of Primal infeasibilities using tolerance based on error in primals
    301      double sumOfRelaxedPrimalInfeasibilities_;
    302      /// Saved best dual on gub row in pricing
    303      double savedBestGubDual_;
    304      /// Saved best set in pricing
    305      int savedBestSet_;
    306      /// Backward pointer to pivot row !!!
    307      int * backToPivotRow_;
    308      /// Key variable of set (only accurate if none in small problem)
    309      mutable int * keyVariable_;
    310      /// Backward pointer to extra row
    311      int * toIndex_;
    312      // Reverse pointer from index to set
    313      int * fromIndex_;
    314      /// Number of sets (dynamic rows)
    315      int numberSets_;
    316      /// Number of active sets
    317      int numberActiveSets_;
    318      /// Saved value of objective offset
    319      double objectiveOffset_;
    320      /// Lower bounds on sets
    321      double * lowerSet_;
    322      /// Upper bounds on sets
    323      double * upperSet_;
    324      /// Status of slack on set
    325      unsigned char * status_;
    326      /// Pointer back to model
    327      ClpSimplex * model_;
    328      /// first free
    329      int firstAvailable_;
    330      /// first free when iteration started
    331      int firstAvailableBefore_;
    332      /// first dynamic
    333      int firstDynamic_;
    334      /// number of columns in dynamic model
    335      int lastDynamic_;
    336      /// number of rows in original model
    337      int numberStaticRows_;
    338      /// size of working matrix (max)
    339      CoinBigIndex numberElements_;
    340      /// Number of dual infeasibilities
    341      int numberDualInfeasibilities_;
    342      /// Number of primal infeasibilities
    343      int numberPrimalInfeasibilities_;
    344      /** If pricing will declare victory (i.e. no check every factorization).
     329  //@{
     330  /// Sum of dual infeasibilities
     331  double sumDualInfeasibilities_;
     332  /// Sum of primal infeasibilities
     333  double sumPrimalInfeasibilities_;
     334  /// Sum of Dual infeasibilities using tolerance based on error in duals
     335  double sumOfRelaxedDualInfeasibilities_;
     336  /// Sum of Primal infeasibilities using tolerance based on error in primals
     337  double sumOfRelaxedPrimalInfeasibilities_;
     338  /// Saved best dual on gub row in pricing
     339  double savedBestGubDual_;
     340  /// Saved best set in pricing
     341  int savedBestSet_;
     342  /// Backward pointer to pivot row !!!
     343  int *backToPivotRow_;
     344  /// Key variable of set (only accurate if none in small problem)
     345  mutable int *keyVariable_;
     346  /// Backward pointer to extra row
     347  int *toIndex_;
     348  // Reverse pointer from index to set
     349  int *fromIndex_;
     350  /// Number of sets (dynamic rows)
     351  int numberSets_;
     352  /// Number of active sets
     353  int numberActiveSets_;
     354  /// Saved value of objective offset
     355  double objectiveOffset_;
     356  /// Lower bounds on sets
     357  double *lowerSet_;
     358  /// Upper bounds on sets
     359  double *upperSet_;
     360  /// Status of slack on set
     361  unsigned char *status_;
     362  /// Pointer back to model
     363  ClpSimplex *model_;
     364  /// first free
     365  int firstAvailable_;
     366  /// first free when iteration started
     367  int firstAvailableBefore_;
     368  /// first dynamic
     369  int firstDynamic_;
     370  /// number of columns in dynamic model
     371  int lastDynamic_;
     372  /// number of rows in original model
     373  int numberStaticRows_;
     374  /// size of working matrix (max)
     375  CoinBigIndex numberElements_;
     376  /// Number of dual infeasibilities
     377  int numberDualInfeasibilities_;
     378  /// Number of primal infeasibilities
     379  int numberPrimalInfeasibilities_;
     380  /** If pricing will declare victory (i.e. no check every factorization).
    345381         -1 - always check
    346382         0  - don't check
    347383         1  - in don't check mode but looks optimal
    348384     */
    349      int noCheck_;
    350      /// Infeasibility weight when last full pass done
    351      double infeasibilityWeight_;
    352      /// size
    353      int numberGubColumns_;
    354      /// current maximum number of columns (then compress)
    355      int maximumGubColumns_;
    356      /// current maximum number of elemnts (then compress)
    357      CoinBigIndex maximumElements_;
    358      /// Start of each set
    359      int * startSet_;
    360      /// next in chain
    361      int * next_;
    362      /// Starts of each column
    363      CoinBigIndex * startColumn_;
    364      /// rows
    365      int * row_;
    366      /// elements
    367      double * element_;
    368      /// costs
    369      double * cost_;
    370      /// ids of active columns (just index here)
    371      int * id_;
    372      /// for status and which bound
    373      unsigned char * dynamicStatus_;
    374      /// Optional lower bounds on columns
    375      double * columnLower_;
    376      /// Optional upper bounds on columns
    377      double * columnUpper_;
    378      //@}
     385  int noCheck_;
     386  /// Infeasibility weight when last full pass done
     387  double infeasibilityWeight_;
     388  /// size
     389  int numberGubColumns_;
     390  /// current maximum number of columns (then compress)
     391  int maximumGubColumns_;
     392  /// current maximum number of elemnts (then compress)
     393  CoinBigIndex maximumElements_;
     394  /// Start of each set
     395  int *startSet_;
     396  /// next in chain
     397  int *next_;
     398  /// Starts of each column
     399  CoinBigIndex *startColumn_;
     400  /// rows
     401  int *row_;
     402  /// elements
     403  double *element_;
     404  /// costs
     405  double *cost_;
     406  /// ids of active columns (just index here)
     407  int *id_;
     408  /// for status and which bound
     409  unsigned char *dynamicStatus_;
     410  /// Optional lower bounds on columns
     411  double *columnLower_;
     412  /// Optional upper bounds on columns
     413  double *columnUpper_;
     414  //@}
    379415};
    380416
    381417#endif
     418
     419/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     420*/
Note: See TracChangeset for help on using the changeset viewer.