ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,96 +0,0 @@
-// $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

@@ -1,309 +0,0 @@
-// $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

@@ -1,192 +0,0 @@
-/* $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
-