From 4b64cf486f5c999fd8167758cae27839f3b50848 Mon Sep 17 00:00:00 2001 From: Harpreet Date: Sat, 3 Sep 2016 00:34:27 +0530 Subject: Structure updated and intqpipopt files added --- .../linux/include/coin/CbcHeuristicLocal.hpp | 271 +++++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 newstructure/thirdparty/linux/include/coin/CbcHeuristicLocal.hpp (limited to 'newstructure/thirdparty/linux/include/coin/CbcHeuristicLocal.hpp') diff --git a/newstructure/thirdparty/linux/include/coin/CbcHeuristicLocal.hpp b/newstructure/thirdparty/linux/include/coin/CbcHeuristicLocal.hpp new file mode 100644 index 0000000..baed8d5 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/CbcHeuristicLocal.hpp @@ -0,0 +1,271 @@ +/* $Id: CbcHeuristicLocal.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). + +#ifndef CbcHeuristicLocal_H +#define CbcHeuristicLocal_H + +#include "CbcHeuristic.hpp" +/** LocalSearch class + */ + +class CbcHeuristicLocal : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicLocal (); + + /* Constructor with model - assumed before cuts + Initial version does not do Lps + */ + CbcHeuristicLocal (CbcModel & model); + + // Copy constructor + CbcHeuristicLocal ( const CbcHeuristicLocal &); + + // Destructor + ~CbcHeuristicLocal (); + + /// Clone + virtual CbcHeuristic * clone() const; + + /// Assignment operator + CbcHeuristicLocal & operator=(const CbcHeuristicLocal& rhs); + + /// Create C++ lines to get to current state + virtual void generateCpp( FILE * fp) ; + + /// Resets stuff if model changes + virtual void resetModel(CbcModel * model); + + /// update model (This is needed if cliques update matrix etc) + 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) + This is called after cuts have been added - so can not add cuts + First tries setting a variable to better value. If feasible then + tries setting others. If not feasible then tries swaps + + ******** + + This first version does not do LP's and does swaps of two integer + variables. Later versions could do Lps. + */ + virtual int solution(double & objectiveValue, + double * newSolution); + /// This version fixes stuff and does IP + int solutionFix(double & objectiveValue, + double * newSolution, + const int * keep); + + /// Sets type of search + inline void setSearchType(int value) { + swap_ = value; + } + /// Used array so we can set + inline int * used() const { + return used_; + } + +protected: + // Data + + // Original matrix by column + CoinPackedMatrix matrix_; + + // Number of solutions so we only do after new solution + int numberSolutions_; + // Type of search 0=normal, 1=BAB + int swap_; + /// Whether a variable has been in a solution (also when) + int * used_; +}; + +/** Proximity Search class + */ +class CbcHeuristicFPump; +class CbcHeuristicProximity : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicProximity (); + + /* Constructor with model - assumed before cuts + */ + CbcHeuristicProximity (CbcModel & model); + + // Copy constructor + CbcHeuristicProximity ( const CbcHeuristicProximity &); + + // Destructor + ~CbcHeuristicProximity (); + + /// Clone + virtual CbcHeuristic * clone() const; + + /// Assignment operator + CbcHeuristicProximity & operator=(const CbcHeuristicProximity& rhs); + + /// Create C++ lines to get to current state + virtual void generateCpp( FILE * fp) ; + + /// Resets stuff if model changes + virtual void resetModel(CbcModel * model); + + /// update model (This is needed if cliques update matrix etc) + 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) + */ + virtual int solution(double & objectiveValue, + double * newSolution); + /// Set extra increment + inline void setIncrement(double value) + { increment_ = value;} + /// Used array so we can set + inline int * used() const { + return used_; + } + +protected: + // Data + /// Increment to use if no change + double increment_; + /// Copy of Feasibility pump + CbcHeuristicFPump * feasibilityPump_; + /// Number of solutions so we only do after new solution + int numberSolutions_; + /// Whether a variable has been in a solution (also when) + int * used_; +}; + + +/** Naive class + a) Fix all ints as close to zero as possible + b) Fix all ints with nonzero costs and < large to zero + c) Put bounds round continuous and UIs and maximize + */ + +class CbcHeuristicNaive : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicNaive (); + + /* Constructor with model - assumed before cuts + Initial version does not do Lps + */ + CbcHeuristicNaive (CbcModel & model); + + // Copy constructor + CbcHeuristicNaive ( const CbcHeuristicNaive &); + + // Destructor + ~CbcHeuristicNaive (); + + /// Clone + virtual CbcHeuristic * clone() const; + + /// Assignment operator + CbcHeuristicNaive & operator=(const CbcHeuristicNaive& rhs); + + /// Create C++ lines to get to current state + virtual void generateCpp( FILE * fp) ; + + /// Resets stuff if model changes + virtual void resetModel(CbcModel * model); + + /// update model (This is needed if cliques update matrix etc) + 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) + */ + virtual int solution(double & objectiveValue, + double * newSolution); + + /// Sets large cost value + inline void setLargeValue(double value) { + large_ = value; + } + /// Gets large cost value + inline double largeValue() const { + return large_; + } + +protected: + /// Data + /// Large value + double large_; +}; + +/** Crossover Search class + */ + +class CbcHeuristicCrossover : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicCrossover (); + + /* Constructor with model - assumed before cuts + Initial version does not do Lps + */ + CbcHeuristicCrossover (CbcModel & model); + + // Copy constructor + CbcHeuristicCrossover ( const CbcHeuristicCrossover &); + + // Destructor + ~CbcHeuristicCrossover (); + + /// Clone + virtual CbcHeuristic * clone() const; + + /// Assignment operator + CbcHeuristicCrossover & operator=(const CbcHeuristicCrossover& rhs); + + /// Create C++ lines to get to current state + virtual void generateCpp( FILE * fp) ; + + /// Resets stuff if model changes + virtual void resetModel(CbcModel * model); + + /// update model (This is needed if cliques update matrix etc) + virtual void setModel(CbcModel * model); + + using CbcHeuristic::solution ; + /** returns 0 if no solution, 1 if valid solution. + Fix variables if agree in useNumber_ solutions + when_ 0 off, 1 only at new solutions, 2 also every now and then + add 10 to make only if agree at lower bound + */ + virtual int solution(double & objectiveValue, + double * newSolution); + + /// Sets number of solutions to use + inline void setNumberSolutions(int value) { + if (value > 0 && value <= 10) + useNumber_ = value; + } + +protected: + // Data + /// Attempts + std::vector attempts_; + /// Random numbers to stop same search happening + double random_[10]; + /// Number of solutions so we only do after new solution + int numberSolutions_; + /// Number of solutions to use + int useNumber_; +}; + +#endif + -- cgit