ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,39 +0,0 @@
-/* $Id: CbcCompare.hpp 1899 2013-04-09 18:12:08Z stefan $ */
-// 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 CbcCompare_H
-#define CbcCompare_H
-
-class CbcCompareBase;
-
-class CbcCompare {
-public:
-    CbcCompareBase * test_;
-    // Default Constructor
-    CbcCompare () {
-        test_ = NULL;
-    }
-
-    virtual ~CbcCompare() {}
-
-    bool operator() (CbcNode * x, CbcNode * y) {
-        return test_->test(x, y);
-    }
-    bool compareNodes (CbcNode * x, CbcNode * y) {
-        return test_->test(x, y);
-    }
-    /// This is alternate test function
-    inline bool alternateTest (CbcNode * x, CbcNode * y) {
-        return test_->alternateTest(x, y);
-    }
-
-    /// return comparison object
-    inline CbcCompareBase * comparisonObject() const {
-        return test_;
-    }
-};
-
-#endif
-

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

@@ -1,14 +0,0 @@
-/* $Id: CbcCompareActual.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// 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 CbcCompareActual_H
-#define CbcCompareActual_H
-#include "CbcNode.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCompare.hpp"
-#include "CbcCompareDepth.hpp"
-#include "CbcCompareDefault.hpp"
-#endif
-

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

@@ -1,142 +0,0 @@
-/* $Id: CbcCompareBase.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// 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 CbcCompareBase_H
-#define CbcCompareBase_H
-
-
-//#############################################################################
-/*  These are alternative strategies for node traversal.
-    They can take data etc for fine tuning
-
-    At present the node list is stored as a heap and the "test"
-    comparison function returns true if node y is better than node x.
-
-    This is rather inflexible so if the comparison functions wants
-    it can signal to use alternative criterion on a complete pass
-    throgh tree.
-
-*/
-#include "CbcNode.hpp"
-#include "CbcConfig.h"
-
-class CbcModel;
-class CbcTree;
-class CbcCompareBase {
-public:
-    // Default Constructor
-    CbcCompareBase () {
-        test_ = NULL;
-        threaded_ = false;
-    }
-
-    /*! \brief Reconsider behaviour after discovering a new solution.
-    
-      This allows any method to change its behaviour. It is called
-      after each solution.
-
-      The method should return true if changes are made which will
-      alter the evaluation criteria applied to a node. (So that in
-      cases where the search tree is sorted, it can be properly
-      rebuilt.)
-    */
-    virtual bool newSolution(CbcModel * ) { return (false) ; }
-
-    /*! \brief Reconsider behaviour after discovering a new solution.
-    
-      This allows any method to change its behaviour. It is called
-      after each solution.
-
-      The method should return true if changes are made which will
-      alter the evaluation criteria applied to a node. (So that in
-      cases where the search tree is sorted, it can be properly
-      rebuilt.)
-    */
-    virtual bool newSolution(CbcModel * ,
-                             double ,
-                             int ) { return (false) ; }
-
-    // This allows any method to change behavior as it is called
-    // after every 1000 nodes.
-    // Return true if want tree re-sorted
-    virtual bool every1000Nodes(CbcModel * , int ) {
-        return false;
-    }
-
-    /** Returns true if wants code to do scan with alternate criterion
-        NOTE - this is temporarily disabled
-    */
-    virtual bool fullScan() const {
-        return false;
-    }
-
-    virtual ~CbcCompareBase() {}
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * ) {}
-
-    // Copy constructor
-    CbcCompareBase ( const CbcCompareBase & rhs) {
-        test_ = rhs.test_;
-        threaded_ = rhs.threaded_;
-    }
-
-    // Assignment operator
-    CbcCompareBase & operator=( const CbcCompareBase& rhs) {
-        if (this != &rhs) {
-            test_ = rhs.test_;
-            threaded_ = rhs.threaded_;
-        }
-        return *this;
-    }
-
-    /// Clone
-    virtual CbcCompareBase * clone() const {
-        abort();
-        return NULL;
-    }
-
-    /// This is test function
-    virtual bool test (CbcNode * , CbcNode * ) {
-        return true;
-    }
-
-    /// This is alternate test function
-    virtual bool alternateTest (CbcNode * x, CbcNode * y) {
-        return test(x, y);
-    }
-
-    bool operator() (CbcNode * x, CbcNode * y) {
-        return test(x, y);
-    }
-    /// Further test if everything else equal
-    inline bool equalityTest (CbcNode * x, CbcNode * y) const {
-        assert (x);
-        assert (y);
-        if (!threaded_) {
-            CbcNodeInfo * infoX = x->nodeInfo();
-            assert (infoX);
-            int nodeNumberX = infoX->nodeNumber();
-            CbcNodeInfo * infoY = y->nodeInfo();
-            assert (infoY);
-            int nodeNumberY = infoY->nodeNumber();
-            assert (nodeNumberX != nodeNumberY);
-            return (nodeNumberX > nodeNumberY);
-        } else {
-            assert (x->nodeNumber() != y->nodeNumber());
-            return (x->nodeNumber() > y->nodeNumber());
-        }
-    }
-    /// Say threaded
-    inline void sayThreaded() {
-        threaded_ = true;
-    }
-protected:
-    CbcCompareBase * test_;
-    // If not threaded we can use better way to break ties
-    bool threaded_;
-};
-
-#endif
-

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

@@ -1,120 +0,0 @@
-// $Id: CbcCompareDefault.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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/25/09 carved out of CbcCompareActual
-
-#ifndef CbcCompareDefault_H
-#define CbcCompareDefault_H
-
-
-//#############################################################################
-/*  These are alternative strategies for node traversal.
-    They can take data etc for fine tuning
-
-    At present the node list is stored as a heap and the "test"
-    comparison function returns true if node y is better than node x.
-
-*/
-#include "CbcNode.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCompare.hpp"
-
-class CbcModel;
-
-/* This is an example of a more complex rule with data
-   It is default after first solution
-   If weight is 0.0 then it is computed to hit first solution
-   less 5%
-*/
-class CbcCompareDefault  : public CbcCompareBase {
-public:
-    /// Default Constructor
-    CbcCompareDefault () ;
-    /// Constructor with weight
-    CbcCompareDefault (double weight);
-
-    /// Copy constructor
-    CbcCompareDefault ( const CbcCompareDefault &rhs);
-
-    /// Assignment operator
-    CbcCompareDefault & operator=( const CbcCompareDefault& rhs);
-
-    /// Clone
-    virtual CbcCompareBase * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp);
-
-    ~CbcCompareDefault() ;
-    /* This returns true if weighted value of node y is less than
-       weighted value of node x */
-    virtual bool test (CbcNode * x, CbcNode * y) ;
-
-    using CbcCompareBase::newSolution ;
-    /// This allows method to change behavior as it is called
-    /// after each solution
-    virtual bool newSolution(CbcModel * model,
-                             double objectiveAtContinuous,
-                             int numberInfeasibilitiesAtContinuous) ;
-    /// This allows method to change behavior
-    /// Return true if want tree re-sorted
-    virtual bool every1000Nodes(CbcModel * model, int numberNodes);
-
-    /* if weight == -1.0 then fewest infeasibilities (before solution)
-       if -2.0 then do breadth first just for first 1000 nodes
-       if -3.0 then depth first before solution
-    */
-    inline double getWeight() const {
-        return weight_;
-    }
-    inline void setWeight(double weight) {
-        weight_ = weight;
-    }
-    /// Cutoff
-    inline double getCutoff() const {
-        return cutoff_;
-    }
-    inline void setCutoff(double cutoff) {
-        cutoff_ = cutoff;
-    }
-    /// Best possible solution
-    inline double getBestPossible() const {
-        return bestPossible_;
-    }
-    inline void setBestPossible(double bestPossible) {
-        bestPossible_ = bestPossible;
-    }
-    /// Depth above which want to explore first
-    inline void setBreadthDepth(int value) {
-        breadthDepth_ = value;
-    }
-    /// Start dive
-    void startDive(CbcModel * model);
-    /// Clean up diving (i.e. switch off or prepare)
-    void cleanDive();
-protected:
-    /// Weight for each infeasibility
-    double weight_;
-    /// Weight for each infeasibility - computed from solution
-    double saveWeight_;
-    /// Cutoff
-    double cutoff_;
-    /// Best possible solution
-    double bestPossible_;
-    /// Number of solutions
-    int numberSolutions_;
-    /// Tree size (at last check)
-    int treeSize_;
-    /// Depth above which want to explore first
-    int breadthDepth_;
-    /// Chosen node from estimated (-1 is off)
-    int startNodeNumber_;
-    /// Node number when dive started
-    int afterNodeNumber_;
-    /// Indicates doing setup for diving
-    bool setupForDiving_ ;
-};
-
-#endif //CbcCompareDefault_H
-

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

@@ -1,47 +0,0 @@
-// $Id: CbcCompareDepth.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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/24/09 carved out of CbcCompareActual
-
-#ifndef CbcCompareDepth_H
-#define CbcCompareDepth_H
-
-
-//#############################################################################
-/*  These are alternative strategies for node traversal.
-    They can take data etc for fine tuning
-
-    At present the node list is stored as a heap and the "test"
-    comparison function returns true if node y is better than node x.
-
-*/
-#include "CbcNode.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCompare.hpp"
-class CbcModel;
-// This is default before first solution
-class CbcCompareDepth : public CbcCompareBase {
-public:
-    // Default Constructor
-    CbcCompareDepth () ;
-
-    ~CbcCompareDepth();
-    // Copy constructor
-    CbcCompareDepth ( const CbcCompareDepth &rhs);
-
-    // Assignment operator
-    CbcCompareDepth & operator=( const CbcCompareDepth& rhs);
-
-    /// Clone
-    virtual CbcCompareBase * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp);
-
-    // This returns true if the depth of node y is greater than depth of node x
-    virtual bool test (CbcNode * x, CbcNode * y);
-};
-
-#endif
-

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

@@ -1,48 +0,0 @@
-// $Id: CbcCompareEstimate.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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/25/09 carved out of CbcCompareActual
-
-#ifndef CbcCompareEstimate_H
-#define CbcCompareEstimate_H
-
-
-//#############################################################################
-/*  These are alternative strategies for node traversal.
-    They can take data etc for fine tuning
-
-    At present the node list is stored as a heap and the "test"
-    comparison function returns true if node y is better than node x.
-
-*/
-#include "CbcNode.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCompare.hpp"
-class CbcModel;
-
-/* This is when rounding is being done
-*/
-class CbcCompareEstimate  : public CbcCompareBase {
-public:
-    // Default Constructor
-    CbcCompareEstimate () ;
-    ~CbcCompareEstimate() ;
-    // Copy constructor
-    CbcCompareEstimate ( const CbcCompareEstimate &rhs);
-
-    // Assignment operator
-    CbcCompareEstimate & operator=( const CbcCompareEstimate& rhs);
-
-    /// Clone
-    virtual CbcCompareBase * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp);
-
-    virtual bool test (CbcNode * x, CbcNode * y) ;
-};
-
-
-#endif //CbcCompareEstimate_H
-

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

@@ -1,49 +0,0 @@
-// $Id: CbcCompareObjective.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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/25/09 carved out of CbcCompareActual
-
-#ifndef CbcCompareObjective_H
-#define CbcCompareObjective_H
-
-
-//#############################################################################
-/*  These are alternative strategies for node traversal.
-    They can take data etc for fine tuning
-
-    At present the node list is stored as a heap and the "test"
-    comparison function returns true if node y is better than node x.
-
-*/
-#include "CbcNode.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCompare.hpp"
-
-class CbcModel;
-
-class CbcCompareObjective  : public CbcCompareBase {
-public:
-    // Default Constructor
-    CbcCompareObjective ();
-
-    virtual ~CbcCompareObjective();
-    // Copy constructor
-    CbcCompareObjective ( const CbcCompareObjective &rhs);
-
-    // Assignment operator
-    CbcCompareObjective & operator=( const CbcCompareObjective& rhs);
-
-    /// Clone
-    virtual CbcCompareBase * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp);
-
-    /* This returns true if objective value of node y is less than
-       objective value of node x */
-    virtual bool test (CbcNode * x, CbcNode * y);
-};
-
-#endif //CbcCompareObjective_H
-