Changeset 49


Ignore:
Timestamp:
Nov 4, 2002 10:29:34 PM (17 years ago)
Author:
ladanyi
Message:

everything compiles

Location:
branches/devel-1
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/Makefile

    r22 r49  
    3232
    3333clean:
    34         rm -rf Junk
    35         @rm -rf $(DEPDIR)
    36         @rm -rf $(TARGETDIR)
     34        @rm -rf Junk
     35        @rm -rf $(UNAME)
     36        @rm -rf dep
  • branches/devel-1/PresolveDoubleton.cpp

    r45 r49  
    417417  double *acts  = prob->acts_;
    418418  double * sol = prob->sol_;
    419   unsigned char * colstat = prob->colstat_;
     419  //  unsigned char * colstat = prob->colstat_;
    420420
    421421
  • branches/devel-1/PresolveDual.cpp

    r45 r49  
    3333  double *cup   = prob->cup_;
    3434
    35   double *rowels        = prob->rowels_;
    36   int *hcol             = prob->hcol_;
    37   CoinBigIndex *mrstrt          = prob->mrstrt_;
    38   int *hinrow           = prob->hinrow_;
     35  //  double *rowels    = prob->rowels_;
     36  //  int *hcol         = prob->hcol_;
     37  //  CoinBigIndex *mrstrt              = prob->mrstrt_;
     38  //  int *hinrow               = prob->hinrow_;
    3939  int nrows             = prob->nrows_;
    4040
  • branches/devel-1/PresolveDupcol.cpp

    r45 r49  
    9292  int nrows             = prob->nrows_;
    9393
    94   double *rlo   = prob->rlo_;
    95   double *rup   = prob->rup_;
     94  //  double *rlo       = prob->rlo_;
     95  //  double *rup       = prob->rup_;
    9696
    9797  double *dcost = prob->cost_;
     
    498498
    499499    if (nfinite > 1) {
    500       double l_j = f->thislo;
     500       //      double l_j = f->thislo;
    501501      double u_j = f->thisup;
    502502      double l_k = f->lastlo;
     
    567567                                               const PresolveAction *next)
    568568{
    569   double *colels        = prob->colels_;
     569   //  double *colels   = prob->colels_;
    570570  int *hrow             = prob->hrow_;
    571   CoinBigIndex *mcstrt          = prob->mcstrt_;
    572   int *hincol           = prob->hincol_;
     571  //  CoinBigIndex *mcstrt              = prob->mcstrt_;
     572  //  int *hincol               = prob->hincol_;
    573573  int ncols             = prob->ncols_;
    574574
    575   double *clo   = prob->clo_;
    576   double *cup   = prob->cup_;
     575  //  double *clo       = prob->clo_;
     576  //  double *cup       = prob->cup_;
    577577
    578578  double *rowels        = prob->rowels_;
     
    585585  double *rup   = prob->rup_;
    586586
    587   const char *integerType = prob->integerType_;
    588 
    589   double maxmin = prob->maxmin_;
     587  //  const char *integerType = prob->integerType_;
     588
     589  //  double maxmin     = prob->maxmin_;
    590590
    591591  action *actions       = new action [nrows];
     
    627627      CoinBigIndex krs = mrstrt[ithis];
    628628      CoinBigIndex kre = krs + hinrow[ithis];
    629       int ishift = mrstrt[ilast];
     629      //      int ishift = mrstrt[ilast];
    630630      if (hinrow[ithis] == hinrow[ilast]) {
    631631        int ishift = mrstrt[ilast] - krs;
  • branches/devel-1/PresolveEmpty.cpp

    r45 r49  
    2020  CoinBigIndex *mcstrt          = prob->mcstrt_;
    2121  int *hincol           = prob->hincol_;
    22   int *hcol             = prob->hcol_;
     22  //  int *hcol         = prob->hcol_;
    2323
    2424  // We know we are not going to need row copy again
     
    134134{
    135135  const int *hincol     = prob->hincol_;
    136   const double *clo     = prob->clo_;
    137   const double *cup     = prob->cup_;
     136  //  const double *clo = prob->clo_;
     137  //  const double *cup = prob->cup_;
    138138  int ncols             = prob->ncols_;
    139139  int i;
     
    169169
    170170  int ncols             = prob->ncols_;
    171   CoinBigIndex nelems           = prob->nelems_;
     171  //  CoinBigIndex nelems               = prob->nelems_;
    172172
    173173  CoinBigIndex *mcstrt  = prob->mcstrt_;
    174174  int *hincol   = prob->hincol_;
    175   int *hrow     = prob->hrow_;
     175  //  int *hrow = prob->hrow_;
    176176
    177177  double *clo   = prob->clo_;
  • branches/devel-1/PresolveFixed.cpp

    r45 r49  
    3838  CoinBigIndex *mrstrt          = prob->mrstrt_;
    3939  int *hinrow           = prob->hinrow_;
    40   int nrows             = prob->nrows_;
    41 
    42   double *clo   = prob->clo_;
    43   double *cup   = prob->cup_;
     40  //  int nrows         = prob->nrows_;
     41
     42  double *clo   = prob->clo_;
     43  //  double *cup       = prob->cup_;
    4444  double *rlo   = prob->rlo_;
    4545  double *rup   = prob->rup_;
    4646  double *acts  = prob->acts_;
    4747
    48   double *dcost = prob->cost_;
     48  //  double *dcost     = prob->cost_;
    4949
    5050  presolvehlink *clink = prob->clink_;
     
    156156  int *hincol           = prob->hincol_;
    157157  int *link             = prob->link_;
    158   int ncols             = prob->ncols_;
     158  //  int ncols         = prob->ncols_;
    159159  CoinBigIndex free_list                = prob->free_list_;
    160160
     
    172172
    173173  unsigned char *colstat        = prob->colstat_;
    174   unsigned char *rowstat        = prob->rowstat_;
     174  //  unsigned char *rowstat    = prob->rowstat_;
    175175
    176176  const double maxmin   = prob->maxmin_;
    177177
    178178  char *cdone   = prob->cdone_;
    179   char *rdone   = prob->rdone_;
     179  //  char *rdone       = prob->rdone_;
    180180
    181181  for (const action *f = &actions[nactions-1]; actions<=f; f--) {
     
    327327{
    328328  const action *const actions = actions_;
    329   const int nactions    = nactions_;
     329  //  const int nactions        = nactions_;
    330330  const bool fix_to_lower       = fix_to_lower_;
    331331
  • branches/devel-1/PresolveForcing.cpp

    r45 r49  
    149149                               double *maxupp, double *maxdownp)
    150150{
    151   int jcol;
     151   //  int jcol;
    152152  double iclb, icub;
    153153
     
    219219  const double *rup     = prob->rup_;
    220220
    221   const char *integerType = prob->integerType_;
     221  //  const char *integerType = prob->integerType_;
    222222
    223223  const double tol      = ZTOLDP;
     
    385385  const int *link               = prob->link_;
    386386
    387   CoinBigIndex free_list = prob->free_list_;
     387  //  CoinBigIndex free_list = prob->free_list_;
    388388
    389389  double *clo   = prob->clo_;
  • branches/devel-1/PresolveImpliedFree.cpp

    r45 r49  
    6060  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    6161  int *hinrow   = prob->hinrow_;
    62   const int nrows       = prob->nrows_;
     62  //  const int nrows   = prob->nrows_;
    6363
    6464  /*const*/ double *rlo = prob->rlo_;
     
    7474  const double tol = prob->feasibilityTolerance_;
    7575
    76   int nbounds = 0;
     76  //  int nbounds = 0;
    7777
    7878  action *actions       = new action [ncols];
     
    378378  double *rowduals = prob->rowduals_;
    379379
    380   const double ztoldj   = prob->ztoldj_;
    381   const double ztolzb   = prob->ztolzb_;
     380  //  const double ztoldj       = prob->ztoldj_;
     381  //  const double ztolzb       = prob->ztolzb_;
    382382
    383383  const double maxmin   = prob->maxmin_;
     
    441441    {
    442442      double act = 0.0;
    443       double coeff;
     443      double coeff = 0.0;
    444444
    445445      for (int k = 0; k<ninrow; k++)
  • branches/devel-1/PresolveMatrix.cpp

    r45 r49  
    721721  // here by reserving much more than the amount of space I probably need.
    722722  // If this guess is wrong, check_free_list may be called.
    723   int bufsize = 2*nelems0;
     723  //  int bufsize = 2*nelems0;
    724724
    725725  memset(cdone_, -1, ncols0_);
  • branches/devel-1/PresolvePsdebug.cpp

    r29 r49  
    1010
    1111
    12 static const double *lookup_by_col(const int *mcstrt, const int *hrow,
    13                             const int *hincol,
    14                             const int *hinrow, const double *colels,
    15                             int row, int col)
     12static inline const double *
     13lookup_by_col(const int *mcstrt, const int *hrow,
     14              const int *hincol, const int *hinrow, const double *colels,
     15              int row, int col)
    1616{
    1717  int kcs = mcstrt[col];
     
    3030}
    3131
    32 static void no_dups(const char *done,
    33              const int *mcstrt, const int *hrow, const int *hincol, int ncols)
     32static inline void
     33no_dups(const char *done,
     34        const int *mcstrt, const int *hrow, const int *hincol, int ncols)
    3435{
    3536#if     DEBUG_PRESOLVE
     
    186187
    187188
    188 static void a_ok(PostsolveMatrix *prob)
     189static inline void a_ok(PostsolveMatrix *prob)
    189190{
    190191#if 0
  • branches/devel-1/PresolveSingleton.cpp

    r45 r49  
    4040  const CoinBigIndex *mrstrt    = prob->mrstrt_;
    4141  int *hinrow           = prob->hinrow_;
    42   int nrows             = prob->nrows_;
     42  //  int nrows         = prob->nrows_;
    4343
    4444  double *rlo           = prob->rlo_;
     
    4747  // If rowstat exists then all do
    4848  unsigned char *rowstat        = prob->rowstat_;
    49   double *acts  = prob->acts_;
     49  //  double *acts      = prob->acts_;
    5050  double * sol = prob->sol_;
    51   unsigned char * colstat = prob->colstat_;
    52 
    53   const char *integerType = prob->integerType_;
     51  //  unsigned char * colstat = prob->colstat_;
     52
     53  //  const char *integerType = prob->integerType_;
    5454
    5555  const double ztolzb   = prob->ztolzb_;
     
    7777      double up = rup[irow];
    7878      double acoeff = fabs(coeff);
    79       const bool singleton_col = (hincol[jcol] == 1);
     79      //      const bool singleton_col = (hincol[jcol] == 1);
    8080
    8181      if (acoeff < ZTOLDP)
     
    229229  int *hincol           = prob->hincol_;
    230230  int *link             = prob->link_;
    231   int ncols             = prob->ncols_;
     231  //  int ncols         = prob->ncols_;
    232232
    233233  double *clo           = prob->clo_;
     
    244244
    245245  unsigned char *colstat                = prob->colstat_;
    246   unsigned char *rowstat                = prob->rowstat_;
    247 
    248   char *cdone           = prob->cdone_;
     246  //  unsigned char *rowstat            = prob->rowstat_;
     247
     248  //  char *cdone               = prob->cdone_;
    249249  char *rdone           = prob->rdone_;
    250250  CoinBigIndex free_list                = prob->free_list_;
  • branches/devel-1/PresolveSubst.cpp

    r45 r49  
    152152  CoinBigIndex krsx = mrstrt[irowx];
    153153  CoinBigIndex krex = krsx + hinrow[irowx];
    154   const int maxk = mrstrt[nrows];       // (22)
     154  //  const int maxk = mrstrt[nrows];   // (22)
    155155
    156156  // if irowx is very long, the searching gets very slow,
     
    507507
    508508  // DEBUGGING
    509   int nt = 0;
     509  //  int nt = 0;
    510510  int ngood = 0;
    511511  int nsubst = 0;
     
    756756              int irow = hrow[k];
    757757              CoinBigIndex krs = mrstrt[irow];
    758               CoinBigIndex kre = krs + hinrow[irow];
     758              //              CoinBigIndex kre = krs + hinrow[irow];
    759759
    760760              prob->addRow(irow);
     
    830830            if (hincol[jcoly] != 2) {
    831831              CoinBigIndex krs = mrstrt[rowy];
    832               CoinBigIndex kre = krs + hinrow[rowy];
     832              //              CoinBigIndex kre = krs + hinrow[rowy];
    833833              CoinSort_2(hcol+krs,hcol+krs+hinrow[rowy],rowels+krs);
    834834              //ekk_sort2(hcol+krs,  rowels+krs,  hinrow[rowy]);
     
    898898                {
    899899                  CoinBigIndex krs = mrstrt[rowy];
    900                   CoinBigIndex kre = krs + hinrow[rowy];
     900                  //              CoinBigIndex kre = krs + hinrow[rowy];
    901901                  int niny = hinrow[rowy];
    902902                 
    903903                  CoinBigIndex krsx = mrstrt[rowx];
    904                   CoinBigIndex krex = krsx + hinrow[rowx];
     904                  //              CoinBigIndex krex = krsx + hinrow[rowx];
    905905                  for (CoinBigIndex ki=0; ki<niny; ++ki) {
    906906                    CoinBigIndex k = krs + ki;
     
    10551055  int *hincol           = prob->hincol_;
    10561056  int *link             = prob->link_;
    1057   int ncols             = prob->ncols_;
     1057  //  int ncols         = prob->ncols_;
    10581058
    10591059  double *clo   = prob->clo_;
     
    10761076
    10771077  const double ztolzb   = prob->ztolzb_;
    1078   const double ztoldj   = prob->ztoldj_;
     1078  //  const double ztoldj       = prob->ztoldj_;
    10791079  const double maxmin = prob->maxmin_;
    10801080
     
    12641264
    12651265    {
    1266       CoinBigIndex k;
     1266       //      CoinBigIndex k;
    12671267      double dj = maxmin*dcost[icol];
    12681268      double bounds_factor = rhsy/coeffy;
  • branches/devel-1/PresolveTighten.cpp

    r45 r49  
    7272
    7373  // NEED TO THINK MORE ABOUT INTEGER VARS
    74   const char *integerType = prob->integerType_;
     74  //  const char *integerType = prob->integerType_;
    7575
    7676  int *fixup_cols       = new int[ncols];
     
    270270  int *hincol           = prob->hincol_;
    271271  int *link             = prob->link_;
    272   int ncols             = prob->ncols_;
     272  //  int ncols         = prob->ncols_;
    273273
    274274  double *clo   = prob->clo_;
     
    278278
    279279  double *sol   = prob->sol_;
    280   double *dcost = prob->cost_;
    281   double *rcosts        = prob->rcosts_;
     280  //  double *dcost     = prob->cost_;
     281  //  double *rcosts    = prob->rcosts_;
    282282
    283283  double *acts  = prob->acts_;
    284   double *rowduals = prob->rowduals_;
    285 
    286 
    287   const double ztolzb   = prob->ztolzb_;
    288 
    289   char *cdone   = prob->cdone_;
    290   char *rdone   = prob->rdone_;
     284  //  double *rowduals = prob->rowduals_;
     285
     286
     287  //  const double ztolzb       = prob->ztolzb_;
     288
     289  //  char *cdone       = prob->cdone_;
     290  //  char *rdone       = prob->rdone_;
    291291
    292292  for (const action *f = &actions[nactions-1]; actions<=f; f--) {
    293293    int jcol = f->col;
    294     int iflag = f->direction;
     294    //    int iflag = f->direction;
    295295    int nr   = f->nrows;
    296296    const int *rows = f->rows;
     
    316316    // Each constraint has exactly one bound.
    317317    // The correction should only ever be forced to move in one direction.
    318     double orig_sol = sol[jcol];
     318    //    double orig_sol = sol[jcol];
    319319    double correction = 0.0;
    320320   
     
    364364      double coeff = colels[k];
    365365      k = link[k];
    366       double activity = acts[irow];
     366      //      double activity = acts[irow];
    367367
    368368      acts[irow] += correction * coeff;
  • branches/devel-1/PresolveUseless.cpp

    r45 r49  
    2929        int *hincol     = prob->hincol_;
    3030
    31   double *clo   = prob->clo_;
    32   double *cup   = prob->cup_;
     31        //  double *clo = prob->clo_;
     32        //  double *cup = prob->cup_;
    3333
    3434  const double *rowels  = prob->rowels_;
     
    3838  // may be written by useless constraint
    3939        int *hinrow     = prob->hinrow_;
    40   const int nrows       = prob->nrows_;
     40        //  const int nrows     = prob->nrows_;
    4141
    4242  double *rlo   = prob->rlo_;
     
    9494  int *hincol           = prob->hincol_;
    9595 
    96   double *rowduals      = prob->rowduals_;
     96  //  double *rowduals  = prob->rowduals_;
    9797  double *rowacts       = prob->acts_;
    9898  const double *sol     = prob->sol_;
     
    117117    for (CoinBigIndex k=0; k<ninrow; k++) {
    118118      int jcol = rowcols[k];
    119       CoinBigIndex kk = mcstrt[jcol];
     119      //      CoinBigIndex kk = mcstrt[jcol];
    120120
    121121      // append deleted row element to each col
  • branches/devel-1/PresolveZeros.cpp

    r45 r49  
    9999  int ncols             = prob->ncols_;
    100100
    101   int i;
     101  //  int i;
    102102  dropped_zero * zeros = new dropped_zero[ncols];
    103103
     
    114114    CoinBigIndex *mrstrt                = prob->mrstrt_;
    115115    int *hinrow         = prob->hinrow_;
    116     int nrows           = prob->nrows_;
     116    //    int nrows             = prob->nrows_;
    117117
    118118#if     PRESOLVE_SUMMARY
  • branches/devel-1/Test/Makefile

    r22 r49  
    2626
    2727clean:
    28         rm -rf Junk
    29         rm -rf dep
    30         rm -rf $(UNAME)*
     28        @rm -rf Junk
     29        @rm -rf $(UNAME)
     30        @rm -rf dep
  • branches/devel-1/include/PresolveMatrix.hpp

    r45 r49  
    3232
    3333#ifdef  DEBUG_PRESOLVE
    34 inline void     DIE(char *s)    { std::cout<<s; abort(); }
     34inline void     DIE(const char *s)      { std::cout<<s; abort(); }
    3535#else
    36   inline void   DIE(char *s)    {}
     36  inline void   DIE(const char *s)      {}
    3737#endif
    3838
     
    284284// it will if there isn't enough space to postsolve the matrix.
    285285// see the note below.
    286 static void check_free_list(int free_list)
     286static inline void check_free_list(int free_list)
    287287{
    288288  if (free_list < 0) {
Note: See TracChangeset for help on using the changeset viewer.