From 037c047f2cb5c962335898c85af2ecef8045027f Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Fri, 26 Dec 2025 11:53:19 -0500 Subject: [PATCH] simd/archsimd: add more tests for Extend operations The operations that extend only low elements, ExtendLoNTo..., are not yet included. Change-Id: I93168889b92c56720344b443c1cff238f8cc096a Reviewed-on: https://go-review.googlesource.com/c/go/+/732661 Reviewed-by: David Chase LUCI-TryBot-Result: Go LUCI --- src/simd/archsimd/_gen/tmplgen/main.go | 20 +- .../internal/simd_test/helpers_test.go | 5 +- .../internal/simd_test/unary_helpers_test.go | 2333 +++++++++++++++-- .../archsimd/internal/simd_test/unary_test.go | 28 +- 4 files changed, 2083 insertions(+), 303 deletions(-) diff --git a/src/simd/archsimd/_gen/tmplgen/main.go b/src/simd/archsimd/_gen/tmplgen/main.go index 52ac10af1d..a54d462d01 100644 --- a/src/simd/archsimd/_gen/tmplgen/main.go +++ b/src/simd/archsimd/_gen/tmplgen/main.go @@ -372,9 +372,21 @@ func test{{.VType}}ConvertTo{{.OEType}}(t *testing.T, f func(x archsimd.{{.VType } `) -var unaryToInt32 = convertTemplate.target("int", 32) -var unaryToUint32 = convertTemplate.target("uint", 32) -var unaryToUint16 = convertTemplate.target("uint", 16) +var ( + // templates and shapes for conversion. + // TODO: this includes shapes where in and out have the same element type, + // which are not needed. + unaryToInt8 = convertTemplate.target("int", 8) + unaryToUint8 = convertTemplate.target("uint", 8) + unaryToInt16 = convertTemplate.target("int", 16) + unaryToUint16 = convertTemplate.target("uint", 16) + unaryToInt32 = convertTemplate.target("int", 32) + unaryToUint32 = convertTemplate.target("uint", 32) + unaryToInt64 = convertTemplate.target("int", 64) + unaryToUint64 = convertTemplate.target("uint", 64) + unaryToFloat32 = convertTemplate.target("float", 32) + unaryToFloat64 = convertTemplate.target("float", 64) +) var binaryTemplate = templateOf("binary_helpers", ` // test{{.VType}}Binary tests the simd binary method f against the expected behavior generated by want @@ -862,7 +874,7 @@ func main() { one(*ush, unsafePrologue, unsafePATemplate) } if *uh != "" { - one(*uh, curryTestPrologue("unary simd methods"), unaryTemplate, unaryToInt32, unaryToUint32, unaryToUint16, unaryFlakyTemplate) + one(*uh, curryTestPrologue("unary simd methods"), unaryTemplate, unaryToInt8, unaryToUint8, unaryToInt16, unaryToUint16, unaryToInt32, unaryToUint32, unaryToInt64, unaryToUint64, unaryToFloat32, unaryToFloat64, unaryFlakyTemplate) } if *bh != "" { one(*bh, curryTestPrologue("binary simd methods"), binaryTemplate) diff --git a/src/simd/archsimd/internal/simd_test/helpers_test.go b/src/simd/archsimd/internal/simd_test/helpers_test.go index b9d5098dba..ccad70de92 100644 --- a/src/simd/archsimd/internal/simd_test/helpers_test.go +++ b/src/simd/archsimd/internal/simd_test/helpers_test.go @@ -126,8 +126,9 @@ func map1[T, U any](elem func(x T) U) func(x []T) []U { } } -// map1 returns a function that returns the slice of the results of applying -// comparison function elem to the respective elements of its two slice inputs. +// mapCompare returns a function that returns the slice of the results of applying +// comparison function elem to the respective elements of its two slice inputs, +// and returns -1 if the comparison is true, 0 otherwise. func mapCompare[T number](elem func(x, y T) bool) func(x, y []T) []int64 { return func(x, y []T) []int64 { s := make([]int64, len(x)) diff --git a/src/simd/archsimd/internal/simd_test/unary_helpers_test.go b/src/simd/archsimd/internal/simd_test/unary_helpers_test.go index 1601e32486..626a0971d7 100644 --- a/src/simd/archsimd/internal/simd_test/unary_helpers_test.go +++ b/src/simd/archsimd/internal/simd_test/unary_helpers_test.go @@ -433,915 +433,2670 @@ func testFloat64x8Unary(t *testing.T, f func(_ archsimd.Float64x8) archsimd.Floa }) } +// testInt8x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x16ConvertToInt8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int8x16, want func(x []int8) []int8) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int8x16, want func(x []uint8) []int8) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x32ConvertToInt8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int8x32, want func(x []int8) []int8) { + n := 32 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x32Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToInt8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int8x16, want func(x []int16) []int8) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x32ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int8x32, want func(x []uint8) []int8) { + n := 32 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x32Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int8x16, want func(x []uint16) []int8) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x64ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x64ConvertToInt8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int8x64, want func(x []int8) []int8) { + n := 64 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x64Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x32ConvertToInt8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int8x32, want func(x []int16) []int8) { + n := 32 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x32Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToInt8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int8x16, want func(x []int32) []int8) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x64ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x64ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int8x64, want func(x []uint8) []int8) { + n := 64 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x64Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x32ConvertToInt8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int8x32, want func(x []uint16) []int8) { + n := 32 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x32Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int8x16, want func(x []uint32) []int8) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToInt8(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int8x16, want func(x []float32) []int8) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]int8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x16ConvertToUint8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint8x16, want func(x []int8) []uint8) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint8x16, want func(x []uint8) []uint8) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x32ConvertToUint8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint8x32, want func(x []int8) []uint8) { + n := 32 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x32Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToUint8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint8x16, want func(x []int16) []uint8) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x32ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint8x32, want func(x []uint8) []uint8) { + n := 32 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x32Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint8x16, want func(x []uint16) []uint8) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x64ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x64ConvertToUint8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint8x64, want func(x []int8) []uint8) { + n := 64 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x64Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x32ConvertToUint8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint8x32, want func(x []int16) []uint8) { + n := 32 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x32Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToUint8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint8x16, want func(x []int32) []uint8) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x64ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x64ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint8x64, want func(x []uint8) []uint8) { + n := 64 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x64Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x32ConvertToUint8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint8x32, want func(x []uint16) []uint8) { + n := 32 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x32Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint8x16, want func(x []uint32) []uint8) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToUint8(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint8x16, want func(x []float32) []uint8) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]uint8, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x16ConvertToInt16(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int16x16, want func(x []int8) []int16) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x8ConvertToInt16(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int16x8, want func(x []int16) []int16) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int16x16, want func(x []uint8) []int16) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int16x8, want func(x []uint16) []int16) { + n := 8 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x32ConvertToInt16(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int16x32, want func(x []int8) []int16) { + n := 32 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x32Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToInt16(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int16x16, want func(x []int16) []int16) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x8ConvertToInt16(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int16x8, want func(x []int32) []int16) { + n := 8 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x32ConvertToInt16(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int16x32, want func(x []uint8) []int16) { + n := 32 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x32Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int16x16, want func(x []uint16) []int16) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int16x8, want func(x []uint32) []int16) { + n := 8 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x8ConvertToInt16(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int16x8, want func(x []float32) []int16) { + n := 8 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x32ConvertToInt16(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int16x32, want func(x []int16) []int16) { + n := 32 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x32Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToInt16(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int16x16, want func(x []int32) []int16) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x8ConvertToInt16(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int16x8, want func(x []int64) []int16) { + n := 8 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x32ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int16x32, want func(x []uint16) []int16) { + n := 32 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x32Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int16x16, want func(x []uint32) []int16) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int16x8, want func(x []uint64) []int16) { + n := 8 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToInt16(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int16x16, want func(x []float32) []int16) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x8ConvertToInt16(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int16x8, want func(x []float64) []int16) { + n := 8 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x8Slice(x) + g := make([]int16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x16ConvertToUint16(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint16x16, want func(x []int8) []uint16) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x8ConvertToUint16(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint16x8, want func(x []int16) []uint16) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint16x16, want func(x []uint8) []uint16) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint16x8, want func(x []uint16) []uint16) { + n := 8 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x32ConvertToUint16(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint16x32, want func(x []int8) []uint16) { + n := 32 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x32Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToUint16(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint16x16, want func(x []int16) []uint16) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x8ConvertToUint16(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint16x8, want func(x []int32) []uint16) { + n := 8 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint16x32, want func(x []uint8) []uint16) { + n := 32 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x32Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint16x16, want func(x []uint16) []uint16) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint16x8, want func(x []uint32) []uint16) { + n := 8 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x8ConvertToUint16(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint16x8, want func(x []float32) []uint16) { + n := 8 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x32ConvertToUint16(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint16x32, want func(x []int16) []uint16) { + n := 32 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x32Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToUint16(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint16x16, want func(x []int32) []uint16) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x8ConvertToUint16(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint16x8, want func(x []int64) []uint16) { + n := 8 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint16x32, want func(x []uint16) []uint16) { + n := 32 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x32Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint16x16, want func(x []uint32) []uint16) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint16x8, want func(x []uint64) []uint16) { + n := 8 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToUint16(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint16x16, want func(x []float32) []uint16) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x8ConvertToUint16(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint16x8, want func(x []float64) []uint16) { + n := 8 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x8Slice(x) + g := make([]uint16, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + // testInt8x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt8x16ConvertToInt32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int32x16, want func(x []int8) []int32) { - n := 16 +func testInt8x16ConvertToInt32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int32x16, want func(x []int8) []int32) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x8ConvertToInt32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int32x8, want func(x []int16) []int32) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x4ConvertToInt32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int32x4, want func(x []int32) []int32) { + n := 4 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int32x16, want func(x []uint8) []int32) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int32x8, want func(x []uint16) []int32) { + n := 8 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int32x4, want func(x []uint32) []int32) { + n := 4 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x4ConvertToInt32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int32x4, want func(x []float32) []int32) { + n := 4 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToInt32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int32x16, want func(x []int16) []int32) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x8ConvertToInt32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int32x8, want func(x []int32) []int32) { + n := 8 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x4ConvertToInt32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int32x4, want func(x []int64) []int32) { + n := 4 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int32x16, want func(x []uint16) []int32) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int32x8, want func(x []uint32) []int32) { + n := 8 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int32x4, want func(x []uint64) []int32) { + n := 4 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x8ConvertToInt32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int32x8, want func(x []float32) []int32) { + n := 8 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x4ConvertToInt32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int32x4, want func(x []float64) []int32) { + n := 4 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x4Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToInt32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int32x16, want func(x []int32) []int32) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x8ConvertToInt32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int32x8, want func(x []int64) []int32) { + n := 8 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int32x16, want func(x []uint32) []int32) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int32x8, want func(x []uint64) []int32) { + n := 8 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToInt32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int32x16, want func(x []float32) []int32) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x8ConvertToInt32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int32x8, want func(x []float64) []int32) { + n := 8 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x8Slice(x) + g := make([]int32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt8x16ConvertToUint32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint32x16, want func(x []int8) []uint32) { + n := 16 + t.Helper() + forSlice(t, int8s, n, func(x []int8) bool { + t.Helper() + a := archsimd.LoadInt8x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x8ConvertToUint32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint32x8, want func(x []int16) []uint32) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x4ConvertToUint32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint32x4, want func(x []int32) []uint32) { + n := 4 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint8x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint32x16, want func(x []uint8) []uint32) { + n := 16 + t.Helper() + forSlice(t, uint8s, n, func(x []uint8) bool { + t.Helper() + a := archsimd.LoadUint8x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint32x8, want func(x []uint16) []uint32) { + n := 8 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint32x4, want func(x []uint32) []uint32) { + n := 4 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x4ConvertToUint32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint32x4, want func(x []float32) []uint32) { + n := 4 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x16ConvertToUint32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint32x16, want func(x []int16) []uint32) { + n := 16 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x8ConvertToUint32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint32x8, want func(x []int32) []uint32) { + n := 8 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x4ConvertToUint32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint32x4, want func(x []int64) []uint32) { + n := 4 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint32x16, want func(x []uint16) []uint32) { + n := 16 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint32x8, want func(x []uint32) []uint32) { + n := 8 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint32x4, want func(x []uint64) []uint32) { + n := 4 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x8ConvertToUint32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint32x8, want func(x []float32) []uint32) { + n := 8 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x4ConvertToUint32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint32x4, want func(x []float64) []uint32) { + n := 4 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x4Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x16ConvertToUint32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint32x16, want func(x []int32) []uint32) { + n := 16 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x8ConvertToUint32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint32x8, want func(x []int64) []uint32) { + n := 8 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint32x16, want func(x []uint32) []uint32) { + n := 16 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint32x8, want func(x []uint64) []uint32) { + n := 8 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x16ConvertToUint32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint32x16, want func(x []float32) []uint32) { + n := 16 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x16Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x8ConvertToUint32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint32x8, want func(x []float64) []uint32) { + n := 8 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x8Slice(x) + g := make([]uint32, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt16x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt16x8ConvertToInt64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int64x8, want func(x []int16) []int64) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x4ConvertToInt64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int64x4, want func(x []int32) []int64) { + n := 4 + t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x4Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x2ConvertToInt64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int64x2, want func(x []int64) []int64) { + n := 2 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x2Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint16x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint16x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int64x8, want func(x []uint16) []int64) { + n := 8 + t.Helper() + forSlice(t, uint16s, n, func(x []uint16) bool { + t.Helper() + a := archsimd.LoadUint16x8Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint32x4ConvertToInt64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int64x4, want func(x []uint32) []int64) { + n := 4 + t.Helper() + forSlice(t, uint32s, n, func(x []uint32) bool { + t.Helper() + a := archsimd.LoadUint32x4Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x2ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int64x2, want func(x []uint64) []int64) { + n := 2 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x2Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x4ConvertToInt64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int64x4, want func(x []float32) []int64) { + n := 4 + t.Helper() + forSlice(t, float32s, n, func(x []float32) bool { + t.Helper() + a := archsimd.LoadFloat32x4Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x2ConvertToInt64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Int64x2, want func(x []float64) []int64) { + n := 2 t.Helper() - forSlice(t, int8s, n, func(x []int8) bool { + forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadInt8x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat64x2Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x8ConvertToInt32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int32x8, want func(x []int16) []int32) { +func testInt32x8ConvertToInt64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int64x8, want func(x []int32) []int64) { n := 8 t.Helper() - forSlice(t, int16s, n, func(x []int16) bool { + forSlice(t, int32s, n, func(x []int32) bool { t.Helper() - a := archsimd.LoadInt16x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt32x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x4ConvertToInt32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int32x4, want func(x []int32) []int32) { +func testInt64x4ConvertToInt64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int64x4, want func(x []int64) []int64) { n := 4 t.Helper() - forSlice(t, int32s, n, func(x []int32) bool { + forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadInt32x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt64x4Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint8x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint8x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int32x16, want func(x []uint8) []int32) { - n := 16 +func testUint32x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int64x8, want func(x []uint32) []int64) { + n := 8 t.Helper() - forSlice(t, uint8s, n, func(x []uint8) bool { + forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() - a := archsimd.LoadUint8x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint32x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int32x8, want func(x []uint16) []int32) { +func testUint64x4ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int64x4, want func(x []uint64) []int64) { + n := 4 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x4Slice(x) + g := make([]int64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat32x8ConvertToInt64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int64x8, want func(x []float32) []int64) { n := 8 t.Helper() - forSlice(t, uint16s, n, func(x []uint16) bool { + forSlice(t, float32s, n, func(x []float32) bool { t.Helper() - a := archsimd.LoadUint16x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat32x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int32x4, want func(x []uint32) []int32) { +func testFloat64x4ConvertToInt64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int64x4, want func(x []float64) []int64) { n := 4 t.Helper() - forSlice(t, uint32s, n, func(x []uint32) bool { + forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadUint32x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat64x4Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x4ConvertToInt32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int32x4, want func(x []float32) []int32) { - n := 4 +func testInt64x8ConvertToInt64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int64x8, want func(x []int64) []int64) { + n := 8 t.Helper() - forSlice(t, float32s, n, func(x []float32) bool { + forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadFloat32x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt64x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x16ConvertToInt32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int32x16, want func(x []int16) []int32) { - n := 16 +func testUint64x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int64x8, want func(x []uint64) []int64) { + n := 8 t.Helper() - forSlice(t, int16s, n, func(x []int16) bool { + forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() - a := archsimd.LoadInt16x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint64x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x8ConvertToInt32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int32x8, want func(x []int32) []int32) { +func testFloat64x8ConvertToInt64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int64x8, want func(x []float64) []int64) { n := 8 t.Helper() - forSlice(t, int32s, n, func(x []int32) bool { + forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadInt32x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat64x8Slice(x) + g := make([]int64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt16x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt64x4ConvertToInt32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int32x4, want func(x []int64) []int32) { +func testInt16x8ConvertToUint64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint64x8, want func(x []int16) []uint64) { + n := 8 + t.Helper() + forSlice(t, int16s, n, func(x []int16) bool { + t.Helper() + a := archsimd.LoadInt16x8Slice(x) + g := make([]uint64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt32x4ConvertToUint64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint64x4, want func(x []int32) []uint64) { n := 4 t.Helper() + forSlice(t, int32s, n, func(x []int32) bool { + t.Helper() + a := archsimd.LoadInt32x4Slice(x) + g := make([]uint64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x2ConvertToUint64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint64x2, want func(x []int64) []uint64) { + n := 2 + t.Helper() forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadInt64x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt64x2Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint16x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int32x16, want func(x []uint16) []int32) { - n := 16 +func testUint16x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint64x8, want func(x []uint16) []uint64) { + n := 8 t.Helper() forSlice(t, uint16s, n, func(x []uint16) bool { t.Helper() - a := archsimd.LoadUint16x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint16x8Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int32x8, want func(x []uint32) []int32) { - n := 8 +func testUint32x4ConvertToUint64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint64x4, want func(x []uint32) []uint64) { + n := 4 t.Helper() forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() - a := archsimd.LoadUint32x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint32x4Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint64x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int32x4, want func(x []uint64) []int32) { - n := 4 +func testUint64x2ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint64x2, want func(x []uint64) []uint64) { + n := 2 t.Helper() forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() - a := archsimd.LoadUint64x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint64x2Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x8ConvertToInt32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int32x8, want func(x []float32) []int32) { - n := 8 +func testFloat32x4ConvertToUint64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint64x4, want func(x []float32) []uint64) { + n := 4 t.Helper() forSlice(t, float32s, n, func(x []float32) bool { t.Helper() - a := archsimd.LoadFloat32x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat32x4Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat64x4ConvertToInt32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int32x4, want func(x []float64) []int32) { - n := 4 +func testFloat64x2ConvertToUint64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Uint64x2, want func(x []float64) []uint64) { + n := 2 t.Helper() forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadFloat64x4Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat64x2Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x16ConvertToInt32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int32x16, want func(x []int32) []int32) { - n := 16 +func testInt32x8ConvertToUint64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint64x8, want func(x []int32) []uint64) { + n := 8 t.Helper() forSlice(t, int32s, n, func(x []int32) bool { t.Helper() - a := archsimd.LoadInt32x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt32x8Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testInt64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt64x8ConvertToInt32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int32x8, want func(x []int64) []int32) { - n := 8 +func testInt64x4ConvertToUint64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint64x4, want func(x []int64) []uint64) { + n := 4 t.Helper() forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadInt64x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadInt64x4Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int32x16, want func(x []uint32) []int32) { - n := 16 +func testUint32x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint64x8, want func(x []uint32) []uint64) { + n := 8 t.Helper() forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() - a := archsimd.LoadUint32x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint32x8Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint64x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int32x8, want func(x []uint64) []int32) { - n := 8 +func testUint64x4ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint64x4, want func(x []uint64) []uint64) { + n := 4 t.Helper() forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() - a := archsimd.LoadUint64x8Slice(x) - g := make([]int32, n) + a := archsimd.LoadUint64x4Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x16ConvertToInt32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int32x16, want func(x []float32) []int32) { - n := 16 +func testFloat32x8ConvertToUint64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint64x8, want func(x []float32) []uint64) { + n := 8 t.Helper() forSlice(t, float32s, n, func(x []float32) bool { t.Helper() - a := archsimd.LoadFloat32x16Slice(x) - g := make([]int32, n) + a := archsimd.LoadFloat32x8Slice(x) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat64x8ConvertToInt32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int32x8, want func(x []float64) []int32) { +func testFloat64x4ConvertToUint64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint64x4, want func(x []float64) []uint64) { + n := 4 + t.Helper() + forSlice(t, float64s, n, func(x []float64) bool { + t.Helper() + a := archsimd.LoadFloat64x4Slice(x) + g := make([]uint64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testInt64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testInt64x8ConvertToUint64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint64x8, want func(x []int64) []uint64) { + n := 8 + t.Helper() + forSlice(t, int64s, n, func(x []int64) bool { + t.Helper() + a := archsimd.LoadInt64x8Slice(x) + g := make([]uint64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testUint64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testUint64x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint64x8, want func(x []uint64) []uint64) { + n := 8 + t.Helper() + forSlice(t, uint64s, n, func(x []uint64) bool { + t.Helper() + a := archsimd.LoadUint64x8Slice(x) + g := make([]uint64, n) + f(a).StoreSlice(g) + w := want(x) + return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) + }) +} + +// testFloat64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want +// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. +func testFloat64x8ConvertToUint64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint64x8, want func(x []float64) []uint64) { n := 8 t.Helper() forSlice(t, float64s, n, func(x []float64) bool { t.Helper() a := archsimd.LoadFloat64x8Slice(x) - g := make([]int32, n) + g := make([]uint64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt8x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt8x16ConvertToUint32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint32x16, want func(x []int8) []uint32) { +func testInt8x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Float32x16, want func(x []int8) []float32) { n := 16 t.Helper() forSlice(t, int8s, n, func(x []int8) bool { t.Helper() a := archsimd.LoadInt8x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt16x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x8ConvertToUint32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint32x8, want func(x []int16) []uint32) { +func testInt16x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Float32x8, want func(x []int16) []float32) { n := 8 t.Helper() forSlice(t, int16s, n, func(x []int16) bool { t.Helper() a := archsimd.LoadInt16x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x4ConvertToUint32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint32x4, want func(x []int32) []uint32) { +func testInt32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Float32x4, want func(x []int32) []float32) { n := 4 t.Helper() forSlice(t, int32s, n, func(x []int32) bool { t.Helper() a := archsimd.LoadInt32x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint8x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint8x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint32x16, want func(x []uint8) []uint32) { +func testUint8x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Float32x16, want func(x []uint8) []float32) { n := 16 t.Helper() forSlice(t, uint8s, n, func(x []uint8) bool { t.Helper() a := archsimd.LoadUint8x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint16x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint32x8, want func(x []uint16) []uint32) { +func testUint16x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Float32x8, want func(x []uint16) []float32) { n := 8 t.Helper() forSlice(t, uint16s, n, func(x []uint16) bool { t.Helper() a := archsimd.LoadUint16x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint32x4, want func(x []uint32) []uint32) { +func testUint32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Float32x4, want func(x []uint32) []float32) { n := 4 t.Helper() forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() a := archsimd.LoadUint32x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x4ConvertToUint32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint32x4, want func(x []float32) []uint32) { +func testFloat32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Float32x4, want func(x []float32) []float32) { n := 4 t.Helper() forSlice(t, float32s, n, func(x []float32) bool { t.Helper() a := archsimd.LoadFloat32x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt16x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x16ConvertToUint32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint32x16, want func(x []int16) []uint32) { +func testInt16x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Float32x16, want func(x []int16) []float32) { n := 16 t.Helper() forSlice(t, int16s, n, func(x []int16) bool { t.Helper() a := archsimd.LoadInt16x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x8ConvertToUint32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint32x8, want func(x []int32) []uint32) { +func testInt32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Float32x8, want func(x []int32) []float32) { n := 8 t.Helper() forSlice(t, int32s, n, func(x []int32) bool { t.Helper() a := archsimd.LoadInt32x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt64x4ConvertToUint32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint32x4, want func(x []int64) []uint32) { +func testInt64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Float32x4, want func(x []int64) []float32) { n := 4 t.Helper() forSlice(t, int64s, n, func(x []int64) bool { t.Helper() a := archsimd.LoadInt64x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint16x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint32x16, want func(x []uint16) []uint32) { +func testUint16x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Float32x16, want func(x []uint16) []float32) { n := 16 t.Helper() forSlice(t, uint16s, n, func(x []uint16) bool { t.Helper() a := archsimd.LoadUint16x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint32x8, want func(x []uint32) []uint32) { +func testUint32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Float32x8, want func(x []uint32) []float32) { n := 8 t.Helper() forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() a := archsimd.LoadUint32x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint64x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint32x4, want func(x []uint64) []uint32) { +func testUint64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Float32x4, want func(x []uint64) []float32) { n := 4 t.Helper() forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() a := archsimd.LoadUint64x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x8ConvertToUint32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint32x8, want func(x []float32) []uint32) { +func testFloat32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Float32x8, want func(x []float32) []float32) { n := 8 t.Helper() forSlice(t, float32s, n, func(x []float32) bool { t.Helper() a := archsimd.LoadFloat32x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat64x4ConvertToUint32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint32x4, want func(x []float64) []uint32) { +func testFloat64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Float32x4, want func(x []float64) []float32) { n := 4 t.Helper() forSlice(t, float64s, n, func(x []float64) bool { t.Helper() a := archsimd.LoadFloat64x4Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x16ConvertToUint32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint32x16, want func(x []int32) []uint32) { +func testInt32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Float32x16, want func(x []int32) []float32) { n := 16 t.Helper() forSlice(t, int32s, n, func(x []int32) bool { t.Helper() a := archsimd.LoadInt32x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testInt64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt64x8ConvertToUint32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint32x8, want func(x []int64) []uint32) { +func testInt64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Float32x8, want func(x []int64) []float32) { n := 8 t.Helper() forSlice(t, int64s, n, func(x []int64) bool { t.Helper() a := archsimd.LoadInt64x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint32x16, want func(x []uint32) []uint32) { +func testUint32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Float32x16, want func(x []uint32) []float32) { n := 16 t.Helper() forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() a := archsimd.LoadUint32x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testUint64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint64x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint32x8, want func(x []uint64) []uint32) { +func testUint64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Float32x8, want func(x []uint64) []float32) { n := 8 t.Helper() forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() a := archsimd.LoadUint64x8Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x16ConvertToUint32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint32x16, want func(x []float32) []uint32) { +func testFloat32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Float32x16, want func(x []float32) []float32) { n := 16 t.Helper() forSlice(t, float32s, n, func(x []float32) bool { t.Helper() a := archsimd.LoadFloat32x16Slice(x) - g := make([]uint32, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat64x8ConvertToUint32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint32x8, want func(x []float64) []uint32) { +func testFloat64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Float32x8, want func(x []float64) []float32) { n := 8 t.Helper() forSlice(t, float64s, n, func(x []float64) bool { t.Helper() a := archsimd.LoadFloat64x8Slice(x) - g := make([]uint32, n) - f(a).StoreSlice(g) - w := want(x) - return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) - }) -} - -// testInt8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want -// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt8x16ConvertToUint16(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint16x16, want func(x []int8) []uint16) { - n := 16 - t.Helper() - forSlice(t, int8s, n, func(x []int8) bool { - t.Helper() - a := archsimd.LoadInt8x16Slice(x) - g := make([]uint16, n) + g := make([]float32, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt16x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x8ConvertToUint16(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint16x8, want func(x []int16) []uint16) { +func testInt16x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Float64x8, want func(x []int16) []float64) { n := 8 t.Helper() forSlice(t, int16s, n, func(x []int16) bool { t.Helper() a := archsimd.LoadInt16x8Slice(x) - g := make([]uint16, n) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint8x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint16x16, want func(x []uint8) []uint16) { - n := 16 +func testInt32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Float64x4, want func(x []int32) []float64) { + n := 4 t.Helper() - forSlice(t, uint8s, n, func(x []uint8) bool { + forSlice(t, int32s, n, func(x []int32) bool { t.Helper() - a := archsimd.LoadUint8x16Slice(x) - g := make([]uint16, n) + a := archsimd.LoadInt32x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint16x8, want func(x []uint16) []uint16) { - n := 8 +func testInt64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Float64x2, want func(x []int64) []float64) { + n := 2 t.Helper() - forSlice(t, uint16s, n, func(x []uint16) bool { + forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadUint16x8Slice(x) - g := make([]uint16, n) + a := archsimd.LoadInt64x2Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint16x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt8x32ConvertToUint16(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint16x32, want func(x []int8) []uint16) { - n := 32 +func testUint16x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Float64x8, want func(x []uint16) []float64) { + n := 8 t.Helper() - forSlice(t, int8s, n, func(x []int8) bool { + forSlice(t, uint16s, n, func(x []uint16) bool { t.Helper() - a := archsimd.LoadInt8x32Slice(x) - g := make([]uint16, n) + a := archsimd.LoadUint16x8Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x16ConvertToUint16(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint16x16, want func(x []int16) []uint16) { - n := 16 +func testUint32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Float64x4, want func(x []uint32) []float64) { + n := 4 t.Helper() - forSlice(t, int16s, n, func(x []int16) bool { + forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() - a := archsimd.LoadInt16x16Slice(x) - g := make([]uint16, n) + a := archsimd.LoadUint32x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x8ConvertToUint16(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint16x8, want func(x []int32) []uint16) { - n := 8 +func testUint64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Float64x2, want func(x []uint64) []float64) { + n := 2 t.Helper() - forSlice(t, int32s, n, func(x []int32) bool { + forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() - a := archsimd.LoadInt32x8Slice(x) - g := make([]uint16, n) + a := archsimd.LoadUint64x2Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint8x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint16x32, want func(x []uint8) []uint16) { - n := 32 +func testFloat32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Float64x4, want func(x []float32) []float64) { + n := 4 t.Helper() - forSlice(t, uint8s, n, func(x []uint8) bool { + forSlice(t, float32s, n, func(x []float32) bool { t.Helper() - a := archsimd.LoadUint8x32Slice(x) - g := make([]uint16, n) + a := archsimd.LoadFloat32x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint16x16, want func(x []uint16) []uint16) { - n := 16 +func testFloat64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Float64x2, want func(x []float64) []float64) { + n := 2 t.Helper() - forSlice(t, uint16s, n, func(x []uint16) bool { + forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadUint16x16Slice(x) - g := make([]uint16, n) + a := archsimd.LoadFloat64x2Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint16x8, want func(x []uint32) []uint16) { +func testInt32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Float64x8, want func(x []int32) []float64) { n := 8 t.Helper() - forSlice(t, uint32s, n, func(x []uint32) bool { + forSlice(t, int32s, n, func(x []int32) bool { t.Helper() - a := archsimd.LoadUint32x8Slice(x) - g := make([]uint16, n) + a := archsimd.LoadInt32x8Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x8ConvertToUint16(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint16x8, want func(x []float32) []uint16) { - n := 8 +func testInt64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Float64x4, want func(x []int64) []float64) { + n := 4 t.Helper() - forSlice(t, float32s, n, func(x []float32) bool { + forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadFloat32x8Slice(x) - g := make([]uint16, n) + a := archsimd.LoadInt64x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt16x32ConvertToUint16(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint16x32, want func(x []int16) []uint16) { - n := 32 +func testUint32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Float64x8, want func(x []uint32) []float64) { + n := 8 t.Helper() - forSlice(t, int16s, n, func(x []int16) bool { + forSlice(t, uint32s, n, func(x []uint32) bool { t.Helper() - a := archsimd.LoadInt16x32Slice(x) - g := make([]uint16, n) + a := archsimd.LoadUint32x8Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt32x16ConvertToUint16(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint16x16, want func(x []int32) []uint16) { - n := 16 +func testUint64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Float64x4, want func(x []uint64) []float64) { + n := 4 t.Helper() - forSlice(t, int32s, n, func(x []int32) bool { + forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() - a := archsimd.LoadInt32x16Slice(x) - g := make([]uint16, n) + a := archsimd.LoadUint64x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testInt64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testFloat32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testInt64x8ConvertToUint16(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint16x8, want func(x []int64) []uint16) { +func testFloat32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Float64x8, want func(x []float32) []float64) { n := 8 t.Helper() - forSlice(t, int64s, n, func(x []int64) bool { + forSlice(t, float32s, n, func(x []float32) bool { t.Helper() - a := archsimd.LoadInt64x8Slice(x) - g := make([]uint16, n) + a := archsimd.LoadFloat32x8Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint16x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint16x32, want func(x []uint16) []uint16) { - n := 32 +func testFloat64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Float64x4, want func(x []float64) []float64) { + n := 4 t.Helper() - forSlice(t, uint16s, n, func(x []uint16) bool { + forSlice(t, float64s, n, func(x []float64) bool { t.Helper() - a := archsimd.LoadUint16x32Slice(x) - g := make([]uint16, n) + a := archsimd.LoadFloat64x4Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testInt64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint32x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint16x16, want func(x []uint32) []uint16) { - n := 16 +func testInt64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Float64x8, want func(x []int64) []float64) { + n := 8 t.Helper() - forSlice(t, uint32s, n, func(x []uint32) bool { + forSlice(t, int64s, n, func(x []int64) bool { t.Helper() - a := archsimd.LoadUint32x16Slice(x) - g := make([]uint16, n) + a := archsimd.LoadInt64x8Slice(x) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testUint64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testUint64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testUint64x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint16x8, want func(x []uint64) []uint16) { +func testUint64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Float64x8, want func(x []uint64) []float64) { n := 8 t.Helper() forSlice(t, uint64s, n, func(x []uint64) bool { t.Helper() a := archsimd.LoadUint64x8Slice(x) - g := make([]uint16, n) - f(a).StoreSlice(g) - w := want(x) - return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) - }) -} - -// testFloat32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want -// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat32x16ConvertToUint16(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint16x16, want func(x []float32) []uint16) { - n := 16 - t.Helper() - forSlice(t, float32s, n, func(x []float32) bool { - t.Helper() - a := archsimd.LoadFloat32x16Slice(x) - g := make([]uint16, n) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) }) } -// testFloat64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want +// testFloat64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width. -func testFloat64x8ConvertToUint16(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint16x8, want func(x []float64) []uint16) { +func testFloat64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Float64x8, want func(x []float64) []float64) { n := 8 t.Helper() forSlice(t, float64s, n, func(x []float64) bool { t.Helper() a := archsimd.LoadFloat64x8Slice(x) - g := make([]uint16, n) + g := make([]float64, n) f(a).StoreSlice(g) w := want(x) return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) }) diff --git a/src/simd/archsimd/internal/simd_test/unary_test.go b/src/simd/archsimd/internal/simd_test/unary_test.go index 4a80860f40..9110a6eac6 100644 --- a/src/simd/archsimd/internal/simd_test/unary_test.go +++ b/src/simd/archsimd/internal/simd_test/unary_test.go @@ -130,14 +130,26 @@ func TestToInt32(t *testing.T) { testFloat32x8ConvertToInt32(t, archsimd.Float32x8.ConvertToInt32, map1[float32](toInt32)) } -func TestConverts(t *testing.T) { - testUint8x16ConvertToUint16(t, archsimd.Uint8x16.ExtendToUint16, map1[uint8](toUint16)) - testUint16x8ConvertToUint32(t, archsimd.Uint16x8.ExtendToUint32, map1[uint16](toUint32)) -} +func TestExtend(t *testing.T) { + if archsimd.X86.AVX2() { + testInt8x16ConvertToInt16(t, archsimd.Int8x16.ExtendToInt16, map1[int8](toInt16)) + testInt16x8ConvertToInt32(t, archsimd.Int16x8.ExtendToInt32, map1[int16](toInt32)) + testInt32x4ConvertToInt64(t, archsimd.Int32x4.ExtendToInt64, map1[int32](toInt64)) + testUint8x16ConvertToUint16(t, archsimd.Uint8x16.ExtendToUint16, map1[uint8](toUint16)) + testUint16x8ConvertToUint32(t, archsimd.Uint16x8.ExtendToUint32, map1[uint16](toUint32)) + testUint32x4ConvertToUint64(t, archsimd.Uint32x4.ExtendToUint64, map1[uint32](toUint64)) + } -func TestConvertsAVX512(t *testing.T) { - if !archsimd.X86.AVX512() { - t.Skip("Needs AVX512") + if archsimd.X86.AVX512() { + testInt8x32ConvertToInt16(t, archsimd.Int8x32.ExtendToInt16, map1[int8](toInt16)) + testInt8x16ConvertToInt32(t, archsimd.Int8x16.ExtendToInt32, map1[int8](toInt32)) + testInt16x16ConvertToInt32(t, archsimd.Int16x16.ExtendToInt32, map1[int16](toInt32)) + testInt16x8ConvertToInt64(t, archsimd.Int16x8.ExtendToInt64, map1[int16](toInt64)) + testInt32x8ConvertToInt64(t, archsimd.Int32x8.ExtendToInt64, map1[int32](toInt64)) + testUint8x32ConvertToUint16(t, archsimd.Uint8x32.ExtendToUint16, map1[uint8](toUint16)) + testUint8x16ConvertToUint32(t, archsimd.Uint8x16.ExtendToUint32, map1[uint8](toUint32)) + testUint16x16ConvertToUint32(t, archsimd.Uint16x16.ExtendToUint32, map1[uint16](toUint32)) + testUint16x8ConvertToUint64(t, archsimd.Uint16x8.ExtendToUint64, map1[uint16](toUint64)) + testUint32x8ConvertToUint64(t, archsimd.Uint32x8.ExtendToUint64, map1[uint32](toUint64)) } - testUint8x32ConvertToUint16(t, archsimd.Uint8x32.ExtendToUint16, map1[uint8](toUint16)) } -- 2.52.0