Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.2

0.1.2 / tests / engine / lanes_binary_checks.lucb

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

test "add in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.add, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] + b_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.add, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] + b_f64[i]))
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.add, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] + b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.add, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] + b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.add, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] + b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.add, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] + b_u64[i]))

test "sub in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.sub, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] - b_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.sub, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] - b_f64[i]))
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.sub, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] - b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.sub, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] - b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.sub, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] - b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.sub, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] - b_u64[i]))

test "mul in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.mul, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] * b_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.mul, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] * b_f64[i]))
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.mul, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] * b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.mul, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] * b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.mul, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] * b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.mul, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] * b_u64[i]))

test "div in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.div, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], a_f32[i] / b_f32[i]))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.div, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], a_f64[i] / b_f64[i]))

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

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

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

test "sadd in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.sadd, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] +| b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.sadd, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] +| b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.sadd, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] +| b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.sadd, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] +| b_u64[i]))

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

test "smul in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.smul, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] *| b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.smul, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] *| b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.smul, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] *| b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.smul, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] *| b_u64[i]))

test "idiv in every width":
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.idiv, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] // b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.idiv, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] // b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.idiv, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] // b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.idiv, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] // b_u64[i]))

test "rem in every width":
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.rem, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] % b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, -4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.rem, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] % b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.rem, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] % b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.rem, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] % b_u64[i]))

test "min in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.min, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.min(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.min, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.min(a_f64[i], b_f64[i])))
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.min, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] if a_i32[i] < b_i32[i] else b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.min, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] if a_i64[i] < b_i64[i] else b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.min, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] if a_u32[i] < b_u32[i] else b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.min, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] if a_u64[i] < b_u64[i] else b_u64[i]))

test "max in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.max, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.max(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.max, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.max(a_f64[i], b_f64[i])))
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.max, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] if a_i32[i] > b_i32[i] else b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.max, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] if a_i64[i] > b_i64[i] else b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.max, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] if a_u32[i] > b_u32[i] else b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.max, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] if a_u64[i] > b_u64[i] else b_u64[i]))

test "band in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.band, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] & b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.band, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] & b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.band, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] & b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.band, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] & b_u64[i]))
    let a_mask: u8[8] = [0, 1, 0, 1, 1, 0, 1, 0]
    let b_mask: u8[8] = [0, 0, 1, 1, 0, 1, 1, 1]
    var d_mask: u8[8]
    assert(try binary_case(.band, .mask, a_mask, b_mask, d_mask, .mask) == none)
    for i in 0..<8: assert(d_mask[i] == (a_mask[i] & b_mask[i]))

test "bor in every width":
    let a_i32: i32[8] = [2147483647, (-2147483648), -1, 0, 5, 2147483647, (-2147483648), 3]
    let b_i32: i32[8] = [1, -1, (-2147483648), 2147483647, 7, 2147483647, (-2147483648), 3]
    var d_i32: i32[8]
    assert(try binary_case(.bor, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] | b_i32[i]))
    let a_i64: i64[8] = [9223372036854775807, (-9223372036854775808), -1, 0, 5, 9223372036854775807, (-9223372036854775808), 3]
    let b_i64: i64[8] = [1, -1, (-9223372036854775808), 9223372036854775807, 7, 9223372036854775807, (-9223372036854775808), 3]
    var d_i64: i64[8]
    assert(try binary_case(.bor, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] | b_i64[i]))
    let a_u32: u32[8] = [4294967295, 0, 1, 5, 4294967295, 2, 3, 4]
    let b_u32: u32[8] = [1, 1, 4294967295, 7, 4294967295, 3, 4, 5]
    var d_u32: u32[8]
    assert(try binary_case(.bor, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] | b_u32[i]))
    let a_u64: u64[8] = [18446744073709551615, 0, 1, 5, 18446744073709551615, 2, 3, 4]
    let b_u64: u64[8] = [1, 1, 18446744073709551615, 7, 18446744073709551615, 3, 4, 5]
    var d_u64: u64[8]
    assert(try binary_case(.bor, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] | b_u64[i]))
    let a_mask: u8[8] = [0, 1, 0, 1, 1, 0, 1, 0]
    let b_mask: u8[8] = [0, 0, 1, 1, 0, 1, 1, 1]
    var d_mask: u8[8]
    assert(try binary_case(.bor, .mask, a_mask, b_mask, d_mask, .mask) == none)
    for i in 0..<8: assert(d_mask[i] == (a_mask[i] | b_mask[i]))

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

test "shl in every width":
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.shl, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] << b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.shl, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] << b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.shl, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] << b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.shl, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] << b_u64[i]))

test "shr in every width":
    let a_i32: i32[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i32: i32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_i32: i32[8]
    assert(try binary_case(.shr, .i32, a_i32, b_i32, d_i32, .i32) == none)
    for i in 0..<8: assert(d_i32[i] == (a_i32[i] >> b_i32[i]))
    let a_i64: i64[8] = [0, 1, -7, 100, -1000, 12345, 77, -2]
    let b_i64: i64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_i64: i64[8]
    assert(try binary_case(.shr, .i64, a_i64, b_i64, d_i64, .i64) == none)
    for i in 0..<8: assert(d_i64[i] == (a_i64[i] >> b_i64[i]))
    let a_u32: u32[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u32: u32[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u32: u32[8]
    assert(try binary_case(.shr, .u32, a_u32, b_u32, d_u32, .u32) == none)
    for i in 0..<8: assert(d_u32[i] == (a_u32[i] >> b_u32[i]))
    let a_u64: u64[8] = [10, 11, 70, 100, 1000, 12345, 77, 9]
    let b_u64: u64[8] = [1, 2, 3, 4, 5, 6, 7, 8]
    var d_u64: u64[8]
    assert(try binary_case(.shr, .u64, a_u64, b_u64, d_u64, .u64) == none)
    for i in 0..<8: assert(d_u64[i] == (a_u64[i] >> b_u64[i]))

test "pow in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.pow, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.pow(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.pow, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.pow(a_f64[i], b_f64[i])))

test "atan2 in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.atan2, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.atan2(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.atan2, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.atan2(a_f64[i], b_f64[i])))

test "fmod in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.fmod, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.mod(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.fmod, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.mod(a_f64[i], b_f64[i])))

test "hypot in every width":
    let a_f32: f32[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f32: f32[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f32: f32[8]
    assert(try binary_case(.hypot, .f32, a_f32, b_f32, d_f32, .f32) == none)
    for i in 0..<8: assert(same_f32(d_f32[i], math32.hypot(a_f32[i], b_f32[i])))
    let a_f64: f64[8] = [0.0, -0.0, 1.5, -2.25, 100.0, 0.001, 7.0, -3.5]
    let b_f64: f64[8] = [1.0, 2.0, -0.5, 4.0, -8.0, 0.25, 3.0, 0.5]
    var d_f64: f64[8]
    assert(try binary_case(.hypot, .f64, a_f64, b_f64, d_f64, .f64) == none)
    for i in 0..<8: assert(same_f64(d_f64[i], math.hypot(a_f64[i], b_f64[i])))