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
*/