Changeset 2385 for trunk/Clp/src/ClpDynamicMatrix.hpp
 Timestamp:
 Jan 6, 2019 2:43:06 PM (4 months ago)
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

trunk/Clp/src/ClpDynamicMatrix.hpp
r2271 r2385 6 6 #ifndef ClpDynamicMatrix_H 7 7 #define ClpDynamicMatrix_H 8 9 8 10 9 #include "CoinPragma.hpp" … … 21 20 22 21 public: 23 24 25 26 27 28 29 30 31 32 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 /** 37 36 update information for a pivot (and effective rhs) 38 37 */ 39 virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);40 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 41 40 or big dynamic or anywhere where going through full columns is 42 41 expensive. This may recompute */ 43 virtual double * rhsOffset(ClpSimplex *model, bool forceRefresh = false,44 45 46 using ClpPackedMatrix::times;47 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>. 48 47 @pre <code>x</code> must be of size <code>numColumns()</code> 49 48 @pre <code>y</code> must be of size <code>numRows()</code> */ 50 51 const double * x, double *y) const;52 53 54 55 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 /** 57 56 mode=0  Set up before "updateTranspose" and "transposeTimes" for duals using extended 58 57 updates array (and may use other if dual values pass) … … 62 61 mode=4  Modify before updateTranspose in partial pricing 63 62 */ 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 /** 67 66 mode=0  Create list of nonkey basics in pivotVariable_ using 68 67 number as numberBasic in and out … … 81 80 mode=13  at end of simplex to delete stuff 82 81 */ 83 virtual int generalExpanded(ClpSimplex * model, int mode, int &number);84 82 virtual int generalExpanded(ClpSimplex *model, int mode, int &number); 83 /** Purely for column generation and similar ideas. Allows 85 84 matrix and any bounds or costs to be updated (sensibly). 86 85 Returns nonzero if any changes. 87 86 */ 88 virtual int refresh(ClpSimplex *model);89 87 virtual int refresh(ClpSimplex *model); 88 /** Creates a variable. This is called after partial pricing and will modify matrix. 90 89 Will update bestSequence. 91 90 */ 92 virtual void createVariable(ClpSimplex * model, int &bestSequence);93 94 virtual double reducedCost( ClpSimplex *model, int sequence) const;95 96 97 98 void writeMps(const char *name);99 100 101 102 int addColumn(CoinBigIndex numberEntries, const int * row, const double *element,103 104 105 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. 106 105 If >=0 then entry stayed in, if 1 then entry went out to lower bound.of zero. 107 106 Entries at upper bound (really nonzero) never go out (at present). 108 107 */ 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. 130 133 It assumes factorization frequency will not be changed. 131 134 This resizes model !!!! … … 133 136 will be sanitized so can be deleted (to avoid a very small memory leak) 134 137 */ 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 //@} 289 325 290 326 protected: 291 327 /**@name Data members 292 328 The data members are protected to allow access for derived classes. */ 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 int *backToPivotRow_;308 309 mutable int *keyVariable_;310 311 int *toIndex_;312 313 int *fromIndex_;314 315 316 317 318 319 320 321 double *lowerSet_;322 323 double *upperSet_;324 325 unsigned char *status_;326 327 ClpSimplex *model_;328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 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). 345 381 1  always check 346 382 0  don't check 347 383 1  in don't check mode but looks optimal 348 384 */ 349 350 351 352 353 354 355 356 357 358 359 int *startSet_;360 361 int *next_;362 363 CoinBigIndex *startColumn_;364 365 int *row_;366 367 double *element_;368 369 double *cost_;370 371 int *id_;372 373 unsigned char *dynamicStatus_;374 375 double *columnLower_;376 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 //@} 379 415 }; 380 416 381 417 #endif 418 419 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2 420 */
Note: See TracChangeset
for help on using the changeset viewer.