cbc-wrapper 2.9.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3176d8dfba6c230a803fb332c3cfd5bbe99e3490
+  data.tar.gz: a04e0e5ca7f307e43708ca1bfd5756a430dc0434
+SHA512:
+  metadata.gz: 3d0431ee7a3871cd7ef72097c998a987b5a7811d7983cc7b376470567f9f4bd77caeb64052d4db22c7299bf8db889791ffabf301fb881358b7c9de5f7d0948d1
+  data.tar.gz: 6c4d00bfebab09ac0197ab6d60e1c7d7e37b7c2e01d36a84a692e8edf3536554ce5e5b69056ba14a69cd2c39ca29f603cb78d52a3f8263a4d26bb04c664873af

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cbc.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,239 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+    a) in the case of the initial Contributor, the initial code and
+    documentation distributed under this Agreement, and
+
+    b) in the case of each subsequent Contributor:
+
+        i) changes to the Program, and
+
+	ii) additions to the Program;
+
+    where such changes and/or additions to the Program originate
+    from and are distributed by that particular Contributor. A
+    Contribution 'originates' from a Contributor if it was added to
+    the Program by such Contributor itself or anyone acting on such
+    Contributor's behalf. Contributions do not include additions to
+    the Program which: (i) are separate modules of software
+    distributed in conjunction with the Program under their own
+    license agreement, and (ii) are not derivative works of the
+    Program.
+
+"Contributor" means any person or entity that distributes the
+Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor
+which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with
+this Agreement.
+
+"Recipient" means anyone who receives the Program under this
+Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free copyright
+license to reproduce, prepare derivative works of, publicly display,
+publicly perform, distribute and sublicense the Contribution of such
+Contributor, if any, and such derivative works, in source code and
+object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free patent
+license under Licensed Patents to make, use, sell, offer to sell,
+import and otherwise transfer the Contribution of such Contributor,
+if any, in source code and object code form. This patent license
+shall apply to the combination of the Contribution and the Program
+if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any
+other combinations which include the Contribution. No hardware per
+se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the
+licenses to its Contributions set forth herein, no assurances are
+provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other
+entity. Each Contributor disclaims any liability to Recipient for
+claims brought by any other entity based on infringement of
+intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, each Recipient
+hereby assumes sole responsibility to secure any other intellectual
+property rights needed, if any. For example, if a third party patent
+license is required to allow Recipient to distribute the Program, it
+is Recipient's responsibility to acquire that license before
+distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has
+sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:
+
+    a) it complies with the terms and conditions of this Agreement;
+    and
+
+    b) its license agreement:
+
+        i) effectively disclaims on behalf of all Contributors all
+	warranties and conditions, express and implied, including
+	warranties or conditions of title and non-infringement, and
+	implied warranties or conditions of merchantability and
+	fitness for a particular purpose;
+
+	ii) effectively excludes on behalf of all Contributors all
+        liability for damages, including direct, indirect, special,
+        incidental and consequential damages, such as lost profits;
+
+        iii) states that any provisions which differ from this
+        Agreement are offered by that Contributor alone and not by
+        any other party; and
+
+        iv) states that source code for the Program is available
+        from such Contributor, and informs licensees how to obtain
+        it in a reasonable manner on or through a medium customarily
+        used for software exchange.
+
+When the Program is made available in source code form:
+
+    a) it must be made available under this Agreement; and
+
+    b) a copy of this Agreement must be included with each copy of
+    the Program.
+
+Contributors may not remove or alter any copyright notices contained
+within the Program.
+
+Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the
+commercial use of the Program, the Contributor who includes the
+Program in a commercial product offering should do so in a manner
+which does not create potential liability for other
+Contributors. Therefore, if a Contributor includes the Program in a
+commercial product offering, such Contributor ("Commercial
+Contributor") hereby agrees to defend and indemnify every other
+Contributor ("Indemnified Contributor") against any losses, damages
+and costs (collectively "Losses") arising from claims, lawsuits and
+other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the
+Program in a commercial product offering. The obligations in this
+section do not apply to any claims or Losses relating to any actual
+or alleged intellectual property infringement. In order to qualify,
+an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial
+Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement
+negotiations. The Indemnified Contributor may participate in any
+such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's
+responsibility alone. Under this section, the Commercial Contributor
+would have to defend claims against the other Contributors related
+to those performance claims and warranties, and if a court requires
+any other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient
+is solely responsible for determining the appropriateness of using
+and distributing the Program and assumes all risks associated with
+its exercise of rights under this Agreement , including but not
+limited to the risks and costs of program errors, compliance with
+applicable laws, damage to or loss of data, programs or equipment,
+and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability
+of the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to
+the minimum extent necessary to make such provision valid and
+enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+the Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then
+such Recipient's rights granted under Section 2(b) shall terminate
+as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably
+practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall
+continue and survive.
+
+Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions
+(including revisions) of this Agreement from time to time. No one
+other than the Agreement Steward has the right to modify this
+Agreement. The Eclipse Foundation is the initial Agreement
+Steward. The Eclipse Foundation may assign the responsibility to
+serve as the Agreement Steward to a suitable separate entity. Each
+new version of the Agreement will be given a distinguishing version
+number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it
+was received. In addition, after a new version of the Agreement is
+published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives
+no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly
+granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No
+party to this Agreement will bring a legal action under this
+Agreement more than one year after the cause of action arose. Each
+party waives its rights to a jury trial in any resulting litigation.

data/README.md

@@ -0,0 +1,397 @@
+# Cbc-Wrapper
+
+This gem wraps the Coin-Or Cbc Mixed Integer Linear Programming Library.
+It uses the version 2.9.7 of Cbc.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cbc-wrapper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cbc-wrapper
+
+The gem includes a version of the Coin-Or Cbc library. It downloads the library sources and
+recompiles them at installation. (curl, make and some gcc tools are needed)
+
+It also works on Heroku.
+
+## Usage
+
+All functions defined in Cbc_C_interface.h are wrapped. You can use any function named
+`func_name` with 
+```ruby
+Cbc_wrapper.func_name
+```
+
+You can find an example on how to use it at https://github.com/gverger/ruby-cbc.
+
+Below is the Cbc_C_interface.h file:
+
+```c
+    /**@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)
+    ;
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gverger/cbc-wrapper.
+