rams 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67e00b03b834709c1fe99786d347e930d4446738
+  data.tar.gz: 92e7882abc5840a724ec73a9966180150bedddd4
+SHA512:
+  metadata.gz: a8d314f2631447ae0a8d500b5b358f55fe319cb6a60a44c21ac439a032c9a7b0504654ac14bbe1b81bc9c52687ec04e68f8d6b3d617e305f143912d8cff748ad
+  data.tar.gz: d9944355d64f23fd6c43ddc841e668ae9f6d272eeec906b1df9809a01df987a59514e43600528619eec3a34db7df0dafb0e6f0557542438452b3b2a5b68e3b73

data/lib/rams/constraint.rb

@@ -0,0 +1,58 @@
+module RAMS
+  # A RAMS::Constraint must take the form:
+  #
+  #     lhs ==|<=|>= rhs
+  #
+  # lhs is a hash of variables to coefficients and rhs is a constant.
+  # The sense is the sense of the inequality and must be closed.
+  #
+  class Constraint
+    attr_reader :id, :lhs, :sense, :rhs
+
+    def initialize(lhs, sense, rhs)
+      @id = Variable.next_id
+
+      @lhs = lhs.dup
+      @sense = sense
+      @rhs = rhs
+
+      validate
+    end
+
+    def name
+      "c#{id}"
+    end
+
+    def to_s
+      lhs_s = lhs.map { |v, c| "#{c >= 0 ? '+' : '-'} #{c} #{v.name} " }.join
+      sense_s = sense == :== ? '=' : sense.to_s
+      "#{name}: #{lhs_s}#{sense_s} #{rhs}"
+    end
+
+    @next_id = 0
+
+    def self.next_id
+      @next_id += 1
+    end
+
+    private
+
+    def validate
+      validate_lhs
+      validate_sense
+      validate_rhs
+    end
+
+    def validate_lhs
+      raise(ArgumentError, 'invalid lhs') if lhs.empty?
+    end
+
+    def validate_sense
+      raise(ArgumentError, 'invalid sense') unless [:<=, :==, :>=].index(sense)
+    end
+
+    def validate_rhs
+      raise(ArgumentError, 'invalid rhs') unless rhs.is_a? Numeric
+    end
+  end
+end

data/lib/rams/expression.rb

@@ -0,0 +1,99 @@
+require_relative 'constraint'
+
+module RAMS
+  # A RAMS::Expression is a dot product of variables, cofficients, and a
+  # constant offset:
+  #
+  #     3 * x1 + 1.5 * x3 - 4
+  #
+  # Expressions must be linear. They can be added and subtracted.
+  #
+  class Expression
+    attr_reader :coefficients, :constant
+
+    def initialize(coefficients = {}, constant = 0.0)
+      @coefficients = coefficients.dup
+      @coefficients.default = 0.0
+      @constant = constant.to_f
+    end
+
+    def -@
+      Expression.new coefficients.map { |v, c| [v, -c] }.to_h, -constant
+    end
+
+    def +(other)
+      if other.is_a? Numeric
+        return Expression.new({}, 0.0) unless other
+        return Expression.new(coefficients, constant + other)
+      end
+      Expression.new add_coefficients(other), constant + other.constant
+    end
+
+    def -(other)
+      if other.is_a? Numeric
+        return Expression.new({}, 0.0) unless other
+        return Expression.new(coefficients, constant - other)
+      end
+      Expression.new add_coefficients(other, -1), constant - other.constant
+    end
+
+    def *(other)
+      if other.is_a? Numeric
+        return Expression.new(coefficients.map do |v, c|
+          [v, c * other]
+        end.to_h, constant * other)
+      end
+      raise NotImplementedError
+    end
+
+    def /(other)
+      if other.is_a? Numeric
+        return Expression.new(coefficients.map do |v, c|
+          [v, c / other]
+        end.to_h, constant / other)
+      end
+      raise NotImplementedError
+    end
+
+    def <=(other)
+      RAMS::Constraint.new(lhs(other), :<=, rhs(other))
+    end
+
+    def ==(other)
+      RAMS::Constraint.new(lhs(other), :==, rhs(other))
+    end
+
+    def >=(other)
+      RAMS::Constraint.new(lhs(other), :>=, rhs(other))
+    end
+
+    def to_s
+      vars_s = coefficients.map { |v, c| "#{c >= 0 ? '+' : '-'} #{c} #{v.name} " }.join
+      sign_s = constant >= 0 ? '+' : '-'
+      const_s = constant == 0 ? '' : "#{sign_s} #{constant}"
+      vars_s + const_s
+    end
+
+    private
+
+    def merge_variables(other)
+      (coefficients.keys + other.coefficients.keys).uniq
+    end
+
+    def add_coefficients(other, sign = +1)
+      vars = merge_variables(other)
+      vars.map do |v|
+        [v, coefficients[v] + (sign * other.coefficients[v])]
+      end.to_h
+    end
+
+    def lhs(other)
+      (self - other).coefficients
+    end
+
+    def rhs(other)
+      return other - constant if other.is_a? Numeric
+      other.constant - constant
+    end
+  end
+end

data/lib/rams/model.rb

@@ -0,0 +1,92 @@
+require 'tempfile'
+require_relative 'variable'
+require_relative 'solvers/glpk'
+
+module RAMS
+  # A Model is a collection of:
+  #
+  #   * Variables
+  #   * Constraints
+  #   * An objective function and sense
+  #
+  # An example of a simple model:
+  #
+  #   m = RAMS::Model.new
+  #   x1 = m.variable(type: :binary)
+  #   x2 = m.variable
+  #   m.constrain(x1 + x2 <= 1)
+  #
+  # Models can be maximized or minimized by different solvers.
+  #
+  #   m.sense = :max
+  #   m.objective = (x1 + (2 * x2))
+  #   m.solver = :glpk
+  #   m.verbose = true
+  #   m.solve
+  #
+  class Model
+    attr_accessor :objective, :args, :verbose
+    attr_reader :solver, :sense, :variables, :constraints
+
+    SOLVERS = { glpk: RAMS::Solvers::GLPK.new }.freeze
+
+    def initialize
+      @solver = :glpk
+      @sense = :max
+      @objective = nil
+      @verbose = false
+      @args = []
+      @variables = {}
+      @constraints = {}
+    end
+
+    def solver=(solver)
+      raise(ArgumentError, "valid solvers: #{SOLVERS.keys.join(' ')}") if SOLVERS[solver].nil?
+      @solver = solver
+    end
+
+    def sense=(sense)
+      raise(ArgumentError, 'sense must be :min or :max') unless sense == :min || sense == :max
+      @sense = sense
+    end
+
+    def variable(low: 0.0, high: nil, type: :continuous)
+      v = Variable.new low: low, high: high, type: type
+      variables[v.name] = v
+    end
+
+    def constrain(constraint)
+      constraints[constraint.name] = constraint
+    end
+
+    def solve
+      raise(ArgumentError, 'model has no variables') if variables.empty?
+      raise(ArgumentError, 'model has no constraints') if constraints.empty?
+      SOLVERS[solver].solve self
+    end
+
+    # rubocop:disable AbcSize
+    def to_s
+      <<-LP
+#{sense}
+  obj: #{feasible_objective.is_a?(Variable) ? feasible_objective.name : feasible_objective}
+st
+  #{constraints.values.map(&:to_s).join("\n  ")}
+bounds
+  #{variables.values.map(&:to_s).join("\n  ")}
+general
+  #{variables.values.select { |v| v.type == :integer }.map(&:name).join("\n  ")}
+binary
+  #{variables.values.select { |v| v.type == :binary }.map(&:name).join("\n  ")}
+end
+      LP
+    end
+    # rubocop:enable AbcSize
+
+    private
+
+    def feasible_objective
+      objective || variables.values.first
+    end
+  end
+end

data/lib/rams/numeric.rb

@@ -0,0 +1,59 @@
+# Fixnums can be added to expressions or variables or multiplied
+# by them to create expressions:
+#
+#     4 - (3 * x)
+#     y / 2
+class Fixnum
+  alias old_add +
+  alias old_sub -
+  alias old_multiply *
+  alias old_divide /
+
+  def +(other)
+    return other + self if other.is_a? RAMS::Expression
+    old_add other
+  end
+
+  def -(other)
+    return -other + self if other.is_a? RAMS::Expression
+    old_sub other
+  end
+
+  def *(other)
+    return other * self if other.is_a? RAMS::Expression
+    old_multiply other
+  end
+
+  def /(other)
+    return other * (1.0 / self) if other.is_a? RAMS::Expression
+    old_divide other
+  end
+end
+
+# Floats can be treated the same way as Fixnums.
+class Float
+  alias old_add +
+  alias old_sub -
+  alias old_multiply *
+  alias old_divide /
+
+  def +(other)
+    return other + self if other.is_a? RAMS::Expression
+    old_add other
+  end
+
+  def -(other)
+    return -other + self if other.is_a? RAMS::Expression
+    old_sub other
+  end
+
+  def *(other)
+    return other * self if other.is_a? RAMS::Expression
+    old_multiply other
+  end
+
+  def /(other)
+    return other * (1.0 / self) if other.is_a? RAMS::Expression
+    old_divide other
+  end
+end

data/lib/rams/solution.rb

@@ -0,0 +1,23 @@
+module RAMS
+  # A Solution contains the output running a model through a solver:
+  #
+  #     * Solution status
+  #     * Objective value
+  #     * Primal variable values
+  #     * Dual prices
+  #
+  class Solution
+    attr_reader :status, :objective, :primal, :dual
+
+    def initialize(status, objective, primal, dual)
+      @status = status
+      @objective = objective
+      @primal = primal
+      @dual = dual
+    end
+
+    def [](variable)
+      primal[variable]
+    end
+  end
+end

data/lib/rams/solvers/glpk.rb

@@ -0,0 +1,40 @@
+require_relative 'solver'
+
+module RAMS
+  module Solvers
+    # Interface to the GNU Linear Programming Kit
+    class GLPK < Solver
+      def solver_command(model_file, solution_file)
+        ['glpsol', '--lp', model_file.path, '--output', solution_file.path]
+      end
+
+      private
+
+      def parse_status(lines)
+        status = lines.select { |l| l =~ /^Status/ }.first
+        return :optimal if status =~ /OPTIMAL/
+        return :feasible if status =~ /FEASIBLE/
+        return :infeasible if status =~ /EMPTY/
+        :undefined
+      end
+
+      def parse_objective(lines)
+        lines.select { |l| l =~ /^Objective/ }.first.split[3].to_f
+      end
+
+      def parse_primal(model, lines)
+        primal = model.variables.values.map { |v| [v, 0.0] }.to_h
+        start_idx = lines.index { |l| l =~ /Column name/ } + 2
+        length = lines[start_idx, lines.length].index { |l| l == '' }
+        primal.update(lines[start_idx, length].map { |l| [model.variables[l[7, 12].strip], l[23, 13].to_f] }.to_h)
+      end
+
+      def parse_dual(model, lines)
+        duals = model.constraints.values.map { |c| [c, 0.0] }.to_h
+        start_idx = lines.index { |l| l =~ /Row name/ } + 2
+        length = lines[start_idx, lines.length].index { |l| l == '' }
+        duals.update(lines[start_idx, length].map { |l| [model.constraints[l[7, 12].strip], l[-13, 13].to_f] }.to_h)
+      end
+    end
+  end
+end

data/lib/rams/solvers/solver.rb

@@ -0,0 +1,88 @@
+require 'open3'
+require_relative '../solution'
+
+module RAMS
+  module Solvers
+    # Generic solver interface
+    class Solver
+      def solve(model)
+        model_file = write_model_file model
+        begin
+          get_solution model, model_file
+        ensure
+          model_file.unlink
+        end
+      end
+
+      private
+
+      def write_model_file(model)
+        model_file = Tempfile.new ['', '.lp']
+        model_file.write model.to_s
+        model_file.close
+        model_file
+      end
+
+      def get_solution(model, model_file)
+        solution_file = Tempfile.new ['', '.sol']
+        begin
+          solve_and_parse model, model_file, solution_file
+        ensure
+          solution_file.unlink
+        end
+      end
+
+      def solve_and_parse(model, model_file, solution_file)
+        call_solver model, model_file, solution_file
+        parse_solution model, File.read(solution_file)
+      end
+
+      # rubocop:disable MethodLength
+      def call_solver(model, model_file, solution_file)
+        command = solver_command(model_file, solution_file) + model.args
+        _, stdout, stderr, exit_code = Open3.popen3(*command)
+
+        begin
+          output = stdout.gets(nil) || ''
+          error = output + (stderr.gets(nil) || '')
+          puts output if model.verbose && output != ''
+          raise error unless exit_code.value == 0
+        ensure
+          stdout.close
+          stderr.close
+        end
+      end
+      # rubocop:enable MethodLength
+
+      def solver_command(_model_file, _solution_file)
+        raise NotImplementedError
+      end
+
+      def parse_solution(model, solution_text)
+        lines = solution_text.split "\n"
+        RAMS::Solution.new(
+          parse_status(lines),
+          parse_objective(lines),
+          parse_primal(model, lines),
+          parse_dual(model, lines)
+        )
+      end
+
+      def parse_status(_lines)
+        raise NotImplementedError
+      end
+
+      def parse_objective(_lines)
+        raise NotImplementedError
+      end
+
+      def parse_primal(_model, _lines)
+        raise NotImplementedError
+      end
+
+      def parse_dual(_model, _lines)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rams/variable.rb

@@ -0,0 +1,48 @@
+require_relative 'expression'
+
+module RAMS
+  # A Variable has bounds and a type. Names are created automatically.
+  #
+  #    RAMS::Variable.new                     # continuous, >= 0
+  #    RAMS::Variable.new low: nil            # continuous, unbounded
+  #    RAMS::Variable.new low: 1, high: 2.5   # continuous, >= 1, <= 2.5
+  #    RAMS::Variable.new type: :binary       # binary variable
+  #    RAMS::Variable.new type: :integer      # integer variable, >= 0
+  #
+  class Variable < Expression
+    attr_reader :id, :low, :high, :type
+
+    def initialize(low: 0.0, high: nil, type: :continuous)
+      @id = Variable.next_id
+
+      @low = low
+      @high = high
+      @type = type
+
+      super({ self => 1.0 })
+    end
+
+    def name
+      "v#{id}"
+    end
+
+    def to_s
+      return to_s_binary if type == :binary
+      "#{low.nil? ? '-inf' : low} <= #{name} <= #{high.nil? ? '+inf' : high}"
+    end
+
+    @next_id = 0
+
+    def self.next_id
+      @next_id += 1
+    end
+
+    private
+
+    def to_s_binary
+      low_s = low.nil? ? 0.0 : [0.0, low].max
+      high_s = high.nil? ? 1.0 : [1.0, high].min
+      "#{low_s} <= #{name} <= #{high_s}"
+    end
+  end
+end

data/lib/rams.rb

@@ -0,0 +1,5 @@
+require_relative 'rams/constraint'
+require_relative 'rams/expression'
+require_relative 'rams/model'
+require_relative 'rams/numeric'
+require_relative 'rams/variable'

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rams
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Ryan J. O'Neil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-07 00:00:00.000000000 Z
+dependencies: []
+description: A library for solving MILPs in Ruby.
+email:
+- ryanjoneil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rams.rb
+- lib/rams/constraint.rb
+- lib/rams/expression.rb
+- lib/rams/model.rb
+- lib/rams/numeric.rb
+- lib/rams/solution.rb
+- lib/rams/solvers/glpk.rb
+- lib/rams/solvers/solver.rb
+- lib/rams/variable.rb
+homepage: https://github.com/ryanjoneil/rams
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby Algebraic Modeling System
+test_files: []