00001
00002
00003 #ifndef CoinPresolveMatrix_H
00004 #define CoinPresolveMatrix_H
00005
00006 #include "CoinPragma.hpp"
00007 #include "CoinPackedMatrix.hpp"
00008 #include "CoinMessage.hpp"
00009 #include "CoinTime.hpp"
00010
00011 #include <cmath>
00012 #include <cassert>
00013 #include <cfloat>
00014 #include <cassert>
00015
00024 #if defined(_MSC_VER)
00025
00026
00027 #define deleteAction(array,type) delete [] ((type) array)
00028 #else
00029 #define deleteAction(array,type) delete [] array
00030 #endif
00031
00036 const double ZTOLDP = 1e-12;
00037
00038
00039
00040 #if PRESOLVE_DEBUG || PRESOLVE_CONSISTENCY
00041 #define PRESOLVE_STMT(s) s
00042 #define PRESOLVEASSERT(x) \
00043 ((x) ? 1 : \
00044 ((std::cerr << "FAILED ASSERTION at line " \
00045 << __LINE__ << ": " #x "\n"), abort(), 0))
00046
00047 inline void DIE(const char *s) { std::cout<<s; abort(); }
00048
00049
00050
00051 #define PRESENT_IN_REDUCED '\377'
00052
00053 #else
00054
00055 #define PRESOLVEASSERT(x)
00056 #define PRESOLVE_STMT(s)
00057
00058 inline void DIE(const char *s) {}
00059
00060 #endif
00061
00062 inline int ALIGN(int n, int m) { return (((n + m - 1) / m) * m); }
00063 inline int ALIGN_DOUBLE(int n) { return ALIGN(n,sizeof(double)); }
00064
00065
00066 #ifndef COIN_DBL_MAX
00067 #define COIN_DBL_MAX DBL_MAX
00068 #endif
00069 #define PRESOLVE_INF COIN_DBL_MAX
00070
00071 class CoinPostsolveMatrix;
00072
00073
00074
00075
00076
00077
00078
00079
00080
00130 class CoinPresolveAction
00131 {
00132 public:
00139 static void throwCoinError(const char *error, const char *ps_routine)
00140 { throw CoinError(error, ps_routine, "CoinPresolve"); }
00141
00142
00147 const CoinPresolveAction *next;
00148
00154 CoinPresolveAction(const CoinPresolveAction *next) : next(next) {}
00155
00160 virtual const char *name() const = 0;
00161
00165 virtual void postsolve(CoinPostsolveMatrix *prob) const = 0;
00166
00168 virtual ~CoinPresolveAction() {}
00169 };
00170
00171
00172
00173
00174
00175 class ClpSimplex;
00176 class OsiSolverInterface;
00177
00178
00179
00180
00181
00182 class CoinWarmStartBasis ;
00183
00232 class CoinPrePostsolveMatrix
00233 {
00234 public:
00235
00245 CoinPrePostsolveMatrix(int ncols_alloc, int nrows_alloc,
00246 CoinBigIndex nelems_alloc) ;
00247
00252 CoinPrePostsolveMatrix(const OsiSolverInterface * si,
00253 int ncols_,
00254 int nrows_,
00255 CoinBigIndex nelems_);
00256
00261 CoinPrePostsolveMatrix(const ClpSimplex * si,
00262 int ncols_,
00263 int nrows_,
00264 CoinBigIndex nelems_,
00265 double bulkRatio);
00266
00268 ~CoinPrePostsolveMatrix();
00270
00280 enum Status {
00281 isFree = 0x00,
00282 basic = 0x01,
00283 atUpperBound = 0x02,
00284 atLowerBound = 0x03,
00285 superBasic = 0x04
00286 };
00287
00294
00296 inline void setRowStatus(int sequence, Status status)
00297 {
00298 unsigned char & st_byte = rowstat_[sequence];
00299 st_byte &= ~7;
00300 st_byte |= status;
00301 }
00303 inline Status getRowStatus(int sequence) const
00304 {return static_cast<Status> (rowstat_[sequence]&7);}
00306 inline bool rowIsBasic(int sequence) const
00307 {return (static_cast<Status> (rowstat_[sequence]&7)==basic);}
00309 inline void setColumnStatus(int sequence, Status status)
00310 {
00311 unsigned char & st_byte = colstat_[sequence];
00312 st_byte &= ~7;
00313 st_byte |= status;
00314
00315 # ifdef PRESOLVE_DEBUG
00316 switch (status)
00317 { case isFree:
00318 { if (clo_[sequence] > -PRESOLVE_INF || cup_[sequence] < PRESOLVE_INF)
00319 { std::cout << "Bad status: Var " << sequence
00320 << " isFree, lb = " << clo_[sequence]
00321 << ", ub = " << cup_[sequence] << std::endl ; }
00322 break ; }
00323 case basic:
00324 { break ; }
00325 case atUpperBound:
00326 { if (cup_[sequence] >= PRESOLVE_INF)
00327 { std::cout << "Bad status: Var " << sequence
00328 << " atUpperBound, lb = " << clo_[sequence]
00329 << ", ub = " << cup_[sequence] << std::endl ; }
00330 break ; }
00331 case atLowerBound:
00332 { if (clo_[sequence] <= -PRESOLVE_INF)
00333 { std::cout << "Bad status: Var " << sequence
00334 << " atLowerBound, lb = " << clo_[sequence]
00335 << ", ub = " << cup_[sequence] << std::endl ; }
00336 break ; }
00337 case superBasic:
00338 { if (clo_[sequence] <= -PRESOLVE_INF && cup_[sequence] >= PRESOLVE_INF)
00339 { std::cout << "Bad status: Var " << sequence
00340 << " superBasic, lb = " << clo_[sequence]
00341 << ", ub = " << cup_[sequence] << std::endl ; }
00342 break ; }
00343 default:
00344 { assert(false) ;
00345 break ; } }
00346 # endif
00347 }
00349 inline Status getColumnStatus(int sequence) const
00350 {return static_cast<Status> (colstat_[sequence]&7);}
00352 inline bool columnIsBasic(int sequence) const
00353 {return (static_cast<Status> (colstat_[sequence]&7)==basic);}
00357 void setRowStatusUsingValue(int iRow);
00361 void setColumnStatusUsingValue(int iColumn);
00363 void setStructuralStatus(const char *strucStatus, int lenParam) ;
00365 void setArtificialStatus(const char *artifStatus, int lenParam) ;
00367 void setStatus(const CoinWarmStartBasis *basis) ;
00369 CoinWarmStartBasis *getStatus() ;
00373 const char *columnStatusString(int j) const ;
00377 const char *rowStatusString(int i) const ;
00379
00387
00388 void setObjOffset(double offset) ;
00393 void setObjSense(double objSense) ;
00395 void setPrimalTolerance(double primTol) ;
00397 void setDualTolerance(double dualTol) ;
00399 void setColLower(const double *colLower, int lenParam) ;
00401 void setColUpper(const double *colUpper, int lenParam) ;
00403 void setColSolution(const double *colSol, int lenParam) ;
00405 void setCost(const double *cost, int lenParam) ;
00407 void setReducedCost(const double *redCost, int lenParam) ;
00409 void setRowLower(const double *rowLower, int lenParam) ;
00411 void setRowUpper(const double *rowUpper, int lenParam) ;
00413 void setRowPrice(const double *rowSol, int lenParam) ;
00415 void setRowActivity(const double *rowAct, int lenParam) ;
00417
00420
00421 inline int getNumCols()
00422 { return (ncols_) ; }
00424 inline int getNumRows()
00425 { return (nrows_) ; }
00427 inline int getNumElems()
00428 { return (nelems_) ; }
00430 inline const CoinBigIndex *getColStarts() const
00431 { return (mcstrt_) ; }
00433 inline const int *getColLengths() const
00434 { return (hincol_) ; }
00436 inline const int *getRowIndicesByCol() const
00437 { return (hrow_) ; }
00439 inline const double *getElementsByCol() const
00440 { return (colels_) ; }
00442 inline const double *getColLower() const
00443 { return (clo_) ; }
00445 inline const double *getColUpper() const
00446 { return (cup_) ; }
00448 inline const double *getCost() const
00449 { return (cost_) ; }
00451 inline const double *getRowLower() const
00452 { return (rlo_) ; }
00454 inline const double *getRowUpper() const
00455 { return (rup_) ; }
00457 inline const double *getColSolution() const
00458 { return (sol_) ; }
00460 inline const double *getRowActivity() const
00461 { return (acts_) ; }
00463 inline const double *getRowPrice() const
00464 { return (rowduals_) ; }
00466 inline const double *getReducedCost() const
00467 { return (rcosts_) ; }
00469 inline int countEmptyCols()
00470 { int empty = 0 ;
00471 for (int i = 0 ; i < ncols_ ; i++) if (hincol_[i] == 0) empty++ ;
00472 return (empty) ; }
00474
00475
00478
00479 inline CoinMessageHandler *messageHandler() const
00480 { return handler_; }
00486 inline void setMessageHandler(CoinMessageHandler *handler)
00487 { if (defaultHandler_ == true)
00488 { delete handler_ ;
00489 defaultHandler_ = false ; }
00490 handler_ = handler ; }
00492 inline CoinMessages messages() const
00493 { return messages_; }
00495
00505
00507 int ncols_;
00509 int nrows_;
00511 CoinBigIndex nelems_;
00512
00514 int ncols0_;
00516 int nrows0_ ;
00518 CoinBigIndex nelems0_ ;
00527 CoinBigIndex bulk0_ ;
00529 double bulkRatio_;
00531
00540
00541 CoinBigIndex *mcstrt_;
00543 int *hincol_;
00545 int *hrow_;
00547 double *colels_;
00548
00550 double *cost_;
00552 double originalOffset_;
00553
00555 double *clo_;
00557 double *cup_;
00558
00560 double *rlo_;
00562 double *rup_;
00563
00565 int * originalColumn_;
00567 int * originalRow_;
00568
00570 double ztolzb_;
00572 double ztoldj_;
00573
00575 double maxmin_;
00577
00598 double *sol_;
00604 double *rowduals_;
00610 double *acts_;
00616 double *rcosts_;
00617
00624 unsigned char *colstat_;
00625
00632 unsigned char *rowstat_;
00634
00643
00644 CoinMessageHandler *handler_;
00646 bool defaultHandler_;
00648 CoinMessage messages_;
00650
00651 };
00652
00653
00678 class presolvehlink
00679 { public:
00680 int pre, suc;
00681 } ;
00682
00683 #define NO_LINK -66666666
00684
00690 inline void PRESOLVE_REMOVE_LINK(presolvehlink *link, int i)
00691 {
00692 int ipre = link[i].pre;
00693 int isuc = link[i].suc;
00694 if (ipre >= 0) {
00695 link[ipre].suc = isuc;
00696 }
00697 if (isuc >= 0) {
00698 link[isuc].pre = ipre;
00699 }
00700 link[i].pre = NO_LINK, link[i].suc = NO_LINK;
00701 }
00702
00708 inline void PRESOLVE_INSERT_LINK(presolvehlink *link, int i, int j)
00709 {
00710 int isuc = link[j].suc;
00711 link[j].suc = i;
00712 link[i].pre = j;
00713 if (isuc >= 0) {
00714 link[isuc].pre = i;
00715 }
00716 link[i].suc = isuc;
00717 }
00718
00730 inline void PRESOLVE_MOVE_LINK(presolvehlink *link, int i, int j)
00731 {
00732 int ipre = link[i].pre;
00733 int isuc = link[i].suc;
00734 if (ipre >= 0) {
00735 link[ipre].suc = j;
00736 }
00737 if (isuc >= 0) {
00738 link[isuc].pre = j;
00739 }
00740 link[i].pre = NO_LINK, link[i].suc = NO_LINK;
00741 }
00742
00743
00765 class CoinPresolveMatrix : public CoinPrePostsolveMatrix
00766 {
00767 public:
00768
00775 CoinPresolveMatrix(int ncols_alloc, int nrows_alloc,
00776 CoinBigIndex nelems_alloc) ;
00777
00782 CoinPresolveMatrix(int ncols0,
00783 double maxmin,
00784
00785
00786 ClpSimplex * si,
00787
00788
00789 int nrows,
00790 CoinBigIndex nelems,
00791 bool doStatus,
00792 double nonLinearVariable,
00793 double bulkRatio);
00794
00796 void update_model(ClpSimplex * si,
00797 int nrows0,
00798 int ncols0,
00799 CoinBigIndex nelems0);
00804 CoinPresolveMatrix(int ncols0,
00805 double maxmin,
00806
00807
00808 OsiSolverInterface * si,
00809
00810
00811 int nrows,
00812 CoinBigIndex nelems,
00813 bool doStatus,
00814 double nonLinearVariable,
00815 const char * prohibited);
00816
00818 void update_model(OsiSolverInterface * si,
00819 int nrows0,
00820 int ncols0,
00821 CoinBigIndex nelems0);
00822
00824 ~CoinPresolveMatrix();
00825
00831 friend void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ;
00832
00841 void setMatrix(const CoinPackedMatrix *mtx) ;
00842
00844 inline int countEmptyRows()
00845 { int empty = 0 ;
00846 for (int i = 0 ; i < nrows_ ; i++) if (hinrow_[i] == 0) empty++ ;
00847 return (empty) ; }
00848
00854 inline void setVariableType(int i, int variableType)
00855 { if (integerType_ == 0) integerType_ = new unsigned char [ncols0_] ;
00856 integerType_[i] = variableType ; }
00857
00863 void setVariableType(const unsigned char *variableType, int lenParam) ;
00864
00870 void setVariableType (bool allIntegers, int lenParam) ;
00871
00873 inline void setAnyInteger (bool anyInteger = true)
00874 { anyInteger_ = anyInteger ; }
00876
00880
00882 inline const CoinBigIndex *getRowStarts() const
00883 { return (mrstrt_) ; }
00885 inline const int *getColIndicesByRow() const
00886 { return (hcol_) ; }
00888 inline const double *getElementsByRow() const
00889 { return (rowels_) ; }
00890
00896 inline bool isInteger (int i) const
00897 { if (integerType_ == 0)
00898 { return (anyInteger_) ; }
00899 else
00900 if (integerType_[i] == 1)
00901 { return (true) ; }
00902 else
00903 { return (false) ; } }
00904
00909 inline bool anyInteger () const
00910 { return (anyInteger_) ; }
00912 inline int presolveOptions() const
00913 { return presolveOptions_;}
00915 inline void setPresolveOptions(int value)
00916 { presolveOptions_=value;}
00918
00926
00927 presolvehlink *clink_;
00929 presolvehlink *rlink_;
00931
00933 double dobias_;
00934
00936 inline void change_bias(double change_amount)
00937 {
00938 dobias_ += change_amount;
00939 #if PRESOLVE_DEBUG
00940 assert(fabs(change_amount)<1.0e50);
00941 #endif
00942 if (change_amount)
00943 PRESOLVE_STMT(printf("changing bias by %g to %g\n",
00944 change_amount, dobias_));
00945 }
00946
00955
00956 CoinBigIndex *mrstrt_;
00958 int *hinrow_;
00960 double *rowels_;
00962 int *hcol_;
00964
00966 unsigned char *integerType_;
00972 bool anyInteger_ ;
00974 bool tuning_;
00976 void statistics();
00978 double startTime_;
00979
00981 double feasibilityTolerance_;
00983 inline double feasibilityTolerance()
00984 { return (feasibilityTolerance_) ; }
00986 inline void setFeasibilityTolerance (double val)
00987 { feasibilityTolerance_ = val ; }
00988
00994 int status_;
00996 inline int status()
00997 { return (status_) ; }
00999 inline void setStatus(int status)
01000 { status_ = (status&0x3) ; }
01001
01007 int pass_;
01009 inline void setPass (int pass = 0)
01010 { pass_ = pass ; }
01011
01016 int maxSubstLevel_;
01018 inline void setMaximumSubstitutionLevel (int level)
01019 { maxSubstLevel_ = level ; }
01020
01021
01044 unsigned char * colChanged_;
01046 int * colsToDo_;
01048 int numberColsToDo_;
01050 int * nextColsToDo_;
01052 int numberNextColsToDo_;
01053
01063 unsigned char * rowChanged_;
01065 int * rowsToDo_;
01067 int numberRowsToDo_;
01069 int * nextRowsToDo_;
01071 int numberNextRowsToDo_;
01077 int presolveOptions_;
01083 bool anyProhibited_;
01085
01088
01094 void initColsToDo () ;
01095
01101 int stepColsToDo () ;
01102
01104 inline int numberColsToDo()
01105 { return (numberColsToDo_) ; }
01106
01108 inline bool colChanged(int i) const {
01109 return (colChanged_[i]&1)!=0;
01110 }
01112 inline void unsetColChanged(int i) {
01113 colChanged_[i] &= ~1;;
01114 }
01116 inline void setColChanged(int i) {
01117 colChanged_[i] |= 1;
01118 }
01120 inline void addCol(int i) {
01121 if ((colChanged_[i]&1)==0) {
01122 colChanged_[i] |= 1;
01123 nextColsToDo_[numberNextColsToDo_++] = i;
01124 }
01125 }
01127 inline bool colProhibited(int i) const {
01128 return (colChanged_[i]&2)!=0;
01129 }
01136 inline bool colProhibited2(int i) const {
01137 if (!anyProhibited_)
01138 return false;
01139 else
01140 return (colChanged_[i]&2)!=0;
01141 }
01143 inline void setColProhibited(int i) {
01144 colChanged_[i] |= 2;
01145 }
01151 inline bool colUsed(int i) const {
01152 return (colChanged_[i]&4)!=0;
01153 }
01155 inline void setColUsed(int i) {
01156 colChanged_[i] |= 4;
01157 }
01159 inline void unsetColUsed(int i) {
01160 colChanged_[i] &= ~4;;
01161 }
01162
01168 void initRowsToDo () ;
01169
01175 int stepRowsToDo () ;
01176
01178 inline int numberRowsToDo()
01179 { return (numberRowsToDo_) ; }
01180
01182 inline bool rowChanged(int i) const {
01183 return (rowChanged_[i]&1)!=0;
01184 }
01186 inline void unsetRowChanged(int i) {
01187 rowChanged_[i] &= ~1;;
01188 }
01190 inline void setRowChanged(int i) {
01191 rowChanged_[i] |= 1;
01192 }
01194 inline void addRow(int i) {
01195 if ((rowChanged_[i]&1)==0) {
01196 rowChanged_[i] |= 1;
01197 nextRowsToDo_[numberNextRowsToDo_++] = i;
01198 }
01199 }
01201 inline bool rowProhibited(int i) const {
01202 return (rowChanged_[i]&2)!=0;
01203 }
01210 inline bool rowProhibited2(int i) const {
01211 if (!anyProhibited_)
01212 return false;
01213 else
01214 return (rowChanged_[i]&2)!=0;
01215 }
01217 inline void setRowProhibited(int i) {
01218 rowChanged_[i] |= 2;
01219 }
01225 inline bool rowUsed(int i) const {
01226 return (rowChanged_[i]&4)!=0;
01227 }
01229 inline void setRowUsed(int i) {
01230 rowChanged_[i] |= 4;
01231 }
01233 inline void unsetRowUsed(int i) {
01234 rowChanged_[i] &= ~4;;
01235 }
01236
01237
01239 inline bool anyProhibited() const
01240 { return anyProhibited_;}
01242 inline void setAnyProhibited(bool val = true)
01243 { anyProhibited_ = val ; }
01245
01246 };
01247
01272 class CoinPostsolveMatrix : public CoinPrePostsolveMatrix
01273 {
01274 public:
01275
01282 CoinPostsolveMatrix(int ncols_alloc, int nrows_alloc,
01283 CoinBigIndex nelems_alloc) ;
01284
01285
01290 CoinPostsolveMatrix(ClpSimplex * si,
01291
01292 int ncols0,
01293 int nrows0,
01294 CoinBigIndex nelems0,
01295
01296 double maxmin_,
01297
01298
01299 double *sol,
01300 double *acts,
01301
01302 unsigned char *colstat,
01303 unsigned char *rowstat);
01304
01309 CoinPostsolveMatrix(OsiSolverInterface * si,
01310
01311 int ncols0,
01312 int nrows0,
01313 CoinBigIndex nelems0,
01314
01315 double maxmin_,
01316
01317
01318 double *sol,
01319 double *acts,
01320
01321 unsigned char *colstat,
01322 unsigned char *rowstat);
01323
01334 void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ;
01335
01337 ~CoinPostsolveMatrix();
01338
01347
01349 CoinBigIndex free_list_;
01351 int maxlink_;
01356 CoinBigIndex *link_;
01357
01359
01367 char *cdone_;
01368 char *rdone_;
01370
01372 void check_nbasic();
01373
01374 };
01375
01376
01377 #define PRESOLVEFINITE(n) (-PRESOLVE_INF < (n) && (n) < PRESOLVE_INF)
01378
01385
01390 void presolve_make_memlists(CoinBigIndex *starts, int *lengths,
01391 presolvehlink *link, int n);
01392
01400 bool presolve_expand_major(CoinBigIndex *majstrts, double *majels,
01401 int *minndxs, int *majlens,
01402 presolvehlink *majlinks, int nmaj, int k) ;
01403
01409 inline bool presolve_expand_col(CoinBigIndex *mcstrt, double *colels,
01410 int *hrow, int *hincol,
01411 presolvehlink *clink, int ncols, int colx)
01412 { return presolve_expand_major(mcstrt,colels,
01413 hrow,hincol,clink,ncols,colx) ; }
01414
01420 inline bool presolve_expand_row(CoinBigIndex *mrstrt, double *rowels,
01421 int *hcol, int *hinrow,
01422 presolvehlink *rlink, int nrows, int rowx)
01423 { return presolve_expand_major(mrstrt,rowels,
01424 hcol,hinrow,rlink,nrows,rowx) ; }
01425
01426
01435 CoinBigIndex presolve_find_minor(int tgt, CoinBigIndex ks, CoinBigIndex ke,
01436 const int *minndxs);
01437
01444 inline CoinBigIndex presolve_find_row(int row, CoinBigIndex kcs,
01445 CoinBigIndex kce, const int *hrow)
01446 { return presolve_find_minor(row,kcs,kce,hrow) ; }
01447
01454 inline CoinBigIndex presolve_find_col(int col, CoinBigIndex krs,
01455 CoinBigIndex kre, const int *hcol)
01456 { return presolve_find_minor(col,krs,kre,hcol) ; }
01457
01458
01467 CoinBigIndex presolve_find_minor1(int tgt, CoinBigIndex ks, CoinBigIndex ke,
01468 const int *minndxs);
01469
01476 inline CoinBigIndex presolve_find_row1(int row, CoinBigIndex kcs,
01477 CoinBigIndex kce, const int *hrow)
01478 { return presolve_find_minor1(row,kcs,kce,hrow) ; }
01479
01486 inline CoinBigIndex presolve_find_col1(int col, CoinBigIndex krs,
01487 CoinBigIndex kre, const int *hcol)
01488 { return presolve_find_minor1(col,krs,kre,hcol) ; }
01489
01498 CoinBigIndex presolve_find_minor2(int tgt, CoinBigIndex ks, int majlen,
01499 const int *minndxs,
01500 const CoinBigIndex *majlinks) ;
01501
01509 inline CoinBigIndex presolve_find_row2(int row, CoinBigIndex kcs, int collen,
01510 const int *hrow,
01511 const CoinBigIndex *clinks)
01512 { return presolve_find_minor2(row,kcs,collen,hrow,clinks) ; }
01513
01522 CoinBigIndex presolve_find_minor3(int tgt, CoinBigIndex ks, int majlen,
01523 const int *minndxs,
01524 const CoinBigIndex *majlinks) ;
01525
01533 inline CoinBigIndex presolve_find_row3(int row, CoinBigIndex kcs, int collen,
01534 const int *hrow,
01535 const CoinBigIndex *clinks)
01536 { return presolve_find_minor3(row,kcs,collen,hrow,clinks) ; }
01537
01547 void presolve_delete_from_major(int majndx, int minndx,
01548 const CoinBigIndex *majstrts,
01549 int *majlens, int *minndxs, double *els) ;
01550
01551 void presolve_delete_many_from_major(int majndx, char * marked,
01552 const CoinBigIndex *majstrts,
01553 int *majlens, int *minndxs, double *els) ;
01554
01565 inline void presolve_delete_from_col(int row, int col,
01566 const CoinBigIndex *mcstrt,
01567 int *hincol, int *hrow, double *colels)
01568 { presolve_delete_from_major(col,row,mcstrt,hincol,hrow,colels) ; }
01569
01580 inline void presolve_delete_from_row(int row, int col,
01581 const CoinBigIndex *mrstrt,
01582 int *hinrow, int *hcol, double *rowels)
01583 { presolve_delete_from_major(row,col,mrstrt,hinrow,hcol,rowels) ; }
01584
01595 void presolve_delete_from_major2 (int majndx, int minndx,
01596 CoinBigIndex *majstrts, int *majlens,
01597 int *minndxs, double *els, int *majlinks,
01598 CoinBigIndex *free_listp) ;
01599
01610 inline void presolve_delete_from_col2(int row, int col, CoinBigIndex *mcstrt,
01611 int *hincol, int *hrow,
01612 double *colels, int *clinks,
01613 CoinBigIndex *free_listp)
01614 { presolve_delete_from_major2(col,row,mcstrt,hincol,hrow,colels,clinks,
01615 free_listp) ; }
01616
01618
01624
01636 double *presolve_dupmajor(const double *elems, const int *indices,
01637 int length, CoinBigIndex offset, int tgt = -1);
01638
01640
01641
01642 #endif