source: stable/2.9/Cbc/src/CbcLinked.hpp @ 2180

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

This is to allow the user to replace initialSolve and resolve
This version changes coefficients
*/

class OsiSolverLink : public CbcOsiSolver {

public:
    //---------------------------------------------------------------------------
    /**@name Solve methods */
    //@{
    /// Solve initial LP relaxation
    virtual void initialSolve();

    /// Resolve an LP relaxation after problem modification
    virtual void resolve();

    /**
       Problem specific
       Returns -1 if node fathomed and no solution
                0 if did nothing
            1 if node fathomed and solution
       allFixed is true if all LinkedBound variables are fixed
    */
    virtual int fathom(bool allFixed) ;
    /** Solves nonlinear problem from CoinModel using SLP - may be used as crash
        for other algorithms when number of iterations small.
        Also exits if all problematical variables are changing
        less than deltaTolerance
        Returns solution array
    */
    double * nonlinearSLP(int numberPasses, double deltaTolerance);
    /** Solve linearized quadratic objective branch and bound.
        Return cutoff and OA cut
    */
    double linearizedBAB(CglStored * cut) ;
    /** Solves nonlinear problem from CoinModel using SLP - and then tries to get
        heuristic solution
        Returns solution array
        mode -
        0 just get continuous
        1 round and try normal bab
        2 use defaultBound_ to bound integer variables near current solution
    */
    double * heuristicSolution(int numberPasses, double deltaTolerance, int mode);

    /// Do OA cuts
    int doAOCuts(CglTemporary * cutGen, const double * solution, const double * solution2);
    //@}


    /**@name Constructors and destructors */
    //@{
    /// Default Constructor
    OsiSolverLink ();

    /** This creates from a coinModel object

        if errors.then number of sets is -1

        This creates linked ordered sets information.  It assumes -

        for product terms syntax is yy*f(zz)
        also just f(zz) is allowed
        and even a constant

        modelObject not const as may be changed as part of process.
    */
    OsiSolverLink(  CoinModel & modelObject);
    // Other way with existing object
    void load(  CoinModel & modelObject, bool tightenBounds = false, int logLevel = 1);
    /// Clone
    virtual OsiSolverInterface * clone(bool copyData = true) const;

    /// Copy constructor
    OsiSolverLink (const OsiSolverLink &);

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

    /// Destructor
    virtual ~OsiSolverLink ();

    //@}


    /**@name Sets and Gets */
    //@{
    /// Add a bound modifier
    void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable, int whichVariableAffected,
                          double multiplier = 1.0);
    /// Update coefficients - returns number updated if in updating mode
    int updateCoefficients(ClpSimplex * solver, CoinPackedMatrix * matrix);
    /// Analyze constraints to see which are convex (quadratic)
    void analyzeObjects();
    /// Add reformulated bilinear constraints
    void addTighterConstraints();
    /// Objective value of best solution found internally
    inline double bestObjectiveValue() const {
        return bestObjectiveValue_;
    }
    /// Set objective value of best solution found internally
    inline void setBestObjectiveValue(double value) {
        bestObjectiveValue_ = value;
    }
    /// Best solution found internally
    inline const double * bestSolution() const {
        return bestSolution_;
    }
    /// Set best solution found internally
    void setBestSolution(const double * solution, int numberColumns);
    /// Set special options
    inline void setSpecialOptions2(int value) {
        specialOptions2_ = value;
    }
    /// Say convex (should work it out) - if convex false then strictly concave
    void sayConvex(bool convex);
    /// Get special options
    inline int specialOptions2() const {
        return specialOptions2_;
    }
    /** Clean copy of matrix
        So we can add rows
    */
    CoinPackedMatrix * cleanMatrix() const {
        return matrix_;
    }
    /** Row copy of matrix
        Just genuine columns and rows
        Linear part
    */
    CoinPackedMatrix * originalRowCopy() const {
        return originalRowCopy_;
    }
    /// Copy of quadratic model if one
    ClpSimplex * quadraticModel() const {
        return quadraticModel_;
    }
    /// Gets correct form for a quadratic row - user to delete
    CoinPackedMatrix * quadraticRow(int rowNumber, double * linear) const;
    /// Default meshSize
    inline double defaultMeshSize() const {
        return defaultMeshSize_;
    }
    inline void setDefaultMeshSize(double value) {
        defaultMeshSize_ = value;
    }
    /// Default maximumbound
    inline double defaultBound() const {
        return defaultBound_;
    }
    inline void setDefaultBound(double value) {
        defaultBound_ = value;
    }
    /// Set integer priority
    inline void setIntegerPriority(int value) {
        integerPriority_ = value;
    }
    /// Get integer priority
    inline int integerPriority() const {
        return integerPriority_;
    }
    /// Objective transfer variable if one
    inline int objectiveVariable() const {
        return objectiveVariable_;
    }
    /// Set biLinear priority
    inline void setBiLinearPriority(int value) {
        biLinearPriority_ = value;
    }
    /// Get biLinear priority
    inline int biLinearPriority() const {
        return biLinearPriority_;
    }
    /// Return CoinModel
    inline const CoinModel * coinModel() const {
        return &coinModel_;
    }
    /// Set all biLinear priorities on x-x variables
    void setBiLinearPriorities(int value, double meshSize = 1.0);
    /** Set options and priority on all or some biLinear variables
        1 - on I-I
        2 - on I-x
        4 - on x-x
        or combinations.
        -1 means leave (for priority value and strategy value)
    */
    void setBranchingStrategyOnVariables(int strategyValue, int priorityValue = -1,
                                         int mode = 7);
    /// Set all mesh sizes on x-x variables
    void setMeshSizes(double value);
    /** Two tier integer problem where when set of variables with priority
        less than this are fixed the problem becomes an easier integer problem
    */
    void setFixedPriority(int priorityValue);
    //@}

    //---------------------------------------------------------------------------

protected:


    /**@name functions */
    //@{
    /// Do real work of initialize
    //void initialize(ClpSimplex * & solver, OsiObject ** & object) const;
    /// Do real work of delete
    void gutsOfDestructor(bool justNullify = false);
    /// Do real work of copy
    void gutsOfCopy(const OsiSolverLink & rhs) ;
    //@}

    /**@name Private member data */
    //@{
    /** Clean copy of matrix
        Marked coefficients will be multiplied by L or U
    */
    CoinPackedMatrix * matrix_;
    /** Row copy of matrix
        Just genuine columns and rows
    */
    CoinPackedMatrix * originalRowCopy_;
    /// Copy of quadratic model if one
    ClpSimplex * quadraticModel_;
    /// Number of rows with nonLinearities
    int numberNonLinearRows_;
    /// Starts of lists
    int * startNonLinear_;
    /// Row number for a list
    int * rowNonLinear_;
    /** Indicator whether is convex, concave or neither
        -1 concave, 0 neither, +1 convex
    */
    int * convex_;
    /// Indices in a list/row
    int * whichNonLinear_;
    /// Model in CoinModel format
    CoinModel coinModel_;
    /// Number of variables in tightening phase
    int numberVariables_;
    /// Information
    OsiLinkedBound * info_;
    /**
       0 bit (1) - call fathom (may do mini B&B)
       1 bit (2) - quadratic only in objective (add OA cuts)
       2 bit (4) - convex
       3 bit (8) - try adding OA cuts
       4 bit (16) - add linearized constraints
    */
    int specialOptions2_;
    /// Objective transfer row if one
    int objectiveRow_;
    /// Objective transfer variable if one
    int objectiveVariable_;
    /// Objective value of best solution found internally
    double bestObjectiveValue_;
    /// Default mesh
    double defaultMeshSize_;
    /// Default maximum bound
    double defaultBound_;
    /// Best solution found internally
    double * bestSolution_;
    /// Priority for integers
    int integerPriority_;
    /// Priority for bilinear
    int biLinearPriority_;
    /// Number of variables which when fixed help
    int numberFix_;
    /// list of fixed variables
    int * fixVariables_;
    //@}
};
/**
   List of bounds which depend on other bounds
*/

class OsiLinkedBound {

public:
    //---------------------------------------------------------------------------
    /**@name Action methods */
    //@{
    /// Update other bounds
    void updateBounds(ClpSimplex * solver);
    //@}


    /**@name Constructors and destructors */
    //@{
    /// Default Constructor
    OsiLinkedBound ();
    /// Useful Constructor
    OsiLinkedBound(OsiSolverInterface * model, int variable,
                   int numberAffected, const int * positionL,
                   const int * positionU, const double * multiplier);

    /// Copy constructor
    OsiLinkedBound (const OsiLinkedBound &);

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

    /// Destructor
    ~OsiLinkedBound ();

    //@}

    /**@name Sets and Gets */
    //@{
    /// Get variable
    inline int variable() const {
        return variable_;
    }
    /// Add a bound modifier
    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;

    /**@name Private member data */
    //@{
    /// Pointer back to model
    OsiSolverInterface * model_;
    /// Variable
    int variable_;
    /// Number of variables/elements affected
    int numberAffected_;
    /// Maximum number of variables/elements affected
    int maximumAffected_;
    /// Actions
    boundElementAction * affected_;
    //@}
};
#include "CbcHeuristic.hpp"
/** heuristic - just picks up any good solution
 */

class CbcHeuristicDynamic3 : public CbcHeuristic {
public:

    // Default Constructor
    CbcHeuristicDynamic3 ();

    /* Constructor with model
     */
    CbcHeuristicDynamic3 (CbcModel & model);

    // Copy constructor
    CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);

    // Destructor
    ~CbcHeuristicDynamic3 ();

    /// Clone
    virtual CbcHeuristic * clone() const;

    /// update model
    virtual void setModel(CbcModel * model);

    using CbcHeuristic::solution ;
    /** returns 0 if no solution, 1 if valid solution.
        Sets solution values if good, sets objective value (only if good)
        We leave all variables which are at one at this node of the
        tree to that value and will
        initially set all others to zero.  We then sort all variables in order of their cost
        divided by the number of entries in rows which are not yet covered.  We randomize that
        value a bit so that ties will be broken in different ways on different runs of the heuristic.
        We then choose the best one and set it to one and repeat the exercise.

    */
    virtual int solution(double & objectiveValue,
                         double * newSolution);
    /// Resets stuff if model changes
    virtual void resetModel(CbcModel * model);
    /// Returns true if can deal with "odd" problems e.g. sos type 2
    virtual bool canDealWithOdd() const {
        return true;
    }

protected:
private:
    /// Illegal Assignment operator
    CbcHeuristicDynamic3 & operator=(const CbcHeuristicDynamic3& rhs);
};

#include "OsiBranchingObject.hpp"

/** Define Special Linked Ordered Sets.

*/
class CoinWarmStartBasis;

class OsiOldLink : public OsiSOS {

public:

    // Default Constructor
    OsiOldLink ();

    /** Useful constructor - A valid solution is if all variables are zero
        apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
        numberInSet-1.  The length of weights array is numberInSet.
        For this constructor the variables in matrix are the numberInSet*numberLink
        starting at first. If weights null then 0,1,2..
    */
    OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
                int numberLinks, int first,
                const double * weights, int setNumber);
    /** Useful constructor - A valid solution is if all variables are zero
        apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
        numberInSet-1.  The length of weights array is numberInSet.
        For this constructor the variables are given by list - grouped.
        If weights null then 0,1,2..
    */
    OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
                int numberLinks, int typeSOS, const int * which,
                const double * weights, int setNumber);

    // Copy constructor
    OsiOldLink ( const OsiOldLink &);

    /// Clone
    virtual OsiObject * clone() const;

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

    // Destructor
    virtual ~OsiOldLink ();

    using OsiObject::infeasibility ;
    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

    using OsiObject::feasibleRegion ;
    /** Set bounds to fix the variable at the current (integer) value.

      Given an integer value, set the lower and upper bounds to fix the
      variable. Returns amount it had to move variable.
    */
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    /** Creates a branching object

      The preferred direction is set by \p way, 0 for down, 1 for up.
    */
    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

    /// Redoes data when sequence numbers change
    virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

    /// Number of links for each member
    inline int numberLinks() const {
        return numberLinks_;
    }

    /** \brief Return true if object can take part in normal heuristics
    */
    virtual bool canDoHeuristics() const {
        return false;
    }
    /** \brief Return true if branch should only bound variables
    */
    virtual bool boundBranch() const {
        return false;
    }

private:
    /// data

    /// Number of links
    int numberLinks_;
};
/** Branching object for Linked ordered sets

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

    /// Clone
    virtual OsiBranchingObject * clone() const;

    // Destructor
    virtual ~OsiOldLinkBranchingObject ();

    using OsiBranchingObject::branch ;
    /// Does next branch and updates state
    virtual double branch(OsiSolverInterface * solver);

    using OsiBranchingObject::print ;
    /** \brief Print something about branch - only if log level high
    */
    virtual void print(const OsiSolverInterface * solver = NULL);
private:
    /// data
};
/** Define data for one link

*/


class OsiOneLink {

public:

    // Default Constructor
    OsiOneLink ();

    /** Useful constructor -

    */
    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 ();

    /// data

    /// Row which defines x (if -1 then no x)
    int xRow_;
    /// Column which defines x
    int xColumn_;
    /// Output row
    int xyRow;
    /// Function
    std::string function_;
};
/** Define Special Linked Ordered Sets. New style

    members and weights may be stored in SOS object

    This is for y and x*f(y) and z*g(y) etc

*/


class OsiLink : public OsiSOS {

public:

    // Default Constructor
    OsiLink ();

    /** Useful constructor -

    */
    OsiLink (const OsiSolverInterface * solver, int yRow,
             int yColumn, double meshSize);

    // Copy constructor
    OsiLink ( const OsiLink &);

    /// Clone
    virtual OsiObject * clone() const;

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

    // Destructor
    virtual ~OsiLink ();

    using OsiObject::infeasibility ;
    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

    using OsiObject::feasibleRegion ;
    /** Set bounds to fix the variable at the current (integer) value.

      Given an integer value, set the lower and upper bounds to fix the
      variable. Returns amount it had to move variable.
    */
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    /** Creates a branching object

      The preferred direction is set by \p way, 0 for down, 1 for up.
    */
    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

    /// Redoes data when sequence numbers change
    virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

    /// Number of links for each member
    inline int numberLinks() const {
        return numberLinks_;
    }

    /** \brief Return true if object can take part in normal heuristics
    */
    virtual bool canDoHeuristics() const {
        return false;
    }
    /** \brief Return true if branch should only bound variables
    */
    virtual bool boundBranch() const {
        return false;
    }

private:
    /// data
    /// Current increment for y points
    double meshSize_;
    /// Links
    OsiOneLink * data_;
    /// Number of links
    int numberLinks_;
    /// Row which defines y
    int yRow_;
    /// Column which defines y
    int yColumn_;
};
/** Branching object for Linked ordered sets

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

    /// Clone
    virtual OsiBranchingObject * clone() const;

    // Destructor
    virtual ~OsiLinkBranchingObject ();

    using OsiBranchingObject::branch ;
    /// Does next branch and updates state
    virtual double branch(OsiSolverInterface * solver);

    using OsiBranchingObject::print ;
    /** \brief Print something about branch - only if log level high
    */
    virtual void print(const OsiSolverInterface * solver = NULL);
private:
    /// data
};
/** Define BiLinear objects

    This models x*y where one or both are integer

*/


class OsiBiLinear : public OsiObject2 {

public:

    // Default Constructor
    OsiBiLinear ();

    /** Useful constructor -
        This Adds in rows and variables to construct valid Linked Ordered Set
        Adds extra constraints to match other x/y
        So note not const solver
    */
    OsiBiLinear (OsiSolverInterface * solver, int xColumn,
                 int yColumn, int xyRow, double coefficient,
                 double xMesh, double yMesh,
                 int numberExistingObjects = 0, const OsiObject ** objects = NULL );

    /** Useful constructor -
        This Adds in rows and variables to construct valid Linked Ordered Set
        Adds extra constraints to match other x/y
        So note not const model
    */
    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 &);

    /// Clone
    virtual OsiObject * clone() const;

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

    // Destructor
    virtual ~OsiBiLinear ();

    using OsiObject::infeasibility ;
    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

    using OsiObject::feasibleRegion ;
    /** Set bounds to fix the variable at the current (integer) value.

      Given an integer value, set the lower and upper bounds to fix the
      variable. Returns amount it had to move variable.
    */
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    /** Creates a branching object

      The preferred direction is set by \p way, 0 for down, 1 for up.
    */
    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

    /// Redoes data when sequence numbers change
    virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);

    // This does NOT set mutable stuff
    virtual double checkInfeasibility(const OsiBranchingInformation * info) const;

    /** \brief Return true if object can take part in normal heuristics
    */
    virtual bool canDoHeuristics() const {
        return false;
    }
    /** \brief Return true if branch should only bound variables
    */
    virtual bool boundBranch() const {
        return (branchingStrategy_&4) != 0;
    }
    /// X column
    inline int xColumn() const {
        return xColumn_;
    }
    /// Y column
    inline int yColumn() const {
        return yColumn_;
    }
    /// X row
    inline int xRow() const {
        return xRow_;
    }
    /// Y row
    inline int yRow() const {
        return yRow_;
    }
    /// XY row
    inline int xyRow() const {
        return xyRow_;
    }
    /// Coefficient
    inline double coefficient() const {
        return coefficient_;
    }
    /// Set coefficient
    inline void setCoefficient(double value) {
        coefficient_ = value;
    }
    /// First lambda (of 4)
    inline int firstLambda() const {
        return firstLambda_;
    }
    /// X satisfied if less than this away from mesh
    inline double xSatisfied() const {
        return xSatisfied_;
    }
    inline void setXSatisfied(double value) {
        xSatisfied_ = value;
    }
    /// Y satisfied if less than this away from mesh
    inline double ySatisfied() const {
        return ySatisfied_;
    }
    inline void setYSatisfied(double value) {
        ySatisfied_ = value;
    }
    /// X other satisfied if less than this away from mesh
    inline double xOtherSatisfied() const {
        return xOtherSatisfied_;
    }
    inline void setXOtherSatisfied(double value) {
        xOtherSatisfied_ = value;
    }
    /// Y other satisfied if less than this away from mesh
    inline double yOtherSatisfied() const {
        return yOtherSatisfied_;
    }
    inline void setYOtherSatisfied(double value) {
        yOtherSatisfied_ = value;
    }
    /// X meshSize
    inline double xMeshSize() const {
        return xMeshSize_;
    }
    inline void setXMeshSize(double value) {
        xMeshSize_ = value;
    }
    /// Y meshSize
    inline double yMeshSize() const {
        return yMeshSize_;
    }
    inline void setYMeshSize(double value) {
        yMeshSize_ = value;
    }
    /// XY satisfied if two version differ by less than this
    inline double xySatisfied() const {
        return xySatisfied_;
    }
    inline void setXYSatisfied(double value) {
        xySatisfied_ = value;
    }
    /// Set sizes and other stuff
    void setMeshSizes(const OsiSolverInterface * solver, double x, double y);
    /** branching strategy etc
        bottom 2 bits
        0 branch on either, 1 branch on x, 2 branch on y
        next bit
        4 set to say don't update coefficients
        next bit
        8 set to say don't use in feasible region
        next bit
        16 set to say - Always satisfied !!
    */
    inline int branchingStrategy() const {
        return branchingStrategy_;
    }
    inline void setBranchingStrategy(int value) {
        branchingStrategy_ = value;
    }
    /** Simple quadratic bound marker.
        0 no
        1 L if coefficient pos, G if negative i.e. value is ub on xy
        2 G if coefficient pos, L if negative i.e. value is lb on xy
        3 E
        If bound then real coefficient is 1.0 and coefficient_ is bound
    */
    inline int boundType() const {
        return boundType_;
    }
    inline void setBoundType(int value) {
        boundType_ = value;
    }
    /// Does work of branching
    void newBounds(OsiSolverInterface * solver, int way, short xOrY, double separator) const;
    /// Updates coefficients - returns number updated
    int updateCoefficients(const double * lower, const double * upper, double * objective,
                           CoinPackedMatrix * matrix, CoinWarmStartBasis * basis) const;
    /// Returns true value of single xyRow coefficient
    double xyCoefficient(const double * solution) const;
    /// Get LU coefficients from matrix
    void getCoefficients(const OsiSolverInterface * solver, double xB[2], double yB[2], double xybar[4]) const;
    /// Compute lambdas (third entry in each .B is current value) (nonzero if bad)
    double computeLambdas(const double xB[3], const double yB[3], const double xybar[4], double lambda[4]) const;
    /// Adds in data for extra row with variable coefficients
    void addExtraRow(int row, double multiplier);
    /// Sets infeasibility and other when pseudo shadow prices
    void getPseudoShadow(const OsiBranchingInformation * info);
    /// Gets sum of movements to correct value
    double getMovement(const OsiBranchingInformation * info);

protected:
    /// Compute lambdas if coefficients not changing
    void computeLambdas(const OsiSolverInterface * solver, double lambda[4]) const;
    /// data

    /// Coefficient
    double coefficient_;
    /// x mesh
    double xMeshSize_;
    /// y mesh
    double yMeshSize_;
    /// x satisfied if less than this away from mesh
    double xSatisfied_;
    /// y satisfied if less than this away from mesh
    double ySatisfied_;
    /// X other satisfied if less than this away from mesh
    double xOtherSatisfied_;
    /// Y other satisfied if less than this away from mesh
    double yOtherSatisfied_;
    /// xy satisfied if less than this away from true
    double xySatisfied_;
    /// value of x or y to branch about
    mutable double xyBranchValue_;
    /// x column
    int xColumn_;
    /// y column
    int yColumn_;
    /// First lambda (of 4)
    int firstLambda_;
    /** branching strategy etc
        bottom 2 bits
        0 branch on either, 1 branch on x, 2 branch on y
        next bit
        4 set to say don't update coefficients
        next bit
        8 set to say don't use in feasible region
        next bit
        16 set to say - Always satisfied !!
    */
    int branchingStrategy_;
    /** Simple quadratic bound marker.
        0 no
        1 L if coefficient pos, G if negative i.e. value is ub on xy
        2 G if coefficient pos, L if negative i.e. value is lb on xy
        3 E
        If bound then real coefficient is 1.0 and coefficient_ is bound
    */
    int boundType_;
    /// x row
    int xRow_;
    /// y row (-1 if x*x)
    int yRow_;
    /// Output row
    int xyRow_;
    /// Convexity row
    int convexity_;
    /// Number of extra rows (coefficients to be modified)
    int numberExtraRows_;
    /// Multiplier for coefficient on row
    double * multiplier_;
    /// Row number
    int * extraRow_;
    /// Which chosen -1 none, 0 x, 1 y
    mutable short chosen_;
};
/** Branching object for BiLinear objects

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

    /// Clone
    virtual OsiBranchingObject * clone() const;

    // Destructor
    virtual ~OsiBiLinearBranchingObject ();

    using OsiBranchingObject::branch ;
    /// Does next branch and updates state
    virtual double branch(OsiSolverInterface * solver);

    using OsiBranchingObject::print ;
    /** \brief Print something about branch - only if log level high
    */
    virtual void print(const OsiSolverInterface * solver = NULL);
    /** \brief Return true if branch should only bound variables
    */
    virtual bool boundBranch() const;
private:
    /// data
    /// 1 means branch on x, 2 branch on y
    short chosen_;
};
/** Define Continuous BiLinear objects for an == bound

    This models x*y = b where both are continuous

*/


class OsiBiLinearEquality : public OsiBiLinear {

public:

    // Default Constructor
    OsiBiLinearEquality ();

    /** Useful constructor -
        This Adds in rows and variables to construct Ordered Set
        for x*y = b
        So note not const solver
    */
    OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
                         int yColumn, int xyRow, double rhs,
                         double xMesh);

    // Copy constructor
    OsiBiLinearEquality ( const OsiBiLinearEquality &);

    /// Clone
    virtual OsiObject * clone() const;

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

    // Destructor
    virtual ~OsiBiLinearEquality ();

    /// Possible improvement
    virtual double improvement(const OsiSolverInterface * solver) const;
    /** change grid
        if type 0 then use solution and make finer
        if 1 then back to original
        returns mesh size
    */
    double newGrid(OsiSolverInterface * solver, int type) const;
    /// Number of points
    inline int numberPoints() const {
        return numberPoints_;
    }
    inline void setNumberPoints(int value) {
        numberPoints_ = value;
    }

private:
    /// Number of points
    int numberPoints_;
};
/// Define a single integer class - but one where you keep branching until fixed even if satisfied


class OsiSimpleFixedInteger : public OsiSimpleInteger {

public:

    /// Default Constructor
    OsiSimpleFixedInteger ();

    /// Useful constructor - passed solver index
    OsiSimpleFixedInteger (const OsiSolverInterface * solver, int iColumn);

    /// Useful constructor - passed solver index and original bounds
    OsiSimpleFixedInteger (int iColumn, double lower, double upper);

    /// Useful constructor - passed simple integer
    OsiSimpleFixedInteger (const OsiSimpleInteger &);

    /// Copy constructor
    OsiSimpleFixedInteger ( const OsiSimpleFixedInteger &);

    /// Clone
    virtual OsiObject * clone() const;

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

    /// Destructor
    virtual ~OsiSimpleFixedInteger ();

    using OsiObject::infeasibility ;
    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

    /** Creates a branching object

      The preferred direction is set by \p way, 0 for down, 1 for up.
    */
    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
protected:
    /// data

};
/** Define a single variable class which is involved with OsiBiLinear objects.
    This is used so can make better decision on where to branch as it can look at
    all objects.

    This version sees if it can re-use code from OsiSimpleInteger
    even if not an integer variable.  If not then need to duplicate code.
*/


class OsiUsesBiLinear : public OsiSimpleInteger {

public:

    /// Default Constructor
    OsiUsesBiLinear ();

    /// Useful constructor - passed solver index
    OsiUsesBiLinear (const OsiSolverInterface * solver, int iColumn, int type);

    /// Useful constructor - passed solver index and original bounds
    OsiUsesBiLinear (int iColumn, double lower, double upper, int type);

    /// Useful constructor - passed simple integer
    OsiUsesBiLinear (const OsiSimpleInteger & rhs, int type);

    /// Copy constructor
    OsiUsesBiLinear ( const OsiUsesBiLinear & rhs);

    /// Clone
    virtual OsiObject * clone() const;

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

    /// Destructor
    virtual ~OsiUsesBiLinear ();

    using OsiObject::infeasibility ;
    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

    /** Creates a branching object

      The preferred direction is set by \p way, 0 for down, 1 for up.
    */
    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

    using OsiObject::feasibleRegion ;
    /** Set bounds to fix the variable at the current value.

      Given an current value, set the lower and upper bounds to fix the
      variable. Returns amount it had to move variable.
    */
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    /// Add all bi-linear objects
    void addBiLinearObjects(OsiSolverLink * solver);
protected:
    /// data
    /// Number of bilinear objects (maybe could be more general)
    int numberBiLinear_;
    /// Type of variable - 0 continuous, 1 integer
    int type_;
    /// Objects
    OsiObject ** objects_;
};
/** This class chooses a variable to branch on

    This is just as OsiChooseStrong but it fakes it so only
    first so many are looked at in this phase

*/

class OsiChooseStrongSubset  : public OsiChooseStrong {

public:

    /// Default Constructor
    OsiChooseStrongSubset ();

    /// Constructor from solver (so we can set up arrays etc)
    OsiChooseStrongSubset (const OsiSolverInterface * solver);

    /// Copy constructor
    OsiChooseStrongSubset (const OsiChooseStrongSubset &);

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

    /// Clone
    virtual OsiChooseVariable * clone() const;

    /// Destructor
    virtual ~OsiChooseStrongSubset ();

    /** Sets up strong list and clears all if initialize is true.
        Returns number of infeasibilities.
        If returns -1 then has worked out node is infeasible!
    */
    virtual int setupList ( OsiBranchingInformation *info, bool initialize);
    /** Choose a variable
        Returns -
       -1 Node is infeasible
       0  Normal termination - we have a candidate
       1  All looks satisfied - no candidate
       2  We can change the bound on a variable - but we also have a strong branching candidate
       3  We can change the bound on a variable - but we have a non-strong branching candidate
       4  We can change the bound on a variable - no other candidates
       We can pick up branch from bestObjectIndex() and bestWhichWay()
       We can pick up a forced branch (can change bound) from firstForcedObjectIndex() and firstForcedWhichWay()
       If we have a solution then we can pick up from goodObjectiveValue() and goodSolution()
       If fixVariables is true then 2,3,4 are all really same as problem changed
    */
    virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);

    /// Number of objects to use
    inline int numberObjectsToUse() const {
        return numberObjectsToUse_;
    }
    /// Set number of objects to use
    inline void setNumberObjectsToUse(int value) {
        numberObjectsToUse_ = value;
    }

protected:
    // Data
    /// Number of objects to be used (and set in solver)
    int numberObjectsToUse_;
};

#include <string>

#include "CglStored.hpp"

class CoinWarmStartBasis;
/** Stored Temporary Cut Generator Class - destroyed after first use */
class CglTemporary : public CglStored {

public:


    /**@name Generate Cuts */
    //@{
    /** Generate Mixed Integer Stored cuts for the model of the
        solver interface, si.

        Insert the generated cuts into OsiCut, cs.

        This generator just looks at previously stored cuts
        and inserts any that are violated by enough
    */
    virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
                               const CglTreeInfo info = CglTreeInfo());
    //@}

    /**@name Constructors and destructors */
    //@{
    /// Default constructor
    CglTemporary ();

    /// Copy constructor
    CglTemporary (const CglTemporary & rhs);

    /// Clone
    virtual CglCutGenerator * clone() const;

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

    /// Destructor
    virtual
    ~CglTemporary ();
    //@}

private:

// Private member methods

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

/**

This is to allow the user to replace initialSolve and resolve
*/

class OsiSolverLinearizedQuadratic : public OsiClpSolverInterface {

public:
    //---------------------------------------------------------------------------
    /**@name Solve methods */
    //@{
    /// Solve initial LP relaxation
    virtual void initialSolve();
    //@}


    /**@name Constructors and destructors */
    //@{
    /// Default Constructor
    OsiSolverLinearizedQuadratic ();
    /// Useful constructor (solution should be good)
    OsiSolverLinearizedQuadratic(  ClpSimplex * quadraticModel);
    /// Clone
    virtual OsiSolverInterface * clone(bool copyData = true) const;

    /// Copy constructor
    OsiSolverLinearizedQuadratic (const OsiSolverLinearizedQuadratic &);

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

    /// Destructor
    virtual ~OsiSolverLinearizedQuadratic ();

    //@}


    /**@name Sets and Gets */
    //@{
    /// Objective value of best solution found internally
    inline double bestObjectiveValue() const {
        return bestObjectiveValue_;
    }
    /// Best solution found internally
    const double * bestSolution() const {
        return bestSolution_;
    }
    /// Set special options
    inline void setSpecialOptions3(int value) {
        specialOptions3_ = value;
    }
    /// Get special options
    inline int specialOptions3() const {
        return specialOptions3_;
    }
    /// Copy of quadratic model if one
    ClpSimplex * quadraticModel() const {
        return quadraticModel_;
    }
    //@}

    //---------------------------------------------------------------------------

protected:


    /**@name functions */
    //@{

    /**@name Private member data */
    //@{
    /// Objective value of best solution found internally
    double bestObjectiveValue_;
    /// Copy of quadratic model if one
    ClpSimplex * quadraticModel_;
    /// Best solution found internally
    double * bestSolution_;
    /**
       0 bit (1) - don't do mini B&B
       1 bit (2) - quadratic only in objective
    */
    int specialOptions3_;
    //@}
};
class ClpSimplex;
/** Return an approximate solution to a CoinModel.
    Lots of bounds may be odd to force a solution.
    mode = 0 just tries to get a continuous solution
*/
ClpSimplex * approximateSolution(CoinModel & coinModel,
                                 int numberPasses, double deltaTolerance,
                                 int mode = 0);
#endif