/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcLinked.hpp

Go to the documentation of this file.

// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CglLinked_H
#define CglLinked_H
/* THIS CONTAINS STUFF THAT SHOULD BE IN
   OsiSolverLink
   OsiBranchLink
   CglTemporary
*/
#include "CoinModel.hpp"
#include "OsiClpSolverInterface.hpp"
#include "OsiChooseVariable.hpp"
#include "CbcFathom.hpp"
class CbcModel;
class CoinPackedMatrix;
class OsiLinkedBound;
class OsiObject;
class CglStored;
class CglTemporary;
class OsiSolverLink : public CbcOsiSolver {
  
public:
  //---------------------------------------------------------------------------

  virtual void initialSolve();
  
  virtual void resolve();

  virtual int fathom(bool allFixed) ;
  double * nonlinearSLP(int numberPasses,double deltaTolerance);
  double linearizedBAB(CglStored * cut) ;
  double * heuristicSolution(int numberPasses,double deltaTolerance,int mode);
  
  int doAOCuts(CglTemporary * cutGen, const double * solution, const double * solution2);
  
  

  OsiSolverLink ();
  
  OsiSolverLink(  CoinModel & modelObject);
  // Other way with existing object
  void load(  CoinModel & modelObject,bool tightenBounds=false,int logLevel=1);
  virtual OsiSolverInterface * clone(bool copyData=true) const;
  
  OsiSolverLink (const OsiSolverLink &);
  
  OsiSolverLink & operator=(const OsiSolverLink& rhs);
  
  virtual ~OsiSolverLink ();
  
  
  

  void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable, int whichVariableAffected, 
                        double multiplier=1.0);
  int updateCoefficients(ClpSimplex * solver, CoinPackedMatrix * matrix);
  void analyzeObjects();
  void addTighterConstraints();
  inline double bestObjectiveValue() const
  { return bestObjectiveValue_;}
  inline void setBestObjectiveValue(double value)
  { bestObjectiveValue_ = value;}
  inline const double * bestSolution() const
  { return bestSolution_;}
  void setBestSolution(const double * solution, int numberColumns);
  inline void setSpecialOptions2(int value)
  { specialOptions2_=value;}
  void sayConvex(bool convex);
  inline int specialOptions2() const
  { return specialOptions2_;}
  CoinPackedMatrix * cleanMatrix() const
  { return matrix_;}
  CoinPackedMatrix * originalRowCopy() const
  { return originalRowCopy_;}
  ClpSimplex * quadraticModel() const
  { return quadraticModel_;}
  CoinPackedMatrix * quadraticRow(int rowNumber,double * linear) const;
  inline double defaultMeshSize() const
  { return defaultMeshSize_;}
  inline void setDefaultMeshSize(double value)
  { defaultMeshSize_=value;}
  inline double defaultBound() const
  { return defaultBound_;}
  inline void setDefaultBound(double value)
  { defaultBound_=value;}
  inline void setIntegerPriority(int value)
  { integerPriority_=value;}
  inline int integerPriority() const
  { return integerPriority_;}
  inline int objectiveVariable() const
  { return objectiveVariable_;}
  inline void setBiLinearPriority(int value)
  { biLinearPriority_=value;}
  inline int biLinearPriority() const
  { return biLinearPriority_;}
  inline const CoinModel * coinModel() const
  { return &coinModel_;}
  void setBiLinearPriorities(int value, double meshSize=1.0);
  void setBranchingStrategyOnVariables(int strategyValue, int priorityValue=-1,
                                       int mode=7);
  void setMeshSizes(double value);
  void setFixedPriority(int priorityValue);
  
  //---------------------------------------------------------------------------
  
protected:
  
  

  //void initialize(ClpSimplex * & solver, OsiObject ** & object) const;
  void gutsOfDestructor(bool justNullify=false);
  void gutsOfCopy(const OsiSolverLink & rhs) ;
  
  CoinPackedMatrix * matrix_;
  CoinPackedMatrix * originalRowCopy_;
  ClpSimplex * quadraticModel_;
  int numberNonLinearRows_;
  int * startNonLinear_;
  int * rowNonLinear_;
  int * convex_;
  int * whichNonLinear_;
  CoinModel coinModel_;
  int numberVariables_;
  OsiLinkedBound * info_;
  int specialOptions2_;
  int objectiveRow_;
  int objectiveVariable_;
  double bestObjectiveValue_;
  double defaultMeshSize_;
  double defaultBound_;
  double * bestSolution_;
  int integerPriority_;
  int biLinearPriority_;
  int numberFix_;
  int * fixVariables_;
};
class OsiLinkedBound {
  
public:
  //---------------------------------------------------------------------------

  void updateBounds(ClpSimplex * solver);
  
  

  OsiLinkedBound ();
  OsiLinkedBound(OsiSolverInterface * model, int variable,
                 int numberAffected, const int * positionL, 
                 const int * positionU, const double * multiplier);
  
  OsiLinkedBound (const OsiLinkedBound &);
  
  OsiLinkedBound & operator=(const OsiLinkedBound& rhs);
  
  ~OsiLinkedBound ();
  
  

  inline int variable() const
  { return variable_;}
  void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable, 
                        double multiplier=1.0);
  
private:
  typedef struct {
    /*
      0 - LB of variable affected
      1 - UB of variable affected
      2 - element in position (affected) affected
    */
    unsigned int affect:2;
    unsigned int ubUsed:1; // nonzero if UB of this variable is used
    /* 
       0 - use x*multiplier
       1 - use multiplier/x
       2 - if UB use min of current upper and x*multiplier, if LB use max of current lower and x*multiplier
    */
    unsigned int type:4; // type of computation
    unsigned int affected:25; // variable or element affected
    double multiplier; // to use in computation 
  } boundElementAction;
  

  OsiSolverInterface * model_;
  int variable_;
  int numberAffected_;
  int maximumAffected_;
  boundElementAction * affected_;
};
#include "CbcHeuristic.hpp"
class CbcHeuristicDynamic3 : public CbcHeuristic {
public:
  
  // Default Constructor 
  CbcHeuristicDynamic3 ();
  
  /* Constructor with model
   */
  CbcHeuristicDynamic3 (CbcModel & model);
  
  // Copy constructor 
  CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);
  
  // Destructor 
  ~CbcHeuristicDynamic3 ();
  
  virtual CbcHeuristic * clone() const;
  
  virtual void setModel(CbcModel * model);
  
  using CbcHeuristic::solution ;
  virtual int solution(double & objectiveValue,
                       double * newSolution);
  virtual void resetModel(CbcModel * model);
  virtual bool canDealWithOdd() const
  { return true;}
  
protected:
private:
  CbcHeuristicDynamic3 & operator=(const CbcHeuristicDynamic3& rhs);
};

#include "OsiBranchingObject.hpp"

class CoinWarmStartBasis;

class OsiOldLink : public OsiSOS {

public:

  // Default Constructor 
  OsiOldLink ();

  OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
           int numberLinks, int first,
           const double * weights, int setNumber);
  OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
           int numberLinks, int typeSOS, const int * which,
           const double * weights, int setNumber);
  
  // Copy constructor 
  OsiOldLink ( const OsiOldLink &);
   
  virtual OsiObject * clone() const;

  // Assignment operator 
  OsiOldLink & operator=( const OsiOldLink& rhs);

  // Destructor 
  virtual ~OsiOldLink ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

  inline int numberLinks() const
  {return numberLinks_;}

  virtual bool canDoHeuristics() const 
  {return false;}
  virtual bool boundBranch() const 
  {return false;}

private:

  int numberLinks_;
};
class OsiOldLinkBranchingObject : public OsiSOSBranchingObject {

public:

  // Default Constructor 
  OsiOldLinkBranchingObject ();

  // Useful constructor
  OsiOldLinkBranchingObject (OsiSolverInterface * solver,  const OsiOldLink * originalObject,
                          int way,
                          double separator);
  
  // Copy constructor 
  OsiOldLinkBranchingObject ( const OsiOldLinkBranchingObject &);
   
  // Assignment operator 
  OsiOldLinkBranchingObject & operator=( const OsiOldLinkBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  // Destructor 
  virtual ~OsiOldLinkBranchingObject ();
  
  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);
private:
};
class OsiOneLink {

public:

  // Default Constructor 
  OsiOneLink ();

  OsiOneLink (const OsiSolverInterface * solver, int xRow, int xColumn, int xyRow,
              const char * functionString);
  
  // Copy constructor 
  OsiOneLink ( const OsiOneLink &);
   
  // Assignment operator 
  OsiOneLink & operator=( const OsiOneLink& rhs);

  // Destructor 
  virtual ~OsiOneLink ();
  

  int xRow_;
  int xColumn_;
  int xyRow;
  std::string function_;
};
class OsiLink : public OsiSOS {

public:

  // Default Constructor 
  OsiLink ();

  OsiLink (const OsiSolverInterface * solver, int yRow,
           int yColumn, double meshSize);
  
  // Copy constructor 
  OsiLink ( const OsiLink &);
   
  virtual OsiObject * clone() const;

  // Assignment operator 
  OsiLink & operator=( const OsiLink& rhs);

  // Destructor 
  virtual ~OsiLink ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

  inline int numberLinks() const
  {return numberLinks_;}

  virtual bool canDoHeuristics() const 
  {return false;}
  virtual bool boundBranch() const 
  {return false;}

private:
  double meshSize_;
  OsiOneLink * data_;
  int numberLinks_;
  int yRow_;
  int yColumn_;
};
class OsiLinkBranchingObject : public OsiTwoWayBranchingObject {

public:

  // Default Constructor 
  OsiLinkBranchingObject ();

  // Useful constructor
  OsiLinkBranchingObject (OsiSolverInterface * solver,  const OsiLink * originalObject,
                          int way,
                          double separator);
  
  // Copy constructor 
  OsiLinkBranchingObject ( const OsiLinkBranchingObject &);
   
  // Assignment operator 
  OsiLinkBranchingObject & operator=( const OsiLinkBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  // Destructor 
  virtual ~OsiLinkBranchingObject ();
  
  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);
private:
};
class OsiBiLinear : public OsiObject2 {

public:

  // Default Constructor 
  OsiBiLinear ();

  OsiBiLinear (OsiSolverInterface * solver, int xColumn,
               int yColumn, int xyRow, double coefficient,
               double xMesh, double yMesh,
               int numberExistingObjects=0,const OsiObject ** objects=NULL );
  
  OsiBiLinear (CoinModel * coinModel, int xColumn,
               int yColumn, int xyRow, double coefficient,
               double xMesh, double yMesh,
               int numberExistingObjects=0,const OsiObject ** objects=NULL );
  
  // Copy constructor 
  OsiBiLinear ( const OsiBiLinear &);
   
  virtual OsiObject * clone() const;

  // Assignment operator 
  OsiBiLinear & operator=( const OsiBiLinear& rhs);

  // Destructor 
  virtual ~OsiBiLinear ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

  // This does NOT set mutable stuff
  virtual double checkInfeasibility(const OsiBranchingInformation * info) const;
  
  virtual bool canDoHeuristics() const 
  {return false;}
  virtual bool boundBranch() const 
  { return (branchingStrategy_&4)!=0;}
  inline int xColumn() const
  { return xColumn_;}
  inline int yColumn() const
  { return yColumn_;}
  inline int xRow() const
  { return xRow_;}
  inline int yRow() const
  { return yRow_;}
  inline int xyRow() const
  { return xyRow_;}
  inline double coefficient() const
  { return coefficient_;}
  inline void setCoefficient(double value)
  { coefficient_ = value;}
  inline int firstLambda() const
  { return firstLambda_;}
  inline double xSatisfied() const
  { return xSatisfied_;}
  inline void setXSatisfied(double value)
  { xSatisfied_=value;}
  inline double ySatisfied() const
  { return ySatisfied_;}
  inline void setYSatisfied(double value)
  { ySatisfied_=value;}
  inline double xOtherSatisfied() const
  { return xOtherSatisfied_;}
  inline void setXOtherSatisfied(double value)
  { xOtherSatisfied_=value;}
  inline double yOtherSatisfied() const
  { return yOtherSatisfied_;}
  inline void setYOtherSatisfied(double value)
  { yOtherSatisfied_=value;}
  inline double xMeshSize() const
  { return xMeshSize_;}
  inline void setXMeshSize(double value)
  { xMeshSize_=value;}
  inline double yMeshSize() const
  { return yMeshSize_;}
  inline void setYMeshSize(double value)
  { yMeshSize_=value;}
  inline double xySatisfied() const
  { return xySatisfied_;}
  inline void setXYSatisfied(double value)
  { xySatisfied_=value;}
  void setMeshSizes(const OsiSolverInterface * solver, double x, double y);
  inline int branchingStrategy() const
  { return branchingStrategy_;}
  inline void setBranchingStrategy(int value)
  { branchingStrategy_=value;}
  inline int boundType() const
  { return boundType_;}
  inline void setBoundType(int value)
  { boundType_ = value;}
  void newBounds(OsiSolverInterface * solver, int way, short xOrY, double separator) const;
  int updateCoefficients(const double * lower, const double * upper, double * objective,
                          CoinPackedMatrix * matrix, CoinWarmStartBasis * basis) const;
  double xyCoefficient(const double * solution) const;
  void getCoefficients(const OsiSolverInterface * solver,double xB[2], double yB[2], double xybar[4]) const;
  double computeLambdas(const double xB[3], const double yB[3],const double xybar[4],double lambda[4]) const;
  void addExtraRow(int row, double multiplier);
  void getPseudoShadow(const OsiBranchingInformation * info);
  double getMovement(const OsiBranchingInformation * info);

protected:
  void computeLambdas(const OsiSolverInterface * solver,double lambda[4]) const;
  
  double coefficient_;
  double xMeshSize_;
  double yMeshSize_;
  double xSatisfied_;
  double ySatisfied_;
  double xOtherSatisfied_;
  double yOtherSatisfied_;
  double xySatisfied_;
  mutable double xyBranchValue_;
  int xColumn_;
  int yColumn_;
  int firstLambda_;
  int branchingStrategy_;
  int boundType_;
  int xRow_;
  int yRow_;
  int xyRow_;
  int convexity_;
  int numberExtraRows_;
  double * multiplier_;
  int * extraRow_;
  mutable short chosen_;
};
class OsiBiLinearBranchingObject : public OsiTwoWayBranchingObject {

public:

  // Default Constructor 
  OsiBiLinearBranchingObject ();

  // Useful constructor
  OsiBiLinearBranchingObject (OsiSolverInterface * solver,  const OsiBiLinear * originalObject,
                          int way,
                          double separator, int chosen);
  
  // Copy constructor 
  OsiBiLinearBranchingObject ( const OsiBiLinearBranchingObject &);
   
  // Assignment operator 
  OsiBiLinearBranchingObject & operator=( const OsiBiLinearBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  // Destructor 
  virtual ~OsiBiLinearBranchingObject ();
  
  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);
  virtual bool boundBranch() const; 
private:
  short chosen_;
};
class OsiBiLinearEquality : public OsiBiLinear {

public:

  // Default Constructor 
  OsiBiLinearEquality ();

  OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
               int yColumn, int xyRow, double rhs,
                       double xMesh);
  
  // Copy constructor 
  OsiBiLinearEquality ( const OsiBiLinearEquality &);
   
  virtual OsiObject * clone() const;

  // Assignment operator 
  OsiBiLinearEquality & operator=( const OsiBiLinearEquality& rhs);

  // Destructor 
  virtual ~OsiBiLinearEquality ();
  
  virtual double improvement(const OsiSolverInterface * solver) const;
  double newGrid(OsiSolverInterface * solver, int type) const;
  inline int numberPoints() const
  { return numberPoints_;}
  inline void setNumberPoints(int value)
  { numberPoints_ = value;}

private:
  int numberPoints_;
};


class OsiSimpleFixedInteger : public OsiSimpleInteger {

public:

  OsiSimpleFixedInteger ();

  OsiSimpleFixedInteger (const OsiSolverInterface * solver, int iColumn);
  
  OsiSimpleFixedInteger (int iColumn, double lower, double upper);
  
  OsiSimpleFixedInteger (const OsiSimpleInteger &);
  
  OsiSimpleFixedInteger ( const OsiSimpleFixedInteger &);
   
  virtual OsiObject * clone() const;

  OsiSimpleFixedInteger & operator=( const OsiSimpleFixedInteger& rhs);

  virtual ~OsiSimpleFixedInteger ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
protected:
  
};
class OsiUsesBiLinear : public OsiSimpleInteger {

public:

  OsiUsesBiLinear ();

  OsiUsesBiLinear (const OsiSolverInterface * solver, int iColumn, int type);
  
  OsiUsesBiLinear (int iColumn, double lower, double upper, int type);
  
  OsiUsesBiLinear (const OsiSimpleInteger & rhs, int type);
  
  OsiUsesBiLinear ( const OsiUsesBiLinear & rhs);
   
  virtual OsiObject * clone() const;

  OsiUsesBiLinear & operator=( const OsiUsesBiLinear& rhs);

  virtual ~OsiUsesBiLinear ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  void addBiLinearObjects(OsiSolverLink * solver);
protected:
  int numberBiLinear_;
  int type_;
  OsiObject ** objects_;
};
class OsiChooseStrongSubset  : public OsiChooseStrong {
 
public:
    
  OsiChooseStrongSubset ();

  OsiChooseStrongSubset (const OsiSolverInterface * solver);

  OsiChooseStrongSubset (const OsiChooseStrongSubset &);
   
  OsiChooseStrongSubset & operator= (const OsiChooseStrongSubset& rhs);

  virtual OsiChooseVariable * clone() const;

  virtual ~OsiChooseStrongSubset ();

  virtual int setupList ( OsiBranchingInformation *info, bool initialize);
  virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);

  inline int numberObjectsToUse() const
  { return numberObjectsToUse_;}
  inline void setNumberObjectsToUse(int value)
  { numberObjectsToUse_ = value;}

protected:
  // Data
  int numberObjectsToUse_;
};

#include <string>

#include "CglStored.hpp"

class CoinWarmStartBasis;
class CglTemporary : public CglStored {
 
public:
    
  
  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
                             const CglTreeInfo info = CglTreeInfo()) const;


  CglTemporary ();
 
  CglTemporary (const CglTemporary & rhs);

  virtual CglCutGenerator * clone() const;

  CglTemporary &
    operator=(const CglTemporary& rhs);
  
  virtual
    ~CglTemporary ();
      
private:
  
 // Private member methods

  // Private member data
};
//#############################################################################

class OsiSolverLinearizedQuadratic : public OsiClpSolverInterface {
  
public:
  //---------------------------------------------------------------------------

  virtual void initialSolve();
  
  

  OsiSolverLinearizedQuadratic ();
  OsiSolverLinearizedQuadratic(  ClpSimplex * quadraticModel);
  virtual OsiSolverInterface * clone(bool copyData=true) const;
  
  OsiSolverLinearizedQuadratic (const OsiSolverLinearizedQuadratic &);
  
  OsiSolverLinearizedQuadratic & operator=(const OsiSolverLinearizedQuadratic& rhs);
  
  virtual ~OsiSolverLinearizedQuadratic ();
  
  
  

  inline double bestObjectiveValue() const
  { return bestObjectiveValue_;}
  const double * bestSolution() const
  { return bestSolution_;}
  inline void setSpecialOptions3(int value)
  { specialOptions3_=value;}
  inline int specialOptions3() const
  { return specialOptions3_;}
  ClpSimplex * quadraticModel() const
  { return quadraticModel_;}
  
  //---------------------------------------------------------------------------
  
protected:
  
  
  

  double bestObjectiveValue_;
  ClpSimplex * quadraticModel_;
  double * bestSolution_;
  int specialOptions3_;
};
class ClpSimplex;
ClpSimplex * approximateSolution(CoinModel & coinModel, 
                                 int numberPasses, double deltaTolerance,
                                 int mode=0);
#endif

---