initial add

1 files changed, 309 insertions, 0 deletions

diff --git a/build/Bonmin/include/coin/CbcHeuristicDW.hpp b/build/Bonmin/include/coin/CbcHeuristicDW.hpp
new file mode 100644
index 0000000..337bd0f
--- /dev/null
+++ b/build/Bonmin/include/coin/CbcHeuristicDW.hpp
@@ -0,0 +1,309 @@
+// $Id: CbcHeuristicDW.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 CbcHeuristicDW_H
+#define CbcHeuristicDW_H
+
+#include "CbcHeuristic.hpp"
+
+/** 
+    This is unlike the other heuristics in that it is very very compute intensive.
+    It tries to find a DW structure and use that
+ */
+
+class CbcHeuristicDW : public CbcHeuristic {
+public:
+
+    // Default Constructor
+    CbcHeuristicDW ();
+
+    /* Constructor with model - assumed before cuts
+    */
+    CbcHeuristicDW (CbcModel & model, int keepContinuous=0);
+
+    /* Constructor with model - assumed before cuts
+    */
+    CbcHeuristicDW (CbcModel & model,
+		    int callBack(CbcHeuristicDW * currentHeuristic,
+				 CbcModel * thisModel,
+				 int whereFrom),
+		    int keepContinuous=0);
+
+    // Copy constructor
+    CbcHeuristicDW ( const CbcHeuristicDW &);
+
+    // Destructor
+    ~CbcHeuristicDW ();
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+
+    /// Assignment operator
+    CbcHeuristicDW & operator=(const CbcHeuristicDW& 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 does Relaxation Induced Neighborhood Search
+    */
+    virtual int solution(double & objectiveValue,
+                         double * newSolution);
+    /** Return number of blocks
+      <=0 - no usable structure */
+    inline int numberBlocks() const
+    { return numberBlocks_;}
+    /// Pass in a solution
+    void passInSolution(const double * solution);
+    /// Pass in continuous solution
+    void passInContinuousSolution(const double * solution);
+    /** DW Proposal actions
+        fullDWEverySoOften -
+        0 - off
+        k - every k times solution gets better
+     */
+    void setProposalActions(int fullDWEverySoOften);
+    /// Objective value when whichDw created
+    double objectiveValueWhen(int whichDW) const;
+    /// Number of columns in DW
+    int numberColumnsDW(int whichDW) const;
+    /// Solver
+    inline OsiSolverInterface * solver() const
+    { return solver_;}
+    /// DW model (user must delete)
+    OsiSolverInterface * DWModel(int whichDW) const;
+    /// Best objective value
+    inline double bestObjective() const
+    { return bestObjective_;}
+    /// Best solution found so far
+    inline const double * bestSolution() const
+    { return bestSolution_;}
+    /// Continuous solution
+    inline const double * continuousSolution() const
+    { return continuousSolution_;}
+    /// Reduced costs of fixed solution
+    inline const double * fixedDj() const
+    { return fixedDj_;}
+    /// Objective at which DW updated
+    inline const double * objectiveDW() const
+    { return objectiveDW_;}
+    /// Number of times we have added to DW model
+    inline int numberDWTimes() const
+    { return numberDWTimes_;}
+    /// Number of columns in DW
+    inline const int * numberColumnsDW() const
+    { return numberColumnsDW_;}
+    /// Set number of passes
+    inline void setNumberPasses(int value)
+    { numberPasses_ = value;}
+    /// Set number of passes without better solution
+    inline void setNumberBadPasses(int value)
+    { numberBadPasses_ = value;}
+    /// Set number free integers needed (Base value)
+    inline void setNumberNeeded(int value)
+    { nNeededBase_ = value;}
+    /// Get number free integers needed (Base value)
+    inline int getNumberNeeded() const
+    {return nNeededBase_;}
+    /// Set number free integers needed (Current value)
+    inline void setCurrentNumberNeeded(int value)
+    { nNeeded_ = value;}
+    /// Get number free integers needed (Current value)
+    inline int getCurrentNumberNeeded() const
+    {return nNeeded_;}
+    /// Set number nodes (could be done in callback) (Base value)
+    inline void setNumberNodes(int value)
+    { nNodesBase_ = value;}
+    /// Get number nodes (could be done in callback) (Base value)
+    inline int getNumberNodes() const
+    {return nNodesBase_;}
+    /// Set number nodes (could be done in callback) (Current value)
+    inline void setCurrentNumberNodes(int value)
+    { nNodes_ = value;}
+    /// Get number nodes (could be done in callback) (Current value)
+    inline int getCurrentNumberNodes() const
+    {return nNodes_;}
+    /// Set target objective
+    inline void setTargetObjective(double value)
+    { targetObjective_ = value;}
+    /// Sets how often to do it
+    inline void setHowOften(int value) {
+        howOften_ = value;
+    }
+    /// Block for every row
+    inline const int * whichRowBlock() const
+    { return whichRowBlock_;}
+    /// Block for every column
+    inline const int * whichColumnBlock() const
+    { return whichColumnBlock_;}
+    /// Initial Lower bounds
+    inline double * initialLower() const
+    { return saveLower_;}
+    /// Initial Upper bounds
+    inline double * initialUpper() const
+    { return saveUpper_;}
+    /// Local integer arrays (each numberBlocks_ long)
+    inline int * intArrays() const
+    { return intArray_;}
+    /// Local double arrays (each numberBlocks_ long)
+    inline double * doubleArrays() const
+    { return doubleArray_;}
+    /// Phase of solution
+    inline int phase() const
+    { return phase_;}
+    /// Pass number
+    inline int pass() const
+    { return pass_;}
+    /// Which columns are in block
+    inline const int * columnsInBlock() const
+    { return columnsInBlock_;}
+    /// Starts for columnsInBlock
+    inline const int * startColumnBlock() const
+    { return startColumnBlock_;}
+    /// Number of integer variables in each block
+    inline const int * intsInBlock() const
+    { return intsInBlock_;}
+    /// Objective value (could also check validity)
+    double objectiveValue(const double * solution);
+private:
+    /// Guts of copy
+    void gutsOfCopy(const CbcHeuristicDW & rhs);
+    /// Guts of delete
+    void gutsOfDelete();
+    /// Set default values
+    void setDefaults();
+    /// Find structure
+    void findStructure();
+    /// Set up DW structure
+    void setupDWStructures();
+    /// Add DW proposals
+    int addDW(const double * solution,int numberBlocksUsed, 
+	      const int * whichBlocks);
+protected:
+    typedef int (*heuristicCallBack) (CbcHeuristicDW * ,CbcModel *, int) ;
+    // Data
+    /// Target objective
+    double targetObjective_;
+    /// Best objective value
+    double bestObjective_;
+    /// Objective value last time
+    double lastObjective_;
+    /** Call back
+	whereFrom -
+	0 - after blocks found but before data setup
+	1 - after blocks sorted but before used
+	2 - just before normal branch and bound
+	3 - after DW has been updated
+	4 - if better solution found
+	5 - every time a block might be used
+	next few for adjustment of nNeeded etc
+	6 - complete search done - no solution
+	7 - stopped on nodes - no improvement
+	8 - improving (same as 4 but after nNeeded changed
+	Pointers to local data given by following pointers
+    */
+    heuristicCallBack functionPointer_;
+    /// Local integer arrays (each numberBlocks_ long)
+    int * intArray_;
+    /// Local double arrays (each numberBlocks_ long)
+    double * doubleArray_;
+    /// Base solver
+    OsiSolverInterface * solver_;
+    /// DW solver
+    OsiSolverInterface * dwSolver_;
+    /// Best solution found so far
+    double * bestSolution_;
+    /// Continuous solution
+    double * continuousSolution_;
+    /// Reduced costs of fixed solution
+    double * fixedDj_;
+    /// Original lower bounds
+    double * saveLower_;
+    /// Original Upper bounds
+    double * saveUpper_;
+    /// random numbers for master rows
+    double * random_;
+    /// Weights for each proposal
+    double * weights_;
+    /// Objective at which DW updated
+    double * objectiveDW_;
+    /// Number of columns in each DW
+    int * numberColumnsDW_;
+    /// Block for every row
+    int * whichRowBlock_;
+    /// Block for every column
+    int * whichColumnBlock_;
+    /// Block number for each proposal
+    int * dwBlock_;
+    /// Points back to master rows
+    int * backwardRow_;
+    /// Which rows are in blocke
+    int * rowsInBlock_;
+    /// Which columns are in block
+    int * columnsInBlock_;
+    /// Starts for rowsInBlock
+    int * startRowBlock_;
+    /// Starts for columnsInBlock
+    int * startColumnBlock_;
+    /// Number of integer variables in each block
+    int * intsInBlock_;
+    /// Bits set for 1 integers in each block 
+    unsigned int * fingerPrint_;
+    /// Affinity each block has for other (will be triangular?)
+    unsigned short * affinity_;
+    /** DW Proposal actions
+        fullDWEverySoOften -
+        0 - off
+        k - every k times solution gets better
+     */
+    int fullDWEverySoOften_;
+    /// Number of passes
+    int numberPasses_;
+    /// How often to do (code can change)
+    int howOften_;
+    /// Current maximum number of DW proposals
+    int maximumDW_;
+    /// Number of DW proposals
+    int numberDW_;
+    /// Number of times we have added to DW model
+    int numberDWTimes_;
+    /// Number of unsigned ints needed for each block of fingerPrint
+    int sizeFingerPrint_;
+    /// Number of columns in master
+    int numberMasterColumns_;
+    /// Number of rows in master
+    int numberMasterRows_;
+    /// Number of blocks
+    int numberBlocks_;
+    /// Action on decomposition - 1 keep continuous, 0 don't
+    int keepContinuous_;
+    /// Phase of solution
+    int phase_;
+    /// Pass number
+    int pass_;
+    /// Base number of integers needed
+    int nNeededBase_;
+    /// Base number of nodes needed
+    int nNodesBase_;
+    /// Base number of integers needed
+    int nNeeded_;
+    /// Base number of nodes needed
+    int nNodes_;
+    /// Number of passes without better solution
+    int numberBadPasses_;
+    // 0 - fine, 1 can't be better, 2 max node
+    int solveState_;
+};
+
+#endif