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/AbcSimplexFactorization.hpp

    r2078 r2385  
    66#ifndef AbcSimplexFactorization_H
    77#define AbcSimplexFactorization_H
    8 
    98
    109#include "CoinPragma.hpp"
     
    2524    is passed.
    2625*/
    27 class AbcSimplexFactorization
    28 {
    29  
     26class AbcSimplexFactorization {
     27
    3028public:
    3129  /**@name factorization */
     
    4038      and ones thrown out have -1
    4139      returns 0 -okay, -1 singular, -2 too many in basis, -99 memory */
    42   int factorize (AbcSimplex * model, int solveType, bool valuesPass);
     40  int factorize(AbcSimplex *model, int solveType, bool valuesPass);
    4341#ifdef EARLY_FACTORIZE
    4442  /// Returns -2 if can't, -1 if singular, -99 memory, 0 OK
    45   inline int factorize (AbcSimplex * model, CoinIndexedVector & stuff)
    46   { return coinAbcFactorization_->factorize(model,stuff);}
    47 #endif
    48   //@}
    49  
    50  
     43  inline int factorize(AbcSimplex *model, CoinIndexedVector &stuff)
     44  {
     45    return coinAbcFactorization_->factorize(model, stuff);
     46  }
     47#endif
     48  //@}
     49
    5150  /**@name Constructors, destructor */
    5251  //@{
    5352  /** Default constructor. */
    54   AbcSimplexFactorization(int numberRows=0);
     53  AbcSimplexFactorization(int numberRows = 0);
    5554  /** Destructor */
    5655  ~AbcSimplexFactorization();
    5756  //@}
    58  
     57
    5958  /**@name Copy method */
    6059  //@{
    6160  /** The copy constructor. */
    62   AbcSimplexFactorization(const AbcSimplexFactorization&, int denseIfSmaller = 0);
    63   AbcSimplexFactorization& operator=(const AbcSimplexFactorization&);
     61  AbcSimplexFactorization(const AbcSimplexFactorization &, int denseIfSmaller = 0);
     62  AbcSimplexFactorization &operator=(const AbcSimplexFactorization &);
    6463  /// Sets factorization
    65   void setFactorization(AbcSimplexFactorization & rhs);
    66   //@}
    67  
     64  void setFactorization(AbcSimplexFactorization &rhs);
     65  //@}
     66
    6867  /*  **** below here is so can use networkish basis */
    6968  /**@name rank one updates which do exist */
    7069  //@{
    71  
     70
    7271  /** Checks if can replace one Column to basis,
    7372      returns update alpha
     
    7574      partial update already in U */
    7675  inline
    77 #ifdef ABC_LONG_FACTORIZATION
    78   long
    79 #endif
    80   double checkReplacePart1 ( CoinIndexedVector * regionSparse,
    81                              int pivotRow)
    82   {return coinAbcFactorization_->checkReplacePart1(regionSparse,pivotRow);}
     76#ifdef ABC_LONG_FACTORIZATION
     77    long
     78#endif
     79    double
     80    checkReplacePart1(CoinIndexedVector *regionSparse,
     81      int pivotRow)
     82  {
     83    return coinAbcFactorization_->checkReplacePart1(regionSparse, pivotRow);
     84  }
    8385  /** Checks if can replace one Column to basis,
    8486      returns update alpha
    8587      Fills in region for use later
    8688      partial update in vector */
    87   inline
    88 #ifdef ABC_LONG_FACTORIZATION
    89   long
    90 #endif
    91   double checkReplacePart1 ( CoinIndexedVector * regionSparse,
    92                                   CoinIndexedVector * partialUpdate,
    93                                   int pivotRow)
    94   {return coinAbcFactorization_->checkReplacePart1(regionSparse,partialUpdate,pivotRow);}
     89  inline
     90#ifdef ABC_LONG_FACTORIZATION
     91    long
     92#endif
     93    double
     94    checkReplacePart1(CoinIndexedVector *regionSparse,
     95      CoinIndexedVector *partialUpdate,
     96      int pivotRow)
     97  {
     98    return coinAbcFactorization_->checkReplacePart1(regionSparse, partialUpdate, pivotRow);
     99  }
    95100#ifdef MOVE_REPLACE_PART1A
    96101  /** Checks if can replace one Column to basis,
     
    98103      Fills in region for use later
    99104      partial update already in U */
    100   inline void checkReplacePart1a ( CoinIndexedVector * regionSparse,
    101                              int pivotRow)
    102   {coinAbcFactorization_->checkReplacePart1a(regionSparse,pivotRow);}
    103   inline double checkReplacePart1b (CoinIndexedVector * regionSparse,
    104                              int pivotRow)
    105   {return coinAbcFactorization_->checkReplacePart1b(regionSparse,pivotRow);}
     105  inline void checkReplacePart1a(CoinIndexedVector *regionSparse,
     106    int pivotRow)
     107  {
     108    coinAbcFactorization_->checkReplacePart1a(regionSparse, pivotRow);
     109  }
     110  inline double checkReplacePart1b(CoinIndexedVector *regionSparse,
     111    int pivotRow)
     112  {
     113    return coinAbcFactorization_->checkReplacePart1b(regionSparse, pivotRow);
     114  }
    106115#endif
    107116  /** Checks if can replace one Column to basis,
    108117      returns 0=OK, 1=Probably OK, 2=singular, 3=no room, 5 max pivots */
    109   inline int checkReplacePart2 ( int pivotRow,
    110                                  double btranAlpha,
    111                                  double ftranAlpha,
    112 #ifdef ABC_LONG_FACTORIZATION
    113                                  long
    114 #endif
    115                                  double ftAlpha)
    116   {return coinAbcFactorization_->checkReplacePart2(pivotRow,btranAlpha,ftranAlpha,ftAlpha);}
    117 #ifdef ABC_LONG_FACTORIZATION
     118  inline int checkReplacePart2(int pivotRow,
     119    double btranAlpha,
     120    double ftranAlpha,
     121#ifdef ABC_LONG_FACTORIZATION
     122    long
     123#endif
     124    double ftAlpha)
     125  {
     126    return coinAbcFactorization_->checkReplacePart2(pivotRow, btranAlpha, ftranAlpha, ftAlpha);
     127  }
     128#ifdef ABC_LONG_FACTORIZATION
    118129  /// Clear all hidden arrays
    119130  inline void clearHiddenArrays()
    120   { coinAbcFactorization_->clearHiddenArrays();}
     131  {
     132    coinAbcFactorization_->clearHiddenArrays();
     133  }
    121134#endif
    122135  /** Replaces one Column to basis,
    123136      partial update already in U */
    124   void replaceColumnPart3 ( const AbcSimplex * model,
    125                             CoinIndexedVector * regionSparse,
    126                             CoinIndexedVector * tableauColumn,
    127                             int pivotRow,
    128 #ifdef ABC_LONG_FACTORIZATION 
    129                             long
    130 #endif
    131                             double alpha );
     137  void replaceColumnPart3(const AbcSimplex *model,
     138    CoinIndexedVector *regionSparse,
     139    CoinIndexedVector *tableauColumn,
     140    int pivotRow,
     141#ifdef ABC_LONG_FACTORIZATION
     142    long
     143#endif
     144    double alpha);
    132145  /** Replaces one Column to basis,
    133146      partial update in vector */
    134   void replaceColumnPart3 ( const AbcSimplex * model,
    135                             CoinIndexedVector * regionSparse,
    136                             CoinIndexedVector * tableauColumn,
    137                             CoinIndexedVector * partialUpdate,
    138                             int pivotRow,
    139 #ifdef ABC_LONG_FACTORIZATION 
    140                             long
    141 #endif
    142                             double alpha );
     147  void replaceColumnPart3(const AbcSimplex *model,
     148    CoinIndexedVector *regionSparse,
     149    CoinIndexedVector *tableauColumn,
     150    CoinIndexedVector *partialUpdate,
     151    int pivotRow,
     152#ifdef ABC_LONG_FACTORIZATION
     153    long
     154#endif
     155    double alpha);
    143156#ifdef EARLY_FACTORIZE
    144157  /// 0 success, -1 can't +1 accuracy problems
    145   inline int replaceColumns ( const AbcSimplex * model,
    146                         CoinIndexedVector & stuff,
    147                               int firstPivot,int lastPivot,bool cleanUp)
    148   { return coinAbcFactorization_->replaceColumns(model,stuff,firstPivot,lastPivot,cleanUp);}
    149 #endif
    150   //@}
    151  
     158  inline int replaceColumns(const AbcSimplex *model,
     159    CoinIndexedVector &stuff,
     160    int firstPivot, int lastPivot, bool cleanUp)
     161  {
     162    return coinAbcFactorization_->replaceColumns(model, stuff, firstPivot, lastPivot, cleanUp);
     163  }
     164#endif
     165  //@}
     166
    152167  /**@name various uses of factorization (return code number elements)
    153168     which user may want to know about */
     
    180195      Tries to do FT update
    181196      number returned is negative if no room */
    182   inline int updateColumnFT ( CoinIndexedVector & regionSparseFT)
    183   { return coinAbcFactorization_->updateColumnFT(regionSparseFT);}
    184   inline int updateColumnFTPart1 ( CoinIndexedVector & regionSparseFT)
    185   { return coinAbcFactorization_->updateColumnFTPart1(regionSparseFT);}
    186   inline void updateColumnFTPart2 ( CoinIndexedVector & regionSparseFT)
    187   { coinAbcFactorization_->updateColumnFTPart2(regionSparseFT);}
     197  inline int updateColumnFT(CoinIndexedVector &regionSparseFT)
     198  {
     199    return coinAbcFactorization_->updateColumnFT(regionSparseFT);
     200  }
     201  inline int updateColumnFTPart1(CoinIndexedVector &regionSparseFT)
     202  {
     203    return coinAbcFactorization_->updateColumnFTPart1(regionSparseFT);
     204  }
     205  inline void updateColumnFTPart2(CoinIndexedVector &regionSparseFT)
     206  {
     207    coinAbcFactorization_->updateColumnFTPart2(regionSparseFT);
     208  }
    188209  /** Updates one column (FTRAN)
    189210      Tries to do FT update
    190211      puts partial update in vector */
    191   inline void updateColumnFT ( CoinIndexedVector & regionSparseFT,
    192                                CoinIndexedVector & partialUpdate,
    193                                int which)
    194   { coinAbcFactorization_->updateColumnFT(regionSparseFT,partialUpdate,which);}
     212  inline void updateColumnFT(CoinIndexedVector &regionSparseFT,
     213    CoinIndexedVector &partialUpdate,
     214    int which)
     215  {
     216    coinAbcFactorization_->updateColumnFT(regionSparseFT, partialUpdate, which);
     217  }
    195218  /** Updates one column (FTRAN) */
    196   inline int updateColumn ( CoinIndexedVector & regionSparse) const
    197   { return coinAbcFactorization_->updateColumn(regionSparse);}
     219  inline int updateColumn(CoinIndexedVector &regionSparse) const
     220  {
     221    return coinAbcFactorization_->updateColumn(regionSparse);
     222  }
    198223  /** Updates one column (FTRAN) from regionFT
    199224      Tries to do FT update
    200225      number returned is negative if no room.
    201226      Also updates regionOther */
    202   inline int updateTwoColumnsFT ( CoinIndexedVector & regionSparseFT,
    203                            CoinIndexedVector & regionSparseOther)
    204   { return coinAbcFactorization_->updateTwoColumnsFT(regionSparseFT,regionSparseOther);}
     227  inline int updateTwoColumnsFT(CoinIndexedVector &regionSparseFT,
     228    CoinIndexedVector &regionSparseOther)
     229  {
     230    return coinAbcFactorization_->updateTwoColumnsFT(regionSparseFT, regionSparseOther);
     231  }
    205232  /** Updates one column (BTRAN) */
    206   inline int updateColumnTranspose ( CoinIndexedVector & regionSparse) const
    207   { return coinAbcFactorization_->updateColumnTranspose(regionSparse);}
     233  inline int updateColumnTranspose(CoinIndexedVector &regionSparse) const
     234  {
     235    return coinAbcFactorization_->updateColumnTranspose(regionSparse);
     236  }
    208237  /** Updates one column (FTRAN) */
    209   inline void updateColumnCpu ( CoinIndexedVector & regionSparse,int whichCpu) const
    210 #ifndef ABC_USE_COIN_FACTORIZATION
    211   { coinAbcFactorization_->updateColumnCpu(regionSparse,whichCpu);}
    212 #else
    213   { coinAbcFactorization_->updateColumn(regionSparse);}
     238  inline void updateColumnCpu(CoinIndexedVector &regionSparse, int whichCpu) const
     239#ifndef ABC_USE_COIN_FACTORIZATION
     240  {
     241    coinAbcFactorization_->updateColumnCpu(regionSparse, whichCpu);
     242  }
     243#else
     244  {
     245    coinAbcFactorization_->updateColumn(regionSparse);
     246  }
    214247#endif
    215248  /** Updates one column (BTRAN) */
    216   inline void updateColumnTransposeCpu ( CoinIndexedVector & regionSparse,int whichCpu) const
    217 #ifndef ABC_USE_COIN_FACTORIZATION
    218   { coinAbcFactorization_->updateColumnTransposeCpu(regionSparse,whichCpu);}
    219 #else
    220   { coinAbcFactorization_->updateColumnTranspose(regionSparse);}
     249  inline void updateColumnTransposeCpu(CoinIndexedVector &regionSparse, int whichCpu) const
     250#ifndef ABC_USE_COIN_FACTORIZATION
     251  {
     252    coinAbcFactorization_->updateColumnTransposeCpu(regionSparse, whichCpu);
     253  }
     254#else
     255  {
     256    coinAbcFactorization_->updateColumnTranspose(regionSparse);
     257  }
    221258#endif
    222259  /** Updates one full column (FTRAN) */
    223   inline void updateFullColumn ( CoinIndexedVector & regionSparse) const
    224   { coinAbcFactorization_->updateFullColumn(regionSparse);}
     260  inline void updateFullColumn(CoinIndexedVector &regionSparse) const
     261  {
     262    coinAbcFactorization_->updateFullColumn(regionSparse);
     263  }
    225264  /** Updates one full column (BTRAN) */
    226   inline void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const
    227   { coinAbcFactorization_->updateFullColumnTranspose(regionSparse);}
     265  inline void updateFullColumnTranspose(CoinIndexedVector &regionSparse) const
     266  {
     267    coinAbcFactorization_->updateFullColumnTranspose(regionSparse);
     268  }
    228269  /** Updates one column for dual steepest edge weights (FTRAN) */
    229   void updateWeights ( CoinIndexedVector & regionSparse) const
    230 #ifndef ABC_USE_COIN_FACTORIZATION
    231   { coinAbcFactorization_->updateWeights(regionSparse);}
    232 #else
    233   { coinAbcFactorization_->updateColumn(regionSparse);}
     270  void updateWeights(CoinIndexedVector &regionSparse) const
     271#ifndef ABC_USE_COIN_FACTORIZATION
     272  {
     273    coinAbcFactorization_->updateWeights(regionSparse);
     274  }
     275#else
     276  {
     277    coinAbcFactorization_->updateColumn(regionSparse);
     278  }
    234279#endif
    235280  //@}
     
    237282  //@{
    238283  /// Total number of elements in factorization
    239   inline int numberElements (  ) const {
    240     return coinAbcFactorization_->numberElements() ;
     284  inline int numberElements() const
     285  {
     286    return coinAbcFactorization_->numberElements();
    241287  }
    242288  /// Maximum number of pivots between factorizations
    243   inline int maximumPivots (  ) const {
    244     return coinAbcFactorization_->maximumPivots() ;
     289  inline int maximumPivots() const
     290  {
     291    return coinAbcFactorization_->maximumPivots();
    245292  }
    246293  /// Set maximum number of pivots between factorizations
    247   inline void maximumPivots (  int value) {
     294  inline void maximumPivots(int value)
     295  {
    248296    coinAbcFactorization_->maximumPivots(value);
    249297  }
    250298  /// Returns true if doing FT
    251299  inline bool usingFT() const
    252   { return !coinAbcFactorization_->wantsTableauColumn();}
     300  {
     301    return !coinAbcFactorization_->wantsTableauColumn();
     302  }
    253303  /// Returns number of pivots since factorization
    254   inline int pivots (  ) const {
    255     return coinAbcFactorization_->pivots() ;
     304  inline int pivots() const
     305  {
     306    return coinAbcFactorization_->pivots();
    256307  }
    257308  /// Sets model
    258   inline void setModel(AbcSimplex * model)
    259   {model_ = model;}
    260   /// Sets number of pivots since factorization
    261   inline void setPivots ( int value ) const {
    262     coinAbcFactorization_->setPivots(value) ;
     309  inline void setModel(AbcSimplex *model)
     310  {
     311    model_ = model;
     312  }
     313  /// Sets number of pivots since factorization
     314  inline void setPivots(int value) const
     315  {
     316    coinAbcFactorization_->setPivots(value);
    263317  }
    264318  /// Whether larger areas needed
    265   inline double areaFactor (  ) const {
    266     return coinAbcFactorization_->areaFactor() ;
     319  inline double areaFactor() const
     320  {
     321    return coinAbcFactorization_->areaFactor();
    267322  }
    268323  /// Set whether larger areas needed
    269   inline void areaFactor ( double value) {
     324  inline void areaFactor(double value)
     325  {
    270326    coinAbcFactorization_->areaFactor(value);
    271327  }
    272328  /// Zero tolerance
    273   inline double zeroTolerance (  ) const {
    274     return coinAbcFactorization_->zeroTolerance() ;
     329  inline double zeroTolerance() const
     330  {
     331    return coinAbcFactorization_->zeroTolerance();
    275332  }
    276333  /// Set zero tolerance
    277   inline void zeroTolerance (  double value) {
     334  inline void zeroTolerance(double value)
     335  {
    278336    coinAbcFactorization_->zeroTolerance(value);
    279337  }
    280338  /// Set tolerances to safer of existing and given
    281   void saferTolerances (  double zeroTolerance, double pivotTolerance);
     339  void saferTolerances(double zeroTolerance, double pivotTolerance);
    282340  /// Returns status
    283   inline int status (  ) const {
    284     return coinAbcFactorization_->status() ;
     341  inline int status() const
     342  {
     343    return coinAbcFactorization_->status();
    285344  }
    286345  /// Sets status
    287   inline void setStatus (  int value) {
    288     coinAbcFactorization_->setStatus(value) ;
    289   }
    290 #if ABC_PARALLEL==2
     346  inline void setStatus(int value)
     347  {
     348    coinAbcFactorization_->setStatus(value);
     349  }
     350#if ABC_PARALLEL == 2
    291351  /// Says parallel
    292352  inline void setParallelMode(int value)
    293   {coinAbcFactorization_->setParallelMode(value);};
     353  {
     354    coinAbcFactorization_->setParallelMode(value);
     355  };
    294356#endif
    295357  /// Returns number of dense rows
    296   inline int numberDense() const {
    297     return coinAbcFactorization_->numberDense() ;
     358  inline int numberDense() const
     359  {
     360    return coinAbcFactorization_->numberDense();
    298361  }
    299362  bool timeToRefactorize() const;
    300 #if CLP_FACTORIZATION_NEW_TIMING>1
     363#if CLP_FACTORIZATION_NEW_TIMING > 1
    301364  void statsRefactor(char when) const;
    302365#endif
    303366  /// Get rid of all memory
    304   inline void clearArrays() {
     367  inline void clearArrays()
     368  {
    305369    coinAbcFactorization_->clearArrays();
    306370  }
    307371  /// Number of Rows after factorization
    308   inline int numberRows (  ) const {
    309     return coinAbcFactorization_->numberRows() ;
     372  inline int numberRows() const
     373  {
     374    return coinAbcFactorization_->numberRows();
    310375  }
    311376  /// Number of slacks at last factorization
    312377  inline int numberSlacks() const
    313   { return numberSlacks_;}
     378  {
     379    return numberSlacks_;
     380  }
    314381  /// Pivot tolerance
    315   inline double pivotTolerance (  ) const {
     382  inline double pivotTolerance() const
     383  {
    316384    return coinAbcFactorization_->pivotTolerance();
    317385  }
    318386  /// Set pivot tolerance
    319   inline void pivotTolerance (  double value) {
     387  inline void pivotTolerance(double value)
     388  {
    320389    coinAbcFactorization_->pivotTolerance(value);
    321390  }
    322391  /// Minimum pivot tolerance
    323   inline double minimumPivotTolerance (  ) const {
     392  inline double minimumPivotTolerance() const
     393  {
    324394    return coinAbcFactorization_->minimumPivotTolerance();
    325395  }
    326396  /// Set minimum pivot tolerance
    327   inline void minimumPivotTolerance (  double value) {
     397  inline void minimumPivotTolerance(double value)
     398  {
    328399    coinAbcFactorization_->minimumPivotTolerance(value);
    329400  }
    330401  /// pivot region
    331   inline double * pivotRegion() const
    332   { return coinAbcFactorization_->pivotRegion();}
     402  inline double *pivotRegion() const
     403  {
     404    return coinAbcFactorization_->pivotRegion();
     405  }
    333406  /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed
    334407  //inline void relaxAccuracyCheck(double /*value*/) {
     
    336409  //}
    337410  /// Delete all stuff (leaves as after CoinFactorization())
    338   inline void almostDestructor() {
     411  inline void almostDestructor()
     412  {
    339413    coinAbcFactorization_->clearArrays();
    340414  }
     
    347421  void goDenseOrSmall(int numberRows);
    348422  /// Get switch to dense if number rows <= this
    349   inline int goDenseThreshold() const {
     423  inline int goDenseThreshold() const
     424  {
    350425    return goDenseThreshold_;
    351426  }
    352427  /// Set switch to dense if number rows <= this
    353   inline void setGoDenseThreshold(int value) {
     428  inline void setGoDenseThreshold(int value)
     429  {
    354430    goDenseThreshold_ = value;
    355431  }
    356432  /// Get switch to small if number rows <= this
    357   inline int goSmallThreshold() const {
     433  inline int goSmallThreshold() const
     434  {
    358435    return goSmallThreshold_;
    359436  }
    360437  /// Set switch to small if number rows <= this
    361   inline void setGoSmallThreshold(int value) {
     438  inline void setGoSmallThreshold(int value)
     439  {
    362440    goSmallThreshold_ = value;
    363441  }
    364442  /// Get switch to long/ordered if number rows >= this
    365   inline int goLongThreshold() const {
     443  inline int goLongThreshold() const
     444  {
    366445    return goLongThreshold_;
    367446  }
    368447  /// Set switch to long/ordered if number rows >= this
    369   inline void setGoLongThreshold(int value) {
     448  inline void setGoLongThreshold(int value)
     449  {
    370450    goLongThreshold_ = value;
    371451  }
    372452  /// Returns type
    373453  inline int typeOfFactorization() const
    374   { return forceB_;}
     454  {
     455    return forceB_;
     456  }
    375457  /// Synchronize stuff
    376   void synchronize(const ClpFactorization * otherFactorization,const AbcSimplex * model);
    377   //@}
    378  
     458  void synchronize(const ClpFactorization *otherFactorization, const AbcSimplex *model);
     459  //@}
     460
    379461  /**@name other stuff */
    380462  //@{
     
    384466#ifndef ABC_USE_COIN_FACTORIZATION
    385467  inline void checkMarkArrays() const
    386   { coinAbcFactorization_->checkMarkArrays();}
     468  {
     469    coinAbcFactorization_->checkMarkArrays();
     470  }
    387471#else
    388472  inline void checkMarkArrays() const
    389   { }
     473  {
     474  }
    390475#endif
    391476#endif
    392477  /// Says whether to redo pivot order
    393   inline bool needToReorder() const {abort();return true;}
     478  inline bool needToReorder() const
     479  {
     480    abort();
     481    return true;
     482  }
    394483  /// Pointer to factorization
    395484#ifndef ABC_USE_COIN_FACTORIZATION
    396   CoinAbcAnyFactorization * factorization() const
    397   { return coinAbcFactorization_;}
    398 #else
    399   CoinFactorization * factorization() const
    400   { return coinAbcFactorization_;}
    401 #endif
    402   //@}
    403  
     485  CoinAbcAnyFactorization *factorization() const
     486  {
     487    return coinAbcFactorization_;
     488  }
     489#else
     490  CoinFactorization *factorization() const
     491  {
     492    return coinAbcFactorization_;
     493  }
     494#endif
     495  //@}
     496
    404497  ////////////////// data //////////////////
    405498private:
    406  
    407499  /**@name data */
    408500  //@{
    409501  /// Pointer to model
    410   AbcSimplex * model_;
     502  AbcSimplex *model_;
    411503  /// Pointer to factorization
    412504#ifndef ABC_USE_COIN_FACTORIZATION
    413   CoinAbcAnyFactorization * coinAbcFactorization_;
    414 #else
    415   CoinFactorization * coinAbcFactorization_;
     505  CoinAbcAnyFactorization *coinAbcFactorization_;
     506#else
     507  CoinFactorization *coinAbcFactorization_;
    416508#endif
    417509#ifdef CLP_FACTORIZATION_NEW_TIMING
     
    438530
    439531#endif
     532
     533/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     534*/
Note: See TracChangeset for help on using the changeset viewer.