Changeset 480


Ignore:
Timestamp:
Oct 18, 2004 9:43:31 AM (15 years ago)
Author:
forrest
Message:

basis handling and connection to sbb

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpFactorization.cpp

    r461 r480  
    227227        // recompute number basic
    228228        numberBasic = numberRowBasic+numberColumnBasic;
    229         numberElements = startColumnU_[numberBasic-1]
    230           +numberInColumn_[numberBasic-1];
     229        if (numberBasic)
     230          numberElements = startColumnU_[numberBasic-1]
     231            +numberInColumn_[numberBasic-1];
     232        else
     233          numberElements=0;
    231234        lengthU_ = numberElements;
    232235        //CoinFillN(indexColumnU_,numberElements,-1);
  • trunk/ClpSimplex.cpp

    r477 r480  
    397397    for (iRow=0;iRow<numberRows_;iRow++) {
    398398      int iPivot=pivotVariable_[iRow];
     399      assert (iPivot>=0);
    399400      solution_[iPivot] = 0.0;
    400401    }
     
    815816  if (!factorization_->status()) {
    816817    // put in standard form
    817     createRim(7+8+16+32);
     818    createRim(7+8+16+32,false,-1);
    818819    // do work
    819820    gutsOfSolution ( NULL,NULL);
     
    21942195}
    21952196bool
    2196 ClpSimplex::createRim(int what,bool makeRowCopy)
     2197ClpSimplex::createRim(int what,bool makeRowCopy, int startFinishOptions)
    21972198{
    21982199  bool goodMatrix=true;
    21992200  int saveLevel=handler_->logLevel();
     2201  // Arrays will be there and correct size unless what is 63
     2202  bool newArrays = (what==63);
     2203  bool initialize = (what==63);
     2204  // We may be restarting with same size
     2205  bool keepPivots=false;
     2206  if (startFinishOptions==-1) {
     2207    startFinishOptions=0;
     2208    keepPivots=true;
     2209  }
     2210  bool oldMatrix = ((startFinishOptions&4)!=0&&(whatsChanged_&1)!=0);
     2211  if (oldMatrix)
     2212    newArrays=false;
    22002213  if (problemStatus_==10) {
    22012214    handler_->setLogLevel(0); // switch off messages
     2215    if (rowArray_[0]) {
     2216      // stuff is still there
     2217      oldMatrix=true;
     2218      newArrays=false;
     2219      keepPivots=true;
     2220    }
    22022221  } else if (factorization_) {
    22032222    // match up factorization messages
     
    22062225    else
    22072226      factorization_->messageLevel(CoinMax(3,factorization_->messageLevel()));
    2208   }
    2209   bool newArrays = (what&32)!=0;
     2227    if ((startFinishOptions&2)!=0&&factorization_->numberRows()==numberRows_)
     2228      keepPivots=true;
     2229  }
    22102230  numberExtraRows_ = matrix_->generalExpanded(this,2,maximumBasic_);
    2211   if (numberExtraRows_) {
     2231  if (numberExtraRows_&&newArrays) {
    22122232    // make sure status array large enough
    22132233    assert (status_);
     
    22232243  int i;
    22242244  if ((what&1)!=0) {
    2225     delete [] lower_;
    2226     delete [] upper_;
    2227     lower_ = new double[numberColumns_+numberRows2];
    2228     upper_ = new double[numberColumns_+numberRows2];
    2229     rowLowerWork_ = lower_+numberColumns_;
    2230     columnLowerWork_ = lower_;
    2231     rowUpperWork_ = upper_+numberColumns_;
    2232     columnUpperWork_ = upper_;
    2233     memcpy(rowLowerWork_,rowLower_,numberRows_*sizeof(double));
    2234     memcpy(rowUpperWork_,rowUpper_,numberRows_*sizeof(double));
    2235     memcpy(columnLowerWork_,columnLower_,numberColumns_*sizeof(double));
    2236     memcpy(columnUpperWork_,columnUpper_,numberColumns_*sizeof(double));
     2245    if (newArrays) {
     2246      delete [] lower_;
     2247      delete [] upper_;
     2248      lower_ = new double[numberColumns_+numberRows2];
     2249      upper_ = new double[numberColumns_+numberRows2];
     2250      rowLowerWork_ = lower_+numberColumns_;
     2251      columnLowerWork_ = lower_;
     2252      rowUpperWork_ = upper_+numberColumns_;
     2253      columnUpperWork_ = upper_;
     2254    }
    22372255    // clean up any mismatches on infinity
    22382256    for (i=0;i<numberColumns_;i++) {
     2257      columnLowerWork_[i] = columnLower_[i];
    22392258      if (columnLowerWork_[i]<-1.0e30)
    22402259        columnLowerWork_[i] = -COIN_DBL_MAX;
     2260      columnUpperWork_[i] = columnUpper_[i];
    22412261      if (columnUpperWork_[i]>1.0e30)
    22422262        columnUpperWork_[i] = COIN_DBL_MAX;
     
    22442264    // clean up any mismatches on infinity
    22452265    for (i=0;i<numberRows_;i++) {
     2266      rowLowerWork_[i] = rowLower_[i];
    22462267      if (rowLowerWork_[i]<-1.0e30)
    22472268        rowLowerWork_[i] = -COIN_DBL_MAX;
     2269      rowUpperWork_[i] = rowUpper_[i];
    22482270      if (rowUpperWork_[i]>1.0e30)
    22492271        rowUpperWork_[i] = COIN_DBL_MAX;
     
    22702292    }
    22712293    // row reduced costs
    2272     if (!dj_||newArrays) {
    2273       delete [] dj_;
    2274       dj_ = new double[numberRows2+numberColumns_];
    2275       reducedCostWork_ = dj_;
    2276       rowReducedCost_ = dj_+numberColumns_;
     2294    if (!dj_||initialize) {
     2295      if (newArrays) {
     2296        delete [] dj_;
     2297        dj_ = new double[numberRows2+numberColumns_];
     2298        reducedCostWork_ = dj_;
     2299        rowReducedCost_ = dj_+numberColumns_;
     2300      }
    22772301      memcpy(reducedCostWork_,reducedCost_,numberColumns_*sizeof(double));
    22782302      memcpy(rowReducedCost_,dual_,numberRows_*sizeof(double));
    22792303    }
    2280     if (!solution_||newArrays) {
    2281       delete [] solution_;
    2282       solution_ = new double[numberRows2+numberColumns_];
    2283       columnActivityWork_ = solution_;
    2284       rowActivityWork_ = solution_+numberColumns_;
     2304    if (!solution_||initialize) {
     2305      if (newArrays) {
     2306        delete [] solution_;
     2307        solution_ = new double[numberRows2+numberColumns_];
     2308        columnActivityWork_ = solution_;
     2309        rowActivityWork_ = solution_+numberColumns_;
     2310      }
    22852311      if (status_) {
    22862312        for (i=0;i<numberColumns_;i++) {
     
    23202346      matrix_=new ClpPackedMatrix();
    23212347    int checkType=(doSanityCheck) ? 15 : 14;
     2348    if (oldMatrix)
     2349      checkType = 14;
    23222350    if (!matrix_->allElementsInRange(this,smallElement_,1.0e20,checkType)) {
    23232351      problemStatus_=4;
    23242352      goodMatrix= false;
    23252353    }
    2326     if (makeRowCopy) {
     2354    if (makeRowCopy&&!oldMatrix) {
    23272355      delete rowCopy_;
    23282356      // may return NULL if can't give row copy
     
    23462374  }
    23472375  if ((what&4)!=0) {
    2348     delete [] cost_;
    2349     // extra copy with original costs
    2350     int nTotal = numberRows2+numberColumns_;
    2351     //cost_ = new double[2*nTotal];
    2352     cost_ = new double[nTotal];
     2376    if (newArrays) {
     2377      delete [] cost_;
     2378      // extra copy with original costs
     2379      int nTotal = numberRows2+numberColumns_;
     2380      //cost_ = new double[2*nTotal];
     2381      cost_ = new double[nTotal];
     2382    }
    23532383    objectiveWork_ = cost_;
    23542384    rowObjectiveWork_ = cost_+numberColumns_;
     
    23622392  }
    23632393  // do scaling if needed
    2364   if (scalingFlag_>0&&!rowScale_&&(what&16)!=0) {
    2365     if (matrix_->scale(this))
    2366       scalingFlag_=-scalingFlag_; // not scaled after all
    2367     if (rowScale_&&automaticScale_) {
    2368       // try automatic scaling
    2369       double smallestObj=1.0e100;
    2370       double largestObj=0.0;
    2371       double largestRhs=0.0;
    2372       for (i=0;i<numberColumns_+numberRows_;i++) {
    2373         double value = fabs(cost_[i]);
    2374         if (i<numberColumns_)
    2375           value *= columnScale_[i];
    2376         if (value&&lower_[i]!=upper_[i]) {
    2377           smallestObj = CoinMin(smallestObj,value);
    2378           largestObj = CoinMax(largestObj,value);
     2394  if ((what&16)!=0) {
     2395    if (!oldMatrix) {
     2396      assert (scalingFlag_>0||!rowScale_);
     2397      delete [] rowScale_;
     2398      delete [] columnScale_;
     2399      rowScale_=NULL;
     2400      columnScale_=NULL;
     2401    }
     2402    if (scalingFlag_>0&&!rowScale_) {
     2403      if (matrix_->scale(this))
     2404        scalingFlag_=-scalingFlag_; // not scaled after all
     2405      if (rowScale_&&automaticScale_) {
     2406        // try automatic scaling
     2407        double smallestObj=1.0e100;
     2408        double largestObj=0.0;
     2409        double largestRhs=0.0;
     2410        for (i=0;i<numberColumns_+numberRows_;i++) {
     2411          double value = fabs(cost_[i]);
     2412          if (i<numberColumns_)
     2413            value *= columnScale_[i];
     2414          if (value&&lower_[i]!=upper_[i]) {
     2415            smallestObj = CoinMin(smallestObj,value);
     2416            largestObj = CoinMax(largestObj,value);
     2417          }
     2418          if (lower_[i]>0.0||upper_[i]<0.0) {
     2419            double scale;
     2420            if (i<numberColumns_)
     2421              scale = 1.0/columnScale_[i];
     2422            else
     2423              scale = rowScale_[i-numberColumns_];
     2424            //printf("%d %g %g %g %g\n",i,scale,lower_[i],upper_[i],largestRhs);
     2425            if (lower_[i]>0)
     2426              largestRhs=CoinMax(largestRhs,lower_[i]*scale);
     2427            if (upper_[i]<0.0)
     2428              largestRhs=CoinMax(largestRhs,-upper_[i]*scale);
     2429          }
    23792430        }
    2380         if (lower_[i]>0.0||upper_[i]<0.0) {
    2381           double scale;
    2382           if (i<numberColumns_)
    2383             scale = 1.0/columnScale_[i];
    2384           else
    2385             scale = rowScale_[i-numberColumns_];
    2386           //printf("%d %g %g %g %g\n",i,scale,lower_[i],upper_[i],largestRhs);
    2387           if (lower_[i]>0)
    2388             largestRhs=CoinMax(largestRhs,lower_[i]*scale);
    2389           if (upper_[i]<0.0)
    2390             largestRhs=CoinMax(largestRhs,-upper_[i]*scale);
    2391         }
    2392       }
    2393       printf("small obj %g, large %g - rhs %g\n",smallestObj,largestObj,largestRhs);
    2394       bool scalingDone=false;
    2395       // look at element range
    2396       double smallestNegative;
    2397       double largestNegative;
    2398       double smallestPositive;
    2399       double largestPositive;
    2400       matrix_->rangeOfElements(smallestNegative, largestNegative,
    2401                                smallestPositive, largestPositive);
    2402       smallestPositive = CoinMin(fabs(smallestNegative),smallestPositive);
    2403       largestPositive = CoinMax(fabs(largestNegative),largestPositive);
    2404       if (largestObj) {
    2405         double ratio = largestObj/smallestObj;
    2406         double scale=1.0;
    2407         if (ratio<1.0e8) {
    2408           // reasonable
    2409           if (smallestObj<1.0e-4) {
    2410             // may as well scale up
    2411             scalingDone=true;
    2412             scale=1.0e-3/smallestObj;
    2413           } else if (largestObj<1.0e6||(algorithm_>0&&largestObj<1.0e-4*infeasibilityCost_)) {
    2414             //done=true;
     2431        printf("small obj %g, large %g - rhs %g\n",smallestObj,largestObj,largestRhs);
     2432        bool scalingDone=false;
     2433        // look at element range
     2434        double smallestNegative;
     2435        double largestNegative;
     2436        double smallestPositive;
     2437        double largestPositive;
     2438        matrix_->rangeOfElements(smallestNegative, largestNegative,
     2439                                 smallestPositive, largestPositive);
     2440        smallestPositive = CoinMin(fabs(smallestNegative),smallestPositive);
     2441        largestPositive = CoinMax(fabs(largestNegative),largestPositive);
     2442        if (largestObj) {
     2443          double ratio = largestObj/smallestObj;
     2444          double scale=1.0;
     2445          if (ratio<1.0e8) {
     2446            // reasonable
     2447            if (smallestObj<1.0e-4) {
     2448              // may as well scale up
     2449              scalingDone=true;
     2450              scale=1.0e-3/smallestObj;
     2451            } else if (largestObj<1.0e6||(algorithm_>0&&largestObj<1.0e-4*infeasibilityCost_)) {
     2452              //done=true;
     2453            } else {
     2454              scalingDone=true;
     2455              if (algorithm_<0) {
     2456                scale = 1.0e6/largestObj;
     2457              } else {
     2458                scale = CoinMax(1.0e6,1.0e-4*infeasibilityCost_)/largestObj;
     2459              }
     2460            }
     2461          } else if (ratio<1.0e12) {
     2462            // not so good
     2463            if (smallestObj<1.0e-7) {
     2464              // may as well scale up
     2465              scalingDone=true;
     2466              scale=1.0e-6/smallestObj;
     2467            } else if (largestObj<1.0e7||(algorithm_>0&&largestObj<1.0e-3*infeasibilityCost_)) {
     2468              //done=true;
     2469            } else {
     2470              scalingDone=true;
     2471              if (algorithm_<0) {
     2472                scale = 1.0e7/largestObj;
     2473              } else {
     2474                scale = CoinMax(1.0e7,1.0e-3*infeasibilityCost_)/largestObj;
     2475              }
     2476            }
    24152477          } else {
    2416             scalingDone=true;
    2417             if (algorithm_<0) {
    2418               scale = 1.0e6/largestObj;
     2478            // Really nasty problem
     2479            if (smallestObj<1.0e-8) {
     2480              // may as well scale up
     2481              scalingDone=true;
     2482              scale=1.0e-7/smallestObj;
     2483              largestObj *= scale;
     2484            }
     2485            if (largestObj<1.0e7||(algorithm_>0&&largestObj<1.0e-3*infeasibilityCost_)) {
     2486              //done=true;
    24192487            } else {
    2420               scale = CoinMax(1.0e6,1.0e-4*infeasibilityCost_)/largestObj;
     2488              scalingDone=true;
     2489              if (algorithm_<0) {
     2490                scale = 1.0e7/largestObj;
     2491              } else {
     2492                scale = CoinMax(1.0e7,1.0e-3*infeasibilityCost_)/largestObj;
     2493              }
    24212494            }
    24222495          }
    2423         } else if (ratio<1.0e12) {
    2424           // not so good
    2425           if (smallestObj<1.0e-7) {
    2426             // may as well scale up
    2427             scalingDone=true;
    2428             scale=1.0e-6/smallestObj;
    2429           } else if (largestObj<1.0e7||(algorithm_>0&&largestObj<1.0e-3*infeasibilityCost_)) {
    2430             //done=true;
    2431           } else {
    2432             scalingDone=true;
    2433             if (algorithm_<0) {
    2434               scale = 1.0e7/largestObj;
    2435             } else {
    2436               scale = CoinMax(1.0e7,1.0e-3*infeasibilityCost_)/largestObj;
    2437             }
    2438           }
     2496          objectiveScale_=scale;
     2497        }
     2498        if (largestRhs>1.0e12) {
     2499          scalingDone=true;
     2500          rhsScale_=1.0e9/largestRhs;
     2501        } else if (largestPositive>1.0e-14*smallestPositive&&largestRhs>1.0e6) {
     2502          scalingDone=true;
     2503          rhsScale_=1.0e6/largestRhs;
    24392504        } else {
    2440           // Really nasty problem
    2441           if (smallestObj<1.0e-8) {
    2442             // may as well scale up
    2443             scalingDone=true;
    2444             scale=1.0e-7/smallestObj;
    2445             largestObj *= scale;
    2446           }
    2447           if (largestObj<1.0e7||(algorithm_>0&&largestObj<1.0e-3*infeasibilityCost_)) {
    2448             //done=true;
    2449           } else {
    2450             scalingDone=true;
    2451             if (algorithm_<0) {
    2452               scale = 1.0e7/largestObj;
    2453             } else {
    2454               scale = CoinMax(1.0e7,1.0e-3*infeasibilityCost_)/largestObj;
    2455             }
    2456           }
     2505          rhsScale_=1.0;
    24572506        }
    2458         objectiveScale_=scale;
    2459       }
    2460       if (largestRhs>1.0e12) {
    2461         scalingDone=true;
    2462         rhsScale_=1.0e9/largestRhs;
    2463       } else if (largestPositive>1.0e-14*smallestPositive&&largestRhs>1.0e6) {
    2464         scalingDone=true;
    2465         rhsScale_=1.0e6/largestRhs;
    2466       } else {
    2467         rhsScale_=1.0;
    2468       }
    2469       if (scalingDone) {
    2470         handler_->message(CLP_RIM_SCALE,messages_)
    2471           <<objectiveScale_<<rhsScale_
    2472           <<CoinMessageEol;
    2473       }
    2474     }
    2475   } else if (makeRowCopy&&(what&16)!=0&&scalingFlag_>0) {
    2476     matrix_->scaleRowCopy(this);
     2507        if (scalingDone) {
     2508          handler_->message(CLP_RIM_SCALE,messages_)
     2509            <<objectiveScale_<<rhsScale_
     2510            <<CoinMessageEol;
     2511        }
     2512      }
     2513    } else if (makeRowCopy&&scalingFlag_>0&&!oldMatrix) {
     2514      matrix_->scaleRowCopy(this);
     2515    }
    24772516  }
    24782517  if ((what&4)!=0) {
     
    25562595  // we need to treat matrix as if each element by rowScaleIn and columnScaleout??
    25572596  // maybe we need to move scales to SimplexModel for factorization?
    2558   if (((what&8)!=0&&!pivotVariable_)||newArrays) {
     2597  if (((what&8)!=0&&!pivotVariable_)||(newArrays&&!keepPivots)) {
    25592598    delete [] pivotVariable_;
    25602599    pivotVariable_=new int[numberRows2];
     2600    for (int i=0;i<numberRows2;i++)
     2601      pivotVariable_[i]=-1;
     2602  } else if (what==63&&!keepPivots) {
     2603    // just reset
    25612604    for (int i=0;i<numberRows2;i++)
    25622605      pivotVariable_[i]=-1;
     
    36133656  finish(); // get rid of arrays
    36143657  return 0;
     3658}
     3659/* Write the basis in MPS format to the specified file.
     3660   If writeValues true writes values of structurals
     3661   (and adds VALUES to end of NAME card)
     3662   
     3663   Row and column names may be null.
     3664   formatType is
     3665   <ul>
     3666   <li> 0 - normal
     3667   <li> 1 - extra accuracy
     3668   <li> 2 - IEEE hex (later)
     3669   </ul>
     3670   
     3671   Returns non-zero on I/O error
     3672*/
     3673int
     3674ClpSimplex::writeBasis(const char *filename,
     3675                            bool writeValues,
     3676                            int formatType) const
     3677{
     3678  return ((const ClpSimplexOther *) this)->writeBasis(filename,writeValues,
     3679                                         formatType);
     3680}
     3681// Read a basis from the given filename
     3682int
     3683ClpSimplex::readBasis(const char *filename)
     3684{
     3685  return ((ClpSimplexOther *) this)->readBasis(filename);
    36153686}
    36163687#include "ClpSimplexNonlinear.hpp"
     
    54135484  // put in standard form (and make row copy)
    54145485  // create modifiable copies of model rim and do optional scaling
    5415   bool goodMatrix=createRim(7+8+16+32,true);
     5486  bool goodMatrix=createRim(7+8+16+32,true,startFinishOptions);
    54165487
    54175488  if (goodMatrix) {
     
    54665537        if (!numberThrownOut) {
    54675538          // solution will be done again - skip if absolutely sure
    5468           if ((specialOptions_&512)==0)
     5539          if ((specialOptions_&512)==0) {
    54695540            numberThrownOut = gutsOfSolution(  NULL,NULL,
    54705541                                               ifValuesPass!=0);
     5542          } else {
     5543            // make sure not optimal at once
     5544            numberPrimalInfeasibilities_=1;
     5545          }
    54715546        } else {
    54725547          matrix_->rhsOffset(this,true); // redo rhs offset
     
    55075582  // Get rid of some arrays and empty factorization
    55085583  int getRidOfData=1;
    5509   if ((startFinishOptions&1)!=0) {
     5584  if ((startFinishOptions&1)!=0||problemStatus_==10) {
    55105585    getRidOfData=0; // Keep stuff
    55115586    // mark all as current
     
    61606235    wholeModel->rowCopy_=NULL;
    61616236  }
     6237  whatsChanged_=0;
    61626238  assert (wholeModel->matrix_);
    61636239  wholeModel->matrix_ = wholeModel->matrix_->subsetClone(numberRows_,whichRow,
     
    61816257    mapping[iRow+numberColumns_] = iRow+numberColumns;
    61826258  // Redo costs and bounds of whole model
    6183   wholeModel->createRim(5,false);
     6259  wholeModel->createRim(1+4,false);
    61846260  lower_ = wholeModel->lower_;
    61856261  wholeModel->lower_ = new double [numberTotal];
  • trunk/ClpSimplexDual.cpp

    r478 r480  
    16491649    changeCost=0.0;
    16501650    // put back original bounds and then check
    1651     createRim(3);
     1651    createRim(1);
    16521652    int iSequence;
    16531653    // bounds will get bigger - just look at ones at bounds
  • trunk/ClpSimplexNonlinear.cpp

    r469 r480  
    165165  if (problemStatus_==1) {
    166166    infeasibilityCost_=0.0;
    167     createRim(7);
     167    createRim(1+4);
    168168    nonLinearCost_->checkInfeasibilities(0.0);
    169169    sumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();
  • trunk/ClpSimplexOther.cpp

    r399 r480  
    1111#include "CoinPackedMatrix.hpp"
    1212#include "CoinIndexedVector.hpp"
     13#include "CoinMpsIO.hpp"
    1314#include "ClpMessage.hpp"
    1415#include <cfloat>
     
    353354  }
    354355}
     356/* Write the basis in MPS format to the specified file.
     357   If writeValues true writes values of structurals
     358   (and adds VALUES to end of NAME card)
     359   
     360   Row and column names may be null.
     361   formatType is
     362   <ul>
     363   <li> 0 - normal
     364   <li> 1 - extra accuracy
     365   <li> 2 - IEEE hex (later)
     366   </ul>
     367   
     368   Returns non-zero on I/O error
     369
     370   This is based on code contributed by Thorsten Koch
     371*/
     372int
     373ClpSimplexOther::writeBasis(const char *filename,
     374                            bool writeValues,
     375                            int formatType) const
     376{
     377  formatType=CoinMax(0,formatType);
     378  formatType=CoinMin(2,formatType);
     379  if (!writeValues)
     380    formatType=0;
     381  // See if INTEL if IEEE
     382  if (formatType==2) {
     383    // test intel here and add 1 if not intel
     384    double value=1.0;
     385    char x[8];
     386    memcpy(x,&value,8);
     387    if (x[0]==63) {
     388      formatType ++; // not intel
     389    } else {
     390      assert (x[0]==0);
     391    }
     392  }
     393 
     394  char number[20];
     395  FILE * fp = fopen(filename,"w");
     396  if (!fp)
     397    return -1;
     398   
     399  // NAME card
     400
     401  if (strcmp(strParam_[ClpProbName].c_str(),"")==0) {
     402    fprintf(fp, "NAME          BLANK      ");
     403  } else {
     404    fprintf(fp, "NAME          %s       ",strParam_[ClpProbName].c_str());
     405  }
     406  if (formatType>=2)
     407    fprintf(fp,"IEEE");
     408  else if (writeValues)
     409    fprintf(fp,"VALUES");
     410  // finish off name
     411  fprintf(fp,"\n");
     412  int iRow=0;
     413  for(int iColumn =0; iColumn < numberColumns_; iColumn++) {
     414    bool printit=false;
     415    if( getColumnStatus(iColumn) == ClpSimplex::basic) {
     416      printit=true;
     417      // Find non basic row
     418      for(; iRow < numberRows_; iRow++) {
     419        if (getRowStatus(iRow) != ClpSimplex::basic)
     420          break;
     421      }
     422      if (lengthNames_) {
     423        if (iRow!=numberRows_) {
     424          fprintf(fp, " %s %-8s       %s",
     425                  getRowStatus(iRow) == ClpSimplex::atUpperBound ? "XU" : "XL",
     426                  columnNames_[iColumn].c_str(),
     427                  rowNames_[iRow].c_str());
     428          iRow++;
     429        } else {
     430          // Allow for too many basics!
     431          fprintf(fp, " BS %-8s       ",
     432                  columnNames_[iColumn].c_str());
     433          // Dummy row name if values
     434          if (writeValues)
     435            fprintf(fp,"      _dummy_");
     436        }
     437      } else {
     438        // no names
     439        if (iRow!=numberRows_) {
     440          fprintf(fp, " %s C%7.7d     R%7.7d",
     441                  getRowStatus(iRow) == ClpSimplex::atUpperBound ? "XU" : "XL",
     442                  iColumn,iRow);
     443          iRow++;
     444        } else {
     445          // Allow for too many basics!
     446          fprintf(fp, " BS C%7.7d",iColumn);
     447          // Dummy row name if values
     448          if (writeValues)
     449            fprintf(fp,"      _dummy_");
     450        }
     451      }
     452    } else  {
     453      if( getColumnStatus(iColumn) == ClpSimplex::atUpperBound) {
     454        printit=true;
     455        if (lengthNames_)
     456          fprintf(fp, " UL %s", columnNames_[iColumn].c_str());
     457        else
     458          fprintf(fp, " UL C%7.7d", iColumn);
     459        // Dummy row name if values
     460        if (writeValues)
     461          fprintf(fp,"      _dummy_");
     462      }
     463    }
     464    if (printit&&writeValues) {
     465      // add value
     466      CoinConvertDouble(formatType,columnActivity_[iColumn],number);
     467      fprintf(fp,"     %s",number);
     468    }
     469    if (printit)
     470      fprintf(fp,"\n");
     471  }
     472  fprintf(fp, "ENDATA\n");
     473  fclose(fp);
     474  return 0;
     475}
     476// Read a basis from the given filename
     477int
     478ClpSimplexOther::readBasis(const char *fileName)
     479{
     480  int status=0;
     481  bool canOpen=false;
     482  if (!strcmp(fileName,"-")||!strcmp(fileName,"stdin")) {
     483    // stdin
     484    canOpen=true;
     485  } else {
     486    FILE *fp=fopen(fileName,"r");
     487    if (fp) {
     488      // can open - lets go for it
     489      fclose(fp);
     490      canOpen=true;
     491    } else {
     492      handler_->message(CLP_UNABLE_OPEN,messages_)
     493        <<fileName<<CoinMessageEol;
     494      return -1;
     495    }
     496  }
     497  CoinMpsIO m;
     498  m.passInMessageHandler(handler_);
     499  bool savePrefix =m.messageHandler()->prefix();
     500  m.messageHandler()->setPrefix(handler_->prefix());
     501  status=m.readBasis(fileName,"",columnActivity_,status_+numberColumns_,
     502                     status_,
     503                     columnNames_,numberColumns_,
     504                     rowNames_,numberRows_);
     505  m.messageHandler()->setPrefix(savePrefix);
     506  if (status>=0) {
     507    if (!status) {
     508      // set values
     509      int iColumn,iRow;
     510      for (iRow=0;iRow<numberRows_;iRow++) {
     511        if (getRowStatus(iRow)==atLowerBound)
     512          rowActivity_[iRow]=rowLower_[iRow];
     513        else if (getRowStatus(iRow)==atUpperBound)
     514          rowActivity_[iRow]=rowUpper_[iRow];
     515      }
     516      for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     517        if (getColumnStatus(iColumn)==atLowerBound)
     518          columnActivity_[iColumn]=columnLower_[iColumn];
     519        else if (getColumnStatus(iColumn)==atUpperBound)
     520          columnActivity_[iColumn]=columnUpper_[iColumn];
     521      }
     522    } else {
     523      memset(rowActivity_,0,numberRows_*sizeof(double));
     524      matrix_->times(-1.0,columnActivity_,rowActivity_);
     525    }
     526  } else {
     527    // errors
     528    handler_->message(CLP_IMPORT_ERRORS,messages_)
     529      <<status<<fileName<<CoinMessageEol;
     530  }
     531  return status;
     532}
  • trunk/ClpSimplexPrimal.cpp

    r472 r480  
    413413  if (problemStatus_==1) {
    414414    infeasibilityCost_=0.0;
    415     createRim(7);
     415    createRim(1+4);
    416416    nonLinearCost_->checkInfeasibilities(0.0);
    417417    sumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();
     
    497497      memcpy(saveColumn1,reducedCostWork_,numberColumns_*sizeof(double));
    498498      memcpy(saveColumn2,columnActivityWork_,numberColumns_*sizeof(double));
    499       createRim(7);
     499      createRim(1+4);
    500500      gutsOfSolution(NULL,NULL);
    501501      printf("xxx %d old obj %g, recomputed %g, sum primal inf %g\n",
     
    20022002    return false;
    20032003  // put back original bounds and costs
    2004   createRim(7);
     2004  createRim(1+4);
    20052005  sanityCheck();
    20062006  // unflag
  • trunk/ClpSolve.cpp

    r469 r480  
    7070    16 - switch off interrupt handling
    7171    32 - do not try and make plus minus one matrix
     72    64 - do not use sprint even if problem looks good
    7273 */
    7374int
     
    122123  int doSprint=0;
    123124  int doSlp=0;
     125  int primalStartup=1;
    124126  if (method!=ClpSolve::useDual&&method!=ClpSolve::useBarrier
    125127      &&method!=ClpSolve::useBarrierNoCross) {
     
    183185      if (options.getExtraInfo(1)>0)
    184186        doSlp = options.getExtraInfo(1);
     187      break;
     188    case 11:
     189      doIdiot=0;
     190      doCrash=0;
     191      doSprint=0;
     192      primalStartup=0;
    185193      break;
    186194    default:
     
    667675      model2->nonlinearSLP(doSlp,1.0e-5);
    668676    }
    669     model2->primal(1);
     677    model2->primal(primalStartup);
    670678    time2 = CoinCpuTime();
    671679    timeCore = time2-timeX;
  • trunk/Test/ClpMain.cpp

    r475 r480  
    1414#include "CoinPragma.hpp"
    1515#include "CoinHelperFunctions.hpp"
    16 #define CLPVERSION "1.00.00"
     16// History since 1.0 at end
     17#define CLPVERSION "1.00.01"
    1718
    1819#include "CoinMpsIO.hpp"
     
    7778  MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
    7879  TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,
    79   REALLY_SCALE,
     80  REALLY_SCALE,BASISIN,BASISOUT,
    8081
    8182  INVALID=1000
     
    909910    std::string importFile ="";
    910911    std::string exportFile ="default.mps";
     912    std::string importBasisFile ="";
     913    int basisHasValues=0;
     914    std::string exportBasisFile ="default.bas";
    911915    std::string saveFile ="default.prob";
    912916    std::string restoreFile ="default.prob";
     
    948952
    949953       );
     954    parameters[numberParameters++]=
     955      ClpItem("basisI!n","Import basis from bas file",
     956              BASISIN);
     957    parameters[numberParameters-1].setLonghelp
     958      (
     959       "This will read an MPS format basis file from the given file name.  It will use the default\
     960 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     961 is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
     962 files 'xxxxxxxx.gz'.."
     963       );
     964    parameters[numberParameters-1].setStringValue(importBasisFile);
     965    parameters[numberParameters++]=
     966      ClpItem("basisO!ut","Export basis as bas file",
     967              BASISOUT);
     968    parameters[numberParameters-1].setLonghelp
     969      (
     970       "This will write an MPS format basis file to the given file name.  It will use the default\
     971 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     972 is initialized to 'default.bas'."
     973       );
     974    parameters[numberParameters-1].setStringValue(exportBasisFile);
    950975    parameters[numberParameters++]=
    951976      ClpItem("biasLU","Whether factorization biased towards U",
     
    12671292 to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\
    12681293 otherwise odd values gives one value per line, even two.  Values 1,2 give normal format, 3,4\
    1269  gives greater precision, while 5,6 give IEEE values."
     1294 gives greater precision, while 5,6 give IEEE values.  When used for exporting a basis 1 does not save \
     1295values, 2 saves values, 3 with greater accuracy and 4 in IEEE."
    12701296       );
    12711297    parameters[numberParameters-1].setIntValue(outputFormat);
     
    18881914                  }
    18891915                }
     1916                if (basisHasValues==-1)
     1917                  solveOptions.setSpecialOption(1,11); // switch off values
    18901918              } else if (method==ClpSolve::useBarrier||method==ClpSolve::useBarrierNoCross) {
    18911919                int barrierOptions = choleskyType;
     
    18991927              }
    19001928              model2->initialSolve(solveOptions);
     1929              basisHasValues=1;
    19011930            } else {
    19021931              std::cout<<"** Current model not valid"<<std::endl;
     
    20292058            break;
    20302059          case EXPORT:
    2031             {
     2060            if (goodModels[iModel]) {
    20322061              // get next field
    20332062              field = getString(argc,argv);
     
    21622191                time1=time2;
    21632192              }
     2193            } else {
     2194              std::cout<<"** Current model not valid"<<std::endl;
     2195            }
     2196            break;
     2197          case BASISIN:
     2198            if (goodModels[iModel]) {
     2199              // get next field
     2200              field = getString(argc,argv);
     2201              if (field=="$") {
     2202                field = parameters[iParam].stringValue();
     2203              } else if (field=="EOL") {
     2204                parameters[iParam].printString();
     2205                break;
     2206              } else {
     2207                parameters[iParam].setStringValue(field);
     2208              }
     2209              std::string fileName;
     2210              bool canOpen=false;
     2211              if (field=="-") {
     2212                // stdin
     2213                canOpen=true;
     2214                fileName = "-";
     2215              } else {
     2216                if (field[0]=='/'||field[0]=='\\') {
     2217                  fileName = field;
     2218                } else if (field[0]=='~') {
     2219                  char * environ = getenv("HOME");
     2220                  if (environ) {
     2221                    std::string home(environ);
     2222                    field=field.erase(0,1);
     2223                    fileName = home+field;
     2224                  } else {
     2225                    fileName=field;
     2226                  }
     2227                } else {
     2228                  fileName = directory+field;
     2229                }
     2230                FILE *fp=fopen(fileName.c_str(),"r");
     2231                if (fp) {
     2232                  // can open - lets go for it
     2233                  fclose(fp);
     2234                  canOpen=true;
     2235                } else {
     2236                  std::cout<<"Unable to open file "<<fileName<<std::endl;
     2237                }
     2238              }
     2239              if (canOpen) {
     2240                int values = models[iModel].readBasis(fileName.c_str());
     2241                if (values==0)
     2242                  basisHasValues=-1;
     2243                else
     2244                  basisHasValues=1;
     2245              }
     2246            } else {
     2247              std::cout<<"** Current model not valid"<<std::endl;
     2248            }
     2249            break;
     2250          case BASISOUT:
     2251            if (goodModels[iModel]) {
     2252              // get next field
     2253              field = getString(argc,argv);
     2254              if (field=="$") {
     2255                field = parameters[iParam].stringValue();
     2256              } else if (field=="EOL") {
     2257                parameters[iParam].printString();
     2258                break;
     2259              } else {
     2260                parameters[iParam].setStringValue(field);
     2261              }
     2262              std::string fileName;
     2263              bool canOpen=false;
     2264              if (field[0]=='/'||field[0]=='\\') {
     2265                fileName = field;
     2266              } else if (field[0]=='~') {
     2267                char * environ = getenv("HOME");
     2268                if (environ) {
     2269                  std::string home(environ);
     2270                  field=field.erase(0,1);
     2271                  fileName = home+field;
     2272                } else {
     2273                  fileName=field;
     2274                }
     2275              } else {
     2276                fileName = directory+field;
     2277              }
     2278              FILE *fp=fopen(fileName.c_str(),"w");
     2279              if (fp) {
     2280                // can open - lets go for it
     2281                fclose(fp);
     2282                canOpen=true;
     2283              } else {
     2284                std::cout<<"Unable to open file "<<fileName<<std::endl;
     2285              }
     2286              if (canOpen) {
     2287                ClpSimplex * model2 = models+iModel;
     2288                model2->writeBasis(fileName.c_str(),outputFormat>1,outputFormat-2);
     2289                time2 = CoinCpuTime();
     2290                totalTime += time2-time1;
     2291                time1=time2;
     2292              }
     2293            } else {
     2294              std::cout<<"** Current model not valid"<<std::endl;
    21642295            }
    21652296            break;
     
    26042735  return 0;
    26052736}   
     2737/*
     2738  Version 1.00.00 October 13 2004.
     2739  1.00.01 October 18.  Added basis handline helped/prodded by Thorsten Koch.
     2740  Also modifications to make faster with sbb (I hope I haven't broken anything).
     2741 */
  • trunk/Test/unitTest.cpp

    r473 r480  
    660660    ClpSimplex model;
    661661    model.loadProblem(M, collb, colub, obj, rowlb, rowub);
    662     model.dual(0,1); // keep factorization
     662    model.dual(0,1); // keep factorization 
    663663   
    664664    //check that the tableau matches wolsey (B-1 A)
     
    675675      printf("\n");
    676676    }
    677     // See if can re-use factorization
    678     model.primal(0,3); // keep factorization
     677    // See if can re-use factorization AND arrays
     678    model.primal(0,3+4); // keep factorization
    679679    // And do by column
    680680    printf("B-1 A by column\n");
     
    688688    }
    689689    free(binvA);
    690     model.dual(0,2); // use factorization
     690    model.setColUpper(1,2.0);
     691    model.dual(0,2+4); // use factorization and arrays
    691692    model.dual(0,2); // hopefully will not use factorization
    692693  }
  • trunk/include/ClpSimplex.hpp

    r472 r480  
    231231                  double * valueIncrease, int * sequenceIncrease,
    232232                  double * valueDecrease, int * sequenceDecrease);
     233  /** Write the basis in MPS format to the specified file.
     234      If writeValues true writes values of structurals
     235      (and adds VALUES to end of NAME card)
     236     
     237      Row and column names may be null.
     238      formatType is
     239      <ul>
     240      <li> 0 - normal
     241      <li> 1 - extra accuracy
     242      <li> 2 - IEEE hex (later)
     243      </ul>
     244     
     245      Returns non-zero on I/O error
     246  */
     247  int writeBasis(const char *filename,
     248                 bool writeValues=false,
     249                 int formatType=0) const;
     250  /** Read a basis from the given filename,
     251      returns -1 on file error, 0 if no values, 1 if values */
     252  int readBasis(const char *filename);
    233253  /// Passes in factorization
    234254  void setFactorization( ClpFactorization & factorization);
     
    624644      16 also moves solutions etc in to work arrays
    625645      On 16 returns false if problem "bad" i.e. matrix or bounds bad
    626   */
    627   bool createRim(int what,bool makeRowCopy=false);
     646      If startFinishOptions is -1 then called by user in getSolution
     647      so do arrays but keep pivotVariable_
     648  */
     649  bool createRim(int what,bool makeRowCopy=false,int startFinishOptions=0);
    628650  /** releases above arrays and does solution scaling out.  May also
    629651      get rid of factorization data -
  • trunk/include/ClpSimplexOther.hpp

    r389 r480  
    6767  void checkPrimalRatios(CoinIndexedVector * rowArray,
    6868                         int direction);
     69    /** Write the basis in MPS format to the specified file.
     70        If writeValues true writes values of structurals
     71        (and adds VALUES to end of NAME card)
     72
     73        Row and column names may be null.
     74        formatType is
     75        <ul>
     76          <li> 0 - normal
     77          <li> 1 - extra accuracy
     78          <li> 2 - IEEE hex (later)
     79        </ul>
     80
     81        Returns non-zero on I/O error
     82    */
     83    int writeBasis(const char *filename,
     84                 bool writeValues=false,
     85                 int formatType=0) const;
     86    /// Read a basis from the given filename
     87    int readBasis(const char *filename);
    6988  //@}
    7089};
  • trunk/include/ClpSolve.hpp

    r461 r480  
    7676                   9 - do allslack or sprint
    7777                   10 - slp before
     78                   11 - no nothing and primal(0)
    7879      2 - interrupt handling - 0 yes, 1 no (for threadsafe)
    7980      3 - whether to make +- 1matrix - 0 yes, 1 no
Note: See TracChangeset for help on using the changeset viewer.