Skip to content

@authorNari /gist:3806667
Created

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
origin(r37032) vs non-recursive marking(r36982)
2012-09-30 21:25:48 +0900
target 0: ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux]
target 1: ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux]
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.069356499
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.064061865
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.056181321
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.063135696
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.078710363
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.073622703
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.4042069
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.380156938
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.409791855
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.38677502
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.36354446
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.365782682
-----------------------------------------------------------
app_factorial
def fact(n)
if(n > 1)
n * fact(n-1)
else
1
end
end
100.times {
fact(5000)
}
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.105660614
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.127912072
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.109416446
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.135852428
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.137487919
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.120887073
-----------------------------------------------------------
app_fib
def fib n
if n < 3
1
else
fib(n-1) + fib(n-2)
end
end
fib(34)
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.72943414
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.733502726
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.733495922
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.688261031
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.687592698
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.683147567
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.578863307
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.505474104
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.504051975
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.532242724
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.53033762
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.53533595
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 18.03987355
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 18.141016334
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 18.172188301
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 17.245547859
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 17.547516347
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 17.460078599
-----------------------------------------------------------
app_raise
i = 0
while i<300000
i+=1
begin
raise
rescue
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.372994689
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.371561548
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.370629204
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.352022138
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.369656578
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.342859302
-----------------------------------------------------------
app_strconcat
i = 0
while i<2_000_000
"#{1+1} #{1+1} #{1+1}"
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.523259341
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.543172707
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.540047301
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.494560509
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.497409371
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.499485723
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.24460054
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.20879519
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.112204382
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.976128217
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.002950286
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.99035027
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.90951879
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.947003965
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.880754051
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.811778701
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.947111056
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.813879163
-----------------------------------------------------------
app_uri
require 'uri'
100_000.times{
uri = URI.parse('http://www.ruby-lang.org')
uri.scheme
uri.host
uri.port
}
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.091817629
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.083181695
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.067426075
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.047350409
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.070511298
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.018111493
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.372050017
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.384155196
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.382435642
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.258653506
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.210940008
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.231766842
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.108567682
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.153899772
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.118466089
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.861659879
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.939852579
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.886806783
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.904107456
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.857860886
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.852002023
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.777518783
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.79384847
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.788407041
-----------------------------------------------------------
io_select
# IO.select performance
w = [ IO.pipe[1] ];
nr = 1000000
nr.times {
IO.select nil, w
}
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.24407426
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.254317533
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.270998316
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.138764933
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.144242229
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.153553742
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.499180405
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.493436851
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.483542507
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.397307749
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.428728363
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.426114469
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.028549024
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.03246322
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.023578693
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.04939645
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.043589946
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.029141976
-----------------------------------------------------------
loop_for
for i in 1..30_000_000
#
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.365153195
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.306977958
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.321613874
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.34007753
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.281438134
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.321779365
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.430296071
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.424760547
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.436553188
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.424226744
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.433521291
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.422469489
-----------------------------------------------------------
loop_times
30_000_000.times{|e|}
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.152620696
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.175735684
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.178108478
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.173152975
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.199012558
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.226926617
-----------------------------------------------------------
loop_whileloop
i = 0
while i<30_000_000 # benchmark loop 1
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.568685853
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.556536587
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.583763427
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.613163935
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.73789316
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.602380524
-----------------------------------------------------------
loop_whileloop2
i = 0
while i< 6_000_000 # benchmark loop 2
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.125749003
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.129118855
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.121595079
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.138642389
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.137224207
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.134413156
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.805291225
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.755158433
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.809916983
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.764330046
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.759546312
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.782302443
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.246091408
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.25453949
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.240573727
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.240433738
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.248207702
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.222250108
-----------------------------------------------------------
so_binary_trees
# The Computer Language Shootout Benchmarks
# http://shootout.alioth.debian.org
#
# contributed by Jesse Millikan
# disable output
def STDOUT.write_ *args
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 = 12 # 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)}"
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.473840249
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.468455968
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.46648805
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.433181162
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.453594282
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.44514496
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.232305179
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.136654379
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.116336039
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.753459349
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.85781549
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.975663141
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.48536237
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.198960744
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.189652208
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.212537069
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.211523528
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.204213147
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.39123631
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.415174151
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.392664
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.389046818
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.38011163
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.397278528
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.493413834
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.482614826
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.48888763
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.467941872
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.598866179
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.528235313
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.505120632
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.507944676
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.503951028
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.209249012
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.217668199
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.239620709
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.742361205
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.741598961
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.716648042
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.632274368
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.627643634
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.628376887
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.356777082
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.345556151
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.313940046
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.272491596
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.271399745
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.229065041
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.082181035
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.04987843
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.07091047
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.186425395
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.10040952
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.272427428
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.833128237
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.810086802
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.837916759
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.796188924
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.80919548
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.790409616
-----------------------------------------------------------
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 boundries 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 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 accross the rows
(location / 6).to_i.upto(9) do | row_on |
# obtain a set of regions representing the bits of the curent 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 muliple 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
# follwing 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 acheived 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 noticable 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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.352270935
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.281774517
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.260251745
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.64616521
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.259086888
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.349850605
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.636808785
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.654080747
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.625884746
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.584374511
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.615817476
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.614168326
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.077382907
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.174170486
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.067437463
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.047161919
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.033981348
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.060507432
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.192186695
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.915912353
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.95810425
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.825024361
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.825202836
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.852777234
-----------------------------------------------------------
so_nsieve_bits
#!/usr/bin/ruby
#
# 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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.808935581
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.954418327
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.93334933
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.776700409
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.739391216
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.673607333
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.94712292
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.922851447
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.948232492
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.894249204
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.900731469
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.88137131
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.749712683
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.915673894
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.882950753
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.82355996
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.686623383
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.734052339
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.662234744
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.659698802
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.665069595
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.668972308
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.667914326
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.683186119
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.515818243
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.524088623
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.528828401
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.540918065
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.541113039
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.534266947
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 7.127404462
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 6.977702817
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 6.992548649
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 9.622386334
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 9.626735167
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 9.683168587
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.845783165
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.848730114
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.883973275
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.824382618
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.852367397
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.853203794
-----------------------------------------------------------
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.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.519144388
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.514532217
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.716207401
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.624282879
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.466449621
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.542055618
-----------------------------------------------------------
vm1_block
def m
yield
end
i = 0
while i<30_000_000 # while loop 1
i+=1
m{
}
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.54733746
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.47185557
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.330835436
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.284224462
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.311436366
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.509424533
-----------------------------------------------------------
vm1_const
Const = 1
i = 0
while i<30_000_000 # while loop 1
i+= 1
j = Const
k = Const
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.297367357
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.260963872
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.238480238
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.233450446
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.234425539
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.289979479
-----------------------------------------------------------
vm1_ensure
i = 0
while i<30_000_000 # benchmark loop 1
i+=1
begin
begin
ensure
end
ensure
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.63870417
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.631710304
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.627617204
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.666388321
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.674633142
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.708656375
-----------------------------------------------------------
vm1_ivar
@a = 1
i = 0
while i<30_000_000 # while loop 1
i+= 1
j = @a
k = @a
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.290487293
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.280964462
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.275782859
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.305875153
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.316604464
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.294314874
-----------------------------------------------------------
vm1_ivar_set
i = 0
while i<30_000_000 # while loop 1
i+= 1
@a = 1
@b = 2
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.646206332
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.690575017
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.522146352
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.473532799
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.585017381
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.548251217
-----------------------------------------------------------
vm1_length
a = 'abc'
b = [1, 2, 3]
i = 0
while i<30_000_000 # while loop 1
i+=1
a.length
b.length
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.307087301
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.291204786
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.245261117
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.234679376
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.256798982
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.202340422
-----------------------------------------------------------
vm1_lvar_init
def m v
unless v
# unreachable code
v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = v9 = v10 =
v11 = v12 = v13 = v14 = v15 = v16 = v17 = v18 = v19 = v20 =
v21 = v22 = v23 = v24 = v25 = v26 = v27 = v28 = v29 = v30 =
v31 = v32 = v33 = v34 = v35 = v36 = v37 = v38 = v39 = v40 =
v41 = v42 = v43 = v44 = v45 = v46 = v47 = v48 = v49 = v50 = 1
end
end
i = 0
while i<30_000_000 # while loop 1
i+=1
m i
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.255557313
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.708471091
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.383969231
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.188923135
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.214155906
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.423123778
-----------------------------------------------------------
vm1_lvar_set
i = 0
while i<30_000_000 # while loop 1
i+= 1
a = b = c = d = e = f = g = h = j = k = l = m = n = o = p = q = r = 1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.07380173
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.928038454
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.024604887
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.002744977
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.974972761
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.069241418
-----------------------------------------------------------
vm1_neq
i = 0
obj1 = Object.new
obj2 = Object.new
while i<30_000_000 # while loop 1
i+= 1
obj1 != obj2
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.97359345
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.059398898
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.064484078
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.131951323
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.075079057
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.130894177
-----------------------------------------------------------
vm1_not
i = 0
obj = Object.new
while i<30_000_000 # while loop 1
i+= 1
!obj
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.869433726
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.83556224
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.80482855
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.85125971
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.90279896
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.8992366
-----------------------------------------------------------
vm1_rescue
i = 0
while i<30_000_000 # while loop 1
i+=1
begin
rescue
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.719303912
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.725712448
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.690120835
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.893927191
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.904758213
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.69868818
-----------------------------------------------------------
vm1_simplereturn
def m
return 1
end
i = 0
while i<30_000_000 # while loop 1
i+=1
m
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.663576591
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.647786084
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.682517734
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.118771134
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.665168017
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.741160017
-----------------------------------------------------------
vm1_swap
a = 1
b = 2
i = 0
while i<30_000_000 # while loop 1
i+=1
a, b = b, a
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.857045535
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.843121216
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.84112904
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.878685397
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.830756172
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.885661316
-----------------------------------------------------------
vm2_array
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
a = [1,2,3,4,5,6,7,8,9,10]
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.863589374
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.831263725
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.844665482
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.822193199
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.840983555
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.829496314
-----------------------------------------------------------
vm2_bigarray
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
a = [
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
]
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.018945378
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.051169646
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.0312729
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 8.0656294
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 7.889391309
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 8.069994641
-----------------------------------------------------------
vm2_bighash
i = 0
while i<60_000 # benchmark loop 2
i+=1
a = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9, 10=>10, 11=>11, 12=>12, 13=>13, 14=>14, 15=>15, 16=>16, 17=>17, 18=>18, 19=>19, 20=>20, 21=>21, 22=>22, 23=>23, 24=>24, 25=>25, 26=>26, 27=>27, 28=>28, 29=>29, 30=>30, 31=>31, 32=>32, 33=>33, 34=>34, 35=>35, 36=>36, 37=>37, 38=>38, 39=>39, 40=>40, 41=>41, 42=>42, 43=>43, 44=>44, 45=>45, 46=>46, 47=>47, 48=>48, 49=>49, 50=>50, 51=>51, 52=>52, 53=>53, 54=>54, 55=>55, 56=>56, 57=>57, 58=>58, 59=>59, 60=>60, 61=>61, 62=>62, 63=>63, 64=>64, 65=>65, 66=>66, 67=>67, 68=>68, 69=>69, 70=>70, 71=>71, 72=>72, 73=>73, 74=>74, 75=>75, 76=>76, 77=>77, 78=>78, 79=>79, 80=>80, 81=>81, 82=>82, 83=>83, 84=>84, 85=>85, 86=>86, 87=>87, 88=>88, 89=>89, 90=>90, 91=>91, 92=>92, 93=>93, 94=>94, 95=>95, 96=>96, 97=>97, 98=>98, 99=>99, 100=>100, 101=>101, 102=>102, 103=>103, 104=>104, 105=>105, 106=>106, 107=>107, 108=>108, 109=>109, 110=>110, 111=>111, 112=>112, 113=>113, 114=>114, 115=>115, 116=>116, 117=>117, 118=>118, 119=>119, 120=>120, 121=>121, 122=>122, 123=>123, 124=>124, 125=>125, 126=>126, 127=>127, 128=>128, 129=>129, 130=>130, 131=>131, 132=>132, 133=>133, 134=>134, 135=>135, 136=>136, 137=>137, 138=>138, 139=>139, 140=>140, 141=>141, 142=>142, 143=>143, 144=>144, 145=>145, 146=>146, 147=>147, 148=>148, 149=>149, 150=>150, 151=>151, 152=>152, 153=>153, 154=>154, 155=>155, 156=>156, 157=>157, 158=>158, 159=>159, 160=>160, 161=>161, 162=>162, 163=>163, 164=>164, 165=>165, 166=>166, 167=>167, 168=>168, 169=>169, 170=>170, 171=>171, 172=>172, 173=>173, 174=>174, 175=>175, 176=>176, 177=>177, 178=>178, 179=>179, 180=>180, 181=>181, 182=>182, 183=>183, 184=>184, 185=>185, 186=>186, 187=>187, 188=>188, 189=>189, 190=>190, 191=>191, 192=>192, 193=>193, 194=>194, 195=>195, 196=>196, 197=>197, 198=>198, 199=>199, 200=>200, 201=>201, 202=>202, 203=>203, 204=>204, 205=>205, 206=>206, 207=>207, 208=>208, 209=>209, 210=>210, 211=>211, 212=>212, 213=>213, 214=>214, 215=>215, 216=>216, 217=>217, 218=>218, 219=>219, 220=>220, 221=>221, 222=>222, 223=>223, 224=>224, 225=>225, 226=>226, 227=>227, 228=>228, 229=>229, 230=>230, 231=>231, 232=>232, 233=>233, 234=>234, 235=>235, 236=>236, 237=>237, 238=>238, 239=>239, 240=>240, 241=>241, 242=>242, 243=>243, 244=>244, 245=>245, 246=>246, 247=>247, 248=>248, 249=>249, 250=>250, 251=>251, 252=>252, 253=>253, 254=>254, 255=>255, 256=>256, 257=>257, 258=>258, 259=>259, 260=>260, 261=>261, 262=>262, 263=>263, 264=>264, 265=>265, 266=>266, 267=>267, 268=>268, 269=>269, 270=>270, 271=>271, 272=>272, 273=>273, 274=>274, 275=>275, 276=>276, 277=>277, 278=>278, 279=>279, 280=>280, 281=>281, 282=>282, 283=>283, 284=>284, 285=>285, 286=>286, 287=>287, 288=>288, 289=>289, 290=>290, 291=>291, 292=>292, 293=>293, 294=>294, 295=>295, 296=>296, 297=>297, 298=>298, 299=>299, 300=>300, 301=>301, 302=>302, 303=>303, 304=>304, 305=>305, 306=>306, 307=>307, 308=>308, 309=>309, 310=>310, 311=>311, 312=>312, 313=>313, 314=>314, 315=>315, 316=>316, 317=>317, 318=>318, 319=>319, 320=>320, 321=>321, 322=>322, 323=>323, 324=>324, 325=>325, 326=>326, 327=>327, 328=>328, 329=>329, 330=>330, 331=>331, 332=>332, 333=>333, 334=>334, 335=>335, 336=>336, 337=>337, 338=>338, 339=>339, 340=>340, 341=>341, 342=>342, 343=>343, 344=>344, 345=>345, 346=>346, 347=>347, 348=>348, 349=>349, 350=>350, 351=>351, 352=>352, 353=>353, 354=>354, 355=>355, 356=>356, 357=>357, 358=>358, 359=>359, 360=>360, 361=>361, 362=>362, 363=>363, 364=>364, 365=>365, 366=>366, 367=>367, 368=>368, 369=>369, 370=>370, 371=>371, 372=>372, 373=>373, 374=>374, 375=>375, 376=>376, 377=>377, 378=>378, 379=>379, 380=>380, 381=>381, 382=>382, 383=>383, 384=>384, 385=>385, 386=>386, 387=>387, 388=>388, 389=>389, 390=>390, 391=>391, 392=>392, 393=>393, 394=>394, 395=>395, 396=>396, 397=>397, 398=>398, 399=>399, 400=>400, 401=>401, 402=>402, 403=>403, 404=>404, 405=>405, 406=>406, 407=>407, 408=>408, 409=>409, 410=>410, 411=>411, 412=>412, 413=>413, 414=>414, 415=>415, 416=>416, 417=>417, 418=>418, 419=>419, 420=>420, 421=>421, 422=>422, 423=>423, 424=>424, 425=>425, 426=>426, 427=>427, 428=>428, 429=>429, 430=>430, 431=>431, 432=>432, 433=>433, 434=>434, 435=>435, 436=>436, 437=>437, 438=>438, 439=>439, 440=>440, 441=>441, 442=>442, 443=>443, 444=>444, 445=>445, 446=>446, 447=>447, 448=>448, 449=>449, 450=>450, 451=>451, 452=>452, 453=>453, 454=>454, 455=>455, 456=>456, 457=>457, 458=>458, 459=>459, 460=>460, 461=>461, 462=>462, 463=>463, 464=>464, 465=>465, 466=>466, 467=>467, 468=>468, 469=>469, 470=>470, 471=>471, 472=>472, 473=>473, 474=>474, 475=>475, 476=>476, 477=>477, 478=>478, 479=>479, 480=>480, 481=>481, 482=>482, 483=>483, 484=>484, 485=>485, 486=>486, 487=>487, 488=>488, 489=>489, 490=>490, 491=>491, 492=>492, 493=>493, 494=>494, 495=>495, 496=>496, 497=>497, 498=>498, 499=>499, 500=>500,}
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 4.905673979
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 5.116930091
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 5.256677031
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.946240747
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.934043061
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 4.949210751
-----------------------------------------------------------
vm2_case
i = 0
while i<6_000_000 # while loop 2
case :foo
when :bar
raise
when :baz
raise
when :boo
raise
when :foo
i+=1
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.256916535
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.241868476
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.262323658
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.253002938
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.268495779
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.251397151
-----------------------------------------------------------
vm2_defined_method
class Object
define_method(:m){}
end
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
m; m; m; m; m; m; m; m;
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.235828692
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.212240727
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 3.185548324
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.158472073
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.543625985
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 3.52026857
-----------------------------------------------------------
vm2_eval
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
eval("1")
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 17.568371117
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 17.19374903
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 17.364915861
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 16.720215087
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 15.925787985
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 16.520173982
-----------------------------------------------------------
vm2_method
def m
nil
end
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
m; m; m; m; m; m; m; m;
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.050344077
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.16879252
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.979065582
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.032034627
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.03797382
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.009723624
-----------------------------------------------------------
vm2_mutex
require 'thread'
m = Mutex.new
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
m.synchronize{}
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.232996526
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.156645323
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.144323318
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.0774299
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.283385858
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.080503399
-----------------------------------------------------------
vm2_poly_method
class C1
def m
1
end
end
class C2
def m
2
end
end
o1 = C1.new
o2 = C2.new
i = 0
while i<6_000_000 # benchmark loop 2
o = (i % 2 == 0) ? o1 : o2
o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.943331298
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.918329832
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 2.895945582
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.793855118
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.916755202
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 2.955051961
-----------------------------------------------------------
vm2_poly_method_ov
class C1
def m
1
end
end
class C2
def m
2
end
end
o1 = C1.new
o2 = C2.new
i = 0
while i<6_000_000 # benchmark loop 2
o = (i % 2 == 0) ? o1 : o2
# o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.351856948
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.317965594
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.313841362
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.33295781
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.323056439
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.3457694
-----------------------------------------------------------
vm2_proc
def m &b
b
end
pr = m{
a = 1
}
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
pr.call
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.65962196
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.629273197
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.597403897
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.646632067
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.681657474
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.633967363
-----------------------------------------------------------
vm2_raise1
def rec n
if n > 0
rec n-1
else
raise
end
end
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
begin
rec 1
rescue
# ignore
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.315547558
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.3074806
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 8.165156575
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 8.011856293
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 7.405329279
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 7.864148564
-----------------------------------------------------------
vm2_raise2
def rec n
if n > 0
rec n-1
else
raise
end
end
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
begin
rec 10
rescue
# ignore
end
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 12.258904878
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 12.120895284
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 12.679291914
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 11.10472803
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 10.926978892
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 11.393963
-----------------------------------------------------------
vm2_regexp
i = 0
str = 'xxxhogexxx'
while i<6_000_000 # benchmark loop 2
/hoge/ =~ str
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.594027611
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.69635214
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 1.548472075
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.375756579
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.365137851
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 1.49930266
-----------------------------------------------------------
vm2_send
class C
def m
end
end
o = C.new
i = 0
while i<6_000_000 # benchmark loop 2
i+=1
o.__send__ :m
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.477846788
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.477580093
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.497264137
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.557168495
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.442911618
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.484033229
-----------------------------------------------------------
vm2_super
class C
def m
1
end
end
class CC < C
def m
super()
end
end
obj = CC.new
i = 0
while i<6_000_000 # benchmark loop 2
obj.m
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.721257777
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.700338653
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.759245125
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.68508479
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.710217125
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.700573992
-----------------------------------------------------------
vm2_unif1
i = 0
def m a, b
end
while i<6_000_000 # benchmark loop 2
i+=1
m 100, 200
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.375809584
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.370508869
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.357353086
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.370056549
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.378671892
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.395107904
-----------------------------------------------------------
vm2_zsuper
i = 0
class C
def m a
1
end
end
class CC < C
def m a
super
end
end
obj = CC.new
while i<6_000_000 # benchmark loop 2
obj.m 10
i+=1
end
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.69653387
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.681699088
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.781548382
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.667405319
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.733980621
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.721975082
-----------------------------------------------------------
vm3_backtrace
# get last backtrace
begin
caller(0, 0)
rescue ArgumentError
alias caller_orig caller
def caller lev, n
caller_orig(lev)[0..n]
end
end
def rec n
if n < 0
100_000.times{
caller(0, 1)
}
else
rec(n-1)
end
end
rec 50
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.165290705
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.165950356
ruby 2.0.0dev (2012-09-25 trunk 37032) [x86_64-linux] 0.1719487
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.156350203
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.173305186
ruby 2.0.0dev (2012-09-16 trunk 36982) [x86_64-linux] 0.186206512