CbcLinked.hpp

Go to the documentation of this file.

/* $Id: CbcLinked.hpp 1200 2009-07-25 08:44:13Z forrest $ */
// 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 {
        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()) 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