Zust vs Lua vs Python

NoteThe Python version did not complete in this run and is excluded from the geometric mean. Lua has valid data and is still shown against 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
}

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)

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))

NoteThe Python version did not complete in this run and is excluded from the geometric mean. Lua has valid data and is still shown against 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
}

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)

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))