ClpInterior.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
/*
   Authors
 
   John Tomlin (pdco)
   John Forrest (standard predictor-corrector)
 
   Note JJF has added arrays - this takes more memory but makes
   flow easier to understand and hopefully easier to extend
 
 */
#ifndef ClpInterior_H
#define ClpInterior_H
 
#include <iostream>
#include <cfloat>
#include "ClpModel.hpp"
#include "ClpMatrixBase.hpp"
#include "ClpSolve.hpp"
#include "CoinDenseVector.hpp"
class ClpLsqr;
class ClpPdcoBase;
typedef struct {
  double atolmin;
  double r3norm;
  double LSdamp;
  double *deltay;
} Info;
 
typedef struct {
  double atolold;
  double atolnew;
  double r3ratio;
  int istop;
  int itncg;
} Outfo;
 
typedef struct {
  double gamma;
  double delta;
  int MaxIter;
  double FeaTol;
  double OptTol;
  double StepTol;
  double x0min;
  double z0min;
  double mu0;
  int LSmethod; // 1=Cholesky    2=QR    3=LSQR
  int LSproblem; // See below
  int LSQRMaxIter;
  double LSQRatol1; // Initial  atol
  double LSQRatol2; // Smallest atol (unless atol1 is smaller)
  double LSQRconlim;
  int wait;
} Options;
class Lsqr;
class ClpCholeskyBase;
// ***** END
class ClpInterior : public ClpModel {
  friend void ClpInteriorUnitTest(const std::string &mpsDir,
    const std::string &netlibDir);
 
public:
  ClpInterior();
 
  ClpInterior(const ClpInterior &);
  ClpInterior(const ClpModel &);
  ClpInterior(const ClpModel *wholeModel,
    int numberRows, const int *whichRows,
    int numberColumns, const int *whichColumns,
    bool dropNames = true, bool dropIntegers = true);
  ClpInterior &operator=(const ClpInterior &rhs);
  ~ClpInterior();
  // Ones below are just ClpModel with some changes
  void loadProblem(const ClpMatrixBase &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub,
    const double *rowObjective = NULL);
  void loadProblem(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub,
    const double *rowObjective = NULL);
 
  void loadProblem(const int numcols, const int numrows,
    const CoinBigIndex *start, const int *index,
    const double *value,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub,
    const double *rowObjective = NULL);
  void loadProblem(const int numcols, const int numrows,
    const CoinBigIndex *start, const int *index,
    const double *value, const int *length,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub,
    const double *rowObjective = NULL);
  int readMps(const char *filename,
    bool keepNames = false,
    bool ignoreErrors = false);
  void borrowModel(ClpModel &otherModel);
  void returnModel(ClpModel &otherModel);
 
  int pdco();
  // ** Temporary version
  int pdco(ClpPdcoBase *stuff, Options &options, Info &info, Outfo &outfo);
  int primalDual();
 
  inline bool primalFeasible() const
  {
    return (sumPrimalInfeasibilities_ <= 1.0e-5);
  }
  inline bool dualFeasible() const
  {
    return (sumDualInfeasibilities_ <= 1.0e-5);
  }
  inline int algorithm() const
  {
    return algorithm_;
  }
  inline void setAlgorithm(int value)
  {
    algorithm_ = value;
  }
  inline CoinWorkDouble sumDualInfeasibilities() const
  {
    return sumDualInfeasibilities_;
  }
  inline CoinWorkDouble sumPrimalInfeasibilities() const
  {
    return sumPrimalInfeasibilities_;
  }
  inline CoinWorkDouble dualObjective() const
  {
    return dualObjective_;
  }
  inline CoinWorkDouble primalObjective() const
  {
    return primalObjective_;
  }
  inline CoinWorkDouble diagonalNorm() const
  {
    return diagonalNorm_;
  }
  inline CoinWorkDouble linearPerturbation() const
  {
    return linearPerturbation_;
  }
  inline void setLinearPerturbation(CoinWorkDouble value)
  {
    linearPerturbation_ = value;
  }
  inline CoinWorkDouble projectionTolerance() const
  {
    return projectionTolerance_;
  }
  inline void setProjectionTolerance(CoinWorkDouble value)
  {
    projectionTolerance_ = value;
  }
  inline CoinWorkDouble diagonalPerturbation() const
  {
    return diagonalPerturbation_;
  }
  inline void setDiagonalPerturbation(CoinWorkDouble value)
  {
    diagonalPerturbation_ = value;
  }
  inline CoinWorkDouble gamma() const
  {
    return gamma_;
  }
  inline void setGamma(CoinWorkDouble value)
  {
    gamma_ = value;
  }
  inline CoinWorkDouble delta() const
  {
    return delta_;
  }
  inline void setDelta(CoinWorkDouble value)
  {
    delta_ = value;
  }
  inline CoinWorkDouble complementarityGap() const
  {
    return complementarityGap_;
  }
 
  inline CoinWorkDouble largestPrimalError() const
  {
    return largestPrimalError_;
  }
  inline CoinWorkDouble largestDualError() const
  {
    return largestDualError_;
  }
  inline int maximumBarrierIterations() const
  {
    return maximumBarrierIterations_;
  }
  inline void setMaximumBarrierIterations(int value)
  {
    maximumBarrierIterations_ = value;
  }
  void setCholesky(ClpCholeskyBase *cholesky);
  int numberFixed() const;
  void fixFixed(bool reallyFix = true);
  inline CoinWorkDouble *primalR() const
  {
    return primalR_;
  }
  inline CoinWorkDouble *dualR() const
  {
    return dualR_;
  }
 
protected:
  void gutsOfDelete();
  void gutsOfCopy(const ClpInterior &rhs);
  bool createWorkingData();
  void deleteWorkingData();
  bool sanityCheck();
  int housekeeping();
public:
  inline CoinWorkDouble rawObjectiveValue() const
  {
    return objectiveValue_;
  }
  inline int isColumn(int sequence) const
  {
    return sequence < numberColumns_ ? 1 : 0;
  }
  inline int sequenceWithin(int sequence) const
  {
    return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
  }
  void checkSolution();
  CoinWorkDouble quadraticDjs(CoinWorkDouble *djRegion, const CoinWorkDouble *solution,
    CoinWorkDouble scaleFactor);
 
  inline void setFixed(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 1);
  }
  inline void clearFixed(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~1);
  }
  inline bool fixed(int sequence) const
  {
    return ((status_[sequence] & 1) != 0);
  }
 
  inline void setFlagged(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 2);
  }
  inline void clearFlagged(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~2);
  }
  inline bool flagged(int sequence) const
  {
    return ((status_[sequence] & 2) != 0);
  }
 
  inline void setFixedOrFree(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 4);
  }
  inline void clearFixedOrFree(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~4);
  }
  inline bool fixedOrFree(int sequence) const
  {
    return ((status_[sequence] & 4) != 0);
  }
 
  inline void setLowerBound(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 8);
  }
  inline void clearLowerBound(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~8);
  }
  inline bool lowerBound(int sequence) const
  {
    return ((status_[sequence] & 8) != 0);
  }
 
  inline void setUpperBound(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 16);
  }
  inline void clearUpperBound(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~16);
  }
  inline bool upperBound(int sequence) const
  {
    return ((status_[sequence] & 16) != 0);
  }
 
  inline void setFakeLower(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 32);
  }
  inline void clearFakeLower(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~32);
  }
  inline bool fakeLower(int sequence) const
  {
    return ((status_[sequence] & 32) != 0);
  }
 
  inline void setFakeUpper(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 64);
  }
  inline void clearFakeUpper(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~64);
  }
  inline bool fakeUpper(int sequence) const
  {
    return ((status_[sequence] & 64) != 0);
  }
 
protected:
  CoinWorkDouble largestPrimalError_;
  CoinWorkDouble largestDualError_;
  CoinWorkDouble sumDualInfeasibilities_;
  CoinWorkDouble sumPrimalInfeasibilities_;
  CoinWorkDouble worstComplementarity_;
public:
  CoinWorkDouble xsize_;
  CoinWorkDouble zsize_;
 
protected:
  CoinWorkDouble *lower_;
  CoinWorkDouble *rowLowerWork_;
  CoinWorkDouble *columnLowerWork_;
  CoinWorkDouble *upper_;
  CoinWorkDouble *rowUpperWork_;
  CoinWorkDouble *columnUpperWork_;
  CoinWorkDouble *cost_;
 
public:
  CoinWorkDouble *rhs_;
  CoinWorkDouble *x_;
  CoinWorkDouble *y_;
  CoinWorkDouble *dj_;
 
protected:
  ClpLsqr *lsqrObject_;
  ClpPdcoBase *pdcoStuff_;
  CoinWorkDouble mu_;
  CoinWorkDouble objectiveNorm_;
  CoinWorkDouble rhsNorm_;
  CoinWorkDouble solutionNorm_;
  CoinWorkDouble dualObjective_;
  CoinWorkDouble primalObjective_;
  CoinWorkDouble diagonalNorm_;
  CoinWorkDouble stepLength_;
  CoinWorkDouble linearPerturbation_;
  CoinWorkDouble diagonalPerturbation_;
  // gamma from Saunders and Tomlin regularized
  CoinWorkDouble gamma_;
  // delta from Saunders and Tomlin regularized
  CoinWorkDouble delta_;
  CoinWorkDouble targetGap_;
  CoinWorkDouble projectionTolerance_;
  CoinWorkDouble maximumRHSError_;
  CoinWorkDouble maximumBoundInfeasibility_;
  CoinWorkDouble maximumDualError_;
  CoinWorkDouble diagonalScaleFactor_;
  CoinWorkDouble scaleFactor_;
  CoinWorkDouble actualPrimalStep_;
  CoinWorkDouble actualDualStep_;
  CoinWorkDouble smallestInfeasibility_;
#define LENGTH_HISTORY 5
  CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY];
  CoinWorkDouble complementarityGap_;
  CoinWorkDouble baseObjectiveNorm_;
  CoinWorkDouble worstDirectionAccuracy_;
  CoinWorkDouble maximumRHSChange_;
  CoinWorkDouble *errorRegion_;
  CoinWorkDouble *rhsFixRegion_;
  CoinWorkDouble *upperSlack_;
  CoinWorkDouble *lowerSlack_;
  CoinWorkDouble *diagonal_;
  CoinWorkDouble *solution_;
  CoinWorkDouble *workArray_;
  CoinWorkDouble *deltaX_;
  CoinWorkDouble *deltaY_;
  CoinWorkDouble *deltaZ_;
  CoinWorkDouble *deltaW_;
  CoinWorkDouble *deltaSU_;
  CoinWorkDouble *deltaSL_;
  CoinWorkDouble *primalR_;
  CoinWorkDouble *dualR_;
  CoinWorkDouble *rhsB_;
  CoinWorkDouble *rhsU_;
  CoinWorkDouble *rhsL_;
  CoinWorkDouble *rhsZ_;
  CoinWorkDouble *rhsW_;
  CoinWorkDouble *rhsC_;
  CoinWorkDouble *zVec_;
  CoinWorkDouble *wVec_;
  ClpCholeskyBase *cholesky_;
  int numberComplementarityPairs_;
  int numberComplementarityItems_;
  int maximumBarrierIterations_;
  bool gonePrimalFeasible_;
  bool goneDualFeasible_;
  int algorithm_;
};
//#############################################################################
void ClpInteriorUnitTest(const std::string &mpsDir,
  const std::string &netlibDir);
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/