Move sources into maven modules

luaj-test/src/test/resources/perf/binarytrees.lua

@@ -0,0 +1,50 @@
+-- The Computer Language Benchmarks Game
+-- http://shootout.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)))

luaj-test/src/test/resources/perf/fannkuch.lua

@@ -0,0 +1,51 @@
+-- The Computer Language Benchmarks Game
+-- http://shootout.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function fannkuch(n)
+  local p, q, s, odd, check, maxflips = {}, {}, {}, true, 0, 0
+  for i=1,n do p[i] = i; q[i] = i; s[i] = i end
+  repeat
+    -- Print max. 30 permutations.
+    if check < 30 then
+      if not p[n] then return maxflips end	-- Catch n = 0, 1, 2.
+      io.write(table.unpack(p)); io.write("\n")
+      check = check + 1
+    end
+    -- Copy and flip.
+    local q1 = p[1]				-- Cache 1st element.
+    if p[n] ~= n and q1 ~= 1 then		-- Avoid useless work.
+      for i=2,n do q[i] = p[i] end		-- Work on a copy.
+      for flips=1,1000000 do			-- Flip ...
+	local qq = q[q1]
+	if qq == 1 then				-- ... until 1st element is 1.
+	  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
+      end
+    end
+    -- Permute.
+    if odd then
+      p[2], p[1] = p[1], p[2]; odd = false	-- Rotate 1<-2.
+    else
+      p[2], p[3] = p[3], p[2]; odd = true	-- 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 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 1
+io.write("Pfannkuchen(", n, ") = ", fannkuch(n), "\n")

luaj-test/src/test/resources/perf/nbody.lua

@@ -0,0 +1,123 @@
+-- The Great Computer Language Shootout
+-- http://shootout.alioth.debian.org/
+-- contributed by Isaac Gouy, tuned by Mike Pall
+
+local sqrt = math.sqrt
+
+local PI = 3.141592653589793
+local SOLAR_MASS = 4 * PI * PI
+local DAYS_PER_YEAR = 365.24
+
+local Jupiter = {
+   x = 4.84143144246472090e+00
+  ,y = -1.16032004402742839e+00
+  ,z = -1.03622044471123109e-01
+  ,vx = 1.66007664274403694e-03 * DAYS_PER_YEAR
+  ,vy = 7.69901118419740425e-03 * DAYS_PER_YEAR
+  ,vz = -6.90460016972063023e-05 * DAYS_PER_YEAR
+  ,mass = 9.54791938424326609e-04 * SOLAR_MASS
+}
+
+local Saturn = {
+   x = 8.34336671824457987e+00
+  ,y = 4.12479856412430479e+00
+  ,z = -4.03523417114321381e-01
+  ,vx = -2.76742510726862411e-03 * DAYS_PER_YEAR
+  ,vy = 4.99852801234917238e-03 * DAYS_PER_YEAR
+  ,vz = 2.30417297573763929e-05 * DAYS_PER_YEAR
+  ,mass = 2.85885980666130812e-04 * SOLAR_MASS
+}
+
+local Uranus = {
+   x = 1.28943695621391310e+01
+  ,y = -1.51111514016986312e+01
+  ,z = -2.23307578892655734e-01
+  ,vx = 2.96460137564761618e-03 * DAYS_PER_YEAR
+  ,vy = 2.37847173959480950e-03 * DAYS_PER_YEAR
+  ,vz = -2.96589568540237556e-05 * DAYS_PER_YEAR
+  ,mass = 4.36624404335156298e-05 * SOLAR_MASS
+}
+
+local Neptune = {
+   x = 1.53796971148509165e+01
+  ,y = -2.59193146099879641e+01
+  ,z = 1.79258772950371181e-01
+  ,vx = 2.68067772490389322e-03 * DAYS_PER_YEAR
+  ,vy = 1.62824170038242295e-03 * DAYS_PER_YEAR
+  ,vz = -9.51592254519715870e-05 * DAYS_PER_YEAR
+  ,mass = 5.15138902046611451e-05 * SOLAR_MASS
+}
+
+local Sun = { x = 0, y = 0, z = 0,
+              vx = 0, vy = 0, vz = 0, mass = SOLAR_MASS }
+
+local function advance(bodies, nbody, dt)
+  for i=1,nbody do
+    local bi = bodies[i]
+    local bix, biy, biz, bimass = bi.x, bi.y, bi.z, bi.mass
+    local bivx, bivy, bivz = bi.vx, bi.vy, bi.vz
+    for j=i+1,nbody do
+      local bj = bodies[j]
+      local dx, dy, dz = bix-bj.x, biy-bj.y, biz-bj.z
+      local distance = sqrt(dx*dx + dy*dy + dz*dz)
+      local mag = dt / (distance * distance * distance)
+      local bim, bjm = bimass*mag, bj.mass*mag
+      bivx = bivx - (dx * bjm)
+      bivy = bivy - (dy * bjm)
+      bivz = bivz - (dz * bjm)
+      bj.vx = bj.vx + (dx * bim)
+      bj.vy = bj.vy + (dy * bim)
+      bj.vz = bj.vz + (dz * bim)
+    end
+    bi.vx = bivx
+    bi.vy = bivy
+    bi.vz = bivz
+  end
+  for i=1,nbody do
+    local bi = bodies[i]
+    bi.x = bi.x + (dt * bi.vx)
+    bi.y = bi.y + (dt * bi.vy)
+    bi.z = bi.z + (dt * bi.vz)
+  end
+end
+
+
+local function energy(bodies, nbody)
+  local e = 0
+  for i=1,nbody do
+    local bi = bodies[i]
+    local vx, vy, vz, bim = bi.vx, bi.vy, bi.vz, bi.mass
+    e = e + (0.5 * bim * (vx*vx + vy*vy + vz*vz))
+    for j=i+1,nbody do
+      local bj = bodies[j]
+      local dx, dy, dz = bi.x-bj.x, bi.y-bj.y, bi.z-bj.z
+      local distance = sqrt(dx*dx + dy*dy + dz*dz)
+      e = e - ((bim * bj.mass) / distance)
+    end
+  end
+  return e
+end
+
+
+local function offsetMomentum(b, nbody)
+  local px, py, pz = 0, 0, 0
+  for i=1,nbody do
+    local bi = b[i]
+    local bim = bi.mass
+    px = px + (bi.vx * bim)
+    py = py + (bi.vy * bim)
+    pz = pz + (bi.vz * bim)
+  end
+  b[1].vx = -px / SOLAR_MASS
+  b[1].vy = -py / SOLAR_MASS
+  b[1].vz = -pz / SOLAR_MASS
+end
+
+local N = tonumber(arg and arg[1]) or 1000
+local bodies = { Sun, Jupiter, Saturn, Uranus, Neptune }
+local nbody = #bodies
+
+offsetMomentum(bodies, nbody)
+io.write( string.format("%0.9f",energy(bodies, nbody)), "\n")
+for i=1,N do advance(bodies, nbody, 0.01) end
+io.write( string.format("%0.9f",energy(bodies, nbody)), "\n")

luaj-test/src/test/resources/perf/nsieve.lua

@@ -0,0 +1,35 @@
+-- The Computer Language Shootout
+-- http://shootout.alioth.debian.org/
+-- contributed by Isaac Gouy
+-- modified by Mike Pall
+
+
+local function nsieve(m,isPrime)
+   for i=2,m do
+      isPrime[i] = true
+   end
+   local count = 0
+
+   for i=2,m do
+      if isPrime[i] then
+         for k=i+i, m, i do
+            if isPrime[k] then isPrime[k] = false end
+         end
+         count = count + 1
+      end
+   end
+   return count
+end
+
+
+local n = tonumber(arg and arg[1]) or 1
+local flags = {}
+
+local m = (2^n)*10000
+print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))
+
+m = (2^(n-1))*10000
+print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))
+
+m = (2^(n-2))*10000
+print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))