Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Benchmark result on Haswell
2016-09-12 07:02:10 +0900
target 0: ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] at "./miniruby55727 -I./lib -I. -I.ext/common --disable-gem"
target 1: built-ruby (ruby 2.4.0dev (2016-09-11) [x86_64-linux]) at "./miniruby -I./lib -I. -I.ext/common --disable-gem"
measure target: real
-----------------------------------------------------------
app_answer
def ack(m, n)
if m == 0 then
n + 1
elsif n == 0 then
ack(m - 1, 1)
else
ack(m - 1, ack(m, n - 1))
end
end
def the_answer_to_life_the_universe_and_everything
(ack(3,7).to_s.split(//).inject(0){|s,x| s+x.to_i}.to_s + "2" ).to_i
end
answer = the_answer_to_life_the_universe_and_everything
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.054968526936136186
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.043999257031828165
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.043813185999169946
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.06688361300621182
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.06308504904154688
built-ruby 0.06399883492849767
built-ruby 0.047931801062077284
built-ruby 0.07002927793655545
built-ruby 0.04975632997229695
built-ruby 0.06824782805051655
-----------------------------------------------------------
app_aobench
# 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
#
IMAGE_WIDTH = 256
IMAGE_HEIGHT = 256
NSUBSAMPLES = 2
NAO_SAMPLES = 8
class Vec
def initialize(x, y, z)
@x = x
@y = y
@z = z
end
attr_accessor :x, :y, :z
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)
@x * b.x + @y * b.y + @z * b.z
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 then
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
attr_reader :center, :radius
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 then
t = - b - Math.sqrt(d)
if t > 0.0 and t < isect.t then
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
else
0.0
end
end
nil
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 then
v0 = -v
end
if v0 < 1.0e-17 then
return
end
t = -(ray.org.vdot(@n) + d) / v
if t > 0.0 and t < isect.t then
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
nil
end
end
class Ray
def initialize(org, dir)
@org = org
@dir = dir
end
attr_accessor :org, :dir
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
attr_accessor :t, :hit, :pl, :n
end
def clamp(f)
i = f * 255.5
if i > 255.0 then
i = 255.0
end
if i < 0.0 then
i = 0.0
end
i.to_i
end
def otherBasis(basis, n)
basis[2] = Vec.new(n.x, n.y, n.z)
basis[1] = Vec.new(0.0, 0.0, 0.0)
if n.x < 0.6 and n.x > -0.6 then
basis[1].x = 1.0
elsif n.y < 0.6 and n.y > -0.6 then
basis[1].y = 1.0
elsif n.z < 0.6 and n.z > -0.6 then
basis[1].z = 1.0
else
basis[1].x = 1.0
end
basis[0] = basis[1].vcross(basis[2])
basis[0] = basis[0].vnormalize
basis[1] = basis[2].vcross(basis[0])
basis[1] = basis[1].vnormalize
end
class Scene
def initialize
@spheres = Array.new
@spheres[0] = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
@spheres[1] = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
@spheres[2] = 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 = Array.new
otherBasis(basis, 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 |j|
ntheta.times do |i|
r = rand
phi = 2.0 * 3.14159265 * 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[0].x + y * basis[1].x + z * basis[2].x
ry = x * basis[0].y + y * basis[1].y + z * basis[2].y
rz = x * basis[0].z + y * basis[1].z + z * basis[2].z
raydir = Vec.new(rx, ry, rz)
ray = Ray.new(p0, raydir)
occisect = Isect.new
@spheres[0].intersect(ray, occisect)
@spheres[1].intersect(ray, occisect)
@spheres[2].intersect(ray, occisect)
@plane.intersect(ray, occisect)
if occisect.hit then
occlusion = occlusion + 1.0
else
0.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)
cnt = 0
nsf = nsubsamples.to_f
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|
cnt = cnt + 1
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
@spheres[0].intersect(ray, isect)
@spheres[1].intersect(ray, isect)
@spheres[2].intersect(ray, isect)
@plane.intersect(ray, isect)
if isect.hit then
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 / (nsf * nsf)
g = rad.y / (nsf * nsf)
b = rad.z / (nsf * nsf)
printf("%c", clamp(r))
printf("%c", clamp(g))
printf("%c", clamp(b))
end
nil
end
nil
end
end
alias printf_orig printf
def printf *args
end
# File.open("ao.ppm", "w") do |fp|
printf("P6\n")
printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
printf("255\n", IMAGE_WIDTH, IMAGE_HEIGHT)
Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
# end
undef printf
alias printf printf_orig
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 54.58599109004717
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 55.576182116987184
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 55.796338962973095
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 55.292317920946516
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 55.461386871989816
built-ruby 51.75369838497136
built-ruby 51.12740166299045
built-ruby 52.270437979954295
built-ruby 50.30211525806226
built-ruby 51.37324380793143
-----------------------------------------------------------
app_erb
#
# Create many HTML strings with ERB.
#
require 'erb'
data = DATA.read
max = 15_000
title = "hello world!"
content = "hello world!\n" * 10
max.times{
ERB.new(data).result(binding)
}
__END__
<html>
<head> <%= title %> </head>
<body>
<h1> <%= title %> </h1>
<p>
<%= content %>
</p>
</body>
</html>
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.231968601932749
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.214464233024046
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.2946588959312066
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.2567868429468945
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.302027763915248
built-ruby 2.3040525909746066
built-ruby 2.373874614946544
built-ruby 2.360743193072267
built-ruby 2.296779378084466
built-ruby 2.3394880950218067
-----------------------------------------------------------
app_factorial
def fact(n)
if(n > 1)
n * fact(n-1)
else
1
end
end
100.times {
fact(5000)
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8302856918890029
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8107500380137935
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8689422660972923
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8381959450198337
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8038355390308425
built-ruby 0.8040747550548986
built-ruby 0.8507883159909397
built-ruby 0.798156816046685
built-ruby 0.805755464010872
built-ruby 0.8560758630046621
-----------------------------------------------------------
app_fib
def fib n
if n < 3
1
else
fib(n-1) + fib(n-2)
end
end
fib(34)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5394219270674512
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5461057809880003
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5409830220742151
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5282882750034332
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.542332053068094
built-ruby 0.5090699099237099
built-ruby 0.49279818299692124
built-ruby 0.503557913005352
built-ruby 0.529371326090768
built-ruby 0.5138792649377137
-----------------------------------------------------------
app_lc_fizzbuzz
#
# FizzBuzz program using only lambda calculus
#
# This program is quoted from
# "Understanding Computation" by Tom Stuart
# http://computationbook.com/
#
# You can understand why this program works fine by reading this book.
#
solution = -> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[m][n]][-> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[f[-> n { -> p { -> x { p[n[p][x]] } } }[m]][n]][m][x] }][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]] } } }][-> p { -> x { p[x] } }][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] } }]][-> n { -> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[x]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> n { -> l { -> x { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][x]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[-> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> x { f[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { -> n { -> p { -> x { p[n[p][x]] } } }[f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n]][x] }][-> p { -> x { x } }] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][x] }]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]] } }][n]]]] }]
FIRST = -> l { LEFT[RIGHT[l]] }
IF = -> b { b }
LEFT = -> p { p[-> x { -> y { x } } ] }
RIGHT = -> p { p[-> x { -> y { y } } ] }
IS_EMPTY = LEFT
REST = -> l { RIGHT[RIGHT[l]] }
def to_integer(proc)
proc[-> n { n + 1 }][0]
end
def to_boolean(proc)
IF[proc][true][false]
end
def to_array(proc)
array = []
until to_boolean(IS_EMPTY[proc])
array.push(FIRST[proc])
proc = REST[proc]
end
array
end
def to_char(c)
'0123456789BFiuz'.slice(to_integer(c))
end
def to_string(s)
to_array(s).map { |c| to_char(c) }.join
end
answer = to_array(solution).map do |p|
to_string(p)
end
answer_ary = answer.to_a
# puts answer_ary
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 69.99791057093535
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 70.33638256508857
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 69.43688092799857
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 68.59378365206067
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 71.47225636104122
built-ruby 40.99161151901353
built-ruby 41.49508108908776
built-ruby 42.590445040958
built-ruby 44.49675606191158
built-ruby 42.17322386696469
-----------------------------------------------------------
app_mandelbrot
require 'complex'
def mandelbrot? z
i = 0
while i<100
i += 1
z = z * z
return false if z.abs > 2
end
true
end
ary = []
(0..1000).each{|dx|
(0..1000).each{|dy|
x = dx / 50.0
y = dy / 50.0
c = Complex(x, y)
ary << c if mandelbrot?(c)
}
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4691719140391797
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4137170379981399
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.439615415991284
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4169191860128194
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4996583830798045
built-ruby 1.4342095679603517
built-ruby 1.4227394519839436
built-ruby 1.4569037030451
built-ruby 1.3930311589501798
built-ruby 1.4416190939955413
-----------------------------------------------------------
app_pentomino
#!/usr/local/bin/ruby
# This program is contributed by Shin Nishiyama
# modified by K.Sasada
NP = 5
ROW = 8 + NP
COL = 8
$p = []
$b = []
$no = 0
def piece(n, a, nb)
nb.each{|x|
a[n] = x
if n == NP-1
$p << [a.sort]
else
nbc=nb.dup
[-ROW, -1, 1, ROW].each{|d|
if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
nbc << x+d
end
}
nbc.delete x
piece(n+1,a[0..n],nbc)
end
}
end
def kikaku(a)
a.collect {|x| x - a[0]}
end
def ud(a)
kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
end
def rl(a)
kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
end
def xy(a)
kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
end
def mkpieces
piece(0,[],[0])
$p.each do |a|
a0 = a[0]
a[1] = ud(a0)
a[2] = rl(a0)
a[3] = ud(rl(a0))
a[4] = xy(a0)
a[5] = ud(xy(a0))
a[6] = rl(xy(a0))
a[7] = ud(rl(xy(a0)))
a.sort!
a.uniq!
end
$p.uniq!.sort! {|x,y| x[0] <=> y[0] }
end
def mkboard
(0...ROW*COL).each{|i|
if i % ROW >= ROW-NP
$b[i] = -2
else
$b[i] = -1
end
$b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
}
end
def pboard
return # skip print
print "No. #$no\n"
(0...COL).each{|i|
print "|"
(0...ROW-NP).each{|j|
x = $b[i*ROW+j]
if x < 0
print "..|"
else
printf "%2d|",x+1
end
}
print "\n"
}
print "\n"
end
$pnum=[]
def setpiece(a,pos)
if a.length == $p.length then
$no += 1
pboard
return
end
while $b[pos] != -1
pos += 1
end
($pnum - a).each do |i|
$p[i].each do |x|
f = 0
x.each{|s|
if $b[pos+s] != -1
f=1
break
end
}
if f == 0 then
x.each{|s|
$b[pos+s] = i
}
a << i
setpiece(a.dup, pos)
a.pop
x.each{|s|
$b[pos+s] = -1
}
end
end
end
end
mkpieces
mkboard
$p[4] = [$p[4][0]]
$pnum = (0...$p.length).to_a
setpiece([],0)
__END__
# original
NP = 5
ROW = 8 + NP
COL = 8
$p = []
$b = []
$no = 0
def piece(n,a,nb)
for x in nb
a[n] = x
if n == NP-1
$p << [a.sort]
else
nbc=nb.dup
for d in [-ROW, -1, 1, ROW]
if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
nbc << x+d
end
end
nbc.delete x
piece(n+1,a[0..n],nbc)
end
end
end
def kikaku(a)
a.collect {|x| x - a[0]}
end
def ud(a)
kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
end
def rl(a)
kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
end
def xy(a)
kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
end
def mkpieces
piece(0,[],[0])
$p.each do |a|
a0 = a[0]
a[1] = ud(a0)
a[2] = rl(a0)
a[3] = ud(rl(a0))
a[4] = xy(a0)
a[5] = ud(xy(a0))
a[6] = rl(xy(a0))
a[7] = ud(rl(xy(a0)))
a.sort!
a.uniq!
end
$p.uniq!.sort! {|x,y| x[0] <=> y[0] }
end
def mkboard
for i in 0...ROW*COL
if i % ROW >= ROW-NP
$b[i] = -2
else
$b[i] = -1
end
$b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
end
end
def pboard
print "No. #$no\n"
for i in 0...COL
print "|"
for j in 0...ROW-NP
x = $b[i*ROW+j]
if x < 0
print "..|"
else
printf "%2d|",x+1
end
end
print "\n"
end
print "\n"
end
$pnum=[]
def setpiece(a,pos)
if a.length == $p.length then
$no += 1
pboard
return
end
while $b[pos] != -1
pos += 1
end
($pnum - a).each do |i|
$p[i].each do |x|
f = 0
for s in x do
if $b[pos+s] != -1
f=1
break
end
end
if f == 0 then
for s in x do
$b[pos+s] = i
end
a << i
setpiece(a.dup, pos)
a.pop
for s in x do
$b[pos+s] = -1
end
end
end
end
end
mkpieces
mkboard
$p[4] = [$p[4][0]]
$pnum = (0...$p.length).to_a
setpiece([],0)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 16.955009859986603
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 17.016228512045927
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 17.123202687012963
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 17.22535213001538
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 17.16649117495399
built-ruby 17.548675701022148
built-ruby 17.592179167084396
built-ruby 17.548861957970075
built-ruby 17.845728643005714
built-ruby 17.710411740932614
-----------------------------------------------------------
app_raise
i = 0
while i<300000
i += 1
begin
raise
rescue
end
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.24152075592428446
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.30898132803849876
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.2403825499350205
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.25906085793394595
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.26233157294336706
built-ruby 0.25932497496251017
built-ruby 0.2245949930511415
built-ruby 0.23073543095961213
built-ruby 0.21433765604160726
built-ruby 0.22223564109299332
-----------------------------------------------------------
app_strconcat
i = 0
while i<2_000_000
"#{1+1} #{1+1} #{1+1}"
i += 1
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.099352365010418
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1284073980059475
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0681289340136573
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0726434210082516
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1101944859838113
built-ruby 1.1025448340224102
built-ruby 1.211157893994823
built-ruby 1.1006269420031458
built-ruby 1.0723086389480159
built-ruby 1.114692494040355
-----------------------------------------------------------
app_tak
def tak x, y, z
unless y < x
z
else
tak( tak(x-1, y, z),
tak(y-1, z, x),
tak(z-1, x, y))
end
end
tak(18, 9, 0)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7760888659395278
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7183313800487667
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.800829699030146
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7779099229956046
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7689379589864984
built-ruby 0.7379660790320486
built-ruby 0.7507547120330855
built-ruby 0.7746493939775974
built-ruby 0.7573163129854947
built-ruby 0.7513459080364555
-----------------------------------------------------------
app_tarai
def tarai( x, y, z )
if x <= y
then y
else tarai(tarai(x-1, y, z),
tarai(y-1, z, x),
tarai(z-1, x, y))
end
end
tarai(12, 6, 0)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6000802039634436
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6422550959978253
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6254906730027869
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6682855940889567
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6114415570627898
built-ruby 0.6225703150266781
built-ruby 0.619686861988157
built-ruby 0.6119015109725296
built-ruby 0.6365446960553527
built-ruby 0.6483560899505392
-----------------------------------------------------------
app_uri
require 'uri'
100_000.times{
uri = URI.parse('http://www.ruby-lang.org')
uri.scheme
uri.host
uri.port
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6080217339331284
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5974279250949621
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6283238979522139
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5964365160325542
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5917318909196183
built-ruby 0.5834868639940396
built-ruby 0.5648214350221679
built-ruby 0.6081726279808208
built-ruby 0.5777335789753124
built-ruby 0.5967385330004618
-----------------------------------------------------------
array_shift
require 'benchmark'
Benchmark.bm do |x|
[10_000,1_000_000,100_000_000].each do |n|
ary = Array.new(n,0)
GC.start
x.report("#{n}:shift"){ ary.shift }
(0..4).each do |i|
ary = Array.new(n,0)
GC.start
x.report("#{n}:shift(#{i})"){ ary.shift(i) }
end
end
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 19.911575963022187
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 21.80540126003325
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 21.684410477988422
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 19.361100711044855
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 20.460079101030715
built-ruby 20.590318536036648
built-ruby 20.145105980103835
built-ruby 18.954186240094714
built-ruby 18.368444312014617
built-ruby 19.730205620988272
-----------------------------------------------------------
hash_aref_dsym
h = {}
syms = ('a'..'z').map { |s| s.to_sym }
syms.each { |s| h[s] = 1 }
200_000.times { syms.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4216823069145903
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3622758809942752
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.38479660102166235
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.40343340998515487
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.49036661093123257
built-ruby 0.43174306803848594
built-ruby 0.5595700640697032
built-ruby 0.5306916529079899
built-ruby 0.5160241100238636
built-ruby 0.39117593702394515
-----------------------------------------------------------
hash_aref_dsym_long
# [ruby-core:70129] [Bug #11396]
collection_size = 200000
sample_size = 10000
values = (1..collection_size).to_a.map do |x|
"THIS IS A LONGER STRING THAT IS ALSO UNIQUE #{x}"
end
symbol_hash = {}
values.each do |x|
symbol_hash[x.to_sym] = 1
end
# use the same samples each time to minimize deviations
rng = Random.new(0)
symbol_sample_array = values.sample(sample_size, random: rng).map(&:to_sym)
3000.times do
symbol_sample_array.each { |x| symbol_hash[x] }
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 8.994142417912371
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 8.65070200106129
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 8.894787893048488
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 8.891105056973174
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 8.985472270986065
built-ruby 9.263988000922836
built-ruby 8.880853733047843
built-ruby 8.88276363699697
built-ruby 8.975527776987292
built-ruby 9.016328673926182
-----------------------------------------------------------
hash_aref_fix
h = {}
nums = (1..26).to_a
nums.each { |i| h[i] = i }
200_000.times { nums.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.37598705396521837
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.365062219905667
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.41727619199082255
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4163406129227951
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4131853310391307
built-ruby 0.42576511297374964
built-ruby 0.39972475508693606
built-ruby 0.4207646220456809
built-ruby 0.42259231791831553
built-ruby 0.4202495509525761
-----------------------------------------------------------
hash_aref_flo
h = {}
strs = [*1..10000].map! {|i| i.fdiv(10)}
strs.each { |s| h[s] = s }
50.times { strs.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.11718685796950012
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.11380171892233193
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08189995994325727
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.07708744995761663
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09865439892746508
built-ruby 0.11252881400287151
built-ruby 0.08053674502298236
built-ruby 0.07900785398669541
built-ruby 0.11016465292777866
built-ruby 0.11145737406332046
-----------------------------------------------------------
hash_aref_miss
h = {}
strs = ('a'..'z').to_a.map!(&:freeze)
strs.each { |s| h[s] = s }
strs = ('A'..'Z').to_a
200_000.times { strs.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6566751280333847
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5181243579136208
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4812287100357935
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4952475589234382
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5520137930288911
built-ruby 0.5301608719164506
built-ruby 0.7099478869931772
built-ruby 0.687668439000845
built-ruby 0.505970490979962
built-ruby 0.6379513390129432
-----------------------------------------------------------
hash_aref_str
h = {}
strs = ('a'..'z').to_a.map!(&:freeze)
strs.each { |s| h[s] = s }
200_000.times { strs.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.46142047201283276
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.557503585005179
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.44997511396650225
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.473411327926442
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4952690149657428
built-ruby 0.5121987810125574
built-ruby 0.5139237380353734
built-ruby 0.5129490919644013
built-ruby 0.549338715034537
built-ruby 0.510490596992895
-----------------------------------------------------------
hash_aref_sym
h = {}
syms = ('a'..'z').to_a
begin
syms = eval("%i[#{syms.join(' ')}]")
rescue SyntaxError # <= 1.9.3
syms.map!(&:to_sym)
end
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3888717930531129
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.35667734197340906
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.35198676493018866
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.35674102103803307
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.40656316094100475
built-ruby 0.37652272009290755
built-ruby 0.38751485000830144
built-ruby 0.3706149799982086
built-ruby 0.3702603030251339
built-ruby 0.3512671149801463
-----------------------------------------------------------
hash_aref_sym_long
h = {}
syms = %w[puts warn syswrite write stat bacon lettuce tomato
some symbols in this array may already be interned others should not be
hash browns make good breakfast but not cooked using prime numbers
shift for division entries delete_if keys exist?
]
begin
syms = eval("%i[#{syms.join(' ')}]")
rescue SyntaxError # <= 1.9.3
syms.map!(&:to_sym)
end
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5792624419555068
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.560205984977074
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.541156632010825
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5849411159288138
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5847152499482036
built-ruby 0.5648888240102679
built-ruby 0.5205608840333298
built-ruby 0.5261825050693005
built-ruby 0.5629314871039242
built-ruby 0.5783154160017148
-----------------------------------------------------------
hash_flatten
h = {}
10000.times do |i|
h[i] = nil
end
1000.times do
h.flatten
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3427213099785149
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3069341860245913
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.34275468497071415
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.38032072596251965
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.346936195041053
built-ruby 0.32654421601910144
built-ruby 0.3373371420893818
built-ruby 0.34255180205218494
built-ruby 0.3248691939515993
built-ruby 0.34191841701976955
-----------------------------------------------------------
hash_ident_flo
h = {}.compare_by_identity
strs = (1..10000).to_a.map!(&:to_f)
strs.each { |s| h[s] = s }
50.times { strs.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.04220124601852149
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.041269097942858934
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.04389087401796132
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.04291684599593282
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.07074739702511579
built-ruby 0.05692592798732221
built-ruby 0.044749675085768104
built-ruby 0.0664445529691875
built-ruby 0.07258922001346946
built-ruby 0.07019294996280223
-----------------------------------------------------------
hash_ident_num
h = {}.compare_by_identity
nums = (1..26).to_a
nums.each { |n| h[n] = n }
200_000.times { nums.each { |n| h[n] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.39377539709676057
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.39119664498139173
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3880777000449598
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.40493444295134395
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.36523314204532653
built-ruby 0.3929379280889407
built-ruby 0.34873612003866583
built-ruby 0.3442114370409399
built-ruby 0.38300986506510526
built-ruby 0.37529788399115205
-----------------------------------------------------------
hash_ident_obj
h = {}.compare_by_identity
objs = 26.times.map { Object.new }
objs.each { |o| h[o] = o }
200_000.times { objs.each { |o| h[o] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3828392189461738
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.35609906795434654
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3869356900686398
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.38341773208230734
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.37513233406934887
built-ruby 0.36865005106665194
built-ruby 0.4118203339166939
built-ruby 0.35567324492149055
built-ruby 0.37416579702403396
built-ruby 0.3900904100155458
-----------------------------------------------------------
hash_ident_str
h = {}.compare_by_identity
strs = ('a'..'z').to_a
strs.each { |s| h[s] = s }
200_000.times { strs.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.377036583959125
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3820425069425255
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.36399687302764505
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.34358865895774215
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.34478977404069155
built-ruby 0.3856695689028129
built-ruby 0.3960615099640563
built-ruby 0.39091065991669893
built-ruby 0.362755179987289
built-ruby 0.48463089496362954
-----------------------------------------------------------
hash_ident_sym
h = {}.compare_by_identity
syms = ('a'..'z').to_a.map(&:to_sym)
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3676063900347799
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.372383851907216
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3768876070389524
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3810834060423076
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3695543850772083
built-ruby 0.40730858489405364
built-ruby 0.35844991891644895
built-ruby 0.3562260299222544
built-ruby 0.36219201888889074
built-ruby 0.3705180719261989
-----------------------------------------------------------
hash_keys
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do
h.keys
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3813573819352314
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.40435454109683633
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.36419785604812205
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.36185255693271756
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.37647308001760393
built-ruby 0.37183589406777173
built-ruby 0.37212479999288917
built-ruby 0.3915642349747941
built-ruby 0.3662926279939711
built-ruby 0.3848387829493731
-----------------------------------------------------------
hash_shift
h = {}
10000.times do |i|
h[i] = nil
end
50000.times do
k, v = h.shift
h[k] = v
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.019978645024821162
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.02057298901490867
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.021030289004556835
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.02016332291532308
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.020496617071330547
built-ruby 0.019983322941698134
built-ruby 0.019883542088791728
built-ruby 0.01988018094561994
built-ruby 0.019127018051221967
built-ruby 0.019923339947126806
-----------------------------------------------------------
hash_shift_u16
h = {}
(16384..65536).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.10453401308041066
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09176352899521589
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.11688991403207183
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09428807406220585
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.0933125379960984
built-ruby 0.0919919959269464
built-ruby 0.1384998329449445
built-ruby 0.09584043198265135
built-ruby 0.142563764937222
built-ruby 0.14312137803062797
-----------------------------------------------------------
hash_shift_u24
h = {}
(0xff4000..0xffffff).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1365325200604275
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.11648659699130803
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09805822500493377
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09307972399983555
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09942812204826623
built-ruby 0.13245002599433064
built-ruby 0.13298956002108753
built-ruby 0.09465779503807425
built-ruby 0.1013404109980911
built-ruby 0.13682444905862212
-----------------------------------------------------------
hash_shift_u32
h = {}
(0xffff4000..0xffffffff).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08892942301463336
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08826780295930803
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.10507124394644052
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.0913004920585081
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.13256571907550097
built-ruby 0.09448003501165658
built-ruby 0.1459165009437129
built-ruby 0.09830889292061329
built-ruby 0.09352237393613905
built-ruby 0.13785196701064706
-----------------------------------------------------------
hash_to_proc
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do |i|
[i].map(&h)
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.019653267925605178
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.01671880902722478
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.015707271988503635
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.01917582901660353
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.016913854982703924
built-ruby 0.016896598041057587
built-ruby 0.01782079297117889
built-ruby 0.018575310008600354
built-ruby 0.016450647031888366
built-ruby 0.010085696005262434
-----------------------------------------------------------
hash_values
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do
h.values
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.38122058392036706
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.34331048699095845
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3440139730228111
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3586773299612105
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.35639152803923935
built-ruby 0.3473863329272717
built-ruby 0.35828115697950125
built-ruby 0.3558147290023044
built-ruby 0.3774512440431863
built-ruby 0.40638430789113045
-----------------------------------------------------------
io_file_create
#
# Create files
#
max = 200_000
file = './tmpfile_of_bm_io_file_create'
max.times{
f = open(file, 'w')
f.close#(true)
}
File.unlink(file)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0968290109885857
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.069951456040144
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1728365051094443
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1180928848916665
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1327887700172141
built-ruby 1.245755268028006
built-ruby 1.1043767239898443
built-ruby 1.1141724679619074
built-ruby 1.1341513060033321
built-ruby 1.1506679240847006
-----------------------------------------------------------
io_file_read
#
# Seek and Read file.
#
require 'tempfile'
max = 200_000
str = "Hello world! " * 1000
f = Tempfile.new('yarv-benchmark')
f.write str
max.times{
f.seek 0
f.read
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4777622310211882
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4042066799011081
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4235800999449566
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3972327669616789
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4454854049254209
built-ruby 1.452328918967396
built-ruby 1.4763240709435195
built-ruby 1.4212326299166307
built-ruby 1.4206862730206922
built-ruby 1.4323099629255012
-----------------------------------------------------------
io_file_write
#
# Seek and Write file.
#
require 'tempfile'
max = 200_000
str = "Hello world! " * 1000
f = Tempfile.new('yarv-benchmark')
max.times{
f.seek 0
f.write str
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5536080140154809
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5973453510086983
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5510142010170966
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5829400019720197
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5641764220781624
built-ruby 0.5483221609611064
built-ruby 0.5867528859525919
built-ruby 0.6009624869329855
built-ruby 0.5745283620199189
built-ruby 0.5461939809611067
-----------------------------------------------------------
io_nonblock_noex
nr = 1_000_000
i = 0
msg = '.'
buf = '.'
noex = { exception: false }
begin
r, w = IO.pipe
while i < nr
i += 1
w.write_nonblock(msg, noex)
r.read_nonblock(1, buf, noex)
end
rescue ArgumentError # old Rubies
while i < nr
i += 1
w.write_nonblock(msg)
r.read_nonblock(1, buf)
end
ensure
r.close
w.close
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29950 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29952 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29954 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29956 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29958 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29960 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29962 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29964 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29966 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex.rb' exited with abnormal status (pid 29968 exit 1)
0
-----------------------------------------------------------
io_nonblock_noex2
nr = 1_000_000
i = 0
msg = '.'
buf = '.'
begin
r, w = IO.pipe
while i < nr
i += 1
w.write_nonblock(msg, exception: false)
r.read_nonblock(1, buf, exception: false)
end
rescue ArgumentError # old Rubies
while i < nr
i += 1
w.write_nonblock(msg)
r.read_nonblock(1, buf)
end
ensure
r.close
w.close
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29970 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29972 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29974 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29976 exit 1)
0
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] `./miniruby55727 -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29978 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29980 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29982 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29984 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29986 exit 1)
0
built-ruby `./miniruby -I./lib -I. -I.ext/common --disable-gem ./benchmark/bm_io_nonblock_noex2.rb' exited with abnormal status (pid 29988 exit 1)
0
-----------------------------------------------------------
io_select
# IO.select performance
w = [ IO.pipe[1] ];
nr = 1000000
nr.times {
IO.select nil, w
}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3566845810273662
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3276568519650027
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3886774969287217
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4759572820039466
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.381032899953425
built-ruby 1.4428902280051261
built-ruby 1.398780834977515
built-ruby 1.4073024929966778
built-ruby 1.403941371012479
built-ruby 1.390713831060566
-----------------------------------------------------------
io_select2
# IO.select performance. worst case of single fd.
ios = []
nr = 1000000
if defined?(Process::RLIMIT_NOFILE)
max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
else
max = 64
end
puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
((max / 2) - 10).times do
ios.concat IO.pipe
end
last = [ ios[-1] ]
puts "last IO: #{last[0].inspect}"
nr.times do
IO.select nil, last
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.6995966200483963
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.6652121299412102
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.6420642510056496
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.8304848399711773
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.6703923679888248
built-ruby 1.6714988009771332
built-ruby 1.661516672000289
built-ruby 1.658023179974407
built-ruby 1.7248587399953976
built-ruby 1.6729385469807312
-----------------------------------------------------------
io_select3
# IO.select performance. a lot of fd
ios = []
nr = 100
if defined?(Process::RLIMIT_NOFILE)
max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
else
max = 64
end
puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
(max - 10).times do
r, w = IO.pipe
r.close
ios.push w
end
nr.times do
IO.select nil, ios
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08045057998970151
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08171069796662778
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08577974699437618
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.08378621900919825
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.09031901403795928
built-ruby 0.09006700303871185
built-ruby 0.07957196491770446
built-ruby 0.08113130403216928
built-ruby 0.07871861499734223
built-ruby 0.08099054102785885
-----------------------------------------------------------
loop_for
for i in 1..30_000_000
#
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.429033393971622
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3902404700638726
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3368758759461343
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.5224818449933082
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3832816269714385
built-ruby 1.4056512729730457
built-ruby 1.3982130440417677
built-ruby 1.4856738760136068
built-ruby 1.4355269520310685
built-ruby 1.3960542739368975
-----------------------------------------------------------
loop_generator
max = 600000
if defined? Fiber
gen = (1..max).each
loop do
gen.next
end
else
require 'generator'
gen = Generator.new((0..max))
while gen.next?
gen.next
end
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.447983055957593
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.43713122291956097
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.41632595006376505
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.413728442043066
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.43117495195474476
built-ruby 0.3936361169908196
built-ruby 0.41520697495434433
built-ruby 0.3813484450802207
built-ruby 0.4186007340904325
built-ruby 0.46606297697871923
-----------------------------------------------------------
loop_times
30_000_000.times{|e|}
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2660569730214775
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.288977800984867
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2790794249158353
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2557534169172868
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.242581072030589
built-ruby 1.367729538003914
built-ruby 1.2490719420602545
built-ruby 1.2537770349299535
built-ruby 1.3036859730491415
built-ruby 1.315647570998408
-----------------------------------------------------------
loop_whileloop
i = 0
while i<30_000_000 # benchmark loop 1
i += 1
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6696008009603247
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6613349430263042
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6545510729774833
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7210862779757008
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6868640170432627
built-ruby 0.7538669649511576
built-ruby 0.6594554899493232
built-ruby 0.6867847840767354
built-ruby 0.7034585719229653
built-ruby 0.676485852105543
-----------------------------------------------------------
loop_whileloop2
i = 0
while i< 6_000_000 # benchmark loop 2
i += 1
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.16582438093610108
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1785859070951119
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1345876029226929
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.19371888297609985
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1576415990712121
built-ruby 0.18836930592078716
built-ruby 0.17945012100972235
built-ruby 0.13904708600603044
built-ruby 0.13976143905892968
built-ruby 0.16039950295817107
-----------------------------------------------------------
marshal_dump_flo
bug10761 = 10000.times.map { |x| x.to_f }
100.times { Marshal.dump(bug10761) }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.40514840092509985
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4423090369673446
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4337517569074407
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.4403481970075518
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3930218250025064
built-ruby 0.4278980160597712
built-ruby 0.43506750697270036
built-ruby 0.4263163349824026
built-ruby 0.42774789698887616
built-ruby 0.4529707379406318
-----------------------------------------------------------
marshal_dump_load_geniv
a = ''
a.instance_eval do
@a = :a
@b = :b
@c = :c
end
100000.times do
a = Marshal.load(Marshal.dump(a))
end
#p(a.instance_eval { @a == :a && @b == :b && @c == :c })
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6123521019471809
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6119896658929065
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6105287390528247
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6229553610319272
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6130104489857331
built-ruby 0.6296117239398882
built-ruby 0.6413133019814268
built-ruby 0.589495872030966
built-ruby 0.597406764049083
built-ruby 0.5956406740006059
-----------------------------------------------------------
marshal_dump_load_time
100000.times { Marshal.load(Marshal.dump(Time.now)) }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.700435527949594
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.7273683469975367
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.6878731369506568
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.8823049339698628
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.695577287930064
built-ruby 1.7563206269405782
built-ruby 1.874093962018378
built-ruby 1.7417739329393953
built-ruby 1.8114637369289994
built-ruby 1.750103313010186
-----------------------------------------------------------
require
$:.push File.join(File.dirname(__FILE__), "bm_require.data")
1.upto(10000) do |i|
require "c#{i}"
end
$:.pop
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0619833109667525
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9308968300465494
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0666463939705864
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8810079169925302
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.8796678589424118
built-ruby 0.9250150509178638
built-ruby 0.8820322109386325
built-ruby 0.8508778579998761
built-ruby 0.9202019539661705
built-ruby 0.9012398619670421
-----------------------------------------------------------
require_thread
$:.push File.join(File.dirname(__FILE__), "bm_require.data")
i=0
t = Thread.new do
while true
i = i+1 # dummy loop
end
end
1.upto(100) do |i|
require "c#{i}"
end
$:.pop
t.kill
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.21662832389120013
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.22078900691121817
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5179030389990658
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5129538390319794
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5115444009425119
built-ruby 0.31828783394303173
built-ruby 0.32342322205659
built-ruby 0.21796219993848354
built-ruby 0.4137510540895164
built-ruby 0.1225852380739525
-----------------------------------------------------------
securerandom
require "securerandom"
20_0000.times do
SecureRandom.random_number(100)
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.26040642301086336
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.2563073959900066
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.2603783579543233
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.27299292106181383
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.2926094400463626
built-ruby 0.2890160030219704
built-ruby 0.2857340909540653
built-ruby 0.29148439900018275
built-ruby 0.24334233906120062
built-ruby 0.28515519900247455
-----------------------------------------------------------
so_ackermann
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: ackermann-ruby.code,v 1.4 2004/11/13 07:40:41 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
def ack(m, n)
if m == 0 then
n + 1
elsif n == 0 then
ack(m - 1, 1)
else
ack(m - 1, ack(m, n - 1))
end
end
NUM = 9
ack(3, NUM)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7351798920426518
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6416415710700676
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6314938109135255
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6161993889836594
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6308393200160936
built-ruby 0.6026810819748789
built-ruby 0.5840895769651979
built-ruby 0.5894482340663671
built-ruby 0.5874529340071604
built-ruby 0.563191408989951
-----------------------------------------------------------
so_array
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: ary-ruby.code,v 1.4 2004/11/13 07:41:27 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Paul Brannan and Mark Hubbart
n = 9000 # Integer(ARGV.shift || 1)
x = Array.new(n)
y = Array.new(n, 0)
n.times{|bi|
x[bi] = bi + 1
}
(0 .. 999).each do |e|
(n-1).step(0,-1) do |bi|
y[bi] += x.at(bi)
end
end
# puts "#{y.first} #{y.last}"
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9406678340164945
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9825775140197948
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9287008650135249
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9349297150038183
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.9208299829624593
built-ruby 0.9324882669607177
built-ruby 0.938745960011147
built-ruby 1.01670901698526
built-ruby 0.9396806108998135
built-ruby 0.9004901159787551
-----------------------------------------------------------
so_binary_trees
# The Computer Language Shootout Benchmarks
# http://shootout.alioth.debian.org
#
# contributed by Jesse Millikan
# disable output
alias puts_orig puts
def puts str
# disable puts
end
def item_check(tree)
if tree[0] == nil
tree[1]
else
tree[1] + item_check(tree[0]) - item_check(tree[2])
end
end
def bottom_up_tree(item, depth)
if depth > 0
item_item = 2 * item
depth -= 1
[bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
else
[nil, item, nil]
end
end
max_depth = 16 # ARGV[0].to_i
min_depth = 4
max_depth = min_depth + 2 if min_depth + 2 > max_depth
stretch_depth = max_depth + 1
stretch_tree = bottom_up_tree(0, stretch_depth)
puts "stretch tree of depth #{stretch_depth}\t check: #{item_check(stretch_tree)}"
stretch_tree = nil
long_lived_tree = bottom_up_tree(0, max_depth)
min_depth.step(max_depth + 1, 2) do |depth|
iterations = 2**(max_depth - depth + min_depth)
check = 0
for i in 1..iterations
temp_tree = bottom_up_tree(i, depth)
check += item_check(temp_tree)
temp_tree = bottom_up_tree(-i, depth)
check += item_check(temp_tree)
end
puts "#{iterations * 2}\t trees of depth #{depth}\t check: #{check}"
end
puts "long lived tree of depth #{max_depth}\t check: #{item_check(long_lived_tree)}"
undef puts
alias puts puts_orig
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 6.260964497923851
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 6.2369194839848205
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 6.4077904800651595
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 6.403173052938655
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 6.439292576978914
built-ruby 5.983900416991673
built-ruby 6.202562858001329
built-ruby 6.169638277031481
built-ruby 6.154955621925183
built-ruby 6.205964269000106
-----------------------------------------------------------
so_concatenate
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: strcat-ruby.code,v 1.4 2004/11/13 07:43:28 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# based on code from Aristarkh A Zagorodnikov and Dat Nguyen
STUFF = "hello\n"
i = 0
while i<10
i += 1
hello = ''
4_000_000.times do |e|
hello << STUFF
end
end
# puts hello.length
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 4.001141563989222
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 4.09834510309156
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 4.112204045988619
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 4.056181942927651
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 4.053268599906005
built-ruby 4.231184215983376
built-ruby 4.214553599944338
built-ruby 4.225530072930269
built-ruby 4.23357527400367
built-ruby 4.446332956082188
-----------------------------------------------------------
so_count_words
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: wc-ruby.code,v 1.4 2004/11/13 07:43:32 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Paul Brannan
input = open(File.join(File.dirname($0), 'wc.input'), 'rb')
nl = nw = nc = 0
while true
tmp = input.read(4096) or break
data = tmp << (input.gets || "")
nc += data.length
nl += data.count("\n")
((data.strip! || data).tr!("\n", " ") || data).squeeze!
nw += data.count(" ") + 1
end
# STDERR.puts "#{nl} #{nw} #{nc}"
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.18317602504976094
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.16097911505494267
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1944847139529884
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.16829874098766595
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.1914049789775163
built-ruby 0.1907938700169325
built-ruby 0.15760852908715606
built-ruby 0.15018033992964774
built-ruby 0.1822699890471995
built-ruby 0.14878833096008748
-----------------------------------------------------------
so_exception
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: except-ruby.code,v 1.4 2004/11/13 07:41:33 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
$HI = 0
$LO = 0
NUM = 250000 # Integer(ARGV[0] || 1)
class Lo_Exception < Exception
def initialize(num)
@value = num
end
end
class Hi_Exception < Exception
def initialize(num)
@value = num
end
end
def some_function(num)
begin
hi_function(num)
rescue
print "We shouldn't get here, exception is: #{$!.type}\n"
end
end
def hi_function(num)
begin
lo_function(num)
rescue Hi_Exception
$HI = $HI + 1
end
end
def lo_function(num)
begin
blowup(num)
rescue Lo_Exception
$LO = $LO + 1
end
end
def blowup(num)
if num % 2 == 0
raise Lo_Exception.new(num)
else
raise Hi_Exception.new(num)
end
end
i = 1
max = NUM+1
while i < max
i += 1
some_function(i+1)
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.2948280469281599
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3389579759677872
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.3021621649386361
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.297112351981923
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.32233828597236425
built-ruby 0.3171930620446801
built-ruby 0.2824935069074854
built-ruby 0.29181393200997263
built-ruby 0.27976310497615486
built-ruby 0.28373940801247954
-----------------------------------------------------------
so_fannkuch
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
# Modified by Ryan Williams
def fannkuch(n)
maxFlips, m, r, check = 0, n-1, n, 0
count = (1..n).to_a
perm = (1..n).to_a
while true
if check < 30
puts "#{perm}"
check += 1
end
while r != 1
count[r-1] = r
r -= 1
end
if perm[0] != 1 and perm[m] != n
perml = perm.clone #.dup
flips = 0
while (k = perml.first ) != 1
perml = perml.slice!(0, k).reverse + perml
flips += 1
end
maxFlips = flips if flips > maxFlips
end
while true
if r==n then return maxFlips end
perm.insert r,perm.shift
break if (count[r] -= 1) > 0
r += 1
end
end
end
def puts *args
end
N = 9 # (ARGV[0] || 1).to_i
puts "Pfannkuchen(#{N}) = #{fannkuch(N)}"
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.195548600051552
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2603375089820474
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.173193629947491
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.230126878945157
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3135004850337282
built-ruby 1.222666513058357
built-ruby 1.1949388809734955
built-ruby 1.188238336937502
built-ruby 1.214579998049885
built-ruby 1.1952616450143978
-----------------------------------------------------------
so_fasta
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
$last = 42.0
def gen_random (max,im=139968,ia=3877,ic=29573)
(max * ($last = ($last * ia + ic) % im)) / im
end
alu =
"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"+
"GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"+
"CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"+
"ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"+
"GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"+
"AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"+
"AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
iub = [
["a", 0.27],
["c", 0.12],
["g", 0.12],
["t", 0.27],
["B", 0.02],
["D", 0.02],
["H", 0.02],
["K", 0.02],
["M", 0.02],
["N", 0.02],
["R", 0.02],
["S", 0.02],
["V", 0.02],
["W", 0.02],
["Y", 0.02],
]
homosapiens = [
["a", 0.3029549426680],
["c", 0.1979883004921],
["g", 0.1975473066391],
["t", 0.3015094502008],
]
def make_repeat_fasta(id, desc, src, n)
puts ">#{id} #{desc}"
v = nil
width = 60
l = src.length
s = src * ((n / l) + 1)
s.slice!(n, l)
puts(s.scan(/.{1,#{width}}/).join("\n"))
end
def make_random_fasta(id, desc, table, n)
puts ">#{id} #{desc}"
rand, v = nil,nil
width = 60
chunk = 1 * width
prob = 0.0
table.each{|v| v[1]= (prob += v[1])}
for i in 1..(n/width)
puts((1..width).collect{
rand = gen_random(1.0)
table.find{|v| v[1]>rand}[0]
}.join)
end
if n%width != 0
puts((1..(n%width)).collect{
rand = gen_random(1.0)
table.find{|v| v[1]>rand}[0]
}.join)
end
end
n = (ARGV[0] or 250_000).to_i
make_repeat_fasta('ONE', 'Homo sapiens alu', alu, n*2)
make_random_fasta('TWO', 'IUB ambiguity codes', iub, n*3)
make_random_fasta('THREE', 'Homo sapiens frequency', homosapiens, n*5)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.0799837020458654
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.0712170960614458
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.025488005951047
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.099908426986076
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.051318514975719
built-ruby 1.9957283459370956
built-ruby 1.9421377900289372
built-ruby 1.9475463649723679
built-ruby 1.9905491810059175
built-ruby 1.9425933110760525
-----------------------------------------------------------
so_k_nucleotide
# The Computer Language Shootout
# http://shootout.alioth.debian.org
#
# contributed by jose fco. gonzalez
# modified by Sokolov Yura
seq = String.new
def frecuency( seq,length )
n, table = seq.length - length + 1, Hash.new(0)
f, i = nil, nil
(0 ... length).each do |f|
(f ... n).step(length) do |i|
table[seq[i,length]] += 1
end
end
[n,table]
end
def sort_by_freq( seq,length )
n,table = frecuency( seq,length )
a, b, v = nil, nil, nil
table.sort{|a,b| b[1] <=> a[1]}.each do |v|
puts "%s %.3f" % [v[0].upcase,((v[1]*100).to_f/n)]
end
puts
end
def find_seq( seq,s )
n,table = frecuency( seq,s.length )
puts "#{table[s].to_s}\t#{s.upcase}"
end
input = open(File.join(File.dirname($0), 'fasta.output.100000'), 'rb')
line = input.gets while line !~ /^>THREE/
line = input.gets
while (line !~ /^>/) & line do
seq << line.chomp
line = input.gets
end
[1,2].each {|i| sort_by_freq( seq,i ) }
%w(ggt ggta ggtatt ggtattttaatt ggtattttaatttatagt).each{|s| find_seq( seq,s) }
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3331258340040222
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3210365020204335
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2975040499586612
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2961266150232404
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2919675910379738
built-ruby 1.3116200920194387
built-ruby 1.8578620590269566
built-ruby 1.2753536959644407
built-ruby 1.2576407550368458
built-ruby 1.3670301890233532
-----------------------------------------------------------
so_lists
#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
NUM = 300
SIZE = 10000
def test_lists()
# create a list of integers (Li1) from 1 to SIZE
li1 = (1..SIZE).to_a
# copy the list to li2 (not by individual items)
li2 = li1.dup
# remove each individual item from left side of li2 and
# append to right side of li3 (preserving order)
li3 = Array.new
while (not li2.empty?)
li3.push(li2.shift)
end
# li2 must now be empty
# remove each individual item from right side of li3 and
# append to right side of li2 (reversing list)
while (not li3.empty?)
li2.push(li3.pop)
end
# li3 must now be empty
# reverse li1 in place
li1.reverse!
# check that first item is now SIZE
if li1[0] != SIZE then
p "not SIZE"
0
else
# compare li1 and li2 for equality
if li1 != li2 then
return(0)
else
# return the length of the list
li1.length
end
end
end
i = 0
while i<NUM
i += 1
result = test_lists()
end
result
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6434617630438879
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5584338919725269
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6284601120278239
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5885989199159667
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.569430175004527
built-ruby 0.5566898250253871
built-ruby 0.5767613250063732
built-ruby 0.536732375039719
built-ruby 0.5868497409392148
built-ruby 0.5715375680010766
-----------------------------------------------------------
so_mandelbrot
# The Computer Language Benchmarks Game
# http://shootout.alioth.debian.org/
#
# contributed by Karl von Laudermann
# modified by Jeremy Echols
size = 600 # ARGV[0].to_i
puts "P4\n#{size} #{size}"
ITER = 49 # Iterations - 1 for easy for..in looping
LIMIT_SQUARED = 4.0 # Presquared limit
byte_acc = 0
bit_num = 0
count_size = size - 1 # Precomputed size for easy for..in looping
# For..in loops are faster than .upto, .downto, .times, etc.
for y in 0..count_size
for x in 0..count_size
zr = 0.0
zi = 0.0
cr = (2.0*x/size)-1.5
ci = (2.0*y/size)-1.0
escape = false
# To make use of the for..in code, we use a dummy variable,
# like one would in C
for dummy in 0..ITER
tr = zr*zr - zi*zi + cr
ti = 2*zr*zi + ci
zr, zi = tr, ti
if (zr*zr+zi*zi) > LIMIT_SQUARED
escape = true
break
end
end
byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
bit_num += 1
# Code is very similar for these cases, but using separate blocks
# ensures we skip the shifting when it's unnecessary, which is most cases.
if (bit_num == 8)
print byte_acc.chr
byte_acc = 0
bit_num = 0
elsif (x == count_size)
byte_acc <<= (8 - bit_num)
print byte_acc.chr
byte_acc = 0
bit_num = 0
end
end
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6933954290580004
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.719763809000142
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.7030250899260864
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.710448632016778
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6677420960040763
built-ruby 2.582454991992563
built-ruby 2.630644400953315
built-ruby 2.610673886956647
built-ruby 2.5824020489817485
built-ruby 2.57853459904436
-----------------------------------------------------------
so_matrix
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: matrix-ruby.code,v 1.4 2004/11/13 07:42:14 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
n = 60 #Integer(ARGV.shift || 1)
size = 40
def mkmatrix(rows, cols)
count = 1
mx = Array.new(rows)
(0 .. (rows - 1)).each do |bi|
row = Array.new(cols, 0)
(0 .. (cols - 1)).each do |j|
row[j] = count
count += 1
end
mx[bi] = row
end
mx
end
def mmult(rows, cols, m1, m2)
m3 = Array.new(rows)
(0 .. (rows - 1)).each do |bi|
row = Array.new(cols, 0)
(0 .. (cols - 1)).each do |j|
val = 0
(0 .. (cols - 1)).each do |k|
val += m1.at(bi).at(k) * m2.at(k).at(j)
end
row[j] = val
end
m3[bi] = row
end
m3
end
m1 = mkmatrix(size, size)
m2 = mkmatrix(size, size)
mm = Array.new
n.times do
mm = mmult(size, size, m1, m2)
end
# puts "#{mm[0][0]} #{mm[2][3]} #{mm[3][2]} #{mm[4][4]}"
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5532322749495506
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5392589321127161
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5494304629974067
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5443849539151415
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.5887995599769056
built-ruby 0.57345147698652
built-ruby 0.548274885979481
built-ruby 0.5917947690468282
built-ruby 0.5585711450548843
built-ruby 0.5582691869931296
-----------------------------------------------------------
so_meteor_contest
#!/usr/bin/env ruby
#
# The Computer Language Shootout
# http://shootout.alioth.debian.org
# contributed by Kevin Barnes (Ruby novice)
# PROGRAM: the main body is at the bottom.
# 1) read about the problem here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
# 2) see how I represent a board as a bitmask by reading the blank_board comments
# 3) read as your mental paths take you
def print *args
end
# class to represent all information about a particular rotation of a particular piece
class Rotation
# an array (by location) containing a bit mask for how the piece maps at the given location.
# if the rotation is invalid at that location the mask will contain false
attr_reader :start_masks
# maps a direction to a relative location. these differ depending on whether it is an even or
# odd row being mapped from
@@rotation_even_adder = { :west => -1, :east => 1, :nw => -7, :ne => -6, :sw => 5, :se => 6 }
@@rotation_odd_adder = { :west => -1, :east => 1, :nw => -6, :ne => -5, :sw => 6, :se => 7 }
def initialize( directions )
@even_offsets, @odd_offsets = normalize_offsets( get_values( directions ))
@even_mask = mask_for_offsets( @even_offsets)
@odd_mask = mask_for_offsets( @odd_offsets)
@start_masks = Array.new(60)
# create the rotational masks by placing the base mask at the location and seeing if
# 1) it overlaps the boundaries and 2) it produces a prunable board. if either of these
# is true the piece cannot be placed
0.upto(59) do | offset |
mask = is_even(offset) ? (@even_mask << offset) : (@odd_mask << offset)
if (blank_board & mask == 0 && !prunable(blank_board | mask, 0, true)) then
imask = compute_required( mask, offset)
@start_masks[offset] = [ mask, imask, imask | mask ]
else
@start_masks[offset] = false
end
end
end
def compute_required( mask, offset )
board = blank_board
0.upto(offset) { | i | board |= 1 << i }
board |= mask
return 0 if (!prunable(board | mask, offset))
board = flood_fill(board,58)
count = 0
imask = 0
0.upto(59) do | i |
if (board[i] == 0) then
imask |= (1 << i)
count += 1
end
end
(count > 0 && count < 5) ? imask : 0
end
def flood_fill( board, location)
return board if (board[location] == 1)
board |= 1 << location
row, col = location.divmod(6)
board = flood_fill( board, location - 1) if (col > 0)
board = flood_fill( board, location + 1) if (col < 4)
if (row % 2 == 0) then
board = flood_fill( board, location - 7) if (col > 0 && row > 0)
board = flood_fill( board, location - 6) if (row > 0)
board = flood_fill( board, location + 6) if (row < 9)
board = flood_fill( board, location + 5) if (col > 0 && row < 9)
else
board = flood_fill( board, location - 5) if (col < 4 && row > 0)
board = flood_fill( board, location - 6) if (row > 0)
board = flood_fill( board, location + 6) if (row < 9)
board = flood_fill( board, location + 7) if (col < 4 && row < 9)
end
board
end
# given a location, produces a list of relative locations covered by the piece at this rotation
def offsets( location)
if is_even( location) then
@even_offsets.collect { | value | value + location }
else
@odd_offsets.collect { | value | value + location }
end
end
# returns a set of offsets relative to the top-left most piece of the rotation (by even or odd rows)
# this is hard to explain. imagine we have this partial board:
# 0 0 0 0 0 x [positions 0-5]
# 0 0 1 1 0 x [positions 6-11]
# 0 0 1 0 0 x [positions 12-17]
# 0 1 0 0 0 x [positions 18-23]
# 0 1 0 0 0 x [positions 24-29]
# 0 0 0 0 0 x [positions 30-35]
# ...
# The top-left of the piece is at position 8, the
# board would be passed as a set of positions (values array) containing [8,9,14,19,25] not necessarily in that
# sorted order. Since that array starts on an odd row, the offsets for an odd row are: [0,1,6,11,17] obtained
# by subtracting 8 from everything. Now imagine the piece shifted up and to the right so it's on an even row:
# 0 0 0 1 1 x [positions 0-5]
# 0 0 1 0 0 x [positions 6-11]
# 0 0 1 0 0 x [positions 12-17]
# 0 1 0 0 0 x [positions 18-23]
# 0 0 0 0 0 x [positions 24-29]
# 0 0 0 0 0 x [positions 30-35]
# ...
# Now the positions are [3,4,8,14,19] which after subtracting the lowest value (3) gives [0,1,5,11,16] thus, the
# offsets for this particular piece are (in even, odd order) [0,1,5,11,16],[0,1,6,11,17] which is what
# this function would return
def normalize_offsets( values)
min = values.min
even_min = is_even(min)
other_min = even_min ? min + 6 : min + 7
other_values = values.collect do | value |
if is_even(value) then
value + 6 - other_min
else
value + 7 - other_min
end
end
values.collect! { | value | value - min }
if even_min then
[values, other_values]
else
[other_values, values]
end
end
# produce a bitmask representation of an array of offset locations
def mask_for_offsets( offsets )
mask = 0
offsets.each { | value | mask = mask + ( 1 << value ) }
mask
end
# finds a "safe" position that a position as described by a list of directions can be placed
# without falling off any edge of the board. the values returned a location to place the first piece
# at so it will fit after making the described moves
def start_adjust( directions )
south = east = 0;
directions.each do | direction |
east += 1 if ( direction == :sw || direction == :nw || direction == :west )
south += 1 if ( direction == :nw || direction == :ne )
end
south * 6 + east
end
# given a set of directions places the piece (as defined by a set of directions) on the board at
# a location that will not take it off the edge
def get_values ( directions )
start = start_adjust(directions)
values = [ start ]
directions.each do | direction |
if (start % 12 >= 6) then
start += @@rotation_odd_adder[direction]
else
start += @@rotation_even_adder[direction]
end
values += [ start ]
end
# some moves take you back to an existing location, we'll strip duplicates
values.uniq
end
end
# describes a piece and caches information about its rotations to as to be efficient for iteration
# ATTRIBUTES:
# rotations -- all the rotations of the piece
# type -- a numeic "name" of the piece
# masks -- an array by location of all legal rotational masks (a n inner array) for that location
# placed -- the mask that this piece was last placed at (not a location, but the actual mask used)
class Piece
attr_reader :rotations, :type, :masks
attr_accessor :placed
# transform hashes that change one direction into another when you either flip or rotate a set of directions
@@flip_converter = { :west => :west, :east => :east, :nw => :sw, :ne => :se, :sw => :nw, :se => :ne }
@@rotate_converter = { :west => :nw, :east => :se, :nw => :ne, :ne => :east, :sw => :west, :se => :sw }
def initialize( directions, type )
@type = type
@rotations = Array.new();
@map = {}
generate_rotations( directions )
directions.collect! { | value | @@flip_converter[value] }
generate_rotations( directions )
# creates the masks AND a map that returns [location, rotation] for any given mask
# this is used when a board is found and we want to draw it, otherwise the map is unused
@masks = Array.new();
0.upto(59) do | i |
even = true
@masks[i] = @rotations.collect do | rotation |
mask = rotation.start_masks[i]
@map[mask[0]] = [ i, rotation ] if (mask)
mask || nil
end
@masks[i].compact!
end
end
# rotates a set of directions through all six angles and adds a Rotation to the list for each one
def generate_rotations( directions )
6.times do
rotations.push( Rotation.new(directions))
directions.collect! { | value | @@rotate_converter[value] }
end
end
# given a board string, adds this piece to the board at whatever location/rotation
# important: the outbound board string is 5 wide, the normal location notation is six wide (padded)
def fill_string( board_string)
location, rotation = @map[@placed]
rotation.offsets(location).each do | offset |
row, col = offset.divmod(6)
board_string[ row*5 + col, 1 ] = @type.to_s
end
end
end
# a blank bit board having this form:
#
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 1 1 1 1 1 1
#
# where left lest significant bit is the top left and the most significant is the lower right
# the actual board only consists of the 0 places, the 1 places are blockers to keep things from running
# off the edges or bottom
def blank_board
0b111111100000100000100000100000100000100000100000100000100000100000
end
def full_board
0b111111111111111111111111111111111111111111111111111111111111111111
end
# determines if a location (bit position) is in an even row
def is_even( location)
(location % 12) < 6
end
# support function that create three utility maps:
# $converter -- for each row an array that maps a five bit row (via array mapping)
# to the a five bit representation of the bits below it
# $bit_count -- maps a five bit row (via array mapping) to the number of 1s in the row
# @@new_regions -- maps a five bit row (via array mapping) to an array of "region" arrays
# a region array has three values the first is a mask of bits in the region,
# the second is the count of those bits and the third is identical to the first
# examples:
# 0b10010 => [ 0b01100, 2, 0b01100 ], [ 0b00001, 1, 0b00001]
# 0b01010 => [ 0b10000, 1, 0b10000 ], [ 0b00100, 1, 0b00100 ], [ 0b00001, 1, 0b00001]
# 0b10001 => [ 0b01110, 3, 0b01110 ]
def create_collector_support
odd_map = [0b11, 0b110, 0b1100, 0b11000, 0b10000]
even_map = [0b1, 0b11, 0b110, 0b1100, 0b11000]
all_odds = Array.new(0b100000)
all_evens = Array.new(0b100000)
bit_counts = Array.new(0b100000)
new_regions = Array.new(0b100000)
0.upto(0b11111) do | i |
bit_count = odd = even = 0
0.upto(4) do | bit |
if (i[bit] == 1) then
bit_count += 1
odd |= odd_map[bit]
even |= even_map[bit]
end
end
all_odds[i] = odd
all_evens[i] = even
bit_counts[i] = bit_count
new_regions[i] = create_regions( i)
end
$converter = []
10.times { | row | $converter.push((row % 2 == 0) ? all_evens : all_odds) }
$bit_counts = bit_counts
$regions = new_regions.collect { | set | set.collect { | value | [ value, bit_counts[value], value] } }
end
# determines if a board is punable, meaning that there is no possibility that it
# can be filled up with pieces. A board is prunable if there is a grouping of unfilled spaces
# that are not a multiple of five. The following board is an example of a prunable board:
# 0 0 1 0 0
# 0 1 0 0 0
# 1 1 0 0 0
# 0 1 0 0 0
# 0 0 0 0 0
# ...
#
# This board is prunable because the top left corner is only 3 bits in area, no piece will ever fit it
# parameters:
# board -- an initial bit board (6 bit padded rows, see blank_board for format)
# location -- starting location, everything above and to the left is already full
# slotting -- set to true only when testing initial pieces, when filling normally
# additional assumptions are possible
#
# Algorithm:
# The algorithm starts at the top row (as determined by location) and iterates a row at a time
# maintainng counts of active open areas (kept in the collector array) each collector contains
# three values at the start of an iteration:
# 0: mask of bits that would be adjacent to the collector in this row
# 1: the number of bits collected so far
# 2: a scratch space starting as zero, but used during the computation to represent
# the empty bits in the new row that are adjacent (position 0)
# The exact procedure is described in-code
def prunable( board, location, slotting = false)
collectors = []
# loop across the rows
(location / 6).to_i.upto(9) do | row_on |
# obtain a set of regions representing the bits of the current row.
regions = $regions[(board >> (row_on * 6)) & 0b11111]
converter = $converter[row_on]
# track the number of collectors at the start of the cycle so that
# we don't compute against newly created collectors, only existing collectors
initial_collector_count = collectors.length
# loop against the regions. For each region of the row
# we will see if it connects to one or more existing collectors.
# if it connects to 1 collector, the bits from the region are added to the
# bits of the collector and the mask is placed in collector[2]
# If the region overlaps more than one collector then all the collectors
# it overlaps with are merged into the first one (the others are set to nil in the array)
# if NO collectors are found then the region is copied as a new collector
regions.each do | region |
collector_found = nil
region_mask = region[2]
initial_collector_count.times do | collector_num |
collector = collectors[collector_num]
if (collector) then
collector_mask = collector[0]
if (collector_mask & region_mask != 0) then
if (collector_found) then
collector_found[0] |= collector_mask
collector_found[1] += collector[1]
collector_found[2] |= collector[2]
collectors[collector_num] = nil
else
collector_found = collector
collector[1] += region[1]
collector[2] |= region_mask
end
end
end
end
if (collector_found == nil) then
collectors.push(Array.new(region))
end
end
# check the existing collectors, if any collector overlapped no bits in the region its [2] value will
# be zero. The size of any such reaason is tested if it is not a multiple of five true is returned since
# the board is prunable. if it is a multiple of five it is removed.
# Collector that are still active have a new adjacent value [0] set based n the matched bits
# and have [2] cleared out for the next cycle.
collectors.length.times do | collector_num |
collector = collectors[collector_num]
if (collector) then
if (collector[2] == 0) then
return true if (collector[1] % 5 != 0)
collectors[collector_num] = nil
else
# if a collector matches all bits in the row then we can return unprunable early for the
# following reasons:
# 1) there can be no more unavailable bits bince we fill from the top left downward
# 2) all previous regions have been closed or joined so only this region can fail
# 3) this region must be good since there can never be only 1 region that is nuot
# a multiple of five
# this rule only applies when filling normally, so we ignore the rule if we are "slotting"
# in pieces to see what configurations work for them (the only other time this algorithm is used).
return false if (collector[2] == 0b11111 && !slotting)
collector[0] = converter[collector[2]]
collector[2] = 0
end
end
end
# get rid of all the empty converters for the next round
collectors.compact!
end
return false if (collectors.length <= 1) # 1 collector or less and the region is fine
collectors.any? { | collector | (collector[1] % 5) != 0 } # more than 1 and we test them all for bad size
end
# creates a region given a row mask. see prunable for what a "region" is
def create_regions( value )
regions = []
cur_region = 0
5.times do | bit |
if (value[bit] == 0) then
cur_region |= 1 << bit
else
if (cur_region != 0 ) then
regions.push( cur_region)
cur_region = 0;
end
end
end
regions.push(cur_region) if (cur_region != 0)
regions
end
# find up to the counted number of solutions (or all solutions) and prints the final result
def find_all
find_top( 1)
find_top( 0)
print_results
end
# show the board
def print_results
print "#{@boards_found} solutions found\n\n"
print_full_board( @min_board)
print "\n"
print_full_board( @max_board)
print "\n"
end
# finds solutions. This special version of the main function is only used for the top level
# the reason for it is basically to force a particular ordering on how the rotations are tested for
# the first piece. It is called twice, first looking for placements of the odd rotations and then
# looking for placements of the even locations.
#
# WHY?
# Since any found solution has an inverse we want to maximize finding solutions that are not already found
# as an inverse. The inverse will ALWAYS be 3 one of the piece configurations that is exactly 3 rotations away
# (an odd number). Checking even vs odd then produces a higher probability of finding more pieces earlier
# in the cycle. We still need to keep checking all the permutations, but our probability of finding one will
# diminsh over time. Since we are TOLD how many to search for this lets us exit before checking all pieces
# this bennifit is very great when seeking small numbers of solutions and is 0 when looking for more than the
# maximum number
def find_top( rotation_skip)
board = blank_board
(@pieces.length-1).times do
piece = @pieces.shift
piece.masks[0].each do | mask, imask, cmask |
if ((rotation_skip += 1) % 2 == 0) then
piece.placed = mask
find( 1, 1, board | mask)
end
end
@pieces.push(piece)
end
piece = @pieces.shift
@pieces.push(piece)
end
# the normail find routine, iterates through the available pieces, checks all rotations at the current location
# and adds any boards found. depth is achieved via recursion. the overall approach is described
# here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
# parameters:
# start_location -- where to start looking for place for the next piece at
# placed -- number of pieces placed
# board -- current state of the board
#
# see in-code comments
def find( start_location, placed, board)
# find the next location to place a piece by looking for an empty bit
while board[start_location] == 1
start_location += 1
end
@pieces.length.times do
piece = @pieces.shift
piece.masks[start_location].each do | mask, imask, cmask |
if ( board & cmask == imask) then
piece.placed = mask
if (placed == 9) then
add_board
else
find( start_location + 1, placed + 1, board | mask)
end
end
end
@pieces.push(piece)
end
end
# print the board
def print_full_board( board_string)
10.times do | row |
print " " if (row % 2 == 1)
5.times do | col |
print "#{board_string[row*5 + col,1]} "
end
print "\n"
end
end
# when a board is found we "draw it" into a string and then flip that string, adding both to
# the list (hash) of solutions if they are unique.
def add_board
board_string = "99999999999999999999999999999999999999999999999999"
@all_pieces.each { | piece | piece.fill_string( board_string ) }
save( board_string)
save( board_string.reverse)
end
# adds a board string to the list (if new) and updates the current best/worst board
def save( board_string)
if (@all_boards[board_string] == nil) then
@min_board = board_string if (board_string < @min_board)
@max_board = board_string if (board_string > @max_board)
@all_boards.store(board_string,true)
@boards_found += 1
# the exit motif is a time saver. Ideally the function should return, but those tests
# take noticeable time (performance).
if (@boards_found == @stop_count) then
print_results
exit(0)
end
end
end
##
## MAIN BODY :)
##
create_collector_support
@pieces = [
Piece.new( [ :nw, :ne, :east, :east ], 2),
Piece.new( [ :ne, :se, :east, :ne ], 7),
Piece.new( [ :ne, :east, :ne, :nw ], 1),
Piece.new( [ :east, :sw, :sw, :se ], 6),
Piece.new( [ :east, :ne, :se, :ne ], 5),
Piece.new( [ :east, :east, :east, :se ], 0),
Piece.new( [ :ne, :nw, :se, :east, :se ], 4),
Piece.new( [ :se, :se, :se, :west ], 9),
Piece.new( [ :se, :se, :east, :se ], 8),
Piece.new( [ :east, :east, :sw, :se ], 3)
];
@all_pieces = Array.new( @pieces)
@min_board = "99999999999999999999999999999999999999999999999999"
@max_board = "00000000000000000000000000000000000000000000000000"
@stop_count = ARGV[0].to_i || 2089
@all_boards = {}
@boards_found = 0
find_all ######## DO IT!!!
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 3.214573436998762
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 3.1098699789727107
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 3.2271991709712893
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 3.1673258210066706
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 3.161870562005788
built-ruby 3.284487602999434
built-ruby 3.1628922530217096
built-ruby 3.23014268593397
built-ruby 3.2681007150094956
built-ruby 3.2358279089676216
-----------------------------------------------------------
so_nbody
# The Computer Language Shootout
# http://shootout.alioth.debian.org
#
# Optimized for Ruby by Jesse Millikan
# From version ported by Michael Neumann from the C gcc version,
# which was written by Christoph Bauer.
SOLAR_MASS = 4 * Math::PI**2
DAYS_PER_YEAR = 365.24
def _puts *args
end
class Planet
attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
def initialize(x, y, z, vx, vy, vz, mass)
@x, @y, @z = x, y, z
@vx, @vy, @vz = vx * DAYS_PER_YEAR, vy * DAYS_PER_YEAR, vz * DAYS_PER_YEAR
@mass = mass * SOLAR_MASS
end
def move_from_i(bodies, nbodies, dt, i)
while i < nbodies
b2 = bodies[i]
dx = @x - b2.x
dy = @y - b2.y
dz = @z - b2.z
distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
mag = dt / (distance * distance * distance)
b_mass_mag, b2_mass_mag = @mass * mag, b2.mass * mag
@vx -= dx * b2_mass_mag
@vy -= dy * b2_mass_mag
@vz -= dz * b2_mass_mag
b2.vx += dx * b_mass_mag
b2.vy += dy * b_mass_mag
b2.vz += dz * b_mass_mag
i += 1
end
@x += dt * @vx
@y += dt * @vy
@z += dt * @vz
end
end
def energy(bodies)
e = 0.0
nbodies = bodies.size
for i in 0 ... nbodies
b = bodies[i]
e += 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
for j in (i + 1) ... nbodies
b2 = bodies[j]
dx = b.x - b2.x
dy = b.y - b2.y
dz = b.z - b2.z
distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
e -= (b.mass * b2.mass) / distance
end
end
e
end
def offset_momentum(bodies)
px, py, pz = 0.0, 0.0, 0.0
for b in bodies
m = b.mass
px += b.vx * m
py += b.vy * m
pz += b.vz * m
end
b = bodies[0]
b.vx = - px / SOLAR_MASS
b.vy = - py / SOLAR_MASS
b.vz = - pz / SOLAR_MASS
end
BODIES = [
# sun
Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
# jupiter
Planet.new(
4.84143144246472090e+00,
-1.16032004402742839e+00,
-1.03622044471123109e-01,
1.66007664274403694e-03,
7.69901118419740425e-03,
-6.90460016972063023e-05,
9.54791938424326609e-04),
# saturn
Planet.new(
8.34336671824457987e+00,
4.12479856412430479e+00,
-4.03523417114321381e-01,
-2.76742510726862411e-03,
4.99852801234917238e-03,
2.30417297573763929e-05,
2.85885980666130812e-04),
# uranus
Planet.new(
1.28943695621391310e+01,
-1.51111514016986312e+01,
-2.23307578892655734e-01,
2.96460137564761618e-03,
2.37847173959480950e-03,
-2.96589568540237556e-05,
4.36624404335156298e-05),
# neptune
Planet.new(
1.53796971148509165e+01,
-2.59193146099879641e+01,
1.79258772950371181e-01,
2.68067772490389322e-03,
1.62824170038242295e-03,
-9.51592254519715870e-05,
5.15138902046611451e-05)
]
init = 200_000 # ARGV[0]
n = Integer(init)
offset_momentum(BODIES)
puts "%.9f" % energy(BODIES)
nbodies = BODIES.size
dt = 0.01
n.times do
i = 0
while i < nbodies
b = BODIES[i]
b.move_from_i(BODIES, nbodies, dt, i + 1)
i += 1
end
end
puts "%.9f" % energy(BODIES)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4895762570668012
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4316055789822713
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.845774877932854
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.619503965950571
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4358512359904125
built-ruby 1.489605403970927
built-ruby 1.6369827128946781
built-ruby 1.4628069479949772
built-ruby 1.4912516539916396
built-ruby 1.5065212330082431
-----------------------------------------------------------
so_nested_loop
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: nestedloop-ruby.code,v 1.4 2004/11/13 07:42:22 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# from Avi Bryant
n = 16 # Integer(ARGV.shift || 1)
x = 0
n.times do
n.times do
n.times do
n.times do
n.times do
n.times do
x += 1
end
end
end
end
end
end
# puts x
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1538302639964968
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1864004079252481
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.2282375219510868
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.138558418955654
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.16007225390058
built-ruby 1.185616576927714
built-ruby 1.1600782250752673
built-ruby 1.1420731919351965
built-ruby 1.1650092269992456
built-ruby 1.2048731839749962
-----------------------------------------------------------
so_nsieve
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# contributed by Glenn Parker, March 2005
# modified by Evan Phoenix, Sept 2006
def sieve(m)
flags = Flags.dup[0,m]
count = 0
pmax = m - 1
p = 2
while p <= pmax
unless flags[p].zero?
count += 1
mult = p
while mult <= pmax
flags[mult] = 0
mult += p
end
end
p += 1
end
count
end
n = 9 # (ARGV[0] || 2).to_i
Flags = ("\x1" * ( 2 ** n * 10_000)).unpack("c*")
n.downto(n-2) do |exponent|
break if exponent < 0
m = (1 << exponent) * 10_000
# m = (2 ** exponent) * 10_000
count = sieve(m)
printf "Primes up to %8d %8d\n", m, count
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6415367040317506
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6886816358892247
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6680605559377
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.6920543529558927
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.782741497969255
built-ruby 2.6169516319641843
built-ruby 3.1001667861128226
built-ruby 2.6669340380467474
built-ruby 2.6808960790513083
built-ruby 2.7213375431019813
-----------------------------------------------------------
so_nsieve_bits
#!/usr/bin/ruby
#coding: us-ascii
#
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# nsieve-bits in Ruby
# Contributed by Glenn Parker, March 2005
CharExponent = 3
BitsPerChar = 1 << CharExponent
LowMask = BitsPerChar - 1
def sieve(m)
items = "\xFF" * ((m / BitsPerChar) + 1)
masks = ""
BitsPerChar.times do |b|
masks << (1 << b).chr
end
count = 0
pmax = m - 1
2.step(pmax, 1) do |p|
if items[p >> CharExponent][p & LowMask] == 1
count += 1
p.step(pmax, p) do |mult|
a = mult >> CharExponent
b = mult & LowMask
items[a] -= masks[b] if items[a][b] != 0
end
end
end
count
end
n = 9 # (ARGV[0] || 2).to_i
n.step(n - 2, -1) do |exponent|
break if exponent < 0
m = 2 ** exponent * 10_000
count = sieve(m)
printf "Primes up to %8d %8d\n", m, count
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.301028444082476
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.2683443799614906
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.3539857430150732
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.322234852006659
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.3135949260322377
built-ruby 2.3850281490013003
built-ruby 2.345874104066752
built-ruby 2.378566651022993
built-ruby 2.3643613040912896
built-ruby 2.3432405130006373
-----------------------------------------------------------
so_object
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: objinst-ruby.code,v 1.4 2004/11/13 07:42:25 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Aristarkh Zagorodnikov
class Toggle
def initialize(start_state)
@bool = start_state
end
def value
@bool
end
def activate
@bool = !@bool
self
end
end
class NthToggle < Toggle
def initialize(start_state, max_counter)
super start_state
@count_max = max_counter
@counter = 0
end
def activate
@counter += 1
if @counter >= @count_max
@bool = !@bool
@counter = 0
end
self
end
end
n = 1500000 # (ARGV.shift || 1).to_i
toggle = Toggle.new 1
5.times do
toggle.activate.value ? 'true' : 'false'
end
n.times do
toggle = Toggle.new 1
end
ntoggle = NthToggle.new 1, 3
8.times do
ntoggle.activate.value ? 'true' : 'false'
end
n.times do
ntoggle = NthToggle.new 1, 3
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7316628498956561
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7300474169896916
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7387221120297909
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7108710629399866
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6899573819246143
built-ruby 0.7220470539759845
built-ruby 0.6960933840600774
built-ruby 0.7012202719924971
built-ruby 0.7292858430882916
built-ruby 0.7503255079500377
-----------------------------------------------------------
so_partial_sums
n = 2_500_000 # (ARGV.shift || 1).to_i
alt = 1.0 ; s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.0
1.upto(n) do |d|
d = d.to_f ; d2 = d * d ; d3 = d2 * d ; ds = Math.sin(d) ; dc = Math.cos(d)
s0 += (2.0 / 3.0) ** (d - 1.0)
s1 += 1.0 / Math.sqrt(d)
s2 += 1.0 / (d * (d + 1.0))
s3 += 1.0 / (d3 * ds * ds)
s4 += 1.0 / (d3 * dc * dc)
s5 += 1.0 / d
s6 += 1.0 / d2
s7 += alt / d
s8 += alt / (2.0 * d - 1.0)
alt = -alt
end
if false
printf("%.9f\t(2/3)^k\n", s0)
printf("%.9f\tk^-0.5\n", s1)
printf("%.9f\t1/k(k+1)\n", s2)
printf("%.9f\tFlint Hills\n", s3)
printf("%.9f\tCookson Hills\n", s4)
printf("%.9f\tHarmonic\n", s5)
printf("%.9f\tRiemann Zeta\n", s6)
printf("%.9f\tAlternating Harmonic\n", s7)
printf("%.9f\tGregory\n", s8)
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.500978328054771
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.635557516012341
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.560625697951764
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.581163607072085
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.5816292610252276
built-ruby 2.362442729063332
built-ruby 2.4183926139958203
built-ruby 2.3625309329945594
built-ruby 2.341785904020071
built-ruby 2.298863000003621
-----------------------------------------------------------
so_pidigits
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# contributed by Gabriele Renzi
class PiDigitSpigot
def initialize()
@z = Transformation.new 1,0,0,1
@x = Transformation.new 0,0,0,0
@inverse = Transformation.new 0,0,0,0
end
def next!
@y = @z.extract(3)
if safe? @y
@z = produce(@y)
@y
else
@z = consume @x.next!()
next!()
end
end
def safe?(digit)
digit == @z.extract(4)
end
def produce(i)
@inverse.qrst(10,-10*i,0,1).compose(@z)
end
def consume(a)
@z.compose(a)
end
end
class Transformation
attr_reader :q, :r, :s, :t
def initialize (q, r, s, t)
@q,@r,@s,@t,@k = q,r,s,t,0
end
def next!()
@q = @k = @k + 1
@r = 4 * @k + 2
@s = 0
@t = 2 * @k + 1
self
end
def extract(j)
(@q * j + @r) / (@s * j + @t)
end
def compose(a)
self.class.new( @q * a.q,
@q * a.r + r * a.t,
@s * a.q + t * a.s,
@s * a.r + t * a.t
)
end
def qrst *args
initialize *args
self
end
end
WIDTH = 10
n = 2_500 # Integer(ARGV[0])
j = 0
digits = PiDigitSpigot.new
while n > 0
if n >= WIDTH
WIDTH.times {print digits.next!}
j += WIDTH
else
n.times {print digits.next!}
(WIDTH-n).times {print " "}
j += n
end
puts "\t:"+j.to_s
n -= WIDTH
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1014664309332147
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.131148666027002
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1265840419800952
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.1504818280227482
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.0819793560076505
built-ruby 1.122832366032526
built-ruby 1.10261272394564
built-ruby 1.1235766469035298
built-ruby 1.0744329700246453
built-ruby 1.1077712529804558
-----------------------------------------------------------
so_random
# from http://www.bagley.org/~doug/shootout/bench/random/random.ruby
IM = 139968.0
IA = 3877.0
IC = 29573.0
$last = 42.0
def gen_random(max)
(max * ($last = ($last * IA + IC) % IM)) / IM
end
N = 3_000_000
i = 0
while i<N
i +=1
gen_random(100.0)
end
# "%.9f" % gen_random(100.0)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.7285520100267604
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6450352750252932
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6077214890392497
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6734153520083055
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6686573839979246
built-ruby 0.628942308947444
built-ruby 0.6288085500709713
built-ruby 0.5946870530024171
built-ruby 0.6637242790311575
built-ruby 0.6055637079989538
-----------------------------------------------------------
so_reverse_complement
#!/usr/bin/ruby
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# Contributed by Peter Bjarke Olsen
# Modified by Doug King
seq=Array.new
def revcomp(seq)
seq.reverse!.tr!('wsatugcyrkmbdhvnATUGCYRKMBDHVN','WSTAACGRYMKVHDBNTAACGRYMKVHDBN')
stringlen=seq.length
0.step(stringlen-1,60) {|x| print seq.slice(x,60) , "\n"}
end
input = open(File.join(File.dirname($0), 'fasta.output.2500000'), 'rb')
while input.gets
if $_ =~ />/
if seq.length != 0
revcomp(seq.join)
seq=Array.new
end
puts $_
else
$_.sub(/\n/,'')
seq.push $_
end
end
revcomp(seq.join)
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4943940199445933
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.440265225013718
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.445961530902423
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.435811645933427
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4018389220582321
built-ruby 1.469454557984136
built-ruby 1.4507102069910616
built-ruby 1.4145648250123486
built-ruby 1.455602815025486
built-ruby 1.4465106899151579
-----------------------------------------------------------
so_sieve
# from http://www.bagley.org/~doug/shootout/bench/sieve/sieve.ruby
num = 500
count = i = j = 0
flags0 = Array.new(8192,1)
k = 0
while k < num
k += 1
count = 0
flags = flags0.dup
i = 2
while i<8192
i += 1
if flags[i]
# remove all multiples of prime: i
j = i*i
while j < 8192
j += i
flags[j] = nil
end
count += 1
end
end
end
count
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.660474959993735
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6891729219350964
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6417632529046386
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6398323100293055
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 0.6328638480044901
built-ruby 0.6445695080328733
built-ruby 0.6266142230015248
built-ruby 0.6595635160338134
built-ruby 0.6133787289727479
built-ruby 0.5951220249990001
-----------------------------------------------------------
so_spectralnorm
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
def eval_A(i,j)
return 1.0/((i+j)*(i+j+1)/2+i+1)
end
def eval_A_times_u(u)
v, i = nil, nil
(0..u.length-1).collect { |i|
v = 0
for j in 0..u.length-1
v += eval_A(i,j)*u[j]
end
v
}
end
def eval_At_times_u(u)
v, i = nil, nil
(0..u.length-1).collect{|i|
v = 0
for j in 0..u.length-1
v += eval_A(j,i)*u[j]
end
v
}
end
def eval_AtA_times_u(u)
return eval_At_times_u(eval_A_times_u(u))
end
n = 500 # ARGV[0].to_i
u=[1]*n
for i in 1..10
v=eval_AtA_times_u(u)
u=eval_AtA_times_u(v)
end
vBv=0
vv=0
for i in 0..n-1
vBv += u[i]*v[i]
vv += v[i]*v[i]
end
str = "%0.9f" % (Math.sqrt(vBv/vv)), "\n"
# print str
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.059270013938658
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.9691427529323846
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.0123793249949813
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.1967068141093478
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 2.023914583027363
built-ruby 1.9620243050158024
built-ruby 2.0216803189832717
built-ruby 2.025437308009714
built-ruby 2.004478244925849
built-ruby 1.990443977061659
-----------------------------------------------------------
vm1_attr_ivar
class C
attr_reader :a, :b
def initialize
@a = nil
@b = nil
end
end
obj = C.new
i = 0
while i<30_000_000 # while loop 1
i += 1
j = obj.a
k = obj.b
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3876241719117388
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.423093921970576
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4063733690418303
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.3726484590442851
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.4575823689810932
built-ruby 1.4028229980031028
built-ruby 1.3671701760031283
built-ruby 1.3549646720057353
built-ruby 1.3731246680254117
built-ruby 1.3669164490420371
-----------------------------------------------------------
vm1_attr_ivar_set
class C
attr_accessor :a, :b
def initialize
@a = nil
@b = nil
end
end
obj = C.new
i = 0
while i<30_000_000 # while loop 1
i += 1
obj.a = 1
obj.b = 2
end
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.5688812079606578
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.5478982600616291
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.5380625020479783
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.5633647539652884
ruby 2.4.0dev (2016-07-22 trunk 55727) [x86_64-linux] 1.620823297998868
built-ruby 1.5418967349687591
built-ruby 1.48236778692808