# CoinPresolveMatrix.hpp

Go to the documentation of this file.

    00001 /* $Id: CoinPresolveMatrix.hpp 1761 2014-12-10 09:43:07Z forrest $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef CoinPresolveMatrix_H
    00007 #define CoinPresolveMatrix_H
    00008
    00009 #include "CoinPragma.hpp"
    00010 #include "CoinPackedMatrix.hpp"
    00011 #include "CoinMessage.hpp"
    00012 #include "CoinTime.hpp"
    00013
    00014 #include <cmath>
    00015 #include <cassert>
    00016 #include <cfloat>
    00017 #include <cassert>
    00018 #include <cstdlib>
    00019
    00020 #if PRESOLVE_DEBUG > 0
    00021 #include "CoinFinite.hpp"
    00022 #endif
    00023
    00032 #if defined(_MSC_VER)
    00033 // Avoid MS Compiler problem in recognizing type to delete
    00034 // by casting to type.
    00035 // Is this still necessary? -- lh, 111202 --
    00036 #define deleteAction(array,type) delete [] ((type) array)
    00037 #else
    00038 #define deleteAction(array,type) delete [] array
    00039 #endif
    00040
    00041 /*
    00042   Define PRESOLVE_DEBUG and PRESOLVE_CONSISTENCY on the configure command
    00043   line or in a Makefile!  See comments in CoinPresolvePsdebug.hpp.
    00044 */
    00045 #if PRESOLVE_DEBUG > 0 || PRESOLVE_CONSISTENCY > 0
    00046
    00047 #define PRESOLVE_STMT(s) s
    00048
    00049 #define PRESOLVEASSERT(x) \
    00050   ((x) ? 1 : ((std::cerr << "FAILED ASSERTION at line " \
    00051                          << __LINE__ << ": " #x "\n"), abort(), 0))
    00052
    00053 inline void DIE(const char *s) { std::cout << s ; abort() ; }
    00054
    00065 #define PRESENT_IN_REDUCED      '\377'
    00066
    00067 #else
    00068
    00069 #define PRESOLVEASSERT(x) {}
    00070 #define PRESOLVE_STMT(s) {}
    00071
    00072 inline void DIE(const char *) {}
    00073
    00074 #endif
    00075
    00076 /*
    00077   Unclear why these are separate from standard debug.
    00078 */
    00079 #ifndef PRESOLVE_DETAIL
    00080 #define PRESOLVE_DETAIL_PRINT(s) {}
    00081 #else
    00082 #define PRESOLVE_DETAIL_PRINT(s) s
    00083 #endif
    00084
    00089 const double ZTOLDP = 1e-12 ;
    00094 const double ZTOLDP2 = 1e-10 ;
    00095
    00097 #define PRESOLVE_INF COIN_DBL_MAX
    00099 #define PRESOLVE_SMALL_INF 1.0e20
    00101 #define PRESOLVEFINITE(n) (-PRESOLVE_INF < (n) && (n) < PRESOLVE_INF)
    00102
    00103
    00104 class CoinPostsolveMatrix ;
    00105
    00155 class CoinPresolveAction
    00156 {
    00157  public:
    00164   static void throwCoinError(const char *error, const char *ps_routine)
    00165   { throw CoinError(error, ps_routine, "CoinPresolve"); }
    00166
    00171   const CoinPresolveAction *next;
    00172
    00178   CoinPresolveAction(const CoinPresolveAction *next) : next(next) {}
    00180   inline void setNext(const CoinPresolveAction *nextAction)
    00181   { next = nextAction;}
    00182
    00187   virtual const char *name() const = 0;
    00188
    00192   virtual void postsolve(CoinPostsolveMatrix *prob) const = 0;
    00193
    00195   virtual ~CoinPresolveAction() {}
    00196 };
    00197
    00198 /*
    00199   These are needed for OSI-aware constructors associated with
    00200   CoinPrePostsolveMatrix, CoinPresolveMatrix, and CoinPostsolveMatrix.
    00201 */
    00202 class ClpSimplex;
    00203 class OsiSolverInterface;
    00204
    00205 /*
    00206   CoinWarmStartBasis is required for methods in CoinPrePostsolveMatrix
    00207   that accept/return a CoinWarmStartBasis object.
    00208 */
    00209 class CoinWarmStartBasis ;
    00210
    00265 class CoinPrePostsolveMatrix
    00266 {
    00267  public:
    00268
    00278   CoinPrePostsolveMatrix(int ncols_alloc, int nrows_alloc,
    00279                          CoinBigIndex nelems_alloc) ;
    00280
    00285   CoinPrePostsolveMatrix(const OsiSolverInterface * si,
    00286                         int ncols_,
    00287                         int nrows_,
    00288                         CoinBigIndex nelems_);
    00289
    00294   CoinPrePostsolveMatrix(const ClpSimplex * si,
    00295                         int ncols_,
    00296                         int nrows_,
    00297                         CoinBigIndex nelems_,
    00298                          double bulkRatio);
    00299
    00301   ~CoinPrePostsolveMatrix();
    00303
    00313   enum Status {
    00314     isFree = 0x00,
    00315     basic = 0x01,
    00316     atUpperBound = 0x02,
    00317     atLowerBound = 0x03,
    00318     superBasic = 0x04
    00319   };
    00320
    00333
    00335   inline void setRowStatus(int sequence, Status status)
    00336   {
    00337     unsigned char & st_byte = rowstat_[sequence];
    00338     st_byte = static_cast<unsigned char>(st_byte & (~7)) ;
    00339     st_byte = static_cast<unsigned char>(st_byte | status) ;
    00340   }
    00342   inline Status getRowStatus(int sequence) const
    00343   {return static_cast<Status> (rowstat_[sequence]&7);}
    00345   inline bool rowIsBasic(int sequence) const
    00346   {return (static_cast<Status> (rowstat_[sequence]&7)==basic);}
    00348   inline void setColumnStatus(int sequence, Status status)
    00349   {
    00350     unsigned char & st_byte = colstat_[sequence];
    00351     st_byte = static_cast<unsigned char>(st_byte & (~7)) ;
    00352     st_byte = static_cast<unsigned char>(st_byte | status) ;
    00353
    00354 #   ifdef PRESOLVE_DEBUG
    00355     switch (status)
    00356     { case isFree:
    00357       { if (clo_[sequence] > -PRESOLVE_INF || cup_[sequence] < PRESOLVE_INF)
    00358         { std::cout << "Bad status: Var " << sequence
    00359                     << " isFree, lb = " << clo_[sequence]
    00360                     << ", ub = " << cup_[sequence] << std::endl ; }
    00361         break ; }
    00362       case basic:
    00363       { break ; }
    00364       case atUpperBound:
    00365       { if (cup_[sequence] >= PRESOLVE_INF)
    00366         { std::cout << "Bad status: Var " << sequence
    00367                     << " atUpperBound, lb = " << clo_[sequence]
    00368                     << ", ub = " << cup_[sequence] << std::endl ; }
    00369         break ; }
    00370       case atLowerBound:
    00371       { if (clo_[sequence] <= -PRESOLVE_INF)
    00372         { std::cout << "Bad status: Var " << sequence
    00373                     << " atLowerBound, lb = " << clo_[sequence]
    00374                     << ", ub = " << cup_[sequence] << std::endl ; }
    00375         break ; }
    00376       case superBasic:
    00377       { if (clo_[sequence] <= -PRESOLVE_INF && cup_[sequence] >= PRESOLVE_INF)
    00378         { std::cout << "Bad status: Var " << sequence
    00379                     << " superBasic, lb = " << clo_[sequence]
    00380                     << ", ub = " << cup_[sequence] << std::endl ; }
    00381         break ; }
    00382       default:
    00383       { assert(false) ;
    00384         break ; } }
    00385 #   endif
    00386   }
    00388   inline Status getColumnStatus(int sequence) const
    00389   {return static_cast<Status> (colstat_[sequence]&7);}
    00391   inline bool columnIsBasic(int sequence) const
    00392   {return (static_cast<Status> (colstat_[sequence]&7)==basic);}
    00396   void setRowStatusUsingValue(int iRow);
    00400   void setColumnStatusUsingValue(int iColumn);
    00402   void setStructuralStatus(const char *strucStatus, int lenParam) ;
    00404   void setArtificialStatus(const char *artifStatus, int lenParam) ;
    00406   void setStatus(const CoinWarmStartBasis *basis) ;
    00408   CoinWarmStartBasis *getStatus() ;
    00412   const char *columnStatusString(int j) const ;
    00416   const char *rowStatusString(int i) const ;
    00418
    00426
    00427   void setObjOffset(double offset) ;
    00434   void setObjSense(double objSense) ;
    00436   void setPrimalTolerance(double primTol) ;
    00438   void setDualTolerance(double dualTol) ;
    00440   void setColLower(const double *colLower, int lenParam) ;
    00442   void setColUpper(const double *colUpper, int lenParam) ;
    00444   void setColSolution(const double *colSol, int lenParam) ;
    00446   void setCost(const double *cost, int lenParam) ;
    00448   void setReducedCost(const double *redCost, int lenParam) ;
    00450   void setRowLower(const double *rowLower, int lenParam) ;
    00452   void setRowUpper(const double *rowUpper, int lenParam) ;
    00454   void setRowPrice(const double *rowSol, int lenParam) ;
    00456   void setRowActivity(const double *rowAct, int lenParam) ;
    00458
    00461
    00462   inline int getNumCols() const
    00463   { return (ncols_) ; }
    00465   inline int getNumRows() const
    00466   { return (nrows_) ; }
    00468   inline int getNumElems() const
    00469   { return (nelems_) ; }
    00471   inline const CoinBigIndex *getColStarts() const
    00472   { return (mcstrt_) ; }
    00474   inline const int *getColLengths() const
    00475   { return (hincol_) ; }
    00477   inline const int *getRowIndicesByCol() const
    00478   { return (hrow_) ; }
    00480   inline const double *getElementsByCol() const
    00481   { return (colels_) ; }
    00483   inline const double *getColLower() const
    00484   { return (clo_) ; }
    00486   inline const double *getColUpper() const
    00487   { return (cup_) ; }
    00489   inline const double *getCost() const
    00490   { return (cost_) ; }
    00492   inline const double *getRowLower() const
    00493   { return (rlo_) ; }
    00495   inline const double *getRowUpper() const
    00496   { return (rup_) ; }
    00498   inline const double *getColSolution() const
    00499   { return (sol_) ; }
    00501   inline const double *getRowActivity() const
    00502   { return (acts_) ; }
    00504   inline const double *getRowPrice() const
    00505   { return (rowduals_) ; }
    00507   inline const double *getReducedCost() const
    00508   { return (rcosts_) ; }
    00510   inline int countEmptyCols()
    00511   { int empty = 0 ;
    00512     for (int i = 0 ; i < ncols_ ; i++) if (hincol_[i] == 0) empty++ ;
    00513     return (empty) ; }
    00515
    00516
    00519
    00520   inline CoinMessageHandler *messageHandler() const
    00521   { return handler_; }
    00527   inline void setMessageHandler(CoinMessageHandler *handler)
    00528   { if (defaultHandler_ == true)
    00529     { delete handler_ ;
    00530       defaultHandler_ = false ; }
    00531     handler_ = handler ; }
    00533   inline CoinMessages messages() const
    00534   { return messages_; }
    00536
    00546
    00548   int ncols_;
    00550   int nrows_;
    00552   CoinBigIndex nelems_;
    00553
    00555   int ncols0_;
    00557   int nrows0_ ;
    00559   CoinBigIndex nelems0_ ;
    00568   CoinBigIndex bulk0_ ;
    00570   double bulkRatio_;
    00572
    00581
    00582   CoinBigIndex *mcstrt_;
    00584   int *hincol_;
    00586   int *hrow_;
    00588   double *colels_;
    00589
    00591   double *cost_;
    00593   double originalOffset_;
    00594
    00596   double *clo_;
    00598   double *cup_;
    00599
    00601   double *rlo_;
    00603   double *rup_;
    00604
    00611   int * originalColumn_;
    00618   int * originalRow_;
    00619
    00621   double ztolzb_;
    00623   double ztoldj_;
    00624
    00630   double maxmin_;
    00632
    00653   double *sol_;
    00659   double *rowduals_;
    00665   double *acts_;
    00671   double *rcosts_;
    00672
    00679   unsigned char *colstat_;
    00680
    00687   unsigned char *rowstat_;
    00689
    00698
    00699   CoinMessageHandler *handler_;
    00701   bool defaultHandler_;
    00703   CoinMessage messages_;
    00705
    00706 };
    00707
    00711 const char *statusName (CoinPrePostsolveMatrix::Status status) ;
    00712
    00713
    00738 class presolvehlink
    00739 { public:
    00740   int pre, suc;
    00741 } ;
    00742
    00743 #define NO_LINK -66666666
    00744
    00750 inline void PRESOLVE_REMOVE_LINK(presolvehlink *link, int i)
    00751 {
    00752   int ipre = link[i].pre;
    00753   int isuc = link[i].suc;
    00754   if (ipre >= 0) {
    00755     link[ipre].suc = isuc;
    00756   }
    00757   if (isuc >= 0) {
    00758     link[isuc].pre = ipre;
    00759   }
    00760   link[i].pre = NO_LINK, link[i].suc = NO_LINK;
    00761 }
    00762
    00768 inline void PRESOLVE_INSERT_LINK(presolvehlink *link, int i, int j)
    00769 {
    00770   int isuc = link[j].suc;
    00771   link[j].suc = i;
    00772   link[i].pre = j;
    00773   if (isuc >= 0) {
    00774     link[isuc].pre = i;
    00775   }
    00776   link[i].suc = isuc;
    00777 }
    00778
    00790 inline void PRESOLVE_MOVE_LINK(presolvehlink *link, int i, int j)
    00791 {
    00792   int ipre = link[i].pre;
    00793   int isuc = link[i].suc;
    00794   if (ipre >= 0) {
    00795     link[ipre].suc = j;
    00796   }
    00797   if (isuc >= 0) {
    00798     link[isuc].pre = j;
    00799   }
    00800   link[i].pre = NO_LINK, link[i].suc = NO_LINK;
    00801 }
    00802
    00803
    00835 class CoinPresolveMatrix : public CoinPrePostsolveMatrix
    00836 {
    00837  public:
    00838
    00845   CoinPresolveMatrix(int ncols_alloc, int nrows_alloc,
    00846                      CoinBigIndex nelems_alloc) ;
    00847
    00852   CoinPresolveMatrix(int ncols0,
    00853                     double maxmin,
    00854                     // end prepost members
    00855
    00856                     ClpSimplex * si,
    00857
    00858                     // rowrep
    00859                     int nrows,
    00860                     CoinBigIndex nelems,
    00861                  bool doStatus,
    00862                  double nonLinearVariable,
    00863                      double bulkRatio);
    00864
    00866   void update_model(ClpSimplex * si,
    00867                             int nrows0,
    00868                             int ncols0,
    00869                             CoinBigIndex nelems0);
    00874   CoinPresolveMatrix(int ncols0,
    00875                      double maxmin,
    00876                      // end prepost members
    00877                      OsiSolverInterface * si,
    00878                      // rowrep
    00879                      int nrows,
    00880                      CoinBigIndex nelems,
    00881                      bool doStatus,
    00882                      double nonLinearVariable,
    00883                      const char * prohibited,
    00884                      const char * rowProhibited=NULL);
    00885
    00887   void update_model(OsiSolverInterface * si,
    00888                             int nrows0,
    00889                             int ncols0,
    00890                             CoinBigIndex nelems0);
    00891
    00893   ~CoinPresolveMatrix();
    00894
    00900   friend void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ;
    00901
    00910   void setMatrix(const CoinPackedMatrix *mtx) ;
    00911
    00913   inline int countEmptyRows()
    00914   { int empty = 0 ;
    00915     for (int i = 0 ; i < nrows_ ; i++) if (hinrow_[i] == 0) empty++ ;
    00916     return (empty) ; }
    00917
    00923   inline void setVariableType(int i, int variableType)
    00924   { if (integerType_ == 0) integerType_ = new unsigned char [ncols0_] ;
    00925     integerType_[i] = static_cast<unsigned char>(variableType) ; }
    00926
    00932   void setVariableType(const unsigned char *variableType, int lenParam) ;
    00933
    00939   void setVariableType (bool allIntegers, int lenParam) ;
    00940
    00942   inline void setAnyInteger (bool anyInteger = true)
    00943   { anyInteger_ = anyInteger ; }
    00945
    00949
    00951   inline const CoinBigIndex *getRowStarts() const
    00952   { return (mrstrt_) ; }
    00954   inline const int *getColIndicesByRow() const
    00955   { return (hcol_) ; }
    00957   inline const double *getElementsByRow() const
    00958   { return (rowels_) ; }
    00959
    00965   inline bool isInteger (int i) const
    00966   { if (integerType_ == 0)
    00967     { return (anyInteger_) ; }
    00968     else
    00969     if (integerType_[i] == 1)
    00970     { return (true) ; }
    00971     else
    00972     { return (false) ; } }
    00973
    00978   inline bool anyInteger () const
    00979   { return (anyInteger_) ; }
    00981   inline int presolveOptions() const
    00982   { return presolveOptions_;}
    00984   inline void setPresolveOptions(int value)
    00985   { presolveOptions_=value;}
    00987
    00995
    00996   presolvehlink *clink_;
    00998   presolvehlink *rlink_;
    01000
    01002   double dobias_ ;
    01003
    01005   inline void change_bias(double change_amount)
    01006   {
    01007     dobias_ += change_amount ;
    01008   # if PRESOLVE_DEBUG > 2
    01009     assert(fabs(change_amount)<1.0e50) ;
    01010     if (change_amount)
    01011       PRESOLVE_STMT(printf("changing bias by %g to %g\n",
    01012                             change_amount, dobias_)) ;
    01013   # endif
    01014   }
    01015
    01024
    01025   CoinBigIndex *mrstrt_;
    01027   int *hinrow_;
    01029   double *rowels_;
    01031   int *hcol_;
    01033
    01035   unsigned char *integerType_;
    01041   bool anyInteger_ ;
    01043   bool tuning_;
    01045   void statistics();
    01047   double startTime_;
    01048
    01050   double feasibilityTolerance_;
    01052   inline double feasibilityTolerance()
    01053   { return (feasibilityTolerance_) ; }
    01055   inline void setFeasibilityTolerance (double val)
    01056   { feasibilityTolerance_ = val ; }
    01057
    01063   int status_;
    01065   inline int status()
    01066   { return (status_) ; }
    01068   inline void setStatus(int status)
    01069   { status_ = (status&0x3) ; }
    01070
    01078   int pass_;
    01080   inline void setPass (int pass = 0)
    01081   { pass_ = pass ; }
    01082
    01087   int maxSubstLevel_;
    01089   inline void setMaximumSubstitutionLevel (int level)
    01090   { maxSubstLevel_ = level ; }
    01091
    01092
    01116   unsigned char * colChanged_;
    01118   int * colsToDo_;
    01120   int numberColsToDo_;
    01122   int * nextColsToDo_;
    01124   int numberNextColsToDo_;
    01125
    01135   unsigned char * rowChanged_;
    01137   int * rowsToDo_;
    01139   int numberRowsToDo_;
    01141   int * nextRowsToDo_;
    01143   int numberNextRowsToDo_;
    01161   int presolveOptions_;
    01167   bool anyProhibited_;
    01169
    01180
    01181   int *usefulRowInt_ ;
    01183   double *usefulRowDouble_ ;
    01185   int *usefulColumnInt_ ;
    01187   double *usefulColumnDouble_ ;
    01189   double *randomNumber_ ;
    01190
    01192   int *infiniteUp_ ;
    01194   double *sumUp_ ;
    01196   int *infiniteDown_ ;
    01198   double *sumDown_ ;
    01200
    01212   int recomputeSums(int whichRow) ;
    01213
    01215   void initializeStuff() ;
    01217   void deleteStuff() ;
    01218
    01221
    01227   void initColsToDo () ;
    01228
    01234   int stepColsToDo () ;
    01235
    01237   inline int numberColsToDo()
    01238   { return (numberColsToDo_) ; }
    01239
    01241   inline bool colChanged(int i) const {
    01242     return (colChanged_[i]&1)!=0;
    01243   }
    01245   inline void unsetColChanged(int i) {
    01246     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~1)) ;
    01247   }
    01249   inline void setColChanged(int i) {
    01250     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (1)) ;
    01251   }
    01253   inline void addCol(int i) {
    01254     if ((colChanged_[i]&1)==0) {
    01255       colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (1)) ;
    01256       nextColsToDo_[numberNextColsToDo_++] = i;
    01257     }
    01258   }
    01260   inline bool colProhibited(int i) const {
    01261     return (colChanged_[i]&2)!=0;
    01262   }
    01269   inline bool colProhibited2(int i) const {
    01270     if (!anyProhibited_)
    01271       return false;
    01272     else
    01273       return (colChanged_[i]&2)!=0;
    01274   }
    01276   inline void setColProhibited(int i) {
    01277     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (2)) ;
    01278   }
    01284   inline bool colUsed(int i) const {
    01285     return (colChanged_[i]&4)!=0;
    01286   }
    01288   inline void setColUsed(int i) {
    01289     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (4)) ;
    01290   }
    01292   inline void unsetColUsed(int i) {
    01293     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~4)) ;
    01294   }
    01296   inline bool colInfinite(int i) const {
    01297     return (colChanged_[i]&8)!=0;
    01298   }
    01300   inline void unsetColInfinite(int i) {
    01301     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~8)) ;
    01302   }
    01304   inline void setColInfinite(int i) {
    01305     colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (8)) ;
    01306   }
    01307
    01313   void initRowsToDo () ;
    01314
    01320   int stepRowsToDo () ;
    01321
    01323   inline int numberRowsToDo()
    01324   { return (numberRowsToDo_) ; }
    01325
    01327   inline bool rowChanged(int i) const {
    01328     return (rowChanged_[i]&1)!=0;
    01329   }
    01331   inline void unsetRowChanged(int i) {
    01332     rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] & (~1)) ;
    01333   }
    01335   inline void setRowChanged(int i) {
    01336     rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (1)) ;
    01337   }
    01339   inline void addRow(int i) {
    01340     if ((rowChanged_[i]&1)==0) {
    01341       rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (1)) ;
    01342       nextRowsToDo_[numberNextRowsToDo_++] = i;
    01343     }
    01344   }
    01346   inline bool rowProhibited(int i) const {
    01347     return (rowChanged_[i]&2)!=0;
    01348   }
    01355   inline bool rowProhibited2(int i) const {
    01356     if (!anyProhibited_)
    01357       return false;
    01358     else
    01359       return (rowChanged_[i]&2)!=0;
    01360   }
    01362   inline void setRowProhibited(int i) {
    01363     rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (2)) ;
    01364   }
    01370   inline bool rowUsed(int i) const {
    01371     return (rowChanged_[i]&4)!=0;
    01372   }
    01374   inline void setRowUsed(int i) {
    01375     rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (4)) ;
    01376   }
    01378   inline void unsetRowUsed(int i) {
    01379     rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] & (~4)) ;
    01380   }
    01381
    01382
    01384   inline bool anyProhibited() const
    01385   { return anyProhibited_;}
    01387   inline void setAnyProhibited(bool val = true)
    01388   { anyProhibited_ = val ; }
    01390
    01391 };
    01392
    01421 class CoinPostsolveMatrix : public CoinPrePostsolveMatrix
    01422 {
    01423  public:
    01424
    01431   CoinPostsolveMatrix(int ncols_alloc, int nrows_alloc,
    01432                       CoinBigIndex nelems_alloc) ;
    01433
    01434
    01439   CoinPostsolveMatrix(ClpSimplex * si,
    01440
    01441                    int ncols0,
    01442                    int nrows0,
    01443                    CoinBigIndex nelems0,
    01444
    01445                    double maxmin_,
    01446                    // end prepost members
    01447
    01448                    double *sol,
    01449                    double *acts,
    01450
    01451                    unsigned char *colstat,
    01452                    unsigned char *rowstat);
    01453
    01458   CoinPostsolveMatrix(OsiSolverInterface * si,
    01459
    01460                    int ncols0,
    01461                    int nrows0,
    01462                    CoinBigIndex nelems0,
    01463
    01464                    double maxmin_,
    01465                    // end prepost members
    01466
    01467                    double *sol,
    01468                    double *acts,
    01469
    01470                    unsigned char *colstat,
    01471                    unsigned char *rowstat);
    01472
    01483   void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ;
    01484
    01486   ~CoinPostsolveMatrix();
    01487
    01499
    01501   CoinBigIndex free_list_;
    01503   int maxlink_;
    01508   CoinBigIndex *link_;
    01509
    01511
    01519   char *cdone_;
    01520   char *rdone_;
    01522
    01524   void check_nbasic();
    01525
    01526 };
    01527
    01528
    01535
    01540 void presolve_make_memlists(/*CoinBigIndex *starts,*/ int *lengths,
    01541                             presolvehlink *link, int n);
    01542
    01550 bool presolve_expand_major(CoinBigIndex *majstrts, double *majels,
    01551                            int *minndxs, int *majlens,
    01552                            presolvehlink *majlinks, int nmaj, int k) ;
    01553
    01559 inline bool presolve_expand_col(CoinBigIndex *mcstrt, double *colels,
    01560                                 int *hrow, int *hincol,
    01561                                 presolvehlink *clink, int ncols, int colx)
    01562 { return presolve_expand_major(mcstrt,colels,
    01563                                hrow,hincol,clink,ncols,colx) ; }
    01564
    01570 inline bool presolve_expand_row(CoinBigIndex *mrstrt, double *rowels,
    01571                                 int *hcol, int *hinrow,
    01572                                 presolvehlink *rlink, int nrows, int rowx)
    01573 { return presolve_expand_major(mrstrt,rowels,
    01574                                hcol,hinrow,rlink,nrows,rowx) ; }
    01575
    01576
    01585 inline CoinBigIndex presolve_find_minor(int tgt,
    01586                                         CoinBigIndex ks, CoinBigIndex ke,
    01587                                         const int *minndxs)
    01588 { CoinBigIndex k ;
    01589   for (k = ks ; k < ke ; k++)
    01590 #ifndef NDEBUG
    01591   { if (minndxs[k] == tgt)
    01592       return (k) ; }
    01593   DIE("FIND_MINOR") ;
    01594
    01595   abort () ; return -1;
    01596 #else
    01597   { if (minndxs[k] == tgt)
    01598       break ; }
    01599   return (k) ;
    01600 #endif
    01601 }
    01602
    01609 inline CoinBigIndex presolve_find_row(int row, CoinBigIndex kcs,
    01610                                       CoinBigIndex kce, const int *hrow)
    01611 { return presolve_find_minor(row,kcs,kce,hrow) ; }
    01612
    01619 inline CoinBigIndex presolve_find_col(int col, CoinBigIndex krs,
    01620                                       CoinBigIndex kre, const int *hcol)
    01621 { return presolve_find_minor(col,krs,kre,hcol) ; }
    01622
    01623
    01632 CoinBigIndex presolve_find_minor1(int tgt, CoinBigIndex ks, CoinBigIndex ke,
    01633                                   const int *minndxs);
    01634
    01641 inline CoinBigIndex presolve_find_row1(int row, CoinBigIndex kcs,
    01642                                        CoinBigIndex kce, const int *hrow)
    01643 { return presolve_find_minor1(row,kcs,kce,hrow) ; }
    01644
    01651 inline CoinBigIndex presolve_find_col1(int col, CoinBigIndex krs,
    01652                                        CoinBigIndex kre, const int *hcol)
    01653 { return presolve_find_minor1(col,krs,kre,hcol) ; }
    01654
    01663 CoinBigIndex presolve_find_minor2(int tgt, CoinBigIndex ks, int majlen,
    01664                                   const int *minndxs,
    01665                                   const CoinBigIndex *majlinks) ;
    01666
    01674 inline CoinBigIndex presolve_find_row2(int row, CoinBigIndex kcs, int collen,
    01675                                        const int *hrow,
    01676                                        const CoinBigIndex *clinks)
    01677 { return presolve_find_minor2(row,kcs,collen,hrow,clinks) ; }
    01678
    01687 CoinBigIndex presolve_find_minor3(int tgt, CoinBigIndex ks, int majlen,
    01688                                   const int *minndxs,
    01689                                   const CoinBigIndex *majlinks) ;
    01690
    01698 inline CoinBigIndex presolve_find_row3(int row, CoinBigIndex kcs, int collen,
    01699                                        const int *hrow,
    01700                                        const CoinBigIndex *clinks)
    01701 { return presolve_find_minor3(row,kcs,collen,hrow,clinks) ; }
    01702
    01712 inline void presolve_delete_from_major(int majndx, int minndx,
    01713                                 const CoinBigIndex *majstrts,
    01714                                 int *majlens, int *minndxs, double *els)
    01715 {
    01716   const CoinBigIndex ks = majstrts[majndx] ;
    01717   const CoinBigIndex ke = ks+majlens[majndx] ;
    01718
    01719   const CoinBigIndex kmi = presolve_find_minor(minndx,ks,ke,minndxs) ;
    01720
    01721   minndxs[kmi] = minndxs[ke-1] ;
    01722   els[kmi] = els[ke-1] ;
    01723   majlens[majndx]-- ;
    01724
    01725   return ;
    01726 }
    01727
    01734 inline void presolve_delete_many_from_major(int majndx, char *marked,
    01735                                 const CoinBigIndex *majstrts,
    01736                                 int *majlens, int *minndxs, double *els)
    01737 {
    01738   const CoinBigIndex ks = majstrts[majndx] ;
    01739   const CoinBigIndex ke = ks+majlens[majndx] ;
    01740   CoinBigIndex put = ks ;
    01741   for (CoinBigIndex k = ks ; k < ke ; k++) {
    01742     int iMinor = minndxs[k] ;
    01743     if (!marked[iMinor]) {
    01744       minndxs[put] = iMinor ;
    01745       els[put++] = els[k] ;
    01746     } else {
    01747       marked[iMinor] = 0 ;
    01748     }
    01749   }
    01750   majlens[majndx] = put-ks ;
    01751   return ;
    01752 }
    01753
    01764 inline void presolve_delete_from_col(int row, int col,
    01765                                      const CoinBigIndex *mcstrt,
    01766                                      int *hincol, int *hrow, double *colels)
    01767 { presolve_delete_from_major(col,row,mcstrt,hincol,hrow,colels) ; }
    01768
    01779 inline void presolve_delete_from_row(int row, int col,
    01780                                      const CoinBigIndex *mrstrt,
    01781                                      int *hinrow, int *hcol, double *rowels)
    01782 { presolve_delete_from_major(row,col,mrstrt,hinrow,hcol,rowels) ; }
    01783
    01794 void presolve_delete_from_major2 (int majndx, int minndx,
    01795                                   CoinBigIndex *majstrts, int *majlens,
    01796                                   int *minndxs, int *majlinks,
    01797                                    CoinBigIndex *free_listp) ;
    01798
    01809 inline void presolve_delete_from_col2(int row, int col, CoinBigIndex *mcstrt,
    01810                                       int *hincol, int *hrow,
    01811                                       int *clinks, CoinBigIndex *free_listp)
    01812 { presolve_delete_from_major2(col,row,mcstrt,hincol,hrow,clinks,free_listp) ; }
    01813
    01815
    01821
    01833 double *presolve_dupmajor(const double *elems, const int *indices,
    01834                           int length, CoinBigIndex offset, int tgt = -1);
    01835
    01837 void coin_init_random_vec(double *work, int n);
    01838
    01840
    01841
    01842 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines