rubyduino 0.1.1

data/vendor/spinel/benchmark/bm_ao_render.rb

@@ -0,0 +1,323 @@
+# AO render benchmark
+# Original program (C) Syoyo Fujita in JavaScript (and other languages)
+#      https://code.google.com/p/aobench/
+# Ruby(yarv2llvm) version by Hideki Miura
+# mruby version by Hideki Miura
+#
+
+IMAGE_WIDTH = Integer(ARGV[0] || 64)
+IMAGE_HEIGHT = IMAGE_WIDTH
+NSUBSAMPLES = 2
+NAO_SAMPLES = 8
+
+class Rand
+  def initialize
+    @x = 123456789
+    @y = 362436069
+    @z = 521288629
+    @w = 88675123
+  end
+  def rand
+    x = @x
+    t = x ^ ((x & 0xfffff) << 11)
+    w = @w
+    @x, @y, @z = @y, @z, w
+    w = @w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
+    r = (w % 536870912).to_f / 536870912.0
+    r
+  end
+end
+RAND = Rand.new
+
+class Vec
+  def initialize(x, y, z)
+    @x = x
+    @y = y
+    @z = z
+  end
+
+  def x=(v); @x = v; end
+  def y=(v); @y = v; end
+  def z=(v); @z = v; end
+  def x; @x; end
+  def y; @y; end
+  def z; @z; end
+
+  def vadd(b)
+    Vec.new(@x + b.x, @y + b.y, @z + b.z)
+  end
+
+  def vsub(b)
+    Vec.new(@x - b.x, @y - b.y, @z - b.z)
+  end
+
+  def vcross(b)
+    Vec.new(@y * b.z - @z * b.y,
+            @z * b.x - @x * b.z,
+            @x * b.y - @y * b.x)
+  end
+
+  def vdot(b)
+    r = @x * b.x + @y * b.y + @z * b.z
+    r
+  end
+
+  def vlength
+    Math.sqrt(@x * @x + @y * @y + @z * @z)
+  end
+
+  def vnormalize
+    len = vlength
+    v = Vec.new(@x, @y, @z)
+    if len > 1.0e-17
+      v.x = v.x / len
+      v.y = v.y / len
+      v.z = v.z / len
+    end
+    v
+  end
+end
+
+
+class Sphere
+  def initialize(center, radius)
+    @center = center
+    @radius = radius
+  end
+
+  def center; @center; end
+  def radius; @radius; end
+
+  def intersect(ray, isect)
+    rs = ray.org.vsub(@center)
+    b = rs.vdot(ray.dir)
+    c = rs.vdot(rs) - (@radius * @radius)
+    d = b * b - c
+    if d > 0.0
+      t = - b - Math.sqrt(d)
+
+      if t > 0.0 and t < isect.t
+        isect.t = t
+        isect.hit = true
+        isect.pl = Vec.new(ray.org.x + ray.dir.x * t,
+                          ray.org.y + ray.dir.y * t,
+                          ray.org.z + ray.dir.z * t)
+        n = isect.pl.vsub(@center)
+        isect.n = n.vnormalize
+      end
+    end
+  end
+end
+
+class Plane
+  def initialize(p, n)
+    @p = p
+    @n = n
+  end
+
+  def intersect(ray, isect)
+    d = -@p.vdot(@n)
+    v = ray.dir.vdot(@n)
+    v0 = v
+    if v < 0.0
+      v0 = -v
+    end
+    if v0 < 1.0e-17
+      return
+    end
+
+    t = -(ray.org.vdot(@n) + d) / v
+
+    if t > 0.0 and t < isect.t
+      isect.hit = true
+      isect.t = t
+      isect.n = @n
+      isect.pl = Vec.new(ray.org.x + t * ray.dir.x,
+                        ray.org.y + t * ray.dir.y,
+                        ray.org.z + t * ray.dir.z)
+    end
+  end
+end
+
+class Ray
+  def initialize(org, dir)
+    @org = org
+    @dir = dir
+  end
+
+  def org; @org; end
+  def org=(v); @org = v; end
+  def dir; @dir; end
+  def dir=(v); @dir = v; end
+end
+
+class Isect
+  def initialize
+    @t = 10000000.0
+    @hit = false
+    @pl = Vec.new(0.0, 0.0, 0.0)
+    @n = Vec.new(0.0, 0.0, 0.0)
+  end
+
+  def t; @t; end
+  def t=(v); @t = v; end
+  def hit; @hit; end
+  def hit=(v); @hit = v; end
+  def pl; @pl; end
+  def pl=(v); @pl = v; end
+  def n; @n; end
+  def n=(v); @n = v; end
+end
+
+def clamp(f)
+  i = f * 255.5
+  if i > 255.0
+    i = 255.0
+  end
+  if i < 0.0
+    i = 0.0
+  end
+  i.to_i
+end
+
+class Basis
+  def initialize
+    @b0 = Vec.new(0.0, 0.0, 0.0)
+    @b1 = Vec.new(0.0, 0.0, 0.0)
+    @b2 = Vec.new(0.0, 0.0, 0.0)
+  end
+  def b0; @b0; end
+  def b0=(v); @b0 = v; end
+  def b1; @b1; end
+  def b1=(v); @b1 = v; end
+  def b2; @b2; end
+  def b2=(v); @b2 = v; end
+
+  def compute(n)
+    @b2 = Vec.new(n.x, n.y, n.z)
+    @b1 = Vec.new(0.0, 0.0, 0.0)
+
+    if n.x < 0.6 and n.x > -0.6
+      @b1.x = 1.0
+    elsif n.y < 0.6 and n.y > -0.6
+      @b1.y = 1.0
+    elsif n.z < 0.6 and n.z > -0.6
+      @b1.z = 1.0
+    else
+      @b1.x = 1.0
+    end
+
+    @b0 = @b1.vcross(@b2)
+    @b0 = @b0.vnormalize
+
+    @b1 = @b2.vcross(@b0)
+    @b1 = @b1.vnormalize
+  end
+end
+
+class Scene
+  def initialize
+    @s0 = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
+    @s1 = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
+    @s2 = Sphere.new(Vec.new(1.0, 0.0, -2.2), 0.5)
+    @plane = Plane.new(Vec.new(0.0, -0.5, 0.0), Vec.new(0.0, 1.0, 0.0))
+  end
+
+  def ambient_occlusion(isect)
+    basis = Basis.new
+    basis.compute(isect.n)
+
+    ntheta    = NAO_SAMPLES
+    nphi      = NAO_SAMPLES
+    eps       = 0.0001
+    occlusion = 0.0
+
+    p0 = Vec.new(isect.pl.x + eps * isect.n.x,
+                isect.pl.y + eps * isect.n.y,
+                isect.pl.z + eps * isect.n.z)
+    nphi.times do
+      ntheta.times do
+        r = RAND.rand
+        phi = 2.0 * 3.14159265 * RAND.rand
+        x = Math.cos(phi) * Math.sqrt(1.0 - r)
+        y = Math.sin(phi) * Math.sqrt(1.0 - r)
+        z = Math.sqrt(r)
+
+        rx = x * basis.b0.x + y * basis.b1.x + z * basis.b2.x
+        ry = x * basis.b0.y + y * basis.b1.y + z * basis.b2.y
+        rz = x * basis.b0.z + y * basis.b1.z + z * basis.b2.z
+
+        raydir = Vec.new(rx, ry, rz)
+        ray = Ray.new(p0, raydir)
+
+        occisect = Isect.new
+        @s0.intersect(ray, occisect)
+        @s1.intersect(ray, occisect)
+        @s2.intersect(ray, occisect)
+        @plane.intersect(ray, occisect)
+        if occisect.hit
+          occlusion = occlusion + 1.0
+        end
+      end
+    end
+
+    occlusion = (ntheta.to_f * nphi.to_f - occlusion) / (ntheta.to_f * nphi.to_f)
+    Vec.new(occlusion, occlusion, occlusion)
+  end
+
+  def render(w, h, nsubsamples)
+    nsf = nsubsamples.to_f
+    nsfs = nsf * nsf
+    h.times do |y|
+      w.times do |x|
+        rad = Vec.new(0.0, 0.0, 0.0)
+
+        # Subsampling
+        nsubsamples.times do |v|
+          nsubsamples.times do |u|
+            wf = w.to_f
+            hf = h.to_f
+            xf = x.to_f
+            yf = y.to_f
+            uf = u.to_f
+            vf = v.to_f
+
+            px = (xf + (uf / nsf) - (wf / 2.0)) / (wf / 2.0)
+            py = -(yf + (vf / nsf) - (hf / 2.0)) / (hf / 2.0)
+
+            eye = Vec.new(px, py, -1.0).vnormalize
+
+            ray = Ray.new(Vec.new(0.0, 0.0, 0.0), eye)
+
+            isect = Isect.new
+            @s0.intersect(ray, isect)
+            @s1.intersect(ray, isect)
+            @s2.intersect(ray, isect)
+            @plane.intersect(ray, isect)
+            if isect.hit
+              col = ambient_occlusion(isect)
+              rad.x = rad.x + col.x
+              rad.y = rad.y + col.y
+              rad.z = rad.z + col.z
+            end
+          end
+        end
+
+        r = rad.x / nsfs
+        g = rad.y / nsfs
+        b = rad.z / nsfs
+        print clamp(r).chr
+        print clamp(g).chr
+        print clamp(b).chr
+      end
+    end
+  end
+end
+
+# File.open("ao.ppm", "w") do |fp|
+  printf("P6\n")
+  printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
+  printf("255\n")
+  Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
+#  Scene.new.render(256, 256, 2)
+# end

data/vendor/spinel/benchmark/bm_attr_accessor.rb

@@ -0,0 +1,41 @@
+# attr_accessor benchmark (from yjit-bench)
+
+class TheClass
+  attr_accessor :levar
+
+  def initialize
+    @v0 = 1
+    @v1 = 2
+    @v2 = 3
+    @levar = 1
+  end
+
+  def get_value_loop
+    sum = 0
+    i = 0
+    while i < 1000000
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      sum = sum + levar
+      i = i + 1
+    end
+    sum
+  end
+end
+
+obj = TheClass.new
+total = 0
+n = 0
+while n < 10
+  total = total + obj.get_value_loop
+  n = n + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_bigint_fib.rb

@@ -0,0 +1,10 @@
+a = 0
+b = 1
+i = 0
+while i < 1000
+  c = a + b
+  a = b
+  b = c
+  i = i + 1
+end
+puts a

data/vendor/spinel/benchmark/bm_binary_trees.rb

@@ -0,0 +1,53 @@
+# The Computer Language Benchmarks Game
+# Binary Trees - class-based nodes
+
+class Node
+  attr_accessor :left, :right
+  def initialize(left, right)
+    @left = left
+    @right = right
+  end
+end
+
+def make_tree(depth)
+  if depth == 0
+    return Node.new(nil, nil)
+  end
+  d = depth - 1
+  Node.new(make_tree(d), make_tree(d))
+end
+
+def check_tree(node)
+  if node.left == nil
+    return 1
+  end
+  1 + check_tree(node.left) + check_tree(node.right)
+end
+
+max_depth = Integer(ARGV[0] || 10)
+min_depth = 4
+if min_depth + 2 > max_depth
+  max_depth = min_depth + 2
+end
+
+stretch_depth = max_depth + 1
+stretch_tree = make_tree(stretch_depth)
+puts check_tree(stretch_tree)
+
+long_lived_tree = make_tree(max_depth)
+
+depth = min_depth
+while depth <= max_depth
+  iterations = 2 ** (max_depth - depth + min_depth)
+  check = 0
+  i = 1
+  while i <= iterations
+    t = make_tree(depth)
+    check = check + check_tree(t)
+    i = i + 1
+  end
+  puts check
+  depth = depth + 2
+end
+
+puts check_tree(long_lived_tree)

data/vendor/spinel/benchmark/bm_csv_process.rb

@@ -0,0 +1,58 @@
+# CSV processor - process only (no massive string concat in generate)
+
+def generate_lines(n)
+  depts = ["eng", "sales", "hr", "ops"]
+  names = ["alice", "bob", "carol", "dave", "eve"]
+  lines = ["name,dept,salary,age"]
+  i = 0
+  while i < n
+    name = names[i % 5]
+    dept = depts[i % 4]
+    salary = 30000 + (i * 1337) % 70000
+    age = 22 + i % 40
+    lines.push(name + "," + dept + "," + salary.to_s + "," + age.to_s)
+    i = i + 1
+  end
+  lines
+end
+
+def process_lines(lines)
+  total_salary = 0
+  high_earners = 0
+  dept_counts = {}
+  i = 1
+  while i < lines.length
+    fields = lines[i].split(",")
+    if fields.length >= 4
+      dept = fields[1]
+      salary = fields[2].to_i
+      total_salary = total_salary + salary
+      if salary >= 80000
+        high_earners = high_earners + 1
+      end
+      if dept_counts.has_key?(dept)
+        dept_counts[dept] = dept_counts[dept] + 1
+      else
+        dept_counts[dept] = 1
+      end
+    end
+    i = i + 1
+  end
+  puts lines.length - 1
+  puts total_salary
+  puts high_earners
+  dept_counts.each { |k, v|
+    puts k + ": " + v.to_s
+  }
+end
+
+lines = generate_lines(5000)
+process_lines(lines)
+
+# Benchmark: process 200 times
+i = 0
+while i < 200
+  process_lines(lines)
+  i = i + 1
+end
+puts "done"

data/vendor/spinel/benchmark/bm_fannkuch.rb

@@ -0,0 +1,88 @@
+# The Computer Language Benchmarks Game
+# Fannkuch-Redux - adapted for Spinel
+
+def fannkuch(n)
+  p = Array.new(n + 1, 0)
+  s = Array.new(n + 1, 0)
+  q = Array.new(n + 1, 0)
+  i = 0
+  while i <= n
+    p[i] = i
+    s[i] = i
+    q[i] = i
+    i = i + 1
+  end
+  sign = 1
+  sum = 0
+  maxflips = 0
+  while true
+    q1 = p[1]
+    if q1 != 1
+      i = 0
+      while i <= n
+        q[i] = p[i]
+        i = i + 1
+      end
+      flips = 1
+      qq = q[q1]
+      while qq != 1
+        q[q1] = q1
+        if q1 >= 4
+          i = 2
+          j = q1 - 1
+          while i < j
+            t = q[i]
+            q[i] = q[j]
+            q[j] = t
+            i = i + 1
+            j = j - 1
+          end
+        end
+        q1 = qq
+        flips = flips + 1
+        qq = q[q1]
+      end
+      sum = sum + sign * flips
+      if flips > maxflips
+        maxflips = flips
+      end
+    end
+    # Permute
+    if sign == 1
+      t = p[1]
+      p[1] = p[2]
+      p[2] = t
+      sign = -1
+    else
+      t = p[2]
+      p[2] = p[3]
+      p[3] = t
+      sign = 1
+      i = 3
+      while i <= n
+        if s[i] != 1
+          break
+        end
+        if i == n
+          puts sum
+          puts maxflips
+          return
+        end
+        s[i] = i
+        # Rotate 1<-...<-i+1
+        t = p[1]
+        j = 1
+        while j < i + 1
+          p[j] = p[j + 1]
+          j = j + 1
+        end
+        p[i + 1] = t
+        i = i + 1
+      end
+      s[i] = s[i] - 1
+    end
+  end
+end
+
+n = Integer(ARGV[0] || 7)
+fannkuch(n)

data/vendor/spinel/benchmark/bm_fasta.rb

@@ -0,0 +1,87 @@
+# The Computer Language Benchmarks Game - Fasta
+# Generate random DNA sequences
+
+IM = 139968
+IA = 3877
+IC = 29573
+
+$last = 42
+
+def gen_random(max)
+  $last = ($last * IA + IC) % IM
+  max * $last / IM
+end
+
+def make_repeat_fasta(id, desc, src, n)
+  puts ">" + id + " " + desc
+  k = 0
+  i = 0
+  while i < n
+    len = 60
+    if n - i < 60
+      len = n - i
+    end
+    line = ""
+    j = 0
+    while j < len
+      line = line + src[k % src.length]
+      k = k + 1
+      j = j + 1
+    end
+    puts line
+    i = i + len
+  end
+end
+
+def make_random_fasta(id, desc, table_chars, table_probs, n)
+  puts ">" + id + " " + desc
+  # Build cumulative probabilities
+  cp = Array.new(table_probs.length, 0.0)
+  sum = 0.0
+  k = 0
+  while k < table_probs.length
+    sum = sum + table_probs[k]
+    cp[k] = sum
+    k = k + 1
+  end
+  i = 0
+  while i < n
+    len = 60
+    if n - i < 60
+      len = n - i
+    end
+    line = ""
+    j = 0
+    while j < len
+      r = gen_random(1.0)
+      # Linear search
+      c = 0
+      while c < cp.length - 1
+        if r < cp[c]
+          break
+        end
+        c = c + 1
+      end
+      line = line + table_chars[c]
+      j = j + 1
+    end
+    puts line
+    i = i + len
+  end
+end
+
+ALU = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAAA"
+
+n = Integer(ARGV[0] || 1000)
+
+make_repeat_fasta("ONE", "Homo sapiens alu", ALU, n * 2)
+
+iub_chars = ["a", "c", "g", "t", "B", "D", "H", "K", "M", "N", "R", "S", "V", "W", "Y"]
+iub_probs = [0.27, 0.12, 0.12, 0.27, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02]
+
+make_random_fasta("TWO", "IUB ambiguity codes", iub_chars, iub_probs, n * 3)
+
+homo_chars = ["a", "c", "g", "t"]
+homo_probs = [0.3029549426680, 0.1979883004921, 0.1975473066391, 0.3015094502008]
+
+make_random_fasta("THREE", "Homo sapiens frequency", homo_chars, homo_probs, n * 5)

data/vendor/spinel/benchmark/bm_fib.rb

@@ -0,0 +1,9 @@
+def fib(n)
+  if n < 2
+    n
+  else
+    fib(n - 1) + fib(n - 2)
+  end
+end
+
+puts fib(34)