rulp 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjEyMDI0ZDM1NzVhNWE3NmJkYTk5Yzg3ODQyMjRiMmYxOWFkMDdkZQ==
+  data.tar.gz: !binary |-
+    YzE0NmE1YzFhNDg1YTI4YjUzNTc3YmY2NzA4NTI3MDE1NGE2MzI2NA==
+SHA512:
+  metadata.gz: !binary |-
+    M2ZhODczODZkYmU4ZGQ0N2RmZGM4MzZiN2ZmYjc3NjhkZjAyOTE0MjE0MWNj
+    ZTI1MWJkYzA5YWI0NmQyMjE1NmJjNTZhMGUxYjIyNDA4NzhjZDQzZTBkNzNi
+    ZjE3ZjQwZjEyNDI4YWNmYTkwMDk5NzZkYjliYTIxMTczMGJlODY=
+  data.tar.gz: !binary |-
+    ODhjYmYwOGY1N2E0MDc2OTlmYjBjZTRjN2VmMDk5NjVkOGIyMDM3NDA4ZTU2
+    YWE0MWU3ODIwY2VhZmI4NWU0OTcwMDg0ZmJiMzIzNTk2OGIwZDQ2ZTUwMDFh
+    ZTIwM2EwZDVmYWMyZjdkYzgwZDZiYWQyYmJmN2Y5ZjYzMjdmNWQ=

data/bin/rulp

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require_relative '../lib/rulp'
+begin
+  load Gem.bin_path('pry', 'pry', ">= 0.9")
+rescue
+  require 'irb'
+  ARGV.clear # otherwise all script parameters get passed to IRB
+  IRB.start
+end

data/lib/extensions/array_extensions.rb

@@ -0,0 +1,5 @@
+class Array
+  def sum
+    self.inject(:+)
+  end
+end

data/lib/extensions/extensions.rb

@@ -0,0 +1,3 @@
+require_relative './array_extensions'
+require_relative './kernel_extensions'
+require_relative './object_extensions'

data/lib/extensions/kernel_extensions.rb

@@ -0,0 +1,82 @@
+##
+# Kernel extension to allow numbered LP variables to be initialised dynamically using the following
+# syntax.
+#
+# [Capitalized_varname][lp var type suffix]( integer )
+#
+# This is similar to the syntax defined in the object extensions but allows for numbered
+# suffixes to quickly generate ranges of similar variables.
+#
+# Where lp var type suffix is either _b for binary, _i for integer, or _f for float.
+# I.e
+#
+# Rating_i(5) is the equivalent of Rating_5 (type integer)
+# Is_happy_b(2) is the equivalent of Is_happy_2 (type binary/boolean)
+# ...
+##
+module Kernel
+  alias_method :old_method_missing, :method_missing
+  def method_missing(value, *args)
+    method_name = "#{value}" rescue ""
+    start = method_name[0]
+    if (start <= "Z" && start >= "A")
+      case method_name[-1]
+      when "b"
+        method_name = method_name[0..(method_name[-2] == "_" ? -3 : -2)] + args.join("_")
+        return BV.send(method_name)
+      when "i"
+        method_name = method_name[0..(method_name[-2] == "_" ? -3 : -2)] + args.join("_")
+        return IV.send(method_name)
+      when "f"
+        method_name = method_name[0..(method_name[-2] == "_" ? -3 : -2)] + args.join("_")
+        return LV.send(method_name)
+      end
+    end
+    old_method_missing(value, *args)
+  end
+
+  def _profile
+    start        = Time.now
+    return_value = yield
+    return return_value, Time.now - start
+  end
+end
+
+
+module Kernel
+  ##
+  # Adds assertion capabilities to ruby.
+  # The assert function will raise an error if the inner block returns false.
+  # The error will contain the file, line number and source line of the failing assertion.
+  ##
+  class AssertionException < Exception; end
+
+  ##
+  # Ensure the SCRIPT_LINES global variable exists so that we can access the source of the failed assertion
+  ##
+  ::SCRIPT_LINES__ = {} unless defined? ::SCRIPT_LINES__
+
+  ##
+  # If assertion returns false we return a new assertion exception with the failing file and line,
+  # and attempt to return the failed source if accessible.
+  ##
+  def assert(truthy=false)
+    unless truthy || (block_given? && yield)
+      file, line = caller[0].split(":")
+      error_message = "Assertion Failed! < #{file}:#{line}:#{ SCRIPT_LINES__[file][line.to_i - 1][0..-2] rescue ''} >"
+      raise AssertionException.new(error_message)
+    end
+  end
+end
+
+
+def given
+  @dummy ||= begin
+   dummy =  {}
+    class << dummy
+      def [](*args)
+      end
+    end
+    dummy
+  end
+end

data/lib/extensions/object_extensions.rb

@@ -0,0 +1,26 @@
+##
+# Object extension to allow numbered LP variables to be initialised dynamically using the following
+# syntax.
+#
+# [Capitalized_varname][lp var type suffix]
+#
+# Where lp var type suffix is either _b for binary, _i for integer, or _f for float.
+# I.e
+#
+# Rating_i is the equivalent of Rating (type integer)
+# Is_happy_b is the equivalent of Is_happy (type binary/boolean)
+##
+class << Object
+  def const_missing(value)
+    method_name = "#{value}" rescue ""
+    if (("A".."Z").include?(method_name[0]))
+      if(method_name.end_with?("b"))
+        BV.send(method_name[0..(method_name[-2] == "_" ? -3 : -2)])
+      elsif(method_name.end_with?("i"))
+        IV.send(method_name[0..(method_name[-2] == "_" ? -3 : -2)])
+      elsif(method_name.end_with?("f"))
+        LV.send(method_name[0..(method_name[-2] == "_" ? -3 : -2)])
+      end
+    end
+  end
+end

data/lib/helpers/log.rb

@@ -0,0 +1,57 @@
+##
+# Basic logger module.
+# Allows logging in the format
+#
+# "This is a string".log(:debug)
+# "Oh no!".log(:error)
+#
+# Log level is set as follows.
+# Rulp::Logger::level = :debug
+#
+##
+module Rulp
+  module Logger
+    DEBUG = 5
+    INFO  = 4
+    WARN  = 3
+    ERROR = 2
+    OFF   = 1
+
+    LEVELS = {
+      debug: DEBUG,
+      info: INFO,
+      warn: WARN,
+      error: ERROR,
+      off: OFF
+    }
+
+    def self.level=(value)
+      raise Exception.new("#{value} is not a valid log level") unless LEVELS[value]
+      @@level = value
+    end
+
+    def self.level
+      @@level || :info
+    end
+
+    def self.log(level, message)
+      if(LEVELS[level].to_i <= LEVELS[self.level])
+        puts("[#{level}] #{message}")
+      end
+    end
+
+    self.level = :info
+
+    class ::String
+      def log(level)
+        Logger::log(level, self)
+      end
+    end
+
+    class ::Array
+      def log(level, sep="\n")
+        Logger::log(level, self.join("#{sep}[#{level}] "))
+      end
+    end
+  end
+end

data/lib/rulp.rb

@@ -0,0 +1,2 @@
+STDOUT.sync = true
+require_relative 'rulp/rulp'

data/lib/rulp/constraint.rb

@@ -0,0 +1,17 @@
+##
+# An LP Expression constraint. A mathematical expression of which the result
+# must be constrained in some way.
+##
+class Constraint
+  def initialize(*constraint_expression)
+    @expressions , @constraint_op, @value = constraint_expression
+  end
+
+  def variables
+    @expressions.variables
+  end
+
+  def to_s
+    return "#{@expressions} #{@constraint_op == :== ? "=" : @constraint_op} #{@value}"
+  end
+end

data/lib/rulp/expression.rb

@@ -0,0 +1,112 @@
+##
+# An LP Expression. A mathematical expression.
+# Can be a constraint or can be the objective function of a LP or MIP problem.
+##
+class Expressions
+  attr_accessor :expressions
+  def initialize(expressions)
+    @expressions = expressions
+  end
+
+  def +(other)
+    return Expressions.new(@expressions + [other])
+  end
+
+  def to_s
+    @expressions.map{|expression|
+      [expression.operand < 0 ? " " : " + ", expression.to_s]
+    }.flatten[1..-1].join("")
+  end
+
+  def variables
+    @expressions.map(&:variable)
+  end
+
+  [:==, :<, :<=, :>, :>=].each do |constraint_type|
+    define_method(constraint_type){|value|
+      Constraint.new(self, constraint_type, value)
+    }
+  end
+
+  def -@
+    -self.expressions[0]
+    self
+  end
+
+  def -(other)
+    other = -other
+    self + other
+  end
+
+  def +(other)
+    Expressions.new(self.expressions + Expressions[other].expressions)
+  end
+
+  def self.[](value)
+    return Expressions.new([Fragment.new(value, 1)]) if value.kind_of?(LV)
+    return Expressions.new([value]) if value.kind_of?(Fragment)
+    return value if value.kind_of?(Expressions)
+  end
+
+  def evaluate
+    self.expressions.map(&:evaluate).inject(:+)
+  end
+end
+
+##
+# An expression fragment. An expression can consist of many fragments.
+##
+class Fragment
+  attr_accessor :lv, :operand
+
+  def initialize(lv, operand)
+    @lv = lv
+    @operand = operand
+  end
+
+  def +(other)
+    return Expressions.new([self] + Expressions[other].expressions)
+  end
+
+  def -(other)
+    self.+(-other)
+  end
+
+  def *(value)
+    Fragment.new(@lv, @operand * value)
+  end
+
+  def evaluate
+    if [TrueClass,FalseClass].include? @lv.value.class
+      @operand * (@lv.value ? 1 : 0)
+    else
+      @operand * @lv.value
+    end
+  end
+
+  def -@
+    @operand = -@operand
+    self
+  end
+
+  def variable
+    @lv
+  end
+
+  [:==, :<, :<=, :>, :>=].each do |constraint_type|
+    define_method(constraint_type){|value|
+      Constraint.new(Expressions.new(self), constraint_type, value)
+    }
+  end
+
+  def to_s
+    case @operand
+    when -1
+      "-#{@lv}"
+    when 1
+      "#{@lv}"
+    else
+    "#{@operand} #{@lv}"
+    end
+  end
+end

data/lib/rulp/lv.rb

@@ -0,0 +1,74 @@
+##
+# An LP Variable. Used as arguments in LP Expressions.
+# The subtypes BV and IV represent Binary and Integer variables.
+# These are constructed dynamically by using the special Capitalised variable declaration syntax.
+##
+class LV
+  attr_reader :name
+  attr_accessor :lt, :lte, :gt, :gte, :value
+  include Rulp::Bounds
+  include Rulp::Initializers
+
+  def to_proc
+    ->(index){ send(self.meth(index)) }
+  end
+
+  def meth(index)
+    "#{self.name}#{index}_#{self.suffix}"
+  end
+
+  def suffix
+    "f"
+  end
+
+  def self.method_missing(name, *args)
+    return self.definition( "#{name}#{args.join("_")}" )
+  end
+
+  def self.const_missing(name)
+    return self.definition(name)
+  end
+
+  def self.definition(name)
+    self.class.send(:define_method, name){
+      LV::names_table["#{name}#{self}"] if LV::names_table["#{name}#{self}"].class == self
+    }
+    return self.send(name) || self.new(name)
+  end
+
+  def * (numeric)
+    self.nocoerce
+    Expressions.new([Fragment.new(self, numeric)])
+  end
+
+  def -@
+    return self * -1
+  end
+
+  def -(other)
+    self + (-other)
+  end
+
+  def + (expressions)
+    Expressions[self] + Expressions[expressions]
+  end
+
+  def value
+    if self.class == BV
+      return @value.round(2) == 1
+    else
+      @value
+    end
+  end
+end
+
+class BV < LV;
+  def suffix
+    "b"
+  end
+end
+class IV < LV;
+  def suffix
+    "i"
+  end
+end

data/lib/rulp/rulp.rb

@@ -0,0 +1,134 @@
+require_relative "rulp_bounds"
+require_relative "rulp_initializers"
+require_relative "lv"
+require_relative "constraint"
+require_relative "expression"
+
+require_relative "../solvers/solvers"
+require_relative "../extensions/extensions"
+require_relative "../helpers/log"
+
+require 'set'
+
+GLPK  = "glpsol"
+SCIP  = "scip"
+CBC   = "cbc"
+
+module Rulp
+  attr_accessor :expressions
+  MIN = "Minimize"
+  MAX = "Maximize"
+
+  GLPK  = ::GLPK
+  SCIP  = ::SCIP
+  CBC   = ::CBC
+
+  SOLVERS = {
+    "glpsol" => Glpk,
+    "scip"   => Scip,
+    "cbc"    => Cbc
+  }
+
+  def self.Glpk(lp)
+    lp.solve_with(GLPK)
+  end
+
+  def self.Cbc(lp)
+    lp.solve_with(CBC)
+  end
+
+  def self.Scip(lp)
+    lp.solve_with(SCIP)
+  end
+
+  def self.Max(objective_expression)
+    "Creating maximization problem".log :info
+    Problem.new(Rulp::MAX, objective_expression)
+  end
+
+  def self.Min(objective_expression)
+    "Creating minimization problem".log :info
+    Problem.new(Rulp::MIN, objective_expression)
+  end
+
+  class Problem
+    def initialize(objective, objective_expression)
+      @objective = objective
+      @variables = Set.new
+      @objective_expression = objective_expression.kind_of?(LV) ? 1 * objective_expression : objective_expression
+      @variables.merge(@objective_expression.variables)
+      @constraints = []
+    end
+
+    def [](*constraints)
+      @constraints.concat(constraints)
+      @variables.merge(constraints.map(&:variables).flatten)
+      self
+    end
+
+    def constraints
+      @constraints.map.with_index{|constraint, i|
+        " c#{i}: #{constraint}"
+      }.join("\n")
+    end
+
+    def integers
+      ints = @variables.select{|x| x.kind_of?(IV) }.join(" ")
+      return "\nGeneral\n #{ints}" if(ints.length > 0)
+    end
+
+    def bits
+      bits = @variables.select{|x| x.kind_of?(BV) }.join(" ")
+      return "\nBinary\n #{bits}" if(bits.length > 0)
+    end
+
+    def bounds
+      @variables.map{|var|
+        next unless var.bounds_str
+        " #{var.bounds_str}"
+      }.compact.join("\n")
+    end
+
+    def get_output_filename
+      "/tmp/rulp-#{Random.rand(0..1000)}.lp"
+    end
+
+    def output(filename)
+      IO.write(filename, self)
+    end
+
+    def solve_with(type, open_definition=false, open_solution=false)
+      filename = get_output_filename
+      solver = SOLVERS[type].new(filename)
+
+      "Writing problem".log(:info)
+      IO.write(filename, self)
+
+      `open #{filename}` if open_definition
+
+      "Solving problem".log(:info)
+      _, time = _profile{ solver.solve(open_solution) }
+
+      "Solver took #{time}".log(:info)
+
+      "Parsing result".log(:info)
+      solver.store_results(@variables)
+
+      result = @objective_expression.evaluate
+
+      "Objective: #{result}\n#{@variables.map{|v|[v.name, "=", v.value].join(' ') if v.value}.compact.join("\n")}".log(:debug)
+      return result
+    end
+
+    def to_s
+      "\
+#{@objective}
+ obj: #{@objective_expression}
+Subject to
+#{constraints}
+Bounds
+#{bounds}#{integers}#{bits}
+End"
+    end
+  end
+end

data/lib/rulp/rulp_bounds.rb

@@ -0,0 +1,65 @@
+module Rulp
+  module Bounds
+
+    attr_accessor :const
+
+    DIRS = {">" => {value: "gt=", equality: "gte="}, "<" => {value: "lt=", equality: "lte="}}
+    DIRS_REVERSED = {">" => DIRS["<"], "<" => DIRS[">"]}
+
+    def relative_constraint direction, value, equality=false
+      direction = coerced? ? DIRS_REVERSED[direction] : DIRS[direction]
+      self.const = false
+      self.send(direction[:value], value)
+      self.send(direction[:equality], equality)
+      return self
+    end
+
+    def nocoerce
+      @@coerced = false
+    end
+
+    def coerced?
+      was_coerced = @@coerced rescue nil
+      @@coerced = false
+      return was_coerced
+    end
+
+    def >(val)
+      relative_constraint(">", val)
+    end
+
+    def >=(val)
+      relative_constraint(">", val, true)
+    end
+
+    def <(val)
+      relative_constraint("<", val)
+    end
+
+    def <=(val)
+      relative_constraint("<", val, true)
+    end
+
+    def ==(val)
+      self.const = val
+    end
+
+    def coerce(something)
+      @@coerced = true
+      return self, something
+    end
+
+    def bounds_str
+      return nil if !(self.gt || self.lt || self.const)
+      return "#{self.name} = #{self.const}" if self.const
+
+      [
+        self.gt,
+        self.gt ? "<=" : nil,
+        self.name,
+        self.lt ? "<=" : nil,
+        self.lt
+      ].compact.join(" ")
+    end
+  end
+end

data/lib/rulp/rulp_initializers.rb

@@ -0,0 +1,24 @@
+module Rulp
+  module Initializers
+    def initialize(name)
+      raise Exception.new("Variable with the name #{name} of a different type (#{LV::names_table[name].class}) already exists") if LV::names_table[name]
+      LV::names_table["#{name}#{self.class}"] = self
+      @name = name
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def names_table
+        @@names ||= {}
+      end
+    end
+
+    def to_s
+      "#{self.name}"
+    end
+  end
+end
+

data/lib/solvers/cbc.rb

@@ -0,0 +1,24 @@
+class Cbc < Solver
+  def solve(open_solution=false)
+    `#{executable} #{@filename} branch solution #{@outfile}`
+    `open #{@outfile}` if open_solution
+  end
+
+  def executable
+    :cbc
+  end
+
+  def store_results(variables)
+    rows = IO.read(@outfile).split("\n")
+    objective = rows[0].split(/\s+/)[-1].to_f
+    vars_by_name = {}
+    rows[1..-1].each do |row|
+      cols = row.strip.split(/\s+/)
+      vars_by_name[cols[1].to_s] = cols[2].to_f
+    end
+    variables.each do |var|
+      var.value = vars_by_name[var.name.to_s].to_f
+    end
+    return objective
+  end
+end

data/lib/solvers/glpk.rb

@@ -0,0 +1,19 @@
+class Glpk < Solver
+  def solve(open_solution=false)
+    `#{executable} --lp #{@filename} --write #{@outfile}`
+    `open #{@outfile}` if open_solution
+  end
+
+  def executable
+    :glpsol
+  end
+
+  def store_results(variables)
+    rows = IO.read(@outfile).split("\n")
+    variables.zip(rows[-variables.count..-1]).each do |var, row|
+      cols = row.split(" ")
+      var.value = cols[[1, cols.count - 1].min].to_f
+    end
+    return rows[1].split(" ")[-1]
+  end
+end

data/lib/solvers/scip.rb

@@ -0,0 +1,30 @@
+class Scip < Solver
+  def solve(open_solution=false)
+    `#{executable} -f #{@filename} > #{@outfile}`
+    `open #{@outfile}` if open_solution
+  end
+
+  def executable
+    :scip
+  end
+
+  def store_results(variables)
+    results  = IO.read(@outfile)
+    start    = results.sub(/.*?primal solution:.*?=+/m, "")
+    stripped = start.sub(/Statistics.+/m, "").strip
+    rows     = stripped.split("\n")
+
+    objective = rows[0].split(/\s+/)[-1].to_f
+
+    vars_by_name = {}
+    rows[1..-1].each do |row|
+      cols = row.strip.split(/\s+/)
+      vars_by_name[cols[0].to_s] = cols[1].to_f
+    end
+    variables.each do |var|
+      var.value = vars_by_name[var.name.to_s].to_f
+    end
+
+    return objective
+  end
+end

data/lib/solvers/solvers.rb

@@ -0,0 +1,20 @@
+class Solver
+  def initialize(filename)
+    @filename = filename
+    @outfile = "/tmp/#{executable}-output.txt"
+    raise Exception.new("Couldn't find solver #{executable}!") if `which #{executable}`.length == 0
+    @solver_exists = true
+  end
+
+  def store_results(variables)
+    puts "Not yet implemented"
+  end
+
+  def solver_exists?
+    @solver_exists || false
+  end
+end
+
+require_relative 'cbc'
+require_relative 'scip'
+require_relative 'glpk'

data/test/test_boolean.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+##
+#
+# Given 50 items of varying prices
+# Get the minimal sum of 10 items that equals at least $15 dollars
+#
+##
+class BooleanTest < Minitest::Test
+  def setup
+    @items       = 30.times.map(&Shop_Item_b)
+    items_count = @items.sum
+    items_costs = @items.map{|item| item * Random.rand(1.0...5.0)}.sum
+
+    @problem =
+    Rulp::Min( items_costs ) [
+      items_count  >= 10,
+      items_costs  >= 15
+    ]
+  end
+
+  def test_scip
+    solution = Rulp::Scip @problem
+    selected = @items.select(&:value)
+    assert_equal selected.length, 10
+    assert_operator solution.round(2), :>=, 15
+    assert_operator solution, :<=, 25
+  end
+
+  def test_cbc
+    solution = Rulp::Cbc @problem
+    selected = @items.select(&:value)
+    assert_equal selected.length, 10
+    assert_operator solution.round(2), :>=, 15
+    assert_operator solution, :<=, 25
+  end
+
+  def test_glpk
+    solution = Rulp::Glpk @problem
+    selected = @items.select(&:value)
+    assert_equal selected.length, 10
+    assert_operator solution.round(2), :>=, 15
+    assert_operator solution, :<=, 25
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+gem "minitest"
+
+require_relative "../lib/rulp"
+require "minitest/autorun"
+
+Rulp::Logger::level = :off

data/test/test_simple.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+# maximize
+#   z = 10 * x + 6 * y + 4 * z
+#
+# subject to
+#   p:      x +     y +     z <= 100
+#   q: 10 * x + 4 * y + 5 * z <= 600
+#   r:  2 * x + 2 * y + 6 * z <= 300
+#
+# where all variables are non-negative integers
+#   x >= 0, y >= 0, z >= 0
+#
+
+class SimpleTest < Minitest::Test
+  def setup
+    given[ X_i >= 0,  Y_i >= 0,  Z_i >= 0 ]
+    @problem =
+    Rulp::Max( 10 * X_i + 6 * Y_i + 4 * Z_i ) [
+                    X_i +     Y_i +     Z_i <= 100,
+               10 * X_i + 4 * Y_i + 5 * Z_i <= 600,
+               2 *  X_i + 2 * Y_i + 6 * Z_i <= 300
+    ]
+  end
+
+  def test_scip
+    solution =   Rulp::Scip @problem
+    assert_equal X_i.value, 33
+    assert_equal Y_i.value, 67
+    assert_equal Z_i.value, 0
+    assert_equal solution , 732
+
+  end
+
+  def test_cbc
+    solution =   Rulp::Cbc @problem
+    assert_equal X_i.value, 33
+    assert_equal Y_i.value, 67
+    assert_equal Z_i.value, 0
+    assert_equal solution , 732
+
+  end
+
+  def test_glpk
+    solution =   Rulp::Glpk @problem
+    assert_equal X_i.value, 33
+    assert_equal Y_i.value, 67
+    assert_equal Z_i.value, 0
+    assert_equal solution , 732
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: rulp
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Wouter Coppieters
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-18 00:00:00.000000000 Z
+dependencies: []
+description: A simple Ruby LP description DSL
+email: wc@pico.net.nz
+executables:
+- rulp
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rulp
+- lib/extensions/array_extensions.rb
+- lib/extensions/extensions.rb
+- lib/extensions/kernel_extensions.rb
+- lib/extensions/object_extensions.rb
+- lib/helpers/log.rb
+- lib/rulp.rb
+- lib/rulp/constraint.rb
+- lib/rulp/expression.rb
+- lib/rulp/lv.rb
+- lib/rulp/rulp.rb
+- lib/rulp/rulp_bounds.rb
+- lib/rulp/rulp_initializers.rb
+- lib/solvers/cbc.rb
+- lib/solvers/glpk.rb
+- lib/solvers/scip.rb
+- lib/solvers/solvers.rb
+- test/test_boolean.rb
+- test/test_helper.rb
+- test/test_simple.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: Ruby Linear Programming
+test_files:
+- test/test_boolean.rb
+- test/test_helper.rb
+- test/test_simple.rb
+has_rdoc: