Best Use & Engineering Application Guide

Engineering Category: Deterministic Sovereign Compute Kernel

Best Use in Production: Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.

When to Select This Capsule: Sole canonical implementation for its 64-vector functional equivalence class. Low-latency L1-resident kernel (394233/25000 cyc/op); well-suited for high-frequency pipeline stages.

Snap-Circuit Wiring Role: Specialized Multi-Pin Stage `(i32,i32,i32,i32)->[i32;8]` — wire matching input pins via `snap_dag` or `snap_pipeline`.

Hardware _rdtsc: 394233/25000 cycles/op
Latency: 427801/100000 ns/op
Throughput: 100000000/427801 ops/us
Compiled ELF64 .text: 270 B (80 x86_64 insns)
C64 64KB RAM Budget: 967/65536 (967 B source)
Ternary Vote: + (score 1) | Salience: 7695565/84456
Pure-Rust Capsule Source Code (967 B)
pub const fn step_babbage_cubic_8x_i32(p0: i32, p1: i32, p2: i32, p3: i32) -> [i32; 8] {
    let x0 = p0 as i64;
    let x1 = p1 as i64;
    let x2 = p2 as i64;
    let x3 = p3 as i64;

    // Catmull-Rom polynomial coefficients scaled by 2 * 512 = 1024 (t = k/8, k=0..7)
    let c0 = 2 * x1;
    let c1 = x2 - x0;
    let c2 = 2 * x0 - 5 * x1 + 4 * x2 - x3;
    let c3 = -x0 + 3 * x1 - 3 * x2 + x3;

    // Evaluate at k = 0, 1, 2, 3 to seed Babbage forward differences (d1, d2, d3)
    let f0 = c0 * 512;
    let f1 = c0 * 512 + c1 * 64 + c2 * 8 + c3;
    let f2 = c0 * 512 + c1 * 128 + c2 * 32 + c3 * 8;
    let f3 = c0 * 512 + c1 * 192 + c2 * 72 + c3 * 27;

    let mut y = f0;
    let mut d1 = f1 - f0;
    let mut d2 = (f2 - f1) - d1;
    let d3 = f3 - 3 * f2 + 3 * f1 - f0;

    let mut out = [0i32; 8];
    let mut k = 0;
    while k < 8 {
        out[k] = (y >> 10) as i32;
        y += d1;
        d1 += d2;
        d2 += d3;
        k += 1;
    }
    out
}
rustc -C opt-level=3 x86_64 Disassembly (270 B .text / 80 insns)
step_babbage_cubic_8x_i32:
    mov    rax, rdi
    movsxd    rsi, esi
    movsxd    r9, edx
    movsxd    rdx, ecx
    movsxd    rcx, r8d
    lea    r8, [r9 + 4*r9]
    lea    r10, [4*rdx]
    mov    rdi, r9
    mov    dword ptr [rax], r9d
    sub    r9, rdx
    sub    rdx, rsi
    lea    r10, [r10 + 2*rsi]
    sub    r10, r8
    sub    r10, rcx
    lea    r8, [r9 + 2*r9]
    sub    rcx, rsi
    add    rcx, r8
    shl    rdi, 10
    mov    rsi, rdx
    shl    rsi, 6
    add    rsi, rdi
    add    rsi, rcx
    lea    r8, [rsi + 8*r10]
    lea    rsi, [rdx + 2*rdx]
    shl    rdx, 7
    add    rdx, rdi
    lea    r9, [r10 + 8*r10]
    shl    r10, 5
    add    r10, rdx
    lea    rdx, [r10 + 8*rcx]
    shl    rsi, 6
    lea    rcx, [rcx + 8*rcx]
    lea    r10, [rcx + 2*rcx]
    mov    r11, r8
    sub    r11, rdi
    add    r11, r8
    mov    rcx, rdx
    sub    rcx, r11
    mov    rdi, r8
    sub    rdi, rdx
    lea    r11, [rdi + 2*rdi]
    lea    rdi, [rsi + 8*r9]
    add    rdi, r10
    add    rdi, r11
    mov    rsi, rdx
    sub    rsi, r8
    add    rcx, rdi
    shr    r8, 10
    mov    dword ptr [rax + 4], r8d
    add    rsi, rcx
    add    rcx, rdi
    mov    r8, rdx
    shr    r8, 10
    mov    dword ptr [rax + 8], r8d
    add    rdx, rsi
    add    rsi, rcx
    add    rcx, rdi
    mov    r8, rdx
    shr    r8, 10
    mov    dword ptr [rax + 12], r8d
    add    rdx, rsi
    add    rsi, rcx
    add    rcx, rdi
    mov    r8, rdx
    shr    r8, 10
    mov    dword ptr [rax + 16], r8d
    add    rdx, rsi
    add    rsi, rcx
    add    rcx, rdi
    mov    rdi, rdx
    shr    rdi, 10
    mov    dword ptr [rax + 20], edi
    add    rdx, rsi
    add    rcx, rsi
    add    rcx, rdx
    shr    rdx, 10
    mov    dword ptr [rax + 24], edx
    shr    rcx, 10
    mov    dword ptr [rax + 28], ecx
    ret

Head-to-Head Functional Equivalence Class Peers (1 Implementation(s) Matching 64 Test Vectors)

Global RankCapsule & DomainHardware _rdtscLatencyThroughputELF .textTernary VoteAuthor Aye
#797step_babbage_cubic_8x_i32 (THIS CAPSULE)
domain: ayecast-x86_64 | id: 6d1c05f66367a8220369f5ed890953ef
394233/25000 cyc/op427801/100000 ns/op100000000/427801 ops/us270 B .text (80 insns)+ (1)aye::Hue+Gemini(0+1)::x86_64 @ 432Hz