CbcLinked.hpp

Go to the documentation of this file.

/* $Id: CbcLinked.hpp 2465 2019-01-03 19:26:52Z unxusr $ */
// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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);
 
protected:
  typedef struct {
    double multiplier; // to use in computation
    int affected; // variable or element affected
    /*
          0 - LB of variable affected
          1 - UB of variable affected
          2 - element in position (affected) affected
        */
    unsigned char affect;
    unsigned char ubUsed; // 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 char type; // type of 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;
  }
 
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;
  }
 
protected:
 
  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;
  }
 
protected:
  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;
 
protected:
  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;
  }
 
protected:
  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());
 
  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/