Benchmarks

Zust vs Lua vs Python

这个页面根据仓库根目录 benchmark.md 汇总 32 项测试。Zust 脚本通过 VM/JIT 编译执行，Lua 和 Python 作为脚本基线；展开每一项可以看到当前 benches 目录里的三门语言测试代码。

总览结果结果说明与近期变化所有测试项、代码和结果

几何平均 Lua 7.7x Python 28.7x

28 个有效对比项：Zust = 1.0x，Lua = 7.7x，Python = 28.7x。

Zust 1.0x

Lua 7.7x

Python 28.7x

结果来自 2026-06-17 的 cargo run --bin bench --release。

结果说明与近期变化

bubble sort 和 quicksort 的 Python 版未跑通；Lua 有有效数据，因此表格仍保留 Lua / Zust 对比。
string build 和 ackermann 的部分耗时低于 summary 的稳定计入阈值，因此不进入几何平均，但表格保留实际测得比例。
绝对耗时取决于运行机器与负载；同一次运行内三种语言在相同环境下测得，因此各列比值是稳定的可比信号。
新增 list push only 2M 与 list sum x5 2M，把 list 写入和读取/求和拆开观察。当前 push-only 仍慢于 Lua，sum-repeat 已快于 Lua。
闭包、bit popcount、spectral norm、bintree 等计算项在本轮结果中提升明显。
Dynamic::Map 相关两个 map 基准继续稳定快于 Lua 与 Python。
已知可优化点：list push only 当前仍受每元素一次 native FFI 调用影响，后续可把 push/get_idx 等路径内联进 Cranelift IR。

总览结果

测试项	规模	Zust	Lua	Python	Lua / Zust	Python / Zust
fibonacci(35) recursive	35	131ms	315ms	638ms	2.4x	4.9x
fibonacci iter 50M	50,000,000	163ms	374ms	3.5s	2.3x	21.6x
sieve 100K	100,000	214us	8ms	13ms	36.9x	62.3x
list push/sum 2M	2,000,000	38ms	23ms	168ms	0.6x	4.4x
list push only 2M	2,000,000	32ms	13ms	72ms	0.4x	2.2x
list sum x5 2M	2,000,000	36ms	60ms	584ms	1.7x	16.4x
bintree depth 20	20	5ms	34ms	46ms	6.3x	8.7x
nested loops(2000)	2,000	11ms	155ms	1.3s	13.6x	111.7x
float ops 20M	20,000,000	50ms	270ms	1.7s	5.4x	34.6x
strcat x50000	50,000	1ms	44ms	15ms	41.2x	14.0x
collatz(100K)	100,000	24ms	230ms	820ms	9.8x	34.7x
pow mod 5M	5,000,000	58ms	770ms	3.9s	13.2x	65.9x
gcd(5M)	5,000,000	186ms	496ms	1.6s	2.7x	8.7x
prime check(500K)	500,000	32ms	235ms	748ms	7.3x	23.4x
bubble sort 10K	10,000	48ms	676ms	ERR	14.1x	-
map bracket get/set 200K	200,000	41ms	120ms	89ms	2.9x	2.2x
mandelbrot 1000	1,000	31ms	626ms	3.9s	20.4x	127.5x
spectral norm 550	550	6ms	190ms	495ms	31.8x	82.8x
bit popcount 50M	50,000,000	49ms	1.9s	10.8s	38.2x	221.5x
sequential fact 100M	100,000,000	368ms	500ms	5.7s	1.4x	15.6x
string build x5000	5,000	54us	14ms	2ms	261.2x	41.4x
map bracket acc 200K	200,000	42ms	61ms	61ms	1.5x	1.4x
struct field ops 20M	20,000,000	62ms	675ms	2.7s	10.9x	43.6x
closure sum 50M	50,000,000	24ms	601ms	2.9s	25.2x	120.5x
closure 16args 10M	10,000,000	8ms	562ms	1.5s	73.5x	193.4x
vec add 100x500K	500,000	26ms	309ms	2.2s	11.7x	85.3x
ackermann(3,6)	6	897us	7ms	95us	7.9x	0.1x
quicksort 2K	2,000	55us	931us	ERR	16.9x	-
matrix mul 40x40 x50	50	3ms	89ms	274ms	32.9x	101.4x
binary search 10K	10,000	702us	10ms	14ms	14.1x	19.8x
random LCG 50M	50,000,000	62ms	422ms	6.6s	6.8x	106.6x
array reverse 1K x10K	10,000	9ms	139ms	1.2s	15.7x	130.8x

所有测试项、代码和结果

fibonacci(35) recursive Zust 131ms · Lua 315ms · Python 638ms

规模35 Zust131ms Lua315ms Python638ms Lua / Zust2.4x Python / Zust4.9x

Zust

fn fib(n: i64) {
    if n <= 1 {
        return n;
    }
    fib(n - 1) + fib(n - 2)
}

pub fn bench(n: i64) {
    fib(n)
}

Lua

local function fib(n)
    if n <= 1 then return n end
    return fib(n - 1) + fib(n - 2)
end
local n = tonumber(arg[1])
print(fib(n))

Python

import sys
def fib(n):
    if n <= 1: return n
    return fib(n - 1) + fib(n - 2)
n = int(sys.argv[1])
print(fib(n))

fibonacci iter 50M Zust 163ms · Lua 374ms · Python 3.5s

规模50,000,000 Zust163ms Lua374ms Python3.5s Lua / Zust2.3x Python / Zust21.6x

Zust

pub fn bench(n: i64) {
    let a = 0i64;
    let b = 1i64;
    for _ in 0..n {
        (a, b) = (b, (a + b) % 1000000007i64);
    }
    a
}

Lua

local n = tonumber(arg[1])
local a, b = 0, 1
for _ = 1, n do
    a, b = b, (a + b) % 1000000007
end
print(a)

Python

import sys

n = int(sys.argv[1])
a, b = 0, 1
for _ in range(n):
    a, b = b, (a + b) % 1000000007
print(a)

sieve 100K Zust 214us · Lua 8ms · Python 13ms

规模100,000 Zust214us Lua8ms Python13ms Lua / Zust36.9x Python / Zust62.3x

Zust

pub fn bench<N>() {
    let is_prime = [true; N];
    is_prime[0] = false;
    is_prime[1] = false;
    let count = 0i64;
    for p in 2i64..N {
        if is_prime[p] == true {
            count = count + 1;
            let step = p;
            let j = p * p;
            while j < N {
                is_prime[j] = false;
                j = j + step;
            }
        }
    }
    count
}

Lua

local n = tonumber(arg[1])
local is_prime = {}
for i = 0, n do is_prime[i] = true end
if n >= 0 then is_prime[0] = false end
if n >= 1 then is_prime[1] = false end
local count = 0
for p = 2, n do
    if is_prime[p] then
        count = count + 1
        local step = p
        local j = p * p
        while j <= n do
            is_prime[j] = false
            j = j + step
        end
    end
end
print(count)

Python

import sys
n = int(sys.argv[1])
is_prime = [True] * (n + 1)
if n >= 0: is_prime[0] = False
if n >= 1: is_prime[1] = False
count = 0
for p in range(2, n + 1):
    if is_prime[p]:
        count += 1
        step = p
        j = p * p
        while j <= n:
            is_prime[j] = False
            j += step
print(count)

list push/sum 2M Zust 38ms · Lua 23ms · Python 168ms

规模2,000,000 Zust38ms Lua23ms Python168ms Lua / Zust0.6x Python / Zust4.4x

Zust

pub fn bench(n: i64) {
    let l = [];
    for i in 0..n {
        l.push(i);
    }
    let sum = 0i64;
    for j in 0..n {
        sum = sum + l[j];
    }
    sum
}

Lua

local n = tonumber(arg[1])
local l = {}
for i = 0, n - 1 do l[i] = i end
local sum = 0
for i = 0, n - 1 do sum = sum + l[i] end
print(sum)

Python

import sys
n = int(sys.argv[1])
l = []
for i in range(n): l.append(i)
total = 0
for i in range(n): total += l[i]
print(total)

list push only 2M Zust 32ms · Lua 13ms · Python 72ms

规模2,000,000 Zust32ms Lua13ms Python72ms Lua / Zust0.4x Python / Zust2.2x

Zust

pub fn bench(n: i64) {
    let l = [];
    for i in 0..n {
        l.push(i);
    }
    l[n - 1i64]
}

Lua

local n = tonumber(arg[1])
local l = {}
for i = 0, n - 1 do l[i] = i end
print(l[n - 1])

Python

import sys
n = int(sys.argv[1])
l = []
for i in range(n): l.append(i)
print(l[n - 1])

list sum x5 2M Zust 36ms · Lua 60ms · Python 584ms

规模2,000,000 Zust36ms Lua60ms Python584ms Lua / Zust1.7x Python / Zust16.4x

Zust

pub fn bench(n: i64) {
    let l = [];
    for i in 0..n {
        l.push(i);
    }
    let sum = 0i64;
    for repeat in 0i64..5i64 {
        for j in 0..n {
            sum = sum + l[j];
        }
    }
    sum
}

Lua

local n = tonumber(arg[1])
local l = {}
for i = 0, n - 1 do l[i] = i end
local sum = 0
for _ = 1, 5 do
    for i = 0, n - 1 do sum = sum + l[i] end
end
print(sum)

Python

import sys
n = int(sys.argv[1])
l = []
for i in range(n): l.append(i)
total = 0
for _ in range(5):
    for i in range(n): total += l[i]
print(total)

bintree depth 20 Zust 5ms · Lua 34ms · Python 46ms

规模20 Zust5ms Lua34ms Python46ms Lua / Zust6.3x Python / Zust8.7x

Zust

fn make_tree(depth: i64) {
    if depth <= 0 {
        return 1;
    }
    1 + make_tree(depth - 1) + make_tree(depth - 1)
}

pub fn bench(n: i64) {
    make_tree(n)
}

Lua

local function make_tree(depth)
    if depth <= 0 then return 1 end
    return 1 + make_tree(depth - 1) + make_tree(depth - 1)
end
local n = tonumber(arg[1])
print(make_tree(n))

Python

import sys
def make_tree(depth):
    if depth <= 0: return 1
    return 1 + make_tree(depth - 1) + make_tree(depth - 1)
n = int(sys.argv[1])
print(make_tree(n))

nested loops(2000) Zust 11ms · Lua 155ms · Python 1.3s

规模2,000 Zust11ms Lua155ms Python1.3s Lua / Zust13.6x Python / Zust111.7x

Zust

pub fn bench(n: i64) {
    let bodies = 100i64;
    let total = 0i64;
    for step in 0..n {
        for i in 0..bodies {
            for j in 0..bodies {
                if i != j {
                    total = total + i * j;
                }
            }
        }
    }
    total
}

Lua

local n = tonumber(arg[1])
local bodies = 100
local total = 0
for step = 1, n do
    for i = 0, bodies - 1 do
        for j = 0, bodies - 1 do
            if i ~= j then
                total = total + i * j
            end
        end
    end
end
print(total)

Python

import sys

n = int(sys.argv[1])
bodies = 100
total = 0
for step in range(n):
    for i in range(bodies):
        for j in range(bodies):
            if i != j:
                total += i * j
print(total)

float ops 20M Zust 50ms · Lua 270ms · Python 1.7s

规模20,000,000 Zust50ms Lua270ms Python1.7s Lua / Zust5.4x Python / Zust34.6x

Zust

pub fn bench(n: i64) {
    let x = 1.0f64;
    let y = 2.0f64;
    for i in 0..n {
        x = x * 1.000001f64 + y * 0.999999f64;
        y = y * 1.000001f64 - x * 0.999999f64;
    }
    (x + y) as i64
}

Lua

local n = tonumber(arg[1])
local x = 1.0
local y = 2.0
for _ = 1, n do
    x = x * 1.000001 + y * 0.999999
    y = y * 1.000001 - x * 0.999999
end
print(math.floor(x + y))

Python

import sys

n = int(sys.argv[1])
x = 1.0
y = 2.0
for _ in range(n):
    x = x * 1.000001 + y * 0.999999
    y = y * 1.000001 - x * 0.999999
print(int(x + y))

strcat x50000 Zust 1ms · Lua 44ms · Python 15ms

规模50,000 Zust1ms Lua44ms Python15ms Lua / Zust41.2x Python / Zust14.0x

Zust

pub fn bench(n: i64) {
    let s = "";
    for i in 0..n {
        s = s + "x";
    }
    s.len() as i64
}

Lua

local n = tonumber(arg[1])
local s = ""
for _ = 1, n do
    s = s .. "x"
end
print(#s)

Python

import sys

n = int(sys.argv[1])
s = ""
for _ in range(n):
    s += "x"
print(len(s))

collatz(100K) Zust 24ms · Lua 230ms · Python 820ms

规模100,000 Zust24ms Lua230ms Python820ms Lua / Zust9.8x Python / Zust34.7x

Zust

pub fn bench(n: i64) {
    let total = 0i64;
    for start in 1..=n {
        let x = start;
        while x != 1 {
            if x % 2 == 0 {
                x = x / 2;
            } else {
                x = 3 * x + 1;
            }
            total = total + 1;
        }
    }
    total
}

Lua

local n = tonumber(arg[1])
local total = 0
for start = 1, n do
    local x = start
    while x ~= 1 do
        if x % 2 == 0 then
            x = x / 2
        else
            x = 3 * x + 1
        end
        total = total + 1
    end
end
print(total)

Python

import sys

n = int(sys.argv[1])
total = 0
for start in range(1, n + 1):
    x = start
    while x != 1:
        if x % 2 == 0:
            x = x // 2
        else:
            x = 3 * x + 1
        total += 1
print(total)

pow mod 5M Zust 58ms · Lua 770ms · Python 3.9s

规模5,000,000 Zust58ms Lua770ms Python3.9s Lua / Zust13.2x Python / Zust65.9x

Zust

pub fn bench(n: i64) {
    let result = 1i64;
    for i in 0..n {
        let base = (i % 100i64) + 2i64;
        let exp = (i % 31i64) + 1i64;
        let m = 1000000007i64;
        let r = 1i64;
        let b = base;
        let e = exp;
        while e > 0 {
            if e % 2i64 == 1i64 {
                r = (r * b) % m;
            }
            b = (b * b) % m;
            e = e / 2i64;
        }
        result = (result + r) % m;
    }
    result
}

Lua

local n = tonumber(arg[1])
local result = 1
for i = 0, n - 1 do
    local base = (i % 100) + 2
    local exp = (i % 31) + 1
    local m = 1000000007
    local r = 1
    local b = base
    local e = exp
    while e > 0 do
        if e % 2 == 1 then
            r = (r * b) % m
        end
        b = (b * b) % m
        e = math.floor(e / 2)
    end
    result = (result + r) % m
end
print(result)

Python

import sys

n = int(sys.argv[1])
result = 1
for i in range(n):
    base = (i % 100) + 2
    exp = (i % 31) + 1
    m = 1000000007
    r = 1
    b = base
    e = exp
    while e > 0:
        if e % 2 == 1:
            r = (r * b) % m
        b = (b * b) % m
        e = e // 2
    result = (result + r) % m
print(result)

gcd(5M) Zust 186ms · Lua 496ms · Python 1.6s

规模5,000,000 Zust186ms Lua496ms Python1.6s Lua / Zust2.7x Python / Zust8.7x

Zust

fn gcd(a: i64, b: i64) {
    let x = a;
    let y = b;
    while y != 0 {
        let t = y;
        y = x % y;
        x = t;
    }
    x
}

pub fn bench(n: i64) {
    let total = 0i64;
    for i in 0..n {
        total = total + gcd(i, n - i);
    }
    total
}

Lua

local function gcd(a, b)
    while b ~= 0 do
        a, b = b, a % b
    end
    return a
end

local n = tonumber(arg[1])
local total = 0
for i = 0, n - 1 do
    total = total + gcd(i, n - i)
end
print(total)

Python

import sys

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

n = int(sys.argv[1])
total = 0
for i in range(n):
    total += gcd(i, n - i)
print(total)

prime check(500K) Zust 32ms · Lua 235ms · Python 748ms

规模500,000 Zust32ms Lua235ms Python748ms Lua / Zust7.3x Python / Zust23.4x

Zust

fn is_prime(n: i64) {
    if n < 2 { return false; }
    let i = 2i64;
    while i * i <= n {
        if n % i == 0 { return false; }
        i = i + 1;
    }
    true
}

pub fn bench(n: i64) {
    let count = 0i64;
    for x in 2..=n {
        if is_prime(x) == true {
            count = count + 1;
        }
    }
    count
}

Lua

local function is_prime(n)
    if n < 2 then return false end
    local i = 2
    while i * i <= n do
        if n % i == 0 then return false end
        i = i + 1
    end
    return true
end

local n = tonumber(arg[1])
local count = 0
for x = 2, n do
    if is_prime(x) then count = count + 1 end
end
print(count)

Python

import sys

def is_prime(n):
    if n < 2:
        return False
    i = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += 1
    return True

n = int(sys.argv[1])
count = 0
for x in range(2, n + 1):
    if is_prime(x):
        count += 1
print(count)

bubble sort 10K Zust 48ms · Lua 676ms · Python ERR

规模10,000 Zust48ms Lua676ms PythonERR Lua / Zust14.1x Python / Zust-

说明Python 版本次未跑通，不计入几何平均。Lua 有有效数据，仍单独展示 Lua / Zust。

Zust

pub fn bench<N>() {
    let items: [i64; N] = [0i64; N];
    for i in 0i64..N {
        let seed = i * 6364136223846793005i64 + 1i64;
        items[i] = seed;
    }
    for i in 0i64..N {
        let limit = N - i - 1;
        for j in 0i64..limit {
            if items[j] > items[j + 1] {
                let a = items[j];
                let b = items[j + 1];
                items[j] = b;
                items[j + 1] = a;
            }
        }
    }
    let sum = 0i64;
    for i in 0i64..N {
        sum = sum + items[i];
    }
    sum
}

Lua

local function bubble_sort(items)
    local n = #items
    for i = 1, n do
        for j = 1, n - i do
            if items[j] > items[j + 1] then
                items[j], items[j + 1] = items[j + 1], items[j]
            end
        end
    end
end

local n = tonumber(arg[1])
local items = {}
for i = 0, n - 1 do
    local seed = i * 6364136223846793005 + 1
    items[i + 1] = seed
end
bubble_sort(items)
local sum = 0
for i = 1, n do sum = sum + items[i] end
print(sum)

Python

import sys

def bubble_sort(items):
    n = len(items)
    for i in range(n):
        for j in range(n - i - 1):
            if items[j] > items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]

n = int(sys.argv[1])
items = []
for i in range(n):
    seed = i * 6364136223846793005 + 1
    items.append(seed)
bubble_sort(items)
print(sum(items))

map bracket get/set 200K Zust 41ms · Lua 120ms · Python 89ms

规模200,000 Zust41ms Lua120ms Python89ms Lua / Zust2.9x Python / Zust2.2x

Zust

pub fn bench(n: i64) {
    let m = {};
    for i in 0..n {
        let key = "key_" + i;
        m[key] = i;
    }
    let sum = 0i64;
    for i in 0..n {
        let key = "key_" + i;
        sum = sum + m[key];
    }
    sum
}

Lua

local n = tonumber(arg[1])
local m = {}
for i = 0, n - 1 do
    local key = "key_" .. i
    m[key] = i
end
local sum = 0
for i = 0, n - 1 do
    local key = "key_" .. i
    sum = sum + m[key]
end
print(sum)

Python

import sys

n = int(sys.argv[1])
m = {}
for i in range(n):
    key = "key_" + str(i)
    m[key] = i
total = 0
for i in range(n):
    key = "key_" + str(i)
    total += m[key]
print(total)

mandelbrot 1000 Zust 31ms · Lua 626ms · Python 3.9s

规模1,000 Zust31ms Lua626ms Python3.9s Lua / Zust20.4x Python / Zust127.5x

Zust

pub fn bench(n: i64) {
    let hw = n / 2;
    let total = 0i64;
    let nf = n as f64;
    let hwf = hw as f64;
    for y in 0..n {
        let yf = y as f64;
        let ci = (yf - hwf) / (0.5f64 * nf);
        for x in 0..n {
            let xf = x as f64;
            let cr = 1.5f64 * (xf - hwf) / (0.5f64 * nf);
            let zr = 0.0f64;
            let zi = 0.0f64;
            let k = 0i64;
            while k < 50 && zr * zr + zi * zi < 4.0f64 {
                let zr2 = zr * zr;
                let zi2 = zi * zi;
                zi = 2.0f64 * zr * zi + ci;
                zr = zr2 - zi2 + cr;
                k = k + 1;
            }
            total = total + k;
        }
    }
    total
}

Lua

local n = tonumber(arg[1])
local total = 0
for y = 0, n - 1 do
    for x = 0, n - 1 do
        local cr = 1.5 * (x - n / 2) / (0.5 * n)
        local ci = (y - n / 2) / (0.5 * n)
        local zr, zi = 0.0, 0.0
        local k = 0
        while k < 50 and zr * zr + zi * zi < 4 do
            zr, zi = zr * zr - zi * zi + cr, 2 * zr * zi + ci
            k = k + 1
        end
        total = total + k
    end
end
print(total)

Python

import sys

n = int(sys.argv[1])
total = 0
for y in range(n):
    for x in range(n):
        cr = 1.5 * (x - n / 2) / (0.5 * n)
        ci = (y - n / 2) / (0.5 * n)
        zr = zi = 0.0
        k = 0
        while k < 50 and zr * zr + zi * zi < 4:
            zr, zi = zr * zr - zi * zi + cr, 2 * zr * zi + ci
            k += 1
        total += k
print(total)

spectral norm 550 Zust 6ms · Lua 190ms · Python 495ms

规模550 Zust6ms Lua190ms Python495ms Lua / Zust31.8x Python / Zust82.8x

Zust

fn eval_a(i: i64, j: i64) {
    1.0f64 / ((i + j) * (i + j + 1) / 2 + i + 1) as f64
}

fn multiply_av(n: i64, v: [f64; 550]) {
    let result: [f64; 550] = [0.0f64; 550];
    for i in 0..n {
        let sum = 0.0f64;
        for j in 0..n {
            sum = sum + eval_a(i, j) * v[j];
        }
        result[i] = sum;
    }
    result
}

fn multiply_atv(n: i64, v: [f64; 550]) {
    let result: [f64; 550] = [0.0f64; 550];
    for i in 0..n {
        let sum = 0.0f64;
        for j in 0..n {
            sum = sum + eval_a(j, i) * v[j];
        }
        result[i] = sum;
    }
    result
}

pub fn bench(n: i64) {
    let u: [f64; 550] = [1.0f64; 550];
    let v: [f64; 550] = [0.0f64; 550];
    for _ in 0..10 {
        v = multiply_av(n, u);
        u = multiply_atv(n, v);
    }
    let vbv = 0.0f64;
    let vv = 0.0f64;
    for i in 0..n {
        vbv = vbv + u[i] * v[i];
        vv = vv + v[i] * v[i];
    }
    let result = sqrt(vbv / vv);
    (result * 1000000.0f64) as i64
}

Lua

local function eval_A(i, j)
    return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1)
end

local function multiply_Av(n, v)
    local result = {}
    for i = 0, n - 1 do
        local sum = 0.0
        for j = 0, n - 1 do
            sum = sum + eval_A(i, j) * v[j + 1]
        end
        result[i + 1] = sum
    end
    return result
end

local function multiply_Atv(n, v)
    local result = {}
    for i = 0, n - 1 do
        local sum = 0.0
        for j = 0, n - 1 do
            sum = sum + eval_A(j, i) * v[j + 1]
        end
        result[i + 1] = sum
    end
    return result
end

local n = tonumber(arg[1])
local u = {}
local v = {}
for i = 0, n - 1 do u[i + 1] = 1.0 end
for _ = 1, 10 do
    v = multiply_Av(n, u)
    u = multiply_Atv(n, v)
end
local vBv = 0.0
local vv = 0.0
for i = 0, n - 1 do
    vBv = vBv + u[i + 1] * v[i + 1]
    vv = vv + v[i + 1] * v[i + 1]
end
local result = math.sqrt(vBv / vv)
print(math.floor(result * 1000000))

Python

import sys
import math

def eval_A(i, j):
    return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1)

def multiply_Av(n, v):
    result = [0.0] * n
    for i in range(n):
        s = 0.0
        for j in range(n):
            s += eval_A(i, j) * v[j]
        result[i] = s
    return result

def multiply_Atv(n, v):
    result = [0.0] * n
    for i in range(n):
        s = 0.0
        for j in range(n):
            s += eval_A(j, i) * v[j]
        result[i] = s
    return result

n = int(sys.argv[1])
u = [1.0] * n
v = [0.0] * n
for _ in range(10):
    v = multiply_Av(n, u)
    u = multiply_Atv(n, v)
vBv = 0.0
vv = 0.0
for i in range(n):
    vBv += u[i] * v[i]
    vv += v[i] * v[i]
result = math.sqrt(vBv / vv)
print(int(result * 1000000))

bit popcount 50M Zust 49ms · Lua 1.9s · Python 10.8s

规模50,000,000 Zust49ms Lua1.9s Python10.8s Lua / Zust38.2x Python / Zust221.5x

Zust

fn popcount(x: i64) {
    let n = x;
    n = n - ((n >> 1) & 0x5555555555555555i64);
    n = (n & 0x3333333333333333i64) + ((n >> 2) & 0x3333333333333333i64);
    n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0Fi64;
    n = n + (n >> 8);
    n = n + (n >> 16);
    n = n + (n >> 32);
    n & 0x7Fi64
}

pub fn bench(n: i64) {
    let total = 0i64;
    for i in 0..n {
        total = total + popcount(i);
    }
    total
}

Lua

local function popcount(x)
    local n = x
    n = n - ((n >> 1) & 0x5555555555555555)
    n = (n & 0x3333333333333333) + ((n >> 2) & 0x3333333333333333)
    n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0F
    n = n + (n >> 8)
    n = n + (n >> 16)
    n = n + (n >> 32)
    return n & 0x7F
end

local n = tonumber(arg[1])
local total = 0
for i = 0, n - 1 do
    total = total + popcount(i)
end
print(total)

Python

import sys

def popcount(x):
    n = x
    n = n - ((n >> 1) & 0x5555555555555555)
    n = (n & 0x3333333333333333) + ((n >> 2) & 0x3333333333333333)
    n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0F
    n = n + (n >> 8)
    n = n + (n >> 16)
    n = n + (n >> 32)
    return n & 0x7F

n = int(sys.argv[1])
total = 0
for i in range(n):
    total += popcount(i)
print(total)

sequential fact 100M Zust 368ms · Lua 500ms · Python 5.7s

规模100,000,000 Zust368ms Lua500ms Python5.7s Lua / Zust1.4x Python / Zust15.6x

Zust

pub fn bench(n: i64) {
    let result = 1i64;
    let m = 1000000007i64;
    for i in 1..=n {
        result = (result * i) % m;
    }
    result
}

Lua

local n = tonumber(arg[1])
local result = 1
local m = 1000000007
for i = 1, n do
    result = (result * i) % m
end
print(result)

Python

import sys

n = int(sys.argv[1])
result = 1
m = 1000000007
for i in range(1, n + 1):
    result = (result * i) % m
print(result)

string build x5000 Zust 54us · Lua 14ms · Python 2ms

规模5,000 Zust54us Lua14ms Python2ms Lua / Zust261.2x Python / Zust41.4x

Zust

pub fn bench(n: i64) {
    let s = "";
    let sep = ",";
    let chunk = "hello";
    for i in 0..n {
        if i > 0 {
            s = s + sep;
        }
        s = s + chunk;
    }
    s.len() as i64
}

Lua

local n = tonumber(arg[1])
local s = ""
local sep = ","
local chunk = "hello"
for i = 0, n - 1 do
    if i > 0 then s = s .. sep end
    s = s .. chunk
end
print(#s)

Python

import sys

n = int(sys.argv[1])
s = ""
sep = ","
chunk = "hello"
for i in range(n):
    if i > 0:
        s += sep
    s += chunk
print(len(s))

map bracket acc 200K Zust 42ms · Lua 61ms · Python 61ms

规模200,000 Zust42ms Lua61ms Python61ms Lua / Zust1.5x Python / Zust1.4x

Zust

pub fn bench(n: i64) {
    let m = {};
    for i in 0..n {
        let key = "" + i;
        m[key] = i;
    }
    let sum = 0i64;
    for i in 0..n {
        let key = "" + i;
        sum = sum + m[key];
    }
    sum
}

Lua

local n = tonumber(arg[1])
local m = {}
for i = 0, n - 1 do
    local key = tostring(i)
    m[key] = i
end
local sum = 0
for i = 0, n - 1 do
    local key = tostring(i)
    sum = sum + m[key]
end
print(sum)

Python

import sys

n = int(sys.argv[1])
m = {}
for i in range(n):
    key = str(i)
    m[key] = i
total = 0
for i in range(n):
    key = str(i)
    total += m[key]
print(total)

struct field ops 20M Zust 62ms · Lua 675ms · Python 2.7s

规模20,000,000 Zust62ms Lua675ms Python2.7s Lua / Zust10.9x Python / Zust43.6x

Zust

struct Vec3 {
    x: f64,
    y: f64,
    z: f64,
}

pub fn bench(n: i64) {
    let v = Vec3{x: 1.0f64, y: 2.0f64, z: 3.0f64};
    let total = 0.0f64;
    for _ in 0..n {
        let sum = v.x + v.y + v.z;
        v.x = v.x + 0.001f64;
        v.y = v.y + 0.002f64;
        v.z = v.z + 0.003f64;
        total = total + sum;
    }
    total as i64
}

Lua

local Vec3 = {}
function Vec3.new(x, y, z)
    return {x = x, y = y, z = z}
end

local n = tonumber(arg[1])
local v = Vec3.new(1.0, 2.0, 3.0)
local total = 0.0
for _ = 0, n - 1 do
    local sum = v.x + v.y + v.z
    v.x = v.x + 0.001
    v.y = v.y + 0.002
    v.z = v.z + 0.003
    total = total + sum
end
print(math.floor(total))

Python

import sys

class Vec3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

n = int(sys.argv[1])
v = Vec3(1.0, 2.0, 3.0)
total = 0.0
for _ in range(n):
    s = v.x + v.y + v.z
    v.x += 0.001
    v.y += 0.002
    v.z += 0.003
    total += s
print(int(total))

closure sum 50M Zust 24ms · Lua 601ms · Python 2.9s

规模50,000,000 Zust24ms Lua601ms Python2.9s Lua / Zust25.2x Python / Zust120.5x

Zust

pub fn bench(n: i64) {
    let acc = 0i64;
    let add = |a: i64, b: i64| {
        a + b
    };
    for i in 0..n {
        acc = add(acc, i);
    }
    acc
}

Lua

local n = tonumber(arg[1])
local acc = 0
local function add(a, b)
    return a + b
end
for i = 0, n - 1 do
    acc = add(acc, i)
end
print(acc)

Python

import sys

n = int(sys.argv[1])
acc = 0
def add(a, b):
    return a + b
for i in range(n):
    acc = add(acc, i)
print(acc)

closure 16args 10M Zust 8ms · Lua 562ms · Python 1.5s

规模10,000,000 Zust8ms Lua562ms Python1.5s Lua / Zust73.5x Python / Zust193.4x

Zust

pub fn bench(n: i64) {
    let acc = 0i64;
    let sum16 = |a, b, c, d, e, f, g, h, i, j, k, l, m, n_arg, o, p| {
        a + b + c + d + e + f + g + h + i + j + k + l + m + n_arg + o + p
    };
    for idx in 0..n {
        acc = acc + sum16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
    }
    acc
}

Lua

local n = tonumber(arg[1])
local acc = 0
local function sum16(a, b, c, d, e, f, g, h, i, j, k, l, m, n_arg, o, p)
    return a + b + c + d + e + f + g + h + i + j + k + l + m + n_arg + o + p
end
for idx = 0, n - 1 do
    acc = acc + sum16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
end
print(acc)

Python

import sys

n = int(sys.argv[1])
acc = 0
def sum16(a, b, c, d, e, f, g, h, i, j, k, l, m, n_arg, o, p):
    return a + b + c + d + e + f + g + h + i + j + k + l + m + n_arg + o + p
for idx in range(n):
    acc += sum16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
print(acc)

vec add 100x500K Zust 26ms · Lua 309ms · Python 2.2s

规模500,000 Zust26ms Lua309ms Python2.2s Lua / Zust11.7x Python / Zust85.3x

Zust

pub fn bench(n: i64) {
    let size = 100i64;
    let a: [f64; 100] = [0.0f64; 100];
    for i in 0..size {
        a[i] = (i as f64) * 1.5f64;
    }
    let total = 0.0f64;
    for _ in 0..n {
        for i in 0..size {
            total = total + a[i];
        }
    }
    total as i64
}

Lua

local n = tonumber(arg[1])
local size = 100
local a = {}
for i = 0, size - 1 do
    a[i + 1] = i * 1.5
end
local total = 0.0
for _ = 0, n - 1 do
    for i = 0, size - 1 do
        total = total + a[i + 1]
    end
end
print(math.floor(total))

Python

import sys

n = int(sys.argv[1])
size = 100
a = [i * 1.5 for i in range(size)]
total = 0.0
for _ in range(n):
    for i in range(size):
        total += a[i]
print(int(total))

ackermann(3,6) Zust 897us · Lua 7ms · Python 95us

规模6 Zust897us Lua7ms Python95us Lua / Zust7.9x Python / Zust0.1x

Zust

fn ack(m: i64, n: i64) {
    if m == 0 {
        return n + 1;
    }
    if n == 0 {
        return ack(m - 1, 1);
    }
    ack(m - 1, ack(m, n - 1))
}

pub fn bench(n: i64) {
    ack(3, n)
}

Lua

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

local n = 6  -- default
if arg and arg[1] then n = tonumber(arg[1]) or 6 end
print(ack(3, n))

Python

import sys

def ack(m, n):
    if m == 0:
        return n + 1
    if n == 0:
        return ack(m - 1, 1)
    return ack(m - 1, ack(m, n - 1))

n = int(sys.argv[1]) if len(sys.argv) > 1 else 6
print(ack(3, n))

quicksort 2K Zust 55us · Lua 931us · Python ERR

规模2,000 Zust55us Lua931us PythonERR Lua / Zust16.9x Python / Zust-

说明Python 版本次未跑通，不计入几何平均。Lua 有有效数据，仍单独展示 Lua / Zust。

Zust

pub fn bench<N>() {
    let arr: [i64; N] = [0i64; N];
    for i in 0i64..N {
        let seed = i * 6364136223846793005i64 + 1i64;
        arr[i] = seed;
    }

    let lows: [i64; N] = [0i64; N];
    let highs: [i64; N] = [0i64; N];
    let top = 0i64;
    lows[top] = 0i64;
    highs[top] = N - 1;

    while top >= 0i64 {
        let low = lows[top];
        let high = highs[top];
        top -= 1i64;

        while low < high {
            let pivot = arr[high];
            let i = low - 1i64;
            for j in low..high {
                if arr[j] <= pivot {
                    i += 1i64;
                    let tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }

            let pi = i + 1i64;
            let tmp = arr[pi];
            arr[pi] = arr[high];
            arr[high] = tmp;

            if pi - low < high - pi {
                if pi + 1i64 < high {
                    top += 1i64;
                    lows[top] = pi + 1i64;
                    highs[top] = high;
                }
                high = pi - 1i64;
            } else {
                if low < pi - 1i64 {
                    top += 1i64;
                    lows[top] = low;
                    highs[top] = pi - 1i64;
                }
                low = pi + 1i64;
            }
        }
    }

    let sum = 0i64;
    for idx in 0i64..N {
        sum = sum + arr[idx];
    }
    sum
}

Lua

local function partition(arr, low, high)
    local pivot = arr[high + 1]
    local i = low
    for j = low, high - 1 do
        if arr[j + 1] <= pivot then
            arr[i + 1], arr[j + 1] = arr[j + 1], arr[i + 1]
            i = i + 1
        end
    end
    arr[i + 1], arr[high + 1] = arr[high + 1], arr[i + 1]
    return i
end

local function quicksort(arr, low, high)
    if low < high then
        local pi = partition(arr, low, high)
        quicksort(arr, low, pi - 1)
        quicksort(arr, pi + 1, high)
    end
end

local n = tonumber(arg[1])
local arr = {}
for i = 0, n - 1 do
    arr[i + 1] = i * 6364136223846793005 + 1
end
quicksort(arr, 0, n - 1)
local sum = 0
for i = 0, n - 1 do
    sum = sum + arr[i + 1]
end
print(sum)

Python

import sys

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

def quicksort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quicksort(arr, low, pi - 1)
        quicksort(arr, pi + 1, high)

n = int(sys.argv[1])
arr = [i * 6364136223846793005 + 1 for i in range(n)]
quicksort(arr, 0, n - 1)
print(sum(arr))

matrix mul 40x40 x50 Zust 3ms · Lua 89ms · Python 274ms

规模50 Zust3ms Lua89ms Python274ms Lua / Zust32.9x Python / Zust101.4x

Zust

pub fn bench(n: i64) {
    let sz = 40i64;
    let a: [f64; 1600] = [0.0f64; 1600];
    let b: [f64; 1600] = [0.0f64; 1600];
    let c: [f64; 1600] = [0.0f64; 1600];
    for i in 0..sz {
        for j in 0..sz {
            a[i * sz + j] = ((i * j) as f64) * 0.01f64;
            b[i * sz + j] = ((i + j) as f64) * 0.005f64;
        }
    }
    for _ in 0..n {
        for i in 0..sz {
            for k in 0..sz {
                let aik = a[i * sz + k];
                for j in 0..sz {
                    c[i * sz + j] = c[i * sz + j] + aik * b[k * sz + j];
                }
            }
        }
    }
    c[0] as i64
}

Lua

local n = tonumber(arg[1])
local sz = 40
local a, b, c = {}, {}, {}
for i = 0, sz - 1 do
    for j = 0, sz - 1 do
        a[i * sz + j + 1] = (i * j) * 0.01
        b[i * sz + j + 1] = (i + j) * 0.005
    end
end
for i = 0, sz - 1 do
    for j = 0, sz - 1 do
        c[i * sz + j + 1] = 0.0
    end
end
for _ = 1, n do
    for i = 0, sz - 1 do
        for k = 0, sz - 1 do
            local aik = a[i * sz + k + 1]
            for j = 0, sz - 1 do
                c[i * sz + j + 1] = c[i * sz + j + 1] + aik * b[k * sz + j + 1]
            end
        end
    end
end
print(math.floor(c[1]))

Python

import sys
n = int(sys.argv[1])
sz = 40
sz2 = sz * sz
a = [0.0] * sz2
b = [0.0] * sz2
c = [0.0] * sz2
for i in range(sz):
    for j in range(sz):
        a[i * sz + j] = (i * j) * 0.01
        b[i * sz + j] = (i + j) * 0.005
for _ in range(n):
    for i in range(sz):
        for k in range(sz):
            aik = a[i * sz + k]
            base = i * sz
            bk_base = k * sz
            for j in range(sz):
                c[base + j] += aik * b[bk_base + j]
print(int(c[0]))

binary search 10K Zust 702us · Lua 10ms · Python 14ms

规模10,000 Zust702us Lua10ms Python14ms Lua / Zust14.1x Python / Zust19.8x

Zust

pub fn bench<N>() {
    let arr: [i64; N] = [0i64; N];
    for i in 0i64..N {
        arr[i] = i * 2;
    }
    let sum = 0i64;
    for target in 0i64..N {
        let low = 0i64;
        let high = N - 1;
        let found = -1i64;
        while low <= high {
            let mid = (low + high) / 2;
            if arr[mid] == target * 2 {
                found = mid;
                low = high + 1;
            } else {
                if arr[mid] < target * 2 {
                    low = mid + 1;
                } else {
                    high = mid - 1;
                }
            }
        }
        sum = sum + found;
    }
    sum
}

Lua

local n = tonumber(arg[1])
local arr = {}
for i = 0, n - 1 do
    arr[i + 1] = i * 2
end
local sum = 0
for target = 0, n - 1 do
    local low, high = 0, n - 1
    local found = -1
    while low <= high do
        local mid = math.floor((low + high) / 2)
        if arr[mid + 1] == target * 2 then
            found = mid
            low = high + 1
        elseif arr[mid + 1] < target * 2 then
            low = mid + 1
        else
            high = mid - 1
        end
    end
    sum = sum + found
end
print(sum)

Python

import sys
n = int(sys.argv[1])
arr = [i * 2 for i in range(n)]
total = 0
for target in range(n):
    low, high = 0, n - 1
    found = -1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target * 2:
            found = mid
            low = high + 1
        elif arr[mid] < target * 2:
            low = mid + 1
        else:
            high = mid - 1
    total += found
print(total)

random LCG 50M Zust 62ms · Lua 422ms · Python 6.6s

规模50,000,000 Zust62ms Lua422ms Python6.6s Lua / Zust6.8x Python / Zust106.6x

Zust

pub fn bench(n: i64) {
    let seed = 12345i64;
    let total = 0i64;
    for _ in 0..n {
        seed = seed * 1103515245i64 + 12345i64;
        seed = seed & 0x7fffffff;
        total = total + (seed & 0xff);
    }
    total
}

Lua

local n = tonumber(arg[1])
local seed = 12345
local total = 0
for _ = 1, n do
    seed = seed * 1103515245 + 12345
    seed = seed & 0x7fffffff
    total = total + (seed & 0xff)
end
print(total)

Python

import sys
n = int(sys.argv[1])
seed = 12345
total = 0
for _ in range(n):
    seed = seed * 1103515245 + 12345
    seed = seed & 0x7fffffff
    total += seed & 0xff
print(total)

array reverse 1K x10K Zust 9ms · Lua 139ms · Python 1.2s

规模10,000 Zust9ms Lua139ms Python1.2s Lua / Zust15.7x Python / Zust130.8x

Zust

pub fn bench(n: i64) {
    let arr: [i64; 1000] = [0i64; 1000];
    for i in 0..1000 {
        arr[i] = i;
    }
    let total = 0i64;
    for _ in 0..n {
        let half = 500i64;
        for i in 0..half {
            let j = 999i64 - i;
            let tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
        for i in 0..1000 {
            total = total + arr[i];
        }
    }
    total
}

Lua

local n = tonumber(arg[1])
local arr = {}
for i = 0, 999 do
    arr[i + 1] = i
end
local total = 0
for _ = 1, n do
    local half = 500
    for i = 0, half - 1 do
        local j = 999 - i + 1
        local tmp = arr[i + 1]
        arr[i + 1] = arr[j]
        arr[j] = tmp
    end
    for i = 0, 999 do
        total = total + arr[i + 1]
    end
end
print(total)

Python

import sys
n = int(sys.argv[1])
arr = list(range(1000))
total = 0
half = 500
for _ in range(n):
    for i in range(half):
        j = 999 - i
        arr[i], arr[j] = arr[j], arr[i]
    for i in range(1000):
        total += arr[i]
print(total)