Structure updated and intqpipopt files added

1 files changed, 0 insertions, 1406 deletions

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