casadi 3.7.2__cp314-none-win_amd64.whl

casadi/include/coin/CbcLinked.hpp

@@ -0,0 +1,1443 @@
+/* $Id$ */
+// 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);
+  //@}
+
+protected:
+  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;
+  }
+
+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;
+  }
+
+protected:
+  /// 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;
+  }
+
+protected:
+  /// 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;
+
+protected:
+  /// 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;
+  }
+
+protected:
+  /// 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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/