ruby-cbc 0.1.9

data/ext/ruby-cbc/install/include/coin/CbcHeuristicDINS.hpp

@@ -0,0 +1,96 @@
+// $Id: CbcHeuristicDINS.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).
+
+// edwin 12/5/09 carved out of CbcHeuristicRINS
+
+#ifndef CbcHeuristicDINS_H
+#define CbcHeuristicDINS_H
+
+#include "CbcHeuristic.hpp"
+
+
+class CbcHeuristicDINS : public CbcHeuristic {
+public:
+
+    // Default Constructor
+    CbcHeuristicDINS ();
+
+    /* Constructor with model - assumed before cuts
+       Initial version does not do Lps
+    */
+    CbcHeuristicDINS (CbcModel & model);
+
+    // Copy constructor
+    CbcHeuristicDINS ( const CbcHeuristicDINS &);
+
+    // Destructor
+    ~CbcHeuristicDINS ();
+
+    /// Clone
+    virtual CbcHeuristic * clone() const;
+
+
+    /// Assignment operator
+    CbcHeuristicDINS & operator=(const CbcHeuristicDINS& 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);
+    /// This version fixes stuff and does IP
+    int solutionFix(double & objectiveValue,
+                    double * newSolution,
+                    const int * keep);
+
+    /// Sets how often to do it
+    inline void setHowOften(int value) {
+        howOften_ = value;
+    }
+    /// Sets maximum number of solutions kept
+    inline void setMaximumKeep(int value) {
+        maximumKeepSolutions_ = value;
+    }
+    /// Sets tightness of extra constraint
+    inline void setConstraint(int value) {
+        localSpace_ = value;
+    }
+
+protected:
+    // Data
+
+    /// Number of solutions so we can do something at solution
+    int numberSolutions_;
+    /// How often to do (code can change)
+    int howOften_;
+    /// Number of successes
+    int numberSuccesses_;
+    /// Number of tries
+    int numberTries_;
+    /// Maximum number of solutions to keep
+    int maximumKeepSolutions_;
+    /// Number of solutions kept
+    int numberKeptSolutions_;
+    /// Number of integer variables
+    int numberIntegers_;
+    /// Local parameter
+    int localSpace_;
+    /// Values of integer variables
+    int ** values_;
+};
+
+#endif
+

data/ext/ruby-cbc/install/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

data/ext/ruby-cbc/install/include/coin/CbcHeuristicDive.hpp

@@ -0,0 +1,192 @@
+/* $Id: CbcHeuristicDive.hpp 2093 2014-11-06 16:17:38Z forrest $ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcHeuristicDive_H
+#define CbcHeuristicDive_H
+
+#include "CbcHeuristic.hpp"
+class CbcSubProblem;
+class OsiRowCut;
+struct PseudoReducedCost {
+    int var;
+    double pseudoRedCost;
+};
+
+
+/** Dive class
+ */
+
+class CbcHeuristicDive : public CbcHeuristic {
+public:
+
+    // Default Constructor
+    CbcHeuristicDive ();
+
+    // Constructor with model - assumed before cuts
+    CbcHeuristicDive (CbcModel & model);
+
+    // Copy constructor
+    CbcHeuristicDive ( const CbcHeuristicDive &);
+
+    // Destructor
+    ~CbcHeuristicDive ();
+
+    /// Clone
+    virtual CbcHeuristicDive * clone() const = 0;
+
+    /// Assignment operator
+    CbcHeuristicDive & operator=(const CbcHeuristicDive& rhs);
+
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * ) {}
+
+    /// Create C++ lines to get to current state - does work for base class
+    void generateCpp( FILE * fp, const char * heuristic);
+
+    /// 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);
+
+    //  REMLOVE using CbcHeuristic::solution ;
+    /** returns 0 if no solution, 1 if valid solution
+        with better objective value than one passed in
+        Sets solution values if good, sets objective value (only if good)
+        This is called after cuts have been added - so can not add cuts
+        This does Fractional Diving
+    */
+    virtual int solution(double & objectiveValue,
+                         double * newSolution);
+    /// inner part of dive
+    int solution(double & objectiveValue, int & numberNodes,
+		 int & numberCuts, OsiRowCut ** cuts,
+		 CbcSubProblem ** & nodes,
+		 double * newSolution);
+    /** returns 0 if no solution, 1 if valid solution
+        with better objective value than one passed in
+	also returns list of nodes
+        This does Fractional Diving
+    */
+    int fathom(CbcModel * model, int & numberNodes,CbcSubProblem ** & nodes);
+
+    /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
+    virtual void validate();
+
+    /// Sets priorities if any
+    void setPriorities();
+
+    /// Select candidate binary variables for fixing
+    void selectBinaryVariables();
+
+    /// Set percentage of integer variables to fix at bounds
+    void setPercentageToFix(double value) {
+        percentageToFix_ = value;
+    }
+
+    /// Set maximum number of iterations
+    void setMaxIterations(int value) {
+        maxIterations_ = value;
+    }
+
+    /// Set maximum number of simplex iterations
+    void setMaxSimplexIterations(int value) {
+        maxSimplexIterations_ = value;
+    }
+    /// Get maximum number of simplex iterations
+    inline int maxSimplexIterations() const {
+        return maxSimplexIterations_;
+    }
+
+    /// Set maximum number of simplex iterations at root node
+    void setMaxSimplexIterationsAtRoot(int value) {
+        maxSimplexIterationsAtRoot_ = value;
+    }
+
+    /// Set maximum time allowed
+    void setMaxTime(double value) {
+        maxTime_ = value;
+    }
+
+    /// Tests if the heuristic can run
+    virtual bool canHeuristicRun();
+
+    /** Selects the next variable to branch on
+        Returns true if all the fractional variables can be trivially
+        rounded. Returns false, if there is at least one fractional variable
+        that is not trivially roundable. In this case, the bestColumn
+        returned will not be trivially roundable.
+    */
+    virtual bool selectVariableToBranch(OsiSolverInterface* solver,
+                                        const double* newSolution,
+                                        int& bestColumn,
+                                        int& bestRound) = 0;
+    /** Initializes any data which is going to be used repeatedly
+        in selectVariableToBranch */
+    virtual void initializeData() {}
+
+    /// Perform reduced cost fixing on integer variables
+    int reducedCostFix (OsiSolverInterface* solver);
+    /// Fix other variables at bounds
+    virtual int fixOtherVariables(OsiSolverInterface * solver,
+                                  const double * solution,
+                                  PseudoReducedCost * candidate,
+                                  const double * random);
+
+protected:
+    // Data
+
+    // Original matrix by column
+    CoinPackedMatrix matrix_;
+
+    // Original matrix by
+    CoinPackedMatrix matrixByRow_;
+
+    // Down locks
+    unsigned short * downLocks_;
+
+    // Up locks
+    unsigned short * upLocks_;
+
+    /// Extra down array (number Integers long)
+    double * downArray_;
+
+    /// Extra up array (number Integers long)
+    double * upArray_;
+
+    /// Array of priorities
+    typedef struct {
+      unsigned int direction:3; //  0 bit off, 1 bit (0 down first, 1 up first) 2 bit non zero don't try other way
+      unsigned int priority:29;
+    } PriorityType;
+    PriorityType * priority_;
+    // Indexes of binary variables with 0 objective coefficient
+    // and in variable bound constraints
+    std::vector<int> binVarIndex_;
+
+    // Indexes of variable bound rows for each binary variable
+    std::vector<int> vbRowIndex_;
+
+    // Percentage of integer variables to fix at bounds
+    double percentageToFix_;
+
+    // Maximum time allowed
+    double maxTime_;
+
+    // Small objective (i.e. treat zero objective as this)
+    double smallObjective_;
+
+    // Maximum number of major iterations
+    int maxIterations_;
+
+    // Maximum number of simplex iterations
+    int maxSimplexIterations_;
+
+    // Maximum number of simplex iterations at root node
+    int maxSimplexIterationsAtRoot_;
+
+};
+#endif
+

data/ext/ruby-cbc/install/include/coin/CbcHeuristicDiveCoefficient.hpp

@@ -0,0 +1,52 @@
+/* $Id: CbcHeuristicDiveCoefficient.hpp 1899 2013-04-09 18:12:08Z stefan $ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcHeuristicDiveCoefficient_H
+#define CbcHeuristicDiveCoefficient_H
+
+#include "CbcHeuristicDive.hpp"
+
+/** DiveCoefficient class
+ */
+
+class CbcHeuristicDiveCoefficient : public CbcHeuristicDive {
+public:
+
+    // Default Constructor
+    CbcHeuristicDiveCoefficient ();
+
+    // Constructor with model - assumed before cuts
+    CbcHeuristicDiveCoefficient (CbcModel & model);
+
+    // Copy constructor
+    CbcHeuristicDiveCoefficient ( const CbcHeuristicDiveCoefficient &);
+
+    // Destructor
+    ~CbcHeuristicDiveCoefficient ();
+
+    /// Clone
+    virtual CbcHeuristicDiveCoefficient * clone() const;
+
+    /// Assignment operator
+    CbcHeuristicDiveCoefficient & operator=(const CbcHeuristicDiveCoefficient& rhs);
+
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp) ;
+
+    /// Selects the next variable to branch on
+    /** Returns true if all the fractional variables can be trivially
+        rounded. Returns false, if there is at least one fractional variable
+        that is not trivially roundable. In this case, the bestColumn
+        returned will not be trivially roundable.
+    */
+    virtual bool selectVariableToBranch(OsiSolverInterface* solver,
+                                        const double* newSolution,
+                                        int& bestColumn,
+                                        int& bestRound);
+
+};
+
+#endif
+

data/ext/ruby-cbc/install/include/coin/CbcHeuristicDiveFractional.hpp

@@ -0,0 +1,52 @@
+/* $Id: CbcHeuristicDiveFractional.hpp 1899 2013-04-09 18:12:08Z stefan $ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcHeuristicDiveFractional_H
+#define CbcHeuristicDiveFractional_H
+
+#include "CbcHeuristicDive.hpp"
+
+/** DiveFractional class
+ */
+
+class CbcHeuristicDiveFractional : public CbcHeuristicDive {
+public:
+
+    // Default Constructor
+    CbcHeuristicDiveFractional ();
+
+    // Constructor with model - assumed before cuts
+    CbcHeuristicDiveFractional (CbcModel & model);
+
+    // Copy constructor
+    CbcHeuristicDiveFractional ( const CbcHeuristicDiveFractional &);
+
+    // Destructor
+    ~CbcHeuristicDiveFractional ();
+
+    /// Clone
+    virtual CbcHeuristicDiveFractional * clone() const;
+
+    /// Assignment operator
+    CbcHeuristicDiveFractional & operator=(const CbcHeuristicDiveFractional& rhs);
+
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp) ;
+
+    /// Selects the next variable to branch on
+    /** Returns true if all the fractional variables can be trivially
+        rounded. Returns false, if there is at least one fractional variable
+        that is not trivially roundable. In this case, the bestColumn
+        returned will not be trivially roundable.
+    */
+    virtual bool selectVariableToBranch(OsiSolverInterface* solver,
+                                        const double* newSolution,
+                                        int& bestColumn,
+                                        int& bestRound);
+
+};
+
+#endif
+