mruby_tools 0.0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9aa01e1c7834a6b9ba351aa1e70df7399628dc8c
+  data.tar.gz: 42b72b7ca714f805e00a0f73b12439d1611dbd65
+SHA512:
+  metadata.gz: 5aae2588bb3b849cba817a377f2995c55d7e0e8b27f770b9f5c991093f6c9f3032a7d2e9e64810bee44ffb8b616b2e6a1f55694297af1b8ca20bc22c1c4b5cde
+  data.tar.gz: 2e225121b919de40e9fbd803fbf0c3aa2cf5ebb7b0433c1bfa30e58e52cce864361f4248ef00b90892669a239d5908c0cab64b1cbf3ea72f1ee868f63dd34a40

data/README.md

@@ -0,0 +1 @@
+# MRuby Tools

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/*.rb"
+  t.warning = true
+end
+
+
+#
+# METRICS
+#
+
+begin
+  require 'flog_task'
+  FlogTask.new do |t|
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flog_task unavailable'
+end
+
+begin
+  require 'flay_task'
+  FlayTask.new do |t|
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flay_task unavailable'
+end
+
+begin
+  require 'roodi_task'
+  # RoodiTask.new config: '.roodi.yml', patterns: ['lib/**/*.rb']
+  RoodiTask.new patterns: ['lib/**/*.rb']
+rescue LoadError
+  warn "roodi_task unavailable"
+end
+
+#
+# GEM BUILD / PUBLISH
+#
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'mruby_tools.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  warn "buildar tasks unavailable"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1.1

data/bin/mrbt

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+require 'mruby_tools'
+
+# args like: file1.rb file2.rb -o outfile
+#  possibly: file1.rb -o outfile file2.rb -c generated.c
+
+opts = MRubyTools.args(ARGV)
+outfile = opts.fetch(:outfile)
+
+c_code = <<'EOF'
+#include <stdlib.h>
+#include <mruby.h>
+#include <mruby/compile.h>
+#include <mruby/string.h>
+
+void check_exc(mrb_state *mrb, char *filename) {
+  if (mrb->exc) {
+    mrb_value exc = mrb_obj_value(mrb->exc);
+    mrb_value exc_msg = mrb_funcall(mrb, exc, "to_s", 0);
+    fprintf(stderr, "ERROR in %s - %s: %s\n",
+            filename,
+            mrb_obj_classname(mrb, exc),
+            mrb_str_to_cstr(mrb, exc_msg));
+    /* mrb_print_backtrace(mrb);   # empty */
+    exit(1);
+  }
+}
+
+int
+main(void)
+{
+  mrb_state *mrb = mrb_open();
+  if (!mrb) {
+    printf("mrb problem");
+    exit(1);
+  }
+EOF
+
+c_code += opts.fetch(:rb_files).map { |rbf|
+  "\n" +  MRubyTools.rb2c(rbf) + "\n\n"
+}.join
+
+  c_code += <<EOF
+  mrb_close(mrb);
+  return 0;
+}
+EOF
+
+puts c_code + "\n" if opts[:verbose]
+
+file = opts[:cfile] || Tempfile.new(['generated', '.c'])
+file.write(c_code)
+file.close
+
+msd = MRubyTools.mruby_src_dir
+
+gcc_args = [
+  '-std=c99', "-I", File.join(msd, 'include'), file.path, "-o", outfile,
+  File.join(msd, 'build', 'host', 'lib', 'libmruby.a'), '-lm',
+]
+
+puts "compiling..."
+puts "created binary executable: #{outfile}" if system('gcc', *gcc_args)

data/examples/driver.rb

@@ -0,0 +1,98 @@
+SIMPLEX_PARAMS = [
+  # 1 (index 0)
+  [[1, 1],
+   [[2,  1],
+    [1,  2]],
+   [4, 3]],
+
+  [[3, 4],
+   [[1, 1],
+    [2, 1]],
+   [4, 5]],
+
+  [[2, -1],
+   [[1, 2],
+    [3, 2],],
+   [6, 12]],
+
+  [[60, 90, 300],
+   [[1, 1, 1],
+    [1, 3, 0],
+    [2, 0, 1]],
+   [600, 600, 900]],
+
+  # 5
+  [[70, 210, 140],
+   [[1, 1, 1],
+    [5, 4, 4],
+    [40, 20, 30]],
+   [100, 480, 3200]],
+
+  [[2, -1, 2],
+   [[2, 1, 0],
+    [1, 2, -2],
+    [0, 1, 2]],
+   [10, 20, 5]],
+
+  [[11, 16, 15],
+   [[1, 2, 3.to_f / 2],
+    [2.to_f / 3, 2.to_f / 3, 1],
+    [0.5, 1.to_f / 3, 0.5]],
+   [12_000, 4_600, 2_400]],
+
+  [[5, 4, 3],
+   [[2, 3, 1],
+    [4, 1, 2],
+    [3, 4, 2]],
+   [5, 11, 8]],
+
+  [[3, 2, -4],
+   [[1, 4, 0],
+    [2, 4,-2],
+    [1, 1,-2]],
+   [5, 6, 2]],
+
+  # 10
+  [[2, -1, 8],
+   [[2, -4, 6],
+    [-1, 3, 4],
+    [0, 0, 2]],
+   [3, 2, 1]],
+
+  [[100_000, 40_000, 18_000],
+   [[20, 6, 3],
+    [0, 1, 0],
+    [-1,-1, 1],
+    [-9, 1, 1]],
+   [182, 10, 0, 0]],
+
+  [[1, 2, 1, 2],
+   [[1, 0, 1, 0],
+    [0, 1, 0, 1],
+    [1, 1, 0, 0],
+    [0, 0, 1, 1]],
+   [1, 4, 2, 2]],
+
+  [[10, -57, -9, -24],
+   [[0.5, -5.5, -2.5, 9],
+    [0.5, -1.5, -0.5, 1],
+    [ 1,    0,    0, 0]],
+   [0, 0, 1]],
+
+  # 14 (index 13)
+  [[25, 20],
+   [[20, 12],
+    [1, 1]],
+   [1800, 8*15]],
+]
+
+def simplices
+  SIMPLEX_PARAMS.map { |c, a, b| Simplex.new(c, a, b) }
+end
+
+puts "calculating #{SIMPLEX_PARAMS.size} simplex solutions, repeatedly..."
+val, elapsed = Timer.loop_avg {
+  simplices.map { |s| s.solution }.join("\n")
+}
+
+puts "%0.8f s (avg) per solution" % (elapsed / SIMPLEX_PARAMS.size)

data/examples/goodbye_world.rb

@@ -0,0 +1 @@
+puts :goodbye_world

data/examples/hello_world.rb

@@ -0,0 +1 @@
+puts :hello_world

data/examples/raise.rb

@@ -0,0 +1,2 @@
+raise "stuff"
+#raise StandardError, "things"

data/examples/simplex.rb

@@ -0,0 +1,164 @@
+class Simplex
+  DEFAULT_MAX_PIVOTS = 10_000
+
+  class Error < RuntimeError; end
+  class UnboundedProblem < Error; end
+  class SanityCheck < Error; end
+  class TooManyPivots < Error; end
+
+  attr_accessor :max_pivots
+
+  # c - coefficients of objective function; size: num_vars
+  # a - inequality lhs coefficients;   2dim size: num_inequalities, num_vars
+  # b - inequality rhs constants            size: num_inequalities
+  def initialize(c, a, b)
+    num_vars = c.size
+    num_inequalities = b.size
+    raise(ArgumentError, "a doesn't match b") unless a.size == num_inequalities
+    raise(ArgumentError, "a doesn't match c") unless a.first.size == num_vars
+
+    @max_pivots = DEFAULT_MAX_PIVOTS
+
+    # Problem dimensions; these never change
+    @num_non_slack_vars = num_vars
+    @num_constraints    = num_inequalities
+    @num_vars           = @num_non_slack_vars + @num_constraints
+
+    # Set up initial matrix A and vectors b, c
+    @c = c.map { |flt| -1 * flt } + Array.new(@num_constraints, 0)
+    @a = a.map.with_index { |ary, i|
+      if ary.size != @num_non_slack_vars
+        raise ArgumentError, "a is inconsistent"
+      end
+      ary + Array.new(@num_constraints) { |ci| ci == i ? 1 : 0 }
+    }
+    @b = b
+
+    # set initial solution: all non-slack variables = 0
+    @basic_vars = (@num_non_slack_vars...@num_vars).to_a
+    self.update_solution
+  end
+
+  # does not modify vector / matrix
+  def update_solution
+    @x = Array.new(@num_vars, 0)
+
+    @basic_vars.each { |basic_var|
+      idx = nil
+      @num_constraints.times { |i|
+        if @a[i][basic_var] == 1
+          idx =i
+          break
+        end
+      }
+      raise(SanityCheck, "no idx for basic_var #{basic_var} in a") unless idx
+      @x[basic_var] = @b[idx]
+    }
+  end
+
+  def solution
+    self.solve
+    self.current_solution
+  end
+
+  def solve
+    count = 0
+    while self.can_improve?
+      count += 1
+      raise(TooManyPivots, count.to_s) unless count < @max_pivots
+      self.pivot
+    end
+  end
+
+  def current_solution
+    @x[0...@num_non_slack_vars]
+  end
+
+  def can_improve?
+    !self.entering_variable.nil?
+  end
+
+  # idx of @c's minimum negative value
+  # nil when no improvement is possible
+  #
+  def entering_variable
+    (0...@c.size).select { |i| @c[i] < 0 }.min_by { |i| @c[i] }
+  end
+
+  def pivot
+    pivot_column = self.entering_variable or return nil
+    pivot_row = self.pivot_row(pivot_column) or raise UnboundedProblem
+    leaving_var = nil
+    @a[pivot_row].each_with_index { |a, i|
+      if a == 1 and @basic_vars.include?(i)
+        leaving_var = i
+        break
+      end
+    }
+    raise(SanityCheck, "no leaving_var") if leaving_var.nil?
+
+    @basic_vars.delete(leaving_var)
+    @basic_vars.push(pivot_column)
+    @basic_vars.sort!
+
+    pivot_ratio = 1.to_f / @a[pivot_row][pivot_column]
+
+    # update pivot row
+    @a[pivot_row] = @a[pivot_row].map { |val| val * pivot_ratio }
+    @b[pivot_row] = @b[pivot_row] * pivot_ratio
+
+    # update objective
+    # @c -= @c[pivot_column] * @a[pivot_row]
+    @c = @c.map.with_index { |val, i|
+      val - @c[pivot_column] * @a[pivot_row][i]
+    }
+
+    # update A and B
+    @num_constraints.times { |i|
+      next if i == pivot_row
+      r = @a[i][pivot_column]
+      @a[i] = @a[i].map.with_index { |val, j| val - r * @a[pivot_row][j] }
+      @b[i] = @b[i] - r * @b[pivot_row]
+    }
+
+    self.update_solution
+  end
+
+  def pivot_row(column_ix)
+    min_ratio = nil
+    idx = nil
+    @num_constraints.times { |i|
+      a, b = @a[i][column_ix], @b[i]
+      next if a == 0 or (b < 0) ^ (a < 0)
+      ratio = b.to_f / a
+      idx, min_ratio = i, ratio if min_ratio.nil? or ratio <= min_ratio
+    }
+    idx
+  end
+
+  def formatted_tableau
+    if self.can_improve?
+      pivot_column = self.entering_variable
+      pivot_row    = self.pivot_row(pivot_column)
+    else
+      pivot_row = nil
+    end
+    c = @c.to_a.map { |flt| "%2.3f" % flt }
+    b = @b.to_a.map { |flt| "%2.3f" % flt }
+    a = @a.to_a.map { |vec| vec.to_a.map { |flt| "%2.3f" % flt } }
+    if pivot_row
+      a[pivot_row][pivot_column] = "*" + a[pivot_row][pivot_column]
+    end
+    max = (c + b + a + ["1234567"]).flatten.map(&:size).max
+    result = []
+    result << c.map { |str| str.rjust(max, " ") }
+    a.zip(b) do |arow, brow|
+      result << (arow + [brow]).map { |val| val.rjust(max, " ") }
+      result.last.insert(arow.length, "|")
+    end
+    lines = result.map { |ary| ary.join("  ") }
+    max_line_length = lines.map(&:length).max
+    lines.insert(1, "-"*max_line_length)
+    lines.join("\n")
+  end
+end

data/examples/timer.rb

@@ -0,0 +1,27 @@
+module Timer
+  def self.now
+    Time.now
+  end
+
+  def self.since(t)
+    self.now - t
+  end
+
+  def self.elapsed(&work)
+    t = self.now
+    return yield, self.since(t)
+  end
+
+  def self.loop_avg(count = 999, seconds = 1, &work)
+    i = 0
+    start = self.now
+    val = nil
+    loop {
+      val = yield
+      i += 1
+      break if i >= count
+      break if self.since(start) > seconds
+    }
+    return val, self.since(start) / i.to_f
+  end
+end

data/lib/mruby_tools.rb

@@ -0,0 +1,48 @@
+module MRubyTools
+  def self.rb2c(rb_filename, indent: '  ')
+    c_str = File.read(rb_filename)
+    size = c_str.size
+    c_str = c_str.gsub("\n", '\n').gsub('"', '\"')
+    c_str = File.read(rb_filename).gsub("\n", '\n').gsub('"', '\"')
+    [ "/* #{rb_filename} */",
+      'mrb_load_nstring(mrb, "' + c_str + '", ' + "#{size});",
+      "check_exc(mrb, \"#{rb_filename}\");",
+    ].map { |s| indent + s }.join("\n")
+  end
+
+  def self.mruby_src_dir(env_var = 'MRUBY_SRC')
+    mruby_src_dir = ENV[env_var]
+    raise "env: MRUBY_SRC is required" unless mruby_src_dir
+    raise "bad MRUBY_SRC #{mruby_src_dir}" unless File.directory? mruby_src_dir
+    mruby_inc_dir = File.join(mruby_src_dir, 'include')
+    raise "bad MRUBY_SRC #{mruby_inc_dir}" unless File.directory? mruby_inc_dir
+    mruby_src_dir
+  end
+
+  def self.args(argv = ARGV)
+    rb_files = []
+    outfile = nil
+    cfile = nil
+    verbose = false
+
+    while !argv.empty?
+      arg = argv.shift
+      if arg == '-o'
+        outfile = argv.shift
+        raise "no outfile provided with -o" unless outfile
+        raise "#{outfile} is misnamed" if File.extname(outfile) == '.rb'
+      elsif arg == '-c'
+        cfile = File.open(argv.shift || 'generated.c', "w")
+      elsif arg == '-v'
+        verbose = true
+      else
+        rb_files << arg
+      end
+    end
+
+    { verbose: verbose,
+      cfile: cfile,
+      outfile: outfile || 'outfile',
+      rb_files: rb_files }
+  end
+end

data/mruby_tools.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = 'mruby_tools'
+  s.summary = "MRI Ruby tools for assisting in MRuby development"
+  s.description = "TBD"
+  s.authors = ["Rick Hull"]
+  s.homepage = "https://github.com/rickhull/mruby-tools"
+  s.license = "LGPL-3.0"
+
+  s.required_ruby_version = "~> 2"
+
+  s.version = File.read(File.join(__dir__, 'VERSION')).chomp
+
+  s.files = %w[mruby_tools.gemspec VERSION README.md Rakefile]
+  %w[lib bin test examples].each { |dir|
+    s.files += Dir[File.join(dir, '**', '*.rb')]
+  }
+
+  s.executables << 'mrbt'
+
+  s.add_development_dependency "rake", "~> 0"
+  s.add_development_dependency "buildar", "~> 3.0"
+#  s.add_development_dependency "minitest", "~> 5.0"
+#  s.add_development_dependency "flog", "~> 0"
+#  s.add_development_dependency "flay", "~> 0"
+#  s.add_development_dependency "roodi", "~> 0"
+#  s.add_development_dependency "ruby-prof", "~> 0"
+#  s.add_development_dependency "benchmark-ips", "~> 2.0"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: mruby_tools
+version: !ruby/object:Gem::Version
+  version: 0.0.1.1
+platform: ruby
+authors:
+- Rick Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: buildar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: TBD
+email: 
+executables:
+- mrbt
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- VERSION
+- bin/mrbt
+- examples/driver.rb
+- examples/goodbye_world.rb
+- examples/hello_world.rb
+- examples/raise.rb
+- examples/simplex.rb
+- examples/timer.rb
+- lib/mruby_tools.rb
+- mruby_tools.gemspec
+homepage: https://github.com/rickhull/mruby-tools
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: MRI Ruby tools for assisting in MRuby development
+test_files: []