Some examples from http://benchmarksgame.alioth.debian.org/ to compare SquilU with Lua, generally on this samples SquiLu is on average 30% slower.

SquiLu/samples/binary-tree.lua

@@ -0,0 +1,54 @@
+-- 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 start = os.clock()
+
+local N = tonumber(arg and arg[1]) or 14
+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)))
+
+print("binary-tree", N, os.clock()-start)

SquiLu/samples/binary-tree.nut

@@ -0,0 +1,51 @@
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
+// contributed by Mike Pall
+
+local function BottomUpTree(item, depth){
+  if (depth > 0){
+    local i = item + item;
+    --depth;
+    return [ item, BottomUpTree(i-1, depth),  BottomUpTree(i, depth) ];
+  }
+  else return [ item ];
+}
+
+local function ItemCheck(tree){
+  if (tree.get(1, false))  return tree[0] + ItemCheck(tree[1]) - ItemCheck(tree[2])
+  else
+    return tree[0]
+}
+
+local start = os.clock()
+//check_delayed_release_hooks(false);
+
+local N = vargv.get(1, 14).tointeger();
+local mindepth = 4
+local maxdepth = mindepth + 2
+if (maxdepth < N) maxdepth = N
+
+{
+  local stretchdepth = maxdepth + 1
+  local stretchtree = BottomUpTree(0, stretchdepth)
+  print(format("stretch tree of depth %d\t check: %d",
+    stretchdepth, ItemCheck(stretchtree)))
+}
+
+local longlivedtree = BottomUpTree(0, maxdepth)
+
+for(local depth=mindepth; depth <= maxdepth; depth += 2){
+  local iterations = math.pow(2, (maxdepth - depth + mindepth))
+  local check = 0
+  for(local i=0; i < iterations; ++i){
+    check += ItemCheck(BottomUpTree(1, depth)) +
+            ItemCheck(BottomUpTree(-1, depth))
+  }
+  print(format("%d\t trees of depth %d\t check: %d",
+    iterations*2, depth, check))
+}
+
+print(format("long lived tree of depth %d\t check: %d\n",
+  maxdepth, ItemCheck(longlivedtree)))
+
+print("binary-tree", N, os.clock()-start)

SquiLu/samples/n-body.lua

@@ -0,0 +1,125 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+-- modified by Geoff Leyland
+
+local sqrt = math.sqrt
+
+local PI = 3.141592653589793
+local SOLAR_MASS = 4 * PI * PI
+local DAYS_PER_YEAR = 365.24
+local bodies = {
+  { -- Sun
+    x = 0,
+    y = 0,
+    z = 0,
+    vx = 0,
+    vy = 0,
+    vz = 0,
+    mass = SOLAR_MASS
+  },
+  { -- 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
+  },
+  { -- 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
+  },
+  { -- 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
+  },
+  { -- 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 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 mag = sqrt(dx*dx + dy*dy + dz*dz)
+      mag = dt / (mag * mag * mag)
+      local bm = bj.mass*mag
+      bivx = bivx - (dx * bm)
+      bivy = bivy - (dy * bm)
+      bivz = bivz - (dz * bm)
+      bm = bimass*mag
+      bj.vx = bj.vx + (dx * bm)
+      bj.vy = bj.vy + (dy * bm)
+      bj.vz = bj.vz + (dz * bm)
+    end
+    bi.vx = bivx
+    bi.vy = bivy
+    bi.vz = bivz
+    bi.x = bix + dt * bivx
+    bi.y = biy + dt * bivy
+    bi.z = biz + dt * bivz
+  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 start = os.clock()
+local N = tonumber(arg and arg[1]) or 100000
+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")
+print("n-body", N, os.clock()-start)

SquiLu/samples/n-body.nut

@@ -0,0 +1,125 @@
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
+// contributed by Mike Pall
+// modified by Geoff Leyland
+
+local sqrt = math.sqrt
+
+local PI = 3.141592653589793
+local SOLAR_MASS = 4 * PI * PI
+local DAYS_PER_YEAR = 365.24
+local bodies = [
+  { // Sun
+    x = 0,
+    y = 0,
+    z = 0,
+    vx = 0,
+    vy = 0,
+    vz = 0,
+    mass = SOLAR_MASS
+  },
+  { // 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
+  },
+  { // 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
+  },
+  { // 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
+  },
+  { // 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 function advance(bodies, nbody, dt){
+  for(local i=0; i < nbody; ++i){
+    local bi = bodies[i]
+    local bix = bi.x, biy = bi.y, biz = bi.z, bimass = bi.mass
+    local bivx = bi.vx, bivy = bi.vy, bivz = bi.vz
+    for(local j=i+1; j < nbody; ++j){
+      local bj = bodies[j]
+      local dx = bix-bj.x, dy = biy-bj.y, dz = biz-bj.z
+      local mag = sqrt(dx*dx + dy*dy + dz*dz)
+      mag = dt / (mag * mag * mag)
+      local bm = bj.mass*mag
+      bivx = bivx - (dx * bm)
+      bivy = bivy - (dy * bm)
+      bivz = bivz - (dz * bm)
+      bm = bimass*mag
+      bj.vx = bj.vx + (dx * bm)
+      bj.vy = bj.vy + (dy * bm)
+      bj.vz = bj.vz + (dz * bm)
+    }
+    bi.vx = bivx
+    bi.vy = bivy
+    bi.vz = bivz
+    bi.x = bix + dt * bivx
+    bi.y = biy + dt * bivy
+    bi.z = biz + dt * bivz
+  }
+}
+
+local function energy(bodies, nbody){
+  local e = 0
+  for(local i=0; i < nbody; ++i){
+    local bi = bodies[i]
+    local vx = bi.vx, vy = bi.vy, vz = bi.vz, bim = bi.mass
+    e = e + (0.5 * bim * (vx*vx + vy*vy + vz*vz))
+    for(local j=i+1; j < nbody; ++j){
+      local bj = bodies[j]
+      local dx = bi.x-bj.x, dy = bi.y-bj.y, dz = bi.z-bj.z
+      local distance = sqrt(dx*dx + dy*dy + dz*dz)
+      e = e - ((bim * bj.mass) / distance)
+    }
+  }
+  return e
+}
+
+local function offsetMomentum(b, nbody){
+  local px = 0.0, py = 0.0, pz = 0.0
+  for(local i=0; i < nbody; ++i){
+    local bi = b[i]
+    local bim = bi.mass
+    px = px + (bi.vx * bim)
+    py = py + (bi.vy * bim)
+    pz = pz + (bi.vz * bim)
+  }
+  b[0].vx = -px / SOLAR_MASS
+  b[0].vy = -py / SOLAR_MASS
+  b[0].vz = -pz / SOLAR_MASS
+}
+
+local start = os.clock()
+local N = vargv.get(1, 100000).tointeger();
+local nbody = bodies.len();
+
+offsetMomentum(bodies, nbody)
+print( format("%0.9f",energy(bodies, nbody)))
+for(local i=0; i < N; ++i) advance(bodies, nbody, 0.01) 
+print( format("%0.9f",energy(bodies, nbody)))
+print("n-body", N, os.clock()-start)

SquiLu/samples/spectralnorm.lua

@@ -0,0 +1,49 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function A(i, j)
+  local ij = i+j-1
+  return 1.0 / (ij * (ij-1) * 0.5 + i)
+end
+
+local function Av(x, y, N)
+  for i=1,N do
+    local a = 0
+    for j=1,N do a = a + x[j] * A(i, j) end
+    y[i] = a
+  end
+end
+
+local function Atv(x, y, N)
+  for i=1,N do
+    local a = 0
+    for j=1,N do a = a + x[j] * A(j, i) end
+    y[i] = a
+  end
+end
+
+local function AtAv(x, y, t, N)
+  Av(x, t, N)
+  Atv(t, y, N)
+end
+
+local N = tonumber(arg and arg[1]) or 500
+
+local start = os.clock()
+
+local u, v, t = {}, {}, {}
+for i=1,N do u[i] = 1 end
+
+for i=1,10 do AtAv(u, v, t, N) AtAv(v, u, t, N) end
+
+local vBv, vv = 0, 0
+for i=1,N do
+  local ui, vi = u[i], v[i]
+  vBv = vBv + ui*vi
+  vv = vv + vi*vi
+end
+
+local result = math.sqrt(vBv / vv);
+print("spectralnorm", N, os.clock()-start)
+io.write(string.format("%0.9f\n", result))

SquiLu/samples/spectralnorm.nut

@@ -0,0 +1,58 @@
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
+//
+// contributed by Ian Osgood
+// modified by Isaac Gouy
+
+local function A(i,j) {
+  local ij = i+j;
+  return 1.0/(ij * (ij+1)/2.0+i+1);
+}
+
+local function Au(u,v, N) {
+  for (var i=0; i<N; ++i) {
+    var t = 0.0;
+    for (var j=0; j<N; ++j) t += A(i,j) * u[j];
+    v[i] = t;
+  }
+}
+
+local function Atu(u,v, N) {
+  for (var i=0; i<N; ++i) {
+    var t = 0.0;
+    for (var j=0; j<N; ++j) t += A(j,i) * u[j];
+    v[i] = t;
+  }
+}
+
+local function AtAu(u,v,w, N) {
+  Au(u,w, N);
+  Atu(w,v, N);
+}
+
+local function spectralnorm(n) {
+  var i, u=array(n), v=array(n), w=array(n), vv=0.0, vBv=0.0;
+  for (i=0; i<n; ++i) {
+    u[i] = 1.0; v[i] = w[i] = 0.0; 
+  }
+  for (i=0; i<10; ++i) {
+    AtAu(u,v,w, n);
+    AtAu(v,u,w, n);
+  }
+  for (i=0; i<n; ++i) {
+    vBv += u[i]*v[i];
+    vv  += v[i]*v[i];
+  }
+  return math.sqrt(vBv/vv);
+}
+
+print(check_delayed_release_hooks());
+//check_delayed_release_hooks(false);
+call_delayed_release_hooks();
+print(check_delayed_release_hooks());
+
+local N = vargv.get(1, 500).tointeger();
+local start = os.clock();
+local result = spectralnorm(N);
+print("spectralnorm", N, os.clock()-start);
+print(format("%d = %0.9f\n", N, result));