From a0d9443af147e949c1e6a01ac24749d12593ec5b Mon Sep 17 00:00:00 2001 From: Harpreet Date: Sat, 3 Sep 2016 00:36:51 +0530 Subject: cbcintlinprog added --- thirdparty/linux/include/coin/CbcSimpleInteger.hpp | 286 +++++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 thirdparty/linux/include/coin/CbcSimpleInteger.hpp (limited to 'thirdparty/linux/include/coin/CbcSimpleInteger.hpp') diff --git a/thirdparty/linux/include/coin/CbcSimpleInteger.hpp b/thirdparty/linux/include/coin/CbcSimpleInteger.hpp new file mode 100644 index 0000000..cde7d8c --- /dev/null +++ b/thirdparty/linux/include/coin/CbcSimpleInteger.hpp @@ -0,0 +1,286 @@ +// $Id: CbcSimpleInteger.hpp 1943 2013-07-21 09:05:45Z forrest $ +// Copyright (C) 2002, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +// Edwin 11/9/2009-- carved out of CbcBranchActual + +#ifndef CbcSimpleInteger_H +#define CbcSimpleInteger_H + +#include "CbcBranchingObject.hpp" + +/** Simple branching object for an integer variable + + This object can specify a two-way branch on an integer variable. For each + arm of the branch, the upper and lower bounds on the variable can be + independently specified. + + Variable_ holds the index of the integer variable in the integerVariable_ + array of the model. +*/ + +class CbcIntegerBranchingObject : public CbcBranchingObject { + +public: + + /// Default constructor + CbcIntegerBranchingObject (); + + /** Create a standard floor/ceiling branch object + + Specifies a simple two-way branch. Let \p value = x*. One arm of the + branch will be lb <= x <= floor(x*), the other ceil(x*) <= x <= ub. + Specify way = -1 to set the object state to perform the down arm first, + way = 1 for the up arm. + */ + CbcIntegerBranchingObject (CbcModel *model, int variable, + int way , double value) ; + + /** Create a degenerate branch object + + Specifies a `one-way branch'. Calling branch() for this object will + always result in lowerValue <= x <= upperValue. Used to fix a variable + when lowerValue = upperValue. + */ + + CbcIntegerBranchingObject (CbcModel *model, int variable, int way, + double lowerValue, double upperValue) ; + + /// Copy constructor + CbcIntegerBranchingObject ( const CbcIntegerBranchingObject &); + + /// Assignment operator + CbcIntegerBranchingObject & operator= (const CbcIntegerBranchingObject& rhs); + + /// Clone + virtual CbcBranchingObject * clone() const; + + /// Destructor + virtual ~CbcIntegerBranchingObject (); + + /// Does part of constructor + void fillPart ( int variable, int way , double value) ; + using CbcBranchingObject::branch ; + /** \brief Sets the bounds for the variable according to the current arm + of the branch and advances the object state to the next arm. + Returns change in guessed objective on next branch + */ + virtual double branch(); + /** Update bounds in solver as in 'branch' and update given bounds. + branchState is -1 for 'down' +1 for 'up' */ + virtual void fix(OsiSolverInterface * solver, + double * lower, double * upper, + int branchState) const ; + /** Change (tighten) bounds in object to reflect bounds in solver. + Return true if now fixed */ + virtual bool tighten(OsiSolverInterface * ) ; + +#ifdef JJF_ZERO + // No need to override. Default works fine. + /** Reset every information so that the branching object appears to point to + the previous child. This method does not need to modify anything in any + solver. */ + virtual void previousBranch(); +#endif + + using CbcBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print(); + + /// Lower and upper bounds for down branch + inline const double * downBounds() const { + return down_; + } + /// Lower and upper bounds for up branch + inline const double * upBounds() const { + return up_; + } + /// Set lower and upper bounds for down branch + inline void setDownBounds(const double bounds[2]) { + memcpy(down_, bounds, 2*sizeof(double)); + } + /// Set lower and upper bounds for up branch + inline void setUpBounds(const double bounds[2]) { + memcpy(up_, bounds, 2*sizeof(double)); + } +#ifdef FUNNY_BRANCHING + /** Which variable (top bit if upper bound changing, + next bit if on down branch */ + inline const int * variables() const { + return variables_; + } + // New bound + inline const double * newBounds() const { + return newBounds_; + } + /// Number of bound changes + inline int numberExtraChangedBounds() const { + return numberExtraChangedBounds_; + } + /// Just apply extra bounds to one variable - COIN_DBL_MAX ignore + int applyExtraBounds(int iColumn, double lower, double upper, int way) ; + /// Deactivate bounds for branching + void deactivate(); + /// Are active bounds for branching + inline bool active() const { + return (down_[1] != -COIN_DBL_MAX); + } +#endif + + /** Return the type (an integer identifier) of \c this */ + virtual CbcBranchObjType type() const { + return SimpleIntegerBranchObj; + } + + /** Compare the \c this with \c brObj. \c this and \c brObj must be os the + same type and must have the same original object, but they may have + different feasible regions. + Return the appropriate CbcRangeCompare value (first argument being the + sub/superset if that's the case). In case of overlap (and if \c + replaceIfOverlap is true) replace the current branching object with one + whose feasible region is the overlap. + */ + virtual CbcRangeCompare compareBranchingObject + (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false); + +protected: + /// Lower [0] and upper [1] bounds for the down arm (way_ = -1) + double down_[2]; + /// Lower [0] and upper [1] bounds for the up arm (way_ = 1) + double up_[2]; +#ifdef FUNNY_BRANCHING + /** Which variable (top bit if upper bound changing) + next bit if changing on down branch only */ + int * variables_; + // New bound + double * newBounds_; + /// Number of Extra bound changes + int numberExtraChangedBounds_; +#endif +}; + +/// Define a single integer class + + +class CbcSimpleInteger : public CbcObject { + +public: + + // Default Constructor + CbcSimpleInteger (); + + // Useful constructor - passed model and index + CbcSimpleInteger (CbcModel * model, int iColumn, double breakEven = 0.5); + + // Useful constructor - passed model and Osi object + CbcSimpleInteger (CbcModel * model, const OsiSimpleInteger * object); + + // Copy constructor + CbcSimpleInteger ( const CbcSimpleInteger &); + + /// Clone + virtual CbcObject * clone() const; + + // Assignment operator + CbcSimpleInteger & operator=( const CbcSimpleInteger& rhs); + + // Destructor + virtual ~CbcSimpleInteger (); + /// Construct an OsiSimpleInteger object + OsiSimpleInteger * osiObject() const; + /// Infeasibility - large is 0.5 + virtual double infeasibility(const OsiBranchingInformation * info, + int &preferredWay) const; + + using CbcObject::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; + + /** Create a branching object and indicate which way to branch first. + + The branching object has to know how to create branches (fix + variables, etc.) + */ + virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ; + /// Fills in a created branching object + /*virtual*/ void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ; + + using CbcObject::solverBranch ; + /** Create an OsiSolverBranch object + + This returns NULL if branch not represented by bound changes + */ + virtual OsiSolverBranch * solverBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info) const; + + /** 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. The algorithm takes a bit of care in order to compensate for + minor numerical inaccuracy. + */ + virtual void feasibleRegion(); + + /** Column number if single column object -1 otherwise, + so returns >= 0 + Used by heuristics + */ + virtual int columnNumber() const; + /// Set column number + inline void setColumnNumber(int value) { + columnNumber_ = value; + } + + /** Reset variable bounds to their original values. + + Bounds may be tightened, so it may be good to be able to set this info in object. + */ + virtual void resetBounds(const OsiSolverInterface * solver) ; + + /** Change column numbers after preprocessing + */ + virtual void resetSequenceEtc(int numberColumns, const int * originalColumns) ; + /// Original bounds + inline double originalLowerBound() const { + return originalLower_; + } + inline void setOriginalLowerBound(double value) { + originalLower_ = value; + } + inline double originalUpperBound() const { + return originalUpper_; + } + inline void setOriginalUpperBound(double value) { + originalUpper_ = value; + } + /// Breakeven e.g 0.7 -> >= 0.7 go up first + inline double breakEven() const { + return breakEven_; + } + /// Set breakeven e.g 0.7 -> >= 0.7 go up first + inline void setBreakEven(double value) { + breakEven_ = value; + } + + +protected: + /// data + + /// Original lower bound + double originalLower_; + /// Original upper bound + double originalUpper_; + /// Breakeven i.e. >= this preferred is up + double breakEven_; + /// Column number in model + int columnNumber_; + /// If -1 down always chosen first, +1 up always, 0 normal + int preferredWay_; +}; +#endif + -- cgit