ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,137 +0,0 @@
-/* $Id: CbcFathom.hpp 1889 2013-04-07 13:46:46Z 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).
-
-#ifndef CbcFathom_H
-#define CbcFathom_H
-#include "CbcConfig.h"
-
-/*
-  This file contains two classes, CbcFathom and CbcOsiSolver. It's unclear why
-  they're in the same file. CbcOsiSolver is a base class for CbcLinked.
-
-  --lh, 071031 --
-*/
-
-
-class CbcModel;
-
-//#############################################################################
-/** Fathom base class.
-
-    The idea is that after some branching the problem will be effectively smaller than
-    the original problem and maybe there will be a more specialized technique which can completely
-    fathom this branch quickly.
-
-    One method is to presolve the problem to give a much smaller new problem and then do branch
-    and cut on that.  Another might be dynamic programming.
-
- */
-
-class CbcFathom {
-public:
-    // Default Constructor
-    CbcFathom ();
-
-    // Constructor with model - assumed before cuts
-    CbcFathom (CbcModel & model);
-
-    virtual ~CbcFathom();
-
-    /// update model (This is needed if cliques update matrix etc)
-    virtual void setModel(CbcModel * model);
-
-    /// Clone
-    virtual CbcFathom * clone() const = 0;
-
-    /// Resets stuff if model changes
-    virtual void resetModel(CbcModel * model) = 0;
-
-    /** returns 0 if no fathoming attempted, 1 fully fathomed,
-        2 incomplete search, 3 incomplete search but treat as complete.
-        If solution then newSolution will not be NULL and
-        will be freed by CbcModel.  It is expected that the solution is better
-        than best so far but CbcModel will double check.
-
-        If returns 3 then of course there is no guarantee of global optimum
-    */
-    virtual int fathom(double *& newSolution) = 0;
-
-    // Is this method possible
-    inline bool possible() const {
-        return possible_;
-    }
-
-protected:
-
-    /// Model
-    CbcModel * model_;
-    /// Possible - if this method of fathoming can be used
-    bool possible_;
-private:
-
-    /// Illegal Assignment operator
-    CbcFathom & operator=(const CbcFathom& rhs);
-
-};
-
-#include "OsiClpSolverInterface.hpp"
-
-//#############################################################################
-
-/**
-
-This is for codes where solver needs to know about CbcModel
-  Seems to provide only one value-added feature, a CbcModel object.
-
-*/
-
-class CbcOsiSolver : public OsiClpSolverInterface {
-
-public:
-
-    /**@name Constructors and destructors */
-    //@{
-    /// Default Constructor
-    CbcOsiSolver ();
-
-    /// Clone
-    virtual OsiSolverInterface * clone(bool copyData = true) const;
-
-    /// Copy constructor
-    CbcOsiSolver (const CbcOsiSolver &);
-
-    /// Assignment operator
-    CbcOsiSolver & operator=(const CbcOsiSolver& rhs);
-
-    /// Destructor
-    virtual ~CbcOsiSolver ();
-
-    //@}
-
-
-    /**@name Sets and Gets */
-    //@{
-    /// Set Cbc Model
-    inline void setCbcModel(CbcModel * model) {
-        cbcModel_ = model;
-    }
-    /// Return Cbc Model
-    inline CbcModel * cbcModel() const {
-        return cbcModel_;
-    }
-    //@}
-
-    //---------------------------------------------------------------------------
-
-protected:
-
-
-    /**@name Private member data */
-    //@{
-    /// Pointer back to CbcModel
-    CbcModel * cbcModel_;
-    //@}
-};
-#endif

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

@@ -1,169 +0,0 @@
-/* $Id: CbcFathomDynamicProgramming.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 CbcFathomDynamicProgramming_H
-#define CbcFathomDynamicProgramming_H
-
-#include "CbcFathom.hpp"
-
-//#############################################################################
-/** FathomDynamicProgramming class.
-
-    The idea is that after some branching the problem will be effectively smaller than
-    the original problem and maybe there will be a more specialized technique which can completely
-    fathom this branch quickly.
-
-    This is a dynamic programming implementation which is very fast for some
-    specialized problems.  It expects small integral rhs, an all integer problem
-    and positive integral coefficients. At present it can not do general set covering
-    problems just set partitioning.  It can find multiple optima for various rhs
-    combinations.
-
-    The main limiting factor is size of state space.  Each 1 rhs doubles the size of the problem.
-    2 or 3 rhs quadruples, 4,5,6,7 by 8 etc.
- */
-
-class CbcFathomDynamicProgramming : public CbcFathom {
-public:
-    // Default Constructor
-    CbcFathomDynamicProgramming ();
-
-    // Constructor with model - assumed before cuts
-    CbcFathomDynamicProgramming (CbcModel & model);
-    // Copy constructor
-    CbcFathomDynamicProgramming(const CbcFathomDynamicProgramming & rhs);
-
-    virtual ~CbcFathomDynamicProgramming();
-
-    /// update model (This is needed if cliques update matrix etc)
-    virtual void setModel(CbcModel * model);
-
-    /// Clone
-    virtual CbcFathom * clone() const;
-
-    /// Resets stuff if model changes
-    virtual void resetModel(CbcModel * model);
-
-    /** returns 0 if no fathoming attempted, 1 fully fathomed ,
-        2 incomplete search, 3 incomplete search but treat as complete.
-        If solution then newSolution will not be NULL and
-        will be freed by CbcModel.  It is expected that the solution is better
-        than best so far but CbcModel will double check.
-
-        If returns 3 then of course there is no guarantee of global optimum
-    */
-    virtual int fathom(double *& newSolution);
-
-    /// Maximum size allowed
-    inline int maximumSize() const {
-        return maximumSizeAllowed_;
-    }
-    inline void setMaximumSize(int value) {
-        maximumSizeAllowed_ = value;
-    }
-    /// Returns type of algorithm and sets up arrays
-    int checkPossible(int allowableSize = 0);
-    // set algorithm
-    inline void setAlgorithm(int value) {
-        algorithm_ = value;
-    }
-    /** Tries a column
-        returns true if was used in making any changes.
-    */
-    bool tryColumn(int numberElements, const int * rows,
-                   const double * coefficients, double cost,
-                   int upper = COIN_INT_MAX);
-    /// Returns cost array
-    inline const double * cost() const {
-        return cost_;
-    }
-    /// Returns back array
-    inline const int * back() const {
-        return back_;
-    }
-    /// Gets bit pattern for target result
-    inline int target() const {
-        return target_;
-    }
-    /// Sets bit pattern for target result
-    inline void setTarget(int value) {
-        target_ = value;
-    }
-private:
-    /// Does deleteions
-    void gutsOfDelete();
-
-    /** Adds one attempt of one column of type 0,
-        returns true if was used in making any changes
-    */
-    bool addOneColumn0(int numberElements, const int * rows,
-                       double cost);
-    /** Adds one attempt of one column of type 1,
-        returns true if was used in making any changes.
-        At present the user has to call it once for each possible value
-    */
-    bool addOneColumn1(int numberElements, const int * rows,
-                       const int * coefficients, double cost);
-    /** Adds one attempt of one column of type 1,
-        returns true if was used in making any changes.
-        At present the user has to call it once for each possible value.
-        This version is when there are enough 1 rhs to do faster
-    */
-    bool addOneColumn1A(int numberElements, const int * rows,
-                        const int * coefficients, double cost);
-    /// Gets bit pattern from original column
-    int bitPattern(int numberElements, const int * rows,
-                   const int * coefficients);
-    /// Gets bit pattern from original column
-    int bitPattern(int numberElements, const int * rows,
-                   const double * coefficients);
-    /// Fills in original column (dense) from bit pattern - returning number nonzero
-    int decodeBitPattern(int bitPattern, int * values, int numberRows);
-
-protected:
-
-    /// Size of states (power of 2 unless just one constraint)
-    int size_;
-    /** Type - 0 coefficients and rhs all 1,
-        1 - coefficients > 1 or rhs > 1
-    */
-    int type_;
-    /// Space for states
-    double * cost_;
-    /// Which state produced this cheapest one
-    int * back_;
-    /// Some rows may be satisified so we need a lookup
-    int * lookup_;
-    /// Space for sorted indices
-    int * indices_;
-    /// Number of active rows
-    int numberActive_;
-    /// Maximum size allowed
-    int maximumSizeAllowed_;
-    /// Start bit for each active row
-    int * startBit_;
-    /// Number bits for each active row
-    int * numberBits_;
-    /// Effective rhs
-    int * rhs_;
-    /// Space for sorted coefficients
-    int * coefficients_;
-    /// Target pattern
-    int target_;
-    /// Number of Non 1 rhs
-    int numberNonOne_;
-    /// Current bit pattern
-    int bitPattern_;
-    /// Current algorithm
-    int algorithm_;
-private:
-
-    /// Illegal Assignment operator
-    CbcFathomDynamicProgramming & operator=(const CbcFathomDynamicProgramming& rhs);
-
-};
-
-#endif
-

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

@@ -1,56 +0,0 @@
-/* $Id: CbcFeasibilityBase.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// Copyright (C) 2005, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CbcFeasibilityBase_H
-#define CbcFeasibilityBase_H
-
-
-//#############################################################################
-/*  There are cases where the user wants to control how CBC sees the problems feasibility.
-    The user may want to examine the problem and say :
-    a) The default looks OK
-    b) Pretend this problem is Integer feasible
-    c) Pretend this problem is infeasible even though it looks feasible
-
-    This simple class allows user to do that.
-
-*/
-
-class CbcModel;
-class CbcFeasibilityBase {
-public:
-    // Default Constructor
-    CbcFeasibilityBase () {}
-
-    /**
-       On input mode:
-       0 - called after a solve but before any cuts
-       -1 - called after strong branching
-       Returns :
-       0 - no opinion
-       -1 pretend infeasible
-       1 pretend integer solution
-    */
-    virtual int feasible(CbcModel * , int ) {
-        return 0;
-    }
-
-    virtual ~CbcFeasibilityBase() {}
-
-    // Copy constructor
-    CbcFeasibilityBase ( const CbcFeasibilityBase & ) {}
-
-    // Assignment operator
-    CbcFeasibilityBase & operator=( const CbcFeasibilityBase& ) {
-        return *this;
-    }
-
-    /// Clone
-    virtual CbcFeasibilityBase * clone() const {
-        return new CbcFeasibilityBase(*this);
-    }
-};
-#endif
-

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

@@ -1,67 +0,0 @@
-// $Id: CbcFixVariable.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/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcFixVariable_H
-#define CbcFixVariable_H
-
-#include "CbcBranchBase.hpp"
-/** Class for consequent bounds.
-    When a variable is branched on it normally interacts with other variables by
-    means of equations.  There are cases where we want to step outside LP and do something
-    more directly e.g. fix bounds.  This class is for that.
-
-    A state of -9999 means at LB, +9999 means at UB,
-    others mean if fixed to that value.
-
- */
-
-class CbcFixVariable : public CbcConsequence {
-
-public:
-
-    // Default Constructor
-    CbcFixVariable ();
-
-    // One useful Constructor
-    CbcFixVariable (int numberStates, const int * states, const int * numberNewLower, const int ** newLowerValue,
-                    const int ** lowerColumn,
-                    const int * numberNewUpper, const int ** newUpperValue,
-                    const int ** upperColumn);
-
-    // Copy constructor
-    CbcFixVariable ( const CbcFixVariable & rhs);
-
-    // Assignment operator
-    CbcFixVariable & operator=( const CbcFixVariable & rhs);
-
-    /// Clone
-    virtual CbcConsequence * clone() const;
-
-    /// Destructor
-    virtual ~CbcFixVariable ();
-
-    /** Apply to an LP solver.  Action depends on state
-     */
-    virtual void applyToSolver(OsiSolverInterface * solver, int state) const;
-
-protected:
-    /// Number of states
-    int numberStates_;
-    /// Values of integers for various states
-    int * states_;
-    /// Start of information for each state (setting new lower)
-    int * startLower_;
-    /// Start of information for each state (setting new upper)
-    int * startUpper_;
-    /// For each variable new bounds
-    double * newBound_;
-    /// Variable
-    int * variable_;
-};
-
-#endif
-

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

@@ -1,207 +0,0 @@
-// $Id: CbcFollowOn.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/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcFollowOn_H
-#define CbcFollowOn_H
-
-#include "CbcBranchBase.hpp"
-#include "OsiRowCut.hpp"
-#include "CoinHelperFunctions.hpp"
-#include "CoinPackedMatrix.hpp"
-
-/** Define a follow on class.
-    The idea of this is that in air-crew scheduling problems crew may fly in on flight A
-    and out on flight B or on some other flight.  A useful branch is one which on one side
-    fixes all which go out on flight B to 0, while the other branch fixes all those that do NOT
-    go out on flight B to 0.
-
-    This branching rule should be in addition to normal rules and have a high priority.
-*/
-
-class CbcFollowOn : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcFollowOn ();
-
-    /** Useful constructor
-    */
-    CbcFollowOn (CbcModel * model);
-
-    // Copy constructor
-    CbcFollowOn ( const CbcFollowOn &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcFollowOn & operator=( const CbcFollowOn& rhs);
-
-    // Destructor
-    ~CbcFollowOn ();
-
-    /// Infeasibility - large is 0.5
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    using CbcObject::feasibleRegion ;
-    /// This looks at solution and sets bounds to contain solution
-    virtual void feasibleRegion();
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-    /// As some computation is needed in more than one place - returns row
-    virtual int gutsOfFollowOn(int & otherRow, int & preferredWay) const;
-
-protected:
-    /// data
-    /// Matrix
-    CoinPackedMatrix matrix_;
-    /// Matrix by row
-    CoinPackedMatrix matrixByRow_;
-    /// Possible rhs (if 0 then not possible)
-    int * rhs_;
-};
-
-/** General Branching Object class.
-    Each way fixes some variables to lower bound
- */
-class CbcFixingBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcFixingBranchingObject ();
-
-    // Useful constructor
-    CbcFixingBranchingObject (CbcModel * model,
-                              int way,
-                              int numberOnDownSide, const int * down,
-                              int numberOnUpSide, const int * up);
-
-    // Copy constructor
-    CbcFixingBranchingObject ( const CbcFixingBranchingObject &);
-
-    // Assignment operator
-    CbcFixingBranchingObject & operator=( const CbcFixingBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcFixingBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-
-#ifdef JJF_ZERO
-    // No need to override. Default works fine.
-    /** Reset every information so that the branching object appears to point to
-        the previous child. This method does not need to modify anything in any
-        solver. */
-    virtual void previousBranch();
-#endif
-
-    using CbcBranchingObject::print ;
-    /** \brief Print something about branch - only if log level high
-    */
-    virtual void print();
-
-    /** Return the type (an integer identifier) of \c this */
-    virtual CbcBranchObjType type() const {
-        return FollowOnBranchObj;
-    }
-
-    /** 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);
-
-private:
-    /// data
-    /// Number on down list
-    int numberDown_;
-    /// Number on up list
-    int numberUp_;
-    /// downList - variables to fix to lb on down branch
-    int * downList_;
-    /// upList - variables to fix to lb on up branch
-    int * upList_;
-};
-
-/** Define an idiotic idea class.
-    The idea of this is that we take some integer variables away from integer and
-    sum them with some randomness to get signed sum close to 0.5.  We then can
-    branch to exclude that gap.
-
-    This branching rule should be in addition to normal rules and have a high priority.
-*/
-
-class CbcIdiotBranch : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcIdiotBranch ();
-
-    /** Useful constructor
-    */
-    CbcIdiotBranch (CbcModel * model);
-
-    // Copy constructor
-    CbcIdiotBranch ( const CbcIdiotBranch &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcIdiotBranch & operator=( const CbcIdiotBranch& rhs);
-
-    // Destructor
-    ~CbcIdiotBranch ();
-
-    /// Infeasibility - large is 0.5
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    using CbcObject::feasibleRegion ;
-    /// This looks at solution and sets bounds to contain solution
-    virtual void feasibleRegion();
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-    /// Initialize for branching
-    virtual void initializeForBranching(CbcModel * );
-protected:
-    /// Build "cut"
-    OsiRowCut buildCut(const OsiBranchingInformation * info,int type,int & preferredWay) const; 
-    /// data
-    /// Thread specific random number generator
-    mutable CoinThreadRandom randomNumberGenerator_;
-    /// Saved version of thread specific random number generator
-    mutable CoinThreadRandom savedRandomNumberGenerator_;
-};
-
-#endif
-