Source file src/simd/archsimd/internal/simd_test/convert_helpers_test.go

     1  // Code generated by 'tmplgen'; DO NOT EDIT.
     2  
     3  //go:build goexperiment.simd && amd64
     4  
     5  // This file contains functions testing conversion simd methods.
     6  // Each function in this file is specialized for a
     7  // particular simd type <BaseType><Width>x<Count>.
     8  
     9  package simd_test
    10  
    11  import (
    12  	"simd/archsimd"
    13  	"testing"
    14  )
    15  
    16  // testInt8x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    17  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    18  // (extended to at least 128 bits, or truncated to at most 512 bits).
    19  func testInt8x16ConvertToInt8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int8x16, want func(x []int8) []int8) {
    20  	n := 16
    21  	t.Helper()
    22  	forSlice(t, int8s, n, func(x []int8) bool {
    23  		t.Helper()
    24  		a := archsimd.LoadInt8x16(x)
    25  		g := make([]int8, 16)
    26  		f(a).Store(g)
    27  		w := want(x)
    28  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
    29  	})
    30  }
    31  
    32  // testInt16x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    33  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    34  // (extended to at least 128 bits, or truncated to at most 512 bits).
    35  func testInt16x8ConvertToInt8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int8x16, want func(x []int16) []int8) {
    36  	n := 8
    37  	t.Helper()
    38  	forSlice(t, int16s, n, func(x []int16) bool {
    39  		t.Helper()
    40  		a := archsimd.LoadInt16x8(x)
    41  		g := make([]int8, 16)
    42  		f(a).Store(g)
    43  		w := want(x)
    44  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
    45  	})
    46  }
    47  
    48  // testInt32x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    49  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    50  // (extended to at least 128 bits, or truncated to at most 512 bits).
    51  func testInt32x4ConvertToInt8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int8x16, want func(x []int32) []int8) {
    52  	n := 4
    53  	t.Helper()
    54  	forSlice(t, int32s, n, func(x []int32) bool {
    55  		t.Helper()
    56  		a := archsimd.LoadInt32x4(x)
    57  		g := make([]int8, 16)
    58  		f(a).Store(g)
    59  		w := want(x)
    60  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
    61  	})
    62  }
    63  
    64  // testInt64x2ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    65  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    66  // (extended to at least 128 bits, or truncated to at most 512 bits).
    67  func testInt64x2ConvertToInt8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int8x16, want func(x []int64) []int8) {
    68  	n := 2
    69  	t.Helper()
    70  	forSlice(t, int64s, n, func(x []int64) bool {
    71  		t.Helper()
    72  		a := archsimd.LoadInt64x2(x)
    73  		g := make([]int8, 16)
    74  		f(a).Store(g)
    75  		w := want(x)
    76  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
    77  	})
    78  }
    79  
    80  // testUint8x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    81  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    82  // (extended to at least 128 bits, or truncated to at most 512 bits).
    83  func testUint8x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int8x16, want func(x []uint8) []int8) {
    84  	n := 16
    85  	t.Helper()
    86  	forSlice(t, uint8s, n, func(x []uint8) bool {
    87  		t.Helper()
    88  		a := archsimd.LoadUint8x16(x)
    89  		g := make([]int8, 16)
    90  		f(a).Store(g)
    91  		w := want(x)
    92  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
    93  	})
    94  }
    95  
    96  // testUint16x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
    97  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
    98  // (extended to at least 128 bits, or truncated to at most 512 bits).
    99  func testUint16x8ConvertToInt8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int8x16, want func(x []uint16) []int8) {
   100  	n := 8
   101  	t.Helper()
   102  	forSlice(t, uint16s, n, func(x []uint16) bool {
   103  		t.Helper()
   104  		a := archsimd.LoadUint16x8(x)
   105  		g := make([]int8, 16)
   106  		f(a).Store(g)
   107  		w := want(x)
   108  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   109  	})
   110  }
   111  
   112  // testUint32x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   113  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   114  // (extended to at least 128 bits, or truncated to at most 512 bits).
   115  func testUint32x4ConvertToInt8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int8x16, want func(x []uint32) []int8) {
   116  	n := 4
   117  	t.Helper()
   118  	forSlice(t, uint32s, n, func(x []uint32) bool {
   119  		t.Helper()
   120  		a := archsimd.LoadUint32x4(x)
   121  		g := make([]int8, 16)
   122  		f(a).Store(g)
   123  		w := want(x)
   124  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   125  	})
   126  }
   127  
   128  // testUint64x2ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   129  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   130  // (extended to at least 128 bits, or truncated to at most 512 bits).
   131  func testUint64x2ConvertToInt8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int8x16, want func(x []uint64) []int8) {
   132  	n := 2
   133  	t.Helper()
   134  	forSlice(t, uint64s, n, func(x []uint64) bool {
   135  		t.Helper()
   136  		a := archsimd.LoadUint64x2(x)
   137  		g := make([]int8, 16)
   138  		f(a).Store(g)
   139  		w := want(x)
   140  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   141  	})
   142  }
   143  
   144  // testFloat32x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   145  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   146  // (extended to at least 128 bits, or truncated to at most 512 bits).
   147  func testFloat32x4ConvertToInt8(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int8x16, want func(x []float32) []int8) {
   148  	n := 4
   149  	t.Helper()
   150  	forSlice(t, float32s, n, func(x []float32) bool {
   151  		t.Helper()
   152  		a := archsimd.LoadFloat32x4(x)
   153  		g := make([]int8, 16)
   154  		f(a).Store(g)
   155  		w := want(x)
   156  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   157  	})
   158  }
   159  
   160  // testFloat64x2ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   161  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   162  // (extended to at least 128 bits, or truncated to at most 512 bits).
   163  func testFloat64x2ConvertToInt8(t *testing.T, f func(x archsimd.Float64x2) archsimd.Int8x16, want func(x []float64) []int8) {
   164  	n := 2
   165  	t.Helper()
   166  	forSlice(t, float64s, n, func(x []float64) bool {
   167  		t.Helper()
   168  		a := archsimd.LoadFloat64x2(x)
   169  		g := make([]int8, 16)
   170  		f(a).Store(g)
   171  		w := want(x)
   172  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   173  	})
   174  }
   175  
   176  // testInt8x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   177  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   178  // (extended to at least 128 bits, or truncated to at most 512 bits).
   179  func testInt8x32ConvertToInt8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int8x32, want func(x []int8) []int8) {
   180  	n := 32
   181  	t.Helper()
   182  	forSlice(t, int8s, n, func(x []int8) bool {
   183  		t.Helper()
   184  		a := archsimd.LoadInt8x32(x)
   185  		g := make([]int8, 32)
   186  		f(a).Store(g)
   187  		w := want(x)
   188  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   189  	})
   190  }
   191  
   192  // testInt16x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   193  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   194  // (extended to at least 128 bits, or truncated to at most 512 bits).
   195  func testInt16x16ConvertToInt8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int8x16, want func(x []int16) []int8) {
   196  	n := 16
   197  	t.Helper()
   198  	forSlice(t, int16s, n, func(x []int16) bool {
   199  		t.Helper()
   200  		a := archsimd.LoadInt16x16(x)
   201  		g := make([]int8, 16)
   202  		f(a).Store(g)
   203  		w := want(x)
   204  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   205  	})
   206  }
   207  
   208  // testInt32x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   209  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   210  // (extended to at least 128 bits, or truncated to at most 512 bits).
   211  func testInt32x8ConvertToInt8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int8x16, want func(x []int32) []int8) {
   212  	n := 8
   213  	t.Helper()
   214  	forSlice(t, int32s, n, func(x []int32) bool {
   215  		t.Helper()
   216  		a := archsimd.LoadInt32x8(x)
   217  		g := make([]int8, 16)
   218  		f(a).Store(g)
   219  		w := want(x)
   220  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   221  	})
   222  }
   223  
   224  // testInt64x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   225  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   226  // (extended to at least 128 bits, or truncated to at most 512 bits).
   227  func testInt64x4ConvertToInt8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int8x16, want func(x []int64) []int8) {
   228  	n := 4
   229  	t.Helper()
   230  	forSlice(t, int64s, n, func(x []int64) bool {
   231  		t.Helper()
   232  		a := archsimd.LoadInt64x4(x)
   233  		g := make([]int8, 16)
   234  		f(a).Store(g)
   235  		w := want(x)
   236  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   237  	})
   238  }
   239  
   240  // testUint8x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   241  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   242  // (extended to at least 128 bits, or truncated to at most 512 bits).
   243  func testUint8x32ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int8x32, want func(x []uint8) []int8) {
   244  	n := 32
   245  	t.Helper()
   246  	forSlice(t, uint8s, n, func(x []uint8) bool {
   247  		t.Helper()
   248  		a := archsimd.LoadUint8x32(x)
   249  		g := make([]int8, 32)
   250  		f(a).Store(g)
   251  		w := want(x)
   252  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   253  	})
   254  }
   255  
   256  // testUint16x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   257  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   258  // (extended to at least 128 bits, or truncated to at most 512 bits).
   259  func testUint16x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int8x16, want func(x []uint16) []int8) {
   260  	n := 16
   261  	t.Helper()
   262  	forSlice(t, uint16s, n, func(x []uint16) bool {
   263  		t.Helper()
   264  		a := archsimd.LoadUint16x16(x)
   265  		g := make([]int8, 16)
   266  		f(a).Store(g)
   267  		w := want(x)
   268  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   269  	})
   270  }
   271  
   272  // testUint32x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   273  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   274  // (extended to at least 128 bits, or truncated to at most 512 bits).
   275  func testUint32x8ConvertToInt8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int8x16, want func(x []uint32) []int8) {
   276  	n := 8
   277  	t.Helper()
   278  	forSlice(t, uint32s, n, func(x []uint32) bool {
   279  		t.Helper()
   280  		a := archsimd.LoadUint32x8(x)
   281  		g := make([]int8, 16)
   282  		f(a).Store(g)
   283  		w := want(x)
   284  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   285  	})
   286  }
   287  
   288  // testUint64x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   289  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   290  // (extended to at least 128 bits, or truncated to at most 512 bits).
   291  func testUint64x4ConvertToInt8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int8x16, want func(x []uint64) []int8) {
   292  	n := 4
   293  	t.Helper()
   294  	forSlice(t, uint64s, n, func(x []uint64) bool {
   295  		t.Helper()
   296  		a := archsimd.LoadUint64x4(x)
   297  		g := make([]int8, 16)
   298  		f(a).Store(g)
   299  		w := want(x)
   300  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   301  	})
   302  }
   303  
   304  // testFloat32x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   305  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   306  // (extended to at least 128 bits, or truncated to at most 512 bits).
   307  func testFloat32x8ConvertToInt8(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int8x16, want func(x []float32) []int8) {
   308  	n := 8
   309  	t.Helper()
   310  	forSlice(t, float32s, n, func(x []float32) bool {
   311  		t.Helper()
   312  		a := archsimd.LoadFloat32x8(x)
   313  		g := make([]int8, 16)
   314  		f(a).Store(g)
   315  		w := want(x)
   316  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   317  	})
   318  }
   319  
   320  // testFloat64x4ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   321  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   322  // (extended to at least 128 bits, or truncated to at most 512 bits).
   323  func testFloat64x4ConvertToInt8(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int8x16, want func(x []float64) []int8) {
   324  	n := 4
   325  	t.Helper()
   326  	forSlice(t, float64s, n, func(x []float64) bool {
   327  		t.Helper()
   328  		a := archsimd.LoadFloat64x4(x)
   329  		g := make([]int8, 16)
   330  		f(a).Store(g)
   331  		w := want(x)
   332  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   333  	})
   334  }
   335  
   336  // testInt8x64ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   337  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   338  // (extended to at least 128 bits, or truncated to at most 512 bits).
   339  func testInt8x64ConvertToInt8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int8x64, want func(x []int8) []int8) {
   340  	n := 64
   341  	t.Helper()
   342  	forSlice(t, int8s, n, func(x []int8) bool {
   343  		t.Helper()
   344  		a := archsimd.LoadInt8x64(x)
   345  		g := make([]int8, 64)
   346  		f(a).Store(g)
   347  		w := want(x)
   348  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   349  	})
   350  }
   351  
   352  // testInt16x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   353  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   354  // (extended to at least 128 bits, or truncated to at most 512 bits).
   355  func testInt16x32ConvertToInt8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int8x32, want func(x []int16) []int8) {
   356  	n := 32
   357  	t.Helper()
   358  	forSlice(t, int16s, n, func(x []int16) bool {
   359  		t.Helper()
   360  		a := archsimd.LoadInt16x32(x)
   361  		g := make([]int8, 32)
   362  		f(a).Store(g)
   363  		w := want(x)
   364  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   365  	})
   366  }
   367  
   368  // testInt32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   369  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   370  // (extended to at least 128 bits, or truncated to at most 512 bits).
   371  func testInt32x16ConvertToInt8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int8x16, want func(x []int32) []int8) {
   372  	n := 16
   373  	t.Helper()
   374  	forSlice(t, int32s, n, func(x []int32) bool {
   375  		t.Helper()
   376  		a := archsimd.LoadInt32x16(x)
   377  		g := make([]int8, 16)
   378  		f(a).Store(g)
   379  		w := want(x)
   380  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   381  	})
   382  }
   383  
   384  // testInt64x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   385  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   386  // (extended to at least 128 bits, or truncated to at most 512 bits).
   387  func testInt64x8ConvertToInt8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int8x16, want func(x []int64) []int8) {
   388  	n := 8
   389  	t.Helper()
   390  	forSlice(t, int64s, n, func(x []int64) bool {
   391  		t.Helper()
   392  		a := archsimd.LoadInt64x8(x)
   393  		g := make([]int8, 16)
   394  		f(a).Store(g)
   395  		w := want(x)
   396  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   397  	})
   398  }
   399  
   400  // testUint8x64ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   401  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   402  // (extended to at least 128 bits, or truncated to at most 512 bits).
   403  func testUint8x64ConvertToInt8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int8x64, want func(x []uint8) []int8) {
   404  	n := 64
   405  	t.Helper()
   406  	forSlice(t, uint8s, n, func(x []uint8) bool {
   407  		t.Helper()
   408  		a := archsimd.LoadUint8x64(x)
   409  		g := make([]int8, 64)
   410  		f(a).Store(g)
   411  		w := want(x)
   412  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   413  	})
   414  }
   415  
   416  // testUint16x32ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   417  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   418  // (extended to at least 128 bits, or truncated to at most 512 bits).
   419  func testUint16x32ConvertToInt8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int8x32, want func(x []uint16) []int8) {
   420  	n := 32
   421  	t.Helper()
   422  	forSlice(t, uint16s, n, func(x []uint16) bool {
   423  		t.Helper()
   424  		a := archsimd.LoadUint16x32(x)
   425  		g := make([]int8, 32)
   426  		f(a).Store(g)
   427  		w := want(x)
   428  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   429  	})
   430  }
   431  
   432  // testUint32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   433  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   434  // (extended to at least 128 bits, or truncated to at most 512 bits).
   435  func testUint32x16ConvertToInt8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int8x16, want func(x []uint32) []int8) {
   436  	n := 16
   437  	t.Helper()
   438  	forSlice(t, uint32s, n, func(x []uint32) bool {
   439  		t.Helper()
   440  		a := archsimd.LoadUint32x16(x)
   441  		g := make([]int8, 16)
   442  		f(a).Store(g)
   443  		w := want(x)
   444  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   445  	})
   446  }
   447  
   448  // testUint64x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   449  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   450  // (extended to at least 128 bits, or truncated to at most 512 bits).
   451  func testUint64x8ConvertToInt8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int8x16, want func(x []uint64) []int8) {
   452  	n := 8
   453  	t.Helper()
   454  	forSlice(t, uint64s, n, func(x []uint64) bool {
   455  		t.Helper()
   456  		a := archsimd.LoadUint64x8(x)
   457  		g := make([]int8, 16)
   458  		f(a).Store(g)
   459  		w := want(x)
   460  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   461  	})
   462  }
   463  
   464  // testFloat32x16ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   465  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   466  // (extended to at least 128 bits, or truncated to at most 512 bits).
   467  func testFloat32x16ConvertToInt8(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int8x16, want func(x []float32) []int8) {
   468  	n := 16
   469  	t.Helper()
   470  	forSlice(t, float32s, n, func(x []float32) bool {
   471  		t.Helper()
   472  		a := archsimd.LoadFloat32x16(x)
   473  		g := make([]int8, 16)
   474  		f(a).Store(g)
   475  		w := want(x)
   476  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   477  	})
   478  }
   479  
   480  // testFloat64x8ConvertToInt8 tests the simd conversion method f against the expected behavior generated by want.
   481  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   482  // (extended to at least 128 bits, or truncated to at most 512 bits).
   483  func testFloat64x8ConvertToInt8(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int8x16, want func(x []float64) []int8) {
   484  	n := 8
   485  	t.Helper()
   486  	forSlice(t, float64s, n, func(x []float64) bool {
   487  		t.Helper()
   488  		a := archsimd.LoadFloat64x8(x)
   489  		g := make([]int8, 16)
   490  		f(a).Store(g)
   491  		w := want(x)
   492  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   493  	})
   494  }
   495  
   496  // testInt8x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   497  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   498  // (extended to at least 128 bits, or truncated to at most 512 bits).
   499  func testInt8x16ConvertToUint8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint8x16, want func(x []int8) []uint8) {
   500  	n := 16
   501  	t.Helper()
   502  	forSlice(t, int8s, n, func(x []int8) bool {
   503  		t.Helper()
   504  		a := archsimd.LoadInt8x16(x)
   505  		g := make([]uint8, 16)
   506  		f(a).Store(g)
   507  		w := want(x)
   508  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   509  	})
   510  }
   511  
   512  // testInt16x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   513  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   514  // (extended to at least 128 bits, or truncated to at most 512 bits).
   515  func testInt16x8ConvertToUint8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint8x16, want func(x []int16) []uint8) {
   516  	n := 8
   517  	t.Helper()
   518  	forSlice(t, int16s, n, func(x []int16) bool {
   519  		t.Helper()
   520  		a := archsimd.LoadInt16x8(x)
   521  		g := make([]uint8, 16)
   522  		f(a).Store(g)
   523  		w := want(x)
   524  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   525  	})
   526  }
   527  
   528  // testInt32x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   529  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   530  // (extended to at least 128 bits, or truncated to at most 512 bits).
   531  func testInt32x4ConvertToUint8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint8x16, want func(x []int32) []uint8) {
   532  	n := 4
   533  	t.Helper()
   534  	forSlice(t, int32s, n, func(x []int32) bool {
   535  		t.Helper()
   536  		a := archsimd.LoadInt32x4(x)
   537  		g := make([]uint8, 16)
   538  		f(a).Store(g)
   539  		w := want(x)
   540  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   541  	})
   542  }
   543  
   544  // testInt64x2ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   545  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   546  // (extended to at least 128 bits, or truncated to at most 512 bits).
   547  func testInt64x2ConvertToUint8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint8x16, want func(x []int64) []uint8) {
   548  	n := 2
   549  	t.Helper()
   550  	forSlice(t, int64s, n, func(x []int64) bool {
   551  		t.Helper()
   552  		a := archsimd.LoadInt64x2(x)
   553  		g := make([]uint8, 16)
   554  		f(a).Store(g)
   555  		w := want(x)
   556  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   557  	})
   558  }
   559  
   560  // testUint8x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   561  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   562  // (extended to at least 128 bits, or truncated to at most 512 bits).
   563  func testUint8x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint8x16, want func(x []uint8) []uint8) {
   564  	n := 16
   565  	t.Helper()
   566  	forSlice(t, uint8s, n, func(x []uint8) bool {
   567  		t.Helper()
   568  		a := archsimd.LoadUint8x16(x)
   569  		g := make([]uint8, 16)
   570  		f(a).Store(g)
   571  		w := want(x)
   572  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   573  	})
   574  }
   575  
   576  // testUint16x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   577  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   578  // (extended to at least 128 bits, or truncated to at most 512 bits).
   579  func testUint16x8ConvertToUint8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint8x16, want func(x []uint16) []uint8) {
   580  	n := 8
   581  	t.Helper()
   582  	forSlice(t, uint16s, n, func(x []uint16) bool {
   583  		t.Helper()
   584  		a := archsimd.LoadUint16x8(x)
   585  		g := make([]uint8, 16)
   586  		f(a).Store(g)
   587  		w := want(x)
   588  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   589  	})
   590  }
   591  
   592  // testUint32x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   593  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   594  // (extended to at least 128 bits, or truncated to at most 512 bits).
   595  func testUint32x4ConvertToUint8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint8x16, want func(x []uint32) []uint8) {
   596  	n := 4
   597  	t.Helper()
   598  	forSlice(t, uint32s, n, func(x []uint32) bool {
   599  		t.Helper()
   600  		a := archsimd.LoadUint32x4(x)
   601  		g := make([]uint8, 16)
   602  		f(a).Store(g)
   603  		w := want(x)
   604  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   605  	})
   606  }
   607  
   608  // testUint64x2ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   609  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   610  // (extended to at least 128 bits, or truncated to at most 512 bits).
   611  func testUint64x2ConvertToUint8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint8x16, want func(x []uint64) []uint8) {
   612  	n := 2
   613  	t.Helper()
   614  	forSlice(t, uint64s, n, func(x []uint64) bool {
   615  		t.Helper()
   616  		a := archsimd.LoadUint64x2(x)
   617  		g := make([]uint8, 16)
   618  		f(a).Store(g)
   619  		w := want(x)
   620  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   621  	})
   622  }
   623  
   624  // testFloat32x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   625  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   626  // (extended to at least 128 bits, or truncated to at most 512 bits).
   627  func testFloat32x4ConvertToUint8(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint8x16, want func(x []float32) []uint8) {
   628  	n := 4
   629  	t.Helper()
   630  	forSlice(t, float32s, n, func(x []float32) bool {
   631  		t.Helper()
   632  		a := archsimd.LoadFloat32x4(x)
   633  		g := make([]uint8, 16)
   634  		f(a).Store(g)
   635  		w := want(x)
   636  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   637  	})
   638  }
   639  
   640  // testFloat64x2ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   641  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   642  // (extended to at least 128 bits, or truncated to at most 512 bits).
   643  func testFloat64x2ConvertToUint8(t *testing.T, f func(x archsimd.Float64x2) archsimd.Uint8x16, want func(x []float64) []uint8) {
   644  	n := 2
   645  	t.Helper()
   646  	forSlice(t, float64s, n, func(x []float64) bool {
   647  		t.Helper()
   648  		a := archsimd.LoadFloat64x2(x)
   649  		g := make([]uint8, 16)
   650  		f(a).Store(g)
   651  		w := want(x)
   652  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   653  	})
   654  }
   655  
   656  // testInt8x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   657  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   658  // (extended to at least 128 bits, or truncated to at most 512 bits).
   659  func testInt8x32ConvertToUint8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint8x32, want func(x []int8) []uint8) {
   660  	n := 32
   661  	t.Helper()
   662  	forSlice(t, int8s, n, func(x []int8) bool {
   663  		t.Helper()
   664  		a := archsimd.LoadInt8x32(x)
   665  		g := make([]uint8, 32)
   666  		f(a).Store(g)
   667  		w := want(x)
   668  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   669  	})
   670  }
   671  
   672  // testInt16x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   673  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   674  // (extended to at least 128 bits, or truncated to at most 512 bits).
   675  func testInt16x16ConvertToUint8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint8x16, want func(x []int16) []uint8) {
   676  	n := 16
   677  	t.Helper()
   678  	forSlice(t, int16s, n, func(x []int16) bool {
   679  		t.Helper()
   680  		a := archsimd.LoadInt16x16(x)
   681  		g := make([]uint8, 16)
   682  		f(a).Store(g)
   683  		w := want(x)
   684  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   685  	})
   686  }
   687  
   688  // testInt32x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   689  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   690  // (extended to at least 128 bits, or truncated to at most 512 bits).
   691  func testInt32x8ConvertToUint8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint8x16, want func(x []int32) []uint8) {
   692  	n := 8
   693  	t.Helper()
   694  	forSlice(t, int32s, n, func(x []int32) bool {
   695  		t.Helper()
   696  		a := archsimd.LoadInt32x8(x)
   697  		g := make([]uint8, 16)
   698  		f(a).Store(g)
   699  		w := want(x)
   700  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   701  	})
   702  }
   703  
   704  // testInt64x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   705  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   706  // (extended to at least 128 bits, or truncated to at most 512 bits).
   707  func testInt64x4ConvertToUint8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint8x16, want func(x []int64) []uint8) {
   708  	n := 4
   709  	t.Helper()
   710  	forSlice(t, int64s, n, func(x []int64) bool {
   711  		t.Helper()
   712  		a := archsimd.LoadInt64x4(x)
   713  		g := make([]uint8, 16)
   714  		f(a).Store(g)
   715  		w := want(x)
   716  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   717  	})
   718  }
   719  
   720  // testUint8x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   721  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   722  // (extended to at least 128 bits, or truncated to at most 512 bits).
   723  func testUint8x32ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint8x32, want func(x []uint8) []uint8) {
   724  	n := 32
   725  	t.Helper()
   726  	forSlice(t, uint8s, n, func(x []uint8) bool {
   727  		t.Helper()
   728  		a := archsimd.LoadUint8x32(x)
   729  		g := make([]uint8, 32)
   730  		f(a).Store(g)
   731  		w := want(x)
   732  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   733  	})
   734  }
   735  
   736  // testUint16x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   737  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   738  // (extended to at least 128 bits, or truncated to at most 512 bits).
   739  func testUint16x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint8x16, want func(x []uint16) []uint8) {
   740  	n := 16
   741  	t.Helper()
   742  	forSlice(t, uint16s, n, func(x []uint16) bool {
   743  		t.Helper()
   744  		a := archsimd.LoadUint16x16(x)
   745  		g := make([]uint8, 16)
   746  		f(a).Store(g)
   747  		w := want(x)
   748  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   749  	})
   750  }
   751  
   752  // testUint32x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   753  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   754  // (extended to at least 128 bits, or truncated to at most 512 bits).
   755  func testUint32x8ConvertToUint8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint8x16, want func(x []uint32) []uint8) {
   756  	n := 8
   757  	t.Helper()
   758  	forSlice(t, uint32s, n, func(x []uint32) bool {
   759  		t.Helper()
   760  		a := archsimd.LoadUint32x8(x)
   761  		g := make([]uint8, 16)
   762  		f(a).Store(g)
   763  		w := want(x)
   764  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   765  	})
   766  }
   767  
   768  // testUint64x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   769  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   770  // (extended to at least 128 bits, or truncated to at most 512 bits).
   771  func testUint64x4ConvertToUint8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint8x16, want func(x []uint64) []uint8) {
   772  	n := 4
   773  	t.Helper()
   774  	forSlice(t, uint64s, n, func(x []uint64) bool {
   775  		t.Helper()
   776  		a := archsimd.LoadUint64x4(x)
   777  		g := make([]uint8, 16)
   778  		f(a).Store(g)
   779  		w := want(x)
   780  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   781  	})
   782  }
   783  
   784  // testFloat32x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   785  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   786  // (extended to at least 128 bits, or truncated to at most 512 bits).
   787  func testFloat32x8ConvertToUint8(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint8x16, want func(x []float32) []uint8) {
   788  	n := 8
   789  	t.Helper()
   790  	forSlice(t, float32s, n, func(x []float32) bool {
   791  		t.Helper()
   792  		a := archsimd.LoadFloat32x8(x)
   793  		g := make([]uint8, 16)
   794  		f(a).Store(g)
   795  		w := want(x)
   796  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   797  	})
   798  }
   799  
   800  // testFloat64x4ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   801  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   802  // (extended to at least 128 bits, or truncated to at most 512 bits).
   803  func testFloat64x4ConvertToUint8(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint8x16, want func(x []float64) []uint8) {
   804  	n := 4
   805  	t.Helper()
   806  	forSlice(t, float64s, n, func(x []float64) bool {
   807  		t.Helper()
   808  		a := archsimd.LoadFloat64x4(x)
   809  		g := make([]uint8, 16)
   810  		f(a).Store(g)
   811  		w := want(x)
   812  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   813  	})
   814  }
   815  
   816  // testInt8x64ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   817  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   818  // (extended to at least 128 bits, or truncated to at most 512 bits).
   819  func testInt8x64ConvertToUint8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint8x64, want func(x []int8) []uint8) {
   820  	n := 64
   821  	t.Helper()
   822  	forSlice(t, int8s, n, func(x []int8) bool {
   823  		t.Helper()
   824  		a := archsimd.LoadInt8x64(x)
   825  		g := make([]uint8, 64)
   826  		f(a).Store(g)
   827  		w := want(x)
   828  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   829  	})
   830  }
   831  
   832  // testInt16x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   833  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   834  // (extended to at least 128 bits, or truncated to at most 512 bits).
   835  func testInt16x32ConvertToUint8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint8x32, want func(x []int16) []uint8) {
   836  	n := 32
   837  	t.Helper()
   838  	forSlice(t, int16s, n, func(x []int16) bool {
   839  		t.Helper()
   840  		a := archsimd.LoadInt16x32(x)
   841  		g := make([]uint8, 32)
   842  		f(a).Store(g)
   843  		w := want(x)
   844  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   845  	})
   846  }
   847  
   848  // testInt32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   849  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   850  // (extended to at least 128 bits, or truncated to at most 512 bits).
   851  func testInt32x16ConvertToUint8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint8x16, want func(x []int32) []uint8) {
   852  	n := 16
   853  	t.Helper()
   854  	forSlice(t, int32s, n, func(x []int32) bool {
   855  		t.Helper()
   856  		a := archsimd.LoadInt32x16(x)
   857  		g := make([]uint8, 16)
   858  		f(a).Store(g)
   859  		w := want(x)
   860  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   861  	})
   862  }
   863  
   864  // testInt64x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   865  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   866  // (extended to at least 128 bits, or truncated to at most 512 bits).
   867  func testInt64x8ConvertToUint8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint8x16, want func(x []int64) []uint8) {
   868  	n := 8
   869  	t.Helper()
   870  	forSlice(t, int64s, n, func(x []int64) bool {
   871  		t.Helper()
   872  		a := archsimd.LoadInt64x8(x)
   873  		g := make([]uint8, 16)
   874  		f(a).Store(g)
   875  		w := want(x)
   876  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   877  	})
   878  }
   879  
   880  // testUint8x64ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   881  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   882  // (extended to at least 128 bits, or truncated to at most 512 bits).
   883  func testUint8x64ConvertToUint8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint8x64, want func(x []uint8) []uint8) {
   884  	n := 64
   885  	t.Helper()
   886  	forSlice(t, uint8s, n, func(x []uint8) bool {
   887  		t.Helper()
   888  		a := archsimd.LoadUint8x64(x)
   889  		g := make([]uint8, 64)
   890  		f(a).Store(g)
   891  		w := want(x)
   892  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   893  	})
   894  }
   895  
   896  // testUint16x32ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   897  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   898  // (extended to at least 128 bits, or truncated to at most 512 bits).
   899  func testUint16x32ConvertToUint8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint8x32, want func(x []uint16) []uint8) {
   900  	n := 32
   901  	t.Helper()
   902  	forSlice(t, uint16s, n, func(x []uint16) bool {
   903  		t.Helper()
   904  		a := archsimd.LoadUint16x32(x)
   905  		g := make([]uint8, 32)
   906  		f(a).Store(g)
   907  		w := want(x)
   908  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   909  	})
   910  }
   911  
   912  // testUint32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   913  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   914  // (extended to at least 128 bits, or truncated to at most 512 bits).
   915  func testUint32x16ConvertToUint8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint8x16, want func(x []uint32) []uint8) {
   916  	n := 16
   917  	t.Helper()
   918  	forSlice(t, uint32s, n, func(x []uint32) bool {
   919  		t.Helper()
   920  		a := archsimd.LoadUint32x16(x)
   921  		g := make([]uint8, 16)
   922  		f(a).Store(g)
   923  		w := want(x)
   924  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   925  	})
   926  }
   927  
   928  // testUint64x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   929  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   930  // (extended to at least 128 bits, or truncated to at most 512 bits).
   931  func testUint64x8ConvertToUint8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint8x16, want func(x []uint64) []uint8) {
   932  	n := 8
   933  	t.Helper()
   934  	forSlice(t, uint64s, n, func(x []uint64) bool {
   935  		t.Helper()
   936  		a := archsimd.LoadUint64x8(x)
   937  		g := make([]uint8, 16)
   938  		f(a).Store(g)
   939  		w := want(x)
   940  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   941  	})
   942  }
   943  
   944  // testFloat32x16ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   945  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   946  // (extended to at least 128 bits, or truncated to at most 512 bits).
   947  func testFloat32x16ConvertToUint8(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint8x16, want func(x []float32) []uint8) {
   948  	n := 16
   949  	t.Helper()
   950  	forSlice(t, float32s, n, func(x []float32) bool {
   951  		t.Helper()
   952  		a := archsimd.LoadFloat32x16(x)
   953  		g := make([]uint8, 16)
   954  		f(a).Store(g)
   955  		w := want(x)
   956  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   957  	})
   958  }
   959  
   960  // testFloat64x8ConvertToUint8 tests the simd conversion method f against the expected behavior generated by want.
   961  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   962  // (extended to at least 128 bits, or truncated to at most 512 bits).
   963  func testFloat64x8ConvertToUint8(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint8x16, want func(x []float64) []uint8) {
   964  	n := 8
   965  	t.Helper()
   966  	forSlice(t, float64s, n, func(x []float64) bool {
   967  		t.Helper()
   968  		a := archsimd.LoadFloat64x8(x)
   969  		g := make([]uint8, 16)
   970  		f(a).Store(g)
   971  		w := want(x)
   972  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   973  	})
   974  }
   975  
   976  // testInt8x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
   977  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   978  // (extended to at least 128 bits, or truncated to at most 512 bits).
   979  func testInt8x16ConvertToInt16(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int16x16, want func(x []int8) []int16) {
   980  	n := 16
   981  	t.Helper()
   982  	forSlice(t, int8s, n, func(x []int8) bool {
   983  		t.Helper()
   984  		a := archsimd.LoadInt8x16(x)
   985  		g := make([]int16, 16)
   986  		f(a).Store(g)
   987  		w := want(x)
   988  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
   989  	})
   990  }
   991  
   992  // testInt16x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
   993  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
   994  // (extended to at least 128 bits, or truncated to at most 512 bits).
   995  func testInt16x8ConvertToInt16(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int16x8, want func(x []int16) []int16) {
   996  	n := 8
   997  	t.Helper()
   998  	forSlice(t, int16s, n, func(x []int16) bool {
   999  		t.Helper()
  1000  		a := archsimd.LoadInt16x8(x)
  1001  		g := make([]int16, 8)
  1002  		f(a).Store(g)
  1003  		w := want(x)
  1004  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1005  	})
  1006  }
  1007  
  1008  // testInt32x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1009  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1010  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1011  func testInt32x4ConvertToInt16(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int16x8, want func(x []int32) []int16) {
  1012  	n := 4
  1013  	t.Helper()
  1014  	forSlice(t, int32s, n, func(x []int32) bool {
  1015  		t.Helper()
  1016  		a := archsimd.LoadInt32x4(x)
  1017  		g := make([]int16, 8)
  1018  		f(a).Store(g)
  1019  		w := want(x)
  1020  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1021  	})
  1022  }
  1023  
  1024  // testInt64x2ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1025  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1026  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1027  func testInt64x2ConvertToInt16(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int16x8, want func(x []int64) []int16) {
  1028  	n := 2
  1029  	t.Helper()
  1030  	forSlice(t, int64s, n, func(x []int64) bool {
  1031  		t.Helper()
  1032  		a := archsimd.LoadInt64x2(x)
  1033  		g := make([]int16, 8)
  1034  		f(a).Store(g)
  1035  		w := want(x)
  1036  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1037  	})
  1038  }
  1039  
  1040  // testUint8x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1041  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1042  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1043  func testUint8x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int16x16, want func(x []uint8) []int16) {
  1044  	n := 16
  1045  	t.Helper()
  1046  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1047  		t.Helper()
  1048  		a := archsimd.LoadUint8x16(x)
  1049  		g := make([]int16, 16)
  1050  		f(a).Store(g)
  1051  		w := want(x)
  1052  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1053  	})
  1054  }
  1055  
  1056  // testUint16x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1057  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1058  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1059  func testUint16x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int16x8, want func(x []uint16) []int16) {
  1060  	n := 8
  1061  	t.Helper()
  1062  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1063  		t.Helper()
  1064  		a := archsimd.LoadUint16x8(x)
  1065  		g := make([]int16, 8)
  1066  		f(a).Store(g)
  1067  		w := want(x)
  1068  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1069  	})
  1070  }
  1071  
  1072  // testUint32x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1073  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1074  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1075  func testUint32x4ConvertToInt16(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int16x8, want func(x []uint32) []int16) {
  1076  	n := 4
  1077  	t.Helper()
  1078  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1079  		t.Helper()
  1080  		a := archsimd.LoadUint32x4(x)
  1081  		g := make([]int16, 8)
  1082  		f(a).Store(g)
  1083  		w := want(x)
  1084  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1085  	})
  1086  }
  1087  
  1088  // testUint64x2ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1089  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1090  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1091  func testUint64x2ConvertToInt16(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int16x8, want func(x []uint64) []int16) {
  1092  	n := 2
  1093  	t.Helper()
  1094  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1095  		t.Helper()
  1096  		a := archsimd.LoadUint64x2(x)
  1097  		g := make([]int16, 8)
  1098  		f(a).Store(g)
  1099  		w := want(x)
  1100  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1101  	})
  1102  }
  1103  
  1104  // testFloat32x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1105  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1106  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1107  func testFloat32x4ConvertToInt16(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int16x8, want func(x []float32) []int16) {
  1108  	n := 4
  1109  	t.Helper()
  1110  	forSlice(t, float32s, n, func(x []float32) bool {
  1111  		t.Helper()
  1112  		a := archsimd.LoadFloat32x4(x)
  1113  		g := make([]int16, 8)
  1114  		f(a).Store(g)
  1115  		w := want(x)
  1116  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1117  	})
  1118  }
  1119  
  1120  // testFloat64x2ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1121  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1122  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1123  func testFloat64x2ConvertToInt16(t *testing.T, f func(x archsimd.Float64x2) archsimd.Int16x8, want func(x []float64) []int16) {
  1124  	n := 2
  1125  	t.Helper()
  1126  	forSlice(t, float64s, n, func(x []float64) bool {
  1127  		t.Helper()
  1128  		a := archsimd.LoadFloat64x2(x)
  1129  		g := make([]int16, 8)
  1130  		f(a).Store(g)
  1131  		w := want(x)
  1132  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1133  	})
  1134  }
  1135  
  1136  // testInt8x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1137  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1138  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1139  func testInt8x32ConvertToInt16(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int16x32, want func(x []int8) []int16) {
  1140  	n := 32
  1141  	t.Helper()
  1142  	forSlice(t, int8s, n, func(x []int8) bool {
  1143  		t.Helper()
  1144  		a := archsimd.LoadInt8x32(x)
  1145  		g := make([]int16, 32)
  1146  		f(a).Store(g)
  1147  		w := want(x)
  1148  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1149  	})
  1150  }
  1151  
  1152  // testInt16x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1153  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1154  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1155  func testInt16x16ConvertToInt16(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int16x16, want func(x []int16) []int16) {
  1156  	n := 16
  1157  	t.Helper()
  1158  	forSlice(t, int16s, n, func(x []int16) bool {
  1159  		t.Helper()
  1160  		a := archsimd.LoadInt16x16(x)
  1161  		g := make([]int16, 16)
  1162  		f(a).Store(g)
  1163  		w := want(x)
  1164  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1165  	})
  1166  }
  1167  
  1168  // testInt32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1169  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1170  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1171  func testInt32x8ConvertToInt16(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int16x8, want func(x []int32) []int16) {
  1172  	n := 8
  1173  	t.Helper()
  1174  	forSlice(t, int32s, n, func(x []int32) bool {
  1175  		t.Helper()
  1176  		a := archsimd.LoadInt32x8(x)
  1177  		g := make([]int16, 8)
  1178  		f(a).Store(g)
  1179  		w := want(x)
  1180  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1181  	})
  1182  }
  1183  
  1184  // testInt64x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1185  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1186  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1187  func testInt64x4ConvertToInt16(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int16x8, want func(x []int64) []int16) {
  1188  	n := 4
  1189  	t.Helper()
  1190  	forSlice(t, int64s, n, func(x []int64) bool {
  1191  		t.Helper()
  1192  		a := archsimd.LoadInt64x4(x)
  1193  		g := make([]int16, 8)
  1194  		f(a).Store(g)
  1195  		w := want(x)
  1196  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1197  	})
  1198  }
  1199  
  1200  // testUint8x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1201  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1202  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1203  func testUint8x32ConvertToInt16(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int16x32, want func(x []uint8) []int16) {
  1204  	n := 32
  1205  	t.Helper()
  1206  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1207  		t.Helper()
  1208  		a := archsimd.LoadUint8x32(x)
  1209  		g := make([]int16, 32)
  1210  		f(a).Store(g)
  1211  		w := want(x)
  1212  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1213  	})
  1214  }
  1215  
  1216  // testUint16x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1217  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1218  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1219  func testUint16x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int16x16, want func(x []uint16) []int16) {
  1220  	n := 16
  1221  	t.Helper()
  1222  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1223  		t.Helper()
  1224  		a := archsimd.LoadUint16x16(x)
  1225  		g := make([]int16, 16)
  1226  		f(a).Store(g)
  1227  		w := want(x)
  1228  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1229  	})
  1230  }
  1231  
  1232  // testUint32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1233  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1234  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1235  func testUint32x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int16x8, want func(x []uint32) []int16) {
  1236  	n := 8
  1237  	t.Helper()
  1238  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1239  		t.Helper()
  1240  		a := archsimd.LoadUint32x8(x)
  1241  		g := make([]int16, 8)
  1242  		f(a).Store(g)
  1243  		w := want(x)
  1244  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1245  	})
  1246  }
  1247  
  1248  // testUint64x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1249  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1250  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1251  func testUint64x4ConvertToInt16(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int16x8, want func(x []uint64) []int16) {
  1252  	n := 4
  1253  	t.Helper()
  1254  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1255  		t.Helper()
  1256  		a := archsimd.LoadUint64x4(x)
  1257  		g := make([]int16, 8)
  1258  		f(a).Store(g)
  1259  		w := want(x)
  1260  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1261  	})
  1262  }
  1263  
  1264  // testFloat32x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1265  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1266  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1267  func testFloat32x8ConvertToInt16(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int16x8, want func(x []float32) []int16) {
  1268  	n := 8
  1269  	t.Helper()
  1270  	forSlice(t, float32s, n, func(x []float32) bool {
  1271  		t.Helper()
  1272  		a := archsimd.LoadFloat32x8(x)
  1273  		g := make([]int16, 8)
  1274  		f(a).Store(g)
  1275  		w := want(x)
  1276  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1277  	})
  1278  }
  1279  
  1280  // testFloat64x4ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1281  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1282  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1283  func testFloat64x4ConvertToInt16(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int16x8, want func(x []float64) []int16) {
  1284  	n := 4
  1285  	t.Helper()
  1286  	forSlice(t, float64s, n, func(x []float64) bool {
  1287  		t.Helper()
  1288  		a := archsimd.LoadFloat64x4(x)
  1289  		g := make([]int16, 8)
  1290  		f(a).Store(g)
  1291  		w := want(x)
  1292  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1293  	})
  1294  }
  1295  
  1296  // testInt8x64ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1297  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1298  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1299  func testInt8x64ConvertToInt16(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int16x32, want func(x []int8) []int16) {
  1300  	n := 64
  1301  	t.Helper()
  1302  	forSlice(t, int8s, n, func(x []int8) bool {
  1303  		t.Helper()
  1304  		a := archsimd.LoadInt8x64(x)
  1305  		g := make([]int16, 32)
  1306  		f(a).Store(g)
  1307  		w := want(x)
  1308  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1309  	})
  1310  }
  1311  
  1312  // testInt16x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1313  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1314  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1315  func testInt16x32ConvertToInt16(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int16x32, want func(x []int16) []int16) {
  1316  	n := 32
  1317  	t.Helper()
  1318  	forSlice(t, int16s, n, func(x []int16) bool {
  1319  		t.Helper()
  1320  		a := archsimd.LoadInt16x32(x)
  1321  		g := make([]int16, 32)
  1322  		f(a).Store(g)
  1323  		w := want(x)
  1324  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1325  	})
  1326  }
  1327  
  1328  // testInt32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1329  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1330  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1331  func testInt32x16ConvertToInt16(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int16x16, want func(x []int32) []int16) {
  1332  	n := 16
  1333  	t.Helper()
  1334  	forSlice(t, int32s, n, func(x []int32) bool {
  1335  		t.Helper()
  1336  		a := archsimd.LoadInt32x16(x)
  1337  		g := make([]int16, 16)
  1338  		f(a).Store(g)
  1339  		w := want(x)
  1340  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1341  	})
  1342  }
  1343  
  1344  // testInt64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1345  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1346  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1347  func testInt64x8ConvertToInt16(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int16x8, want func(x []int64) []int16) {
  1348  	n := 8
  1349  	t.Helper()
  1350  	forSlice(t, int64s, n, func(x []int64) bool {
  1351  		t.Helper()
  1352  		a := archsimd.LoadInt64x8(x)
  1353  		g := make([]int16, 8)
  1354  		f(a).Store(g)
  1355  		w := want(x)
  1356  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1357  	})
  1358  }
  1359  
  1360  // testUint8x64ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1361  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1362  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1363  func testUint8x64ConvertToInt16(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int16x32, want func(x []uint8) []int16) {
  1364  	n := 64
  1365  	t.Helper()
  1366  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1367  		t.Helper()
  1368  		a := archsimd.LoadUint8x64(x)
  1369  		g := make([]int16, 32)
  1370  		f(a).Store(g)
  1371  		w := want(x)
  1372  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1373  	})
  1374  }
  1375  
  1376  // testUint16x32ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1377  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1378  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1379  func testUint16x32ConvertToInt16(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int16x32, want func(x []uint16) []int16) {
  1380  	n := 32
  1381  	t.Helper()
  1382  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1383  		t.Helper()
  1384  		a := archsimd.LoadUint16x32(x)
  1385  		g := make([]int16, 32)
  1386  		f(a).Store(g)
  1387  		w := want(x)
  1388  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1389  	})
  1390  }
  1391  
  1392  // testUint32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1393  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1394  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1395  func testUint32x16ConvertToInt16(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int16x16, want func(x []uint32) []int16) {
  1396  	n := 16
  1397  	t.Helper()
  1398  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1399  		t.Helper()
  1400  		a := archsimd.LoadUint32x16(x)
  1401  		g := make([]int16, 16)
  1402  		f(a).Store(g)
  1403  		w := want(x)
  1404  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1405  	})
  1406  }
  1407  
  1408  // testUint64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1409  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1410  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1411  func testUint64x8ConvertToInt16(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int16x8, want func(x []uint64) []int16) {
  1412  	n := 8
  1413  	t.Helper()
  1414  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1415  		t.Helper()
  1416  		a := archsimd.LoadUint64x8(x)
  1417  		g := make([]int16, 8)
  1418  		f(a).Store(g)
  1419  		w := want(x)
  1420  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1421  	})
  1422  }
  1423  
  1424  // testFloat32x16ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1425  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1426  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1427  func testFloat32x16ConvertToInt16(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int16x16, want func(x []float32) []int16) {
  1428  	n := 16
  1429  	t.Helper()
  1430  	forSlice(t, float32s, n, func(x []float32) bool {
  1431  		t.Helper()
  1432  		a := archsimd.LoadFloat32x16(x)
  1433  		g := make([]int16, 16)
  1434  		f(a).Store(g)
  1435  		w := want(x)
  1436  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1437  	})
  1438  }
  1439  
  1440  // testFloat64x8ConvertToInt16 tests the simd conversion method f against the expected behavior generated by want.
  1441  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1442  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1443  func testFloat64x8ConvertToInt16(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int16x8, want func(x []float64) []int16) {
  1444  	n := 8
  1445  	t.Helper()
  1446  	forSlice(t, float64s, n, func(x []float64) bool {
  1447  		t.Helper()
  1448  		a := archsimd.LoadFloat64x8(x)
  1449  		g := make([]int16, 8)
  1450  		f(a).Store(g)
  1451  		w := want(x)
  1452  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1453  	})
  1454  }
  1455  
  1456  // testInt8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1457  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1458  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1459  func testInt8x16ConvertToUint16(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint16x16, want func(x []int8) []uint16) {
  1460  	n := 16
  1461  	t.Helper()
  1462  	forSlice(t, int8s, n, func(x []int8) bool {
  1463  		t.Helper()
  1464  		a := archsimd.LoadInt8x16(x)
  1465  		g := make([]uint16, 16)
  1466  		f(a).Store(g)
  1467  		w := want(x)
  1468  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1469  	})
  1470  }
  1471  
  1472  // testInt16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1473  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1474  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1475  func testInt16x8ConvertToUint16(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint16x8, want func(x []int16) []uint16) {
  1476  	n := 8
  1477  	t.Helper()
  1478  	forSlice(t, int16s, n, func(x []int16) bool {
  1479  		t.Helper()
  1480  		a := archsimd.LoadInt16x8(x)
  1481  		g := make([]uint16, 8)
  1482  		f(a).Store(g)
  1483  		w := want(x)
  1484  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1485  	})
  1486  }
  1487  
  1488  // testInt32x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1489  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1490  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1491  func testInt32x4ConvertToUint16(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint16x8, want func(x []int32) []uint16) {
  1492  	n := 4
  1493  	t.Helper()
  1494  	forSlice(t, int32s, n, func(x []int32) bool {
  1495  		t.Helper()
  1496  		a := archsimd.LoadInt32x4(x)
  1497  		g := make([]uint16, 8)
  1498  		f(a).Store(g)
  1499  		w := want(x)
  1500  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1501  	})
  1502  }
  1503  
  1504  // testInt64x2ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1505  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1506  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1507  func testInt64x2ConvertToUint16(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint16x8, want func(x []int64) []uint16) {
  1508  	n := 2
  1509  	t.Helper()
  1510  	forSlice(t, int64s, n, func(x []int64) bool {
  1511  		t.Helper()
  1512  		a := archsimd.LoadInt64x2(x)
  1513  		g := make([]uint16, 8)
  1514  		f(a).Store(g)
  1515  		w := want(x)
  1516  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1517  	})
  1518  }
  1519  
  1520  // testUint8x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1521  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1522  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1523  func testUint8x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint16x16, want func(x []uint8) []uint16) {
  1524  	n := 16
  1525  	t.Helper()
  1526  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1527  		t.Helper()
  1528  		a := archsimd.LoadUint8x16(x)
  1529  		g := make([]uint16, 16)
  1530  		f(a).Store(g)
  1531  		w := want(x)
  1532  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1533  	})
  1534  }
  1535  
  1536  // testUint16x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1537  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1538  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1539  func testUint16x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint16x8, want func(x []uint16) []uint16) {
  1540  	n := 8
  1541  	t.Helper()
  1542  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1543  		t.Helper()
  1544  		a := archsimd.LoadUint16x8(x)
  1545  		g := make([]uint16, 8)
  1546  		f(a).Store(g)
  1547  		w := want(x)
  1548  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1549  	})
  1550  }
  1551  
  1552  // testUint32x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1553  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1554  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1555  func testUint32x4ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint16x8, want func(x []uint32) []uint16) {
  1556  	n := 4
  1557  	t.Helper()
  1558  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1559  		t.Helper()
  1560  		a := archsimd.LoadUint32x4(x)
  1561  		g := make([]uint16, 8)
  1562  		f(a).Store(g)
  1563  		w := want(x)
  1564  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1565  	})
  1566  }
  1567  
  1568  // testUint64x2ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1569  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1570  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1571  func testUint64x2ConvertToUint16(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  1572  	n := 2
  1573  	t.Helper()
  1574  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1575  		t.Helper()
  1576  		a := archsimd.LoadUint64x2(x)
  1577  		g := make([]uint16, 8)
  1578  		f(a).Store(g)
  1579  		w := want(x)
  1580  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1581  	})
  1582  }
  1583  
  1584  // testFloat32x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1585  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1586  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1587  func testFloat32x4ConvertToUint16(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint16x8, want func(x []float32) []uint16) {
  1588  	n := 4
  1589  	t.Helper()
  1590  	forSlice(t, float32s, n, func(x []float32) bool {
  1591  		t.Helper()
  1592  		a := archsimd.LoadFloat32x4(x)
  1593  		g := make([]uint16, 8)
  1594  		f(a).Store(g)
  1595  		w := want(x)
  1596  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1597  	})
  1598  }
  1599  
  1600  // testFloat64x2ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1601  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1602  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1603  func testFloat64x2ConvertToUint16(t *testing.T, f func(x archsimd.Float64x2) archsimd.Uint16x8, want func(x []float64) []uint16) {
  1604  	n := 2
  1605  	t.Helper()
  1606  	forSlice(t, float64s, n, func(x []float64) bool {
  1607  		t.Helper()
  1608  		a := archsimd.LoadFloat64x2(x)
  1609  		g := make([]uint16, 8)
  1610  		f(a).Store(g)
  1611  		w := want(x)
  1612  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1613  	})
  1614  }
  1615  
  1616  // testInt8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1617  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1618  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1619  func testInt8x32ConvertToUint16(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint16x32, want func(x []int8) []uint16) {
  1620  	n := 32
  1621  	t.Helper()
  1622  	forSlice(t, int8s, n, func(x []int8) bool {
  1623  		t.Helper()
  1624  		a := archsimd.LoadInt8x32(x)
  1625  		g := make([]uint16, 32)
  1626  		f(a).Store(g)
  1627  		w := want(x)
  1628  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1629  	})
  1630  }
  1631  
  1632  // testInt16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1633  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1634  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1635  func testInt16x16ConvertToUint16(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint16x16, want func(x []int16) []uint16) {
  1636  	n := 16
  1637  	t.Helper()
  1638  	forSlice(t, int16s, n, func(x []int16) bool {
  1639  		t.Helper()
  1640  		a := archsimd.LoadInt16x16(x)
  1641  		g := make([]uint16, 16)
  1642  		f(a).Store(g)
  1643  		w := want(x)
  1644  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1645  	})
  1646  }
  1647  
  1648  // testInt32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1649  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1650  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1651  func testInt32x8ConvertToUint16(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint16x8, want func(x []int32) []uint16) {
  1652  	n := 8
  1653  	t.Helper()
  1654  	forSlice(t, int32s, n, func(x []int32) bool {
  1655  		t.Helper()
  1656  		a := archsimd.LoadInt32x8(x)
  1657  		g := make([]uint16, 8)
  1658  		f(a).Store(g)
  1659  		w := want(x)
  1660  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1661  	})
  1662  }
  1663  
  1664  // testInt64x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1665  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1666  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1667  func testInt64x4ConvertToUint16(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint16x8, want func(x []int64) []uint16) {
  1668  	n := 4
  1669  	t.Helper()
  1670  	forSlice(t, int64s, n, func(x []int64) bool {
  1671  		t.Helper()
  1672  		a := archsimd.LoadInt64x4(x)
  1673  		g := make([]uint16, 8)
  1674  		f(a).Store(g)
  1675  		w := want(x)
  1676  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1677  	})
  1678  }
  1679  
  1680  // testUint8x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1681  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1682  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1683  func testUint8x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint16x32, want func(x []uint8) []uint16) {
  1684  	n := 32
  1685  	t.Helper()
  1686  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1687  		t.Helper()
  1688  		a := archsimd.LoadUint8x32(x)
  1689  		g := make([]uint16, 32)
  1690  		f(a).Store(g)
  1691  		w := want(x)
  1692  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1693  	})
  1694  }
  1695  
  1696  // testUint16x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1697  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1698  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1699  func testUint16x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint16x16, want func(x []uint16) []uint16) {
  1700  	n := 16
  1701  	t.Helper()
  1702  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1703  		t.Helper()
  1704  		a := archsimd.LoadUint16x16(x)
  1705  		g := make([]uint16, 16)
  1706  		f(a).Store(g)
  1707  		w := want(x)
  1708  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1709  	})
  1710  }
  1711  
  1712  // testUint32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1713  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1714  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1715  func testUint32x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint16x8, want func(x []uint32) []uint16) {
  1716  	n := 8
  1717  	t.Helper()
  1718  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1719  		t.Helper()
  1720  		a := archsimd.LoadUint32x8(x)
  1721  		g := make([]uint16, 8)
  1722  		f(a).Store(g)
  1723  		w := want(x)
  1724  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1725  	})
  1726  }
  1727  
  1728  // testUint64x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1729  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1730  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1731  func testUint64x4ConvertToUint16(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  1732  	n := 4
  1733  	t.Helper()
  1734  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1735  		t.Helper()
  1736  		a := archsimd.LoadUint64x4(x)
  1737  		g := make([]uint16, 8)
  1738  		f(a).Store(g)
  1739  		w := want(x)
  1740  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1741  	})
  1742  }
  1743  
  1744  // testFloat32x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1745  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1746  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1747  func testFloat32x8ConvertToUint16(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint16x8, want func(x []float32) []uint16) {
  1748  	n := 8
  1749  	t.Helper()
  1750  	forSlice(t, float32s, n, func(x []float32) bool {
  1751  		t.Helper()
  1752  		a := archsimd.LoadFloat32x8(x)
  1753  		g := make([]uint16, 8)
  1754  		f(a).Store(g)
  1755  		w := want(x)
  1756  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1757  	})
  1758  }
  1759  
  1760  // testFloat64x4ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1761  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1762  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1763  func testFloat64x4ConvertToUint16(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint16x8, want func(x []float64) []uint16) {
  1764  	n := 4
  1765  	t.Helper()
  1766  	forSlice(t, float64s, n, func(x []float64) bool {
  1767  		t.Helper()
  1768  		a := archsimd.LoadFloat64x4(x)
  1769  		g := make([]uint16, 8)
  1770  		f(a).Store(g)
  1771  		w := want(x)
  1772  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1773  	})
  1774  }
  1775  
  1776  // testInt8x64ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1777  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1778  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1779  func testInt8x64ConvertToUint16(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint16x32, want func(x []int8) []uint16) {
  1780  	n := 64
  1781  	t.Helper()
  1782  	forSlice(t, int8s, n, func(x []int8) bool {
  1783  		t.Helper()
  1784  		a := archsimd.LoadInt8x64(x)
  1785  		g := make([]uint16, 32)
  1786  		f(a).Store(g)
  1787  		w := want(x)
  1788  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1789  	})
  1790  }
  1791  
  1792  // testInt16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1793  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1794  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1795  func testInt16x32ConvertToUint16(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint16x32, want func(x []int16) []uint16) {
  1796  	n := 32
  1797  	t.Helper()
  1798  	forSlice(t, int16s, n, func(x []int16) bool {
  1799  		t.Helper()
  1800  		a := archsimd.LoadInt16x32(x)
  1801  		g := make([]uint16, 32)
  1802  		f(a).Store(g)
  1803  		w := want(x)
  1804  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1805  	})
  1806  }
  1807  
  1808  // testInt32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1809  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1810  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1811  func testInt32x16ConvertToUint16(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint16x16, want func(x []int32) []uint16) {
  1812  	n := 16
  1813  	t.Helper()
  1814  	forSlice(t, int32s, n, func(x []int32) bool {
  1815  		t.Helper()
  1816  		a := archsimd.LoadInt32x16(x)
  1817  		g := make([]uint16, 16)
  1818  		f(a).Store(g)
  1819  		w := want(x)
  1820  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1821  	})
  1822  }
  1823  
  1824  // testInt64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1825  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1826  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1827  func testInt64x8ConvertToUint16(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint16x8, want func(x []int64) []uint16) {
  1828  	n := 8
  1829  	t.Helper()
  1830  	forSlice(t, int64s, n, func(x []int64) bool {
  1831  		t.Helper()
  1832  		a := archsimd.LoadInt64x8(x)
  1833  		g := make([]uint16, 8)
  1834  		f(a).Store(g)
  1835  		w := want(x)
  1836  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1837  	})
  1838  }
  1839  
  1840  // testUint8x64ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1841  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1842  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1843  func testUint8x64ConvertToUint16(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint16x32, want func(x []uint8) []uint16) {
  1844  	n := 64
  1845  	t.Helper()
  1846  	forSlice(t, uint8s, n, func(x []uint8) bool {
  1847  		t.Helper()
  1848  		a := archsimd.LoadUint8x64(x)
  1849  		g := make([]uint16, 32)
  1850  		f(a).Store(g)
  1851  		w := want(x)
  1852  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1853  	})
  1854  }
  1855  
  1856  // testUint16x32ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1857  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1858  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1859  func testUint16x32ConvertToUint16(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint16x32, want func(x []uint16) []uint16) {
  1860  	n := 32
  1861  	t.Helper()
  1862  	forSlice(t, uint16s, n, func(x []uint16) bool {
  1863  		t.Helper()
  1864  		a := archsimd.LoadUint16x32(x)
  1865  		g := make([]uint16, 32)
  1866  		f(a).Store(g)
  1867  		w := want(x)
  1868  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1869  	})
  1870  }
  1871  
  1872  // testUint32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1873  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1874  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1875  func testUint32x16ConvertToUint16(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint16x16, want func(x []uint32) []uint16) {
  1876  	n := 16
  1877  	t.Helper()
  1878  	forSlice(t, uint32s, n, func(x []uint32) bool {
  1879  		t.Helper()
  1880  		a := archsimd.LoadUint32x16(x)
  1881  		g := make([]uint16, 16)
  1882  		f(a).Store(g)
  1883  		w := want(x)
  1884  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1885  	})
  1886  }
  1887  
  1888  // testUint64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1889  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1890  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1891  func testUint64x8ConvertToUint16(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  1892  	n := 8
  1893  	t.Helper()
  1894  	forSlice(t, uint64s, n, func(x []uint64) bool {
  1895  		t.Helper()
  1896  		a := archsimd.LoadUint64x8(x)
  1897  		g := make([]uint16, 8)
  1898  		f(a).Store(g)
  1899  		w := want(x)
  1900  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1901  	})
  1902  }
  1903  
  1904  // testFloat32x16ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1905  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1906  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1907  func testFloat32x16ConvertToUint16(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint16x16, want func(x []float32) []uint16) {
  1908  	n := 16
  1909  	t.Helper()
  1910  	forSlice(t, float32s, n, func(x []float32) bool {
  1911  		t.Helper()
  1912  		a := archsimd.LoadFloat32x16(x)
  1913  		g := make([]uint16, 16)
  1914  		f(a).Store(g)
  1915  		w := want(x)
  1916  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1917  	})
  1918  }
  1919  
  1920  // testFloat64x8ConvertToUint16 tests the simd conversion method f against the expected behavior generated by want.
  1921  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1922  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1923  func testFloat64x8ConvertToUint16(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint16x8, want func(x []float64) []uint16) {
  1924  	n := 8
  1925  	t.Helper()
  1926  	forSlice(t, float64s, n, func(x []float64) bool {
  1927  		t.Helper()
  1928  		a := archsimd.LoadFloat64x8(x)
  1929  		g := make([]uint16, 8)
  1930  		f(a).Store(g)
  1931  		w := want(x)
  1932  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1933  	})
  1934  }
  1935  
  1936  // testInt8x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  1937  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1938  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1939  func testInt8x16ConvertToInt32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int32x16, want func(x []int8) []int32) {
  1940  	n := 16
  1941  	t.Helper()
  1942  	forSlice(t, int8s, n, func(x []int8) bool {
  1943  		t.Helper()
  1944  		a := archsimd.LoadInt8x16(x)
  1945  		g := make([]int32, 16)
  1946  		f(a).Store(g)
  1947  		w := want(x)
  1948  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1949  	})
  1950  }
  1951  
  1952  // testInt16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  1953  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1954  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1955  func testInt16x8ConvertToInt32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int32x8, want func(x []int16) []int32) {
  1956  	n := 8
  1957  	t.Helper()
  1958  	forSlice(t, int16s, n, func(x []int16) bool {
  1959  		t.Helper()
  1960  		a := archsimd.LoadInt16x8(x)
  1961  		g := make([]int32, 8)
  1962  		f(a).Store(g)
  1963  		w := want(x)
  1964  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1965  	})
  1966  }
  1967  
  1968  // testInt32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  1969  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1970  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1971  func testInt32x4ConvertToInt32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int32x4, want func(x []int32) []int32) {
  1972  	n := 4
  1973  	t.Helper()
  1974  	forSlice(t, int32s, n, func(x []int32) bool {
  1975  		t.Helper()
  1976  		a := archsimd.LoadInt32x4(x)
  1977  		g := make([]int32, 4)
  1978  		f(a).Store(g)
  1979  		w := want(x)
  1980  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1981  	})
  1982  }
  1983  
  1984  // testInt64x2ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  1985  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  1986  // (extended to at least 128 bits, or truncated to at most 512 bits).
  1987  func testInt64x2ConvertToInt32(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int32x4, want func(x []int64) []int32) {
  1988  	n := 2
  1989  	t.Helper()
  1990  	forSlice(t, int64s, n, func(x []int64) bool {
  1991  		t.Helper()
  1992  		a := archsimd.LoadInt64x2(x)
  1993  		g := make([]int32, 4)
  1994  		f(a).Store(g)
  1995  		w := want(x)
  1996  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  1997  	})
  1998  }
  1999  
  2000  // testUint8x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2001  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2002  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2003  func testUint8x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int32x16, want func(x []uint8) []int32) {
  2004  	n := 16
  2005  	t.Helper()
  2006  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2007  		t.Helper()
  2008  		a := archsimd.LoadUint8x16(x)
  2009  		g := make([]int32, 16)
  2010  		f(a).Store(g)
  2011  		w := want(x)
  2012  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2013  	})
  2014  }
  2015  
  2016  // testUint16x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2017  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2018  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2019  func testUint16x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int32x8, want func(x []uint16) []int32) {
  2020  	n := 8
  2021  	t.Helper()
  2022  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2023  		t.Helper()
  2024  		a := archsimd.LoadUint16x8(x)
  2025  		g := make([]int32, 8)
  2026  		f(a).Store(g)
  2027  		w := want(x)
  2028  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2029  	})
  2030  }
  2031  
  2032  // testUint32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2033  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2034  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2035  func testUint32x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int32x4, want func(x []uint32) []int32) {
  2036  	n := 4
  2037  	t.Helper()
  2038  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2039  		t.Helper()
  2040  		a := archsimd.LoadUint32x4(x)
  2041  		g := make([]int32, 4)
  2042  		f(a).Store(g)
  2043  		w := want(x)
  2044  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2045  	})
  2046  }
  2047  
  2048  // testUint64x2ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2049  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2050  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2051  func testUint64x2ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int32x4, want func(x []uint64) []int32) {
  2052  	n := 2
  2053  	t.Helper()
  2054  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2055  		t.Helper()
  2056  		a := archsimd.LoadUint64x2(x)
  2057  		g := make([]int32, 4)
  2058  		f(a).Store(g)
  2059  		w := want(x)
  2060  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2061  	})
  2062  }
  2063  
  2064  // testFloat32x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2065  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2066  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2067  func testFloat32x4ConvertToInt32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int32x4, want func(x []float32) []int32) {
  2068  	n := 4
  2069  	t.Helper()
  2070  	forSlice(t, float32s, n, func(x []float32) bool {
  2071  		t.Helper()
  2072  		a := archsimd.LoadFloat32x4(x)
  2073  		g := make([]int32, 4)
  2074  		f(a).Store(g)
  2075  		w := want(x)
  2076  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2077  	})
  2078  }
  2079  
  2080  // testFloat64x2ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2081  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2082  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2083  func testFloat64x2ConvertToInt32(t *testing.T, f func(x archsimd.Float64x2) archsimd.Int32x4, want func(x []float64) []int32) {
  2084  	n := 2
  2085  	t.Helper()
  2086  	forSlice(t, float64s, n, func(x []float64) bool {
  2087  		t.Helper()
  2088  		a := archsimd.LoadFloat64x2(x)
  2089  		g := make([]int32, 4)
  2090  		f(a).Store(g)
  2091  		w := want(x)
  2092  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2093  	})
  2094  }
  2095  
  2096  // testInt8x32ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2097  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2098  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2099  func testInt8x32ConvertToInt32(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int32x16, want func(x []int8) []int32) {
  2100  	n := 32
  2101  	t.Helper()
  2102  	forSlice(t, int8s, n, func(x []int8) bool {
  2103  		t.Helper()
  2104  		a := archsimd.LoadInt8x32(x)
  2105  		g := make([]int32, 16)
  2106  		f(a).Store(g)
  2107  		w := want(x)
  2108  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2109  	})
  2110  }
  2111  
  2112  // testInt16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2113  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2114  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2115  func testInt16x16ConvertToInt32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int32x16, want func(x []int16) []int32) {
  2116  	n := 16
  2117  	t.Helper()
  2118  	forSlice(t, int16s, n, func(x []int16) bool {
  2119  		t.Helper()
  2120  		a := archsimd.LoadInt16x16(x)
  2121  		g := make([]int32, 16)
  2122  		f(a).Store(g)
  2123  		w := want(x)
  2124  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2125  	})
  2126  }
  2127  
  2128  // testInt32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2129  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2130  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2131  func testInt32x8ConvertToInt32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int32x8, want func(x []int32) []int32) {
  2132  	n := 8
  2133  	t.Helper()
  2134  	forSlice(t, int32s, n, func(x []int32) bool {
  2135  		t.Helper()
  2136  		a := archsimd.LoadInt32x8(x)
  2137  		g := make([]int32, 8)
  2138  		f(a).Store(g)
  2139  		w := want(x)
  2140  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2141  	})
  2142  }
  2143  
  2144  // testInt64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2145  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2146  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2147  func testInt64x4ConvertToInt32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int32x4, want func(x []int64) []int32) {
  2148  	n := 4
  2149  	t.Helper()
  2150  	forSlice(t, int64s, n, func(x []int64) bool {
  2151  		t.Helper()
  2152  		a := archsimd.LoadInt64x4(x)
  2153  		g := make([]int32, 4)
  2154  		f(a).Store(g)
  2155  		w := want(x)
  2156  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2157  	})
  2158  }
  2159  
  2160  // testUint8x32ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2161  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2162  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2163  func testUint8x32ConvertToInt32(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int32x16, want func(x []uint8) []int32) {
  2164  	n := 32
  2165  	t.Helper()
  2166  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2167  		t.Helper()
  2168  		a := archsimd.LoadUint8x32(x)
  2169  		g := make([]int32, 16)
  2170  		f(a).Store(g)
  2171  		w := want(x)
  2172  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2173  	})
  2174  }
  2175  
  2176  // testUint16x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2177  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2178  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2179  func testUint16x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int32x16, want func(x []uint16) []int32) {
  2180  	n := 16
  2181  	t.Helper()
  2182  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2183  		t.Helper()
  2184  		a := archsimd.LoadUint16x16(x)
  2185  		g := make([]int32, 16)
  2186  		f(a).Store(g)
  2187  		w := want(x)
  2188  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2189  	})
  2190  }
  2191  
  2192  // testUint32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2193  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2194  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2195  func testUint32x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int32x8, want func(x []uint32) []int32) {
  2196  	n := 8
  2197  	t.Helper()
  2198  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2199  		t.Helper()
  2200  		a := archsimd.LoadUint32x8(x)
  2201  		g := make([]int32, 8)
  2202  		f(a).Store(g)
  2203  		w := want(x)
  2204  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2205  	})
  2206  }
  2207  
  2208  // testUint64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2209  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2210  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2211  func testUint64x4ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int32x4, want func(x []uint64) []int32) {
  2212  	n := 4
  2213  	t.Helper()
  2214  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2215  		t.Helper()
  2216  		a := archsimd.LoadUint64x4(x)
  2217  		g := make([]int32, 4)
  2218  		f(a).Store(g)
  2219  		w := want(x)
  2220  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2221  	})
  2222  }
  2223  
  2224  // testFloat32x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2225  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2226  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2227  func testFloat32x8ConvertToInt32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int32x8, want func(x []float32) []int32) {
  2228  	n := 8
  2229  	t.Helper()
  2230  	forSlice(t, float32s, n, func(x []float32) bool {
  2231  		t.Helper()
  2232  		a := archsimd.LoadFloat32x8(x)
  2233  		g := make([]int32, 8)
  2234  		f(a).Store(g)
  2235  		w := want(x)
  2236  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2237  	})
  2238  }
  2239  
  2240  // testFloat64x4ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2241  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2242  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2243  func testFloat64x4ConvertToInt32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int32x4, want func(x []float64) []int32) {
  2244  	n := 4
  2245  	t.Helper()
  2246  	forSlice(t, float64s, n, func(x []float64) bool {
  2247  		t.Helper()
  2248  		a := archsimd.LoadFloat64x4(x)
  2249  		g := make([]int32, 4)
  2250  		f(a).Store(g)
  2251  		w := want(x)
  2252  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2253  	})
  2254  }
  2255  
  2256  // testInt8x64ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2257  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2258  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2259  func testInt8x64ConvertToInt32(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int32x16, want func(x []int8) []int32) {
  2260  	n := 64
  2261  	t.Helper()
  2262  	forSlice(t, int8s, n, func(x []int8) bool {
  2263  		t.Helper()
  2264  		a := archsimd.LoadInt8x64(x)
  2265  		g := make([]int32, 16)
  2266  		f(a).Store(g)
  2267  		w := want(x)
  2268  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2269  	})
  2270  }
  2271  
  2272  // testInt16x32ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2273  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2274  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2275  func testInt16x32ConvertToInt32(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int32x16, want func(x []int16) []int32) {
  2276  	n := 32
  2277  	t.Helper()
  2278  	forSlice(t, int16s, n, func(x []int16) bool {
  2279  		t.Helper()
  2280  		a := archsimd.LoadInt16x32(x)
  2281  		g := make([]int32, 16)
  2282  		f(a).Store(g)
  2283  		w := want(x)
  2284  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2285  	})
  2286  }
  2287  
  2288  // testInt32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2289  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2290  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2291  func testInt32x16ConvertToInt32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int32x16, want func(x []int32) []int32) {
  2292  	n := 16
  2293  	t.Helper()
  2294  	forSlice(t, int32s, n, func(x []int32) bool {
  2295  		t.Helper()
  2296  		a := archsimd.LoadInt32x16(x)
  2297  		g := make([]int32, 16)
  2298  		f(a).Store(g)
  2299  		w := want(x)
  2300  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2301  	})
  2302  }
  2303  
  2304  // testInt64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2305  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2306  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2307  func testInt64x8ConvertToInt32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int32x8, want func(x []int64) []int32) {
  2308  	n := 8
  2309  	t.Helper()
  2310  	forSlice(t, int64s, n, func(x []int64) bool {
  2311  		t.Helper()
  2312  		a := archsimd.LoadInt64x8(x)
  2313  		g := make([]int32, 8)
  2314  		f(a).Store(g)
  2315  		w := want(x)
  2316  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2317  	})
  2318  }
  2319  
  2320  // testUint8x64ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2321  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2322  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2323  func testUint8x64ConvertToInt32(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int32x16, want func(x []uint8) []int32) {
  2324  	n := 64
  2325  	t.Helper()
  2326  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2327  		t.Helper()
  2328  		a := archsimd.LoadUint8x64(x)
  2329  		g := make([]int32, 16)
  2330  		f(a).Store(g)
  2331  		w := want(x)
  2332  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2333  	})
  2334  }
  2335  
  2336  // testUint16x32ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2337  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2338  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2339  func testUint16x32ConvertToInt32(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int32x16, want func(x []uint16) []int32) {
  2340  	n := 32
  2341  	t.Helper()
  2342  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2343  		t.Helper()
  2344  		a := archsimd.LoadUint16x32(x)
  2345  		g := make([]int32, 16)
  2346  		f(a).Store(g)
  2347  		w := want(x)
  2348  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2349  	})
  2350  }
  2351  
  2352  // testUint32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2353  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2354  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2355  func testUint32x16ConvertToInt32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int32x16, want func(x []uint32) []int32) {
  2356  	n := 16
  2357  	t.Helper()
  2358  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2359  		t.Helper()
  2360  		a := archsimd.LoadUint32x16(x)
  2361  		g := make([]int32, 16)
  2362  		f(a).Store(g)
  2363  		w := want(x)
  2364  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2365  	})
  2366  }
  2367  
  2368  // testUint64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2369  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2370  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2371  func testUint64x8ConvertToInt32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int32x8, want func(x []uint64) []int32) {
  2372  	n := 8
  2373  	t.Helper()
  2374  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2375  		t.Helper()
  2376  		a := archsimd.LoadUint64x8(x)
  2377  		g := make([]int32, 8)
  2378  		f(a).Store(g)
  2379  		w := want(x)
  2380  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2381  	})
  2382  }
  2383  
  2384  // testFloat32x16ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2385  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2386  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2387  func testFloat32x16ConvertToInt32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int32x16, want func(x []float32) []int32) {
  2388  	n := 16
  2389  	t.Helper()
  2390  	forSlice(t, float32s, n, func(x []float32) bool {
  2391  		t.Helper()
  2392  		a := archsimd.LoadFloat32x16(x)
  2393  		g := make([]int32, 16)
  2394  		f(a).Store(g)
  2395  		w := want(x)
  2396  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2397  	})
  2398  }
  2399  
  2400  // testFloat64x8ConvertToInt32 tests the simd conversion method f against the expected behavior generated by want.
  2401  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2402  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2403  func testFloat64x8ConvertToInt32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int32x8, want func(x []float64) []int32) {
  2404  	n := 8
  2405  	t.Helper()
  2406  	forSlice(t, float64s, n, func(x []float64) bool {
  2407  		t.Helper()
  2408  		a := archsimd.LoadFloat64x8(x)
  2409  		g := make([]int32, 8)
  2410  		f(a).Store(g)
  2411  		w := want(x)
  2412  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2413  	})
  2414  }
  2415  
  2416  // testInt8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2417  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2418  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2419  func testInt8x16ConvertToUint32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint32x16, want func(x []int8) []uint32) {
  2420  	n := 16
  2421  	t.Helper()
  2422  	forSlice(t, int8s, n, func(x []int8) bool {
  2423  		t.Helper()
  2424  		a := archsimd.LoadInt8x16(x)
  2425  		g := make([]uint32, 16)
  2426  		f(a).Store(g)
  2427  		w := want(x)
  2428  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2429  	})
  2430  }
  2431  
  2432  // testInt16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2433  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2434  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2435  func testInt16x8ConvertToUint32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint32x8, want func(x []int16) []uint32) {
  2436  	n := 8
  2437  	t.Helper()
  2438  	forSlice(t, int16s, n, func(x []int16) bool {
  2439  		t.Helper()
  2440  		a := archsimd.LoadInt16x8(x)
  2441  		g := make([]uint32, 8)
  2442  		f(a).Store(g)
  2443  		w := want(x)
  2444  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2445  	})
  2446  }
  2447  
  2448  // testInt32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2449  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2450  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2451  func testInt32x4ConvertToUint32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint32x4, want func(x []int32) []uint32) {
  2452  	n := 4
  2453  	t.Helper()
  2454  	forSlice(t, int32s, n, func(x []int32) bool {
  2455  		t.Helper()
  2456  		a := archsimd.LoadInt32x4(x)
  2457  		g := make([]uint32, 4)
  2458  		f(a).Store(g)
  2459  		w := want(x)
  2460  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2461  	})
  2462  }
  2463  
  2464  // testInt64x2ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2465  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2466  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2467  func testInt64x2ConvertToUint32(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint32x4, want func(x []int64) []uint32) {
  2468  	n := 2
  2469  	t.Helper()
  2470  	forSlice(t, int64s, n, func(x []int64) bool {
  2471  		t.Helper()
  2472  		a := archsimd.LoadInt64x2(x)
  2473  		g := make([]uint32, 4)
  2474  		f(a).Store(g)
  2475  		w := want(x)
  2476  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2477  	})
  2478  }
  2479  
  2480  // testUint8x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2481  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2482  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2483  func testUint8x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint32x16, want func(x []uint8) []uint32) {
  2484  	n := 16
  2485  	t.Helper()
  2486  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2487  		t.Helper()
  2488  		a := archsimd.LoadUint8x16(x)
  2489  		g := make([]uint32, 16)
  2490  		f(a).Store(g)
  2491  		w := want(x)
  2492  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2493  	})
  2494  }
  2495  
  2496  // testUint16x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2497  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2498  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2499  func testUint16x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint32x8, want func(x []uint16) []uint32) {
  2500  	n := 8
  2501  	t.Helper()
  2502  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2503  		t.Helper()
  2504  		a := archsimd.LoadUint16x8(x)
  2505  		g := make([]uint32, 8)
  2506  		f(a).Store(g)
  2507  		w := want(x)
  2508  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2509  	})
  2510  }
  2511  
  2512  // testUint32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2513  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2514  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2515  func testUint32x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint32x4, want func(x []uint32) []uint32) {
  2516  	n := 4
  2517  	t.Helper()
  2518  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2519  		t.Helper()
  2520  		a := archsimd.LoadUint32x4(x)
  2521  		g := make([]uint32, 4)
  2522  		f(a).Store(g)
  2523  		w := want(x)
  2524  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2525  	})
  2526  }
  2527  
  2528  // testUint64x2ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2529  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2530  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2531  func testUint64x2ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint32x4, want func(x []uint64) []uint32) {
  2532  	n := 2
  2533  	t.Helper()
  2534  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2535  		t.Helper()
  2536  		a := archsimd.LoadUint64x2(x)
  2537  		g := make([]uint32, 4)
  2538  		f(a).Store(g)
  2539  		w := want(x)
  2540  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2541  	})
  2542  }
  2543  
  2544  // testFloat32x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2545  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2546  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2547  func testFloat32x4ConvertToUint32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint32x4, want func(x []float32) []uint32) {
  2548  	n := 4
  2549  	t.Helper()
  2550  	forSlice(t, float32s, n, func(x []float32) bool {
  2551  		t.Helper()
  2552  		a := archsimd.LoadFloat32x4(x)
  2553  		g := make([]uint32, 4)
  2554  		f(a).Store(g)
  2555  		w := want(x)
  2556  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2557  	})
  2558  }
  2559  
  2560  // testFloat64x2ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2561  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2562  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2563  func testFloat64x2ConvertToUint32(t *testing.T, f func(x archsimd.Float64x2) archsimd.Uint32x4, want func(x []float64) []uint32) {
  2564  	n := 2
  2565  	t.Helper()
  2566  	forSlice(t, float64s, n, func(x []float64) bool {
  2567  		t.Helper()
  2568  		a := archsimd.LoadFloat64x2(x)
  2569  		g := make([]uint32, 4)
  2570  		f(a).Store(g)
  2571  		w := want(x)
  2572  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2573  	})
  2574  }
  2575  
  2576  // testInt8x32ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2577  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2578  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2579  func testInt8x32ConvertToUint32(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint32x16, want func(x []int8) []uint32) {
  2580  	n := 32
  2581  	t.Helper()
  2582  	forSlice(t, int8s, n, func(x []int8) bool {
  2583  		t.Helper()
  2584  		a := archsimd.LoadInt8x32(x)
  2585  		g := make([]uint32, 16)
  2586  		f(a).Store(g)
  2587  		w := want(x)
  2588  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2589  	})
  2590  }
  2591  
  2592  // testInt16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2593  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2594  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2595  func testInt16x16ConvertToUint32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint32x16, want func(x []int16) []uint32) {
  2596  	n := 16
  2597  	t.Helper()
  2598  	forSlice(t, int16s, n, func(x []int16) bool {
  2599  		t.Helper()
  2600  		a := archsimd.LoadInt16x16(x)
  2601  		g := make([]uint32, 16)
  2602  		f(a).Store(g)
  2603  		w := want(x)
  2604  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2605  	})
  2606  }
  2607  
  2608  // testInt32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2609  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2610  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2611  func testInt32x8ConvertToUint32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint32x8, want func(x []int32) []uint32) {
  2612  	n := 8
  2613  	t.Helper()
  2614  	forSlice(t, int32s, n, func(x []int32) bool {
  2615  		t.Helper()
  2616  		a := archsimd.LoadInt32x8(x)
  2617  		g := make([]uint32, 8)
  2618  		f(a).Store(g)
  2619  		w := want(x)
  2620  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2621  	})
  2622  }
  2623  
  2624  // testInt64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2625  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2626  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2627  func testInt64x4ConvertToUint32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint32x4, want func(x []int64) []uint32) {
  2628  	n := 4
  2629  	t.Helper()
  2630  	forSlice(t, int64s, n, func(x []int64) bool {
  2631  		t.Helper()
  2632  		a := archsimd.LoadInt64x4(x)
  2633  		g := make([]uint32, 4)
  2634  		f(a).Store(g)
  2635  		w := want(x)
  2636  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2637  	})
  2638  }
  2639  
  2640  // testUint8x32ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2641  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2642  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2643  func testUint8x32ConvertToUint32(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint32x16, want func(x []uint8) []uint32) {
  2644  	n := 32
  2645  	t.Helper()
  2646  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2647  		t.Helper()
  2648  		a := archsimd.LoadUint8x32(x)
  2649  		g := make([]uint32, 16)
  2650  		f(a).Store(g)
  2651  		w := want(x)
  2652  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2653  	})
  2654  }
  2655  
  2656  // testUint16x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2657  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2658  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2659  func testUint16x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint32x16, want func(x []uint16) []uint32) {
  2660  	n := 16
  2661  	t.Helper()
  2662  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2663  		t.Helper()
  2664  		a := archsimd.LoadUint16x16(x)
  2665  		g := make([]uint32, 16)
  2666  		f(a).Store(g)
  2667  		w := want(x)
  2668  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2669  	})
  2670  }
  2671  
  2672  // testUint32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2673  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2674  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2675  func testUint32x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint32x8, want func(x []uint32) []uint32) {
  2676  	n := 8
  2677  	t.Helper()
  2678  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2679  		t.Helper()
  2680  		a := archsimd.LoadUint32x8(x)
  2681  		g := make([]uint32, 8)
  2682  		f(a).Store(g)
  2683  		w := want(x)
  2684  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2685  	})
  2686  }
  2687  
  2688  // testUint64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2689  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2690  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2691  func testUint64x4ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint32x4, want func(x []uint64) []uint32) {
  2692  	n := 4
  2693  	t.Helper()
  2694  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2695  		t.Helper()
  2696  		a := archsimd.LoadUint64x4(x)
  2697  		g := make([]uint32, 4)
  2698  		f(a).Store(g)
  2699  		w := want(x)
  2700  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2701  	})
  2702  }
  2703  
  2704  // testFloat32x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2705  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2706  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2707  func testFloat32x8ConvertToUint32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint32x8, want func(x []float32) []uint32) {
  2708  	n := 8
  2709  	t.Helper()
  2710  	forSlice(t, float32s, n, func(x []float32) bool {
  2711  		t.Helper()
  2712  		a := archsimd.LoadFloat32x8(x)
  2713  		g := make([]uint32, 8)
  2714  		f(a).Store(g)
  2715  		w := want(x)
  2716  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2717  	})
  2718  }
  2719  
  2720  // testFloat64x4ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2721  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2722  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2723  func testFloat64x4ConvertToUint32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint32x4, want func(x []float64) []uint32) {
  2724  	n := 4
  2725  	t.Helper()
  2726  	forSlice(t, float64s, n, func(x []float64) bool {
  2727  		t.Helper()
  2728  		a := archsimd.LoadFloat64x4(x)
  2729  		g := make([]uint32, 4)
  2730  		f(a).Store(g)
  2731  		w := want(x)
  2732  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2733  	})
  2734  }
  2735  
  2736  // testInt8x64ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2737  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2738  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2739  func testInt8x64ConvertToUint32(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint32x16, want func(x []int8) []uint32) {
  2740  	n := 64
  2741  	t.Helper()
  2742  	forSlice(t, int8s, n, func(x []int8) bool {
  2743  		t.Helper()
  2744  		a := archsimd.LoadInt8x64(x)
  2745  		g := make([]uint32, 16)
  2746  		f(a).Store(g)
  2747  		w := want(x)
  2748  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2749  	})
  2750  }
  2751  
  2752  // testInt16x32ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2753  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2754  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2755  func testInt16x32ConvertToUint32(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint32x16, want func(x []int16) []uint32) {
  2756  	n := 32
  2757  	t.Helper()
  2758  	forSlice(t, int16s, n, func(x []int16) bool {
  2759  		t.Helper()
  2760  		a := archsimd.LoadInt16x32(x)
  2761  		g := make([]uint32, 16)
  2762  		f(a).Store(g)
  2763  		w := want(x)
  2764  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2765  	})
  2766  }
  2767  
  2768  // testInt32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2769  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2770  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2771  func testInt32x16ConvertToUint32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint32x16, want func(x []int32) []uint32) {
  2772  	n := 16
  2773  	t.Helper()
  2774  	forSlice(t, int32s, n, func(x []int32) bool {
  2775  		t.Helper()
  2776  		a := archsimd.LoadInt32x16(x)
  2777  		g := make([]uint32, 16)
  2778  		f(a).Store(g)
  2779  		w := want(x)
  2780  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2781  	})
  2782  }
  2783  
  2784  // testInt64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2785  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2786  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2787  func testInt64x8ConvertToUint32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint32x8, want func(x []int64) []uint32) {
  2788  	n := 8
  2789  	t.Helper()
  2790  	forSlice(t, int64s, n, func(x []int64) bool {
  2791  		t.Helper()
  2792  		a := archsimd.LoadInt64x8(x)
  2793  		g := make([]uint32, 8)
  2794  		f(a).Store(g)
  2795  		w := want(x)
  2796  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2797  	})
  2798  }
  2799  
  2800  // testUint8x64ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2801  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2802  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2803  func testUint8x64ConvertToUint32(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint32x16, want func(x []uint8) []uint32) {
  2804  	n := 64
  2805  	t.Helper()
  2806  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2807  		t.Helper()
  2808  		a := archsimd.LoadUint8x64(x)
  2809  		g := make([]uint32, 16)
  2810  		f(a).Store(g)
  2811  		w := want(x)
  2812  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2813  	})
  2814  }
  2815  
  2816  // testUint16x32ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2817  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2818  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2819  func testUint16x32ConvertToUint32(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint32x16, want func(x []uint16) []uint32) {
  2820  	n := 32
  2821  	t.Helper()
  2822  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2823  		t.Helper()
  2824  		a := archsimd.LoadUint16x32(x)
  2825  		g := make([]uint32, 16)
  2826  		f(a).Store(g)
  2827  		w := want(x)
  2828  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2829  	})
  2830  }
  2831  
  2832  // testUint32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2833  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2834  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2835  func testUint32x16ConvertToUint32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint32x16, want func(x []uint32) []uint32) {
  2836  	n := 16
  2837  	t.Helper()
  2838  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2839  		t.Helper()
  2840  		a := archsimd.LoadUint32x16(x)
  2841  		g := make([]uint32, 16)
  2842  		f(a).Store(g)
  2843  		w := want(x)
  2844  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2845  	})
  2846  }
  2847  
  2848  // testUint64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2849  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2850  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2851  func testUint64x8ConvertToUint32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint32x8, want func(x []uint64) []uint32) {
  2852  	n := 8
  2853  	t.Helper()
  2854  	forSlice(t, uint64s, n, func(x []uint64) bool {
  2855  		t.Helper()
  2856  		a := archsimd.LoadUint64x8(x)
  2857  		g := make([]uint32, 8)
  2858  		f(a).Store(g)
  2859  		w := want(x)
  2860  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2861  	})
  2862  }
  2863  
  2864  // testFloat32x16ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2865  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2866  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2867  func testFloat32x16ConvertToUint32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint32x16, want func(x []float32) []uint32) {
  2868  	n := 16
  2869  	t.Helper()
  2870  	forSlice(t, float32s, n, func(x []float32) bool {
  2871  		t.Helper()
  2872  		a := archsimd.LoadFloat32x16(x)
  2873  		g := make([]uint32, 16)
  2874  		f(a).Store(g)
  2875  		w := want(x)
  2876  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2877  	})
  2878  }
  2879  
  2880  // testFloat64x8ConvertToUint32 tests the simd conversion method f against the expected behavior generated by want.
  2881  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2882  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2883  func testFloat64x8ConvertToUint32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint32x8, want func(x []float64) []uint32) {
  2884  	n := 8
  2885  	t.Helper()
  2886  	forSlice(t, float64s, n, func(x []float64) bool {
  2887  		t.Helper()
  2888  		a := archsimd.LoadFloat64x8(x)
  2889  		g := make([]uint32, 8)
  2890  		f(a).Store(g)
  2891  		w := want(x)
  2892  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2893  	})
  2894  }
  2895  
  2896  // testInt8x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2897  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2898  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2899  func testInt8x16ConvertToInt64(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int64x8, want func(x []int8) []int64) {
  2900  	n := 16
  2901  	t.Helper()
  2902  	forSlice(t, int8s, n, func(x []int8) bool {
  2903  		t.Helper()
  2904  		a := archsimd.LoadInt8x16(x)
  2905  		g := make([]int64, 8)
  2906  		f(a).Store(g)
  2907  		w := want(x)
  2908  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2909  	})
  2910  }
  2911  
  2912  // testInt16x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2913  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2914  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2915  func testInt16x8ConvertToInt64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int64x8, want func(x []int16) []int64) {
  2916  	n := 8
  2917  	t.Helper()
  2918  	forSlice(t, int16s, n, func(x []int16) bool {
  2919  		t.Helper()
  2920  		a := archsimd.LoadInt16x8(x)
  2921  		g := make([]int64, 8)
  2922  		f(a).Store(g)
  2923  		w := want(x)
  2924  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2925  	})
  2926  }
  2927  
  2928  // testInt32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2929  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2930  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2931  func testInt32x4ConvertToInt64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int64x4, want func(x []int32) []int64) {
  2932  	n := 4
  2933  	t.Helper()
  2934  	forSlice(t, int32s, n, func(x []int32) bool {
  2935  		t.Helper()
  2936  		a := archsimd.LoadInt32x4(x)
  2937  		g := make([]int64, 4)
  2938  		f(a).Store(g)
  2939  		w := want(x)
  2940  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2941  	})
  2942  }
  2943  
  2944  // testInt64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2945  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2946  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2947  func testInt64x2ConvertToInt64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int64x2, want func(x []int64) []int64) {
  2948  	n := 2
  2949  	t.Helper()
  2950  	forSlice(t, int64s, n, func(x []int64) bool {
  2951  		t.Helper()
  2952  		a := archsimd.LoadInt64x2(x)
  2953  		g := make([]int64, 2)
  2954  		f(a).Store(g)
  2955  		w := want(x)
  2956  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2957  	})
  2958  }
  2959  
  2960  // testUint8x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2961  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2962  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2963  func testUint8x16ConvertToInt64(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int64x8, want func(x []uint8) []int64) {
  2964  	n := 16
  2965  	t.Helper()
  2966  	forSlice(t, uint8s, n, func(x []uint8) bool {
  2967  		t.Helper()
  2968  		a := archsimd.LoadUint8x16(x)
  2969  		g := make([]int64, 8)
  2970  		f(a).Store(g)
  2971  		w := want(x)
  2972  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2973  	})
  2974  }
  2975  
  2976  // testUint16x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2977  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2978  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2979  func testUint16x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int64x8, want func(x []uint16) []int64) {
  2980  	n := 8
  2981  	t.Helper()
  2982  	forSlice(t, uint16s, n, func(x []uint16) bool {
  2983  		t.Helper()
  2984  		a := archsimd.LoadUint16x8(x)
  2985  		g := make([]int64, 8)
  2986  		f(a).Store(g)
  2987  		w := want(x)
  2988  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  2989  	})
  2990  }
  2991  
  2992  // testUint32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  2993  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  2994  // (extended to at least 128 bits, or truncated to at most 512 bits).
  2995  func testUint32x4ConvertToInt64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int64x4, want func(x []uint32) []int64) {
  2996  	n := 4
  2997  	t.Helper()
  2998  	forSlice(t, uint32s, n, func(x []uint32) bool {
  2999  		t.Helper()
  3000  		a := archsimd.LoadUint32x4(x)
  3001  		g := make([]int64, 4)
  3002  		f(a).Store(g)
  3003  		w := want(x)
  3004  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3005  	})
  3006  }
  3007  
  3008  // testUint64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3009  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3010  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3011  func testUint64x2ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int64x2, want func(x []uint64) []int64) {
  3012  	n := 2
  3013  	t.Helper()
  3014  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3015  		t.Helper()
  3016  		a := archsimd.LoadUint64x2(x)
  3017  		g := make([]int64, 2)
  3018  		f(a).Store(g)
  3019  		w := want(x)
  3020  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3021  	})
  3022  }
  3023  
  3024  // testFloat32x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3025  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3026  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3027  func testFloat32x4ConvertToInt64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Int64x4, want func(x []float32) []int64) {
  3028  	n := 4
  3029  	t.Helper()
  3030  	forSlice(t, float32s, n, func(x []float32) bool {
  3031  		t.Helper()
  3032  		a := archsimd.LoadFloat32x4(x)
  3033  		g := make([]int64, 4)
  3034  		f(a).Store(g)
  3035  		w := want(x)
  3036  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3037  	})
  3038  }
  3039  
  3040  // testFloat64x2ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3041  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3042  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3043  func testFloat64x2ConvertToInt64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Int64x2, want func(x []float64) []int64) {
  3044  	n := 2
  3045  	t.Helper()
  3046  	forSlice(t, float64s, n, func(x []float64) bool {
  3047  		t.Helper()
  3048  		a := archsimd.LoadFloat64x2(x)
  3049  		g := make([]int64, 2)
  3050  		f(a).Store(g)
  3051  		w := want(x)
  3052  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3053  	})
  3054  }
  3055  
  3056  // testInt8x32ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3057  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3058  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3059  func testInt8x32ConvertToInt64(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int64x8, want func(x []int8) []int64) {
  3060  	n := 32
  3061  	t.Helper()
  3062  	forSlice(t, int8s, n, func(x []int8) bool {
  3063  		t.Helper()
  3064  		a := archsimd.LoadInt8x32(x)
  3065  		g := make([]int64, 8)
  3066  		f(a).Store(g)
  3067  		w := want(x)
  3068  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3069  	})
  3070  }
  3071  
  3072  // testInt16x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3073  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3074  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3075  func testInt16x16ConvertToInt64(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int64x8, want func(x []int16) []int64) {
  3076  	n := 16
  3077  	t.Helper()
  3078  	forSlice(t, int16s, n, func(x []int16) bool {
  3079  		t.Helper()
  3080  		a := archsimd.LoadInt16x16(x)
  3081  		g := make([]int64, 8)
  3082  		f(a).Store(g)
  3083  		w := want(x)
  3084  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3085  	})
  3086  }
  3087  
  3088  // testInt32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3089  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3090  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3091  func testInt32x8ConvertToInt64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int64x8, want func(x []int32) []int64) {
  3092  	n := 8
  3093  	t.Helper()
  3094  	forSlice(t, int32s, n, func(x []int32) bool {
  3095  		t.Helper()
  3096  		a := archsimd.LoadInt32x8(x)
  3097  		g := make([]int64, 8)
  3098  		f(a).Store(g)
  3099  		w := want(x)
  3100  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3101  	})
  3102  }
  3103  
  3104  // testInt64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3105  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3106  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3107  func testInt64x4ConvertToInt64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int64x4, want func(x []int64) []int64) {
  3108  	n := 4
  3109  	t.Helper()
  3110  	forSlice(t, int64s, n, func(x []int64) bool {
  3111  		t.Helper()
  3112  		a := archsimd.LoadInt64x4(x)
  3113  		g := make([]int64, 4)
  3114  		f(a).Store(g)
  3115  		w := want(x)
  3116  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3117  	})
  3118  }
  3119  
  3120  // testUint8x32ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3121  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3122  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3123  func testUint8x32ConvertToInt64(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int64x8, want func(x []uint8) []int64) {
  3124  	n := 32
  3125  	t.Helper()
  3126  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3127  		t.Helper()
  3128  		a := archsimd.LoadUint8x32(x)
  3129  		g := make([]int64, 8)
  3130  		f(a).Store(g)
  3131  		w := want(x)
  3132  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3133  	})
  3134  }
  3135  
  3136  // testUint16x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3137  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3138  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3139  func testUint16x16ConvertToInt64(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int64x8, want func(x []uint16) []int64) {
  3140  	n := 16
  3141  	t.Helper()
  3142  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3143  		t.Helper()
  3144  		a := archsimd.LoadUint16x16(x)
  3145  		g := make([]int64, 8)
  3146  		f(a).Store(g)
  3147  		w := want(x)
  3148  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3149  	})
  3150  }
  3151  
  3152  // testUint32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3153  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3154  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3155  func testUint32x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int64x8, want func(x []uint32) []int64) {
  3156  	n := 8
  3157  	t.Helper()
  3158  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3159  		t.Helper()
  3160  		a := archsimd.LoadUint32x8(x)
  3161  		g := make([]int64, 8)
  3162  		f(a).Store(g)
  3163  		w := want(x)
  3164  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3165  	})
  3166  }
  3167  
  3168  // testUint64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3169  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3170  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3171  func testUint64x4ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int64x4, want func(x []uint64) []int64) {
  3172  	n := 4
  3173  	t.Helper()
  3174  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3175  		t.Helper()
  3176  		a := archsimd.LoadUint64x4(x)
  3177  		g := make([]int64, 4)
  3178  		f(a).Store(g)
  3179  		w := want(x)
  3180  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3181  	})
  3182  }
  3183  
  3184  // testFloat32x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3185  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3186  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3187  func testFloat32x8ConvertToInt64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Int64x8, want func(x []float32) []int64) {
  3188  	n := 8
  3189  	t.Helper()
  3190  	forSlice(t, float32s, n, func(x []float32) bool {
  3191  		t.Helper()
  3192  		a := archsimd.LoadFloat32x8(x)
  3193  		g := make([]int64, 8)
  3194  		f(a).Store(g)
  3195  		w := want(x)
  3196  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3197  	})
  3198  }
  3199  
  3200  // testFloat64x4ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3201  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3202  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3203  func testFloat64x4ConvertToInt64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Int64x4, want func(x []float64) []int64) {
  3204  	n := 4
  3205  	t.Helper()
  3206  	forSlice(t, float64s, n, func(x []float64) bool {
  3207  		t.Helper()
  3208  		a := archsimd.LoadFloat64x4(x)
  3209  		g := make([]int64, 4)
  3210  		f(a).Store(g)
  3211  		w := want(x)
  3212  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3213  	})
  3214  }
  3215  
  3216  // testInt8x64ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3217  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3218  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3219  func testInt8x64ConvertToInt64(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int64x8, want func(x []int8) []int64) {
  3220  	n := 64
  3221  	t.Helper()
  3222  	forSlice(t, int8s, n, func(x []int8) bool {
  3223  		t.Helper()
  3224  		a := archsimd.LoadInt8x64(x)
  3225  		g := make([]int64, 8)
  3226  		f(a).Store(g)
  3227  		w := want(x)
  3228  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3229  	})
  3230  }
  3231  
  3232  // testInt16x32ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3233  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3234  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3235  func testInt16x32ConvertToInt64(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int64x8, want func(x []int16) []int64) {
  3236  	n := 32
  3237  	t.Helper()
  3238  	forSlice(t, int16s, n, func(x []int16) bool {
  3239  		t.Helper()
  3240  		a := archsimd.LoadInt16x32(x)
  3241  		g := make([]int64, 8)
  3242  		f(a).Store(g)
  3243  		w := want(x)
  3244  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3245  	})
  3246  }
  3247  
  3248  // testInt32x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3249  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3250  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3251  func testInt32x16ConvertToInt64(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int64x8, want func(x []int32) []int64) {
  3252  	n := 16
  3253  	t.Helper()
  3254  	forSlice(t, int32s, n, func(x []int32) bool {
  3255  		t.Helper()
  3256  		a := archsimd.LoadInt32x16(x)
  3257  		g := make([]int64, 8)
  3258  		f(a).Store(g)
  3259  		w := want(x)
  3260  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3261  	})
  3262  }
  3263  
  3264  // testInt64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3265  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3266  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3267  func testInt64x8ConvertToInt64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int64x8, want func(x []int64) []int64) {
  3268  	n := 8
  3269  	t.Helper()
  3270  	forSlice(t, int64s, n, func(x []int64) bool {
  3271  		t.Helper()
  3272  		a := archsimd.LoadInt64x8(x)
  3273  		g := make([]int64, 8)
  3274  		f(a).Store(g)
  3275  		w := want(x)
  3276  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3277  	})
  3278  }
  3279  
  3280  // testUint8x64ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3281  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3282  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3283  func testUint8x64ConvertToInt64(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int64x8, want func(x []uint8) []int64) {
  3284  	n := 64
  3285  	t.Helper()
  3286  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3287  		t.Helper()
  3288  		a := archsimd.LoadUint8x64(x)
  3289  		g := make([]int64, 8)
  3290  		f(a).Store(g)
  3291  		w := want(x)
  3292  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3293  	})
  3294  }
  3295  
  3296  // testUint16x32ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3297  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3298  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3299  func testUint16x32ConvertToInt64(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int64x8, want func(x []uint16) []int64) {
  3300  	n := 32
  3301  	t.Helper()
  3302  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3303  		t.Helper()
  3304  		a := archsimd.LoadUint16x32(x)
  3305  		g := make([]int64, 8)
  3306  		f(a).Store(g)
  3307  		w := want(x)
  3308  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3309  	})
  3310  }
  3311  
  3312  // testUint32x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3313  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3314  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3315  func testUint32x16ConvertToInt64(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int64x8, want func(x []uint32) []int64) {
  3316  	n := 16
  3317  	t.Helper()
  3318  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3319  		t.Helper()
  3320  		a := archsimd.LoadUint32x16(x)
  3321  		g := make([]int64, 8)
  3322  		f(a).Store(g)
  3323  		w := want(x)
  3324  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3325  	})
  3326  }
  3327  
  3328  // testUint64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3329  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3330  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3331  func testUint64x8ConvertToInt64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int64x8, want func(x []uint64) []int64) {
  3332  	n := 8
  3333  	t.Helper()
  3334  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3335  		t.Helper()
  3336  		a := archsimd.LoadUint64x8(x)
  3337  		g := make([]int64, 8)
  3338  		f(a).Store(g)
  3339  		w := want(x)
  3340  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3341  	})
  3342  }
  3343  
  3344  // testFloat32x16ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3345  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3346  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3347  func testFloat32x16ConvertToInt64(t *testing.T, f func(x archsimd.Float32x16) archsimd.Int64x8, want func(x []float32) []int64) {
  3348  	n := 16
  3349  	t.Helper()
  3350  	forSlice(t, float32s, n, func(x []float32) bool {
  3351  		t.Helper()
  3352  		a := archsimd.LoadFloat32x16(x)
  3353  		g := make([]int64, 8)
  3354  		f(a).Store(g)
  3355  		w := want(x)
  3356  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3357  	})
  3358  }
  3359  
  3360  // testFloat64x8ConvertToInt64 tests the simd conversion method f against the expected behavior generated by want.
  3361  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3362  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3363  func testFloat64x8ConvertToInt64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Int64x8, want func(x []float64) []int64) {
  3364  	n := 8
  3365  	t.Helper()
  3366  	forSlice(t, float64s, n, func(x []float64) bool {
  3367  		t.Helper()
  3368  		a := archsimd.LoadFloat64x8(x)
  3369  		g := make([]int64, 8)
  3370  		f(a).Store(g)
  3371  		w := want(x)
  3372  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3373  	})
  3374  }
  3375  
  3376  // testInt8x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3377  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3378  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3379  func testInt8x16ConvertToUint64(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint64x8, want func(x []int8) []uint64) {
  3380  	n := 16
  3381  	t.Helper()
  3382  	forSlice(t, int8s, n, func(x []int8) bool {
  3383  		t.Helper()
  3384  		a := archsimd.LoadInt8x16(x)
  3385  		g := make([]uint64, 8)
  3386  		f(a).Store(g)
  3387  		w := want(x)
  3388  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3389  	})
  3390  }
  3391  
  3392  // testInt16x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3393  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3394  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3395  func testInt16x8ConvertToUint64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint64x8, want func(x []int16) []uint64) {
  3396  	n := 8
  3397  	t.Helper()
  3398  	forSlice(t, int16s, n, func(x []int16) bool {
  3399  		t.Helper()
  3400  		a := archsimd.LoadInt16x8(x)
  3401  		g := make([]uint64, 8)
  3402  		f(a).Store(g)
  3403  		w := want(x)
  3404  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3405  	})
  3406  }
  3407  
  3408  // testInt32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3409  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3410  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3411  func testInt32x4ConvertToUint64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint64x4, want func(x []int32) []uint64) {
  3412  	n := 4
  3413  	t.Helper()
  3414  	forSlice(t, int32s, n, func(x []int32) bool {
  3415  		t.Helper()
  3416  		a := archsimd.LoadInt32x4(x)
  3417  		g := make([]uint64, 4)
  3418  		f(a).Store(g)
  3419  		w := want(x)
  3420  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3421  	})
  3422  }
  3423  
  3424  // testInt64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3425  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3426  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3427  func testInt64x2ConvertToUint64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint64x2, want func(x []int64) []uint64) {
  3428  	n := 2
  3429  	t.Helper()
  3430  	forSlice(t, int64s, n, func(x []int64) bool {
  3431  		t.Helper()
  3432  		a := archsimd.LoadInt64x2(x)
  3433  		g := make([]uint64, 2)
  3434  		f(a).Store(g)
  3435  		w := want(x)
  3436  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3437  	})
  3438  }
  3439  
  3440  // testUint8x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3441  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3442  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3443  func testUint8x16ConvertToUint64(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint64x8, want func(x []uint8) []uint64) {
  3444  	n := 16
  3445  	t.Helper()
  3446  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3447  		t.Helper()
  3448  		a := archsimd.LoadUint8x16(x)
  3449  		g := make([]uint64, 8)
  3450  		f(a).Store(g)
  3451  		w := want(x)
  3452  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3453  	})
  3454  }
  3455  
  3456  // testUint16x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3457  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3458  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3459  func testUint16x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint64x8, want func(x []uint16) []uint64) {
  3460  	n := 8
  3461  	t.Helper()
  3462  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3463  		t.Helper()
  3464  		a := archsimd.LoadUint16x8(x)
  3465  		g := make([]uint64, 8)
  3466  		f(a).Store(g)
  3467  		w := want(x)
  3468  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3469  	})
  3470  }
  3471  
  3472  // testUint32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3473  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3474  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3475  func testUint32x4ConvertToUint64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint64x4, want func(x []uint32) []uint64) {
  3476  	n := 4
  3477  	t.Helper()
  3478  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3479  		t.Helper()
  3480  		a := archsimd.LoadUint32x4(x)
  3481  		g := make([]uint64, 4)
  3482  		f(a).Store(g)
  3483  		w := want(x)
  3484  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3485  	})
  3486  }
  3487  
  3488  // testUint64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3489  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3490  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3491  func testUint64x2ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint64x2, want func(x []uint64) []uint64) {
  3492  	n := 2
  3493  	t.Helper()
  3494  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3495  		t.Helper()
  3496  		a := archsimd.LoadUint64x2(x)
  3497  		g := make([]uint64, 2)
  3498  		f(a).Store(g)
  3499  		w := want(x)
  3500  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3501  	})
  3502  }
  3503  
  3504  // testFloat32x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3505  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3506  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3507  func testFloat32x4ConvertToUint64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Uint64x4, want func(x []float32) []uint64) {
  3508  	n := 4
  3509  	t.Helper()
  3510  	forSlice(t, float32s, n, func(x []float32) bool {
  3511  		t.Helper()
  3512  		a := archsimd.LoadFloat32x4(x)
  3513  		g := make([]uint64, 4)
  3514  		f(a).Store(g)
  3515  		w := want(x)
  3516  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3517  	})
  3518  }
  3519  
  3520  // testFloat64x2ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3521  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3522  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3523  func testFloat64x2ConvertToUint64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Uint64x2, want func(x []float64) []uint64) {
  3524  	n := 2
  3525  	t.Helper()
  3526  	forSlice(t, float64s, n, func(x []float64) bool {
  3527  		t.Helper()
  3528  		a := archsimd.LoadFloat64x2(x)
  3529  		g := make([]uint64, 2)
  3530  		f(a).Store(g)
  3531  		w := want(x)
  3532  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3533  	})
  3534  }
  3535  
  3536  // testInt8x32ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3537  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3538  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3539  func testInt8x32ConvertToUint64(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint64x8, want func(x []int8) []uint64) {
  3540  	n := 32
  3541  	t.Helper()
  3542  	forSlice(t, int8s, n, func(x []int8) bool {
  3543  		t.Helper()
  3544  		a := archsimd.LoadInt8x32(x)
  3545  		g := make([]uint64, 8)
  3546  		f(a).Store(g)
  3547  		w := want(x)
  3548  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3549  	})
  3550  }
  3551  
  3552  // testInt16x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3553  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3554  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3555  func testInt16x16ConvertToUint64(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint64x8, want func(x []int16) []uint64) {
  3556  	n := 16
  3557  	t.Helper()
  3558  	forSlice(t, int16s, n, func(x []int16) bool {
  3559  		t.Helper()
  3560  		a := archsimd.LoadInt16x16(x)
  3561  		g := make([]uint64, 8)
  3562  		f(a).Store(g)
  3563  		w := want(x)
  3564  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3565  	})
  3566  }
  3567  
  3568  // testInt32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3569  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3570  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3571  func testInt32x8ConvertToUint64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint64x8, want func(x []int32) []uint64) {
  3572  	n := 8
  3573  	t.Helper()
  3574  	forSlice(t, int32s, n, func(x []int32) bool {
  3575  		t.Helper()
  3576  		a := archsimd.LoadInt32x8(x)
  3577  		g := make([]uint64, 8)
  3578  		f(a).Store(g)
  3579  		w := want(x)
  3580  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3581  	})
  3582  }
  3583  
  3584  // testInt64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3585  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3586  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3587  func testInt64x4ConvertToUint64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint64x4, want func(x []int64) []uint64) {
  3588  	n := 4
  3589  	t.Helper()
  3590  	forSlice(t, int64s, n, func(x []int64) bool {
  3591  		t.Helper()
  3592  		a := archsimd.LoadInt64x4(x)
  3593  		g := make([]uint64, 4)
  3594  		f(a).Store(g)
  3595  		w := want(x)
  3596  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3597  	})
  3598  }
  3599  
  3600  // testUint8x32ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3601  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3602  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3603  func testUint8x32ConvertToUint64(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint64x8, want func(x []uint8) []uint64) {
  3604  	n := 32
  3605  	t.Helper()
  3606  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3607  		t.Helper()
  3608  		a := archsimd.LoadUint8x32(x)
  3609  		g := make([]uint64, 8)
  3610  		f(a).Store(g)
  3611  		w := want(x)
  3612  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3613  	})
  3614  }
  3615  
  3616  // testUint16x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3617  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3618  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3619  func testUint16x16ConvertToUint64(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint64x8, want func(x []uint16) []uint64) {
  3620  	n := 16
  3621  	t.Helper()
  3622  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3623  		t.Helper()
  3624  		a := archsimd.LoadUint16x16(x)
  3625  		g := make([]uint64, 8)
  3626  		f(a).Store(g)
  3627  		w := want(x)
  3628  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3629  	})
  3630  }
  3631  
  3632  // testUint32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3633  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3634  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3635  func testUint32x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint64x8, want func(x []uint32) []uint64) {
  3636  	n := 8
  3637  	t.Helper()
  3638  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3639  		t.Helper()
  3640  		a := archsimd.LoadUint32x8(x)
  3641  		g := make([]uint64, 8)
  3642  		f(a).Store(g)
  3643  		w := want(x)
  3644  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3645  	})
  3646  }
  3647  
  3648  // testUint64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3649  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3650  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3651  func testUint64x4ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint64x4, want func(x []uint64) []uint64) {
  3652  	n := 4
  3653  	t.Helper()
  3654  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3655  		t.Helper()
  3656  		a := archsimd.LoadUint64x4(x)
  3657  		g := make([]uint64, 4)
  3658  		f(a).Store(g)
  3659  		w := want(x)
  3660  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3661  	})
  3662  }
  3663  
  3664  // testFloat32x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3665  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3666  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3667  func testFloat32x8ConvertToUint64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Uint64x8, want func(x []float32) []uint64) {
  3668  	n := 8
  3669  	t.Helper()
  3670  	forSlice(t, float32s, n, func(x []float32) bool {
  3671  		t.Helper()
  3672  		a := archsimd.LoadFloat32x8(x)
  3673  		g := make([]uint64, 8)
  3674  		f(a).Store(g)
  3675  		w := want(x)
  3676  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3677  	})
  3678  }
  3679  
  3680  // testFloat64x4ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3681  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3682  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3683  func testFloat64x4ConvertToUint64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Uint64x4, want func(x []float64) []uint64) {
  3684  	n := 4
  3685  	t.Helper()
  3686  	forSlice(t, float64s, n, func(x []float64) bool {
  3687  		t.Helper()
  3688  		a := archsimd.LoadFloat64x4(x)
  3689  		g := make([]uint64, 4)
  3690  		f(a).Store(g)
  3691  		w := want(x)
  3692  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3693  	})
  3694  }
  3695  
  3696  // testInt8x64ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3697  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3698  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3699  func testInt8x64ConvertToUint64(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint64x8, want func(x []int8) []uint64) {
  3700  	n := 64
  3701  	t.Helper()
  3702  	forSlice(t, int8s, n, func(x []int8) bool {
  3703  		t.Helper()
  3704  		a := archsimd.LoadInt8x64(x)
  3705  		g := make([]uint64, 8)
  3706  		f(a).Store(g)
  3707  		w := want(x)
  3708  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3709  	})
  3710  }
  3711  
  3712  // testInt16x32ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3713  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3714  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3715  func testInt16x32ConvertToUint64(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint64x8, want func(x []int16) []uint64) {
  3716  	n := 32
  3717  	t.Helper()
  3718  	forSlice(t, int16s, n, func(x []int16) bool {
  3719  		t.Helper()
  3720  		a := archsimd.LoadInt16x32(x)
  3721  		g := make([]uint64, 8)
  3722  		f(a).Store(g)
  3723  		w := want(x)
  3724  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3725  	})
  3726  }
  3727  
  3728  // testInt32x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3729  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3730  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3731  func testInt32x16ConvertToUint64(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint64x8, want func(x []int32) []uint64) {
  3732  	n := 16
  3733  	t.Helper()
  3734  	forSlice(t, int32s, n, func(x []int32) bool {
  3735  		t.Helper()
  3736  		a := archsimd.LoadInt32x16(x)
  3737  		g := make([]uint64, 8)
  3738  		f(a).Store(g)
  3739  		w := want(x)
  3740  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3741  	})
  3742  }
  3743  
  3744  // testInt64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3745  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3746  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3747  func testInt64x8ConvertToUint64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint64x8, want func(x []int64) []uint64) {
  3748  	n := 8
  3749  	t.Helper()
  3750  	forSlice(t, int64s, n, func(x []int64) bool {
  3751  		t.Helper()
  3752  		a := archsimd.LoadInt64x8(x)
  3753  		g := make([]uint64, 8)
  3754  		f(a).Store(g)
  3755  		w := want(x)
  3756  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3757  	})
  3758  }
  3759  
  3760  // testUint8x64ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3761  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3762  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3763  func testUint8x64ConvertToUint64(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint64x8, want func(x []uint8) []uint64) {
  3764  	n := 64
  3765  	t.Helper()
  3766  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3767  		t.Helper()
  3768  		a := archsimd.LoadUint8x64(x)
  3769  		g := make([]uint64, 8)
  3770  		f(a).Store(g)
  3771  		w := want(x)
  3772  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3773  	})
  3774  }
  3775  
  3776  // testUint16x32ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3777  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3778  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3779  func testUint16x32ConvertToUint64(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint64x8, want func(x []uint16) []uint64) {
  3780  	n := 32
  3781  	t.Helper()
  3782  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3783  		t.Helper()
  3784  		a := archsimd.LoadUint16x32(x)
  3785  		g := make([]uint64, 8)
  3786  		f(a).Store(g)
  3787  		w := want(x)
  3788  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3789  	})
  3790  }
  3791  
  3792  // testUint32x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3793  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3794  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3795  func testUint32x16ConvertToUint64(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint64x8, want func(x []uint32) []uint64) {
  3796  	n := 16
  3797  	t.Helper()
  3798  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3799  		t.Helper()
  3800  		a := archsimd.LoadUint32x16(x)
  3801  		g := make([]uint64, 8)
  3802  		f(a).Store(g)
  3803  		w := want(x)
  3804  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3805  	})
  3806  }
  3807  
  3808  // testUint64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3809  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3810  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3811  func testUint64x8ConvertToUint64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint64x8, want func(x []uint64) []uint64) {
  3812  	n := 8
  3813  	t.Helper()
  3814  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3815  		t.Helper()
  3816  		a := archsimd.LoadUint64x8(x)
  3817  		g := make([]uint64, 8)
  3818  		f(a).Store(g)
  3819  		w := want(x)
  3820  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3821  	})
  3822  }
  3823  
  3824  // testFloat32x16ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3825  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3826  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3827  func testFloat32x16ConvertToUint64(t *testing.T, f func(x archsimd.Float32x16) archsimd.Uint64x8, want func(x []float32) []uint64) {
  3828  	n := 16
  3829  	t.Helper()
  3830  	forSlice(t, float32s, n, func(x []float32) bool {
  3831  		t.Helper()
  3832  		a := archsimd.LoadFloat32x16(x)
  3833  		g := make([]uint64, 8)
  3834  		f(a).Store(g)
  3835  		w := want(x)
  3836  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3837  	})
  3838  }
  3839  
  3840  // testFloat64x8ConvertToUint64 tests the simd conversion method f against the expected behavior generated by want.
  3841  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3842  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3843  func testFloat64x8ConvertToUint64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Uint64x8, want func(x []float64) []uint64) {
  3844  	n := 8
  3845  	t.Helper()
  3846  	forSlice(t, float64s, n, func(x []float64) bool {
  3847  		t.Helper()
  3848  		a := archsimd.LoadFloat64x8(x)
  3849  		g := make([]uint64, 8)
  3850  		f(a).Store(g)
  3851  		w := want(x)
  3852  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3853  	})
  3854  }
  3855  
  3856  // testInt8x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3857  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3858  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3859  func testInt8x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int8x16) archsimd.Float32x16, want func(x []int8) []float32) {
  3860  	n := 16
  3861  	t.Helper()
  3862  	forSlice(t, int8s, n, func(x []int8) bool {
  3863  		t.Helper()
  3864  		a := archsimd.LoadInt8x16(x)
  3865  		g := make([]float32, 16)
  3866  		f(a).Store(g)
  3867  		w := want(x)
  3868  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3869  	})
  3870  }
  3871  
  3872  // testInt16x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3873  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3874  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3875  func testInt16x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int16x8) archsimd.Float32x8, want func(x []int16) []float32) {
  3876  	n := 8
  3877  	t.Helper()
  3878  	forSlice(t, int16s, n, func(x []int16) bool {
  3879  		t.Helper()
  3880  		a := archsimd.LoadInt16x8(x)
  3881  		g := make([]float32, 8)
  3882  		f(a).Store(g)
  3883  		w := want(x)
  3884  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3885  	})
  3886  }
  3887  
  3888  // testInt32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3889  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3890  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3891  func testInt32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x4) archsimd.Float32x4, want func(x []int32) []float32) {
  3892  	n := 4
  3893  	t.Helper()
  3894  	forSlice(t, int32s, n, func(x []int32) bool {
  3895  		t.Helper()
  3896  		a := archsimd.LoadInt32x4(x)
  3897  		g := make([]float32, 4)
  3898  		f(a).Store(g)
  3899  		w := want(x)
  3900  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3901  	})
  3902  }
  3903  
  3904  // testInt64x2ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3905  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3906  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3907  func testInt64x2ConvertToFloat32(t *testing.T, f func(x archsimd.Int64x2) archsimd.Float32x4, want func(x []int64) []float32) {
  3908  	n := 2
  3909  	t.Helper()
  3910  	forSlice(t, int64s, n, func(x []int64) bool {
  3911  		t.Helper()
  3912  		a := archsimd.LoadInt64x2(x)
  3913  		g := make([]float32, 4)
  3914  		f(a).Store(g)
  3915  		w := want(x)
  3916  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3917  	})
  3918  }
  3919  
  3920  // testUint8x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3921  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3922  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3923  func testUint8x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Float32x16, want func(x []uint8) []float32) {
  3924  	n := 16
  3925  	t.Helper()
  3926  	forSlice(t, uint8s, n, func(x []uint8) bool {
  3927  		t.Helper()
  3928  		a := archsimd.LoadUint8x16(x)
  3929  		g := make([]float32, 16)
  3930  		f(a).Store(g)
  3931  		w := want(x)
  3932  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3933  	})
  3934  }
  3935  
  3936  // testUint16x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3937  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3938  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3939  func testUint16x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Float32x8, want func(x []uint16) []float32) {
  3940  	n := 8
  3941  	t.Helper()
  3942  	forSlice(t, uint16s, n, func(x []uint16) bool {
  3943  		t.Helper()
  3944  		a := archsimd.LoadUint16x8(x)
  3945  		g := make([]float32, 8)
  3946  		f(a).Store(g)
  3947  		w := want(x)
  3948  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3949  	})
  3950  }
  3951  
  3952  // testUint32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3953  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3954  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3955  func testUint32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Float32x4, want func(x []uint32) []float32) {
  3956  	n := 4
  3957  	t.Helper()
  3958  	forSlice(t, uint32s, n, func(x []uint32) bool {
  3959  		t.Helper()
  3960  		a := archsimd.LoadUint32x4(x)
  3961  		g := make([]float32, 4)
  3962  		f(a).Store(g)
  3963  		w := want(x)
  3964  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3965  	})
  3966  }
  3967  
  3968  // testUint64x2ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3969  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3970  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3971  func testUint64x2ConvertToFloat32(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Float32x4, want func(x []uint64) []float32) {
  3972  	n := 2
  3973  	t.Helper()
  3974  	forSlice(t, uint64s, n, func(x []uint64) bool {
  3975  		t.Helper()
  3976  		a := archsimd.LoadUint64x2(x)
  3977  		g := make([]float32, 4)
  3978  		f(a).Store(g)
  3979  		w := want(x)
  3980  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3981  	})
  3982  }
  3983  
  3984  // testFloat32x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  3985  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  3986  // (extended to at least 128 bits, or truncated to at most 512 bits).
  3987  func testFloat32x4ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x4) archsimd.Float32x4, want func(x []float32) []float32) {
  3988  	n := 4
  3989  	t.Helper()
  3990  	forSlice(t, float32s, n, func(x []float32) bool {
  3991  		t.Helper()
  3992  		a := archsimd.LoadFloat32x4(x)
  3993  		g := make([]float32, 4)
  3994  		f(a).Store(g)
  3995  		w := want(x)
  3996  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  3997  	})
  3998  }
  3999  
  4000  // testFloat64x2ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4001  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4002  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4003  func testFloat64x2ConvertToFloat32(t *testing.T, f func(x archsimd.Float64x2) archsimd.Float32x4, want func(x []float64) []float32) {
  4004  	n := 2
  4005  	t.Helper()
  4006  	forSlice(t, float64s, n, func(x []float64) bool {
  4007  		t.Helper()
  4008  		a := archsimd.LoadFloat64x2(x)
  4009  		g := make([]float32, 4)
  4010  		f(a).Store(g)
  4011  		w := want(x)
  4012  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4013  	})
  4014  }
  4015  
  4016  // testInt8x32ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4017  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4018  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4019  func testInt8x32ConvertToFloat32(t *testing.T, f func(x archsimd.Int8x32) archsimd.Float32x16, want func(x []int8) []float32) {
  4020  	n := 32
  4021  	t.Helper()
  4022  	forSlice(t, int8s, n, func(x []int8) bool {
  4023  		t.Helper()
  4024  		a := archsimd.LoadInt8x32(x)
  4025  		g := make([]float32, 16)
  4026  		f(a).Store(g)
  4027  		w := want(x)
  4028  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4029  	})
  4030  }
  4031  
  4032  // testInt16x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4033  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4034  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4035  func testInt16x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int16x16) archsimd.Float32x16, want func(x []int16) []float32) {
  4036  	n := 16
  4037  	t.Helper()
  4038  	forSlice(t, int16s, n, func(x []int16) bool {
  4039  		t.Helper()
  4040  		a := archsimd.LoadInt16x16(x)
  4041  		g := make([]float32, 16)
  4042  		f(a).Store(g)
  4043  		w := want(x)
  4044  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4045  	})
  4046  }
  4047  
  4048  // testInt32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4049  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4050  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4051  func testInt32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x8) archsimd.Float32x8, want func(x []int32) []float32) {
  4052  	n := 8
  4053  	t.Helper()
  4054  	forSlice(t, int32s, n, func(x []int32) bool {
  4055  		t.Helper()
  4056  		a := archsimd.LoadInt32x8(x)
  4057  		g := make([]float32, 8)
  4058  		f(a).Store(g)
  4059  		w := want(x)
  4060  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4061  	})
  4062  }
  4063  
  4064  // testInt64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4065  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4066  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4067  func testInt64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Int64x4) archsimd.Float32x4, want func(x []int64) []float32) {
  4068  	n := 4
  4069  	t.Helper()
  4070  	forSlice(t, int64s, n, func(x []int64) bool {
  4071  		t.Helper()
  4072  		a := archsimd.LoadInt64x4(x)
  4073  		g := make([]float32, 4)
  4074  		f(a).Store(g)
  4075  		w := want(x)
  4076  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4077  	})
  4078  }
  4079  
  4080  // testUint8x32ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4081  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4082  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4083  func testUint8x32ConvertToFloat32(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Float32x16, want func(x []uint8) []float32) {
  4084  	n := 32
  4085  	t.Helper()
  4086  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4087  		t.Helper()
  4088  		a := archsimd.LoadUint8x32(x)
  4089  		g := make([]float32, 16)
  4090  		f(a).Store(g)
  4091  		w := want(x)
  4092  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4093  	})
  4094  }
  4095  
  4096  // testUint16x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4097  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4098  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4099  func testUint16x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Float32x16, want func(x []uint16) []float32) {
  4100  	n := 16
  4101  	t.Helper()
  4102  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4103  		t.Helper()
  4104  		a := archsimd.LoadUint16x16(x)
  4105  		g := make([]float32, 16)
  4106  		f(a).Store(g)
  4107  		w := want(x)
  4108  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4109  	})
  4110  }
  4111  
  4112  // testUint32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4113  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4114  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4115  func testUint32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Float32x8, want func(x []uint32) []float32) {
  4116  	n := 8
  4117  	t.Helper()
  4118  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4119  		t.Helper()
  4120  		a := archsimd.LoadUint32x8(x)
  4121  		g := make([]float32, 8)
  4122  		f(a).Store(g)
  4123  		w := want(x)
  4124  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4125  	})
  4126  }
  4127  
  4128  // testUint64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4129  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4130  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4131  func testUint64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Float32x4, want func(x []uint64) []float32) {
  4132  	n := 4
  4133  	t.Helper()
  4134  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4135  		t.Helper()
  4136  		a := archsimd.LoadUint64x4(x)
  4137  		g := make([]float32, 4)
  4138  		f(a).Store(g)
  4139  		w := want(x)
  4140  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4141  	})
  4142  }
  4143  
  4144  // testFloat32x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4145  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4146  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4147  func testFloat32x8ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x8) archsimd.Float32x8, want func(x []float32) []float32) {
  4148  	n := 8
  4149  	t.Helper()
  4150  	forSlice(t, float32s, n, func(x []float32) bool {
  4151  		t.Helper()
  4152  		a := archsimd.LoadFloat32x8(x)
  4153  		g := make([]float32, 8)
  4154  		f(a).Store(g)
  4155  		w := want(x)
  4156  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4157  	})
  4158  }
  4159  
  4160  // testFloat64x4ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4161  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4162  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4163  func testFloat64x4ConvertToFloat32(t *testing.T, f func(x archsimd.Float64x4) archsimd.Float32x4, want func(x []float64) []float32) {
  4164  	n := 4
  4165  	t.Helper()
  4166  	forSlice(t, float64s, n, func(x []float64) bool {
  4167  		t.Helper()
  4168  		a := archsimd.LoadFloat64x4(x)
  4169  		g := make([]float32, 4)
  4170  		f(a).Store(g)
  4171  		w := want(x)
  4172  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4173  	})
  4174  }
  4175  
  4176  // testInt8x64ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4177  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4178  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4179  func testInt8x64ConvertToFloat32(t *testing.T, f func(x archsimd.Int8x64) archsimd.Float32x16, want func(x []int8) []float32) {
  4180  	n := 64
  4181  	t.Helper()
  4182  	forSlice(t, int8s, n, func(x []int8) bool {
  4183  		t.Helper()
  4184  		a := archsimd.LoadInt8x64(x)
  4185  		g := make([]float32, 16)
  4186  		f(a).Store(g)
  4187  		w := want(x)
  4188  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4189  	})
  4190  }
  4191  
  4192  // testInt16x32ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4193  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4194  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4195  func testInt16x32ConvertToFloat32(t *testing.T, f func(x archsimd.Int16x32) archsimd.Float32x16, want func(x []int16) []float32) {
  4196  	n := 32
  4197  	t.Helper()
  4198  	forSlice(t, int16s, n, func(x []int16) bool {
  4199  		t.Helper()
  4200  		a := archsimd.LoadInt16x32(x)
  4201  		g := make([]float32, 16)
  4202  		f(a).Store(g)
  4203  		w := want(x)
  4204  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4205  	})
  4206  }
  4207  
  4208  // testInt32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4209  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4210  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4211  func testInt32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Int32x16) archsimd.Float32x16, want func(x []int32) []float32) {
  4212  	n := 16
  4213  	t.Helper()
  4214  	forSlice(t, int32s, n, func(x []int32) bool {
  4215  		t.Helper()
  4216  		a := archsimd.LoadInt32x16(x)
  4217  		g := make([]float32, 16)
  4218  		f(a).Store(g)
  4219  		w := want(x)
  4220  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4221  	})
  4222  }
  4223  
  4224  // testInt64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4225  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4226  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4227  func testInt64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Int64x8) archsimd.Float32x8, want func(x []int64) []float32) {
  4228  	n := 8
  4229  	t.Helper()
  4230  	forSlice(t, int64s, n, func(x []int64) bool {
  4231  		t.Helper()
  4232  		a := archsimd.LoadInt64x8(x)
  4233  		g := make([]float32, 8)
  4234  		f(a).Store(g)
  4235  		w := want(x)
  4236  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4237  	})
  4238  }
  4239  
  4240  // testUint8x64ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4241  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4242  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4243  func testUint8x64ConvertToFloat32(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Float32x16, want func(x []uint8) []float32) {
  4244  	n := 64
  4245  	t.Helper()
  4246  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4247  		t.Helper()
  4248  		a := archsimd.LoadUint8x64(x)
  4249  		g := make([]float32, 16)
  4250  		f(a).Store(g)
  4251  		w := want(x)
  4252  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4253  	})
  4254  }
  4255  
  4256  // testUint16x32ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4257  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4258  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4259  func testUint16x32ConvertToFloat32(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Float32x16, want func(x []uint16) []float32) {
  4260  	n := 32
  4261  	t.Helper()
  4262  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4263  		t.Helper()
  4264  		a := archsimd.LoadUint16x32(x)
  4265  		g := make([]float32, 16)
  4266  		f(a).Store(g)
  4267  		w := want(x)
  4268  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4269  	})
  4270  }
  4271  
  4272  // testUint32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4273  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4274  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4275  func testUint32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Float32x16, want func(x []uint32) []float32) {
  4276  	n := 16
  4277  	t.Helper()
  4278  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4279  		t.Helper()
  4280  		a := archsimd.LoadUint32x16(x)
  4281  		g := make([]float32, 16)
  4282  		f(a).Store(g)
  4283  		w := want(x)
  4284  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4285  	})
  4286  }
  4287  
  4288  // testUint64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4289  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4290  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4291  func testUint64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Float32x8, want func(x []uint64) []float32) {
  4292  	n := 8
  4293  	t.Helper()
  4294  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4295  		t.Helper()
  4296  		a := archsimd.LoadUint64x8(x)
  4297  		g := make([]float32, 8)
  4298  		f(a).Store(g)
  4299  		w := want(x)
  4300  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4301  	})
  4302  }
  4303  
  4304  // testFloat32x16ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4305  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4306  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4307  func testFloat32x16ConvertToFloat32(t *testing.T, f func(x archsimd.Float32x16) archsimd.Float32x16, want func(x []float32) []float32) {
  4308  	n := 16
  4309  	t.Helper()
  4310  	forSlice(t, float32s, n, func(x []float32) bool {
  4311  		t.Helper()
  4312  		a := archsimd.LoadFloat32x16(x)
  4313  		g := make([]float32, 16)
  4314  		f(a).Store(g)
  4315  		w := want(x)
  4316  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4317  	})
  4318  }
  4319  
  4320  // testFloat64x8ConvertToFloat32 tests the simd conversion method f against the expected behavior generated by want.
  4321  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4322  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4323  func testFloat64x8ConvertToFloat32(t *testing.T, f func(x archsimd.Float64x8) archsimd.Float32x8, want func(x []float64) []float32) {
  4324  	n := 8
  4325  	t.Helper()
  4326  	forSlice(t, float64s, n, func(x []float64) bool {
  4327  		t.Helper()
  4328  		a := archsimd.LoadFloat64x8(x)
  4329  		g := make([]float32, 8)
  4330  		f(a).Store(g)
  4331  		w := want(x)
  4332  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4333  	})
  4334  }
  4335  
  4336  // testInt8x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4337  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4338  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4339  func testInt8x16ConvertToFloat64(t *testing.T, f func(x archsimd.Int8x16) archsimd.Float64x8, want func(x []int8) []float64) {
  4340  	n := 16
  4341  	t.Helper()
  4342  	forSlice(t, int8s, n, func(x []int8) bool {
  4343  		t.Helper()
  4344  		a := archsimd.LoadInt8x16(x)
  4345  		g := make([]float64, 8)
  4346  		f(a).Store(g)
  4347  		w := want(x)
  4348  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4349  	})
  4350  }
  4351  
  4352  // testInt16x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4353  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4354  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4355  func testInt16x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int16x8) archsimd.Float64x8, want func(x []int16) []float64) {
  4356  	n := 8
  4357  	t.Helper()
  4358  	forSlice(t, int16s, n, func(x []int16) bool {
  4359  		t.Helper()
  4360  		a := archsimd.LoadInt16x8(x)
  4361  		g := make([]float64, 8)
  4362  		f(a).Store(g)
  4363  		w := want(x)
  4364  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4365  	})
  4366  }
  4367  
  4368  // testInt32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4369  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4370  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4371  func testInt32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Int32x4) archsimd.Float64x4, want func(x []int32) []float64) {
  4372  	n := 4
  4373  	t.Helper()
  4374  	forSlice(t, int32s, n, func(x []int32) bool {
  4375  		t.Helper()
  4376  		a := archsimd.LoadInt32x4(x)
  4377  		g := make([]float64, 4)
  4378  		f(a).Store(g)
  4379  		w := want(x)
  4380  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4381  	})
  4382  }
  4383  
  4384  // testInt64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4385  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4386  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4387  func testInt64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x2) archsimd.Float64x2, want func(x []int64) []float64) {
  4388  	n := 2
  4389  	t.Helper()
  4390  	forSlice(t, int64s, n, func(x []int64) bool {
  4391  		t.Helper()
  4392  		a := archsimd.LoadInt64x2(x)
  4393  		g := make([]float64, 2)
  4394  		f(a).Store(g)
  4395  		w := want(x)
  4396  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4397  	})
  4398  }
  4399  
  4400  // testUint8x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4401  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4402  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4403  func testUint8x16ConvertToFloat64(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Float64x8, want func(x []uint8) []float64) {
  4404  	n := 16
  4405  	t.Helper()
  4406  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4407  		t.Helper()
  4408  		a := archsimd.LoadUint8x16(x)
  4409  		g := make([]float64, 8)
  4410  		f(a).Store(g)
  4411  		w := want(x)
  4412  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4413  	})
  4414  }
  4415  
  4416  // testUint16x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4417  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4418  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4419  func testUint16x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Float64x8, want func(x []uint16) []float64) {
  4420  	n := 8
  4421  	t.Helper()
  4422  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4423  		t.Helper()
  4424  		a := archsimd.LoadUint16x8(x)
  4425  		g := make([]float64, 8)
  4426  		f(a).Store(g)
  4427  		w := want(x)
  4428  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4429  	})
  4430  }
  4431  
  4432  // testUint32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4433  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4434  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4435  func testUint32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Float64x4, want func(x []uint32) []float64) {
  4436  	n := 4
  4437  	t.Helper()
  4438  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4439  		t.Helper()
  4440  		a := archsimd.LoadUint32x4(x)
  4441  		g := make([]float64, 4)
  4442  		f(a).Store(g)
  4443  		w := want(x)
  4444  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4445  	})
  4446  }
  4447  
  4448  // testUint64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4449  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4450  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4451  func testUint64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Float64x2, want func(x []uint64) []float64) {
  4452  	n := 2
  4453  	t.Helper()
  4454  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4455  		t.Helper()
  4456  		a := archsimd.LoadUint64x2(x)
  4457  		g := make([]float64, 2)
  4458  		f(a).Store(g)
  4459  		w := want(x)
  4460  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4461  	})
  4462  }
  4463  
  4464  // testFloat32x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4465  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4466  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4467  func testFloat32x4ConvertToFloat64(t *testing.T, f func(x archsimd.Float32x4) archsimd.Float64x4, want func(x []float32) []float64) {
  4468  	n := 4
  4469  	t.Helper()
  4470  	forSlice(t, float32s, n, func(x []float32) bool {
  4471  		t.Helper()
  4472  		a := archsimd.LoadFloat32x4(x)
  4473  		g := make([]float64, 4)
  4474  		f(a).Store(g)
  4475  		w := want(x)
  4476  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4477  	})
  4478  }
  4479  
  4480  // testFloat64x2ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4481  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4482  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4483  func testFloat64x2ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x2) archsimd.Float64x2, want func(x []float64) []float64) {
  4484  	n := 2
  4485  	t.Helper()
  4486  	forSlice(t, float64s, n, func(x []float64) bool {
  4487  		t.Helper()
  4488  		a := archsimd.LoadFloat64x2(x)
  4489  		g := make([]float64, 2)
  4490  		f(a).Store(g)
  4491  		w := want(x)
  4492  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4493  	})
  4494  }
  4495  
  4496  // testInt8x32ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4497  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4498  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4499  func testInt8x32ConvertToFloat64(t *testing.T, f func(x archsimd.Int8x32) archsimd.Float64x8, want func(x []int8) []float64) {
  4500  	n := 32
  4501  	t.Helper()
  4502  	forSlice(t, int8s, n, func(x []int8) bool {
  4503  		t.Helper()
  4504  		a := archsimd.LoadInt8x32(x)
  4505  		g := make([]float64, 8)
  4506  		f(a).Store(g)
  4507  		w := want(x)
  4508  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4509  	})
  4510  }
  4511  
  4512  // testInt16x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4513  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4514  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4515  func testInt16x16ConvertToFloat64(t *testing.T, f func(x archsimd.Int16x16) archsimd.Float64x8, want func(x []int16) []float64) {
  4516  	n := 16
  4517  	t.Helper()
  4518  	forSlice(t, int16s, n, func(x []int16) bool {
  4519  		t.Helper()
  4520  		a := archsimd.LoadInt16x16(x)
  4521  		g := make([]float64, 8)
  4522  		f(a).Store(g)
  4523  		w := want(x)
  4524  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4525  	})
  4526  }
  4527  
  4528  // testInt32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4529  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4530  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4531  func testInt32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int32x8) archsimd.Float64x8, want func(x []int32) []float64) {
  4532  	n := 8
  4533  	t.Helper()
  4534  	forSlice(t, int32s, n, func(x []int32) bool {
  4535  		t.Helper()
  4536  		a := archsimd.LoadInt32x8(x)
  4537  		g := make([]float64, 8)
  4538  		f(a).Store(g)
  4539  		w := want(x)
  4540  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4541  	})
  4542  }
  4543  
  4544  // testInt64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4545  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4546  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4547  func testInt64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x4) archsimd.Float64x4, want func(x []int64) []float64) {
  4548  	n := 4
  4549  	t.Helper()
  4550  	forSlice(t, int64s, n, func(x []int64) bool {
  4551  		t.Helper()
  4552  		a := archsimd.LoadInt64x4(x)
  4553  		g := make([]float64, 4)
  4554  		f(a).Store(g)
  4555  		w := want(x)
  4556  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4557  	})
  4558  }
  4559  
  4560  // testUint8x32ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4561  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4562  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4563  func testUint8x32ConvertToFloat64(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Float64x8, want func(x []uint8) []float64) {
  4564  	n := 32
  4565  	t.Helper()
  4566  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4567  		t.Helper()
  4568  		a := archsimd.LoadUint8x32(x)
  4569  		g := make([]float64, 8)
  4570  		f(a).Store(g)
  4571  		w := want(x)
  4572  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4573  	})
  4574  }
  4575  
  4576  // testUint16x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4577  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4578  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4579  func testUint16x16ConvertToFloat64(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Float64x8, want func(x []uint16) []float64) {
  4580  	n := 16
  4581  	t.Helper()
  4582  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4583  		t.Helper()
  4584  		a := archsimd.LoadUint16x16(x)
  4585  		g := make([]float64, 8)
  4586  		f(a).Store(g)
  4587  		w := want(x)
  4588  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4589  	})
  4590  }
  4591  
  4592  // testUint32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4593  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4594  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4595  func testUint32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Float64x8, want func(x []uint32) []float64) {
  4596  	n := 8
  4597  	t.Helper()
  4598  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4599  		t.Helper()
  4600  		a := archsimd.LoadUint32x8(x)
  4601  		g := make([]float64, 8)
  4602  		f(a).Store(g)
  4603  		w := want(x)
  4604  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4605  	})
  4606  }
  4607  
  4608  // testUint64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4609  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4610  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4611  func testUint64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Float64x4, want func(x []uint64) []float64) {
  4612  	n := 4
  4613  	t.Helper()
  4614  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4615  		t.Helper()
  4616  		a := archsimd.LoadUint64x4(x)
  4617  		g := make([]float64, 4)
  4618  		f(a).Store(g)
  4619  		w := want(x)
  4620  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4621  	})
  4622  }
  4623  
  4624  // testFloat32x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4625  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4626  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4627  func testFloat32x8ConvertToFloat64(t *testing.T, f func(x archsimd.Float32x8) archsimd.Float64x8, want func(x []float32) []float64) {
  4628  	n := 8
  4629  	t.Helper()
  4630  	forSlice(t, float32s, n, func(x []float32) bool {
  4631  		t.Helper()
  4632  		a := archsimd.LoadFloat32x8(x)
  4633  		g := make([]float64, 8)
  4634  		f(a).Store(g)
  4635  		w := want(x)
  4636  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4637  	})
  4638  }
  4639  
  4640  // testFloat64x4ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4641  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4642  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4643  func testFloat64x4ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x4) archsimd.Float64x4, want func(x []float64) []float64) {
  4644  	n := 4
  4645  	t.Helper()
  4646  	forSlice(t, float64s, n, func(x []float64) bool {
  4647  		t.Helper()
  4648  		a := archsimd.LoadFloat64x4(x)
  4649  		g := make([]float64, 4)
  4650  		f(a).Store(g)
  4651  		w := want(x)
  4652  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4653  	})
  4654  }
  4655  
  4656  // testInt8x64ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4657  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4658  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4659  func testInt8x64ConvertToFloat64(t *testing.T, f func(x archsimd.Int8x64) archsimd.Float64x8, want func(x []int8) []float64) {
  4660  	n := 64
  4661  	t.Helper()
  4662  	forSlice(t, int8s, n, func(x []int8) bool {
  4663  		t.Helper()
  4664  		a := archsimd.LoadInt8x64(x)
  4665  		g := make([]float64, 8)
  4666  		f(a).Store(g)
  4667  		w := want(x)
  4668  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4669  	})
  4670  }
  4671  
  4672  // testInt16x32ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4673  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4674  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4675  func testInt16x32ConvertToFloat64(t *testing.T, f func(x archsimd.Int16x32) archsimd.Float64x8, want func(x []int16) []float64) {
  4676  	n := 32
  4677  	t.Helper()
  4678  	forSlice(t, int16s, n, func(x []int16) bool {
  4679  		t.Helper()
  4680  		a := archsimd.LoadInt16x32(x)
  4681  		g := make([]float64, 8)
  4682  		f(a).Store(g)
  4683  		w := want(x)
  4684  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4685  	})
  4686  }
  4687  
  4688  // testInt32x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4689  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4690  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4691  func testInt32x16ConvertToFloat64(t *testing.T, f func(x archsimd.Int32x16) archsimd.Float64x8, want func(x []int32) []float64) {
  4692  	n := 16
  4693  	t.Helper()
  4694  	forSlice(t, int32s, n, func(x []int32) bool {
  4695  		t.Helper()
  4696  		a := archsimd.LoadInt32x16(x)
  4697  		g := make([]float64, 8)
  4698  		f(a).Store(g)
  4699  		w := want(x)
  4700  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4701  	})
  4702  }
  4703  
  4704  // testInt64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4705  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4706  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4707  func testInt64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Int64x8) archsimd.Float64x8, want func(x []int64) []float64) {
  4708  	n := 8
  4709  	t.Helper()
  4710  	forSlice(t, int64s, n, func(x []int64) bool {
  4711  		t.Helper()
  4712  		a := archsimd.LoadInt64x8(x)
  4713  		g := make([]float64, 8)
  4714  		f(a).Store(g)
  4715  		w := want(x)
  4716  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4717  	})
  4718  }
  4719  
  4720  // testUint8x64ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4721  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4722  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4723  func testUint8x64ConvertToFloat64(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Float64x8, want func(x []uint8) []float64) {
  4724  	n := 64
  4725  	t.Helper()
  4726  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4727  		t.Helper()
  4728  		a := archsimd.LoadUint8x64(x)
  4729  		g := make([]float64, 8)
  4730  		f(a).Store(g)
  4731  		w := want(x)
  4732  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4733  	})
  4734  }
  4735  
  4736  // testUint16x32ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4737  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4738  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4739  func testUint16x32ConvertToFloat64(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Float64x8, want func(x []uint16) []float64) {
  4740  	n := 32
  4741  	t.Helper()
  4742  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4743  		t.Helper()
  4744  		a := archsimd.LoadUint16x32(x)
  4745  		g := make([]float64, 8)
  4746  		f(a).Store(g)
  4747  		w := want(x)
  4748  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4749  	})
  4750  }
  4751  
  4752  // testUint32x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4753  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4754  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4755  func testUint32x16ConvertToFloat64(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Float64x8, want func(x []uint32) []float64) {
  4756  	n := 16
  4757  	t.Helper()
  4758  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4759  		t.Helper()
  4760  		a := archsimd.LoadUint32x16(x)
  4761  		g := make([]float64, 8)
  4762  		f(a).Store(g)
  4763  		w := want(x)
  4764  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4765  	})
  4766  }
  4767  
  4768  // testUint64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4769  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4770  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4771  func testUint64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Float64x8, want func(x []uint64) []float64) {
  4772  	n := 8
  4773  	t.Helper()
  4774  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4775  		t.Helper()
  4776  		a := archsimd.LoadUint64x8(x)
  4777  		g := make([]float64, 8)
  4778  		f(a).Store(g)
  4779  		w := want(x)
  4780  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4781  	})
  4782  }
  4783  
  4784  // testFloat32x16ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4785  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4786  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4787  func testFloat32x16ConvertToFloat64(t *testing.T, f func(x archsimd.Float32x16) archsimd.Float64x8, want func(x []float32) []float64) {
  4788  	n := 16
  4789  	t.Helper()
  4790  	forSlice(t, float32s, n, func(x []float32) bool {
  4791  		t.Helper()
  4792  		a := archsimd.LoadFloat32x16(x)
  4793  		g := make([]float64, 8)
  4794  		f(a).Store(g)
  4795  		w := want(x)
  4796  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4797  	})
  4798  }
  4799  
  4800  // testFloat64x8ConvertToFloat64 tests the simd conversion method f against the expected behavior generated by want.
  4801  // This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width,
  4802  // (extended to at least 128 bits, or truncated to at most 512 bits).
  4803  func testFloat64x8ConvertToFloat64(t *testing.T, f func(x archsimd.Float64x8) archsimd.Float64x8, want func(x []float64) []float64) {
  4804  	n := 8
  4805  	t.Helper()
  4806  	forSlice(t, float64s, n, func(x []float64) bool {
  4807  		t.Helper()
  4808  		a := archsimd.LoadFloat64x8(x)
  4809  		g := make([]float64, 8)
  4810  		f(a).Store(g)
  4811  		w := want(x)
  4812  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4813  	})
  4814  }
  4815  
  4816  // testInt8x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4817  // This converts only the low 2 elements.
  4818  func testInt8x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int64x2, want func(x []int8) []int64) {
  4819  	n := 16
  4820  	t.Helper()
  4821  	forSlice(t, int8s, n, func(x []int8) bool {
  4822  		t.Helper()
  4823  		a := archsimd.LoadInt8x16(x)
  4824  		g := make([]int64, 2)
  4825  		f(a).Store(g)
  4826  		w := want(x)
  4827  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4828  	})
  4829  }
  4830  
  4831  // testInt16x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4832  // This converts only the low 2 elements.
  4833  func testInt16x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int64x2, want func(x []int16) []int64) {
  4834  	n := 8
  4835  	t.Helper()
  4836  	forSlice(t, int16s, n, func(x []int16) bool {
  4837  		t.Helper()
  4838  		a := archsimd.LoadInt16x8(x)
  4839  		g := make([]int64, 2)
  4840  		f(a).Store(g)
  4841  		w := want(x)
  4842  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4843  	})
  4844  }
  4845  
  4846  // testInt32x4ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4847  // This converts only the low 2 elements.
  4848  func testInt32x4ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int64x2, want func(x []int32) []int64) {
  4849  	n := 4
  4850  	t.Helper()
  4851  	forSlice(t, int32s, n, func(x []int32) bool {
  4852  		t.Helper()
  4853  		a := archsimd.LoadInt32x4(x)
  4854  		g := make([]int64, 2)
  4855  		f(a).Store(g)
  4856  		w := want(x)
  4857  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4858  	})
  4859  }
  4860  
  4861  // testInt64x2ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4862  // This converts only the low 2 elements.
  4863  func testInt64x2ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int64x2, want func(x []int64) []int64) {
  4864  	n := 2
  4865  	t.Helper()
  4866  	forSlice(t, int64s, n, func(x []int64) bool {
  4867  		t.Helper()
  4868  		a := archsimd.LoadInt64x2(x)
  4869  		g := make([]int64, 2)
  4870  		f(a).Store(g)
  4871  		w := want(x)
  4872  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4873  	})
  4874  }
  4875  
  4876  // testUint8x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4877  // This converts only the low 2 elements.
  4878  func testUint8x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int64x2, want func(x []uint8) []int64) {
  4879  	n := 16
  4880  	t.Helper()
  4881  	forSlice(t, uint8s, n, func(x []uint8) bool {
  4882  		t.Helper()
  4883  		a := archsimd.LoadUint8x16(x)
  4884  		g := make([]int64, 2)
  4885  		f(a).Store(g)
  4886  		w := want(x)
  4887  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4888  	})
  4889  }
  4890  
  4891  // testUint16x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4892  // This converts only the low 2 elements.
  4893  func testUint16x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int64x2, want func(x []uint16) []int64) {
  4894  	n := 8
  4895  	t.Helper()
  4896  	forSlice(t, uint16s, n, func(x []uint16) bool {
  4897  		t.Helper()
  4898  		a := archsimd.LoadUint16x8(x)
  4899  		g := make([]int64, 2)
  4900  		f(a).Store(g)
  4901  		w := want(x)
  4902  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4903  	})
  4904  }
  4905  
  4906  // testUint32x4ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4907  // This converts only the low 2 elements.
  4908  func testUint32x4ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int64x2, want func(x []uint32) []int64) {
  4909  	n := 4
  4910  	t.Helper()
  4911  	forSlice(t, uint32s, n, func(x []uint32) bool {
  4912  		t.Helper()
  4913  		a := archsimd.LoadUint32x4(x)
  4914  		g := make([]int64, 2)
  4915  		f(a).Store(g)
  4916  		w := want(x)
  4917  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4918  	})
  4919  }
  4920  
  4921  // testUint64x2ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4922  // This converts only the low 2 elements.
  4923  func testUint64x2ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int64x2, want func(x []uint64) []int64) {
  4924  	n := 2
  4925  	t.Helper()
  4926  	forSlice(t, uint64s, n, func(x []uint64) bool {
  4927  		t.Helper()
  4928  		a := archsimd.LoadUint64x2(x)
  4929  		g := make([]int64, 2)
  4930  		f(a).Store(g)
  4931  		w := want(x)
  4932  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4933  	})
  4934  }
  4935  
  4936  // testInt8x32ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4937  // This converts only the low 2 elements.
  4938  func testInt8x32ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int64x2, want func(x []int8) []int64) {
  4939  	n := 32
  4940  	t.Helper()
  4941  	forSlice(t, int8s, n, func(x []int8) bool {
  4942  		t.Helper()
  4943  		a := archsimd.LoadInt8x32(x)
  4944  		g := make([]int64, 2)
  4945  		f(a).Store(g)
  4946  		w := want(x)
  4947  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4948  	})
  4949  }
  4950  
  4951  // testInt16x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4952  // This converts only the low 2 elements.
  4953  func testInt16x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int64x2, want func(x []int16) []int64) {
  4954  	n := 16
  4955  	t.Helper()
  4956  	forSlice(t, int16s, n, func(x []int16) bool {
  4957  		t.Helper()
  4958  		a := archsimd.LoadInt16x16(x)
  4959  		g := make([]int64, 2)
  4960  		f(a).Store(g)
  4961  		w := want(x)
  4962  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4963  	})
  4964  }
  4965  
  4966  // testInt32x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4967  // This converts only the low 2 elements.
  4968  func testInt32x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int64x2, want func(x []int32) []int64) {
  4969  	n := 8
  4970  	t.Helper()
  4971  	forSlice(t, int32s, n, func(x []int32) bool {
  4972  		t.Helper()
  4973  		a := archsimd.LoadInt32x8(x)
  4974  		g := make([]int64, 2)
  4975  		f(a).Store(g)
  4976  		w := want(x)
  4977  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4978  	})
  4979  }
  4980  
  4981  // testInt64x4ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4982  // This converts only the low 2 elements.
  4983  func testInt64x4ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int64x2, want func(x []int64) []int64) {
  4984  	n := 4
  4985  	t.Helper()
  4986  	forSlice(t, int64s, n, func(x []int64) bool {
  4987  		t.Helper()
  4988  		a := archsimd.LoadInt64x4(x)
  4989  		g := make([]int64, 2)
  4990  		f(a).Store(g)
  4991  		w := want(x)
  4992  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  4993  	})
  4994  }
  4995  
  4996  // testUint8x32ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  4997  // This converts only the low 2 elements.
  4998  func testUint8x32ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int64x2, want func(x []uint8) []int64) {
  4999  	n := 32
  5000  	t.Helper()
  5001  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5002  		t.Helper()
  5003  		a := archsimd.LoadUint8x32(x)
  5004  		g := make([]int64, 2)
  5005  		f(a).Store(g)
  5006  		w := want(x)
  5007  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5008  	})
  5009  }
  5010  
  5011  // testUint16x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5012  // This converts only the low 2 elements.
  5013  func testUint16x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int64x2, want func(x []uint16) []int64) {
  5014  	n := 16
  5015  	t.Helper()
  5016  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5017  		t.Helper()
  5018  		a := archsimd.LoadUint16x16(x)
  5019  		g := make([]int64, 2)
  5020  		f(a).Store(g)
  5021  		w := want(x)
  5022  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5023  	})
  5024  }
  5025  
  5026  // testUint32x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5027  // This converts only the low 2 elements.
  5028  func testUint32x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int64x2, want func(x []uint32) []int64) {
  5029  	n := 8
  5030  	t.Helper()
  5031  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5032  		t.Helper()
  5033  		a := archsimd.LoadUint32x8(x)
  5034  		g := make([]int64, 2)
  5035  		f(a).Store(g)
  5036  		w := want(x)
  5037  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5038  	})
  5039  }
  5040  
  5041  // testUint64x4ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5042  // This converts only the low 2 elements.
  5043  func testUint64x4ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int64x2, want func(x []uint64) []int64) {
  5044  	n := 4
  5045  	t.Helper()
  5046  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5047  		t.Helper()
  5048  		a := archsimd.LoadUint64x4(x)
  5049  		g := make([]int64, 2)
  5050  		f(a).Store(g)
  5051  		w := want(x)
  5052  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5053  	})
  5054  }
  5055  
  5056  // testInt8x64ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5057  // This converts only the low 2 elements.
  5058  func testInt8x64ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int64x2, want func(x []int8) []int64) {
  5059  	n := 64
  5060  	t.Helper()
  5061  	forSlice(t, int8s, n, func(x []int8) bool {
  5062  		t.Helper()
  5063  		a := archsimd.LoadInt8x64(x)
  5064  		g := make([]int64, 2)
  5065  		f(a).Store(g)
  5066  		w := want(x)
  5067  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5068  	})
  5069  }
  5070  
  5071  // testInt16x32ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5072  // This converts only the low 2 elements.
  5073  func testInt16x32ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int64x2, want func(x []int16) []int64) {
  5074  	n := 32
  5075  	t.Helper()
  5076  	forSlice(t, int16s, n, func(x []int16) bool {
  5077  		t.Helper()
  5078  		a := archsimd.LoadInt16x32(x)
  5079  		g := make([]int64, 2)
  5080  		f(a).Store(g)
  5081  		w := want(x)
  5082  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5083  	})
  5084  }
  5085  
  5086  // testInt32x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5087  // This converts only the low 2 elements.
  5088  func testInt32x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int64x2, want func(x []int32) []int64) {
  5089  	n := 16
  5090  	t.Helper()
  5091  	forSlice(t, int32s, n, func(x []int32) bool {
  5092  		t.Helper()
  5093  		a := archsimd.LoadInt32x16(x)
  5094  		g := make([]int64, 2)
  5095  		f(a).Store(g)
  5096  		w := want(x)
  5097  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5098  	})
  5099  }
  5100  
  5101  // testInt64x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5102  // This converts only the low 2 elements.
  5103  func testInt64x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int64x2, want func(x []int64) []int64) {
  5104  	n := 8
  5105  	t.Helper()
  5106  	forSlice(t, int64s, n, func(x []int64) bool {
  5107  		t.Helper()
  5108  		a := archsimd.LoadInt64x8(x)
  5109  		g := make([]int64, 2)
  5110  		f(a).Store(g)
  5111  		w := want(x)
  5112  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5113  	})
  5114  }
  5115  
  5116  // testUint8x64ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5117  // This converts only the low 2 elements.
  5118  func testUint8x64ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int64x2, want func(x []uint8) []int64) {
  5119  	n := 64
  5120  	t.Helper()
  5121  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5122  		t.Helper()
  5123  		a := archsimd.LoadUint8x64(x)
  5124  		g := make([]int64, 2)
  5125  		f(a).Store(g)
  5126  		w := want(x)
  5127  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5128  	})
  5129  }
  5130  
  5131  // testUint16x32ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5132  // This converts only the low 2 elements.
  5133  func testUint16x32ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int64x2, want func(x []uint16) []int64) {
  5134  	n := 32
  5135  	t.Helper()
  5136  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5137  		t.Helper()
  5138  		a := archsimd.LoadUint16x32(x)
  5139  		g := make([]int64, 2)
  5140  		f(a).Store(g)
  5141  		w := want(x)
  5142  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5143  	})
  5144  }
  5145  
  5146  // testUint32x16ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5147  // This converts only the low 2 elements.
  5148  func testUint32x16ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int64x2, want func(x []uint32) []int64) {
  5149  	n := 16
  5150  	t.Helper()
  5151  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5152  		t.Helper()
  5153  		a := archsimd.LoadUint32x16(x)
  5154  		g := make([]int64, 2)
  5155  		f(a).Store(g)
  5156  		w := want(x)
  5157  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5158  	})
  5159  }
  5160  
  5161  // testUint64x8ConvertLoToInt64x2 tests the simd conversion method f against the expected behavior generated by want.
  5162  // This converts only the low 2 elements.
  5163  func testUint64x8ConvertLoToInt64x2(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int64x2, want func(x []uint64) []int64) {
  5164  	n := 8
  5165  	t.Helper()
  5166  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5167  		t.Helper()
  5168  		a := archsimd.LoadUint64x8(x)
  5169  		g := make([]int64, 2)
  5170  		f(a).Store(g)
  5171  		w := want(x)
  5172  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5173  	})
  5174  }
  5175  
  5176  // testInt8x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5177  // This converts only the low 4 elements.
  5178  func testInt8x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int64x4, want func(x []int8) []int64) {
  5179  	n := 16
  5180  	t.Helper()
  5181  	forSlice(t, int8s, n, func(x []int8) bool {
  5182  		t.Helper()
  5183  		a := archsimd.LoadInt8x16(x)
  5184  		g := make([]int64, 4)
  5185  		f(a).Store(g)
  5186  		w := want(x)
  5187  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5188  	})
  5189  }
  5190  
  5191  // testInt16x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5192  // This converts only the low 4 elements.
  5193  func testInt16x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int64x4, want func(x []int16) []int64) {
  5194  	n := 8
  5195  	t.Helper()
  5196  	forSlice(t, int16s, n, func(x []int16) bool {
  5197  		t.Helper()
  5198  		a := archsimd.LoadInt16x8(x)
  5199  		g := make([]int64, 4)
  5200  		f(a).Store(g)
  5201  		w := want(x)
  5202  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5203  	})
  5204  }
  5205  
  5206  // testInt32x4ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5207  // This converts only the low 4 elements.
  5208  func testInt32x4ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int64x4, want func(x []int32) []int64) {
  5209  	n := 4
  5210  	t.Helper()
  5211  	forSlice(t, int32s, n, func(x []int32) bool {
  5212  		t.Helper()
  5213  		a := archsimd.LoadInt32x4(x)
  5214  		g := make([]int64, 4)
  5215  		f(a).Store(g)
  5216  		w := want(x)
  5217  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5218  	})
  5219  }
  5220  
  5221  // testInt64x2ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5222  // This converts only the low 4 elements.
  5223  func testInt64x2ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int64x4, want func(x []int64) []int64) {
  5224  	n := 2
  5225  	t.Helper()
  5226  	forSlice(t, int64s, n, func(x []int64) bool {
  5227  		t.Helper()
  5228  		a := archsimd.LoadInt64x2(x)
  5229  		g := make([]int64, 4)
  5230  		f(a).Store(g)
  5231  		w := want(x)
  5232  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5233  	})
  5234  }
  5235  
  5236  // testUint8x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5237  // This converts only the low 4 elements.
  5238  func testUint8x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int64x4, want func(x []uint8) []int64) {
  5239  	n := 16
  5240  	t.Helper()
  5241  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5242  		t.Helper()
  5243  		a := archsimd.LoadUint8x16(x)
  5244  		g := make([]int64, 4)
  5245  		f(a).Store(g)
  5246  		w := want(x)
  5247  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5248  	})
  5249  }
  5250  
  5251  // testUint16x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5252  // This converts only the low 4 elements.
  5253  func testUint16x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int64x4, want func(x []uint16) []int64) {
  5254  	n := 8
  5255  	t.Helper()
  5256  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5257  		t.Helper()
  5258  		a := archsimd.LoadUint16x8(x)
  5259  		g := make([]int64, 4)
  5260  		f(a).Store(g)
  5261  		w := want(x)
  5262  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5263  	})
  5264  }
  5265  
  5266  // testUint32x4ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5267  // This converts only the low 4 elements.
  5268  func testUint32x4ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int64x4, want func(x []uint32) []int64) {
  5269  	n := 4
  5270  	t.Helper()
  5271  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5272  		t.Helper()
  5273  		a := archsimd.LoadUint32x4(x)
  5274  		g := make([]int64, 4)
  5275  		f(a).Store(g)
  5276  		w := want(x)
  5277  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5278  	})
  5279  }
  5280  
  5281  // testUint64x2ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5282  // This converts only the low 4 elements.
  5283  func testUint64x2ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int64x4, want func(x []uint64) []int64) {
  5284  	n := 2
  5285  	t.Helper()
  5286  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5287  		t.Helper()
  5288  		a := archsimd.LoadUint64x2(x)
  5289  		g := make([]int64, 4)
  5290  		f(a).Store(g)
  5291  		w := want(x)
  5292  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5293  	})
  5294  }
  5295  
  5296  // testInt8x32ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5297  // This converts only the low 4 elements.
  5298  func testInt8x32ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int64x4, want func(x []int8) []int64) {
  5299  	n := 32
  5300  	t.Helper()
  5301  	forSlice(t, int8s, n, func(x []int8) bool {
  5302  		t.Helper()
  5303  		a := archsimd.LoadInt8x32(x)
  5304  		g := make([]int64, 4)
  5305  		f(a).Store(g)
  5306  		w := want(x)
  5307  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5308  	})
  5309  }
  5310  
  5311  // testInt16x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5312  // This converts only the low 4 elements.
  5313  func testInt16x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int64x4, want func(x []int16) []int64) {
  5314  	n := 16
  5315  	t.Helper()
  5316  	forSlice(t, int16s, n, func(x []int16) bool {
  5317  		t.Helper()
  5318  		a := archsimd.LoadInt16x16(x)
  5319  		g := make([]int64, 4)
  5320  		f(a).Store(g)
  5321  		w := want(x)
  5322  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5323  	})
  5324  }
  5325  
  5326  // testInt32x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5327  // This converts only the low 4 elements.
  5328  func testInt32x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int64x4, want func(x []int32) []int64) {
  5329  	n := 8
  5330  	t.Helper()
  5331  	forSlice(t, int32s, n, func(x []int32) bool {
  5332  		t.Helper()
  5333  		a := archsimd.LoadInt32x8(x)
  5334  		g := make([]int64, 4)
  5335  		f(a).Store(g)
  5336  		w := want(x)
  5337  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5338  	})
  5339  }
  5340  
  5341  // testInt64x4ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5342  // This converts only the low 4 elements.
  5343  func testInt64x4ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int64x4, want func(x []int64) []int64) {
  5344  	n := 4
  5345  	t.Helper()
  5346  	forSlice(t, int64s, n, func(x []int64) bool {
  5347  		t.Helper()
  5348  		a := archsimd.LoadInt64x4(x)
  5349  		g := make([]int64, 4)
  5350  		f(a).Store(g)
  5351  		w := want(x)
  5352  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5353  	})
  5354  }
  5355  
  5356  // testUint8x32ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5357  // This converts only the low 4 elements.
  5358  func testUint8x32ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int64x4, want func(x []uint8) []int64) {
  5359  	n := 32
  5360  	t.Helper()
  5361  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5362  		t.Helper()
  5363  		a := archsimd.LoadUint8x32(x)
  5364  		g := make([]int64, 4)
  5365  		f(a).Store(g)
  5366  		w := want(x)
  5367  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5368  	})
  5369  }
  5370  
  5371  // testUint16x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5372  // This converts only the low 4 elements.
  5373  func testUint16x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int64x4, want func(x []uint16) []int64) {
  5374  	n := 16
  5375  	t.Helper()
  5376  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5377  		t.Helper()
  5378  		a := archsimd.LoadUint16x16(x)
  5379  		g := make([]int64, 4)
  5380  		f(a).Store(g)
  5381  		w := want(x)
  5382  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5383  	})
  5384  }
  5385  
  5386  // testUint32x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5387  // This converts only the low 4 elements.
  5388  func testUint32x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int64x4, want func(x []uint32) []int64) {
  5389  	n := 8
  5390  	t.Helper()
  5391  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5392  		t.Helper()
  5393  		a := archsimd.LoadUint32x8(x)
  5394  		g := make([]int64, 4)
  5395  		f(a).Store(g)
  5396  		w := want(x)
  5397  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5398  	})
  5399  }
  5400  
  5401  // testUint64x4ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5402  // This converts only the low 4 elements.
  5403  func testUint64x4ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int64x4, want func(x []uint64) []int64) {
  5404  	n := 4
  5405  	t.Helper()
  5406  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5407  		t.Helper()
  5408  		a := archsimd.LoadUint64x4(x)
  5409  		g := make([]int64, 4)
  5410  		f(a).Store(g)
  5411  		w := want(x)
  5412  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5413  	})
  5414  }
  5415  
  5416  // testInt8x64ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5417  // This converts only the low 4 elements.
  5418  func testInt8x64ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int64x4, want func(x []int8) []int64) {
  5419  	n := 64
  5420  	t.Helper()
  5421  	forSlice(t, int8s, n, func(x []int8) bool {
  5422  		t.Helper()
  5423  		a := archsimd.LoadInt8x64(x)
  5424  		g := make([]int64, 4)
  5425  		f(a).Store(g)
  5426  		w := want(x)
  5427  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5428  	})
  5429  }
  5430  
  5431  // testInt16x32ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5432  // This converts only the low 4 elements.
  5433  func testInt16x32ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int64x4, want func(x []int16) []int64) {
  5434  	n := 32
  5435  	t.Helper()
  5436  	forSlice(t, int16s, n, func(x []int16) bool {
  5437  		t.Helper()
  5438  		a := archsimd.LoadInt16x32(x)
  5439  		g := make([]int64, 4)
  5440  		f(a).Store(g)
  5441  		w := want(x)
  5442  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5443  	})
  5444  }
  5445  
  5446  // testInt32x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5447  // This converts only the low 4 elements.
  5448  func testInt32x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int64x4, want func(x []int32) []int64) {
  5449  	n := 16
  5450  	t.Helper()
  5451  	forSlice(t, int32s, n, func(x []int32) bool {
  5452  		t.Helper()
  5453  		a := archsimd.LoadInt32x16(x)
  5454  		g := make([]int64, 4)
  5455  		f(a).Store(g)
  5456  		w := want(x)
  5457  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5458  	})
  5459  }
  5460  
  5461  // testInt64x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5462  // This converts only the low 4 elements.
  5463  func testInt64x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int64x4, want func(x []int64) []int64) {
  5464  	n := 8
  5465  	t.Helper()
  5466  	forSlice(t, int64s, n, func(x []int64) bool {
  5467  		t.Helper()
  5468  		a := archsimd.LoadInt64x8(x)
  5469  		g := make([]int64, 4)
  5470  		f(a).Store(g)
  5471  		w := want(x)
  5472  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5473  	})
  5474  }
  5475  
  5476  // testUint8x64ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5477  // This converts only the low 4 elements.
  5478  func testUint8x64ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int64x4, want func(x []uint8) []int64) {
  5479  	n := 64
  5480  	t.Helper()
  5481  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5482  		t.Helper()
  5483  		a := archsimd.LoadUint8x64(x)
  5484  		g := make([]int64, 4)
  5485  		f(a).Store(g)
  5486  		w := want(x)
  5487  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5488  	})
  5489  }
  5490  
  5491  // testUint16x32ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5492  // This converts only the low 4 elements.
  5493  func testUint16x32ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int64x4, want func(x []uint16) []int64) {
  5494  	n := 32
  5495  	t.Helper()
  5496  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5497  		t.Helper()
  5498  		a := archsimd.LoadUint16x32(x)
  5499  		g := make([]int64, 4)
  5500  		f(a).Store(g)
  5501  		w := want(x)
  5502  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5503  	})
  5504  }
  5505  
  5506  // testUint32x16ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5507  // This converts only the low 4 elements.
  5508  func testUint32x16ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int64x4, want func(x []uint32) []int64) {
  5509  	n := 16
  5510  	t.Helper()
  5511  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5512  		t.Helper()
  5513  		a := archsimd.LoadUint32x16(x)
  5514  		g := make([]int64, 4)
  5515  		f(a).Store(g)
  5516  		w := want(x)
  5517  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5518  	})
  5519  }
  5520  
  5521  // testUint64x8ConvertLoToInt64x4 tests the simd conversion method f against the expected behavior generated by want.
  5522  // This converts only the low 4 elements.
  5523  func testUint64x8ConvertLoToInt64x4(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int64x4, want func(x []uint64) []int64) {
  5524  	n := 8
  5525  	t.Helper()
  5526  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5527  		t.Helper()
  5528  		a := archsimd.LoadUint64x8(x)
  5529  		g := make([]int64, 4)
  5530  		f(a).Store(g)
  5531  		w := want(x)
  5532  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5533  	})
  5534  }
  5535  
  5536  // testInt8x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5537  // This converts only the low 2 elements.
  5538  func testInt8x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint64x2, want func(x []int8) []uint64) {
  5539  	n := 16
  5540  	t.Helper()
  5541  	forSlice(t, int8s, n, func(x []int8) bool {
  5542  		t.Helper()
  5543  		a := archsimd.LoadInt8x16(x)
  5544  		g := make([]uint64, 2)
  5545  		f(a).Store(g)
  5546  		w := want(x)
  5547  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5548  	})
  5549  }
  5550  
  5551  // testInt16x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5552  // This converts only the low 2 elements.
  5553  func testInt16x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint64x2, want func(x []int16) []uint64) {
  5554  	n := 8
  5555  	t.Helper()
  5556  	forSlice(t, int16s, n, func(x []int16) bool {
  5557  		t.Helper()
  5558  		a := archsimd.LoadInt16x8(x)
  5559  		g := make([]uint64, 2)
  5560  		f(a).Store(g)
  5561  		w := want(x)
  5562  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5563  	})
  5564  }
  5565  
  5566  // testInt32x4ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5567  // This converts only the low 2 elements.
  5568  func testInt32x4ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint64x2, want func(x []int32) []uint64) {
  5569  	n := 4
  5570  	t.Helper()
  5571  	forSlice(t, int32s, n, func(x []int32) bool {
  5572  		t.Helper()
  5573  		a := archsimd.LoadInt32x4(x)
  5574  		g := make([]uint64, 2)
  5575  		f(a).Store(g)
  5576  		w := want(x)
  5577  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5578  	})
  5579  }
  5580  
  5581  // testInt64x2ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5582  // This converts only the low 2 elements.
  5583  func testInt64x2ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint64x2, want func(x []int64) []uint64) {
  5584  	n := 2
  5585  	t.Helper()
  5586  	forSlice(t, int64s, n, func(x []int64) bool {
  5587  		t.Helper()
  5588  		a := archsimd.LoadInt64x2(x)
  5589  		g := make([]uint64, 2)
  5590  		f(a).Store(g)
  5591  		w := want(x)
  5592  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5593  	})
  5594  }
  5595  
  5596  // testUint8x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5597  // This converts only the low 2 elements.
  5598  func testUint8x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint64x2, want func(x []uint8) []uint64) {
  5599  	n := 16
  5600  	t.Helper()
  5601  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5602  		t.Helper()
  5603  		a := archsimd.LoadUint8x16(x)
  5604  		g := make([]uint64, 2)
  5605  		f(a).Store(g)
  5606  		w := want(x)
  5607  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5608  	})
  5609  }
  5610  
  5611  // testUint16x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5612  // This converts only the low 2 elements.
  5613  func testUint16x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint64x2, want func(x []uint16) []uint64) {
  5614  	n := 8
  5615  	t.Helper()
  5616  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5617  		t.Helper()
  5618  		a := archsimd.LoadUint16x8(x)
  5619  		g := make([]uint64, 2)
  5620  		f(a).Store(g)
  5621  		w := want(x)
  5622  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5623  	})
  5624  }
  5625  
  5626  // testUint32x4ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5627  // This converts only the low 2 elements.
  5628  func testUint32x4ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint64x2, want func(x []uint32) []uint64) {
  5629  	n := 4
  5630  	t.Helper()
  5631  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5632  		t.Helper()
  5633  		a := archsimd.LoadUint32x4(x)
  5634  		g := make([]uint64, 2)
  5635  		f(a).Store(g)
  5636  		w := want(x)
  5637  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5638  	})
  5639  }
  5640  
  5641  // testUint64x2ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5642  // This converts only the low 2 elements.
  5643  func testUint64x2ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint64x2, want func(x []uint64) []uint64) {
  5644  	n := 2
  5645  	t.Helper()
  5646  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5647  		t.Helper()
  5648  		a := archsimd.LoadUint64x2(x)
  5649  		g := make([]uint64, 2)
  5650  		f(a).Store(g)
  5651  		w := want(x)
  5652  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5653  	})
  5654  }
  5655  
  5656  // testInt8x32ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5657  // This converts only the low 2 elements.
  5658  func testInt8x32ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint64x2, want func(x []int8) []uint64) {
  5659  	n := 32
  5660  	t.Helper()
  5661  	forSlice(t, int8s, n, func(x []int8) bool {
  5662  		t.Helper()
  5663  		a := archsimd.LoadInt8x32(x)
  5664  		g := make([]uint64, 2)
  5665  		f(a).Store(g)
  5666  		w := want(x)
  5667  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5668  	})
  5669  }
  5670  
  5671  // testInt16x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5672  // This converts only the low 2 elements.
  5673  func testInt16x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint64x2, want func(x []int16) []uint64) {
  5674  	n := 16
  5675  	t.Helper()
  5676  	forSlice(t, int16s, n, func(x []int16) bool {
  5677  		t.Helper()
  5678  		a := archsimd.LoadInt16x16(x)
  5679  		g := make([]uint64, 2)
  5680  		f(a).Store(g)
  5681  		w := want(x)
  5682  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5683  	})
  5684  }
  5685  
  5686  // testInt32x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5687  // This converts only the low 2 elements.
  5688  func testInt32x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint64x2, want func(x []int32) []uint64) {
  5689  	n := 8
  5690  	t.Helper()
  5691  	forSlice(t, int32s, n, func(x []int32) bool {
  5692  		t.Helper()
  5693  		a := archsimd.LoadInt32x8(x)
  5694  		g := make([]uint64, 2)
  5695  		f(a).Store(g)
  5696  		w := want(x)
  5697  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5698  	})
  5699  }
  5700  
  5701  // testInt64x4ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5702  // This converts only the low 2 elements.
  5703  func testInt64x4ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint64x2, want func(x []int64) []uint64) {
  5704  	n := 4
  5705  	t.Helper()
  5706  	forSlice(t, int64s, n, func(x []int64) bool {
  5707  		t.Helper()
  5708  		a := archsimd.LoadInt64x4(x)
  5709  		g := make([]uint64, 2)
  5710  		f(a).Store(g)
  5711  		w := want(x)
  5712  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5713  	})
  5714  }
  5715  
  5716  // testUint8x32ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5717  // This converts only the low 2 elements.
  5718  func testUint8x32ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint64x2, want func(x []uint8) []uint64) {
  5719  	n := 32
  5720  	t.Helper()
  5721  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5722  		t.Helper()
  5723  		a := archsimd.LoadUint8x32(x)
  5724  		g := make([]uint64, 2)
  5725  		f(a).Store(g)
  5726  		w := want(x)
  5727  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5728  	})
  5729  }
  5730  
  5731  // testUint16x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5732  // This converts only the low 2 elements.
  5733  func testUint16x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint64x2, want func(x []uint16) []uint64) {
  5734  	n := 16
  5735  	t.Helper()
  5736  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5737  		t.Helper()
  5738  		a := archsimd.LoadUint16x16(x)
  5739  		g := make([]uint64, 2)
  5740  		f(a).Store(g)
  5741  		w := want(x)
  5742  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5743  	})
  5744  }
  5745  
  5746  // testUint32x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5747  // This converts only the low 2 elements.
  5748  func testUint32x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint64x2, want func(x []uint32) []uint64) {
  5749  	n := 8
  5750  	t.Helper()
  5751  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5752  		t.Helper()
  5753  		a := archsimd.LoadUint32x8(x)
  5754  		g := make([]uint64, 2)
  5755  		f(a).Store(g)
  5756  		w := want(x)
  5757  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5758  	})
  5759  }
  5760  
  5761  // testUint64x4ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5762  // This converts only the low 2 elements.
  5763  func testUint64x4ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint64x2, want func(x []uint64) []uint64) {
  5764  	n := 4
  5765  	t.Helper()
  5766  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5767  		t.Helper()
  5768  		a := archsimd.LoadUint64x4(x)
  5769  		g := make([]uint64, 2)
  5770  		f(a).Store(g)
  5771  		w := want(x)
  5772  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5773  	})
  5774  }
  5775  
  5776  // testInt8x64ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5777  // This converts only the low 2 elements.
  5778  func testInt8x64ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint64x2, want func(x []int8) []uint64) {
  5779  	n := 64
  5780  	t.Helper()
  5781  	forSlice(t, int8s, n, func(x []int8) bool {
  5782  		t.Helper()
  5783  		a := archsimd.LoadInt8x64(x)
  5784  		g := make([]uint64, 2)
  5785  		f(a).Store(g)
  5786  		w := want(x)
  5787  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5788  	})
  5789  }
  5790  
  5791  // testInt16x32ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5792  // This converts only the low 2 elements.
  5793  func testInt16x32ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint64x2, want func(x []int16) []uint64) {
  5794  	n := 32
  5795  	t.Helper()
  5796  	forSlice(t, int16s, n, func(x []int16) bool {
  5797  		t.Helper()
  5798  		a := archsimd.LoadInt16x32(x)
  5799  		g := make([]uint64, 2)
  5800  		f(a).Store(g)
  5801  		w := want(x)
  5802  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5803  	})
  5804  }
  5805  
  5806  // testInt32x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5807  // This converts only the low 2 elements.
  5808  func testInt32x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint64x2, want func(x []int32) []uint64) {
  5809  	n := 16
  5810  	t.Helper()
  5811  	forSlice(t, int32s, n, func(x []int32) bool {
  5812  		t.Helper()
  5813  		a := archsimd.LoadInt32x16(x)
  5814  		g := make([]uint64, 2)
  5815  		f(a).Store(g)
  5816  		w := want(x)
  5817  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5818  	})
  5819  }
  5820  
  5821  // testInt64x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5822  // This converts only the low 2 elements.
  5823  func testInt64x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint64x2, want func(x []int64) []uint64) {
  5824  	n := 8
  5825  	t.Helper()
  5826  	forSlice(t, int64s, n, func(x []int64) bool {
  5827  		t.Helper()
  5828  		a := archsimd.LoadInt64x8(x)
  5829  		g := make([]uint64, 2)
  5830  		f(a).Store(g)
  5831  		w := want(x)
  5832  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5833  	})
  5834  }
  5835  
  5836  // testUint8x64ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5837  // This converts only the low 2 elements.
  5838  func testUint8x64ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint64x2, want func(x []uint8) []uint64) {
  5839  	n := 64
  5840  	t.Helper()
  5841  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5842  		t.Helper()
  5843  		a := archsimd.LoadUint8x64(x)
  5844  		g := make([]uint64, 2)
  5845  		f(a).Store(g)
  5846  		w := want(x)
  5847  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5848  	})
  5849  }
  5850  
  5851  // testUint16x32ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5852  // This converts only the low 2 elements.
  5853  func testUint16x32ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint64x2, want func(x []uint16) []uint64) {
  5854  	n := 32
  5855  	t.Helper()
  5856  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5857  		t.Helper()
  5858  		a := archsimd.LoadUint16x32(x)
  5859  		g := make([]uint64, 2)
  5860  		f(a).Store(g)
  5861  		w := want(x)
  5862  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5863  	})
  5864  }
  5865  
  5866  // testUint32x16ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5867  // This converts only the low 2 elements.
  5868  func testUint32x16ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint64x2, want func(x []uint32) []uint64) {
  5869  	n := 16
  5870  	t.Helper()
  5871  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5872  		t.Helper()
  5873  		a := archsimd.LoadUint32x16(x)
  5874  		g := make([]uint64, 2)
  5875  		f(a).Store(g)
  5876  		w := want(x)
  5877  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5878  	})
  5879  }
  5880  
  5881  // testUint64x8ConvertLoToUint64x2 tests the simd conversion method f against the expected behavior generated by want.
  5882  // This converts only the low 2 elements.
  5883  func testUint64x8ConvertLoToUint64x2(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint64x2, want func(x []uint64) []uint64) {
  5884  	n := 8
  5885  	t.Helper()
  5886  	forSlice(t, uint64s, n, func(x []uint64) bool {
  5887  		t.Helper()
  5888  		a := archsimd.LoadUint64x8(x)
  5889  		g := make([]uint64, 2)
  5890  		f(a).Store(g)
  5891  		w := want(x)
  5892  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5893  	})
  5894  }
  5895  
  5896  // testInt8x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5897  // This converts only the low 4 elements.
  5898  func testInt8x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint64x4, want func(x []int8) []uint64) {
  5899  	n := 16
  5900  	t.Helper()
  5901  	forSlice(t, int8s, n, func(x []int8) bool {
  5902  		t.Helper()
  5903  		a := archsimd.LoadInt8x16(x)
  5904  		g := make([]uint64, 4)
  5905  		f(a).Store(g)
  5906  		w := want(x)
  5907  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5908  	})
  5909  }
  5910  
  5911  // testInt16x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5912  // This converts only the low 4 elements.
  5913  func testInt16x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint64x4, want func(x []int16) []uint64) {
  5914  	n := 8
  5915  	t.Helper()
  5916  	forSlice(t, int16s, n, func(x []int16) bool {
  5917  		t.Helper()
  5918  		a := archsimd.LoadInt16x8(x)
  5919  		g := make([]uint64, 4)
  5920  		f(a).Store(g)
  5921  		w := want(x)
  5922  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5923  	})
  5924  }
  5925  
  5926  // testInt32x4ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5927  // This converts only the low 4 elements.
  5928  func testInt32x4ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint64x4, want func(x []int32) []uint64) {
  5929  	n := 4
  5930  	t.Helper()
  5931  	forSlice(t, int32s, n, func(x []int32) bool {
  5932  		t.Helper()
  5933  		a := archsimd.LoadInt32x4(x)
  5934  		g := make([]uint64, 4)
  5935  		f(a).Store(g)
  5936  		w := want(x)
  5937  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5938  	})
  5939  }
  5940  
  5941  // testInt64x2ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5942  // This converts only the low 4 elements.
  5943  func testInt64x2ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint64x4, want func(x []int64) []uint64) {
  5944  	n := 2
  5945  	t.Helper()
  5946  	forSlice(t, int64s, n, func(x []int64) bool {
  5947  		t.Helper()
  5948  		a := archsimd.LoadInt64x2(x)
  5949  		g := make([]uint64, 4)
  5950  		f(a).Store(g)
  5951  		w := want(x)
  5952  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5953  	})
  5954  }
  5955  
  5956  // testUint8x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5957  // This converts only the low 4 elements.
  5958  func testUint8x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint64x4, want func(x []uint8) []uint64) {
  5959  	n := 16
  5960  	t.Helper()
  5961  	forSlice(t, uint8s, n, func(x []uint8) bool {
  5962  		t.Helper()
  5963  		a := archsimd.LoadUint8x16(x)
  5964  		g := make([]uint64, 4)
  5965  		f(a).Store(g)
  5966  		w := want(x)
  5967  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5968  	})
  5969  }
  5970  
  5971  // testUint16x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5972  // This converts only the low 4 elements.
  5973  func testUint16x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint64x4, want func(x []uint16) []uint64) {
  5974  	n := 8
  5975  	t.Helper()
  5976  	forSlice(t, uint16s, n, func(x []uint16) bool {
  5977  		t.Helper()
  5978  		a := archsimd.LoadUint16x8(x)
  5979  		g := make([]uint64, 4)
  5980  		f(a).Store(g)
  5981  		w := want(x)
  5982  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5983  	})
  5984  }
  5985  
  5986  // testUint32x4ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  5987  // This converts only the low 4 elements.
  5988  func testUint32x4ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint64x4, want func(x []uint32) []uint64) {
  5989  	n := 4
  5990  	t.Helper()
  5991  	forSlice(t, uint32s, n, func(x []uint32) bool {
  5992  		t.Helper()
  5993  		a := archsimd.LoadUint32x4(x)
  5994  		g := make([]uint64, 4)
  5995  		f(a).Store(g)
  5996  		w := want(x)
  5997  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  5998  	})
  5999  }
  6000  
  6001  // testUint64x2ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6002  // This converts only the low 4 elements.
  6003  func testUint64x2ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint64x4, want func(x []uint64) []uint64) {
  6004  	n := 2
  6005  	t.Helper()
  6006  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6007  		t.Helper()
  6008  		a := archsimd.LoadUint64x2(x)
  6009  		g := make([]uint64, 4)
  6010  		f(a).Store(g)
  6011  		w := want(x)
  6012  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6013  	})
  6014  }
  6015  
  6016  // testInt8x32ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6017  // This converts only the low 4 elements.
  6018  func testInt8x32ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint64x4, want func(x []int8) []uint64) {
  6019  	n := 32
  6020  	t.Helper()
  6021  	forSlice(t, int8s, n, func(x []int8) bool {
  6022  		t.Helper()
  6023  		a := archsimd.LoadInt8x32(x)
  6024  		g := make([]uint64, 4)
  6025  		f(a).Store(g)
  6026  		w := want(x)
  6027  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6028  	})
  6029  }
  6030  
  6031  // testInt16x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6032  // This converts only the low 4 elements.
  6033  func testInt16x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint64x4, want func(x []int16) []uint64) {
  6034  	n := 16
  6035  	t.Helper()
  6036  	forSlice(t, int16s, n, func(x []int16) bool {
  6037  		t.Helper()
  6038  		a := archsimd.LoadInt16x16(x)
  6039  		g := make([]uint64, 4)
  6040  		f(a).Store(g)
  6041  		w := want(x)
  6042  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6043  	})
  6044  }
  6045  
  6046  // testInt32x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6047  // This converts only the low 4 elements.
  6048  func testInt32x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint64x4, want func(x []int32) []uint64) {
  6049  	n := 8
  6050  	t.Helper()
  6051  	forSlice(t, int32s, n, func(x []int32) bool {
  6052  		t.Helper()
  6053  		a := archsimd.LoadInt32x8(x)
  6054  		g := make([]uint64, 4)
  6055  		f(a).Store(g)
  6056  		w := want(x)
  6057  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6058  	})
  6059  }
  6060  
  6061  // testInt64x4ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6062  // This converts only the low 4 elements.
  6063  func testInt64x4ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint64x4, want func(x []int64) []uint64) {
  6064  	n := 4
  6065  	t.Helper()
  6066  	forSlice(t, int64s, n, func(x []int64) bool {
  6067  		t.Helper()
  6068  		a := archsimd.LoadInt64x4(x)
  6069  		g := make([]uint64, 4)
  6070  		f(a).Store(g)
  6071  		w := want(x)
  6072  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6073  	})
  6074  }
  6075  
  6076  // testUint8x32ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6077  // This converts only the low 4 elements.
  6078  func testUint8x32ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint64x4, want func(x []uint8) []uint64) {
  6079  	n := 32
  6080  	t.Helper()
  6081  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6082  		t.Helper()
  6083  		a := archsimd.LoadUint8x32(x)
  6084  		g := make([]uint64, 4)
  6085  		f(a).Store(g)
  6086  		w := want(x)
  6087  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6088  	})
  6089  }
  6090  
  6091  // testUint16x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6092  // This converts only the low 4 elements.
  6093  func testUint16x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint64x4, want func(x []uint16) []uint64) {
  6094  	n := 16
  6095  	t.Helper()
  6096  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6097  		t.Helper()
  6098  		a := archsimd.LoadUint16x16(x)
  6099  		g := make([]uint64, 4)
  6100  		f(a).Store(g)
  6101  		w := want(x)
  6102  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6103  	})
  6104  }
  6105  
  6106  // testUint32x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6107  // This converts only the low 4 elements.
  6108  func testUint32x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint64x4, want func(x []uint32) []uint64) {
  6109  	n := 8
  6110  	t.Helper()
  6111  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6112  		t.Helper()
  6113  		a := archsimd.LoadUint32x8(x)
  6114  		g := make([]uint64, 4)
  6115  		f(a).Store(g)
  6116  		w := want(x)
  6117  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6118  	})
  6119  }
  6120  
  6121  // testUint64x4ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6122  // This converts only the low 4 elements.
  6123  func testUint64x4ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint64x4, want func(x []uint64) []uint64) {
  6124  	n := 4
  6125  	t.Helper()
  6126  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6127  		t.Helper()
  6128  		a := archsimd.LoadUint64x4(x)
  6129  		g := make([]uint64, 4)
  6130  		f(a).Store(g)
  6131  		w := want(x)
  6132  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6133  	})
  6134  }
  6135  
  6136  // testInt8x64ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6137  // This converts only the low 4 elements.
  6138  func testInt8x64ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint64x4, want func(x []int8) []uint64) {
  6139  	n := 64
  6140  	t.Helper()
  6141  	forSlice(t, int8s, n, func(x []int8) bool {
  6142  		t.Helper()
  6143  		a := archsimd.LoadInt8x64(x)
  6144  		g := make([]uint64, 4)
  6145  		f(a).Store(g)
  6146  		w := want(x)
  6147  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6148  	})
  6149  }
  6150  
  6151  // testInt16x32ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6152  // This converts only the low 4 elements.
  6153  func testInt16x32ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint64x4, want func(x []int16) []uint64) {
  6154  	n := 32
  6155  	t.Helper()
  6156  	forSlice(t, int16s, n, func(x []int16) bool {
  6157  		t.Helper()
  6158  		a := archsimd.LoadInt16x32(x)
  6159  		g := make([]uint64, 4)
  6160  		f(a).Store(g)
  6161  		w := want(x)
  6162  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6163  	})
  6164  }
  6165  
  6166  // testInt32x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6167  // This converts only the low 4 elements.
  6168  func testInt32x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint64x4, want func(x []int32) []uint64) {
  6169  	n := 16
  6170  	t.Helper()
  6171  	forSlice(t, int32s, n, func(x []int32) bool {
  6172  		t.Helper()
  6173  		a := archsimd.LoadInt32x16(x)
  6174  		g := make([]uint64, 4)
  6175  		f(a).Store(g)
  6176  		w := want(x)
  6177  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6178  	})
  6179  }
  6180  
  6181  // testInt64x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6182  // This converts only the low 4 elements.
  6183  func testInt64x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint64x4, want func(x []int64) []uint64) {
  6184  	n := 8
  6185  	t.Helper()
  6186  	forSlice(t, int64s, n, func(x []int64) bool {
  6187  		t.Helper()
  6188  		a := archsimd.LoadInt64x8(x)
  6189  		g := make([]uint64, 4)
  6190  		f(a).Store(g)
  6191  		w := want(x)
  6192  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6193  	})
  6194  }
  6195  
  6196  // testUint8x64ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6197  // This converts only the low 4 elements.
  6198  func testUint8x64ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint64x4, want func(x []uint8) []uint64) {
  6199  	n := 64
  6200  	t.Helper()
  6201  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6202  		t.Helper()
  6203  		a := archsimd.LoadUint8x64(x)
  6204  		g := make([]uint64, 4)
  6205  		f(a).Store(g)
  6206  		w := want(x)
  6207  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6208  	})
  6209  }
  6210  
  6211  // testUint16x32ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6212  // This converts only the low 4 elements.
  6213  func testUint16x32ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint64x4, want func(x []uint16) []uint64) {
  6214  	n := 32
  6215  	t.Helper()
  6216  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6217  		t.Helper()
  6218  		a := archsimd.LoadUint16x32(x)
  6219  		g := make([]uint64, 4)
  6220  		f(a).Store(g)
  6221  		w := want(x)
  6222  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6223  	})
  6224  }
  6225  
  6226  // testUint32x16ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6227  // This converts only the low 4 elements.
  6228  func testUint32x16ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint64x4, want func(x []uint32) []uint64) {
  6229  	n := 16
  6230  	t.Helper()
  6231  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6232  		t.Helper()
  6233  		a := archsimd.LoadUint32x16(x)
  6234  		g := make([]uint64, 4)
  6235  		f(a).Store(g)
  6236  		w := want(x)
  6237  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6238  	})
  6239  }
  6240  
  6241  // testUint64x8ConvertLoToUint64x4 tests the simd conversion method f against the expected behavior generated by want.
  6242  // This converts only the low 4 elements.
  6243  func testUint64x8ConvertLoToUint64x4(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint64x4, want func(x []uint64) []uint64) {
  6244  	n := 8
  6245  	t.Helper()
  6246  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6247  		t.Helper()
  6248  		a := archsimd.LoadUint64x8(x)
  6249  		g := make([]uint64, 4)
  6250  		f(a).Store(g)
  6251  		w := want(x)
  6252  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6253  	})
  6254  }
  6255  
  6256  // testInt8x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6257  // This converts only the low 4 elements.
  6258  func testInt8x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int32x4, want func(x []int8) []int32) {
  6259  	n := 16
  6260  	t.Helper()
  6261  	forSlice(t, int8s, n, func(x []int8) bool {
  6262  		t.Helper()
  6263  		a := archsimd.LoadInt8x16(x)
  6264  		g := make([]int32, 4)
  6265  		f(a).Store(g)
  6266  		w := want(x)
  6267  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6268  	})
  6269  }
  6270  
  6271  // testInt16x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6272  // This converts only the low 4 elements.
  6273  func testInt16x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int32x4, want func(x []int16) []int32) {
  6274  	n := 8
  6275  	t.Helper()
  6276  	forSlice(t, int16s, n, func(x []int16) bool {
  6277  		t.Helper()
  6278  		a := archsimd.LoadInt16x8(x)
  6279  		g := make([]int32, 4)
  6280  		f(a).Store(g)
  6281  		w := want(x)
  6282  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6283  	})
  6284  }
  6285  
  6286  // testInt32x4ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6287  // This converts only the low 4 elements.
  6288  func testInt32x4ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int32x4, want func(x []int32) []int32) {
  6289  	n := 4
  6290  	t.Helper()
  6291  	forSlice(t, int32s, n, func(x []int32) bool {
  6292  		t.Helper()
  6293  		a := archsimd.LoadInt32x4(x)
  6294  		g := make([]int32, 4)
  6295  		f(a).Store(g)
  6296  		w := want(x)
  6297  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6298  	})
  6299  }
  6300  
  6301  // testInt64x2ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6302  // This converts only the low 4 elements.
  6303  func testInt64x2ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int32x4, want func(x []int64) []int32) {
  6304  	n := 2
  6305  	t.Helper()
  6306  	forSlice(t, int64s, n, func(x []int64) bool {
  6307  		t.Helper()
  6308  		a := archsimd.LoadInt64x2(x)
  6309  		g := make([]int32, 4)
  6310  		f(a).Store(g)
  6311  		w := want(x)
  6312  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6313  	})
  6314  }
  6315  
  6316  // testUint8x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6317  // This converts only the low 4 elements.
  6318  func testUint8x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int32x4, want func(x []uint8) []int32) {
  6319  	n := 16
  6320  	t.Helper()
  6321  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6322  		t.Helper()
  6323  		a := archsimd.LoadUint8x16(x)
  6324  		g := make([]int32, 4)
  6325  		f(a).Store(g)
  6326  		w := want(x)
  6327  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6328  	})
  6329  }
  6330  
  6331  // testUint16x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6332  // This converts only the low 4 elements.
  6333  func testUint16x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int32x4, want func(x []uint16) []int32) {
  6334  	n := 8
  6335  	t.Helper()
  6336  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6337  		t.Helper()
  6338  		a := archsimd.LoadUint16x8(x)
  6339  		g := make([]int32, 4)
  6340  		f(a).Store(g)
  6341  		w := want(x)
  6342  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6343  	})
  6344  }
  6345  
  6346  // testUint32x4ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6347  // This converts only the low 4 elements.
  6348  func testUint32x4ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int32x4, want func(x []uint32) []int32) {
  6349  	n := 4
  6350  	t.Helper()
  6351  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6352  		t.Helper()
  6353  		a := archsimd.LoadUint32x4(x)
  6354  		g := make([]int32, 4)
  6355  		f(a).Store(g)
  6356  		w := want(x)
  6357  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6358  	})
  6359  }
  6360  
  6361  // testUint64x2ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6362  // This converts only the low 4 elements.
  6363  func testUint64x2ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int32x4, want func(x []uint64) []int32) {
  6364  	n := 2
  6365  	t.Helper()
  6366  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6367  		t.Helper()
  6368  		a := archsimd.LoadUint64x2(x)
  6369  		g := make([]int32, 4)
  6370  		f(a).Store(g)
  6371  		w := want(x)
  6372  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6373  	})
  6374  }
  6375  
  6376  // testInt8x32ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6377  // This converts only the low 4 elements.
  6378  func testInt8x32ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int32x4, want func(x []int8) []int32) {
  6379  	n := 32
  6380  	t.Helper()
  6381  	forSlice(t, int8s, n, func(x []int8) bool {
  6382  		t.Helper()
  6383  		a := archsimd.LoadInt8x32(x)
  6384  		g := make([]int32, 4)
  6385  		f(a).Store(g)
  6386  		w := want(x)
  6387  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6388  	})
  6389  }
  6390  
  6391  // testInt16x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6392  // This converts only the low 4 elements.
  6393  func testInt16x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int32x4, want func(x []int16) []int32) {
  6394  	n := 16
  6395  	t.Helper()
  6396  	forSlice(t, int16s, n, func(x []int16) bool {
  6397  		t.Helper()
  6398  		a := archsimd.LoadInt16x16(x)
  6399  		g := make([]int32, 4)
  6400  		f(a).Store(g)
  6401  		w := want(x)
  6402  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6403  	})
  6404  }
  6405  
  6406  // testInt32x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6407  // This converts only the low 4 elements.
  6408  func testInt32x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int32x4, want func(x []int32) []int32) {
  6409  	n := 8
  6410  	t.Helper()
  6411  	forSlice(t, int32s, n, func(x []int32) bool {
  6412  		t.Helper()
  6413  		a := archsimd.LoadInt32x8(x)
  6414  		g := make([]int32, 4)
  6415  		f(a).Store(g)
  6416  		w := want(x)
  6417  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6418  	})
  6419  }
  6420  
  6421  // testInt64x4ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6422  // This converts only the low 4 elements.
  6423  func testInt64x4ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int32x4, want func(x []int64) []int32) {
  6424  	n := 4
  6425  	t.Helper()
  6426  	forSlice(t, int64s, n, func(x []int64) bool {
  6427  		t.Helper()
  6428  		a := archsimd.LoadInt64x4(x)
  6429  		g := make([]int32, 4)
  6430  		f(a).Store(g)
  6431  		w := want(x)
  6432  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6433  	})
  6434  }
  6435  
  6436  // testUint8x32ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6437  // This converts only the low 4 elements.
  6438  func testUint8x32ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int32x4, want func(x []uint8) []int32) {
  6439  	n := 32
  6440  	t.Helper()
  6441  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6442  		t.Helper()
  6443  		a := archsimd.LoadUint8x32(x)
  6444  		g := make([]int32, 4)
  6445  		f(a).Store(g)
  6446  		w := want(x)
  6447  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6448  	})
  6449  }
  6450  
  6451  // testUint16x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6452  // This converts only the low 4 elements.
  6453  func testUint16x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int32x4, want func(x []uint16) []int32) {
  6454  	n := 16
  6455  	t.Helper()
  6456  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6457  		t.Helper()
  6458  		a := archsimd.LoadUint16x16(x)
  6459  		g := make([]int32, 4)
  6460  		f(a).Store(g)
  6461  		w := want(x)
  6462  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6463  	})
  6464  }
  6465  
  6466  // testUint32x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6467  // This converts only the low 4 elements.
  6468  func testUint32x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int32x4, want func(x []uint32) []int32) {
  6469  	n := 8
  6470  	t.Helper()
  6471  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6472  		t.Helper()
  6473  		a := archsimd.LoadUint32x8(x)
  6474  		g := make([]int32, 4)
  6475  		f(a).Store(g)
  6476  		w := want(x)
  6477  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6478  	})
  6479  }
  6480  
  6481  // testUint64x4ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6482  // This converts only the low 4 elements.
  6483  func testUint64x4ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int32x4, want func(x []uint64) []int32) {
  6484  	n := 4
  6485  	t.Helper()
  6486  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6487  		t.Helper()
  6488  		a := archsimd.LoadUint64x4(x)
  6489  		g := make([]int32, 4)
  6490  		f(a).Store(g)
  6491  		w := want(x)
  6492  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6493  	})
  6494  }
  6495  
  6496  // testInt8x64ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6497  // This converts only the low 4 elements.
  6498  func testInt8x64ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int32x4, want func(x []int8) []int32) {
  6499  	n := 64
  6500  	t.Helper()
  6501  	forSlice(t, int8s, n, func(x []int8) bool {
  6502  		t.Helper()
  6503  		a := archsimd.LoadInt8x64(x)
  6504  		g := make([]int32, 4)
  6505  		f(a).Store(g)
  6506  		w := want(x)
  6507  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6508  	})
  6509  }
  6510  
  6511  // testInt16x32ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6512  // This converts only the low 4 elements.
  6513  func testInt16x32ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int32x4, want func(x []int16) []int32) {
  6514  	n := 32
  6515  	t.Helper()
  6516  	forSlice(t, int16s, n, func(x []int16) bool {
  6517  		t.Helper()
  6518  		a := archsimd.LoadInt16x32(x)
  6519  		g := make([]int32, 4)
  6520  		f(a).Store(g)
  6521  		w := want(x)
  6522  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6523  	})
  6524  }
  6525  
  6526  // testInt32x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6527  // This converts only the low 4 elements.
  6528  func testInt32x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int32x4, want func(x []int32) []int32) {
  6529  	n := 16
  6530  	t.Helper()
  6531  	forSlice(t, int32s, n, func(x []int32) bool {
  6532  		t.Helper()
  6533  		a := archsimd.LoadInt32x16(x)
  6534  		g := make([]int32, 4)
  6535  		f(a).Store(g)
  6536  		w := want(x)
  6537  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6538  	})
  6539  }
  6540  
  6541  // testInt64x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6542  // This converts only the low 4 elements.
  6543  func testInt64x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int32x4, want func(x []int64) []int32) {
  6544  	n := 8
  6545  	t.Helper()
  6546  	forSlice(t, int64s, n, func(x []int64) bool {
  6547  		t.Helper()
  6548  		a := archsimd.LoadInt64x8(x)
  6549  		g := make([]int32, 4)
  6550  		f(a).Store(g)
  6551  		w := want(x)
  6552  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6553  	})
  6554  }
  6555  
  6556  // testUint8x64ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6557  // This converts only the low 4 elements.
  6558  func testUint8x64ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int32x4, want func(x []uint8) []int32) {
  6559  	n := 64
  6560  	t.Helper()
  6561  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6562  		t.Helper()
  6563  		a := archsimd.LoadUint8x64(x)
  6564  		g := make([]int32, 4)
  6565  		f(a).Store(g)
  6566  		w := want(x)
  6567  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6568  	})
  6569  }
  6570  
  6571  // testUint16x32ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6572  // This converts only the low 4 elements.
  6573  func testUint16x32ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int32x4, want func(x []uint16) []int32) {
  6574  	n := 32
  6575  	t.Helper()
  6576  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6577  		t.Helper()
  6578  		a := archsimd.LoadUint16x32(x)
  6579  		g := make([]int32, 4)
  6580  		f(a).Store(g)
  6581  		w := want(x)
  6582  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6583  	})
  6584  }
  6585  
  6586  // testUint32x16ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6587  // This converts only the low 4 elements.
  6588  func testUint32x16ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int32x4, want func(x []uint32) []int32) {
  6589  	n := 16
  6590  	t.Helper()
  6591  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6592  		t.Helper()
  6593  		a := archsimd.LoadUint32x16(x)
  6594  		g := make([]int32, 4)
  6595  		f(a).Store(g)
  6596  		w := want(x)
  6597  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6598  	})
  6599  }
  6600  
  6601  // testUint64x8ConvertLoToInt32x4 tests the simd conversion method f against the expected behavior generated by want.
  6602  // This converts only the low 4 elements.
  6603  func testUint64x8ConvertLoToInt32x4(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int32x4, want func(x []uint64) []int32) {
  6604  	n := 8
  6605  	t.Helper()
  6606  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6607  		t.Helper()
  6608  		a := archsimd.LoadUint64x8(x)
  6609  		g := make([]int32, 4)
  6610  		f(a).Store(g)
  6611  		w := want(x)
  6612  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6613  	})
  6614  }
  6615  
  6616  // testInt8x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6617  // This converts only the low 8 elements.
  6618  func testInt8x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int32x8, want func(x []int8) []int32) {
  6619  	n := 16
  6620  	t.Helper()
  6621  	forSlice(t, int8s, n, func(x []int8) bool {
  6622  		t.Helper()
  6623  		a := archsimd.LoadInt8x16(x)
  6624  		g := make([]int32, 8)
  6625  		f(a).Store(g)
  6626  		w := want(x)
  6627  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6628  	})
  6629  }
  6630  
  6631  // testInt16x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6632  // This converts only the low 8 elements.
  6633  func testInt16x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int32x8, want func(x []int16) []int32) {
  6634  	n := 8
  6635  	t.Helper()
  6636  	forSlice(t, int16s, n, func(x []int16) bool {
  6637  		t.Helper()
  6638  		a := archsimd.LoadInt16x8(x)
  6639  		g := make([]int32, 8)
  6640  		f(a).Store(g)
  6641  		w := want(x)
  6642  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6643  	})
  6644  }
  6645  
  6646  // testInt32x4ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6647  // This converts only the low 8 elements.
  6648  func testInt32x4ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int32x8, want func(x []int32) []int32) {
  6649  	n := 4
  6650  	t.Helper()
  6651  	forSlice(t, int32s, n, func(x []int32) bool {
  6652  		t.Helper()
  6653  		a := archsimd.LoadInt32x4(x)
  6654  		g := make([]int32, 8)
  6655  		f(a).Store(g)
  6656  		w := want(x)
  6657  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6658  	})
  6659  }
  6660  
  6661  // testInt64x2ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6662  // This converts only the low 8 elements.
  6663  func testInt64x2ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int32x8, want func(x []int64) []int32) {
  6664  	n := 2
  6665  	t.Helper()
  6666  	forSlice(t, int64s, n, func(x []int64) bool {
  6667  		t.Helper()
  6668  		a := archsimd.LoadInt64x2(x)
  6669  		g := make([]int32, 8)
  6670  		f(a).Store(g)
  6671  		w := want(x)
  6672  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6673  	})
  6674  }
  6675  
  6676  // testUint8x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6677  // This converts only the low 8 elements.
  6678  func testUint8x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int32x8, want func(x []uint8) []int32) {
  6679  	n := 16
  6680  	t.Helper()
  6681  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6682  		t.Helper()
  6683  		a := archsimd.LoadUint8x16(x)
  6684  		g := make([]int32, 8)
  6685  		f(a).Store(g)
  6686  		w := want(x)
  6687  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6688  	})
  6689  }
  6690  
  6691  // testUint16x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6692  // This converts only the low 8 elements.
  6693  func testUint16x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int32x8, want func(x []uint16) []int32) {
  6694  	n := 8
  6695  	t.Helper()
  6696  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6697  		t.Helper()
  6698  		a := archsimd.LoadUint16x8(x)
  6699  		g := make([]int32, 8)
  6700  		f(a).Store(g)
  6701  		w := want(x)
  6702  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6703  	})
  6704  }
  6705  
  6706  // testUint32x4ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6707  // This converts only the low 8 elements.
  6708  func testUint32x4ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int32x8, want func(x []uint32) []int32) {
  6709  	n := 4
  6710  	t.Helper()
  6711  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6712  		t.Helper()
  6713  		a := archsimd.LoadUint32x4(x)
  6714  		g := make([]int32, 8)
  6715  		f(a).Store(g)
  6716  		w := want(x)
  6717  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6718  	})
  6719  }
  6720  
  6721  // testUint64x2ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6722  // This converts only the low 8 elements.
  6723  func testUint64x2ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int32x8, want func(x []uint64) []int32) {
  6724  	n := 2
  6725  	t.Helper()
  6726  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6727  		t.Helper()
  6728  		a := archsimd.LoadUint64x2(x)
  6729  		g := make([]int32, 8)
  6730  		f(a).Store(g)
  6731  		w := want(x)
  6732  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6733  	})
  6734  }
  6735  
  6736  // testInt8x32ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6737  // This converts only the low 8 elements.
  6738  func testInt8x32ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int32x8, want func(x []int8) []int32) {
  6739  	n := 32
  6740  	t.Helper()
  6741  	forSlice(t, int8s, n, func(x []int8) bool {
  6742  		t.Helper()
  6743  		a := archsimd.LoadInt8x32(x)
  6744  		g := make([]int32, 8)
  6745  		f(a).Store(g)
  6746  		w := want(x)
  6747  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6748  	})
  6749  }
  6750  
  6751  // testInt16x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6752  // This converts only the low 8 elements.
  6753  func testInt16x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int32x8, want func(x []int16) []int32) {
  6754  	n := 16
  6755  	t.Helper()
  6756  	forSlice(t, int16s, n, func(x []int16) bool {
  6757  		t.Helper()
  6758  		a := archsimd.LoadInt16x16(x)
  6759  		g := make([]int32, 8)
  6760  		f(a).Store(g)
  6761  		w := want(x)
  6762  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6763  	})
  6764  }
  6765  
  6766  // testInt32x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6767  // This converts only the low 8 elements.
  6768  func testInt32x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int32x8, want func(x []int32) []int32) {
  6769  	n := 8
  6770  	t.Helper()
  6771  	forSlice(t, int32s, n, func(x []int32) bool {
  6772  		t.Helper()
  6773  		a := archsimd.LoadInt32x8(x)
  6774  		g := make([]int32, 8)
  6775  		f(a).Store(g)
  6776  		w := want(x)
  6777  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6778  	})
  6779  }
  6780  
  6781  // testInt64x4ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6782  // This converts only the low 8 elements.
  6783  func testInt64x4ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int32x8, want func(x []int64) []int32) {
  6784  	n := 4
  6785  	t.Helper()
  6786  	forSlice(t, int64s, n, func(x []int64) bool {
  6787  		t.Helper()
  6788  		a := archsimd.LoadInt64x4(x)
  6789  		g := make([]int32, 8)
  6790  		f(a).Store(g)
  6791  		w := want(x)
  6792  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6793  	})
  6794  }
  6795  
  6796  // testUint8x32ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6797  // This converts only the low 8 elements.
  6798  func testUint8x32ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int32x8, want func(x []uint8) []int32) {
  6799  	n := 32
  6800  	t.Helper()
  6801  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6802  		t.Helper()
  6803  		a := archsimd.LoadUint8x32(x)
  6804  		g := make([]int32, 8)
  6805  		f(a).Store(g)
  6806  		w := want(x)
  6807  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6808  	})
  6809  }
  6810  
  6811  // testUint16x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6812  // This converts only the low 8 elements.
  6813  func testUint16x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int32x8, want func(x []uint16) []int32) {
  6814  	n := 16
  6815  	t.Helper()
  6816  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6817  		t.Helper()
  6818  		a := archsimd.LoadUint16x16(x)
  6819  		g := make([]int32, 8)
  6820  		f(a).Store(g)
  6821  		w := want(x)
  6822  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6823  	})
  6824  }
  6825  
  6826  // testUint32x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6827  // This converts only the low 8 elements.
  6828  func testUint32x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int32x8, want func(x []uint32) []int32) {
  6829  	n := 8
  6830  	t.Helper()
  6831  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6832  		t.Helper()
  6833  		a := archsimd.LoadUint32x8(x)
  6834  		g := make([]int32, 8)
  6835  		f(a).Store(g)
  6836  		w := want(x)
  6837  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6838  	})
  6839  }
  6840  
  6841  // testUint64x4ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6842  // This converts only the low 8 elements.
  6843  func testUint64x4ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int32x8, want func(x []uint64) []int32) {
  6844  	n := 4
  6845  	t.Helper()
  6846  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6847  		t.Helper()
  6848  		a := archsimd.LoadUint64x4(x)
  6849  		g := make([]int32, 8)
  6850  		f(a).Store(g)
  6851  		w := want(x)
  6852  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6853  	})
  6854  }
  6855  
  6856  // testInt8x64ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6857  // This converts only the low 8 elements.
  6858  func testInt8x64ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int32x8, want func(x []int8) []int32) {
  6859  	n := 64
  6860  	t.Helper()
  6861  	forSlice(t, int8s, n, func(x []int8) bool {
  6862  		t.Helper()
  6863  		a := archsimd.LoadInt8x64(x)
  6864  		g := make([]int32, 8)
  6865  		f(a).Store(g)
  6866  		w := want(x)
  6867  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6868  	})
  6869  }
  6870  
  6871  // testInt16x32ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6872  // This converts only the low 8 elements.
  6873  func testInt16x32ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int32x8, want func(x []int16) []int32) {
  6874  	n := 32
  6875  	t.Helper()
  6876  	forSlice(t, int16s, n, func(x []int16) bool {
  6877  		t.Helper()
  6878  		a := archsimd.LoadInt16x32(x)
  6879  		g := make([]int32, 8)
  6880  		f(a).Store(g)
  6881  		w := want(x)
  6882  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6883  	})
  6884  }
  6885  
  6886  // testInt32x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6887  // This converts only the low 8 elements.
  6888  func testInt32x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int32x8, want func(x []int32) []int32) {
  6889  	n := 16
  6890  	t.Helper()
  6891  	forSlice(t, int32s, n, func(x []int32) bool {
  6892  		t.Helper()
  6893  		a := archsimd.LoadInt32x16(x)
  6894  		g := make([]int32, 8)
  6895  		f(a).Store(g)
  6896  		w := want(x)
  6897  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6898  	})
  6899  }
  6900  
  6901  // testInt64x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6902  // This converts only the low 8 elements.
  6903  func testInt64x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int32x8, want func(x []int64) []int32) {
  6904  	n := 8
  6905  	t.Helper()
  6906  	forSlice(t, int64s, n, func(x []int64) bool {
  6907  		t.Helper()
  6908  		a := archsimd.LoadInt64x8(x)
  6909  		g := make([]int32, 8)
  6910  		f(a).Store(g)
  6911  		w := want(x)
  6912  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6913  	})
  6914  }
  6915  
  6916  // testUint8x64ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6917  // This converts only the low 8 elements.
  6918  func testUint8x64ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int32x8, want func(x []uint8) []int32) {
  6919  	n := 64
  6920  	t.Helper()
  6921  	forSlice(t, uint8s, n, func(x []uint8) bool {
  6922  		t.Helper()
  6923  		a := archsimd.LoadUint8x64(x)
  6924  		g := make([]int32, 8)
  6925  		f(a).Store(g)
  6926  		w := want(x)
  6927  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6928  	})
  6929  }
  6930  
  6931  // testUint16x32ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6932  // This converts only the low 8 elements.
  6933  func testUint16x32ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int32x8, want func(x []uint16) []int32) {
  6934  	n := 32
  6935  	t.Helper()
  6936  	forSlice(t, uint16s, n, func(x []uint16) bool {
  6937  		t.Helper()
  6938  		a := archsimd.LoadUint16x32(x)
  6939  		g := make([]int32, 8)
  6940  		f(a).Store(g)
  6941  		w := want(x)
  6942  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6943  	})
  6944  }
  6945  
  6946  // testUint32x16ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6947  // This converts only the low 8 elements.
  6948  func testUint32x16ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int32x8, want func(x []uint32) []int32) {
  6949  	n := 16
  6950  	t.Helper()
  6951  	forSlice(t, uint32s, n, func(x []uint32) bool {
  6952  		t.Helper()
  6953  		a := archsimd.LoadUint32x16(x)
  6954  		g := make([]int32, 8)
  6955  		f(a).Store(g)
  6956  		w := want(x)
  6957  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6958  	})
  6959  }
  6960  
  6961  // testUint64x8ConvertLoToInt32x8 tests the simd conversion method f against the expected behavior generated by want.
  6962  // This converts only the low 8 elements.
  6963  func testUint64x8ConvertLoToInt32x8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int32x8, want func(x []uint64) []int32) {
  6964  	n := 8
  6965  	t.Helper()
  6966  	forSlice(t, uint64s, n, func(x []uint64) bool {
  6967  		t.Helper()
  6968  		a := archsimd.LoadUint64x8(x)
  6969  		g := make([]int32, 8)
  6970  		f(a).Store(g)
  6971  		w := want(x)
  6972  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6973  	})
  6974  }
  6975  
  6976  // testInt8x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  6977  // This converts only the low 4 elements.
  6978  func testInt8x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint32x4, want func(x []int8) []uint32) {
  6979  	n := 16
  6980  	t.Helper()
  6981  	forSlice(t, int8s, n, func(x []int8) bool {
  6982  		t.Helper()
  6983  		a := archsimd.LoadInt8x16(x)
  6984  		g := make([]uint32, 4)
  6985  		f(a).Store(g)
  6986  		w := want(x)
  6987  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  6988  	})
  6989  }
  6990  
  6991  // testInt16x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  6992  // This converts only the low 4 elements.
  6993  func testInt16x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint32x4, want func(x []int16) []uint32) {
  6994  	n := 8
  6995  	t.Helper()
  6996  	forSlice(t, int16s, n, func(x []int16) bool {
  6997  		t.Helper()
  6998  		a := archsimd.LoadInt16x8(x)
  6999  		g := make([]uint32, 4)
  7000  		f(a).Store(g)
  7001  		w := want(x)
  7002  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7003  	})
  7004  }
  7005  
  7006  // testInt32x4ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7007  // This converts only the low 4 elements.
  7008  func testInt32x4ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint32x4, want func(x []int32) []uint32) {
  7009  	n := 4
  7010  	t.Helper()
  7011  	forSlice(t, int32s, n, func(x []int32) bool {
  7012  		t.Helper()
  7013  		a := archsimd.LoadInt32x4(x)
  7014  		g := make([]uint32, 4)
  7015  		f(a).Store(g)
  7016  		w := want(x)
  7017  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7018  	})
  7019  }
  7020  
  7021  // testInt64x2ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7022  // This converts only the low 4 elements.
  7023  func testInt64x2ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint32x4, want func(x []int64) []uint32) {
  7024  	n := 2
  7025  	t.Helper()
  7026  	forSlice(t, int64s, n, func(x []int64) bool {
  7027  		t.Helper()
  7028  		a := archsimd.LoadInt64x2(x)
  7029  		g := make([]uint32, 4)
  7030  		f(a).Store(g)
  7031  		w := want(x)
  7032  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7033  	})
  7034  }
  7035  
  7036  // testUint8x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7037  // This converts only the low 4 elements.
  7038  func testUint8x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint32x4, want func(x []uint8) []uint32) {
  7039  	n := 16
  7040  	t.Helper()
  7041  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7042  		t.Helper()
  7043  		a := archsimd.LoadUint8x16(x)
  7044  		g := make([]uint32, 4)
  7045  		f(a).Store(g)
  7046  		w := want(x)
  7047  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7048  	})
  7049  }
  7050  
  7051  // testUint16x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7052  // This converts only the low 4 elements.
  7053  func testUint16x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint32x4, want func(x []uint16) []uint32) {
  7054  	n := 8
  7055  	t.Helper()
  7056  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7057  		t.Helper()
  7058  		a := archsimd.LoadUint16x8(x)
  7059  		g := make([]uint32, 4)
  7060  		f(a).Store(g)
  7061  		w := want(x)
  7062  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7063  	})
  7064  }
  7065  
  7066  // testUint32x4ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7067  // This converts only the low 4 elements.
  7068  func testUint32x4ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint32x4, want func(x []uint32) []uint32) {
  7069  	n := 4
  7070  	t.Helper()
  7071  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7072  		t.Helper()
  7073  		a := archsimd.LoadUint32x4(x)
  7074  		g := make([]uint32, 4)
  7075  		f(a).Store(g)
  7076  		w := want(x)
  7077  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7078  	})
  7079  }
  7080  
  7081  // testUint64x2ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7082  // This converts only the low 4 elements.
  7083  func testUint64x2ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint32x4, want func(x []uint64) []uint32) {
  7084  	n := 2
  7085  	t.Helper()
  7086  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7087  		t.Helper()
  7088  		a := archsimd.LoadUint64x2(x)
  7089  		g := make([]uint32, 4)
  7090  		f(a).Store(g)
  7091  		w := want(x)
  7092  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7093  	})
  7094  }
  7095  
  7096  // testInt8x32ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7097  // This converts only the low 4 elements.
  7098  func testInt8x32ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint32x4, want func(x []int8) []uint32) {
  7099  	n := 32
  7100  	t.Helper()
  7101  	forSlice(t, int8s, n, func(x []int8) bool {
  7102  		t.Helper()
  7103  		a := archsimd.LoadInt8x32(x)
  7104  		g := make([]uint32, 4)
  7105  		f(a).Store(g)
  7106  		w := want(x)
  7107  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7108  	})
  7109  }
  7110  
  7111  // testInt16x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7112  // This converts only the low 4 elements.
  7113  func testInt16x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint32x4, want func(x []int16) []uint32) {
  7114  	n := 16
  7115  	t.Helper()
  7116  	forSlice(t, int16s, n, func(x []int16) bool {
  7117  		t.Helper()
  7118  		a := archsimd.LoadInt16x16(x)
  7119  		g := make([]uint32, 4)
  7120  		f(a).Store(g)
  7121  		w := want(x)
  7122  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7123  	})
  7124  }
  7125  
  7126  // testInt32x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7127  // This converts only the low 4 elements.
  7128  func testInt32x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint32x4, want func(x []int32) []uint32) {
  7129  	n := 8
  7130  	t.Helper()
  7131  	forSlice(t, int32s, n, func(x []int32) bool {
  7132  		t.Helper()
  7133  		a := archsimd.LoadInt32x8(x)
  7134  		g := make([]uint32, 4)
  7135  		f(a).Store(g)
  7136  		w := want(x)
  7137  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7138  	})
  7139  }
  7140  
  7141  // testInt64x4ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7142  // This converts only the low 4 elements.
  7143  func testInt64x4ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint32x4, want func(x []int64) []uint32) {
  7144  	n := 4
  7145  	t.Helper()
  7146  	forSlice(t, int64s, n, func(x []int64) bool {
  7147  		t.Helper()
  7148  		a := archsimd.LoadInt64x4(x)
  7149  		g := make([]uint32, 4)
  7150  		f(a).Store(g)
  7151  		w := want(x)
  7152  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7153  	})
  7154  }
  7155  
  7156  // testUint8x32ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7157  // This converts only the low 4 elements.
  7158  func testUint8x32ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint32x4, want func(x []uint8) []uint32) {
  7159  	n := 32
  7160  	t.Helper()
  7161  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7162  		t.Helper()
  7163  		a := archsimd.LoadUint8x32(x)
  7164  		g := make([]uint32, 4)
  7165  		f(a).Store(g)
  7166  		w := want(x)
  7167  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7168  	})
  7169  }
  7170  
  7171  // testUint16x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7172  // This converts only the low 4 elements.
  7173  func testUint16x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint32x4, want func(x []uint16) []uint32) {
  7174  	n := 16
  7175  	t.Helper()
  7176  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7177  		t.Helper()
  7178  		a := archsimd.LoadUint16x16(x)
  7179  		g := make([]uint32, 4)
  7180  		f(a).Store(g)
  7181  		w := want(x)
  7182  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7183  	})
  7184  }
  7185  
  7186  // testUint32x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7187  // This converts only the low 4 elements.
  7188  func testUint32x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint32x4, want func(x []uint32) []uint32) {
  7189  	n := 8
  7190  	t.Helper()
  7191  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7192  		t.Helper()
  7193  		a := archsimd.LoadUint32x8(x)
  7194  		g := make([]uint32, 4)
  7195  		f(a).Store(g)
  7196  		w := want(x)
  7197  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7198  	})
  7199  }
  7200  
  7201  // testUint64x4ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7202  // This converts only the low 4 elements.
  7203  func testUint64x4ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint32x4, want func(x []uint64) []uint32) {
  7204  	n := 4
  7205  	t.Helper()
  7206  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7207  		t.Helper()
  7208  		a := archsimd.LoadUint64x4(x)
  7209  		g := make([]uint32, 4)
  7210  		f(a).Store(g)
  7211  		w := want(x)
  7212  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7213  	})
  7214  }
  7215  
  7216  // testInt8x64ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7217  // This converts only the low 4 elements.
  7218  func testInt8x64ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint32x4, want func(x []int8) []uint32) {
  7219  	n := 64
  7220  	t.Helper()
  7221  	forSlice(t, int8s, n, func(x []int8) bool {
  7222  		t.Helper()
  7223  		a := archsimd.LoadInt8x64(x)
  7224  		g := make([]uint32, 4)
  7225  		f(a).Store(g)
  7226  		w := want(x)
  7227  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7228  	})
  7229  }
  7230  
  7231  // testInt16x32ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7232  // This converts only the low 4 elements.
  7233  func testInt16x32ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint32x4, want func(x []int16) []uint32) {
  7234  	n := 32
  7235  	t.Helper()
  7236  	forSlice(t, int16s, n, func(x []int16) bool {
  7237  		t.Helper()
  7238  		a := archsimd.LoadInt16x32(x)
  7239  		g := make([]uint32, 4)
  7240  		f(a).Store(g)
  7241  		w := want(x)
  7242  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7243  	})
  7244  }
  7245  
  7246  // testInt32x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7247  // This converts only the low 4 elements.
  7248  func testInt32x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint32x4, want func(x []int32) []uint32) {
  7249  	n := 16
  7250  	t.Helper()
  7251  	forSlice(t, int32s, n, func(x []int32) bool {
  7252  		t.Helper()
  7253  		a := archsimd.LoadInt32x16(x)
  7254  		g := make([]uint32, 4)
  7255  		f(a).Store(g)
  7256  		w := want(x)
  7257  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7258  	})
  7259  }
  7260  
  7261  // testInt64x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7262  // This converts only the low 4 elements.
  7263  func testInt64x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint32x4, want func(x []int64) []uint32) {
  7264  	n := 8
  7265  	t.Helper()
  7266  	forSlice(t, int64s, n, func(x []int64) bool {
  7267  		t.Helper()
  7268  		a := archsimd.LoadInt64x8(x)
  7269  		g := make([]uint32, 4)
  7270  		f(a).Store(g)
  7271  		w := want(x)
  7272  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7273  	})
  7274  }
  7275  
  7276  // testUint8x64ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7277  // This converts only the low 4 elements.
  7278  func testUint8x64ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint32x4, want func(x []uint8) []uint32) {
  7279  	n := 64
  7280  	t.Helper()
  7281  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7282  		t.Helper()
  7283  		a := archsimd.LoadUint8x64(x)
  7284  		g := make([]uint32, 4)
  7285  		f(a).Store(g)
  7286  		w := want(x)
  7287  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7288  	})
  7289  }
  7290  
  7291  // testUint16x32ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7292  // This converts only the low 4 elements.
  7293  func testUint16x32ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint32x4, want func(x []uint16) []uint32) {
  7294  	n := 32
  7295  	t.Helper()
  7296  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7297  		t.Helper()
  7298  		a := archsimd.LoadUint16x32(x)
  7299  		g := make([]uint32, 4)
  7300  		f(a).Store(g)
  7301  		w := want(x)
  7302  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7303  	})
  7304  }
  7305  
  7306  // testUint32x16ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7307  // This converts only the low 4 elements.
  7308  func testUint32x16ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint32x4, want func(x []uint32) []uint32) {
  7309  	n := 16
  7310  	t.Helper()
  7311  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7312  		t.Helper()
  7313  		a := archsimd.LoadUint32x16(x)
  7314  		g := make([]uint32, 4)
  7315  		f(a).Store(g)
  7316  		w := want(x)
  7317  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7318  	})
  7319  }
  7320  
  7321  // testUint64x8ConvertLoToUint32x4 tests the simd conversion method f against the expected behavior generated by want.
  7322  // This converts only the low 4 elements.
  7323  func testUint64x8ConvertLoToUint32x4(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint32x4, want func(x []uint64) []uint32) {
  7324  	n := 8
  7325  	t.Helper()
  7326  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7327  		t.Helper()
  7328  		a := archsimd.LoadUint64x8(x)
  7329  		g := make([]uint32, 4)
  7330  		f(a).Store(g)
  7331  		w := want(x)
  7332  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7333  	})
  7334  }
  7335  
  7336  // testInt8x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7337  // This converts only the low 8 elements.
  7338  func testInt8x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint32x8, want func(x []int8) []uint32) {
  7339  	n := 16
  7340  	t.Helper()
  7341  	forSlice(t, int8s, n, func(x []int8) bool {
  7342  		t.Helper()
  7343  		a := archsimd.LoadInt8x16(x)
  7344  		g := make([]uint32, 8)
  7345  		f(a).Store(g)
  7346  		w := want(x)
  7347  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7348  	})
  7349  }
  7350  
  7351  // testInt16x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7352  // This converts only the low 8 elements.
  7353  func testInt16x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint32x8, want func(x []int16) []uint32) {
  7354  	n := 8
  7355  	t.Helper()
  7356  	forSlice(t, int16s, n, func(x []int16) bool {
  7357  		t.Helper()
  7358  		a := archsimd.LoadInt16x8(x)
  7359  		g := make([]uint32, 8)
  7360  		f(a).Store(g)
  7361  		w := want(x)
  7362  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7363  	})
  7364  }
  7365  
  7366  // testInt32x4ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7367  // This converts only the low 8 elements.
  7368  func testInt32x4ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint32x8, want func(x []int32) []uint32) {
  7369  	n := 4
  7370  	t.Helper()
  7371  	forSlice(t, int32s, n, func(x []int32) bool {
  7372  		t.Helper()
  7373  		a := archsimd.LoadInt32x4(x)
  7374  		g := make([]uint32, 8)
  7375  		f(a).Store(g)
  7376  		w := want(x)
  7377  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7378  	})
  7379  }
  7380  
  7381  // testInt64x2ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7382  // This converts only the low 8 elements.
  7383  func testInt64x2ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint32x8, want func(x []int64) []uint32) {
  7384  	n := 2
  7385  	t.Helper()
  7386  	forSlice(t, int64s, n, func(x []int64) bool {
  7387  		t.Helper()
  7388  		a := archsimd.LoadInt64x2(x)
  7389  		g := make([]uint32, 8)
  7390  		f(a).Store(g)
  7391  		w := want(x)
  7392  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7393  	})
  7394  }
  7395  
  7396  // testUint8x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7397  // This converts only the low 8 elements.
  7398  func testUint8x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint32x8, want func(x []uint8) []uint32) {
  7399  	n := 16
  7400  	t.Helper()
  7401  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7402  		t.Helper()
  7403  		a := archsimd.LoadUint8x16(x)
  7404  		g := make([]uint32, 8)
  7405  		f(a).Store(g)
  7406  		w := want(x)
  7407  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7408  	})
  7409  }
  7410  
  7411  // testUint16x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7412  // This converts only the low 8 elements.
  7413  func testUint16x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint32x8, want func(x []uint16) []uint32) {
  7414  	n := 8
  7415  	t.Helper()
  7416  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7417  		t.Helper()
  7418  		a := archsimd.LoadUint16x8(x)
  7419  		g := make([]uint32, 8)
  7420  		f(a).Store(g)
  7421  		w := want(x)
  7422  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7423  	})
  7424  }
  7425  
  7426  // testUint32x4ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7427  // This converts only the low 8 elements.
  7428  func testUint32x4ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint32x8, want func(x []uint32) []uint32) {
  7429  	n := 4
  7430  	t.Helper()
  7431  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7432  		t.Helper()
  7433  		a := archsimd.LoadUint32x4(x)
  7434  		g := make([]uint32, 8)
  7435  		f(a).Store(g)
  7436  		w := want(x)
  7437  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7438  	})
  7439  }
  7440  
  7441  // testUint64x2ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7442  // This converts only the low 8 elements.
  7443  func testUint64x2ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint32x8, want func(x []uint64) []uint32) {
  7444  	n := 2
  7445  	t.Helper()
  7446  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7447  		t.Helper()
  7448  		a := archsimd.LoadUint64x2(x)
  7449  		g := make([]uint32, 8)
  7450  		f(a).Store(g)
  7451  		w := want(x)
  7452  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7453  	})
  7454  }
  7455  
  7456  // testInt8x32ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7457  // This converts only the low 8 elements.
  7458  func testInt8x32ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint32x8, want func(x []int8) []uint32) {
  7459  	n := 32
  7460  	t.Helper()
  7461  	forSlice(t, int8s, n, func(x []int8) bool {
  7462  		t.Helper()
  7463  		a := archsimd.LoadInt8x32(x)
  7464  		g := make([]uint32, 8)
  7465  		f(a).Store(g)
  7466  		w := want(x)
  7467  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7468  	})
  7469  }
  7470  
  7471  // testInt16x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7472  // This converts only the low 8 elements.
  7473  func testInt16x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint32x8, want func(x []int16) []uint32) {
  7474  	n := 16
  7475  	t.Helper()
  7476  	forSlice(t, int16s, n, func(x []int16) bool {
  7477  		t.Helper()
  7478  		a := archsimd.LoadInt16x16(x)
  7479  		g := make([]uint32, 8)
  7480  		f(a).Store(g)
  7481  		w := want(x)
  7482  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7483  	})
  7484  }
  7485  
  7486  // testInt32x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7487  // This converts only the low 8 elements.
  7488  func testInt32x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint32x8, want func(x []int32) []uint32) {
  7489  	n := 8
  7490  	t.Helper()
  7491  	forSlice(t, int32s, n, func(x []int32) bool {
  7492  		t.Helper()
  7493  		a := archsimd.LoadInt32x8(x)
  7494  		g := make([]uint32, 8)
  7495  		f(a).Store(g)
  7496  		w := want(x)
  7497  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7498  	})
  7499  }
  7500  
  7501  // testInt64x4ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7502  // This converts only the low 8 elements.
  7503  func testInt64x4ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint32x8, want func(x []int64) []uint32) {
  7504  	n := 4
  7505  	t.Helper()
  7506  	forSlice(t, int64s, n, func(x []int64) bool {
  7507  		t.Helper()
  7508  		a := archsimd.LoadInt64x4(x)
  7509  		g := make([]uint32, 8)
  7510  		f(a).Store(g)
  7511  		w := want(x)
  7512  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7513  	})
  7514  }
  7515  
  7516  // testUint8x32ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7517  // This converts only the low 8 elements.
  7518  func testUint8x32ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint32x8, want func(x []uint8) []uint32) {
  7519  	n := 32
  7520  	t.Helper()
  7521  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7522  		t.Helper()
  7523  		a := archsimd.LoadUint8x32(x)
  7524  		g := make([]uint32, 8)
  7525  		f(a).Store(g)
  7526  		w := want(x)
  7527  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7528  	})
  7529  }
  7530  
  7531  // testUint16x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7532  // This converts only the low 8 elements.
  7533  func testUint16x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint32x8, want func(x []uint16) []uint32) {
  7534  	n := 16
  7535  	t.Helper()
  7536  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7537  		t.Helper()
  7538  		a := archsimd.LoadUint16x16(x)
  7539  		g := make([]uint32, 8)
  7540  		f(a).Store(g)
  7541  		w := want(x)
  7542  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7543  	})
  7544  }
  7545  
  7546  // testUint32x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7547  // This converts only the low 8 elements.
  7548  func testUint32x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint32x8, want func(x []uint32) []uint32) {
  7549  	n := 8
  7550  	t.Helper()
  7551  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7552  		t.Helper()
  7553  		a := archsimd.LoadUint32x8(x)
  7554  		g := make([]uint32, 8)
  7555  		f(a).Store(g)
  7556  		w := want(x)
  7557  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7558  	})
  7559  }
  7560  
  7561  // testUint64x4ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7562  // This converts only the low 8 elements.
  7563  func testUint64x4ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint32x8, want func(x []uint64) []uint32) {
  7564  	n := 4
  7565  	t.Helper()
  7566  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7567  		t.Helper()
  7568  		a := archsimd.LoadUint64x4(x)
  7569  		g := make([]uint32, 8)
  7570  		f(a).Store(g)
  7571  		w := want(x)
  7572  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7573  	})
  7574  }
  7575  
  7576  // testInt8x64ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7577  // This converts only the low 8 elements.
  7578  func testInt8x64ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint32x8, want func(x []int8) []uint32) {
  7579  	n := 64
  7580  	t.Helper()
  7581  	forSlice(t, int8s, n, func(x []int8) bool {
  7582  		t.Helper()
  7583  		a := archsimd.LoadInt8x64(x)
  7584  		g := make([]uint32, 8)
  7585  		f(a).Store(g)
  7586  		w := want(x)
  7587  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7588  	})
  7589  }
  7590  
  7591  // testInt16x32ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7592  // This converts only the low 8 elements.
  7593  func testInt16x32ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint32x8, want func(x []int16) []uint32) {
  7594  	n := 32
  7595  	t.Helper()
  7596  	forSlice(t, int16s, n, func(x []int16) bool {
  7597  		t.Helper()
  7598  		a := archsimd.LoadInt16x32(x)
  7599  		g := make([]uint32, 8)
  7600  		f(a).Store(g)
  7601  		w := want(x)
  7602  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7603  	})
  7604  }
  7605  
  7606  // testInt32x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7607  // This converts only the low 8 elements.
  7608  func testInt32x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint32x8, want func(x []int32) []uint32) {
  7609  	n := 16
  7610  	t.Helper()
  7611  	forSlice(t, int32s, n, func(x []int32) bool {
  7612  		t.Helper()
  7613  		a := archsimd.LoadInt32x16(x)
  7614  		g := make([]uint32, 8)
  7615  		f(a).Store(g)
  7616  		w := want(x)
  7617  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7618  	})
  7619  }
  7620  
  7621  // testInt64x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7622  // This converts only the low 8 elements.
  7623  func testInt64x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint32x8, want func(x []int64) []uint32) {
  7624  	n := 8
  7625  	t.Helper()
  7626  	forSlice(t, int64s, n, func(x []int64) bool {
  7627  		t.Helper()
  7628  		a := archsimd.LoadInt64x8(x)
  7629  		g := make([]uint32, 8)
  7630  		f(a).Store(g)
  7631  		w := want(x)
  7632  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7633  	})
  7634  }
  7635  
  7636  // testUint8x64ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7637  // This converts only the low 8 elements.
  7638  func testUint8x64ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint32x8, want func(x []uint8) []uint32) {
  7639  	n := 64
  7640  	t.Helper()
  7641  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7642  		t.Helper()
  7643  		a := archsimd.LoadUint8x64(x)
  7644  		g := make([]uint32, 8)
  7645  		f(a).Store(g)
  7646  		w := want(x)
  7647  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7648  	})
  7649  }
  7650  
  7651  // testUint16x32ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7652  // This converts only the low 8 elements.
  7653  func testUint16x32ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint32x8, want func(x []uint16) []uint32) {
  7654  	n := 32
  7655  	t.Helper()
  7656  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7657  		t.Helper()
  7658  		a := archsimd.LoadUint16x32(x)
  7659  		g := make([]uint32, 8)
  7660  		f(a).Store(g)
  7661  		w := want(x)
  7662  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7663  	})
  7664  }
  7665  
  7666  // testUint32x16ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7667  // This converts only the low 8 elements.
  7668  func testUint32x16ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint32x8, want func(x []uint32) []uint32) {
  7669  	n := 16
  7670  	t.Helper()
  7671  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7672  		t.Helper()
  7673  		a := archsimd.LoadUint32x16(x)
  7674  		g := make([]uint32, 8)
  7675  		f(a).Store(g)
  7676  		w := want(x)
  7677  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7678  	})
  7679  }
  7680  
  7681  // testUint64x8ConvertLoToUint32x8 tests the simd conversion method f against the expected behavior generated by want.
  7682  // This converts only the low 8 elements.
  7683  func testUint64x8ConvertLoToUint32x8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint32x8, want func(x []uint64) []uint32) {
  7684  	n := 8
  7685  	t.Helper()
  7686  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7687  		t.Helper()
  7688  		a := archsimd.LoadUint64x8(x)
  7689  		g := make([]uint32, 8)
  7690  		f(a).Store(g)
  7691  		w := want(x)
  7692  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7693  	})
  7694  }
  7695  
  7696  // testInt8x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7697  // This converts only the low 8 elements.
  7698  func testInt8x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Int16x8, want func(x []int8) []int16) {
  7699  	n := 16
  7700  	t.Helper()
  7701  	forSlice(t, int8s, n, func(x []int8) bool {
  7702  		t.Helper()
  7703  		a := archsimd.LoadInt8x16(x)
  7704  		g := make([]int16, 8)
  7705  		f(a).Store(g)
  7706  		w := want(x)
  7707  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7708  	})
  7709  }
  7710  
  7711  // testInt16x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7712  // This converts only the low 8 elements.
  7713  func testInt16x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Int16x8, want func(x []int16) []int16) {
  7714  	n := 8
  7715  	t.Helper()
  7716  	forSlice(t, int16s, n, func(x []int16) bool {
  7717  		t.Helper()
  7718  		a := archsimd.LoadInt16x8(x)
  7719  		g := make([]int16, 8)
  7720  		f(a).Store(g)
  7721  		w := want(x)
  7722  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7723  	})
  7724  }
  7725  
  7726  // testInt32x4ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7727  // This converts only the low 8 elements.
  7728  func testInt32x4ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Int16x8, want func(x []int32) []int16) {
  7729  	n := 4
  7730  	t.Helper()
  7731  	forSlice(t, int32s, n, func(x []int32) bool {
  7732  		t.Helper()
  7733  		a := archsimd.LoadInt32x4(x)
  7734  		g := make([]int16, 8)
  7735  		f(a).Store(g)
  7736  		w := want(x)
  7737  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7738  	})
  7739  }
  7740  
  7741  // testInt64x2ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7742  // This converts only the low 8 elements.
  7743  func testInt64x2ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Int16x8, want func(x []int64) []int16) {
  7744  	n := 2
  7745  	t.Helper()
  7746  	forSlice(t, int64s, n, func(x []int64) bool {
  7747  		t.Helper()
  7748  		a := archsimd.LoadInt64x2(x)
  7749  		g := make([]int16, 8)
  7750  		f(a).Store(g)
  7751  		w := want(x)
  7752  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7753  	})
  7754  }
  7755  
  7756  // testUint8x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7757  // This converts only the low 8 elements.
  7758  func testUint8x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Int16x8, want func(x []uint8) []int16) {
  7759  	n := 16
  7760  	t.Helper()
  7761  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7762  		t.Helper()
  7763  		a := archsimd.LoadUint8x16(x)
  7764  		g := make([]int16, 8)
  7765  		f(a).Store(g)
  7766  		w := want(x)
  7767  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7768  	})
  7769  }
  7770  
  7771  // testUint16x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7772  // This converts only the low 8 elements.
  7773  func testUint16x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Int16x8, want func(x []uint16) []int16) {
  7774  	n := 8
  7775  	t.Helper()
  7776  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7777  		t.Helper()
  7778  		a := archsimd.LoadUint16x8(x)
  7779  		g := make([]int16, 8)
  7780  		f(a).Store(g)
  7781  		w := want(x)
  7782  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7783  	})
  7784  }
  7785  
  7786  // testUint32x4ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7787  // This converts only the low 8 elements.
  7788  func testUint32x4ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Int16x8, want func(x []uint32) []int16) {
  7789  	n := 4
  7790  	t.Helper()
  7791  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7792  		t.Helper()
  7793  		a := archsimd.LoadUint32x4(x)
  7794  		g := make([]int16, 8)
  7795  		f(a).Store(g)
  7796  		w := want(x)
  7797  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7798  	})
  7799  }
  7800  
  7801  // testUint64x2ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7802  // This converts only the low 8 elements.
  7803  func testUint64x2ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Int16x8, want func(x []uint64) []int16) {
  7804  	n := 2
  7805  	t.Helper()
  7806  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7807  		t.Helper()
  7808  		a := archsimd.LoadUint64x2(x)
  7809  		g := make([]int16, 8)
  7810  		f(a).Store(g)
  7811  		w := want(x)
  7812  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7813  	})
  7814  }
  7815  
  7816  // testInt8x32ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7817  // This converts only the low 8 elements.
  7818  func testInt8x32ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Int16x8, want func(x []int8) []int16) {
  7819  	n := 32
  7820  	t.Helper()
  7821  	forSlice(t, int8s, n, func(x []int8) bool {
  7822  		t.Helper()
  7823  		a := archsimd.LoadInt8x32(x)
  7824  		g := make([]int16, 8)
  7825  		f(a).Store(g)
  7826  		w := want(x)
  7827  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7828  	})
  7829  }
  7830  
  7831  // testInt16x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7832  // This converts only the low 8 elements.
  7833  func testInt16x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Int16x8, want func(x []int16) []int16) {
  7834  	n := 16
  7835  	t.Helper()
  7836  	forSlice(t, int16s, n, func(x []int16) bool {
  7837  		t.Helper()
  7838  		a := archsimd.LoadInt16x16(x)
  7839  		g := make([]int16, 8)
  7840  		f(a).Store(g)
  7841  		w := want(x)
  7842  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7843  	})
  7844  }
  7845  
  7846  // testInt32x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7847  // This converts only the low 8 elements.
  7848  func testInt32x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Int16x8, want func(x []int32) []int16) {
  7849  	n := 8
  7850  	t.Helper()
  7851  	forSlice(t, int32s, n, func(x []int32) bool {
  7852  		t.Helper()
  7853  		a := archsimd.LoadInt32x8(x)
  7854  		g := make([]int16, 8)
  7855  		f(a).Store(g)
  7856  		w := want(x)
  7857  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7858  	})
  7859  }
  7860  
  7861  // testInt64x4ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7862  // This converts only the low 8 elements.
  7863  func testInt64x4ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Int16x8, want func(x []int64) []int16) {
  7864  	n := 4
  7865  	t.Helper()
  7866  	forSlice(t, int64s, n, func(x []int64) bool {
  7867  		t.Helper()
  7868  		a := archsimd.LoadInt64x4(x)
  7869  		g := make([]int16, 8)
  7870  		f(a).Store(g)
  7871  		w := want(x)
  7872  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7873  	})
  7874  }
  7875  
  7876  // testUint8x32ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7877  // This converts only the low 8 elements.
  7878  func testUint8x32ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Int16x8, want func(x []uint8) []int16) {
  7879  	n := 32
  7880  	t.Helper()
  7881  	forSlice(t, uint8s, n, func(x []uint8) bool {
  7882  		t.Helper()
  7883  		a := archsimd.LoadUint8x32(x)
  7884  		g := make([]int16, 8)
  7885  		f(a).Store(g)
  7886  		w := want(x)
  7887  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7888  	})
  7889  }
  7890  
  7891  // testUint16x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7892  // This converts only the low 8 elements.
  7893  func testUint16x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Int16x8, want func(x []uint16) []int16) {
  7894  	n := 16
  7895  	t.Helper()
  7896  	forSlice(t, uint16s, n, func(x []uint16) bool {
  7897  		t.Helper()
  7898  		a := archsimd.LoadUint16x16(x)
  7899  		g := make([]int16, 8)
  7900  		f(a).Store(g)
  7901  		w := want(x)
  7902  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7903  	})
  7904  }
  7905  
  7906  // testUint32x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7907  // This converts only the low 8 elements.
  7908  func testUint32x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Int16x8, want func(x []uint32) []int16) {
  7909  	n := 8
  7910  	t.Helper()
  7911  	forSlice(t, uint32s, n, func(x []uint32) bool {
  7912  		t.Helper()
  7913  		a := archsimd.LoadUint32x8(x)
  7914  		g := make([]int16, 8)
  7915  		f(a).Store(g)
  7916  		w := want(x)
  7917  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7918  	})
  7919  }
  7920  
  7921  // testUint64x4ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7922  // This converts only the low 8 elements.
  7923  func testUint64x4ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Int16x8, want func(x []uint64) []int16) {
  7924  	n := 4
  7925  	t.Helper()
  7926  	forSlice(t, uint64s, n, func(x []uint64) bool {
  7927  		t.Helper()
  7928  		a := archsimd.LoadUint64x4(x)
  7929  		g := make([]int16, 8)
  7930  		f(a).Store(g)
  7931  		w := want(x)
  7932  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7933  	})
  7934  }
  7935  
  7936  // testInt8x64ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7937  // This converts only the low 8 elements.
  7938  func testInt8x64ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Int16x8, want func(x []int8) []int16) {
  7939  	n := 64
  7940  	t.Helper()
  7941  	forSlice(t, int8s, n, func(x []int8) bool {
  7942  		t.Helper()
  7943  		a := archsimd.LoadInt8x64(x)
  7944  		g := make([]int16, 8)
  7945  		f(a).Store(g)
  7946  		w := want(x)
  7947  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7948  	})
  7949  }
  7950  
  7951  // testInt16x32ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7952  // This converts only the low 8 elements.
  7953  func testInt16x32ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Int16x8, want func(x []int16) []int16) {
  7954  	n := 32
  7955  	t.Helper()
  7956  	forSlice(t, int16s, n, func(x []int16) bool {
  7957  		t.Helper()
  7958  		a := archsimd.LoadInt16x32(x)
  7959  		g := make([]int16, 8)
  7960  		f(a).Store(g)
  7961  		w := want(x)
  7962  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7963  	})
  7964  }
  7965  
  7966  // testInt32x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7967  // This converts only the low 8 elements.
  7968  func testInt32x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Int16x8, want func(x []int32) []int16) {
  7969  	n := 16
  7970  	t.Helper()
  7971  	forSlice(t, int32s, n, func(x []int32) bool {
  7972  		t.Helper()
  7973  		a := archsimd.LoadInt32x16(x)
  7974  		g := make([]int16, 8)
  7975  		f(a).Store(g)
  7976  		w := want(x)
  7977  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7978  	})
  7979  }
  7980  
  7981  // testInt64x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7982  // This converts only the low 8 elements.
  7983  func testInt64x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Int16x8, want func(x []int64) []int16) {
  7984  	n := 8
  7985  	t.Helper()
  7986  	forSlice(t, int64s, n, func(x []int64) bool {
  7987  		t.Helper()
  7988  		a := archsimd.LoadInt64x8(x)
  7989  		g := make([]int16, 8)
  7990  		f(a).Store(g)
  7991  		w := want(x)
  7992  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  7993  	})
  7994  }
  7995  
  7996  // testUint8x64ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  7997  // This converts only the low 8 elements.
  7998  func testUint8x64ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Int16x8, want func(x []uint8) []int16) {
  7999  	n := 64
  8000  	t.Helper()
  8001  	forSlice(t, uint8s, n, func(x []uint8) bool {
  8002  		t.Helper()
  8003  		a := archsimd.LoadUint8x64(x)
  8004  		g := make([]int16, 8)
  8005  		f(a).Store(g)
  8006  		w := want(x)
  8007  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8008  	})
  8009  }
  8010  
  8011  // testUint16x32ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  8012  // This converts only the low 8 elements.
  8013  func testUint16x32ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Int16x8, want func(x []uint16) []int16) {
  8014  	n := 32
  8015  	t.Helper()
  8016  	forSlice(t, uint16s, n, func(x []uint16) bool {
  8017  		t.Helper()
  8018  		a := archsimd.LoadUint16x32(x)
  8019  		g := make([]int16, 8)
  8020  		f(a).Store(g)
  8021  		w := want(x)
  8022  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8023  	})
  8024  }
  8025  
  8026  // testUint32x16ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  8027  // This converts only the low 8 elements.
  8028  func testUint32x16ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Int16x8, want func(x []uint32) []int16) {
  8029  	n := 16
  8030  	t.Helper()
  8031  	forSlice(t, uint32s, n, func(x []uint32) bool {
  8032  		t.Helper()
  8033  		a := archsimd.LoadUint32x16(x)
  8034  		g := make([]int16, 8)
  8035  		f(a).Store(g)
  8036  		w := want(x)
  8037  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8038  	})
  8039  }
  8040  
  8041  // testUint64x8ConvertLoToInt16x8 tests the simd conversion method f against the expected behavior generated by want.
  8042  // This converts only the low 8 elements.
  8043  func testUint64x8ConvertLoToInt16x8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Int16x8, want func(x []uint64) []int16) {
  8044  	n := 8
  8045  	t.Helper()
  8046  	forSlice(t, uint64s, n, func(x []uint64) bool {
  8047  		t.Helper()
  8048  		a := archsimd.LoadUint64x8(x)
  8049  		g := make([]int16, 8)
  8050  		f(a).Store(g)
  8051  		w := want(x)
  8052  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8053  	})
  8054  }
  8055  
  8056  // testInt8x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8057  // This converts only the low 8 elements.
  8058  func testInt8x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int8x16) archsimd.Uint16x8, want func(x []int8) []uint16) {
  8059  	n := 16
  8060  	t.Helper()
  8061  	forSlice(t, int8s, n, func(x []int8) bool {
  8062  		t.Helper()
  8063  		a := archsimd.LoadInt8x16(x)
  8064  		g := make([]uint16, 8)
  8065  		f(a).Store(g)
  8066  		w := want(x)
  8067  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8068  	})
  8069  }
  8070  
  8071  // testInt16x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8072  // This converts only the low 8 elements.
  8073  func testInt16x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int16x8) archsimd.Uint16x8, want func(x []int16) []uint16) {
  8074  	n := 8
  8075  	t.Helper()
  8076  	forSlice(t, int16s, n, func(x []int16) bool {
  8077  		t.Helper()
  8078  		a := archsimd.LoadInt16x8(x)
  8079  		g := make([]uint16, 8)
  8080  		f(a).Store(g)
  8081  		w := want(x)
  8082  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8083  	})
  8084  }
  8085  
  8086  // testInt32x4ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8087  // This converts only the low 8 elements.
  8088  func testInt32x4ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int32x4) archsimd.Uint16x8, want func(x []int32) []uint16) {
  8089  	n := 4
  8090  	t.Helper()
  8091  	forSlice(t, int32s, n, func(x []int32) bool {
  8092  		t.Helper()
  8093  		a := archsimd.LoadInt32x4(x)
  8094  		g := make([]uint16, 8)
  8095  		f(a).Store(g)
  8096  		w := want(x)
  8097  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8098  	})
  8099  }
  8100  
  8101  // testInt64x2ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8102  // This converts only the low 8 elements.
  8103  func testInt64x2ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int64x2) archsimd.Uint16x8, want func(x []int64) []uint16) {
  8104  	n := 2
  8105  	t.Helper()
  8106  	forSlice(t, int64s, n, func(x []int64) bool {
  8107  		t.Helper()
  8108  		a := archsimd.LoadInt64x2(x)
  8109  		g := make([]uint16, 8)
  8110  		f(a).Store(g)
  8111  		w := want(x)
  8112  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8113  	})
  8114  }
  8115  
  8116  // testUint8x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8117  // This converts only the low 8 elements.
  8118  func testUint8x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint8x16) archsimd.Uint16x8, want func(x []uint8) []uint16) {
  8119  	n := 16
  8120  	t.Helper()
  8121  	forSlice(t, uint8s, n, func(x []uint8) bool {
  8122  		t.Helper()
  8123  		a := archsimd.LoadUint8x16(x)
  8124  		g := make([]uint16, 8)
  8125  		f(a).Store(g)
  8126  		w := want(x)
  8127  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8128  	})
  8129  }
  8130  
  8131  // testUint16x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8132  // This converts only the low 8 elements.
  8133  func testUint16x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint16x8) archsimd.Uint16x8, want func(x []uint16) []uint16) {
  8134  	n := 8
  8135  	t.Helper()
  8136  	forSlice(t, uint16s, n, func(x []uint16) bool {
  8137  		t.Helper()
  8138  		a := archsimd.LoadUint16x8(x)
  8139  		g := make([]uint16, 8)
  8140  		f(a).Store(g)
  8141  		w := want(x)
  8142  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8143  	})
  8144  }
  8145  
  8146  // testUint32x4ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8147  // This converts only the low 8 elements.
  8148  func testUint32x4ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint32x4) archsimd.Uint16x8, want func(x []uint32) []uint16) {
  8149  	n := 4
  8150  	t.Helper()
  8151  	forSlice(t, uint32s, n, func(x []uint32) bool {
  8152  		t.Helper()
  8153  		a := archsimd.LoadUint32x4(x)
  8154  		g := make([]uint16, 8)
  8155  		f(a).Store(g)
  8156  		w := want(x)
  8157  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8158  	})
  8159  }
  8160  
  8161  // testUint64x2ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8162  // This converts only the low 8 elements.
  8163  func testUint64x2ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint64x2) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  8164  	n := 2
  8165  	t.Helper()
  8166  	forSlice(t, uint64s, n, func(x []uint64) bool {
  8167  		t.Helper()
  8168  		a := archsimd.LoadUint64x2(x)
  8169  		g := make([]uint16, 8)
  8170  		f(a).Store(g)
  8171  		w := want(x)
  8172  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8173  	})
  8174  }
  8175  
  8176  // testInt8x32ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8177  // This converts only the low 8 elements.
  8178  func testInt8x32ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int8x32) archsimd.Uint16x8, want func(x []int8) []uint16) {
  8179  	n := 32
  8180  	t.Helper()
  8181  	forSlice(t, int8s, n, func(x []int8) bool {
  8182  		t.Helper()
  8183  		a := archsimd.LoadInt8x32(x)
  8184  		g := make([]uint16, 8)
  8185  		f(a).Store(g)
  8186  		w := want(x)
  8187  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8188  	})
  8189  }
  8190  
  8191  // testInt16x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8192  // This converts only the low 8 elements.
  8193  func testInt16x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int16x16) archsimd.Uint16x8, want func(x []int16) []uint16) {
  8194  	n := 16
  8195  	t.Helper()
  8196  	forSlice(t, int16s, n, func(x []int16) bool {
  8197  		t.Helper()
  8198  		a := archsimd.LoadInt16x16(x)
  8199  		g := make([]uint16, 8)
  8200  		f(a).Store(g)
  8201  		w := want(x)
  8202  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8203  	})
  8204  }
  8205  
  8206  // testInt32x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8207  // This converts only the low 8 elements.
  8208  func testInt32x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int32x8) archsimd.Uint16x8, want func(x []int32) []uint16) {
  8209  	n := 8
  8210  	t.Helper()
  8211  	forSlice(t, int32s, n, func(x []int32) bool {
  8212  		t.Helper()
  8213  		a := archsimd.LoadInt32x8(x)
  8214  		g := make([]uint16, 8)
  8215  		f(a).Store(g)
  8216  		w := want(x)
  8217  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8218  	})
  8219  }
  8220  
  8221  // testInt64x4ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8222  // This converts only the low 8 elements.
  8223  func testInt64x4ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int64x4) archsimd.Uint16x8, want func(x []int64) []uint16) {
  8224  	n := 4
  8225  	t.Helper()
  8226  	forSlice(t, int64s, n, func(x []int64) bool {
  8227  		t.Helper()
  8228  		a := archsimd.LoadInt64x4(x)
  8229  		g := make([]uint16, 8)
  8230  		f(a).Store(g)
  8231  		w := want(x)
  8232  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8233  	})
  8234  }
  8235  
  8236  // testUint8x32ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8237  // This converts only the low 8 elements.
  8238  func testUint8x32ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint8x32) archsimd.Uint16x8, want func(x []uint8) []uint16) {
  8239  	n := 32
  8240  	t.Helper()
  8241  	forSlice(t, uint8s, n, func(x []uint8) bool {
  8242  		t.Helper()
  8243  		a := archsimd.LoadUint8x32(x)
  8244  		g := make([]uint16, 8)
  8245  		f(a).Store(g)
  8246  		w := want(x)
  8247  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8248  	})
  8249  }
  8250  
  8251  // testUint16x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8252  // This converts only the low 8 elements.
  8253  func testUint16x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint16x16) archsimd.Uint16x8, want func(x []uint16) []uint16) {
  8254  	n := 16
  8255  	t.Helper()
  8256  	forSlice(t, uint16s, n, func(x []uint16) bool {
  8257  		t.Helper()
  8258  		a := archsimd.LoadUint16x16(x)
  8259  		g := make([]uint16, 8)
  8260  		f(a).Store(g)
  8261  		w := want(x)
  8262  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8263  	})
  8264  }
  8265  
  8266  // testUint32x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8267  // This converts only the low 8 elements.
  8268  func testUint32x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint32x8) archsimd.Uint16x8, want func(x []uint32) []uint16) {
  8269  	n := 8
  8270  	t.Helper()
  8271  	forSlice(t, uint32s, n, func(x []uint32) bool {
  8272  		t.Helper()
  8273  		a := archsimd.LoadUint32x8(x)
  8274  		g := make([]uint16, 8)
  8275  		f(a).Store(g)
  8276  		w := want(x)
  8277  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8278  	})
  8279  }
  8280  
  8281  // testUint64x4ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8282  // This converts only the low 8 elements.
  8283  func testUint64x4ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint64x4) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  8284  	n := 4
  8285  	t.Helper()
  8286  	forSlice(t, uint64s, n, func(x []uint64) bool {
  8287  		t.Helper()
  8288  		a := archsimd.LoadUint64x4(x)
  8289  		g := make([]uint16, 8)
  8290  		f(a).Store(g)
  8291  		w := want(x)
  8292  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8293  	})
  8294  }
  8295  
  8296  // testInt8x64ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8297  // This converts only the low 8 elements.
  8298  func testInt8x64ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int8x64) archsimd.Uint16x8, want func(x []int8) []uint16) {
  8299  	n := 64
  8300  	t.Helper()
  8301  	forSlice(t, int8s, n, func(x []int8) bool {
  8302  		t.Helper()
  8303  		a := archsimd.LoadInt8x64(x)
  8304  		g := make([]uint16, 8)
  8305  		f(a).Store(g)
  8306  		w := want(x)
  8307  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8308  	})
  8309  }
  8310  
  8311  // testInt16x32ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8312  // This converts only the low 8 elements.
  8313  func testInt16x32ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int16x32) archsimd.Uint16x8, want func(x []int16) []uint16) {
  8314  	n := 32
  8315  	t.Helper()
  8316  	forSlice(t, int16s, n, func(x []int16) bool {
  8317  		t.Helper()
  8318  		a := archsimd.LoadInt16x32(x)
  8319  		g := make([]uint16, 8)
  8320  		f(a).Store(g)
  8321  		w := want(x)
  8322  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8323  	})
  8324  }
  8325  
  8326  // testInt32x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8327  // This converts only the low 8 elements.
  8328  func testInt32x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int32x16) archsimd.Uint16x8, want func(x []int32) []uint16) {
  8329  	n := 16
  8330  	t.Helper()
  8331  	forSlice(t, int32s, n, func(x []int32) bool {
  8332  		t.Helper()
  8333  		a := archsimd.LoadInt32x16(x)
  8334  		g := make([]uint16, 8)
  8335  		f(a).Store(g)
  8336  		w := want(x)
  8337  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8338  	})
  8339  }
  8340  
  8341  // testInt64x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8342  // This converts only the low 8 elements.
  8343  func testInt64x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Int64x8) archsimd.Uint16x8, want func(x []int64) []uint16) {
  8344  	n := 8
  8345  	t.Helper()
  8346  	forSlice(t, int64s, n, func(x []int64) bool {
  8347  		t.Helper()
  8348  		a := archsimd.LoadInt64x8(x)
  8349  		g := make([]uint16, 8)
  8350  		f(a).Store(g)
  8351  		w := want(x)
  8352  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8353  	})
  8354  }
  8355  
  8356  // testUint8x64ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8357  // This converts only the low 8 elements.
  8358  func testUint8x64ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint8x64) archsimd.Uint16x8, want func(x []uint8) []uint16) {
  8359  	n := 64
  8360  	t.Helper()
  8361  	forSlice(t, uint8s, n, func(x []uint8) bool {
  8362  		t.Helper()
  8363  		a := archsimd.LoadUint8x64(x)
  8364  		g := make([]uint16, 8)
  8365  		f(a).Store(g)
  8366  		w := want(x)
  8367  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8368  	})
  8369  }
  8370  
  8371  // testUint16x32ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8372  // This converts only the low 8 elements.
  8373  func testUint16x32ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint16x32) archsimd.Uint16x8, want func(x []uint16) []uint16) {
  8374  	n := 32
  8375  	t.Helper()
  8376  	forSlice(t, uint16s, n, func(x []uint16) bool {
  8377  		t.Helper()
  8378  		a := archsimd.LoadUint16x32(x)
  8379  		g := make([]uint16, 8)
  8380  		f(a).Store(g)
  8381  		w := want(x)
  8382  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8383  	})
  8384  }
  8385  
  8386  // testUint32x16ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8387  // This converts only the low 8 elements.
  8388  func testUint32x16ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint32x16) archsimd.Uint16x8, want func(x []uint32) []uint16) {
  8389  	n := 16
  8390  	t.Helper()
  8391  	forSlice(t, uint32s, n, func(x []uint32) bool {
  8392  		t.Helper()
  8393  		a := archsimd.LoadUint32x16(x)
  8394  		g := make([]uint16, 8)
  8395  		f(a).Store(g)
  8396  		w := want(x)
  8397  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8398  	})
  8399  }
  8400  
  8401  // testUint64x8ConvertLoToUint16x8 tests the simd conversion method f against the expected behavior generated by want.
  8402  // This converts only the low 8 elements.
  8403  func testUint64x8ConvertLoToUint16x8(t *testing.T, f func(x archsimd.Uint64x8) archsimd.Uint16x8, want func(x []uint64) []uint16) {
  8404  	n := 8
  8405  	t.Helper()
  8406  	forSlice(t, uint64s, n, func(x []uint64) bool {
  8407  		t.Helper()
  8408  		a := archsimd.LoadUint64x8(x)
  8409  		g := make([]uint16, 8)
  8410  		f(a).Store(g)
  8411  		w := want(x)
  8412  		return checkSlicesLogInput(t, g, w, 0.0, func() { t.Helper(); t.Logf("x=%v", x) })
  8413  	})
  8414  }
  8415  
  8416  // testFloat32x4UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8417  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8418  func testFloat32x4UnaryFlaky(t *testing.T, f func(x archsimd.Float32x4) archsimd.Float32x4, want func(x []float32) []float32, flakiness float64) {
  8419  	n := 4
  8420  	t.Helper()
  8421  	forSlice(t, float32s, n, func(x []float32) bool {
  8422  		t.Helper()
  8423  		a := archsimd.LoadFloat32x4(x)
  8424  		g := make([]float32, n)
  8425  		f(a).Store(g)
  8426  		w := want(x)
  8427  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8428  	})
  8429  }
  8430  
  8431  // testFloat64x2UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8432  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8433  func testFloat64x2UnaryFlaky(t *testing.T, f func(x archsimd.Float64x2) archsimd.Float64x2, want func(x []float64) []float64, flakiness float64) {
  8434  	n := 2
  8435  	t.Helper()
  8436  	forSlice(t, float64s, n, func(x []float64) bool {
  8437  		t.Helper()
  8438  		a := archsimd.LoadFloat64x2(x)
  8439  		g := make([]float64, n)
  8440  		f(a).Store(g)
  8441  		w := want(x)
  8442  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8443  	})
  8444  }
  8445  
  8446  // testFloat32x8UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8447  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8448  func testFloat32x8UnaryFlaky(t *testing.T, f func(x archsimd.Float32x8) archsimd.Float32x8, want func(x []float32) []float32, flakiness float64) {
  8449  	n := 8
  8450  	t.Helper()
  8451  	forSlice(t, float32s, n, func(x []float32) bool {
  8452  		t.Helper()
  8453  		a := archsimd.LoadFloat32x8(x)
  8454  		g := make([]float32, n)
  8455  		f(a).Store(g)
  8456  		w := want(x)
  8457  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8458  	})
  8459  }
  8460  
  8461  // testFloat64x4UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8462  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8463  func testFloat64x4UnaryFlaky(t *testing.T, f func(x archsimd.Float64x4) archsimd.Float64x4, want func(x []float64) []float64, flakiness float64) {
  8464  	n := 4
  8465  	t.Helper()
  8466  	forSlice(t, float64s, n, func(x []float64) bool {
  8467  		t.Helper()
  8468  		a := archsimd.LoadFloat64x4(x)
  8469  		g := make([]float64, n)
  8470  		f(a).Store(g)
  8471  		w := want(x)
  8472  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8473  	})
  8474  }
  8475  
  8476  // testFloat32x16UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8477  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8478  func testFloat32x16UnaryFlaky(t *testing.T, f func(x archsimd.Float32x16) archsimd.Float32x16, want func(x []float32) []float32, flakiness float64) {
  8479  	n := 16
  8480  	t.Helper()
  8481  	forSlice(t, float32s, n, func(x []float32) bool {
  8482  		t.Helper()
  8483  		a := archsimd.LoadFloat32x16(x)
  8484  		g := make([]float32, n)
  8485  		f(a).Store(g)
  8486  		w := want(x)
  8487  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8488  	})
  8489  }
  8490  
  8491  // testFloat64x8UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
  8492  // but using a flakiness parameter because we haven't exactly figured out how simd floating point works
  8493  func testFloat64x8UnaryFlaky(t *testing.T, f func(x archsimd.Float64x8) archsimd.Float64x8, want func(x []float64) []float64, flakiness float64) {
  8494  	n := 8
  8495  	t.Helper()
  8496  	forSlice(t, float64s, n, func(x []float64) bool {
  8497  		t.Helper()
  8498  		a := archsimd.LoadFloat64x8(x)
  8499  		g := make([]float64, n)
  8500  		f(a).Store(g)
  8501  		w := want(x)
  8502  		return checkSlicesLogInput(t, g, w, flakiness, func() { t.Helper(); t.Logf("x=%v", x) })
  8503  	})
  8504  }
  8505