Structure updated and intqpipopt files added

1 files changed, 1406 insertions, 0 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/CbcLinked.hpp b/newstructure/thirdparty/linux/include/coin/CbcLinked.hpp
new file mode 100644
index 0000000..daa977c
--- /dev/null
+++ b/newstructure/thirdparty/linux/include/coin/CbcLinked.hpp
@@ -0,0 +1,1406 @@
+/* $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;
+/**
+
+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
+