ClpSimplexPrimalQuadratic.hpp

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.

/* 
   Authors
   
   John Forrest

 */
#ifndef ClpSimplexPrimalQuadratic_H
#define ClpSimplexPrimalQuadratic_H

class ClpQuadraticInfo;
class ClpQuadraticObjective;

#include "ClpSimplexPrimal.hpp"

class ClpSimplexPrimalQuadratic : public ClpSimplexPrimal {

public:


  int primalSLP(int numberPasses, double deltaTolerance);
  int primalQuadratic(int phase=2);
  int primalQuadratic2 (ClpQuadraticInfo * info,
                        int phase=2);
  ClpSimplexPrimalQuadratic * makeQuadratic(ClpQuadraticInfo & info);

  int endQuadratic(ClpSimplexPrimalQuadratic * quadraticModel,
                   ClpQuadraticInfo & info);
  int checkComplementarity (ClpQuadraticInfo * info,
                            CoinIndexedVector * array1, CoinIndexedVector * array2);
  void createDjs (ClpQuadraticInfo * info,
                  CoinIndexedVector * array1, CoinIndexedVector * array2);
  int whileIterating (ClpQuadraticInfo * info);
  int primalRow(CoinIndexedVector * rowArray,
                CoinIndexedVector * rhsArray,
                CoinIndexedVector * spareArray,
                CoinIndexedVector * spareArray2,
                ClpQuadraticInfo * info,
                int cleanupIteration);
  void statusOfProblemInPrimal(int & lastCleaned, int type,
                               ClpSimplexProgress * progress,
                               ClpQuadraticInfo * info);

};

class ClpQuadraticInfo  {
  
public:
  
public:


  ClpQuadraticInfo();
  ClpQuadraticInfo(const ClpSimplex * model);
  ~ClpQuadraticInfo();
  // Copy
  ClpQuadraticInfo(const ClpQuadraticInfo&);
  // Assignment
  ClpQuadraticInfo& operator=(const ClpQuadraticInfo&);
     


  inline int numberXColumns() const
  {return numberXColumns_;};
  inline int numberQuadraticColumns() const
  {return numberQuadraticColumns_;};
  inline int numberXRows() const
  {return numberXRows_;};
  inline int numberQuadraticRows() const
  {return numberQuadraticRows_;};
  inline int sequenceIn() const
  {return currentSequenceIn_;};
  inline void setSequenceIn(int sequence) 
  {currentSequenceIn_=sequence;};
  inline int crucialSj() const
  {return crucialSj_;};
  inline void setCrucialSj(int sequence) 
  {crucialSj_=sequence;};
  inline int currentPhase() const
  {return currentPhase_;};
  inline void setCurrentPhase(int phase) 
  {currentPhase_=phase;};
  inline const double * currentSolution() const
  {return currentSolution_;};
  void setCurrentSolution(const double * solution);
  inline ClpQuadraticObjective * originalObjective() const
  { return originalObjective_;};
  inline void setOriginalObjective( ClpQuadraticObjective * obj)
  { originalObjective_ = obj;};
  CoinPackedMatrix * quadraticObjective() const;
  double * linearObjective() const;
  void saveStatus();
  void restoreStatus();
  inline double * djWeight() const
  { return djWeight_;};
  void createGradient(ClpSimplex * model);
  inline double * gradient() const
  { return gradient_;};
  inline double infeasCost() const
  { return infeasCost_;};
  inline void setInfeasCost(double value)
  { infeasCost_ = value;};
  inline int * basicRow() const
  { return basicRow_;};
  inline int * impliedSj() const
  { return impliedSj_;};
    
private:

  ClpQuadraticObjective * originalObjective_;
  int * basicRow_;
  int * impliedSj_;
  int currentSequenceIn_;
  int crucialSj_;
  int validSequenceIn_;
  int validCrucialSj_;
  int currentPhase_;
  double * currentSolution_;
  int validPhase_;
  double * validSolution_;
  double * djWeight_;
  double * gradient_;
  int numberXRows_;
  int numberXColumns_;
  int numberQuadraticColumns_;
  int numberQuadraticRows_;
  double infeasCost_;
};
#endif

---