CbcLinked.hpp

Go to the documentation of this file.

/* $Id: CbcLinked.hpp 1899 2013-04-09 18:12:08Z stefan $ */
// 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);
 
private:
    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;
    }
 
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());
 
    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