Changeset 26 for branches


Ignore:
Timestamp:
Sep 23, 2002 9:40:07 AM (17 years ago)
Author:
forrest
Message:

Taking out dependence on CoinWarmStartBasis?

Location:
branches/devel-1
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/ClpSimplex.cpp

    r23 r26  
    1616#include "ClpPackedMatrix.hpp"
    1717#include "CoinIndexedVector.hpp"
    18 #include "CoinWarmStartBasis.hpp"
    1918#include "ClpDualRowDantzig.hpp"
    2019#include "ClpDualRowSteepest.hpp"
     
    238237      for (iRow=0;iRow<numberOut;iRow++) {
    239238        int iColumn=sort[iRow];
    240         setColumnStatus(iColumn,ClpSimplex::superBasic);
     239        setColumnStatus(iColumn,superBasic);
    241240
    242241      }
     
    526525      if (status_) {
    527526        for (iRow=0;iRow<numberRows_;iRow++) {
    528           if (getRowStatus(iRow)!=ClpSimplex::basic) {
     527          if (getRowStatus(iRow)!=basic) {
    529528            allSlack=false;
    530529            break;
     
    538537          switch(getRowStatus(iRow)) {
    539538           
    540           case ClpSimplex::basic:
     539          case basic:
    541540            numberBasic++;
    542541            break;
    543           case ClpSimplex::isFree:
     542          case isFree:
    544543            assert(rowLowerWork_[iRow]<-largeValue_);
    545544            assert(rowUpperWork_[iRow]>largeValue_);
    546545            rowActivityWork_[iRow]=0.0;
    547546            break;
    548           case ClpSimplex::atUpperBound:
     547          case atUpperBound:
    549548            rowActivityWork_[iRow]=rowUpperWork_[iRow];
    550549            if (rowActivityWork_[iRow]>largeValue_) {
    551550              if (rowLowerWork_[iRow]>-largeValue_) {
    552551                rowActivityWork_[iRow]=rowLowerWork_[iRow];
    553                 setRowStatus(iRow,ClpSimplex::atLowerBound);
     552                setRowStatus(iRow,atLowerBound);
    554553              } else {
    555554                // say free
    556                 setRowStatus(iRow,ClpSimplex::isFree);
     555                setRowStatus(iRow,isFree);
    557556                rowActivityWork_[iRow]=0.0;
    558557              }
    559558            }
    560559            break;
    561           case ClpSimplex::atLowerBound:
     560          case atLowerBound:
    562561            rowActivityWork_[iRow]=rowLowerWork_[iRow];
    563562            if (rowActivityWork_[iRow]<-largeValue_) {
    564563              if (rowUpperWork_[iRow]<largeValue_) {
    565564                rowActivityWork_[iRow]=rowUpperWork_[iRow];
    566                 setRowStatus(iRow,ClpSimplex::atUpperBound);
     565                setRowStatus(iRow,atUpperBound);
    567566              } else {
    568567                // say free
    569                 setRowStatus(iRow,ClpSimplex::isFree);
     568                setRowStatus(iRow,isFree);
    570569                rowActivityWork_[iRow]=0.0;
    571570              }
    572571            }
    573572            break;
    574           case ClpSimplex::superBasic:
     573          case superBasic:
    575574            abort();
    576575            break;
     
    581580          switch(getColumnStatus(iColumn)) {
    582581           
    583           case ClpSimplex::basic:
     582          case basic:
    584583            if (numberBasic==numberRows_) {
    585584              // take out of basis
     
    588587                    columnUpperWork_[iColumn]-columnActivityWork_[iColumn]) {
    589588                  columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
    590                   setColumnStatus(iColumn,ClpSimplex::atLowerBound);
     589                  setColumnStatus(iColumn,atLowerBound);
    591590                } else {
    592591                  columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    593                   setColumnStatus(iColumn,ClpSimplex::atUpperBound);
     592                  setColumnStatus(iColumn,atUpperBound);
    594593                }
    595594              } else if (columnUpperWork_[iColumn]<largeValue_) {
    596595                columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    597                 setColumnStatus(iColumn,ClpSimplex::atUpperBound);
     596                setColumnStatus(iColumn,atUpperBound);
    598597              } else {
    599598                columnActivityWork_[iColumn]=0.0;
    600                 setColumnStatus(iColumn,ClpSimplex::isFree);
     599                setColumnStatus(iColumn,isFree);
    601600              }
    602601            } else {
     
    604603            }
    605604            break;
    606           case ClpSimplex::isFree:
     605          case isFree:
    607606            columnActivityWork_[iColumn]=0.0;
    608607            break;
    609           case ClpSimplex::atUpperBound:
     608          case atUpperBound:
    610609            columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    611610            if (columnActivityWork_[iColumn]>largeValue_) {
    612611              assert(columnLowerWork_[iColumn]>-largeValue_);
    613612              columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
    614               setColumnStatus(iColumn,ClpSimplex::atLowerBound);
     613              setColumnStatus(iColumn,atLowerBound);
    615614            }
    616615            break;
    617           case ClpSimplex::atLowerBound:
     616          case atLowerBound:
    618617            columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
    619618            if (columnActivityWork_[iColumn]<-largeValue_) {
    620619              assert(columnUpperWork_[iColumn]<largeValue_);
    621620              columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    622               setColumnStatus(iColumn,ClpSimplex::atUpperBound);
     621              setColumnStatus(iColumn,atUpperBound);
    623622            }
    624623            break;
    625           case ClpSimplex::superBasic:
     624          case superBasic:
    626625            abort();
    627626            break;
     
    634633        // changed to put free variables in basis
    635634        if (!status_) {
    636           status_ = new unsigned char [numberColumns_+numberRows_];
    637           memset(status_,0,(numberColumns_+numberRows_)*sizeof(char));
     635          createStatus();
    638636        }
    639637        for (iRow=0;iRow<numberRows_;iRow++) {
     
    642640          if (lower>-largeValue_||upper<largeValue_) {
    643641            if (fabs(lower)<=fabs(upper)) {
    644               setRowStatus(iRow,ClpSimplex::atLowerBound);
     642              setRowStatus(iRow,atLowerBound);
    645643              rowActivityWork_[iRow]=lower;
    646644            } else {
    647               setRowStatus(iRow,ClpSimplex::atUpperBound);
     645              setRowStatus(iRow,atUpperBound);
    648646              rowActivityWork_[iRow]=upper;
    649647            }
    650648          } else {
    651             setRowStatus(iRow,ClpSimplex::isFree);
     649            setRowStatus(iRow,isFree);
    652650            rowActivityWork_[iRow]=0.0;
    653651          }
    654652#ifdef TESTFREE
    655           setRowStatus(iRow,ClpSimplex::basic);
     653          setRowStatus(iRow,basic);
    656654          numberBasic++;
    657655#endif
     
    663661          if (lower>-big_bound||upper<big_bound) {
    664662            if (fabs(lower)<=fabs(upper)) {
    665               setColumnStatus(iColumn,ClpSimplex::atLowerBound);
     663              setColumnStatus(iColumn,atLowerBound);
    666664              columnActivityWork_[iColumn]=lower;
    667665            } else {
    668               setColumnStatus(iColumn,ClpSimplex::atUpperBound);
     666              setColumnStatus(iColumn,atUpperBound);
    669667              columnActivityWork_[iColumn]=upper;
    670668            }
     
    672670#ifndef TESTFREE
    673671            numberBasic++;
    674             setColumnStatus(iColumn,ClpSimplex::basic);
     672            setColumnStatus(iColumn,basic);
    675673#else
    676             setColumnStatus(iColumn,ClpSimplex::isFree);
     674            setColumnStatus(iColumn,isFree);
    677675#endif
    678676            columnActivityWork_[iColumn]=0.0;
     
    683681          // might as well do all slack basis
    684682          for (iRow=0;iRow<numberRows_;iRow++) {
    685             setRowStatus(iRow,ClpSimplex::basic);
     683            setRowStatus(iRow,basic);
    686684          }
    687685        }
     
    696694        int numberBasic=0;
    697695        for (iRow=0;iRow<numberRows_;iRow++) {
    698           if (getRowStatus(iRow)==ClpSimplex::basic)
     696          if (getRowStatus(iRow)==basic)
    699697            numberBasic++;
    700698          else
    701             setRowStatus(iRow,ClpSimplex::superBasic);
     699            setRowStatus(iRow,superBasic);
    702700        }
    703701        totalSlacks=numberBasic;
    704702        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    705           if (getColumnStatus(iColumn)==ClpSimplex::basic) {
     703          if (getColumnStatus(iColumn)==basic) {
    706704            if (numberBasic==numberRows_)
    707705              // take out of basis
    708               setColumnStatus(iColumn,ClpSimplex::superBasic);
     706              setColumnStatus(iColumn,superBasic);
    709707            else
    710708              numberBasic++;
    711709          } else {
    712             setColumnStatus(iColumn,ClpSimplex::superBasic);
     710            setColumnStatus(iColumn,superBasic);
    713711          }
    714712        }
     
    717715        int numberBasic=0;
    718716        if (!status_) {
    719           status_ = new unsigned char [numberColumns_+numberRows_];
    720           memset(status_,0,(numberColumns_+numberRows_)*sizeof(char));
     717          createStatus();
    721718        }
    722719        for (iRow=0;iRow<numberRows_;iRow++) {
    723           setRowStatus(iRow,ClpSimplex::basic);
     720          setRowStatus(iRow,basic);
    724721          numberBasic++;
    725722        }
    726723        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    727           setColumnStatus(iColumn,ClpSimplex::superBasic);
     724          setColumnStatus(iColumn,superBasic);
    728725        }
    729726      }
     
    740737    int numberBasic=0;
    741738    for (i=0;i<numberRows_;i++) {
    742       if (getRowStatus(i) == ClpSimplex::basic) {
     739      if (getRowStatus(i) == basic) {
    743740        rowIsBasic[i]=1;
    744741        numberBasic++;
     
    748745    }
    749746    for (i=0;i<numberColumns_;i++) {
    750       if (getColumnStatus(i) == ClpSimplex::basic) {
     747      if (getColumnStatus(i) == basic) {
    751748        columnIsBasic[i]=1;
    752749        numberBasic++;
     
    769766      // do pivot information
    770767      for (i=0;i<numberRows_;i++) {
    771         if (getRowStatus(i) == ClpSimplex::basic) {
     768        if (getRowStatus(i) == basic) {
    772769          pivotVariable_[rowIsBasic[i]]=i+numberColumns_;
    773770        }
    774771      }
    775772      for (i=0;i<numberColumns_;i++) {
    776         if (getColumnStatus(i) == ClpSimplex::basic) {
     773        if (getColumnStatus(i) == basic) {
    777774          pivotVariable_[columnIsBasic[i]]=i;
    778775        }
     
    784781      }
    785782      for (i=0;i<numberRows_;i++) {
    786         if (getRowStatus(i) == ClpSimplex::basic) {
     783        if (getRowStatus(i) == basic) {
    787784          int iPivot = rowIsBasic[i];
    788785          if (iPivot>=0)
     
    791788      }
    792789      for (i=0;i<numberColumns_;i++) {
    793         if (getColumnStatus(i) == ClpSimplex::basic) {
     790        if (getColumnStatus(i) == basic) {
    794791          int iPivot = columnIsBasic[i];
    795792          if (iPivot>=0)
     
    803800        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    804801          if (getColumnStatus(iColumn)==
    805               ClpSimplex::basic) {
     802              basic) {
    806803            // take out
    807804            if (!valuesPass) {
     
    811808              if (lower>-largeValue_||upper<largeValue_) {
    812809                if (fabs(value-lower)<fabs(value-upper)) {
    813                   setColumnStatus(iColumn,ClpSimplex::atLowerBound);
     810                  setColumnStatus(iColumn,atLowerBound);
    814811                  columnActivityWork_[iColumn]=lower;
    815812                } else {
    816                   setColumnStatus(iColumn,ClpSimplex::atUpperBound);
     813                  setColumnStatus(iColumn,atUpperBound);
    817814                  columnActivityWork_[iColumn]=upper;
    818815                }
    819816              } else {
    820                 setColumnStatus(iColumn,ClpSimplex::isFree);
     817                setColumnStatus(iColumn,isFree);
    821818              }
    822819            } else {
    823               setColumnStatus(iColumn,ClpSimplex::superBasic);
     820              setColumnStatus(iColumn,superBasic);
    824821            }
    825822          }
     
    834831            } else {
    835832              // put back structural
    836               setColumnStatus(iSequence,ClpSimplex::basic);
     833              setColumnStatus(iSequence,basic);
    837834            }
    838835          } else {
    839836            // put in slack
    840             setRowStatus(iRow,ClpSimplex::basic);
     837            setRowStatus(iRow,basic);
    841838          }
    842839        }
     
    857854    int numberSlacks=0;
    858855    for (iRow=0;iRow<numberRows_;iRow++) {
    859       if (getRowStatus(iRow) == ClpSimplex::basic)
     856      if (getRowStatus(iRow) == basic)
    860857        numberSlacks++;
    861858    }
     
    888885    <<dualOut_<<dualIn_<<alpha_
    889886    <<CoinMessageEol;
    890   if (getStatus(sequenceIn_)==ClpSimplex::isFree) {
     887  if (getStatus(sequenceIn_)==isFree) {
    891888    handler_->message(CLP_SIMPLEX_FREEIN,messages_)
    892889      <<sequenceIn_
     
    907904    if (sequenceIn_!=sequenceOut_) {
    908905      // variable becoming basic
    909       setStatus(sequenceIn_,ClpSimplex::basic);
     906      setStatus(sequenceIn_,basic);
    910907      if (algorithm_<0) {
    911908        value = upperIn_+dualOut_;
     
    916913    } else {
    917914      value=lowerIn_;
    918       setStatus(sequenceIn_, ClpSimplex::atLowerBound);
     915      setStatus(sequenceIn_, atLowerBound);
    919916    }
    920917  } else {
     
    922919    if (sequenceIn_!=sequenceOut_) {
    923920      // variable becoming basic
    924       setStatus(sequenceIn_,ClpSimplex::basic);
     921      setStatus(sequenceIn_,basic);
    925922      if (algorithm_<0) {
    926923        value = lowerIn_+dualOut_;
     
    931928    } else {
    932929      value=upperIn_;
    933       setStatus(sequenceIn_, ClpSimplex::atUpperBound);
     930      setStatus(sequenceIn_, atUpperBound);
    934931    }
    935932  }
     
    942939  // outgoing
    943940  if (sequenceIn_!=sequenceOut_) {
    944     assert( getStatus(sequenceOut_)== ClpSimplex::basic);
     941    assert( getStatus(sequenceOut_)== basic);
    945942    if (upper_[sequenceOut_]-lower_[sequenceOut_]<1.0e-12)
    946943      progressFlag_ |= 1; // making real progress
     
    948945      if (directionOut_>0) {
    949946        value = lowerOut_;
    950         setStatus(sequenceOut_,ClpSimplex::atLowerBound);
     947        setStatus(sequenceOut_,atLowerBound);
    951948        dj_[sequenceOut_]=theta_;
    952949      } else {
    953950        value = upperOut_;
    954         setStatus(sequenceOut_,ClpSimplex::atUpperBound);
     951        setStatus(sequenceOut_,atUpperBound);
    955952        dj_[sequenceOut_]=-theta_;
    956953      }
     
    969966      // may not be exactly at bound and bounds may have changed
    970967      if (value<=lowerValue+primalTolerance_) {
    971         setStatus(sequenceOut_,ClpSimplex::atLowerBound);
     968        setStatus(sequenceOut_,atLowerBound);
    972969      } else if (value>=upperValue-primalTolerance_) {
    973         setStatus(sequenceOut_,ClpSimplex::atUpperBound);
     970        setStatus(sequenceOut_,atUpperBound);
    974971      } else {
    975972        printf("*** variable wandered off bound %g %g %g!\n",
    976973               lowerValue,value,upperValue);
    977974        if (value-lowerValue<=upperValue-value) {
    978           setStatus(sequenceOut_,ClpSimplex::atLowerBound);
     975          setStatus(sequenceOut_,atLowerBound);
    979976          value=lowerValue;
    980977        } else {
    981           setStatus(sequenceOut_,ClpSimplex::atUpperBound);
     978          setStatus(sequenceOut_,atUpperBound);
    982979          value=upperValue;
    983980        }
     
    14771474
    14781475  for (iRow=0;iRow<numberRows_;iRow++) {
    1479     if (getRowStatus(iRow) != ClpSimplex::basic) {
     1476    if (getRowStatus(iRow) != basic) {
    14801477      // not basic
    14811478      double value = rowReducedCost_[iRow];
     
    14951492              sumOfRelaxedDualInfeasibilities_ += value-relaxedTolerance;
    14961493            numberDualInfeasibilities_ ++;
    1497             if (getRowStatus(iRow) != ClpSimplex::isFree)
     1494            if (getRowStatus(iRow) != isFree)
    14981495              numberDualInfeasibilitiesWithoutFree_ ++;
    14991496            // maybe we can make feasible by increasing tolerance
     
    15221519              sumOfRelaxedDualInfeasibilities_ += value-relaxedTolerance;
    15231520            numberDualInfeasibilities_ ++;
    1524             if (getRowStatus(iRow) != ClpSimplex::isFree)
     1521            if (getRowStatus(iRow) != isFree)
    15251522              numberDualInfeasibilitiesWithoutFree_ ++;
    15261523            // maybe we can make feasible by increasing tolerance
     
    15351532  solution = columnActivityWork_;
    15361533  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1537     if (getColumnStatus(iColumn) != ClpSimplex::basic) {
     1534    if (getColumnStatus(iColumn) != basic) {
    15381535      // not basic
    15391536      double value = reducedCostWork_[iColumn];
     
    15531550              sumOfRelaxedDualInfeasibilities_ += value-relaxedTolerance;
    15541551            numberDualInfeasibilities_ ++;
    1555             if (getColumnStatus(iColumn) != ClpSimplex::isFree)
     1552            if (getColumnStatus(iColumn) != isFree)
    15561553              numberDualInfeasibilitiesWithoutFree_ ++;
    15571554            // maybe we can make feasible by increasing tolerance
     
    15801577              sumOfRelaxedDualInfeasibilities_ += value-relaxedTolerance;
    15811578            numberDualInfeasibilities_ ++;
    1582             if (getColumnStatus(iColumn) != ClpSimplex::isFree)
     1579            if (getColumnStatus(iColumn) != isFree)
    15831580              numberDualInfeasibilitiesWithoutFree_ ++;
    15841581            // maybe we can make feasible by increasing tolerance
     
    18711868  }
    18721869}
    1873 // Sets up basis
    1874 void
    1875 ClpSimplex::setBasis ( const CoinWarmStartBasis & basis)
    1876 {
    1877   // transform basis to status arrays
    1878   int iRow,iColumn;
    1879   if (!status_) {
    1880     /*
    1881       get status arrays
    1882       CoinWarmStartBasis would seem to have overheads and we will need
    1883       extra bits anyway.
    1884     */
    1885     status_ = new unsigned char [numberColumns_+numberRows_];
    1886     memset(status_,0,(numberColumns_+numberRows_)*sizeof(char));
    1887   }
    1888   CoinWarmStartBasis basis2 = basis;
    1889   // resize if necessary
    1890   basis2.resize(numberRows_,numberColumns_);
    1891   // move status
    1892   for (iRow=0;iRow<numberRows_;iRow++) {
    1893     setRowStatus(iRow,
    1894                  (Status) basis2.getArtifStatus(iRow));
    1895   }
    1896   for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1897     setColumnStatus(iColumn,
    1898                     (Status) basis2.getStructStatus(iColumn));
    1899   }
    1900 }
    19011870// Passes in factorization
    19021871void
     
    19051874  delete factorization_;
    19061875  factorization_= new ClpFactorization(factorization);
    1907 }
    1908 // Warm start
    1909 CoinWarmStartBasis 
    1910 ClpSimplex::getBasis() const
    1911 {
    1912   int iRow,iColumn;
    1913   CoinWarmStartBasis basis;
    1914   basis.setSize(numberColumns_,numberRows_);
    1915 
    1916   if(status_) {
    1917     for (iRow=0;iRow<numberRows_;iRow++) {
    1918       basis.setArtifStatus(iRow,
    1919                            (CoinWarmStartBasis::Status) getRowStatus(iRow));
    1920     }
    1921     for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1922       basis.setStructStatus(iColumn,
    1923                        (CoinWarmStartBasis::Status) getColumnStatus(iColumn));
    1924     }
    1925   }
    1926   return basis;
    19271876}
    19281877void
     
    22412190{
    22422191  ClpModel::borrowModel(otherModel);
     2192  createStatus();
    22432193  scaling();
    22442194  ClpDualRowSteepest steep1;
     
    29582908  return true;
    29592909}
     2910// Set up status array (for OsiClp)
     2911void
     2912ClpSimplex::createStatus()
     2913{
     2914  delete [] status_;
     2915  status_ = new unsigned char [numberColumns_+numberRows_];
     2916  memset(status_,0,(numberColumns_+numberRows_)*sizeof(char));
     2917  int i;
     2918  // set column status to one nearest zero
     2919  for (i=0;i<numberColumns_;i++) {
     2920#if 0
     2921    if (columnLower_[i]>=0.0) {
     2922      setColumnStatus(i,atLowerBound);
     2923    } else if (columnUpper_[i]<=0.0) {
     2924      setColumnStatus(i,atUpperBound);
     2925    } else if (columnLower_[i]<-1.0e20&&columnUpper_[i]>1.0e20) {
     2926      // free
     2927      setColumnStatus(i,isFree);
     2928    } else if (fabs(columnLower_[i])<fabs(columnUpper_[i])) {
     2929      setColumnStatus(i,atLowerBound);
     2930    } else {
     2931      setColumnStatus(i,atUpperBound);
     2932    }
     2933#else
     2934    setColumnStatus(i,atLowerBound);
     2935#endif
     2936  }
     2937  for (i=0;i<numberRows_;i++) {
     2938    setRowStatus(i,basic);
     2939  }
     2940}
     2941/* Loads a problem (the constraints on the
     2942   rows are given by lower and upper bounds). If a pointer is 0 then the
     2943   following values are the default:
     2944   <ul>
     2945   <li> <code>colub</code>: all columns have upper bound infinity
     2946   <li> <code>collb</code>: all columns have lower bound 0
     2947   <li> <code>rowub</code>: all rows have upper bound infinity
     2948   <li> <code>rowlb</code>: all rows have lower bound -infinity
     2949   <li> <code>obj</code>: all variables have 0 objective coefficient
     2950   </ul>
     2951*/
     2952void
     2953ClpSimplex::loadProblem (  const ClpMatrixBase& matrix,
     2954                    const double* collb, const double* colub,   
     2955                    const double* obj,
     2956                    const double* rowlb, const double* rowub,
     2957                    const double * rowObjective)
     2958{
     2959  ClpModel::loadProblem(matrix, collb, colub, obj, rowlb, rowub,
     2960                        rowObjective);
     2961  createStatus();
     2962}
     2963void
     2964ClpSimplex::loadProblem (  const CoinPackedMatrix& matrix,
     2965                    const double* collb, const double* colub,   
     2966                    const double* obj,
     2967                    const double* rowlb, const double* rowub,
     2968                    const double * rowObjective)
     2969{
     2970  ClpModel::loadProblem(matrix, collb, colub, obj, rowlb, rowub,
     2971                        rowObjective);
     2972  createStatus();
     2973}
     2974
     2975/* Just like the other loadProblem() method except that the matrix is
     2976   given in a standard column major ordered format (without gaps). */
     2977void
     2978ClpSimplex::loadProblem (  const int numcols, const int numrows,
     2979                    const int* start, const int* index,
     2980                    const double* value,
     2981                    const double* collb, const double* colub,   
     2982                    const double* obj,
     2983                    const double* rowlb, const double* rowub,
     2984                    const double * rowObjective)
     2985{
     2986  ClpModel::loadProblem(numcols, numrows, start, index, value,
     2987                          collb, colub, obj, rowlb, rowub,
     2988                          rowObjective);
     2989  createStatus();
     2990}
     2991// Read an mps file from the given filename
     2992int
     2993ClpSimplex::readMps(const char *filename,
     2994            bool keepNames,
     2995            bool ignoreErrors)
     2996{
     2997  int status = ClpModel::readMps(filename,keepNames,ignoreErrors);
     2998  createStatus();
     2999  return status;
     3000}
  • branches/devel-1/ClpSimplexDual.cpp

    r23 r26  
    420420        double upperValue=upper_[iSequence];
    421421        double value=solution_[iSequence];
    422         if(getStatus(iSequence)!=ClpSimplex::basic) {
     422        if(getStatus(iSequence)!=basic) {
    423423          assert(lowerValue>-1.0e20);
    424424          assert(upperValue<1.0e20);
     
    426426        switch(getStatus(iSequence)) {
    427427         
    428         case ClpSimplex::basic:
     428        case basic:
    429429          break;
    430         case ClpSimplex::isFree:
    431         case ClpSimplex::superBasic:
     430        case isFree:
     431        case superBasic:
    432432          break;
    433         case ClpSimplex::atUpperBound:
     433        case atUpperBound:
    434434          assert (fabs(value-upperValue)<=primalTolerance_) ;
    435435          break;
    436         case ClpSimplex::atLowerBound:
     436        case atLowerBound:
    437437          assert (fabs(value-lowerValue)<=primalTolerance_) ;
    438438          break;
     
    774774        switch(status) {
    775775         
    776         case ClpSimplex::basic:
    777         case ClpSimplex::superBasic:
     776        case basic:
     777        case superBasic:
    778778          break;
    779         case ClpSimplex::isFree:
     779        case isFree:
    780780          if (fabs(value)>tolerance) {
    781781#ifdef CLP_DEBUG
     
    786786          }
    787787          break;
    788         case ClpSimplex::atUpperBound:
     788        case atUpperBound:
    789789          if (value>tolerance) {
    790790            // to lower bound (if swap)
     
    810810                  value>=-tolerance) {
    811811                movement = lower[iSequence]-upper[iSequence];
    812                 setStatus(iSequence+addSequence,ClpSimplex::atLowerBound);
     812                setStatus(iSequence+addSequence,atLowerBound);
    813813                solution[iSequence] = lower[iSequence];
    814814                changeObj += movement*cost[iSequence];
     
    819819          }
    820820          break;
    821         case ClpSimplex::atLowerBound:
     821        case atLowerBound:
    822822          if (value<-tolerance) {
    823823            // to upper bound
     
    843843                  value<=tolerance) {
    844844                movement = upper[iSequence] - lower[iSequence];
    845                 setStatus(iSequence+addSequence,ClpSimplex::atUpperBound);
     845                setStatus(iSequence+addSequence,atUpperBound);
    846846                solution[iSequence] = upper[iSequence];
    847847                changeObj += movement*cost[iSequence];
     
    952952      switch(getStatus(iSequence)) {
    953953
    954       case ClpSimplex::basic:
     954      case basic:
    955955        break;
    956       case ClpSimplex::isFree:
    957       case ClpSimplex::superBasic:
     956      case isFree:
     957      case superBasic:
    958958        break;
    959       case ClpSimplex::atUpperBound:
     959      case atUpperBound:
    960960        if (fabs(value-upperValue)>primalTolerance_)
    961961          numberInfeasibilities++;
    962962        break;
    963       case ClpSimplex::atLowerBound:
     963      case atLowerBound:
    964964        if (fabs(value-lowerValue)>primalTolerance_)
    965965          numberInfeasibilities++;
     
    975975        double newUpperValue;
    976976        Status status = getStatus(iSequence);
    977         if (status==ClpSimplex::atUpperBound||
    978             status==ClpSimplex::atLowerBound) {
     977        if (status==atUpperBound||
     978            status==atLowerBound) {
    979979          double value = solution_[iSequence];
    980980          if (value-lowerValue<=upperValue-value) {
     
    996996              setFakeBound(iSequence,ClpSimplexDual::upperFake);
    997997          }
    998           if (status==ClpSimplex::atUpperBound)
     998          if (status==atUpperBound)
    999999            solution_[iSequence] = newUpperValue;
    10001000          else
     
    10241024    for (iSequence=0;iSequence<numberRows_+numberColumns_;iSequence++) {
    10251025      Status status = getStatus(iSequence);
    1026       if (status==ClpSimplex::atUpperBound||
    1027           status==ClpSimplex::atLowerBound) {
     1026      if (status==atUpperBound||
     1027          status==atLowerBound) {
    10281028        double lowerValue=lower_[iSequence];
    10291029        double upperValue=upper_[iSequence];
     
    11841184      switch(getStatus(iSequence+addSequence)) {
    11851185         
    1186       case ClpSimplex::basic:
     1186      case basic:
    11871187        break;
    1188       case ClpSimplex::isFree:
    1189       case ClpSimplex::superBasic:
     1188      case isFree:
     1189      case superBasic:
    11901190        if (oldValue>dualTolerance_) {
    11911191          if (value<-newTolerance)
     
    12011201        }
    12021202        break;
    1203       case ClpSimplex::atUpperBound:
     1203      case atUpperBound:
    12041204#ifdef CHECK_DJ
    12051205        // For Debug so we can find out where problem is
     
    12141214        }
    12151215        break;
    1216       case ClpSimplex::atLowerBound:
     1216      case atLowerBound:
    12171217#ifdef CHECK_DJ
    12181218        // For Debug so we can find out where problem is
     
    19141914              double * original = columnArray_[0]->denseVector();
    19151915              for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1916                 if(getColumnStatus(iColumn)!= ClpSimplex::basic)
     1916                if(getColumnStatus(iColumn)!= basic)
    19171917                  ray_[iColumn] +=
    19181918                    columnActivityWork_[iColumn]-original[iColumn];
     
    20732073      switch(status) {
    20742074
    2075       case ClpSimplex::basic:
    2076       case ClpSimplex::isFree:
    2077       case ClpSimplex::superBasic:
     2075      case basic:
     2076      case isFree:
     2077      case superBasic:
    20782078        break;
    2079       case ClpSimplex::atUpperBound:
     2079      case atUpperBound:
    20802080        assert (value<=0.0);
    20812081        // to lower bound
    2082         setStatus(iSequence+addSequence,ClpSimplex::atLowerBound);
     2082        setStatus(iSequence+addSequence,atLowerBound);
    20832083        solution[iSequence] = lower[iSequence];
    20842084        break;
    2085       case ClpSimplex::atLowerBound:
     2085      case atLowerBound:
    20862086        assert (value>=0.0);
    20872087        // to upper bound
    2088         setStatus(iSequence+addSequence,ClpSimplex::atUpperBound);
     2088        setStatus(iSequence+addSequence,atUpperBound);
    20892089        solution[iSequence] = upper[iSequence];
    20902090        break;
     
    21222122    }
    21232123  }
    2124   setFakeBound(iSequence,ClpSimplex::noFake);
     2124  setFakeBound(iSequence,noFake);
    21252125}
    21262126/* As changeBounds but just changes new bounds for a single variable.
     
    21442144    if (upperValue > oldLower + dualBound_) {
    21452145      upper_[iSequence]=oldLower+dualBound_;
    2146       setFakeBound(iSequence,ClpSimplex::upperFake);
     2146      setFakeBound(iSequence,upperFake);
    21472147      modified=true;
    21482148    }
     
    21502150    if (lowerValue < oldUpper - dualBound_) {
    21512151      lower_[iSequence]=oldUpper-dualBound_;
    2152       setFakeBound(iSequence,ClpSimplex::lowerFake);
     2152      setFakeBound(iSequence,lowerFake);
    21532153      modified=true;
    21542154    }
     
    26242624    switch(getStatus(iSequence)) {
    26252625
    2626     case ClpSimplex::basic:
     2626    case basic:
    26272627      break;
    2628     case ClpSimplex::isFree:
    2629     case ClpSimplex::superBasic:
     2628    case isFree:
     2629    case superBasic:
    26302630      break;
    2631     case ClpSimplex::atUpperBound:
    2632       if (bound==ClpSimplex::upperFake||bound==ClpSimplex::bothFake)
     2631    case atUpperBound:
     2632      if (bound==upperFake||bound==bothFake)
    26332633        numberFake++;
    26342634      break;
    2635     case ClpSimplex::atLowerBound:
    2636       if (bound==ClpSimplex::lowerFake||bound==ClpSimplex::bothFake)
     2635    case atLowerBound:
     2636      if (bound==lowerFake||bound==bothFake)
    26372637        numberFake++;
    26382638      break;
  • branches/devel-1/ClpSimplexPrimal.cpp

    r23 r26  
    13981398  }
    13991399  for (;iColumn<numberRows_+numberColumns_;iColumn++) {
    1400     if (getStatus(iColumn)==ClpSimplex::superBasic) {
     1400    if (getStatus(iColumn)==superBasic) {
    14011401      // is it really super basic
    14021402      if (fabs(solution_[iColumn]-lower_[iColumn])<=primalTolerance_) {
    14031403        solution_[iColumn]=lower_[iColumn];
    1404         setStatus(iColumn,ClpSimplex::atLowerBound);
     1404        setStatus(iColumn,atLowerBound);
    14051405      } else if (fabs(solution_[iColumn]-upper_[iColumn])
    14061406                 <=primalTolerance_) {
    14071407        solution_[iColumn]=upper_[iColumn];
    1408         setStatus(iColumn,ClpSimplex::atUpperBound);
     1408        setStatus(iColumn,atUpperBound);
    14091409      } else if (lower_[iColumn]<-1.0e20&&upper_[iColumn]>1.0e20) {
    1410         setStatus(iColumn,ClpSimplex::isFree);
     1410        setStatus(iColumn,isFree);
    14111411      } else {
    14121412        break;
  • branches/devel-1/Makefile.Clp

    r22 r26  
    1818LIBSRC += ClpDualRowSteepest.cpp
    1919LIBSRC += ClpFactorization.cpp
    20 #LIBSRC += ClpMalloc.cpp
    2120LIBSRC += ClpMatrixBase.cpp
    2221LIBSRC += ClpMessage.cpp
  • branches/devel-1/Test/ClpMain.cpp

    r19 r26  
    2222//#include "CoinPackedMatrix.hpp"
    2323//#include "CoinPackedVector.hpp"
    24 #include "CoinWarmStartBasis.hpp"
    2524#include "CoinMpsIO.hpp"
    2625
     
    11561155                                                   allowImportErrors);
    11571156                if (!status||(status>0&&allowImportErrors)) {
    1158                   // I don't think there is any need for this but ..
    1159                   CoinWarmStartBasis allSlack;
    11601157                  goodModels[iModel]=true;
    1161                   models[iModel].setBasis(allSlack);
     1158                  // sets to all slack (not necessary?)
     1159                  models[iModel].createStatus();
    11621160                  time2 = cpuTime();
    11631161                  totalTime += time2-time1;
  • branches/devel-1/Test/unitTest.cpp

    r20 r26  
    2121#include "CoinPackedMatrix.hpp"
    2222#include "CoinPackedVector.hpp"
    23 #include "CoinWarmStartBasis.hpp"
     23#include "CoinHelperFunctions.hpp"
    2424
    2525#include "ClpFactorization.hpp"
     
    343343    int rowBasis1[3]={-1,-1,-1};
    344344    int colBasis1[5]={1,1,-1,-1,1};
     345    solution.loadProblem(matrix,colLower,colUpper,objective,
     346                         rowLower,rowUpper);
    345347    int i;
    346     CoinWarmStartBasis warm;
    347     warm.setSize(5,3);
     348    solution.createStatus();
    348349    for (i=0;i<3;i++) {
    349350      if (rowBasis1[i]<0) {
    350         warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
     351        solution.setRowStatus(i,ClpSimplex::atLowerBound);
    351352      } else {
    352         warm.setArtifStatus(i,CoinWarmStartBasis::basic);
     353        solution.setRowStatus(i,ClpSimplex::basic);
    353354      }
    354355    }
    355356    for (i=0;i<5;i++) {
    356357      if (colBasis1[i]<0) {
    357         warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
     358        solution.setColumnStatus(i,ClpSimplex::atLowerBound);
    358359      } else {
    359         warm.setStructStatus(i,CoinWarmStartBasis::basic);
    360       }
    361     }
    362     solution.loadProblem(matrix,colLower,colUpper,objective,
    363                          rowLower,rowUpper);
     360        solution.setColumnStatus(i,ClpSimplex::basic);
     361      }
     362    }
    364363    solution.setLogLevel(3+4+8+16+32);
    365364    solution.primal();
     365    for (i=0;i<3;i++) {
     366      if (rowBasis1[i]<0) {
     367        solution.setRowStatus(i,ClpSimplex::atLowerBound);
     368      } else {
     369        solution.setRowStatus(i,ClpSimplex::basic);
     370      }
     371    }
     372    for (i=0;i<5;i++) {
     373      if (colBasis1[i]<0) {
     374        solution.setColumnStatus(i,ClpSimplex::atLowerBound);
     375      } else {
     376        solution.setColumnStatus(i,ClpSimplex::basic);
     377      }
     378    }
    366379    // intricate stuff does not work with scaling
    367380    solution.scaling(0);
    368     solution.setBasis(warm);
    369381    assert(!solution.factorize ( ));
    370382    const double * colsol = solution.primalColumnSolution();
     
    379391    ClpSimplex solution2 = solution;
    380392    solution2.setFactorization(factorization2);
    381     solution2.setBasis(warm);
     393    solution2.createStatus();
     394    for (i=0;i<3;i++) {
     395      if (rowBasis1[i]<0) {
     396        solution2.setRowStatus(i,ClpSimplex::atLowerBound);
     397      } else {
     398        solution2.setRowStatus(i,ClpSimplex::basic);
     399      }
     400    }
     401    for (i=0;i<5;i++) {
     402      if (colBasis1[i]<0) {
     403        solution2.setColumnStatus(i,ClpSimplex::atLowerBound);
     404      } else {
     405        solution2.setColumnStatus(i,ClpSimplex::basic);
     406      }
     407    }
    382408    // intricate stuff does not work with scaling
    383409    solution2.scaling(0);
     
    506532      CoinDisjointCopyN(solution.dualRowSolution(),numberRows,rowObjective);
    507533      CoinDisjointCopyN(solution.dualColumnSolution(),numberColumns,objective);
    508       CoinWarmStartBasis basis;
    509       solution.setBasis(basis);
     534      // this sets up all slack basis
     535      solution.createStatus();
    510536      solution.dual();
    511537      CoinFillN(rowObjective,numberRows,0.0);
  • branches/devel-1/include/ClpSimplex.hpp

    r23 r26  
    1818class ClpPrimalColumnPivot;
    1919class ClpFactorization;
    20 class CoinWarmStartBasis;
    2120class CoinIndexedVector;
    2221class ClpNonLinearCost;
     
    7877  /// Destructor
    7978   ~ClpSimplex (  );
     79  // Ones below are just ClpModel with setti
     80  /** Loads a problem (the constraints on the
     81        rows are given by lower and upper bounds). If a pointer is 0 then the
     82        following values are the default:
     83        <ul>
     84          <li> <code>colub</code>: all columns have upper bound infinity
     85          <li> <code>collb</code>: all columns have lower bound 0
     86          <li> <code>rowub</code>: all rows have upper bound infinity
     87          <li> <code>rowlb</code>: all rows have lower bound -infinity
     88          <li> <code>obj</code>: all variables have 0 objective coefficient
     89        </ul>
     90    */
     91  void loadProblem (  const ClpMatrixBase& matrix,
     92                     const double* collb, const double* colub,   
     93                     const double* obj,
     94                     const double* rowlb, const double* rowub,
     95                      const double * rowObjective=NULL);
     96  void loadProblem (  const CoinPackedMatrix& matrix,
     97                     const double* collb, const double* colub,   
     98                     const double* obj,
     99                     const double* rowlb, const double* rowub,
     100                      const double * rowObjective=NULL);
     101
     102  /** Just like the other loadProblem() method except that the matrix is
     103        given in a standard column major ordered format (without gaps). */
     104  void loadProblem (  const int numcols, const int numrows,
     105                     const int* start, const int* index,
     106                     const double* value,
     107                     const double* collb, const double* colub,   
     108                     const double* obj,
     109                      const double* rowlb, const double* rowub,
     110                      const double * rowObjective=NULL);
     111  /// Read an mps file from the given filename
     112  int readMps(const char *filename,
     113              bool keepNames=false,
     114              bool ignoreErrors = false);
    80115  /** Borrow model.  This is so we dont have to copy large amounts
    81116      of data around.  It assumes a derived class wants to overwrite
     
    91126  /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
    92127  int primal(int ifValuesPass=0);
    93   /// Sets up working basis as a copy of input
    94   void setBasis( const CoinWarmStartBasis & basis);
    95128  /// Passes in factorization
    96129  void setFactorization( ClpFactorization & factorization);
     
    176209  inline int numberPrimalInfeasibilities() const
    177210          { return numberPrimalInfeasibilities_;} ;
    178   /// Warm start
    179   CoinWarmStartBasis getBasis() const;
    180211  /** Save model to file, returns 0 if success.  This is designed for
    181212      use outside algorithms so does not save iterating arrays etc.
     
    482513  inline bool flagged(int sequence) const
    483514  {return (((status_[sequence]>>6)&1)!=0);};
     515  /// See if status array exists (partly for OsiClp)
     516  inline bool statusExists() const
     517  { return (status_!=NULL);};
     518  /** Set up status array (can be used by OsiClp).
     519      Also can be used to set up all slack basis */
     520  void createStatus() ;
     521   
    484522  /// So we know when to be cautious
    485523  inline int lastBadIteration() const
Note: See TracChangeset for help on using the changeset viewer.