ruby-cbc 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6408ef204ef7ceb4088aa23e8e6181f898206050
+  data.tar.gz: 98f4aed015a1634a9f89a2b49a47a0173cdebf2b
+SHA512:
+  metadata.gz: 65c5931e77fa9825950fe46262ee1b406b5d828126c49253e02933318960277861678b15ca628f7b1e9c014a54b5f0bbd57ed3e32bb7e20e3d42ea53813953f5
+  data.tar.gz: 716c96e89888d24df1f82515c32a05cdf9755ac5e0f7ffa36fb751d694c59e19a898814ec754f82256eba555cbc53344dd4b2404124243ff9a63cb18643e7242

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/README.md

@@ -0,0 +1,203 @@
+# Ruby-Cbc
+
+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'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cbc
+
+The gem includes a version of the Coin-Or Cbc library. If the system on which
+it is installed is not Linux 64bits, it downloads the library sources and
+recompiles them at installation.
+
+It also works on Heroku.
+
+## Usage
+
+```ruby
+# The same Brief Example as found in section 1.3 of 
+# glpk-4.44/doc/glpk.pdf.
+#
+# maximize
+#   z = 10 * x1 + 6 * x2 + 4 * x3
+#
+# subject to
+#   p:      x1 +     x2 +     x3 <= 100
+#   q: 10 * x1 + 4 * x2 + 5 * x3 <= 600
+#   r:  2 * x1 + 2 * x2 + 6 * x3 <= 300
+#
+# where all variables are non-negative
+#   x1 >= 0, x2 >= 0, x3 >= 0
+#
+m = Cbc::Model.new
+x1, x2, x3 = m.int_var_array(3, 0..Cbc::INF)
+
+m.maximize(10 * x1 + 6 * x2 + 4 * x3)
+
+m.enforce(x1 + x2 + x3 <= 100)
+m.enforce(10 * x1 + 4 * x2 + 5 * x3 <= 600)
+m.enforce(2 * x1 + 2 * x2 + 6* x3 <= 300)
+
+p = m.to_problem
+
+p.solve
+
+if ! p.proven_infeasible?
+  puts "x1 = #{p.value_of(x1)}"
+  puts "x2 = #{p.value_of(x2)}"
+  puts "x3 = #{p.value_of(x3)}"
+end
+```
+### Modelling
+
+Let's have a model :
+```ruby
+model = Cbc::Model.new
+```
+#### The variables
+
+3 variable kinds are available:
+```ruby
+x = model.bin_var(name: "x")        # a binary variable (i.e. can take values 0 and 1)
+y = model.int_var(L..U, name: "y")  # a integer variable, L <= y <= U
+z = model.cont_var(L..U, name: "z") # a continuous variable, L <= z <= U
+```
+Name is optional and used only when displaying the model.
+
+If you don't specify the range, the variables are free.
+You can also use ```Cbc::INF``` as the infinity bound.
+
+Each one of these 3 kinds have also an array method that generate several variables.
+For instance to generate 3 positive integer variables named x, y and z :
+```ruby
+x, y, z = model.int_var_array(3, 0..Cbc::INF, names: ["x", "y", "z"])
+```
+
+#### The constraints
+
+You can enforce constraints:
+```ruby
+model.enforce(x + y - z <= 10)
+```
+You are not restricted to usual linear programming rules when writing a constraint.
+Usually you would have to write ```x - y = 0``` to express ```x = y```. Ruby-Cbc allows you to put variables and constants on both sides of the comparison operator. You can write
+```ruby
+model.enforce(x - y == 0)
+model.enforce(x == y)
+model.enforce(x + 2 == y + 2)
+model.enforce(0 == x - y)
+```
+
+Linear constraints are usually of the form
+```ruby
+a1 * x1 + a2 * x2 + ... + an * xn <= C
+a1 * x1 + a2 * x2 + ... + an * xn >= C
+a1 * x1 + a2 * x2 + ... + an * xn == C
+```
+
+With Ruby-Cbc you can write
+```ruby
+2 * (2 + 5 * x) + 4 * 5 + 1 == 1 + 4 * 5
+```
+The (in)equation must still be a **linear** (in)equation, you cannot multiply two variables !
+
+#### Objective
+
+You can set the objective:
+```ruby
+model.maximize(3 * x + 2 * y)
+model.minimize(3 * x + 2 * y)
+```
+
+#### Displaying the model
+
+the `Model` instances have a `to_s` method. You can then run
+```ruby
+puts model
+```
+The model will be printed in LP format.
+
+For instance:
+```
+Maximize
+  + 10 x1 + 6 x2 + 4 x3
+
+Subject To
+  + x1 + x2 + x3 <= 100
+  + 10 x1 + 4 x2 + 5 x3 <= 600
+  + 2 x1 + 2 x2 + 6 x3 <= 300
+
+Bounds
+  0 <= x1 <= +inf
+  0 <= x2 <= +inf
+  0 <= x3 <= +inf
+
+Generals
+  x1
+  x2
+  x3
+
+End
+```
+
+### Solving
+
+To solve the model, you need to first transform it to a problem.
+```ruby
+problem = model.to_problem
+```
+
+You can define a time limit to the resolution
+```ruby
+problem.set_time_limit(nb_seconds)
+```
+
+You can solve the Linear Problem
+```ruby
+problem.solve
+```
+
+You can specify arguments that match the cbc command line
+```ruby
+problem.solve(sec: 60) # equivalent to $ cbc -sec 60
+problem.solve(log: 1)  # equivalent to $ cbc -log 1
+```
+For more examples of available options, if `coinor-cbc` is installed run
+
+    $ cbc
+
+then type `?`
+
+Once `problem.solve` has finished you can query the status:
+```ruby
+problem.proven_infeasible?  # will tell you if the problem has no solution
+problem.proven_optimal?     # will tell you if the problem is solved optimally
+problem.time_limit_reached? # Will tell you if the solve timed out
+```
+
+To have the different values, do
+```ruby
+problem.objective_value # Will tell you the value of the best objective
+problem.best_bound      # Will tell you the best known bound
+                        # if the bound equals the objective value, the problem is optimally solved
+problem.value_of(var)   # will tell you the computed value or a variable
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gverger/ruby-cbc.
+

data/Rakefile

@@ -0,0 +1,40 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rake/extensiontask'
+
+def in_dir(path)
+  original_dir = Dir.pwd
+  Dir.chdir(path)
+  yield
+ensure
+  Dir.chdir(original_dir)
+end
+
+# RSpec::Core::RakeTask.new(:spec)
+#
+# spec = Gem::Specification.load('ruby-cbc.gemspec')
+# Rake::ExtensionTask.new('ruby-cbc', spec) do |ext|
+#   ext.lib_dir = 'lib/ruby-cbc'
+#   ext.tmp_dir = "tmp"
+#   ext.name = 'cbc_wrapper'
+# end
+
+SHARED_LIBRARY_EXTENSION = RUBY_PLATFORM.include?("darwin") ? 'bundle' : 'so'
+EXTENSION = 'lib/ruby-cbc/cbc_wrapper.'+SHARED_LIBRARY_EXTENSION
+
+desc "Use extconf.rb and make to build the extension."
+task :build_extension => EXTENSION
+
+file EXTENSION => 'ext/ruby-cbc/cbc_wrap.c' do
+  puts "start"
+  in_dir('ext/ruby-cbc') do
+    system("ruby extconf.rb")
+    system("make")
+  end
+end
+
+CLEAN.include('ext/ruby-cbc/Makefile', 'ext/ruby-cbc/conftest.dSYM', 'ext/ruby-cbc/mkmf.log', 'ext/ruby-cbc/cbc_wrap.o')
+
+CLOBBER.include('ext/ruby-cbc/cbc_wrap.c', 'ruby-cbc.gemspec')
+
+task :default => [:build_extension, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cbc"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/ruby-cbc/cbc.i

@@ -0,0 +1,15 @@
+%module cbc_wrapper
+
+%include "typemaps.i"
+%include "carrays.i"
+
+%{
+#include "Coin_C_defines.h"
+#include "Cbc_C_Interface.h"
+%}
+
+%array_class(int, IntArray)
+%array_class(double, DoubleArray)
+
+%include "Coin_C_defines.h"
+%include "Cbc_C_Interface.h"