lp_select 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,165 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,96 @@
+# LpSelect
+
+
+This gem provides both an FFI interface to the lp_solve library and a simplified interface
+designed to pick from a set of choices to satisfy constraints (LPSelect). 
+
+lp_solve is a Mixed Integer Linear Programming (MILP) solver.  It solves pure linear, (mixed) integer/binary, 
+semi-cont and special ordered sets (SOS) models.  lp_solve is written in ANSI C and can be compiled on many 
+different platforms like Linux and WINDOWS.
+
+The lp_solve library is included and dynamically loaded.  The gem will look for the library in the 
+lib/binaries folder, and searches for the first library it can load in this order:
+
+liblpsolve55.dylib
+liblpsolve55.dylib-ppc
+liblpsolve55.dylib.x86-64
+liblpsolve55.so
+liblpsolve55.so-ux64
+lpsolve55.dll
+
+
+You can download and compile the liblpsolve library from http://sourceforge.net/projects/lpsolve/
+
+LPSelect is designed for selecting a set of things that satisfies as many constraints as possible.
+The lp_select_test.rb test is a contrived example showing how it can be used to select a fruit salad
+at the lowest cost that satisfies the most people.  The price of each fruit is a weight and the objective
+is to minimize the cost (ie weight) of the selected fruits.  Each person's choices is added as a
+constraint row.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lp_select'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lp_select
+
+
+## Usage
+
+Current usage is focused on a handful of known problems to be solved, but it is easily extensible.  
+
+The lp_solve library uses 1 indexed arrays.
+
+There is more example usage in the LPSelect library and tests
+
+```ruby
+# Make a three row five column equation
+@lp = LPSolve::make_lp(3, 5) 
+
+# Set some column names
+LPSolve::set_col_name(@lp, 1, "fred")
+LPSolve::set_col_name(@lp, 2, "bob")
+# Add a constraint and a row name, the API expects a 1 indexed array
+constraint_vars = [0, 0, 1]
+FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+  p.write_array_of_double(constraint_vars)
+  LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+end
+LPSolve::set_row_name(@lp, 1, "onlyBob")
+
+# Set the objective function and minimize it
+constraint_vars = [1.0, 3.0]
+FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+  p.write_array_of_double(constraint_vars)
+  LPSolve::set_obj_fn(@lp, p)
+end
+LPSolve::set_minim(@lp)
+
+# Solve it and retreive the result
+LPSolve::solve(@lp) 
+@objective = LPSolve::get_objective(@lp)
+
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Contributors
+* James Prior
+* Jake Sower
+* Mattias Ekberg

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/lib/lp_select.rb

@@ -0,0 +1,9 @@
+require "lp_select/version"
+
+require 'ffi'
+require 'yaml'
+
+module LpSelect
+  require 'lp_select/lp_solve.rb'
+  require 'lp_select/lp_select.rb'
+end

data/lib/lp_select/lp_select.rb

@@ -0,0 +1,239 @@
+
+# -----------------------------------------------
+#  
+#  This class relies on the lpsolve library hooks, and 
+#  serves as an interface for solving specialized
+#  selection problems.  It uses binary variables 
+#  with assigned names to determine what is selected
+# -----------------------------------------------
+
+include LPSolve
+
+class LPSelect
+  
+  attr_reader :vars, :lp, :model_name, :results, :objective, :constraints, :objective_row
+  CONSTRAINT_ROW = {:name => "", :vars => [], :op => nil, :target => nil} #our own little format
+  
+  
+  # Create a new selection equation, either by passing a list of variables
+  # corresponding to applicants, or by passing a YAML file or string that
+  # represents an equation serialized by this same model.
+  #
+  # Optionally it can load a file from disk in the lp format and solve it, 
+  # although many of the utilities for inspecting the equation and serializing
+  # it will be non-functional
+  def initialize(opts = {})
+    
+    # The objective is the overall equation to solve, in our case, the minimum
+    # sum of each applicants rank
+    @objective_row = {:direction => "min", :weights => {} }
+    @constraints = [] #This will be filled with dups of CONSTRAINT_ROW
+    @var_struct = nil
+    
+    if opts[:filename] && File::exists?(opts[:filename])
+      load_from_file(opts[:filename])
+    elsif opts[:vars]
+      raise "Invalid option, vars must be an array" unless opts[:vars].is_a? Array
+      create_new(opts[:vars])
+    elsif opts[:yaml]
+      load_from_yaml(opts[:yaml])
+    else
+      raise "Must pass :filename, :yaml, or :vars"
+    end
+    
+    @model_name = Time.now().strftime('%Y%m%d%H%M')
+    LPSolve::set_lp_name(@lp, @model_name)
+    
+    LPSolve::set_verbose(@lp, LPSolve::SEVERE )
+  end
+  
+  def create_new(varnames)
+    self.vars = varnames
+    cols = @vars.length
+    @lp = LPSolve::make_lp(0, cols) 
+    1.upto(cols) do |cnum| 
+      cname = varnames[cnum-1] #For every column get the column name and index (NOT zero indexed)
+      LPSolve::set_binary(@lp, cnum, 1) #Define the column to be binary
+      LPSolve::set_col_name(@lp, cnum, cname.to_s.dup) #Set the name to what we passed
+    end    
+  end
+  
+  def load_from_file(filename)
+    @lp = LPSolve::read_LP(filename, LPSolve::SEVERE, "")
+    
+    loc_lp = LPSolve::copy_lp(@lp) #We make a copy to avoid advancing internal pointers.
+    existing_vars = []
+    1.upto(get_Ncolumns) do |col|
+      existing_vars << LPSolve::get_origcol_name(loc_lp, col).to_s
+    end
+    self.vars = existing_vars
+  end
+  
+  # Weights should be a hash with variable names as keys, and
+  # individual multipliers as the values.  Eg, { "v1" => 10 }
+  # would return a row like +10 v1
+  def set_objective(weights, direction = :min)
+    weights = weights.inject({}) do |options, (key, value)|
+      options[key.to_sym] = value
+      options
+    end
+    
+    obj_fn = [1.0] # placeholder for zero indexed array
+    @vars.each do |var|
+      weight = weights[var] || 0.0
+      obj_fn <<  weight
+    end
+    
+    FFI::MemoryPointer.new(:double, obj_fn.size) do |p|
+      p.write_array_of_double(obj_fn)
+      LPSolve::set_obj_fn(@lp, p)
+    end
+    
+    if direction == :max
+      LPSolve::set_maxim(@lp)
+    else
+      LPSolve::set_minim(@lp)
+    end
+    
+    @objective_row = {:direction => direction, :weights => weights }
+    
+  end
+  
+  def solve
+    
+    #Important step.
+    solution = LPSolve::solve(@lp) 
+
+    if solution == LPSolve::OPTIMAL || LPSolve::SUBOPTIMAL
+      #--------------------
+      #  Get the values
+      #--------------------
+      @results = {}
+      
+      retvals = []
+      FFI::MemoryPointer.new(:double, @vars.size) do |p|
+        if LPSolve::get_variables(@lp, p)
+          retvals = p.get_array_of_double(0, @vars.size)
+          @vars.each_with_index do |c, idx|
+            @results[c] = retvals[idx]
+          end
+        end
+      end
+    
+      #--------------------
+      #  Set the objective (eg, final sum)
+      #--------------------
+      @objective = LPSolve::get_objective(@lp)
+    end
+    return solution
+    
+  end
+  
+  
+  # This piece is what's used to ensure that the function selects the right amounts from
+  # the right categories.  For example, to select at least one applicant from Maine,
+  # we could add a constraint saying that the sum of all applicant variables
+  # representing the applicants from Maine must be greater than or equal to 1.
+  def add_constraint(rowdef = CONSTRAINT_ROW)
+    
+    raise "You must specify at least one variable to add a constraint" if rowdef[:vars].length == 0
+    raise "You must specify an operation" if rowdef[:op].nil?
+    raise "You must specify a target (ie, right hand side)" if rowdef[:target].nil?  
+    raise "Target must be a number" unless rowdef[:target].is_a?(Float) || rowdef[:target].is_a?(Integer)
+    
+    varnames = rowdef[:vars].map! {|v| v.to_sym}
+    
+    #The API expects a 1 indexed array, so start with an empty item in row_constraints[0]
+    row_constraints = [0.0]
+    @vars.each do |v|
+      # Since we're only interested in binary columns, putting in a 1 or a zero is sufficient
+      # to either add them to the constraint or not
+      row_constraints << (varnames.include?(v) ? 1.0 : 0.0)
+    end
+
+    FFI::MemoryPointer.new(:double, row_constraints.size) do |p|
+      p.write_array_of_double(row_constraints)
+      LPSolve::add_constraint(@lp, p, rowdef[:op], rowdef[:target].to_f)
+    end
+    
+    # Every row has a name, and it's helpful if it suggests something about the constraint,
+    # eg maine or minorities
+    if rowdef[:name] == ""
+      rowdef[:name] = "R#{@constraints.length+1}"
+    end
+    @constraints << rowdef
+    LPSolve::set_row_name(@lp, @constraints.length, rowdef[:name])
+  end
+  
+  def to_file(filename)
+    loc_lp = LPSolve::copy_lp(@lp)
+    valid = LPSolve::write_lp(loc_lp, filename)
+    raise "Could not write to #{filename}" unless valid
+  end
+  
+  def to_yaml
+    @complete = {}
+    @complete["vars"] = @vars
+    @complete["model_name"] = @model_name
+    @complete["constraints"] = @constraints
+    @complete["objective"] = @objective_row unless @objective_row[:weights].empty?
+    @complete.to_yaml
+  end
+  
+  def load_from_yaml(yaml)
+    @complete = YAML::load(yaml)
+    raise "could not load from yaml" unless @complete
+    create_new(@complete["vars"])
+    LPSolve::set_lp_name(@lp, @complete["model_name"])
+    @complete["constraints"].each do |c|
+      add_constraint(c)
+    end
+    
+    if @complete['objective']
+      set_objective(@complete['objective'][:weights], @complete['objective'][:direction])
+    end
+  end
+  
+  def to_lp_format
+    lp_text = "/* #{@model_name} */\n\n"
+    
+    lp_text << "/* Objective function */\n"
+    lp_text << "#{@objective_row[:direction]}:"
+    weights = @objective_row[:weights]
+    weights.keys.sort_by{|s| s.to_s}.map{|key| [key, weights[key]] }.each do |var,constant|
+      sign = constant > 0 ? "+" : "-"
+      if constant.abs == 1
+        lp_text << " #{sign}#{var}"
+      else
+        lp_text << " #{sign}#{constant} #{var}"
+      end
+    end
+    lp_text << ";\n\n"
+    
+    lp_text << "/* Constraints */\n"
+    @constraints.each do |row|
+      row_vars = row[:vars].map{|x| "+#{x}"}.sort.join(" ")
+      row_op = LPSolve.op_to_s(row[:op])
+      lp_text << "#{row[:name]}: #{row_vars} #{row_op} #{row[:target]}; \n\n"
+    end
+    
+    lp_text << "\n/* Varible Bounds */\n"
+    @vars.each do |v|
+      lp_text << "#{v} <= 1;\n"
+    end
+
+    lp_text << "\n/* Variable Definitions */\n"
+    lp_text << "int #{@vars.join(", ")};"
+    return lp_text
+  end
+  
+  private 
+  
+    def vars=(new_vars)
+      @vars = new_vars.collect(&:to_sym)
+    end
+  
+    def get_Ncolumns
+      @n_columns ||= LPSolve::get_Ncolumns(@lp)
+    end
+end

data/lib/lp_select/lp_solve.rb

@@ -0,0 +1,154 @@
+# -----------------------------------------------
+#  
+#  This module uses Ruby's DL library to dynamically load
+#  the liblpsolve library, which is a linear equation solver.
+#
+#  The sourceforge summary says:
+#  Mixed Integer Linear Programming (MILP) solver lp_solve solves pure linear, 
+#  (mixed) integer/binary, semi-cont and special ordered sets (SOS) models.  
+#  lp_solve is written in ANSI C and can be compiled on many different platforms 
+#  like Linux and WINDOWS
+#
+#  Read more at http://sourceforge.net/projects/lpsolve/
+#
+#  This module mostly serves to load the file and attach to the 
+#  API functions
+#
+# -----------------------------------------------
+
+module LPSolve
+  extend FFI::Library
+  base = File.expand_path(File.join( File.dirname(__FILE__), "binaries") )
+  err = nil
+  ["liblpsolve55.so", "liblpsolve55.so-ux64", "liblpsolve55.dylib", "liblpsolve55.dylib.x86-64", "liblpsolve55.dylib-ppc", "lpsolve55.dll"].each do |lib|
+    begin 
+      err = nil
+      ffi_lib File.join(base, lib) 
+      break
+    rescue LoadError => e
+      err = e
+    end
+  end
+  raise "Could not find suitable liblpsolve55 library #{err}" unless err.nil?
+  
+  #Constants used when assigning constraints
+  LE = 1 # <=
+  EQ = 3 # ==
+  GE = 2 # >=
+  
+  def op_to_s(op_int)
+    case op_int
+      when LPSelect::GE then ">="
+      when LPSelect::LE then "<=" 
+      when LPSelect::EQ then "=="
+    end
+  end
+  
+  #Constants used for verbosity
+  CRITICAL = 1
+  SEVERE = 2
+  IMPORTANT = 3
+  NORMAL = 4
+  DETAILED = 5
+  FULL = 6
+  
+  #Constants used for solve results
+  NOMEMORY = -2
+  OPTIMAL = 0
+  SUBOPTIMAL = 1
+  INFEASIBLE = 2
+  UNBOUNDED = 3
+  DEGENERATE = 4
+  NUMFAILURE = 5
+  USERABORT = 6
+  TIMEOUT = 7
+  PRESOLVED = 9
+  PROCFAIL = 10
+  PROCBREAK = 11
+  FEASFOUND = 12
+  NOFEASFOUND = 13
+
+  typedef :double, :REAL
+  typedef :long, :lprec
+
+
+  # All of the function signatures here come from 
+  # http://lpsolve.sourceforge.net/5.5/lp_solveAPIreference.htm
+
+  # void lp_solve_version(int *majorversion, int *minorversion, int *release, int *build)
+  attach_function :lp_solve_version, [:pointer, :pointer, :pointer, :pointer], :void
+  
+  # lprec *read_LP(char *filename, int verbose, char *lp_name)
+  attach_function :read_LP, [:string, :int, :string], :pointer
+  
+  # int solve(lprec *lp)
+  attach_function :solve, [:pointer], :int
+  
+  # unsigned char get_variables(lprec *lp, REAL *var);
+  attach_function :get_variables, [:pointer, :pointer], :char
+  
+  # int get_Ncolumns(lprec *lp);
+  attach_function :get_Ncolumns, [:pointer], :int
+  
+  # char *get_col_name(lprec *lp, int column);
+  attach_function :get_col_name, [:pointer, :int], :string
+  
+  # char *get_origcol_name(lprec *lp, int column);
+  attach_function :get_origcol_name, [:pointer, :int], :string
+    
+  # lprec *copy_lp(lprec *lp);
+  attach_function :copy_lp, [:pointer], :pointer
+  
+  # void print_lp(lprec *lp);
+  attach_function :print_lp, [:pointer], :void
+  
+  # lprec *make_lp(int rows, int columns);
+  attach_function :make_lp, [:int, :int], :pointer
+  
+  # void delete_lp(lprec *lp);
+  attach_function :delete_lp, [:pointer], :void
+  
+  # unsigned char set_binary(lprec *lp, int column, unsigned char must_be_bin);
+  attach_function :set_binary, [:pointer, :int, :char], :char
+  
+  # unsigned char set_col_name(lprec *lp, int column, char *new_name);
+  attach_function :set_col_name, [:pointer, :int, :string], :char
+  
+  # unsigned char set_obj_fn(lprec *lp, REAL *row);
+  attach_function :set_obj_fn, [:pointer, :pointer], :char
+  
+  # unsigned char add_constraint(lprec *lp, REAL *row, int constr_type, REAL rh);
+  attach_function :add_constraint, [:pointer, :pointer, :int, :REAL], :char
+  
+  # unsigned char set_row_name(lprec *lp, int row, char *new_name);
+  attach_function :set_row_name, [:pointer, :int, :string], :char
+  
+  # REAL get_objective(lprec *lp);
+  attach_function :get_objective, [:pointer], :REAL
+  
+  # void set_verbose(lprec *lp, int verbose);
+  attach_function :set_verbose, [:pointer, :int], :void
+  
+  # unsigned char set_lp_name(lprec *lp, char *lpname);
+  attach_function :set_lp_name, [:pointer, :string], :char
+  
+  # unsigned char write_lp(lprec *lp, char *filename);
+  attach_function :write_lp, [:pointer, :string], :char
+  
+  # void set_maxim(lprec *lp);
+  attach_function :set_maxim, [:pointer], :void
+  
+  # void set_minim(lprec *lp);
+  attach_function :set_minim, [:pointer], :void
+  
+  def self.version
+    maj_ptr = FFI::MemoryPointer.new(:pointer, 1)
+    min_ptr = FFI::MemoryPointer.new(:pointer, 1)
+    rel_ptr = FFI::MemoryPointer.new(:pointer, 1)
+    bld_ptr = FFI::MemoryPointer.new(:pointer, 1)
+    LPSolve::lp_solve_version(maj_ptr, min_ptr, rel_ptr, bld_ptr)
+    
+    "#{maj_ptr.read_int}.#{min_ptr.read_int}.#{rel_ptr.read_int} build #{bld_ptr.read_int}"
+  end
+  
+end

data/lib/lp_select/version.rb

@@ -0,0 +1,4 @@
+module LpSelect
+  # See http://semver.org/
+  VERSION = "1.0.0"
+end

data/lp_select.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lp_select/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lp_select"
+  spec.version       = LpSelect::VERSION
+  spec.authors       = ["Jake Sower", "James Prior"]
+  spec.email         = ["j.sower@asee.org", "j.prior@asee.org"]
+  spec.description   = %q{Ruby bindings for LPSolve}
+  spec.summary       = %q{Ruby bindings for LPSolve}
+  spec.homepage      = "https://github.com/asee/lp_select"
+  spec.license       = "LGPL"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "ffi"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/test/lp_format_sample.txt

@@ -0,0 +1,6 @@
+-x1 -x2;
+/* or min: x1 + x2; */
+x1 >= 1;
+x2 >= 1;
+x1 + x2 >= 2;
+int x1;

data/test/lp_select_test.rb

@@ -0,0 +1,186 @@
+require 'test_helper'
+
+class LpSelectTest < Test::Unit::TestCase
+  def setup
+    @fruits = {
+      "apple" => 1,
+      "bananna" => 0.3,
+      "pear" => 1.4,
+      "strawberry" => 3,
+      "pineapple" => 5,
+      "watermelon" => 4.3,
+      "grapes" => 2.4,
+      "orange" => 0.89,
+      "kiwi" => 3.49,
+      "mango" => 4.45,
+      "cherry" => 6,
+      "blueberry" => 5.50
+    }
+
+    @lprec = LPSelect.new(:vars => @fruits.keys)
+  end
+
+  def test_set_objective
+    objective_row = {}
+    assert_nothing_raised do
+      @lprec.set_objective(@fruits, :min) # min is the default
+      objective_row = @lprec.objective_row
+    end
+    assert_equal :min, objective_row[:direction]
+    assert_equal @fruits.length, objective_row[:weights].length
+  end
+
+  def test_add_constraints
+    # Alice likes berries, she gets at least one
+    @lprec.add_constraint({:name => "alice_picks", :vars => ["blueberry", "strawberry"], :op => LPSelect::GE, :target => 1})
+    assert_not_nil @lprec.constraints.detect{|x| x[:name] == 'alice_picks'}
+
+    # Bob likes tropical fruit, but he shouldn't get any more than two
+    @lprec.add_constraint({:name => "bob_picks", :vars => ["kiwi", "mango", "pineapple"], :op => LPSelect::LE, :target => 2})
+    assert_not_nil @lprec.constraints.detect{|x| x[:name] == 'bob_picks'}
+
+    # Carol is a toddler and gets to pick only two things.
+    @lprec.add_constraint({:name => "carol_picks", :vars => ["apple", "bananna", "grapes"], :op => LPSelect::EQ, :target => 2})
+    assert_not_nil @lprec.constraints.detect{|x| x[:name] == 'carol_picks'}
+
+    # Dan is an omnivore and we like him enough that he should get at least three.
+    @lprec.add_constraint({:name => "don_picks", :vars => @fruits.keys, :op => LPSelect::GE, :target => 3})
+    assert_not_nil @lprec.constraints.detect{|x| x[:name] == 'don_picks'}
+
+    assert_equal 4, @lprec.constraints.count
+  end
+
+  def test_yaml_serialize
+    @lprec.set_objective(@fruits, :min) # min is the default
+
+    # Alice likes berries, she gets at least one
+    @lprec.add_constraint({:name => "alice_picks", :vars => ["blueberry", "strawberry"], :op => LPSelect::GE, :target => 1})
+
+    # Bob likes tropical fruit, but he shouldn't get any more than two
+    @lprec.add_constraint({:name => "bob_picks", :vars => ["kiwi", "mango", "pineapple"], :op => LPSelect::LE, :target => 2})
+
+    # Carol is a toddler and gets to pick only two things.
+    @lprec.add_constraint({:name => "carol_picks", :vars => ["apple", "bananna", "grapes"], :op => LPSelect::EQ, :target => 2})
+
+    # Dan is an omnivore and we like him enough that he should get at least three.
+    @lprec.add_constraint({:name => "don_picks", :vars => @fruits.keys, :op => LPSelect::GE, :target => 3})
+
+    # etc...
+
+    yaml_source = nil
+    assert_nothing_raised do
+      yaml_source = @lprec.to_yaml
+    end
+    assert_not_nil yaml_source
+
+    alt = LPSelect.new(:yaml => yaml_source)
+    assert_equal alt.objective_row, @lprec.objective_row
+    assert_equal alt.vars, @lprec.vars
+    assert_equal alt.constraints, @lprec.constraints
+  end
+
+  def test_lp_format_serialize
+    @lprec.set_objective(@fruits, :min) # min is the default
+
+    # Alice likes berries, she gets at least one
+    @lprec.add_constraint({:name => "alice_picks", :vars => ["blueberry", "strawberry"], :op => LPSelect::GE, :target => 1})
+
+    # Bob likes tropical fruit, but he shouldn't get any more than two
+    @lprec.add_constraint({:name => "bob_picks", :vars => ["kiwi", "mango", "pineapple"], :op => LPSelect::LE, :target => 2})
+
+    # Carol is a toddler and gets to pick only two things.
+    @lprec.add_constraint({:name => "carol_picks", :vars => ["apple", "bananna", "grapes"], :op => LPSelect::EQ, :target => 2})
+
+    # Dan is an omnivore and we like him enough that he should get at least three.
+    @lprec.add_constraint({:name => "don_picks", :vars => @fruits.keys, :op => LPSelect::GE, :target => 3})
+
+    # etc...
+    begin
+      destination = Tempfile.new("lp_select_test")
+      lp_source = nil
+      assert_nothing_raised do
+        lp_source = @lprec.to_lp_format
+        @lprec.to_file(destination.path)
+      end
+
+      assert_not_nil lp_source
+
+      @lprec.constraints.each do |c|
+        assert lp_source.include?(c[:name]), "Expected the source to include #{c[:name]}"
+      end
+
+      @fruits.keys.each do |name|
+        assert lp_source.include?(name), "Expected the source to include #{name}"
+      end
+
+      assert File.size(destination.path) > 0
+
+      alt = LPSelect.new(:filename => destination.path)
+      assert_equal alt.vars, @lprec.vars
+
+    ensure
+      destination.unlink
+    end
+  end
+
+  def test_should_solve_with_min_price
+    @lprec.set_objective(@fruits, :min) # min is the default
+
+    # Alice likes berries, she gets at least one, strawberry is expected since it is the cheapest
+    @lprec.add_constraint({:name => "alice_picks", :vars => ["blueberry", "strawberry"], :op => LPSelect::GE, :target => 1})
+
+    # Bob likes tropical fruit, but he shouldn't get any more than two.  Since we're minimizing we expect none of these
+    @lprec.add_constraint({:name => "bob_picks", :vars => ["kiwi", "mango", "pineapple"], :op => LPSelect::LE, :target => 2})
+
+    # Carol is a toddler and gets to pick only two things, the two cheapest
+    @lprec.add_constraint({:name => "carol_picks", :vars => ["apple", "bananna", "grapes"], :op => LPSelect::EQ, :target => 2})
+
+    # Dan is an omnivore and we like him enough that he should get at least three, so three total picks
+    @lprec.add_constraint({:name => "don_picks", :vars => @fruits.keys, :op => LPSelect::GE, :target => 3})
+
+    status = nil
+    assert_nothing_raised do
+      status = @lprec.solve
+    end
+
+    assert_not_nil status
+    assert_equal LPSolve::OPTIMAL, status
+
+    assert_not_nil @lprec.results
+    selected_fruits = @lprec.results.collect{|k,v| v == 1.0 ? k : nil}.flatten.compact
+    assert_equal 4.3, @lprec.objective
+    assert_equal [:apple, :bananna, :strawberry], selected_fruits
+  end
+
+  def test_should_solve_with_max_price
+    @lprec.set_objective(@fruits, :max)
+
+    # Alice likes berries, she gets at least one.  Both should show up since we are maximizing
+    @lprec.add_constraint({:name => "alice_picks", :vars => ["blueberry", "strawberry"], :op => LPSelect::GE, :target => 1})
+
+    # Bob likes tropical fruit, but he shouldn't get any more than two - mango and pineapple since they are the most expensive
+    @lprec.add_constraint({:name => "bob_picks", :vars => ["kiwi", "mango", "pineapple"], :op => LPSelect::LE, :target => 2})
+
+    # Carol is a toddler and gets to pick only two things.  Apple and grapes since they are the most expensive, but no bananas
+    @lprec.add_constraint({:name => "carol_picks", :vars => ["apple", "bananna", "grapes"], :op => LPSelect::EQ, :target => 2})
+
+    # Dan is an omnivore and we like him enough that he should get at least three. - so everythign else here
+    @lprec.add_constraint({:name => "don_picks", :vars => @fruits.keys, :op => LPSelect::GE, :target => 3})
+    
+    expected_fruits = @fruits.keys.collect(&:to_sym) - [:bananna, :kiwi]
+
+    status = nil
+    assert_nothing_raised do
+      status = @lprec.solve
+    end
+
+    assert_not_nil status
+    assert_equal LPSolve::OPTIMAL, status
+
+    assert_not_nil @lprec.results
+    selected_fruits = @lprec.results.collect{|k,v| v == 1.0 ? k : nil}.flatten.compact
+    assert_equal 33.94, @lprec.objective
+    assert_equal expected_fruits.collect(&:to_s).sort, selected_fruits.collect(&:to_s).sort
+  end
+
+end

data/test/lp_solve_test.rb

@@ -0,0 +1,251 @@
+require 'test_helper'
+
+class LpSolveTest < Test::Unit::TestCase
+  
+  # void lp_solve_version(int *majorversion, int *minorversion, int *release, int *build)
+  def test_lp_solve_version
+    assert LPSolve.version.include?("5.5.0 build ")
+  end
+  
+  # lprec *make_lp(int rows, int columns);
+  def test_make_lp
+    assert_nothing_raised do
+      @lp = LPSolve::make_lp(0, 0) 
+    end
+    assert_not_nil @lp
+  end
+  
+  # unsigned char set_binary(lprec *lp, int column, unsigned char must_be_bin);
+  def test_set_binary
+    @lp = LPSolve::make_lp(0, 1)
+    assert_nothing_raised do
+      LPSolve::set_binary(@lp, 1, 1) #Define the column to be binary
+    end
+  end
+  
+  # unsigned char set_col_name(lprec *lp, int column, char *new_name);
+  def test_set_col_name
+    @lp = LPSolve::make_lp(0, 1)
+    assert_nothing_raised do
+      LPSolve::set_col_name(@lp, 1, "fred") 
+    end
+  end
+  
+  # unsigned char set_lp_name(lprec *lp, char *lpname);
+  def test_set_lp_name
+    @lp = LPSolve::make_lp(0, 0) 
+    assert_nothing_raised do
+      LPSolve::set_lp_name(@lp, "Hi mom")
+    end
+  end
+  
+  # void set_verbose(lprec *lp, int verbose);
+  def test_set_verbose
+    @lp = LPSolve::make_lp(0, 0) 
+    assert_nothing_raised do
+      LPSolve::set_verbose(@lp, LPSolve::SEVERE )
+    end
+  end
+  
+  # lprec *copy_lp(lprec *lp);
+  def test_copy_lp
+    @lp = LPSolve::make_lp(0, 0) 
+    assert_nothing_raised do
+      LPSolve::copy_lp(@lp)
+    end
+  end
+  
+  # lprec *read_LP(char *filename, int verbose, char *lp_name)
+  def test_read_lp
+    filename = File.expand_path("../lp_format_sample.txt", __FILE__)
+    assert_nothing_raised do
+      @lp = LPSolve::read_LP(filename, LPSolve::SEVERE, "")
+    end
+  end
+  
+  # char *get_origcol_name(lprec *lp, int column);
+  def test_get_origcol_name
+    @lp = LPSolve::make_lp(0, 1)
+    LPSolve::set_col_name(@lp, 1, "fred")
+    
+    colname = LPSolve::get_origcol_name(@lp, 1)
+    assert_equal "fred", colname.to_s
+  end
+
+  # void set_maxim(lprec *lp);
+  def test_set_maxim
+    @lp = LPSolve::make_lp(0, 0) 
+    assert_nothing_raised do
+      LPSolve::set_maxim(@lp)
+    end
+  end
+  
+  # void set_minim(lprec *lp);
+  def test_set_minim
+    @lp = LPSolve::make_lp(0, 0) 
+    assert_nothing_raised do
+      LPSolve::set_minim(@lp)
+    end
+  end
+  
+  # unsigned char write_lp(lprec *lp, char *filename);
+  def test_write_lp
+    destination = Tempfile.new("lp_solve_test")
+    begin
+      @lp = LPSolve::make_lp(0, 1)
+      LPSolve::set_col_name(@lp, 1, "fred")
+    
+      assert_nothing_raised do
+        LPSolve::write_lp(@lp, destination.path)
+      end
+      assert File.size(destination.path) > 0
+    ensure
+      destination.unlink
+    end
+  end
+
+	# int get_Ncolumns(lprec *lp);
+  def test_get_Ncolumns
+    @lp = LPSolve::make_lp(0, 3)
+    ncols = LPSolve::get_Ncolumns(@lp)
+    assert_equal 3, ncols
+  end
+  
+	# char *get_col_name(lprec *lp, int column);
+  def test_get_col_name
+    @lp = LPSolve::make_lp(0, 1)
+    LPSolve::set_col_name(@lp, 1, "fred")
+    
+    colname = LPSolve::get_origcol_name(@lp, 1)
+    assert_equal "fred", colname.to_s
+  end
+  
+	# unsigned char add_constraint(lprec *lp, REAL *row, int constr_type, REAL rh);
+  def test_add_constraint
+    @lp = LPSolve::make_lp(0, 2)
+    
+    #The API expects a 1 indexed array    
+    constraint_vars = [0, 0, 1]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      assert_nothing_raised do
+        LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+      end
+    end
+  end
+  
+  # unsigned char set_row_name(lprec *lp, int row, char *new_name);
+  def test_set_row_name
+    @lp = LPSolve::make_lp(0, 2)
+    LPSolve::set_col_name(@lp, 1, "fred")
+    LPSolve::set_col_name(@lp, 2, "bob")
+    
+    #The API expects a 1 indexed array
+    constraint_vars = [0, 0, 1]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+    end
+    
+    assert_nothing_raised do
+      LPSolve::set_row_name(@lp, 1, "onlyBob")
+    end
+  end
+  
+  # unsigned char set_obj_fn(lprec *lp, REAL *row);
+  def test_set_obj_fn
+    @lp = LPSolve::make_lp(0, 1)
+    
+    #The API expects a 1 indexed array
+    constraint_vars = [1.0, 3.0]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      assert_nothing_raised do
+        LPSolve::set_obj_fn(@lp, p)
+      end
+    end
+  end
+  
+  
+	# void delete_lp(lprec *lp);	
+  def test_delete_lp
+    @lp = LPSolve::make_lp(0, 1)
+    assert_nothing_raised do
+      LPSolve::delete_lp(@lp)
+    end
+  end
+  
+	# int solve(lprec *lp)
+  def test_solve
+    @lp = LPSolve::make_lp(0, 2)
+    LPSolve::set_verbose(@lp, LPSolve::SEVERE )
+    LPSolve::set_col_name(@lp, 1, "fred")
+    LPSolve::set_col_name(@lp, 2, "bob")
+    
+    #The API expects a 1 indexed array
+    constraint_vars = [0, 0, 1]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+    end
+
+    LPSolve::set_minim(@lp)
+    
+    assert_nothing_raised do
+      solution = LPSolve::solve(@lp) 
+    end
+    
+  end
+  
+  # REAL get_objective(lprec *lp);
+  def test_get_objective
+    @lp = LPSolve::make_lp(0, 2)
+    LPSolve::set_verbose(@lp, LPSolve::SEVERE )
+    LPSolve::set_col_name(@lp, 1, "fred")
+    LPSolve::set_col_name(@lp, 2, "bob")
+    
+    #The API expects a 1 indexed array
+    constraint_vars = [0, 0, 1]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+    end
+    
+    LPSolve::set_minim(@lp)
+    solution = LPSolve::solve(@lp) 
+    
+    assert_nothing_raised do
+      objective = LPSolve::get_objective(@lp)
+      assert_not_nil objective
+    end
+  end
+  
+	# unsigned char get_variables(lprec *lp, REAL *var);  
+  def test_get_variables
+    @lp = LPSolve::make_lp(0, 2)
+    LPSolve::set_verbose(@lp, LPSolve::SEVERE )
+    LPSolve::set_col_name(@lp, 1, "fred")
+    LPSolve::set_col_name(@lp, 2, "bob")
+    
+    #The API expects a 1 indexed array
+    constraint_vars = [0, 0, 1]
+    FFI::MemoryPointer.new(:double, constraint_vars.size) do |p|
+      p.write_array_of_double(constraint_vars)
+      LPSolve::add_constraint(@lp, p, LPSelect::EQ, 1.0.to_f)
+    end
+    
+    
+    LPSolve::set_minim(@lp)
+    solution = LPSolve::solve(@lp) 
+    
+    retvals = []
+    FFI::MemoryPointer.new(:double, 2) do |p|
+      assert_nothing_raised do
+        err = LPSolve::get_variables(@lp, p)
+      end
+      retvals = p.get_array_of_double(0,2)
+    end
+    assert_not_nil retvals[0]
+    assert_equal 1.0, retvals[1]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+
+require 'lp_select'
+
+require 'test/unit'
+require 'tempfile'
+
+class Test::Unit::TestCase
+end
+

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: lp_select
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jake Sower
+- James Prior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby bindings for LPSolve
+email:
+- j.sower@asee.org
+- j.prior@asee.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lp_select.rb
+- lib/lp_select/binaries/liblpsolve55.dylib
+- lib/lp_select/binaries/liblpsolve55.dylib-ppc
+- lib/lp_select/binaries/liblpsolve55.dylib.x86-64
+- lib/lp_select/binaries/liblpsolve55.so
+- lib/lp_select/binaries/liblpsolve55.so-ux64
+- lib/lp_select/binaries/lpsolve55.dll
+- lib/lp_select/lp_select.rb
+- lib/lp_select/lp_solve.rb
+- lib/lp_select/version.rb
+- lp_select.gemspec
+- test/lp_format_sample.txt
+- test/lp_select_test.rb
+- test/lp_solve_test.rb
+- test/test_helper.rb
+homepage: https://github.com/asee/lp_select
+licenses:
+- LGPL
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for LPSolve
+test_files:
+- test/lp_format_sample.txt
+- test/lp_select_test.rb
+- test/lp_solve_test.rb
+- test/test_helper.rb
+has_rdoc: