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: Verified baseline member of a 2-capsule Equivalence Class; useful as a reference or cross-validation peer. Multi-step compute kernel (6901067/100000 cyc/op); best used at frame, block, or batch aggregation boundaries.

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

Hardware _rdtsc: 6901067/100000 cycles/op
Latency: 1725883/80000 ns/op
Throughput: 80000000/1725883 ops/us
Compiled ELF64 .text: 496 B (141 x86_64 insns)
C64 64KB RAM Budget: 1257/65536 (1257 B source)
Ternary Vote: + (score 1) | Salience: 21455/234
Pure-Rust Capsule Source Code (1257 B)
/// Q16.16 exponential decay by closed-form [3/3] Padé, integer-only.
///
/// `out = variance * exp(-elapsed / half_life)`, elapsed and half_life in
/// world ticks, amplitude Q16.16. Total for every i64 input.
pub fn decay_pade(variance_q16: i64, elapsed: i64, half_life_ticks: i64) -> i64 {
    const RATE_ONE: i128 = 1 << 16;
    const INV_LN2_Q16: i128 = 94548;
    const LN2_Q16: i128 = 45426;
    const PADE_X_MAX: i128 = 40 << 16;

    if half_life_ticks <= 0 {
        return 0;
    }
    if elapsed <= 0 {
        return variance_q16;
    }

    let mut x = (elapsed as i128) << 16;
    x /= half_life_ticks as i128;
    if x > PADE_X_MAX {
        return 0;
    }
    if x <= 0 {
        return variance_q16;
    }

    let k = (x * INV_LN2_Q16) >> 32;
    let r = x - k * LN2_Q16;
    let r2 = (r * r) >> 16;
    let r3 = (r2 * r) >> 16;
    let num = 120 * RATE_ONE - 60 * r + 12 * r2 - r3;
    let den = 120 * RATE_ONE + 60 * r + 12 * r2 + r3;
    if den <= 0 || k >= 64 {
        return 0;
    }
    let amplitude = ((num << 16) / den) >> k;
    let out = (variance_q16 as i128 * amplitude) >> 16;
    if out > i64::MAX as i128 {
        i64::MAX
    } else if out < i64::MIN as i128 {
        i64::MIN
    } else {
        out as i64
    }
}
rustc -C opt-level=3 x86_64 Disassembly (496 B .text / 141 insns)
decay_pade:
    push    r15
    push    r14
    push    r13
    push    r12
    push    rbx
    test    rdx, rdx
    jle    .LBB7_5
    test    rsi, rsi
    jle    .LBB7_6
    mov    r15, rdi
    mov    r14, rsi
    shr    r14, 48
    shl    rsi, 16
    xor    ebx, ebx
    mov    r12, rsi
    mov    rdi, rsi
    mov    rsi, r14
    mov    r13, rdx
    xor    ecx, ecx
    call    qword ptr [rip + __udivti3@GOTPCREL]
    mov    ecx, 2621440
    cmp    rcx, rax
    mov    ecx, 0
    sbb    rcx, rdx
    jb    .LBB7_7
    cmp    r12, r13
    sbb    r14, 0
    jae    .LBB7_8
    mov    rbx, r15
    jmp    .LBB7_7
.LBB7_6:
    mov    rbx, rdi
    jmp    .LBB7_7
.LBB7_8:
    mov    ecx, 94548
    mov    rsi, rax
    mov    rdi, rdx
    mul    rcx
    mov    rbx, rax
    imul    r8, rdi, 94548
    add    r8, rdx
    shrd    rbx, r8, 32
    shr    r8, 32
    mov    rcx, -45426
    mov    rax, rbx
    mul    rcx
    mov    rcx, rax
    sub    rdx, rbx
    imul    r8, r8, -45426
    add    r8, rdx
    add    rcx, rsi
    adc    r8, rdi
    mov    r14, rcx
    mov    rax, rcx
    mul    rcx
    mov    rsi, rax
    imul    r14, r8
    add    r14, r14
    add    r14, rdx
    shrd    rsi, r14, 16
    shr    r14, 16
    mov    rdi, rsi
    imul    rdi, r8
    mov    rax, rsi
    mul    rcx
    mov    r10, r14
    imul    r10, rcx
    add    r10, rdx
    add    r10, rdi
    mov    r11, r10
    sar    r11, 16
    shld    r10, rax, 48
    mov    edx, 60
    mov    rax, rcx
    mul    rdx
    mov    rdi, rax
    mov    r9, rdx
    imul    rax, r8, 60
    add    r9, rax
    shl    r14, 2
    lea    rcx, [r14 + 2*r14]
    mov    edx, 12
    mov    rax, rsi
    mul    rdx
    add    rax, 7864320
    adc    rdx, rcx
    mov    r8, rax
    add    r8, rdi
    mov    rcx, rdx
    adc    rcx, r9
    add    r8, r10
    adc    rcx, r11
    cmp    r8, 1
    mov    rsi, rcx
    sbb    rsi, 0
    jl    .LBB7_5
    add    rdi, r10
    adc    r9, r11
    sub    rax, rdi
    sbb    rdx, r9
    shld    rdx, rax, 16
    shl    rax, 16
    mov    rdi, rax
    mov    rsi, rdx
    mov    rdx, r8
    call    qword ptr [rip + __divti3@GOTPCREL]
    mov    rsi, rdx
    mov    ecx, ebx
    shrd    rax, rdx, cl
    sar    rdx, cl
    sar    rsi, 63
    test    bl, 64
    cmove    rsi, rdx
    cmovne    rax, rdx
    mov    rcx, r15
    sar    rcx, 63
    imul    rcx, rax
    mul    r15
    imul    rsi, r15
    add    rsi, rdx
    add    rsi, rcx
    mov    rcx, rsi
    sar    rcx, 16
    shld    rsi, rax, 48
    movabs    rbx, 9223372036854775807
    xor    eax, eax
    cmp    rbx, rsi
    sbb    rax, rcx
    jl    .LBB7_7
    movabs    rbx, -9223372036854775808
    cmp    rbx, rsi
    mov    rax, -1
    sbb    rax, rcx
    cmovl    rbx, rsi
    jmp    .LBB7_7
.LBB7_5:
    xor    ebx, ebx
.LBB7_7:
    mov    rax, rbx
    pop    rbx
    pop    r12
    pop    r13
    pop    r14
    pop    r15
    ret

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

Global RankCapsule & DomainHardware _rdtscLatencyThroughputELF .textTernary VoteAuthor Aye
#1671decay_pade
domain: decay | id: 42764f8a71d071b2c7c180772068caab
2740867/100000 cyc/op3427541/400000 ns/op400000000/3427541 ops/us606 B .text (172 insns)+ (1)aye::Peter+Omni(0+1)::aarch64 @ 432Hz
#1713decay_pade (THIS CAPSULE)
domain: decay | id: 8c57c8977eaecf67d331b469f2dedf27
6901067/100000 cyc/op1725883/80000 ns/op80000000/1725883 ops/us496 B .text (141 insns)+ (1)aye::Peter+Omni(0+1)::aarch64 @ 432Hz