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

    r2271 r2385  
    77#define ClpGubMatrix_H
    88
    9 
    109#include "CoinPragma.hpp"
    1110
     
    2322
    2423public:
    25      /**@name Main functions provided */
    26      //@{
    27      /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */
    28      virtual ClpMatrixBase * reverseOrderedCopy() const;
    29      /// Returns number of elements in column part of basis
    30      virtual int countBasis(const int * whichColumn,
    31                                      int & numberColumnBasic);
    32      /// Fills in column part of basis
    33      virtual void fillBasis(ClpSimplex * model,
    34                             const int * whichColumn,
    35                             int & numberColumnBasic,
    36                             int * row, int * start,
    37                             int * rowCount, int * columnCount,
    38                             CoinFactorizationDouble * element);
    39      /** Unpacks a column into an CoinIndexedvector
     24  /**@name Main functions provided */
     25  //@{
     26  /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */
     27  virtual ClpMatrixBase *reverseOrderedCopy() const;
     28  /// Returns number of elements in column part of basis
     29  virtual int countBasis(const int *whichColumn,
     30    int &numberColumnBasic);
     31  /// Fills in column part of basis
     32  virtual void fillBasis(ClpSimplex *model,
     33    const int *whichColumn,
     34    int &numberColumnBasic,
     35    int *row, int *start,
     36    int *rowCount, int *columnCount,
     37    CoinFactorizationDouble *element);
     38  /** Unpacks a column into an CoinIndexedvector
    4039      */
    41      virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
    42                          int column) const ;
    43      /** Unpacks a column into an CoinIndexedvector
     40  virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray,
     41    int column) const;
     42  /** Unpacks a column into an CoinIndexedvector
    4443      ** in packed foramt
    4544         Note that model is NOT const.  Bounds and objective could
    4645         be modified if doing column generation (just for this variable) */
    47      virtual void unpackPacked(ClpSimplex * model,
    48                                CoinIndexedVector * rowArray,
    49                                int column) const;
    50      /** Adds multiple of a column into an CoinIndexedvector
     46  virtual void unpackPacked(ClpSimplex *model,
     47    CoinIndexedVector *rowArray,
     48    int column) const;
     49  /** Adds multiple of a column into an CoinIndexedvector
    5150         You can use quickAdd to add to vector */
    52      virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
    53                       int column, double multiplier) const ;
    54      /** Adds multiple of a column into an array */
    55      virtual void add(const ClpSimplex * model, double * array,
    56                       int column, double multiplier) const;
    57      /// Partial pricing
    58      virtual void partialPricing(ClpSimplex * model, double start, double end,
    59                                  int & bestSequence, int & numberWanted);
    60      /// Returns number of hidden rows e.g. gub
    61      virtual int hiddenRows() const;
    62      //@}
    63 
    64      /**@name Matrix times vector methods */
    65      //@{
    66 
    67      using ClpPackedMatrix::transposeTimes ;
    68      /** Return <code>x * scalar * A + y</code> in <code>z</code>.
     51  virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray,
     52    int column, double multiplier) const;
     53  /** Adds multiple of a column into an array */
     54  virtual void add(const ClpSimplex *model, double *array,
     55    int column, double multiplier) const;
     56  /// Partial pricing
     57  virtual void partialPricing(ClpSimplex *model, double start, double end,
     58    int &bestSequence, int &numberWanted);
     59  /// Returns number of hidden rows e.g. gub
     60  virtual int hiddenRows() const;
     61  //@}
     62
     63  /**@name Matrix times vector methods */
     64  //@{
     65
     66  using ClpPackedMatrix::transposeTimes;
     67  /** Return <code>x * scalar * A + y</code> in <code>z</code>.
    6968     Can use y as temporary array (will be empty at end)
    7069     Note - If x packed mode - then z packed mode
    7170     Squashes small elements and knows about ClpSimplex */
    72      virtual void transposeTimes(const ClpSimplex * model, double scalar,
    73                                  const CoinIndexedVector * x,
    74                                  CoinIndexedVector * y,
    75                                  CoinIndexedVector * z) const;
    76      /** Return <code>x * scalar * A + y</code> in <code>z</code>.
     71  virtual void transposeTimes(const ClpSimplex *model, double scalar,
     72    const CoinIndexedVector *x,
     73    CoinIndexedVector *y,
     74    CoinIndexedVector *z) const;
     75  /** Return <code>x * scalar * A + y</code> in <code>z</code>.
    7776     Can use y as temporary array (will be empty at end)
    7877     Note - If x packed mode - then z packed mode
    7978     Squashes small elements and knows about ClpSimplex.
    8079     This version uses row copy*/
    81      virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
    82                                       const CoinIndexedVector * x,
    83                                       CoinIndexedVector * y,
    84                                       CoinIndexedVector * z) const;
    85      /** Return <code>x *A</code> in <code>z</code> but
     80  virtual void transposeTimesByRow(const ClpSimplex *model, double scalar,
     81    const CoinIndexedVector *x,
     82    CoinIndexedVector *y,
     83    CoinIndexedVector *z) const;
     84  /** Return <code>x *A</code> in <code>z</code> but
    8685     just for indices in y.
    8786     Note - z always packed mode */
    88      virtual void subsetTransposeTimes(const ClpSimplex * model,
    89                                        const CoinIndexedVector * x,
    90                                        const CoinIndexedVector * y,
    91                                        CoinIndexedVector * z) const;
    92      /** expands an updated column to allow for extra rows which the main
     87  virtual void subsetTransposeTimes(const ClpSimplex *model,
     88    const CoinIndexedVector *x,
     89    const CoinIndexedVector *y,
     90    CoinIndexedVector *z) const;
     91  /** expands an updated column to allow for extra rows which the main
    9392         solver does not know about and returns number added if mode 0.
    9493         If mode 1 deletes extra entries
     
    9695         This active in Gub
    9796     */
    98      virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
    99      /**
     97  virtual int extendUpdated(ClpSimplex *model, CoinIndexedVector *update, int mode);
     98  /**
    10099        mode=0  - Set up before "update" and "times" for primal solution using extended rows
    101100        mode=1  - Cleanup primal solution after "times" using extended rows.
    102101        mode=2  - Check (or report on) primal infeasibilities
    103102     */
    104      virtual void primalExpanded(ClpSimplex * model, int mode);
    105      /**
     103  virtual void primalExpanded(ClpSimplex *model, int mode);
     104  /**
    106105         mode=0  - Set up before "updateTranspose" and "transposeTimes" for duals using extended
    107106                   updates array (and may use other if dual values pass)
     
    111110         mode=4  - Modify before updateTranspose in partial pricing
    112111     */
    113      virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
    114                                double * other, int mode);
    115      /**
     112  virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array,
     113    double *other, int mode);
     114  /**
    116115         mode=0  - Create list of non-key basics in pivotVariable_ using
    117116                   number as numberBasic in and out
     
    130129         mode=13  - at end of simplex to delete stuff
    131130     */
    132      virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
    133      /**
     131  virtual int generalExpanded(ClpSimplex *model, int mode, int &number);
     132  /**
    134133        update information for a pivot (and effective rhs)
    135134     */
    136      virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
    137      /// Sets up an effective RHS and does gub crash if needed
    138      virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true);
    139      /** Returns effective RHS offset if it is being used.  This is used for long problems
     135  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
     136  /// Sets up an effective RHS and does gub crash if needed
     137  virtual void useEffectiveRhs(ClpSimplex *model, bool cheapest = true);
     138  /** Returns effective RHS offset if it is being used.  This is used for long problems
    140139         or big gub or anywhere where going through full columns is
    141140         expensive.  This may re-compute */
    142      virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
    143                                 bool check = false);
    144      /** This is local to Gub to allow synchronization:
     141  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
     142    bool check = false);
     143  /** This is local to Gub to allow synchronization:
    145144         mode=0 when status of basis is good
    146145         mode=1 when variable is flagged
     
    154153         mode=9  - adjust lower, upper on set by incoming
    155154     */
    156      virtual int synchronize(ClpSimplex * model, int mode);
    157      /// Correct sequence in and out to give true value
    158      virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
    159      //@}
    160 
    161 
    162 
    163      /**@name Constructors, destructor */
    164      //@{
    165      /** Default constructor. */
    166      ClpGubMatrix();
    167      /** Destructor */
    168      virtual ~ClpGubMatrix();
    169      //@}
    170 
    171      /**@name Copy method */
    172      //@{
    173      /** The copy constructor. */
    174      ClpGubMatrix(const ClpGubMatrix&);
    175      /** The copy constructor from an CoinPackedMatrix. */
    176      ClpGubMatrix(const CoinPackedMatrix&);
    177      /** Subset constructor (without gaps).  Duplicates are allowed
     155  virtual int synchronize(ClpSimplex *model, int mode);
     156  /// Correct sequence in and out to give true value
     157  virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut);
     158  //@}
     159
     160  /**@name Constructors, destructor */
     161  //@{
     162  /** Default constructor. */
     163  ClpGubMatrix();
     164  /** Destructor */
     165  virtual ~ClpGubMatrix();
     166  //@}
     167
     168  /**@name Copy method */
     169  //@{
     170  /** The copy constructor. */
     171  ClpGubMatrix(const ClpGubMatrix &);
     172  /** The copy constructor from an CoinPackedMatrix. */
     173  ClpGubMatrix(const CoinPackedMatrix &);
     174  /** Subset constructor (without gaps).  Duplicates are allowed
    178175         and order is as given */
    179      ClpGubMatrix (const ClpGubMatrix & wholeModel,
    180                    int numberRows, const int * whichRows,
    181                    int numberColumns, const int * whichColumns);
    182      ClpGubMatrix (const CoinPackedMatrix & wholeModel,
    183                    int numberRows, const int * whichRows,
    184                    int numberColumns, const int * whichColumns);
    185 
    186      /** This takes over ownership (for space reasons) */
    187      ClpGubMatrix(CoinPackedMatrix * matrix);
    188 
    189      /** This takes over ownership (for space reasons) and is the
     176  ClpGubMatrix(const ClpGubMatrix &wholeModel,
     177    int numberRows, const int *whichRows,
     178    int numberColumns, const int *whichColumns);
     179  ClpGubMatrix(const CoinPackedMatrix &wholeModel,
     180    int numberRows, const int *whichRows,
     181    int numberColumns, const int *whichColumns);
     182
     183  /** This takes over ownership (for space reasons) */
     184  ClpGubMatrix(CoinPackedMatrix *matrix);
     185
     186  /** This takes over ownership (for space reasons) and is the
    190187         real constructor*/
    191      ClpGubMatrix(ClpPackedMatrix * matrix, int numberSets,
    192                   const int * start, const int * end,
    193                   const double * lower, const double * upper,
    194                   const unsigned char * status = NULL);
    195 
    196      ClpGubMatrix& operator=(const ClpGubMatrix&);
    197      /// Clone
    198      virtual ClpMatrixBase * clone() const ;
    199      /** Subset clone (without gaps).  Duplicates are allowed
     188  ClpGubMatrix(ClpPackedMatrix *matrix, int numberSets,
     189    const int *start, const int *end,
     190    const double *lower, const double *upper,
     191    const unsigned char *status = NULL);
     192
     193  ClpGubMatrix &operator=(const ClpGubMatrix &);
     194  /// Clone
     195  virtual ClpMatrixBase *clone() const;
     196  /** Subset clone (without gaps).  Duplicates are allowed
    200197         and order is as given */
    201      virtual ClpMatrixBase * subsetClone (
    202           int numberRows, const int * whichRows,
    203           int numberColumns, const int * whichColumns) const ;
    204      /** redoes next_ for a set.  */
    205      void redoSet(ClpSimplex * model, int newKey, int oldKey, int iSet);
    206      //@}
    207      /**@name gets and sets */
    208      //@{
    209      /// Status
    210      inline ClpSimplex::Status getStatus(int sequence) const {
    211           return static_cast<ClpSimplex::Status> (status_[sequence] & 7);
    212      }
    213      inline void setStatus(int sequence, ClpSimplex::Status status) {
    214           unsigned char & st_byte = status_[sequence];
    215           st_byte = static_cast<unsigned char>(st_byte & ~7);
    216           st_byte = static_cast<unsigned char>(st_byte | status);
    217      }
    218      /// To flag a variable
    219      inline void setFlagged( int sequence) {
    220           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64);
    221      }
    222      inline void clearFlagged( int sequence) {
    223           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64);
    224      }
    225      inline bool flagged(int sequence) const {
    226           return ((status_[sequence] & 64) != 0);
    227      }
    228      /// To say key is above ub
    229      inline void setAbove( int sequence) {
    230           unsigned char iStat = status_[sequence];
    231           iStat = static_cast<unsigned char>(iStat & ~24);
    232           status_[sequence] = static_cast<unsigned char>(iStat | 16);
    233      }
    234      /// To say key is feasible
    235      inline void setFeasible( int sequence) {
    236           unsigned char iStat = status_[sequence];
    237           iStat = static_cast<unsigned char>(iStat & ~24);
    238           status_[sequence] = static_cast<unsigned char>(iStat | 8);
    239      }
    240      /// To say key is below lb
    241      inline void setBelow( int sequence) {
    242           unsigned char iStat = status_[sequence];
    243           iStat = static_cast<unsigned char>(iStat & ~24);
    244           status_[sequence] = iStat;
    245      }
    246      inline double weight( int sequence) const {
    247           int iStat = status_[sequence] & 31;
    248           iStat = iStat >> 3;
    249           return static_cast<double> (iStat - 1);
    250      }
    251      /// Starts
    252      inline int * start() const {
    253           return start_;
    254      }
    255      /// End
    256      inline int * end() const {
    257           return end_;
    258      }
    259      /// Lower bounds on sets
    260      inline double * lower() const {
    261           return lower_;
    262      }
    263      /// Upper bounds on sets
    264      inline double * upper() const {
    265           return upper_;
    266      }
    267      /// Key variable of set
    268      inline int * keyVariable() const {
    269           return keyVariable_;
    270      }
    271      /// Backward pointer to set number
    272      inline int * backward() const {
    273           return backward_;
    274      }
    275      /// Number of sets (gub rows)
    276      inline int numberSets() const {
    277           return numberSets_;
    278      }
    279      /// Switches off dj checking each factorization (for BIG models)
    280      void switchOffCheck();
    281      //@}
    282 
     198  virtual ClpMatrixBase *subsetClone(
     199    int numberRows, const int *whichRows,
     200    int numberColumns, const int *whichColumns) const;
     201  /** redoes next_ for a set.  */
     202  void redoSet(ClpSimplex *model, int newKey, int oldKey, int iSet);
     203  //@}
     204  /**@name gets and sets */
     205  //@{
     206  /// Status
     207  inline ClpSimplex::Status getStatus(int sequence) const
     208  {
     209    return static_cast< ClpSimplex::Status >(status_[sequence] & 7);
     210  }
     211  inline void setStatus(int sequence, ClpSimplex::Status status)
     212  {
     213    unsigned char &st_byte = status_[sequence];
     214    st_byte = static_cast< unsigned char >(st_byte & ~7);
     215    st_byte = static_cast< unsigned char >(st_byte | status);
     216  }
     217  /// To flag a variable
     218  inline void setFlagged(int sequence)
     219  {
     220    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 64);
     221  }
     222  inline void clearFlagged(int sequence)
     223  {
     224    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~64);
     225  }
     226  inline bool flagged(int sequence) const
     227  {
     228    return ((status_[sequence] & 64) != 0);
     229  }
     230  /// To say key is above ub
     231  inline void setAbove(int sequence)
     232  {
     233    unsigned char iStat = status_[sequence];
     234    iStat = static_cast< unsigned char >(iStat & ~24);
     235    status_[sequence] = static_cast< unsigned char >(iStat | 16);
     236  }
     237  /// To say key is feasible
     238  inline void setFeasible(int sequence)
     239  {
     240    unsigned char iStat = status_[sequence];
     241    iStat = static_cast< unsigned char >(iStat & ~24);
     242    status_[sequence] = static_cast< unsigned char >(iStat | 8);
     243  }
     244  /// To say key is below lb
     245  inline void setBelow(int sequence)
     246  {
     247    unsigned char iStat = status_[sequence];
     248    iStat = static_cast< unsigned char >(iStat & ~24);
     249    status_[sequence] = iStat;
     250  }
     251  inline double weight(int sequence) const
     252  {
     253    int iStat = status_[sequence] & 31;
     254    iStat = iStat >> 3;
     255    return static_cast< double >(iStat - 1);
     256  }
     257  /// Starts
     258  inline int *start() const
     259  {
     260    return start_;
     261  }
     262  /// End
     263  inline int *end() const
     264  {
     265    return end_;
     266  }
     267  /// Lower bounds on sets
     268  inline double *lower() const
     269  {
     270    return lower_;
     271  }
     272  /// Upper bounds on sets
     273  inline double *upper() const
     274  {
     275    return upper_;
     276  }
     277  /// Key variable of set
     278  inline int *keyVariable() const
     279  {
     280    return keyVariable_;
     281  }
     282  /// Backward pointer to set number
     283  inline int *backward() const
     284  {
     285    return backward_;
     286  }
     287  /// Number of sets (gub rows)
     288  inline int numberSets() const
     289  {
     290    return numberSets_;
     291  }
     292  /// Switches off dj checking each factorization (for BIG models)
     293  void switchOffCheck();
     294  //@}
    283295
    284296protected:
    285      /**@name Data members
     297  /**@name Data members
    286298        The data members are protected to allow access for derived classes. */
    287      //@{
    288      /// Sum of dual infeasibilities
    289      double sumDualInfeasibilities_;
    290      /// Sum of primal infeasibilities
    291      double sumPrimalInfeasibilities_;
    292      /// Sum of Dual infeasibilities using tolerance based on error in duals
    293      double sumOfRelaxedDualInfeasibilities_;
    294      /// Sum of Primal infeasibilities using tolerance based on error in primals
    295      double sumOfRelaxedPrimalInfeasibilities_;
    296      /// Infeasibility weight when last full pass done
    297      double infeasibilityWeight_;
    298      /// Starts
    299      int * start_;
    300      /// End
    301      int * end_;
    302      /// Lower bounds on sets
    303      double * lower_;
    304      /// Upper bounds on sets
    305      double * upper_;
    306      /// Status of slacks
    307      mutable unsigned char * status_;
    308      /// Saved status of slacks
    309      unsigned char * saveStatus_;
    310      /// Saved key variables
    311      int * savedKeyVariable_;
    312      /// Backward pointer to set number
    313      int * backward_;
    314      /// Backward pointer to pivot row !!!
    315      int * backToPivotRow_;
    316      /// Change in costs for keys
    317      double * changeCost_;
    318      /// Key variable of set
    319      mutable int * keyVariable_;
    320      /** Next basic variable in set - starts at key and end with -(set+1).
     299  //@{
     300  /// Sum of dual infeasibilities
     301  double sumDualInfeasibilities_;
     302  /// Sum of primal infeasibilities
     303  double sumPrimalInfeasibilities_;
     304  /// Sum of Dual infeasibilities using tolerance based on error in duals
     305  double sumOfRelaxedDualInfeasibilities_;
     306  /// Sum of Primal infeasibilities using tolerance based on error in primals
     307  double sumOfRelaxedPrimalInfeasibilities_;
     308  /// Infeasibility weight when last full pass done
     309  double infeasibilityWeight_;
     310  /// Starts
     311  int *start_;
     312  /// End
     313  int *end_;
     314  /// Lower bounds on sets
     315  double *lower_;
     316  /// Upper bounds on sets
     317  double *upper_;
     318  /// Status of slacks
     319  mutable unsigned char *status_;
     320  /// Saved status of slacks
     321  unsigned char *saveStatus_;
     322  /// Saved key variables
     323  int *savedKeyVariable_;
     324  /// Backward pointer to set number
     325  int *backward_;
     326  /// Backward pointer to pivot row !!!
     327  int *backToPivotRow_;
     328  /// Change in costs for keys
     329  double *changeCost_;
     330  /// Key variable of set
     331  mutable int *keyVariable_;
     332  /** Next basic variable in set - starts at key and end with -(set+1).
    321333         Now changes to -(nonbasic+1).
    322334         next_ has extra space for 2* longest set */
    323      mutable int * next_;
    324      /// Backward pointer to index in CoinIndexedVector
    325      int * toIndex_;
    326      // Reverse pointer from index to set
    327      int * fromIndex_;
    328      /// Pointer back to model
    329      ClpSimplex * model_;
    330      /// Number of dual infeasibilities
    331      int numberDualInfeasibilities_;
    332      /// Number of primal infeasibilities
    333      int numberPrimalInfeasibilities_;
    334      /** If pricing will declare victory (i.e. no check every factorization).
     335  mutable int *next_;
     336  /// Backward pointer to index in CoinIndexedVector
     337  int *toIndex_;
     338  // Reverse pointer from index to set
     339  int *fromIndex_;
     340  /// Pointer back to model
     341  ClpSimplex *model_;
     342  /// Number of dual infeasibilities
     343  int numberDualInfeasibilities_;
     344  /// Number of primal infeasibilities
     345  int numberPrimalInfeasibilities_;
     346  /** If pricing will declare victory (i.e. no check every factorization).
    335347         -1 - always check
    336348         0  - don't check
    337349         1  - in don't check mode but looks optimal
    338350     */
    339      int noCheck_;
    340      /// Number of sets (gub rows)
    341      int numberSets_;
    342      /// Number in vector without gub extension
    343      int saveNumber_;
    344      /// Pivot row of possible next key
    345      int possiblePivotKey_;
    346      /// Gub slack in (set number or -1)
    347      int gubSlackIn_;
    348      /// First gub variables (same as start_[0] at present)
    349      int firstGub_;
    350      /// last gub variable (same as end_[numberSets_-1] at present)
    351      int lastGub_;
    352      /** type of gub - 0 not contiguous, 1 contiguous
     351  int noCheck_;
     352  /// Number of sets (gub rows)
     353  int numberSets_;
     354  /// Number in vector without gub extension
     355  int saveNumber_;
     356  /// Pivot row of possible next key
     357  int possiblePivotKey_;
     358  /// Gub slack in (set number or -1)
     359  int gubSlackIn_;
     360  /// First gub variables (same as start_[0] at present)
     361  int firstGub_;
     362  /// last gub variable (same as end_[numberSets_-1] at present)
     363  int lastGub_;
     364  /** type of gub - 0 not contiguous, 1 contiguous
    353365         add 8 bit to say no ubs on individual variables */
    354      int gubType_;
    355      //@}
     366  int gubType_;
     367  //@}
    356368};
    357369
    358370#endif
     371
     372/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     373*/
Note: See TracChangeset for help on using the changeset viewer.