Changeset 145 for trunk


Ignore:
Timestamp:
Mar 25, 2003 11:04:05 AM (17 years ago)
Author:
forrest
Message:

Zeros in matrix, and minor stuff

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpPackedMatrix.cpp

    r137 r145  
    2424ClpPackedMatrix::ClpPackedMatrix ()
    2525  : ClpMatrixBase(),
    26     matrix_(NULL)
     26    matrix_(NULL),
     27    zeroElements_(false)
    2728{
    2829  setType(1);
     
    3637
    3738  matrix_ = new CoinPackedMatrix(*(rhs.matrix_));
     39  zeroElements_ = rhs.zeroElements_;
    3840 
    3941}
     
    4648
    4749  matrix_ = rhs;
     50  zeroElements_ = false;
    4851  setType(1);
    4952 
     
    5457
    5558  matrix_ = new CoinPackedMatrix(rhs);
     59  zeroElements_ = false;
    5660  setType(1);
    5761 
     
    7680    delete matrix_;
    7781    matrix_ = new CoinPackedMatrix(*(rhs.matrix_));
     82    zeroElements_ = rhs.zeroElements_;
    7883  }
    7984  return *this;
     
    571576  const int * columnLength = matrix_->getVectorLengths();
    572577  CoinBigIndex numberElements=0;
    573   for (i=0;i<numberColumns;i++) {
    574     if (columnIsBasic[i]>=0) {
    575       numberElements += columnLength[i];
     578  if (!zeroElements_) {
     579    for (i=0;i<numberColumns;i++) {
     580      if (columnIsBasic[i]>=0) {
     581        numberElements += columnLength[i];
     582      }
     583    }
     584  } else {
     585    // there are zero elements so need to look more closely
     586    const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     587    const double * elementByColumn = matrix_->getElements();
     588    for (i=0;i<numberColumns;i++) {
     589      if (columnIsBasic[i]>=0) {
     590        CoinBigIndex j;
     591        for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     592          if (elementByColumn[j])
     593            numberElements++;
     594        }
     595      }
    576596    }
    577597  }
     
    593613  int numberColumns = getNumCols();
    594614  CoinBigIndex numberElements=0;
    595   if (!rowScale) {
    596     // no scaling
    597     for (i=0;i<numberColumns;i++) {
    598       if (columnIsBasic[i]>=0) {
    599         CoinBigIndex j;
    600         for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
    601           indexRowU[numberElements]=row[j];
    602           indexColumnU[numberElements]=numberBasic;
    603           elementU[numberElements++]=elementByColumn[j];
    604         }
    605         numberBasic++;
     615  if (!zeroElements_) {
     616    if (!rowScale) {
     617      // no scaling
     618      for (i=0;i<numberColumns;i++) {
     619        if (columnIsBasic[i]>=0) {
     620          CoinBigIndex j;
     621          for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     622            indexRowU[numberElements]=row[j];
     623            indexColumnU[numberElements]=numberBasic;
     624            elementU[numberElements++]=elementByColumn[j];
     625          }
     626          numberBasic++;
     627        }
     628      }
     629    } else {
     630      // scaling
     631      const double * columnScale = model->columnScale();
     632      for (i=0;i<numberColumns;i++) {
     633        if (columnIsBasic[i]>=0) {
     634          CoinBigIndex j;
     635          double scale = columnScale[i];
     636          for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     637            int iRow = row[j];
     638            indexRowU[numberElements]=iRow;
     639            indexColumnU[numberElements]=numberBasic;
     640            elementU[numberElements++]=elementByColumn[j]*scale*rowScale[iRow];
     641          }
     642          numberBasic++;
     643        }
    606644      }
    607645    }
    608646  } else {
    609     // scaling
    610     const double * columnScale = model->columnScale();
    611     for (i=0;i<numberColumns;i++) {
    612       if (columnIsBasic[i]>=0) {
    613         CoinBigIndex j;
    614         double scale = columnScale[i];
    615         for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
    616           int iRow = row[j];
    617           indexRowU[numberElements]=iRow;
    618           indexColumnU[numberElements]=numberBasic;
    619           elementU[numberElements++]=elementByColumn[j]*scale*rowScale[iRow];
    620         }
    621         numberBasic++;
     647    // there are zero elements so need to look more closely
     648    if (!rowScale) {
     649      // no scaling
     650      for (i=0;i<numberColumns;i++) {
     651        if (columnIsBasic[i]>=0) {
     652          CoinBigIndex j;
     653          for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     654            double value = elementByColumn[j];
     655            if (value) {
     656              indexRowU[numberElements]=row[j];
     657              indexColumnU[numberElements]=numberBasic;
     658              elementU[numberElements++]=value;
     659            }
     660          }
     661          numberBasic++;
     662        }
     663      }
     664    } else {
     665      // scaling
     666      const double * columnScale = model->columnScale();
     667      for (i=0;i<numberColumns;i++) {
     668        if (columnIsBasic[i]>=0) {
     669          CoinBigIndex j;
     670          double scale = columnScale[i];
     671          for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     672            double value = elementByColumn[j];
     673            if (value) {
     674              int iRow = row[j];
     675              indexRowU[numberElements]=iRow;
     676              indexColumnU[numberElements]=numberBasic;
     677              elementU[numberElements++]=value*scale*rowScale[iRow];
     678            }
     679          }
     680          numberBasic++;
     681        }
    622682      }
    623683    }
     
    734794            int iColumn = column[j];
    735795            if (usefulColumn[iColumn]) {
    736               double value = fabs(element[j]*columnScale[iColumn]);
    737               largest = max(largest,value);
    738               smallest = min(smallest,value);
     796              double value = fabs(element[j]);
     797              // Don't bother with tiny elements
     798              if (value>1.0e-30) {
     799                value *= columnScale[iColumn];
     800                largest = max(largest,value);
     801                smallest = min(smallest,value);
     802              }
    739803            }
    740804          }
     
    760824               j<columnStart[iColumn]+columnLength[iColumn];j++) {
    761825            iRow=row[j];
    762             if(elementByColumn[j]&&usefulRow[iRow]) {
    763               double value = fabs(elementByColumn[j]*rowScale[iRow]);
     826            double value = fabs(elementByColumn[j]);
     827            // Don't bother with tiny elements
     828            if (value>1.0e-30&&usefulRow[iRow]) {
     829              value *= rowScale[iRow];
    764830              largest = max(largest,value);
    765831              smallest = min(smallest,value);
     
    926992      }
    927993      //printf("%d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     994      if (!value)
     995        zeroElements_ = true; // there are zero elements
    928996      if (value<smallest) {
    929997        numberSmall++;
     
    9641032  else if (numberSmall)
    9651033    matrix_->compress(smallest);
     1034  // If smallest >0.0 then there can't be zero elements
     1035  if (smallest>0.0)
     1036    zeroElements_=false;
    9661037  return true;
    9671038}
  • trunk/ClpSimplexDual.cpp

    r141 r145  
    23282328  // Check if looping
    23292329  int loop;
    2330   if (!givenDuals)
     2330  if (!givenDuals&&type!=2)
    23312331    loop = progress.looping();
    23322332  else
  • trunk/ClpSimplexPrimal.cpp

    r143 r145  
    452452  gutsOfSolution(rowActivityWork_, columnActivityWork_,NULL,NULL);
    453453  // Check if looping
    454   int loop = progress.looping();
     454  int loop;
     455  if (type!=2)
     456    loop = progress.looping();
     457  else
     458    loop=-1;
    455459  if (loop>=0) {
    456460    problemStatus_ = loop; //exit if in loop
  • trunk/Presolve.cpp

    r144 r145  
    257257    result =0;
    258258
     259    if (prob.status_==0&&paction_) {
     260      // Looks feasible but double check to see if anything slipped through
     261      int n             = prob.ncols_;
     262      double * lo = prob.clo_;
     263      double * up = prob.cup_;
     264      int i;
     265     
     266      for (i=0;i<n;i++) {
     267        if (up[i]<lo[i]) {
     268          if (up[i]<lo[i]-1.0e-8) {
     269            // infeasible
     270            prob.status_=1;
     271          } else {
     272            up[i]=lo[i];
     273          }
     274        }
     275      }
     276     
     277      n = prob.nrows_;
     278      lo = prob.rlo_;
     279      up = prob.rup_;
     280
     281      for (i=0;i<n;i++) {
     282        if (up[i]<lo[i]) {
     283          if (up[i]<lo[i]-1.0e-8) {
     284            // infeasible
     285            prob.status_=1;
     286          } else {
     287            up[i]=lo[i];
     288          }
     289        }
     290      }
     291    }
    259292    if (prob.status_==0&&paction_) {
    260293      // feasible
  • trunk/Test/ClpMain.cpp

    r142 r145  
    1919#include <unistd.h>
    2020#endif
    21 #define CLPVERSION "0.94.1"
     21#define CLPVERSION "0.96.1"
    2222
    2323//#include "CoinPackedMatrix.hpp"
     
    11031103              if (preSolve) {
    11041104                model2 = pinfo.presolvedModel(models[iModel],1.0e-8,false,preSolve);
    1105                 model2->checkSolution();
     1105                if (model2) {
     1106                  model2->checkSolution();
    11061107#ifdef CLP_DEBUG
    1107                 printf("%g %g (%d) %g (%d)\n"
    1108                       ,model2->objectiveValue()
    1109                       ,model2->sumDualInfeasibilities()
    1110                       ,model2->numberDualInfeasibilities()
    1111                       ,model2->sumPrimalInfeasibilities()
    1112                       ,model2->numberPrimalInfeasibilities());
     1108                  printf("%g %g (%d) %g (%d)\n"
     1109                        ,model2->objectiveValue()
     1110                        ,model2->sumDualInfeasibilities()
     1111                        ,model2->numberDualInfeasibilities()
     1112                        ,model2->sumPrimalInfeasibilities()
     1113                        ,model2->numberPrimalInfeasibilities());
    11131114#endif
    11141115#if 1
    1115                 if (type==DUALSIMPLEX) {
    1116                   int numberInfeasibilities = model2->tightenPrimalBounds();
    1117                   if (numberInfeasibilities)
    1118                     std::cout<<"** Analysis indicates model infeasible"
    1119                              <<std::endl;
     1116                  if (type==DUALSIMPLEX) {
     1117                    int numberInfeasibilities = model2->tightenPrimalBounds();
     1118                    if (numberInfeasibilities)
     1119                      std::cout<<"** Analysis indicates model infeasible"
     1120                               <<std::endl;
     1121                    model2 = models+iModel;
     1122                    preSolve=0;
     1123                  }
     1124#endif
     1125#endif
     1126#ifdef READLINE     
     1127                currentModel = model2;
     1128#endif
     1129                } else {
     1130                  std::cout<<"** Analysis indicates model infeasible"
     1131                           <<std::endl;
     1132                  model2 = models+iModel;
     1133                  preSolve=0;
    11201134                }
    1121 #endif
    1122               }
    1123 #endif
    1124 #ifdef READLINE     
    1125               currentModel = model2;
    1126 #endif
     1135              }
    11271136              if (type==DUALSIMPLEX) {
    11281137                if (doIdiot<0)
  • trunk/include/ClpPackedMatrix.hpp

    r119 r145  
    182182  /// Data
    183183  CoinPackedMatrix * matrix_;
     184  /// Zero element flag - set true if any zero elements
     185  bool zeroElements_;
    184186   //@}
    185187};
Note: See TracChangeset for help on using the changeset viewer.