ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,372 +0,0 @@
-/* $Id: CbcTreeLocal.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 CbcTreeLocal_H
-#define CbcTreeLocal_H
-
-//#############################################################################
-/*  This implements (approximately) local branching as in the 2002 paper by
-    Matteo Fischetti and Andrea Lodi.
-
-    The very simple version of the algorithm for problems with
-    0-1 variables and continuous is as follows:
-
-    Obtain a feasible solution (one can be passed in).
-
-    Add a cut which limits search to a k neighborhood of this solution.
-    (At most k 0-1 variables may change value)
-    Do branch and bound on this problem.
-
-    If finished search and proven optimal then we can reverse cut so
-    any solutions must be at least k+1 away from solution and we can
-    add a new cut limiting search to a k neighborhood of new solution
-    repeat.
-
-    If finished search and no new solution then the simplest version
-    would reverse last cut and complete search.  The version implemented
-    here can use time and node limits and can widen search (increase effective k)
-    .... and more
-
-*/
-
-#include "CbcTree.hpp"
-#include "CbcNode.hpp"
-#include "OsiRowCut.hpp"
-class CbcModel;
-
-
-class CbcTreeLocal : public CbcTree {
-
-public:
-
-    // Default Constructor
-    CbcTreeLocal ();
-
-    /* Constructor with solution.
-       If solution NULL no solution, otherwise must be integer
-       range is initial upper bound (k) on difference from given solution.
-       typeCuts -
-                0 means just 0-1 cuts and will need to refine 0-1 solution
-            1 uses weaker cuts on all integer variables
-       maxDiversification is maximum number of range widenings to try
-       timeLimit is seconds in subTree
-       nodeLimit is nodes in subTree
-       refine is whether to see if we can prove current solution is optimal
-       when we fix all 0-1 (in case typeCuts==0 and there are general integer variables)
-       if false then no refinement but reverse cuts weaker
-    */
-    CbcTreeLocal (CbcModel * model, const double * solution , int range = 10,
-                  int typeCuts = 0, int maxDiversification = 0,
-                  int timeLimit = 1000000, int nodeLimit = 1000000, bool refine = true);
-    // Copy constructor
-    CbcTreeLocal ( const CbcTreeLocal & rhs);
-
-    // = operator
-    CbcTreeLocal & operator=(const CbcTreeLocal & rhs);
-
-    virtual ~CbcTreeLocal();
-
-    /// Clone
-    virtual CbcTree * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp) ;
-
-    /*! \name Heap access and maintenance methods */
-//@{
-
-    /// Return the top node of the heap
-    virtual CbcNode * top() const;
-
-    /// Add a node to the heap
-    virtual void push(CbcNode * x);
-
-    /// Remove the top node from the heap
-    virtual void pop() ;
-
-//@}
-    /*! \name Other stuff */
-//@{
-
-    /// Create cut - return -1 if bad, 0 if okay and 1 if cut is everything
-    int createCut(const double * solution, OsiRowCut & cut);
-
-    /// Test if empty *** note may be overridden
-    virtual bool empty() ;
-
-    /// We may have got an intelligent tree so give it one more chance
-    virtual void endSearch() ;
-    /// Other side of last cut branch (if bias==rhs_ will be weakest possible)
-    void reverseCut(int state, double bias = 0.0);
-    /// Delete last cut branch
-    void deleteCut(OsiRowCut & cut);
-    /// Pass in solution (so can be used after heuristic)
-    void passInSolution(const double * solution, double solutionValue);
-    // range i.e. k
-    inline int range() const {
-        return range_;
-    }
-    // setrange i.e. k
-    inline void setRange(int value) {
-        range_ = value;
-    }
-    // Type of cuts - 0=just 0-1, 1=all
-    inline int typeCuts() const {
-        return typeCuts_;
-    }
-    // Type of cuts - 0=just 0-1, 1=all
-    inline void setTypeCuts(int value) {
-        typeCuts_ = value;
-    }
-    // maximum number of diversifications
-    inline int maxDiversification() const {
-        return maxDiversification_;
-    }
-    // maximum number of diversifications
-    inline void setMaxDiversification(int value) {
-        maxDiversification_ = value;
-    }
-    // time limit per subtree
-    inline int timeLimit() const {
-        return timeLimit_;
-    }
-    // time limit per subtree
-    inline void setTimeLimit(int value) {
-        timeLimit_ = value;
-    }
-    // node limit for subtree
-    inline int nodeLimit() const {
-        return nodeLimit_;
-    }
-    // node limit for subtree
-    inline void setNodeLimit(int value) {
-        nodeLimit_ = value;
-    }
-    // Whether to do refinement step
-    inline bool refine() const {
-        return refine_;
-    }
-    // Whether to do refinement step
-    inline void setRefine(bool yesNo) {
-        refine_ = yesNo;
-    }
-
-//@}
-private:
-    // Node for local cuts
-    CbcNode * localNode_;
-    // best solution
-    double * bestSolution_;
-    // saved solution
-    double * savedSolution_;
-    // solution number at start of pass
-    int saveNumberSolutions_;
-    /* Cut.  If zero size then no solution yet.  Otherwise is left hand branch */
-    OsiRowCut cut_;
-    // This cut fixes all 0-1 variables
-    OsiRowCut fixedCut_;
-    // Model
-    CbcModel * model_;
-    // Original lower bounds
-    double * originalLower_;
-    // Original upper bounds
-    double * originalUpper_;
-    // range i.e. k
-    int range_;
-    // Type of cuts - 0=just 0-1, 1=all
-    int typeCuts_;
-    // maximum number of diversifications
-    int maxDiversification_;
-    // current diversification
-    int diversification_;
-    // Whether next will be strong diversification
-    bool nextStrong_;
-    // Current rhs
-    double rhs_;
-    // Save allowable gap
-    double savedGap_;
-    // Best solution
-    double bestCutoff_;
-    // time limit per subtree
-    int timeLimit_;
-    // time when subtree started
-    int startTime_;
-    // node limit for subtree
-    int nodeLimit_;
-    // node count when subtree started
-    int startNode_;
-    // -1 not started, 0 == stop on first solution, 1 don't stop on first, 2 refinement step
-    int searchType_;
-    // Whether to do refinement step
-    bool refine_;
-
-};
-
-class CbcTreeVariable : public CbcTree {
-
-public:
-
-    // Default Constructor
-    CbcTreeVariable ();
-
-    /* Constructor with solution.
-       If solution NULL no solution, otherwise must be integer
-       range is initial upper bound (k) on difference from given solution.
-       typeCuts -
-                0 means just 0-1 cuts and will need to refine 0-1 solution
-            1 uses weaker cuts on all integer variables
-       maxDiversification is maximum number of range widenings to try
-       timeLimit is seconds in subTree
-       nodeLimit is nodes in subTree
-       refine is whether to see if we can prove current solution is optimal
-       when we fix all 0-1 (in case typeCuts==0 and there are general integer variables)
-       if false then no refinement but reverse cuts weaker
-    */
-    CbcTreeVariable (CbcModel * model, const double * solution , int range = 10,
-                     int typeCuts = 0, int maxDiversification = 0,
-                     int timeLimit = 1000000, int nodeLimit = 1000000, bool refine = true);
-    // Copy constructor
-    CbcTreeVariable ( const CbcTreeVariable & rhs);
-
-    // = operator
-    CbcTreeVariable & operator=(const CbcTreeVariable & rhs);
-
-    virtual ~CbcTreeVariable();
-
-    /// Clone
-    virtual CbcTree * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp) ;
-
-    /*! \name Heap access and maintenance methods */
-//@{
-
-    /// Return the top node of the heap
-    virtual CbcNode * top() const;
-
-    /// Add a node to the heap
-    virtual void push(CbcNode * x);
-
-    /// Remove the top node from the heap
-    virtual void pop() ;
-
-//@}
-    /*! \name Other stuff */
-//@{
-
-    /// Create cut - return -1 if bad, 0 if okay and 1 if cut is everything
-    int createCut(const double * solution, OsiRowCut & cut);
-
-    /// Test if empty *** note may be overridden
-    virtual bool empty() ;
-
-    /// We may have got an intelligent tree so give it one more chance
-    virtual void endSearch() ;
-    /// Other side of last cut branch (if bias==rhs_ will be weakest possible)
-    void reverseCut(int state, double bias = 0.0);
-    /// Delete last cut branch
-    void deleteCut(OsiRowCut & cut);
-    /// Pass in solution (so can be used after heuristic)
-    void passInSolution(const double * solution, double solutionValue);
-    // range i.e. k
-    inline int range() const {
-        return range_;
-    }
-    // setrange i.e. k
-    inline void setRange(int value) {
-        range_ = value;
-    }
-    // Type of cuts - 0=just 0-1, 1=all
-    inline int typeCuts() const {
-        return typeCuts_;
-    }
-    // Type of cuts - 0=just 0-1, 1=all
-    inline void setTypeCuts(int value) {
-        typeCuts_ = value;
-    }
-    // maximum number of diversifications
-    inline int maxDiversification() const {
-        return maxDiversification_;
-    }
-    // maximum number of diversifications
-    inline void setMaxDiversification(int value) {
-        maxDiversification_ = value;
-    }
-    // time limit per subtree
-    inline int timeLimit() const {
-        return timeLimit_;
-    }
-    // time limit per subtree
-    inline void setTimeLimit(int value) {
-        timeLimit_ = value;
-    }
-    // node limit for subtree
-    inline int nodeLimit() const {
-        return nodeLimit_;
-    }
-    // node limit for subtree
-    inline void setNodeLimit(int value) {
-        nodeLimit_ = value;
-    }
-    // Whether to do refinement step
-    inline bool refine() const {
-        return refine_;
-    }
-    // Whether to do refinement step
-    inline void setRefine(bool yesNo) {
-        refine_ = yesNo;
-    }
-
-//@}
-private:
-    // Node for local cuts
-    CbcNode * localNode_;
-    // best solution
-    double * bestSolution_;
-    // saved solution
-    double * savedSolution_;
-    // solution number at start of pass
-    int saveNumberSolutions_;
-    /* Cut.  If zero size then no solution yet.  Otherwise is left hand branch */
-    OsiRowCut cut_;
-    // This cut fixes all 0-1 variables
-    OsiRowCut fixedCut_;
-    // Model
-    CbcModel * model_;
-    // Original lower bounds
-    double * originalLower_;
-    // Original upper bounds
-    double * originalUpper_;
-    // range i.e. k
-    int range_;
-    // Type of cuts - 0=just 0-1, 1=all
-    int typeCuts_;
-    // maximum number of diversifications
-    int maxDiversification_;
-    // current diversification
-    int diversification_;
-    // Whether next will be strong diversification
-    bool nextStrong_;
-    // Current rhs
-    double rhs_;
-    // Save allowable gap
-    double savedGap_;
-    // Best solution
-    double bestCutoff_;
-    // time limit per subtree
-    int timeLimit_;
-    // time when subtree started
-    int startTime_;
-    // node limit for subtree
-    int nodeLimit_;
-    // node count when subtree started
-    int startNode_;
-    // -1 not started, 0 == stop on first solution, 1 don't stop on first, 2 refinement step
-    int searchType_;
-    // Whether to do refinement step
-    bool refine_;
-
-};
-#endif
-

data/ext/ruby-cbc/install/include/coin/Cbc_C_Interface.h

@@ -1,381 +0,0 @@
-/* $Id: Cbc_C_Interface.h 2091 2014-10-03 00:46:49Z mlubin $ */
-/*
-  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 CbcModelC_H
-#define CbcModelC_H
-
-/* include all defines and ugly stuff */
-#include "Coin_C_defines.h"
-#include <stddef.h>
-
-/*
- * Original verison contributed by Bob Entriken,
- * significantly updated by Miles Lubin.
-*/
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    /**@name Constructors and destructor
-      This is a "C" interface to Cbc.
-      The user does not need to know structure of Cbc_Model.
-    */
-    /*@{*/
-
-    /** Default Cbc_Model constructor */
-    COINLIBAPI Cbc_Model * COINLINKAGE
-    Cbc_newModel(void)
-    ;
-    /** Cbc_Model Destructor */
-    COINLIBAPI void COINLINKAGE
-    Cbc_deleteModel(Cbc_Model * model)
-    ;
-    /** Current version of Cbc */
-    COINLIBAPI const char* COINLINKAGE Cbc_getVersion(void)
-    ;
-    /*@}*/
-
-    /**@name Getting and setting model data
-     Note that problem access and modification methods,
-       such as getColLower and setColLower,
-       are *not valid* after calling Cbc_solve().
-       Therefore it is not recommended to reuse a Cbc_Model
-       object for multiple solves. A workaround is to call Cbc_clone()
-       before solving.
-     * */
-    /*@{*/
-    /** Loads a problem (the constraints on the
-        rows are given by lower and upper bounds). If a pointer is NULL then the
-        following values are the default:
-        <ul>
-        <li> <code>colub</code>: all columns have upper bound infinity
-        <li> <code>collb</code>: all columns have lower bound 0
-        <li> <code>rowub</code>: all rows have upper bound infinity
-        <li> <code>rowlb</code>: all rows have lower bound -infinity
-        <li> <code>obj</code>: all variables have 0 objective coefficient
-        </ul>
-
-     The constraint matrix is
-     given in standard compressed sparse column (without gaps).
-     <ul>
-     <li> <code>start[i]</code> stores the starting index of the ith column
-     <li> <code>index[k]</code> stores the row index of the kth nonzero element
-     <li> <code>value[k]</code> stores the coefficient of the kth nonzero element
-     </ul>
-    */
-    COINLIBAPI void COINLINKAGE
-    Cbc_loadProblem (Cbc_Model * model,  const int numcols, const int numrows,
-                     const CoinBigIndex * start, const int* index,
-                     const double* value,
-                     const double* collb, const double* colub,
-                     const double* obj,
-                     const double* rowlb, const double* rowub)
-    ;
-    /** Read an mps file from the given filename */
-    COINLIBAPI int COINLINKAGE
-    Cbc_readMps(Cbc_Model * model, const char *filename)
-    ;
-    /** Write an mps file from the given filename */
-    COINLIBAPI void COINLINKAGE
-    Cbc_writeMps(Cbc_Model * model, const char *filename)
-    ;
-    /** Provide an initial feasible solution to accelerate branch-and-bound 
-     Note that feasibility of the solution is *not* verified.
-    */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setInitialSolution(Cbc_Model *model, const double * sol)
-    ;
-    /** Fills in array with problem name  */
-    COINLIBAPI void COINLINKAGE
-    Cbc_problemName(Cbc_Model * model, int maxNumberCharacters, char * array)
-    ;
-    /** Sets problem name.
-    
-      \p array must be a null-terminated string.
-    */
-    COINLIBAPI int COINLINKAGE
-    Cbc_setProblemName(Cbc_Model * model, const char * array)
-    ;
-
-    /** Number of nonzero elements in constraint matrix */
-    COINLIBAPI int COINLINKAGE
-    Cbc_getNumElements(Cbc_Model * model)
-    ;
-    /** "Column start" vector of constraint matrix. Same format as Cbc_loadProblem() */
-    COINLIBAPI const CoinBigIndex * COINLINKAGE
-    Cbc_getVectorStarts(Cbc_Model * model)
-    ;
-    /** "Row index" vector of constraint matrix */
-    COINLIBAPI const int * COINLINKAGE
-    Cbc_getIndices(Cbc_Model * model)
-    ;
-    /** Coefficient vector of constraint matrix */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getElements(Cbc_Model * model)
-    ;
-
-    /** Maximum lenght of a row or column name */
-    COINLIBAPI size_t COINLINKAGE
-    Cbc_maxNameLength(Cbc_Model * model)
-    ;
-    /** Fill in first maxLength bytes of name array with a row name */
-    COINLIBAPI void COINLINKAGE
-    Cbc_getRowName(Cbc_Model * model, int iRow, char * name, size_t maxLength)
-    ;
-    /** Fill in first maxLength bytes of name array with a column name */
-    COINLIBAPI void COINLINKAGE
-    Cbc_getColName(Cbc_Model * model, int iColumn, char * name, size_t maxLength)
-    ;
-    /** Set the name of a column */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setColName(Cbc_Model * model, int iColumn, const char * name)
-    ;
-    /** Set the name of a row */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setRowName(Cbc_Model * model, int iRow, const char * name)
-    ;
-    /** Number of constraints in the model */
-    COINLIBAPI int COINLINKAGE
-    Cbc_getNumRows(Cbc_Model * model)
-    ;
-    /** Number of variables in the model */
-    COINLIBAPI int COINLINKAGE
-    Cbc_getNumCols(Cbc_Model * model)
-    ;
-    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore) */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setObjSense(Cbc_Model * model, double sense)
-    ;
-    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore) */
-    COINLIBAPI double COINLINKAGE
-    Cbc_getObjSense(Cbc_Model * model)
-    ;
-    /** Constraint lower bounds */
-    COINLIBAPI const double* COINLINKAGE
-    Cbc_getRowLower(Cbc_Model * model)
-    ;
-    /** Set the lower bound of a single constraint */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setRowLower(Cbc_Model * model, int index, double value)
-    ;
-    /** Constraint upper bounds */
-    COINLIBAPI const double* COINLINKAGE
-    Cbc_getRowUpper(Cbc_Model * model)
-    ;
-    /** Set the upper bound of a single constraint */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setRowUpper(Cbc_Model * model, int index, double value)
-    ;
-    /** Objective vector */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getObjCoefficients(Cbc_Model * model)
-    ;
-    /** Set the objective coefficient of a single variable */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setObjCoeff(Cbc_Model * model, int index, double value)
-    ;
-    /** Variable lower bounds */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getColLower(Cbc_Model * model)
-    ;
-    /** Set the lower bound of a single variable */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setColLower(Cbc_Model * model, int index, double value)
-    ;
-    /** Variable upper bounds */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getColUpper(Cbc_Model * model)
-    ;
-    /** Set the upper bound of a single variable */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setColUpper(Cbc_Model * model, int index, double value)
-    ;
-    /** Determine whether the ith variable is integer restricted */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isInteger(Cbc_Model * model, int i)
-    ;
-    /** Set this variable to be continuous */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setContinuous(Cbc_Model * model, int iColumn)
-    ;
-    /** Set this variable to be integer */
-    COINLIBAPI void COINLINKAGE
-    Cbc_setInteger(Cbc_Model * model, int iColumn)
-    ;
-    /** Add SOS constraints to the model using row-order matrix */
-    COINLIBAPI void  COINLINKAGE
-    Cbc_addSOS(Cbc_Model * model, int numRows, const int * rowStarts,
-               const int * colIndices, const double * weights, const int type)
-    ;
-    /** Print the model */
-    COINLIBAPI void COINLINKAGE
-    Cbc_printModel(Cbc_Model * model, const char * argPrefix)
-    ;
-    /** Return a copy of this model */
-    COINLIBAPI Cbc_Model * COINLINKAGE
-    Cbc_clone(Cbc_Model * model)
-    ;
-    /*@}*/
-    /**@name Solver parameters */
-    /*@{*/
-    /** Set parameter "name" to value "value". Note that this
-     * translates directly to using "-name value" as a 
-     * command-line argument to Cbc.*/
-    COINLIBAPI void COINLINKAGE
-    Cbc_setParameter(Cbc_Model * model, const char * name, const char * value)
-    ;
-
-    
-    /*@}*/
-    /**@name Message handling.  Call backs are handled by ONE function */
-    /*@{*/
-    /** Pass in Callback function.
-     Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */
-    COINLIBAPI void COINLINKAGE
-    Cbc_registerCallBack(Cbc_Model * model,
-                         cbc_callback userCallBack)
-    ;
-    /** Unset Callback function */
-    COINLIBAPI void COINLINKAGE
-    Cbc_clearCallBack(Cbc_Model * model)
-    ;
-
-    /*@}*/
-
-
-    /**@name Solving the model */
-    /*@{*/
-    /* Solve the model with Cbc (using CbcMain1).
-    */
-    COINLIBAPI int COINLINKAGE
-    Cbc_solve(Cbc_Model * model)
-    ;
-    /*@}*/
-
-
-    /**@name Accessing the solution and solution status */
-    /*@{*/
-
-    /** Sum of primal infeasibilities */
-    COINLIBAPI double COINLINKAGE
-    Cbc_sumPrimalInfeasibilities(Cbc_Model * model)
-    ;
-    /** Number of primal infeasibilities */
-    COINLIBAPI int COINLINKAGE
-    Cbc_numberPrimalInfeasibilities(Cbc_Model * model)
-    ;
-
-    /** Just check solution (for external use) - sets sum of
-        infeasibilities etc */
-    COINLIBAPI void COINLINKAGE
-    Cbc_checkSolution(Cbc_Model * model)
-    ;
-
-    /** Number of iterations */
-    COINLIBAPI int COINLINKAGE
-    Cbc_getIterationCount(Cbc_Model * model)
-    ;
-    /** Are there a numerical difficulties? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isAbandoned(Cbc_Model * model)
-    ;
-    /** Is optimality proven? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isProvenOptimal(Cbc_Model * model)
-    ;
-    /** Is infeasiblity proven (or none better than cutoff)? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isProvenInfeasible(Cbc_Model * model)
-    ;
-    /** Was continuous solution unbounded? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isContinuousUnbounded(Cbc_Model * model)
-    ;
-    /** Node limit reached? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isNodeLimitReached(Cbc_Model * model)
-    ;
-    /** Time limit reached? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isSecondsLimitReached(Cbc_Model * model)
-    ;
-    /** Solution limit reached? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isSolutionLimitReached(Cbc_Model * model)
-    ;
-    /** Are there numerical difficulties (for initialSolve) ? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isInitialSolveAbandoned(Cbc_Model * model)
-    ;
-    /** Is optimality proven (for initialSolve) ? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isInitialSolveProvenOptimal(Cbc_Model * model)
-    ;
-    /** Is primal infeasiblity proven (for initialSolve) ? */
-    COINLIBAPI int COINLINKAGE
-    Cbc_isInitialSolveProvenPrimalInfeasible(Cbc_Model * model)
-    ;
-    /** "row" solution
-     *  This is the vector A*x, where A is the constraint matrix
-     *  and x is the current solution. */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getRowActivity(Cbc_Model * model)
-    ;
-    /** Best feasible solution vector */
-    COINLIBAPI const double * COINLINKAGE
-    Cbc_getColSolution(Cbc_Model * model)
-    ;
-    /** Objective value of best feasible solution */
-    COINLIBAPI double COINLINKAGE
-    Cbc_getObjValue(Cbc_Model * model)
-    ;
-    /** Best known bound on the optimal objective value */
-    COINLIBAPI double COINLINKAGE
-    Cbc_getBestPossibleObjValue(Cbc_Model * model)
-    ;
-    /** Number of nodes explored in B&B tree */
-    COINLIBAPI int COINLINKAGE
-    Cbc_getNodeCount(Cbc_Model * model)
-    ;
-    /** Print the solution */
-    COINLIBAPI void  COINLINKAGE
-    Cbc_printSolution(Cbc_Model * model)
-    ;
-    /** Final status of problem
-        Some of these can be found out by is...... functions
-        -1 before branchAndBound
-        0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
-        (or check value of best solution)
-        1 stopped - on maxnodes, maxsols, maxtime
-        2 difficulties so run was abandoned
-        (5 event user programmed event occurred)
-    */
-    COINLIBAPI int COINLINKAGE
-    Cbc_status(Cbc_Model * model)
-    ;
-    /** Secondary status of problem
-        -1 unset (status_ will also be -1)
-        0 search completed with solution
-        1 linear relaxation not feasible (or worse than cutoff)
-        2 stopped on gap
-        3 stopped on nodes
-        4 stopped on time
-        5 stopped on user event
-        6 stopped on solutions
-        7 linear relaxation unbounded
-        8 stopped on iteration limit
-    */
-    COINLIBAPI int COINLINKAGE
-    Cbc_secondaryStatus(Cbc_Model * model)
-    ;
-    /*@}*/
-#ifdef __cplusplus
-}
-#endif
-#endif