Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.0

0.1.0 / tests / engine / lanes_unary_checks.lucb

# Generated by tools/lanes.py from its tables; edit those, not this file.
# Unit checks of every unary and classifying operation in every width.

test "neg in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.neg, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], -a_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.neg, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], -a_f64[i]))
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    var d_i32: i32[8]
    assert(try unary_case(.neg, .i32, a_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (-a_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    var d_i64: i64[8]
    assert(try unary_case(.neg, .i64, a_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (-a_i64[i]))

test "wneg in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try unary_case(.wneg, .i32, a_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (-%a_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try unary_case(.wneg, .i64, a_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (-%a_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    var d_u32: u32[8]
    assert(try unary_case(.wneg, .u32, a_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (-%a_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    var d_u64: u64[8]
    assert(try unary_case(.wneg, .u64, a_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (-%a_u64[i]))

test "abs in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.abs, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.abs(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.abs, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.abs(a_f64[i])))
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    var d_i32: i32[8]
    assert(try unary_case(.abs, .i32, a_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] if a_i32[i] >= 0 else -a_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    var d_i64: i64[8]
    assert(try unary_case(.abs, .i64, a_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] if a_i64[i] >= 0 else -a_i64[i]))

test "bnot in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try unary_case(.bnot, .i32, a_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (~a_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try unary_case(.bnot, .i64, a_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (~a_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    var d_u32: u32[8]
    assert(try unary_case(.bnot, .u32, a_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (~a_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    var d_u64: u64[8]
    assert(try unary_case(.bnot, .u64, a_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (~a_u64[i]))
    let a_mask: u8[8] = [0, 1, 0, 1, 1, 0, 1, 0]
    var d_mask: u8[8]
    assert(try unary_case(.bnot, .mask, a_mask, d_mask, .mask) == none)
    for i in 0..<8: assert(d_mask[i] == (a_mask[i] ^ 1))

test "sqrt in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.sqrt, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.sqrt(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.sqrt, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.sqrt(a_f64[i])))

test "cbrt in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.cbrt, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.cbrt(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.cbrt, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.cbrt(a_f64[i])))

test "exp in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.exp, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.exp(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.exp, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.exp(a_f64[i])))

test "exp2 in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.exp2, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.exp2(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.exp2, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.exp2(a_f64[i])))

test "log in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.log, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.log(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.log, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.log(a_f64[i])))

test "log2 in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.log2, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.log2(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.log2, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.log2(a_f64[i])))

test "log10 in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.log10, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.log10(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.log10, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.log10(a_f64[i])))

test "sin in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.sin, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.sin(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.sin, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.sin(a_f64[i])))

test "cos in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.cos, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.cos(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.cos, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.cos(a_f64[i])))

test "tan in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.tan, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.tan(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.tan, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.tan(a_f64[i])))

test "asin in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.asin, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.asin(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.asin, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.asin(a_f64[i])))

test "acos in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.acos, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.acos(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.acos, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.acos(a_f64[i])))

test "atan in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.atan, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.atan(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.atan, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.atan(a_f64[i])))

test "sinh in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.sinh, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.sinh(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.sinh, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.sinh(a_f64[i])))

test "cosh in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.cosh, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.cosh(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.cosh, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.cosh(a_f64[i])))

test "tanh in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.tanh, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.tanh(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.tanh, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.tanh(a_f64[i])))

test "floor in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.floor, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.floor(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.floor, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.floor(a_f64[i])))

test "ceil in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.ceil, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.ceil(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.ceil, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.ceil(a_f64[i])))

test "round in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.round, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.round(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.round, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.round(a_f64[i])))

test "trunc in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.trunc, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.trunc(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.trunc, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.trunc(a_f64[i])))

test "sign in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.sign, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.sign(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.sign, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.sign(a_f64[i])))

test "frac in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.frac, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] - math32.floor(a_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.frac, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] - math.floor(a_f64[i])))

test "degrees in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.degrees, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] * (180.0 / math32.pi)))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.degrees, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] * (180.0 / math.pi)))

test "radians in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: f32[8]
    assert(try unary_case(.radians, .f32, a_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] * (math32.pi / 180.0)))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: f64[8]
    assert(try unary_case(.radians, .f64, a_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] * (math.pi / 180.0)))

test "isnan in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: u8[8]
    assert(try unary_case(.isnan, .f32, a_f32, d_f32, .mask) == none)
    for i in 0..<8: assert(d_f32[i] == (u8)math32.is_nan(a_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: u8[8]
    assert(try unary_case(.isnan, .f64, a_f64, d_f64, .mask) == none)
    for i in 0..<8: assert(d_f64[i] == (u8)math.is_nan(a_f64[i]))

test "isinf in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: u8[8]
    assert(try unary_case(.isinf, .f32, a_f32, d_f32, .mask) == none)
    for i in 0..<8: assert(d_f32[i] == (u8)math32.is_infinite(a_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: u8[8]
    assert(try unary_case(.isinf, .f64, a_f64, d_f64, .mask) == none)
    for i in 0..<8: assert(d_f64[i] == (u8)math.is_infinite(a_f64[i]))

test "isfinite in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f32: u8[8]
    assert(try unary_case(.isfinite, .f32, a_f32, d_f32, .mask) == none)
    for i in 0..<8: assert(d_f32[i] == (u8)math32.is_finite(a_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    var d_f64: u8[8]
    assert(try unary_case(.isfinite, .f64, a_f64, d_f64, .mask) == none)
    for i in 0..<8: assert(d_f64[i] == (u8)math.is_finite(a_f64[i]))