Add the benchmark suite

Author: gligneul

.gitignore

@@ -0,0 +1 @@
+results.*

ack.lua

@@ -0,0 +1,16 @@
+-- $Id: ackermann.lua,v 1.5 2000/12/09 20:07:43 doug Exp $
+-- http://www.bagley.org/~doug/shootout/
+
+local function Ack(M, N)
+    if (M == 0) then
+        return N + 1
+    end
+    if (N == 0) then
+        return Ack(M - 1, 1)
+    end
+    return Ack(M - 1, Ack(M, (N - 1)))
+end
+
+N = tonumber((arg and arg[1])) or 3
+M = tonumber((arg and arg[2])) or 8
+print(string.format("Ack(%d, %d) = %d\n", N, M, Ack(N,M)))

binary-trees.lua

@@ -0,0 +1,50 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function BottomUpTree(item, depth)
+  if depth > 0 then
+    local i = item + item
+    depth = depth - 1
+    local left, right = BottomUpTree(i-1, depth), BottomUpTree(i, depth)
+    return { item, left, right }
+  else
+    return { item }
+  end
+end
+
+local function ItemCheck(tree)
+  if tree[2] then
+    return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
+  else
+    return tree[1]
+  end
+end
+
+local N = tonumber(arg and arg[1]) or 0
+local mindepth = 4
+local maxdepth = mindepth + 2
+if maxdepth < N then maxdepth = N end
+
+do
+  local stretchdepth = maxdepth + 1
+  local stretchtree = BottomUpTree(0, stretchdepth)
+  io.write(string.format("stretch tree of depth %d\t check: %d\n",
+    stretchdepth, ItemCheck(stretchtree)))
+end
+
+local longlivedtree = BottomUpTree(0, maxdepth)
+
+for depth=mindepth,maxdepth,2 do
+  local iterations = 2 ^ (maxdepth - depth + mindepth)
+  local check = 0
+  for i=1,iterations do
+    check = check + ItemCheck(BottomUpTree(1, depth)) +
+            ItemCheck(BottomUpTree(-1, depth))
+  end
+  io.write(string.format("%d\t trees of depth %d\t check: %d\n",
+    iterations*2, depth, check))
+end
+
+io.write(string.format("long lived tree of depth %d\t check: %d\n",
+  maxdepth, ItemCheck(longlivedtree)))

fannkuch-redux.lua

@@ -0,0 +1,48 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function fannkuch(n)
+  local p, q, s, sign, maxflips, sum = {}, {}, {}, 1, 0, 0
+  for i=1,n do p[i] = i; q[i] = i; s[i] = i end
+  repeat
+    -- Copy and flip.
+    local q1 = p[1]				-- Cache 1st element.
+    if q1 ~= 1 then
+      for i=2,n do q[i] = p[i] end		-- Work on a copy.
+      local flips = 1
+      repeat
+	local qq = q[q1]
+	if qq == 1 then				-- ... until 1st element is 1.
+	  sum = sum + sign*flips
+	  if flips > maxflips then maxflips = flips end -- New maximum?
+	  break
+	end
+	q[q1] = q1
+	if q1 >= 4 then
+	  local i, j = 2, q1 - 1
+	  repeat q[i], q[j] = q[j], q[i]; i = i + 1; j = j - 1; until i >= j
+	end
+	q1 = qq; flips = flips + 1
+      until false
+    end
+    -- Permute.
+    if sign == 1 then
+      p[2], p[1] = p[1], p[2]; sign = -1	-- Rotate 1<-2.
+    else
+      p[2], p[3] = p[3], p[2]; sign = 1		-- Rotate 1<-2 and 1<-2<-3.
+      for i=3,n do
+	local sx = s[i]
+	if sx ~= 1 then s[i] = sx-1; break end
+	if i == n then return sum, maxflips end	-- Out of permutations.
+	s[i] = i
+	-- Rotate 1<-...<-i+1.
+	local t = p[1]; for j=1,i do p[j] = p[j+1] end; p[i+1] = t
+      end
+    end
+  until false
+end
+
+local n = tonumber(arg and arg[1]) or 7
+local sum, flips = fannkuch(n)
+io.write(sum, "\nPfannkuchen(", n, ") = ", flips, "\n")

fasta.lua

@@ -0,0 +1,106 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+-- Compability with Lua 5.3
+if not loadstring then
+    loadstring = load
+end
+if not unpack then
+    unpack = table.unpack
+end
+
+local Last = 42
+local function random(max)
+  local y = (Last * 3877 + 29573) % 139968
+  Last = y
+  return (max * y) / 139968
+end
+
+local function make_repeat_fasta(id, desc, s, n)
+  local write, sub = io.write, string.sub
+  write(">", id, " ", desc, "\n")
+  local p, sn, s2 = 1, #s, s..s
+  for i=60,n,60 do
+    write(sub(s2, p, p + 59), "\n")
+    p = p + 60; if p > sn then p = p - sn end
+  end
+  local tail = n % 60
+  if tail > 0 then write(sub(s2, p, p + tail-1), "\n") end
+end
+
+local function make_random_fasta(id, desc, bs, n)
+  io.write(">", id, " ", desc, "\n")
+  loadstring([=[
+    local write, char, unpack, n, random = io.write, string.char, unpack, ...
+    local buf, p = {}, 1
+    for i=60,n,60 do
+      for j=p,p+59 do ]=]..bs..[=[ end
+      buf[p+60] = 10; p = p + 61
+      if p >= 2048 then write(char(unpack(buf, 1, p-1))); p = 1 end
+    end
+    local tail = n % 60
+    if tail > 0 then
+      for j=p,p+tail-1 do ]=]..bs..[=[ end
+      p = p + tail; buf[p] = 10; p = p + 1
+    end
+    write(char(unpack(buf, 1, p-1)))
+  ]=], desc)(n, random)
+end
+
+local function bisect(c, p, lo, hi)
+  local n = hi - lo
+  if n == 0 then return "buf[j] = "..c[hi].."\n" end
+  local mid = math.floor(n / 2)
+  return "if r < "..p[lo+mid].." then\n"..bisect(c, p, lo, lo+mid)..
+         "else\n"..bisect(c, p, lo+mid+1, hi).."end\n"
+end
+
+local function make_bisect(tab)
+  local c, p, sum = {}, {}, 0
+  for i,row in ipairs(tab) do
+    c[i] = string.byte(row[1])
+    sum = sum + row[2]
+    p[i] = sum
+  end
+  return "local r = random(1)\n"..bisect(c, p, 1, #tab)
+end
+
+local alu =
+  "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"..
+  "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"..
+  "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"..
+  "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"..
+  "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"..
+  "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"..
+  "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
+
+local iub = make_bisect{
+  { "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 },
+}
+
+local homosapiens = make_bisect{
+  { "a", 0.3029549426680 },
+  { "c", 0.1979883004921 },
+  { "g", 0.1975473066391 },
+  { "t", 0.3015094502008 },
+}
+
+local N = tonumber(arg and arg[1]) or 1000
+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)

fixpoint-fact.lua

@@ -0,0 +1,24 @@
+-- fixed-point operator
+local Z = function (le)
+      local a = function (f)
+        return le(function (x) return f(f)(x) end)
+      end
+      return a(a)
+    end
+
+
+-- non-recursive factorial
+
+local F = function (f)
+      return function (n)
+               if n == 0 then return 1
+               else return n*f(n-1) end
+             end
+    end
+
+local fat = Z(F)
+
+local s = 0
+for i = 1, arg[1] or 100 do s = s + fat(i) end
+print(s)
+

heapsort.lua

@@ -0,0 +1,48 @@
+local random, floor = math.random, math.floor
+floor = math.ifloor or floor
+
+function heapsort(n, ra)
+    local j, i, rra
+    local l = floor(n/2) + 1
+    -- local l = (n//2) + 1
+    local ir = n;
+    while 1 do
+        if l > 1 then
+            l = l - 1
+            rra = ra[l]
+        else
+            rra = ra[ir]
+            ra[ir] = ra[1]
+            ir = ir - 1
+            if (ir == 1) then
+                ra[1] = rra
+                return
+            end
+        end
+        i = l
+        j = l * 2
+        while j <= ir do
+            if (j < ir) and (ra[j] < ra[j+1]) then
+                j = j + 1
+            end
+            if rra < ra[j] then
+                ra[i] = ra[j]
+                i = j
+                j = j + i
+            else
+                j = ir + 1
+            end
+        end
+        ra[i] = rra
+    end
+end
+
+local Num = tonumber((arg and arg[1])) or 4
+for i=1,Num do
+  local N = tonumber((arg and arg[2])) or 10000
+  local a = {}
+  for i=1,N do a[i] = random() end
+  heapsort(N, a)
+  for i=1,N-1 do assert(a[i] <= a[i+1]) end
+end
+

k-nucleotide.lua

@@ -0,0 +1,66 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function kfrequency(seq, freq, k, frame)
+  local sub = string.sub
+  local k1 = k - 1
+  for i=frame,string.len(seq)-k1,k do
+    local c = sub(seq, i, i+k1)
+    freq[c] = freq[c] + 1
+  end
+end
+
+local function freqdefault()
+  return 0
+end
+
+local function count(seq, frag)
+  local k = string.len(frag)
+  local freq = setmetatable({}, { __index = freqdefault })
+  for frame=1,k do kfrequency(seq, freq, k, frame) end
+  io.write(freq[frag] or 0, "\t", frag, "\n")
+end
+
+local function frequency(seq, k)
+  local freq = setmetatable({}, { __index = freqdefault })
+  for frame=1,k do kfrequency(seq, freq, k, frame) end
+  local sfreq, sn = {}, 1
+  for c,v in pairs(freq) do sfreq[sn] = c; sn = sn + 1 end
+  table.sort(sfreq, function(a, b)
+    local fa, fb = freq[a], freq[b]
+    return fa == fb and a > b or fa > fb
+  end)
+  sum = string.len(seq)-k+1
+  for _,c in ipairs(sfreq) do
+    io.write(string.format("%s %0.3f\n", c, (freq[c]*100)/sum))
+  end
+  io.write("\n")
+end
+
+local function readseq()
+  local sub = string.sub
+  for line in io.lines() do
+    if sub(line, 1, 1) == ">" and sub(line, 2, 6) == "THREE" then break end
+  end
+  local lines, ln = {}, 0
+  for line in io.lines() do
+    local c = sub(line, 1, 1)
+    if c == ">" then
+      break
+    elseif c ~= ";" then
+      ln = ln + 1
+      lines[ln] = line
+    end
+  end
+  return string.upper(table.concat(lines, "", 1, ln))
+end
+
+local seq = readseq()
+frequency(seq, 1)
+frequency(seq, 2)
+count(seq, "GGT")
+count(seq, "GGTA")
+count(seq, "GGTATT")
+count(seq, "GGTATTTTAATT")
+count(seq, "GGTATTTTAATTTATAGT")