ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/extconf.rb

@@ -1,60 +0,0 @@
-require 'mkmf'
-ROOT_DIR = File.dirname(File.absolute_path(__FILE__))
-
-TARBALL_PATH = "/tmp/Cbc.tgz"
-CBC_SRC_DIR = "/tmp/Cbc-2.9.7"
-CBC_INSTALL = "#{ROOT_DIR}/install"
-def install_cbc
-  system "curl -o #{TARBALL_PATH} http://www.coin-or.org/download/source/Cbc/Cbc-2.9.7.tgz"
-  Dir.chdir "/tmp"
-  system "tar -xzf #{TARBALL_PATH}"
-  res = system "cd #{CBC_SRC_DIR} && ./configure --prefix=#{CBC_INSTALL} -C --with-pic --without-static && make -j4 && make install"
-  if not res
-    puts "Failed to build CBC, aborting"
-    exit 1
-  end
-end
-
-unless RUBY_PLATFORM =~ /x86_64-linux/
-  if not have_library("Cbc")
-    install_cbc
-  end
-end
-
-## Rerun this if updated cbc version
-#  swig_cmd = find_executable "swig"
-#  current_path = File.expand_path('../', __FILE__)
-#  %x{#{swig_cmd} -ruby -I#{current_path}/install/include/coin #{current_path}/cbc.i }
-
-libs = %w(
-  Cbc
-  CbcSolver
-  Cgl
-  Clp
-  ClpSolver
-  CoinUtils
-  Osi
-  OsiCbc
-  OsiClp
-  OsiCommonTests
-)
-
-# $CFLAGS << " -Linstall/lib -Iinstall/include/coin/ "
-# $LIBPATH << "install/lib"
-# $INCFLAGS << " -Iinstall/include/coin/ "
-
-libs.each do |lib|
-  find_library(lib,nil, "#{CBC_INSTALL}/lib")
-end
-
-headers = Dir["#{CBC_INSTALL}/include/coin/*.h"].map{ |h| h.split('/').last }
-# headers = Dir["#{CBC_INSTALL}/include/coin/*.hpp"].map{ |h| h.split('/').last }
-# with_cflags("-x c++") do
-  headers.each do |header|
-    find_header(header, "#{CBC_INSTALL}/include/coin")
-  end
-# end
-
-dir_config("ruby-cbc")
-RPATHFLAG << " -Wl,-rpath='$$ORIGIN/install/lib'"
-create_makefile('cbc_wrapper')

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

@@ -1,24 +0,0 @@
-/* $Id: CbcBranchActual.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 CbcBranchActual_H
-#define CbcBranchActual_H
-
-#include "CbcBranchBase.hpp"
-#include "CoinPackedMatrix.hpp"
-#include "CbcClique.hpp"
-#include "CbcSOS.hpp"
-#include "CbcSimpleInteger.hpp"
-#include "CbcNWay.hpp"
-#include "CbcSimpleIntegerPseudoCost.hpp"
-#include "CbcBranchDefaultDecision.hpp"
-#include "CbcFollowOn.hpp"
-#include "CbcFixVariable.hpp"
-#include "CbcDummyBranchingObject.hpp"
-#include "CbcGeneral.hpp"
-#include "CbcGeneralDepth.hpp"
-#include "CbcSubProblem.hpp"
-#endif
-

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

@@ -1,62 +0,0 @@
-// $Id: CbcBranchAllDifferent.hpp 1899 2013-04-09 18:12:08Z stefan $
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-// Edwin 11/13/2009-- carved out of CbcBranchCut
-
-#ifndef CbcBranchAllDifferent_H
-#define CbcBranchAllDifferent_H
-
-#include "CbcBranchBase.hpp"
-#include "OsiRowCut.hpp"
-#include "CoinPackedMatrix.hpp"
-#include "CbcBranchCut.hpp"
-
-/** Define a branch class that branches so that it is only satsified if all
-    members have different values
-    So cut is x <= y-1 or x >= y+1
-*/
-
-
-class CbcBranchAllDifferent : public CbcBranchCut {
-
-public:
-
-    // Default Constructor
-    CbcBranchAllDifferent ();
-
-    /** Useful constructor - passed set of integer variables which must all be different
-    */
-    CbcBranchAllDifferent (CbcModel * model, int number, const int * which);
-
-    // Copy constructor
-    CbcBranchAllDifferent ( const CbcBranchAllDifferent &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcBranchAllDifferent & operator=( const CbcBranchAllDifferent& rhs);
-
-    // Destructor
-    ~CbcBranchAllDifferent ();
-
-    /// Infeasibility - large is 0.5
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-
-
-protected:
-    /// data
-
-    /// Number of entries
-    int numberInSet_;
-    /// Which variables
-    int * which_;
-};
-#endif
-

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

@@ -1,78 +0,0 @@
-/* $Id: CbcBranchBase.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 CbcBranchBase_H
-#define CbcBranchBase_H
-
-#include <string>
-#include <vector>
-#include "OsiBranchingObject.hpp"
-
-enum CbcRangeCompare {
-    CbcRangeSame,
-    CbcRangeDisjoint,
-    CbcRangeSubset,
-    CbcRangeSuperset,
-    CbcRangeOverlap
-};
-
-#include "CbcObject.hpp"
-#include "CbcBranchingObject.hpp"
-#include "CbcBranchDecision.hpp"
-#include "CbcConsequence.hpp"
-#include "CbcObjectUpdateData.hpp"
-
-//##############################################################################
-
-/** Compare two ranges. The two bounds arrays are both of size two and
-    describe closed intervals. Return the appropriate CbcRangeCompare value
-    (first argument being the sub/superset if that's the case). In case of
-    overlap (and if \c replaceIfOverlap is true) replace the content of thisBd
-    with the intersection of the ranges.
-*/
-static inline CbcRangeCompare
-CbcCompareRanges(double* thisBd, const double* otherBd,
-                 const bool replaceIfOverlap)
-{
-    const double lbDiff = thisBd[0] - otherBd[0];
-    if (lbDiff < 0) { // lb of this < lb of other
-        if (thisBd[1] >= otherBd[1]) { // ub of this >= ub of other
-            return CbcRangeSuperset;
-        } else if (thisBd[1] < otherBd[0]) {
-            return CbcRangeDisjoint;
-        } else {
-            // overlap
-            if (replaceIfOverlap) {
-                thisBd[0] = otherBd[0];
-            }
-            return CbcRangeOverlap;
-        }
-    } else if (lbDiff > 0) { // lb of this > lb of other
-        if (thisBd[1] <= otherBd[1]) { // ub of this <= ub of other
-            return CbcRangeSubset;
-        } else if (thisBd[0] > otherBd[1]) {
-            return CbcRangeDisjoint;
-        } else {
-            // overlap
-            if (replaceIfOverlap) {
-                thisBd[1] = otherBd[1];
-            }
-            return CbcRangeOverlap;
-        }
-    } else { // lb of this == lb of other
-        if (thisBd[1] == otherBd[1]) {
-            return CbcRangeSame;
-        }
-        return thisBd[1] < otherBd[1] ? CbcRangeSubset : CbcRangeSuperset;
-    }
-
-    return CbcRangeSame; // fake return
-
-}
-
-//#############################################################################
-
-#endif
-

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

@@ -1,183 +0,0 @@
-/* $Id: CbcBranchCut.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CbcBranchCut_H
-#define CbcBranchCut_H
-
-#include "CbcBranchBase.hpp"
-#include "OsiRowCut.hpp"
-#include "CoinPackedMatrix.hpp"
-
-/** Define a cut branching class.
-    At present empty - all stuff in descendants
-*/
-
-class CbcBranchCut : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcBranchCut ();
-
-    /** In to maintain normal methods
-    */
-    CbcBranchCut (CbcModel * model);
-    // Copy constructor
-    CbcBranchCut ( const CbcBranchCut &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcBranchCut & operator=( const CbcBranchCut& rhs);
-
-    // Destructor
-    ~CbcBranchCut ();
-
-    /// Infeasibility
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    using CbcObject::feasibleRegion ;
-    /** Set bounds to contain the current solution.
-
-      More precisely, for the variable associated with this object, take the
-      value given in the current solution, force it within the current bounds
-      if required, then set the bounds to fix the variable at the integer
-      nearest the solution value.
-
-      At present this will do nothing
-    */
-    virtual void feasibleRegion();
-
-    /** \brief Return true if branch created by object should fix variables
-    */
-    virtual bool boundBranch() const ;
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-
-    /** \brief Given a valid solution (with reduced costs, etc.),
-        return a branching object which would give a new feasible
-        point in the good direction.
-
-      The preferred branching object will force the variable to be +/-1 from
-      its current value, depending on the reduced cost and objective sense.  If
-      movement in the direction which improves the objective is impossible due
-      to bounds on the variable, the branching object will move in the other
-      direction.  If no movement is possible, the method returns NULL.
-
-      Only the bounds on this variable are considered when determining if the new
-      point is feasible.
-
-      At present this does nothing
-    */
-    virtual CbcBranchingObject * preferredNewFeasible() const;
-
-    /** \brief Given a valid solution (with reduced costs, etc.),
-        return a branching object which would give a new feasible
-        point in a bad direction.
-
-      As for preferredNewFeasible(), but the preferred branching object will
-      force movement in a direction that degrades the objective.
-
-      At present this does nothing
-    */
-    virtual CbcBranchingObject * notPreferredNewFeasible() const ;
-
-    using CbcObject::resetBounds ;
-    /** Reset original upper and lower bound values from the solver.
-
-      Handy for updating bounds held in this object after bounds held in the
-      solver have been tightened.
-     */
-    virtual void resetBounds();
-
-
-protected:
-    /// data
-
-};
-/** Cut branching object
-
-  This object can specify a two-way branch in terms of two cuts
-*/
-
-class CbcCutBranchingObject : public CbcBranchingObject {
-
-public:
-
-    /// Default constructor
-    CbcCutBranchingObject ();
-
-    /** Create a cut branching object
-
-        Cut down will applied on way=-1, up on way==1
-        Assumed down will be first so way_ set to -1
-    */
-    CbcCutBranchingObject (CbcModel * model, OsiRowCut & down, OsiRowCut &up, bool canFix);
-
-    /// Copy constructor
-    CbcCutBranchingObject ( const CbcCutBranchingObject &);
-
-    /// Assignment operator
-    CbcCutBranchingObject & operator= (const CbcCutBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    /// Destructor
-    virtual ~CbcCutBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /** \brief Sets the bounds for variables or adds a cut depending on the
-               current arm of the branch and advances the object state to the next arm.
-           Returns change in guessed objective on next branch
-    */
-    virtual double branch();
-
-    using CbcBranchingObject::print ;
-    /** \brief Print something about branch - only if log level high
-    */
-    virtual void print();
-
-    /** \brief Return true if branch should fix variables
-    */
-    virtual bool boundBranch() const;
-
-    /** Return the type (an integer identifier) of \c this */
-    virtual CbcBranchObjType type() const {
-        return CutBranchingObj;
-    }
-
-    /** Compare the original object of \c this with the original object of \c
-        brObj. Assumes that there is an ordering of the original objects.
-        This method should be invoked only if \c this and brObj are of the same
-        type.
-        Return negative/0/positive depending on whether \c this is
-        smaller/same/larger than the argument.
-    */
-    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
-
-    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
-        same type and must have the same original object, but they may have
-        different feasible regions.
-        Return the appropriate CbcRangeCompare value (first argument being the
-        sub/superset if that's the case). In case of overlap (and if \c
-        replaceIfOverlap is true) replace the current branching object with one
-        whose feasible region is the overlap.
-     */
-    virtual CbcRangeCompare compareBranchingObject
-    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
-
-protected:
-    /// Cut for the down arm (way_ = -1)
-    OsiRowCut down_;
-    /// Cut for the up arm (way_ = 1)
-    OsiRowCut up_;
-    /// True if one way can fix variables
-    bool canFix_;
-};
-#endif

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

@@ -1,129 +0,0 @@
-// $Id: CbcBranchDecision.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/12/2009 carved from CbcBranchBase
-
-#ifndef CbcBranchDecision_H
-#define CbcBranchDecision_H
-
-#include "CbcBranchBase.hpp"
-
-/** Abstract branching decision base class
-
-  In the abstract, an CbcBranchDecision object is expected to be able to
-  compare two possible branching choices.
-
-  The #betterBranch() method is the crucial routine. It is expected to be able
-  to compare two \link CbcBranchingObject CbcBranchingObjects \endlink.
-
-  See CbcObject for an overview of the three classes (CbcObject,
-  CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching
-  model.
-*/
-class CbcModel;
-class OsiChooseVariable;
-
-class CbcBranchDecision {
-public:
-    /// Default Constructor
-    CbcBranchDecision ();
-
-    // Copy constructor
-    CbcBranchDecision ( const CbcBranchDecision &);
-
-    /// Destructor
-    virtual ~CbcBranchDecision();
-
-/// Clone
-    virtual CbcBranchDecision * clone() const = 0;
-
-    /// Initialize <i>e.g.</i> before starting to choose a branch at a node
-    virtual void initialize(CbcModel * model) = 0;
-
-    /** \brief Compare two branching objects. Return nonzero if branching
-           using \p thisOne is better than branching using \p bestSoFar.
-
-      If \p bestSoFar is NULL, the routine should return a nonzero value.
-      This routine is used only after strong branching.
-      Either this or bestBranch is used depending which user wants.
-
-    */
-
-    virtual int
-    betterBranch (CbcBranchingObject * thisOne,
-                  CbcBranchingObject * bestSoFar,
-                  double changeUp, int numberInfeasibilitiesUp,
-                  double changeDown, int numberInfeasibilitiesDown) = 0 ;
-
-    /** \brief Compare N branching objects. Return index of best
-        and sets way of branching in chosen object.
-
-      Either this or betterBranch is used depending which user wants.
-    */
-
-    virtual int
-    bestBranch (CbcBranchingObject ** objects, int numberObjects, int numberUnsatisfied,
-                double * changeUp, int * numberInfeasibilitiesUp,
-                double * changeDown, int * numberInfeasibilitiesDown,
-                double objectiveValue) ;
-
-    /** Says whether this method can handle both methods -
-        1 better, 2 best, 3 both */
-    virtual int whichMethod() {
-        return 2;
-    }
-
-    /** Saves a clone of current branching object.  Can be used to update
-        information on object causing branch - after branch */
-    virtual void saveBranchingObject(OsiBranchingObject * ) {}
-    /** Pass in information on branch just done.
-        assumes object can get information from solver */
-    virtual void updateInformation(OsiSolverInterface * ,
-                                   const CbcNode * ) {}
-    /** Sets or gets best criterion so far */
-    virtual void setBestCriterion(double ) {}
-    virtual double getBestCriterion() const {
-        return 0.0;
-    }
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * ) {}
-    /// Model
-    inline CbcModel * cbcModel() const {
-        return model_;
-    }
-    /* If chooseMethod_ id non-null then the rest is fairly pointless
-       as choosemethod_ will be doing all work
-     This comment makes more sense if you realise that there's a conversion in
-     process from the Cbc branching classes to Osi branching classes. The test
-     for use of the Osi branching classes is CbcModel::branchingMethod_
-     non-null (i.e., it points to one of these CbcBranchDecision objects) and
-     that branch decision object has an OsiChooseVariable method set. In which
-     case, we'll use it, rather than the choose[*]Variable methods defined in
-     CbcNode.
-	*/
-
-    OsiChooseVariable * chooseMethod() const {
-        return chooseMethod_;
-    }
-    /// Set (clone) chooseMethod
-    void setChooseMethod(const OsiChooseVariable & method);
-
-protected:
-
-    // Clone of branching object
-    CbcBranchingObject * object_;
-    /// Pointer to model
-    CbcModel * model_;
-    /* If chooseMethod_ id non-null then the rest is fairly pointless
-       as choosemethod_ will be doing all work
-    */
-    OsiChooseVariable * chooseMethod_;
-private:
-    /// Assignment is illegal
-    CbcBranchDecision & operator=(const CbcBranchDecision& rhs);
-
-};
-#endif
-