binary_test.go

     1  // Copyright 2025 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build goexperiment.simd && amd64
     6  
     7  package simd_test
     8  
     9  import (
    10  	"simd"
    11  	"testing"
    12  )
    13  
    14  func TestAdd(t *testing.T) {
    15  	testFloat32x4Binary(t, simd.Float32x4.Add, addSlice[float32])
    16  	testFloat32x8Binary(t, simd.Float32x8.Add, addSlice[float32])
    17  	testFloat64x2Binary(t, simd.Float64x2.Add, addSlice[float64])
    18  	testFloat64x4Binary(t, simd.Float64x4.Add, addSlice[float64])
    19  
    20  	testInt16x16Binary(t, simd.Int16x16.Add, addSlice[int16])
    21  	testInt16x8Binary(t, simd.Int16x8.Add, addSlice[int16])
    22  	testInt32x4Binary(t, simd.Int32x4.Add, addSlice[int32])
    23  	testInt32x8Binary(t, simd.Int32x8.Add, addSlice[int32])
    24  	testInt64x2Binary(t, simd.Int64x2.Add, addSlice[int64])
    25  	testInt64x4Binary(t, simd.Int64x4.Add, addSlice[int64])
    26  	testInt8x16Binary(t, simd.Int8x16.Add, addSlice[int8])
    27  	testInt8x32Binary(t, simd.Int8x32.Add, addSlice[int8])
    28  
    29  	testUint16x16Binary(t, simd.Uint16x16.Add, addSlice[uint16])
    30  	testUint16x8Binary(t, simd.Uint16x8.Add, addSlice[uint16])
    31  	testUint32x4Binary(t, simd.Uint32x4.Add, addSlice[uint32])
    32  	testUint32x8Binary(t, simd.Uint32x8.Add, addSlice[uint32])
    33  	testUint64x2Binary(t, simd.Uint64x2.Add, addSlice[uint64])
    34  	testUint64x4Binary(t, simd.Uint64x4.Add, addSlice[uint64])
    35  	testUint8x16Binary(t, simd.Uint8x16.Add, addSlice[uint8])
    36  	testUint8x32Binary(t, simd.Uint8x32.Add, addSlice[uint8])
    37  
    38  	if simd.X86.AVX512() {
    39  		testFloat32x16Binary(t, simd.Float32x16.Add, addSlice[float32])
    40  		testFloat64x8Binary(t, simd.Float64x8.Add, addSlice[float64])
    41  		testInt8x64Binary(t, simd.Int8x64.Add, addSlice[int8])
    42  		testInt16x32Binary(t, simd.Int16x32.Add, addSlice[int16])
    43  		testInt32x16Binary(t, simd.Int32x16.Add, addSlice[int32])
    44  		testInt64x8Binary(t, simd.Int64x8.Add, addSlice[int64])
    45  		testUint8x64Binary(t, simd.Uint8x64.Add, addSlice[uint8])
    46  		testUint16x32Binary(t, simd.Uint16x32.Add, addSlice[uint16])
    47  		testUint32x16Binary(t, simd.Uint32x16.Add, addSlice[uint32])
    48  		testUint64x8Binary(t, simd.Uint64x8.Add, addSlice[uint64])
    49  	}
    50  }
    51  
    52  func TestSub(t *testing.T) {
    53  	testFloat32x4Binary(t, simd.Float32x4.Sub, subSlice[float32])
    54  	testFloat32x8Binary(t, simd.Float32x8.Sub, subSlice[float32])
    55  	testFloat64x2Binary(t, simd.Float64x2.Sub, subSlice[float64])
    56  	testFloat64x4Binary(t, simd.Float64x4.Sub, subSlice[float64])
    57  
    58  	testInt16x16Binary(t, simd.Int16x16.Sub, subSlice[int16])
    59  	testInt16x8Binary(t, simd.Int16x8.Sub, subSlice[int16])
    60  	testInt32x4Binary(t, simd.Int32x4.Sub, subSlice[int32])
    61  	testInt32x8Binary(t, simd.Int32x8.Sub, subSlice[int32])
    62  	testInt64x2Binary(t, simd.Int64x2.Sub, subSlice[int64])
    63  	testInt64x4Binary(t, simd.Int64x4.Sub, subSlice[int64])
    64  	testInt8x16Binary(t, simd.Int8x16.Sub, subSlice[int8])
    65  	testInt8x32Binary(t, simd.Int8x32.Sub, subSlice[int8])
    66  
    67  	testUint16x16Binary(t, simd.Uint16x16.Sub, subSlice[uint16])
    68  	testUint16x8Binary(t, simd.Uint16x8.Sub, subSlice[uint16])
    69  	testUint32x4Binary(t, simd.Uint32x4.Sub, subSlice[uint32])
    70  	testUint32x8Binary(t, simd.Uint32x8.Sub, subSlice[uint32])
    71  	testUint64x2Binary(t, simd.Uint64x2.Sub, subSlice[uint64])
    72  	testUint64x4Binary(t, simd.Uint64x4.Sub, subSlice[uint64])
    73  	testUint8x16Binary(t, simd.Uint8x16.Sub, subSlice[uint8])
    74  	testUint8x32Binary(t, simd.Uint8x32.Sub, subSlice[uint8])
    75  
    76  	if simd.X86.AVX512() {
    77  		testFloat32x16Binary(t, simd.Float32x16.Sub, subSlice[float32])
    78  		testFloat64x8Binary(t, simd.Float64x8.Sub, subSlice[float64])
    79  		testInt8x64Binary(t, simd.Int8x64.Sub, subSlice[int8])
    80  		testInt16x32Binary(t, simd.Int16x32.Sub, subSlice[int16])
    81  		testInt32x16Binary(t, simd.Int32x16.Sub, subSlice[int32])
    82  		testInt64x8Binary(t, simd.Int64x8.Sub, subSlice[int64])
    83  		testUint8x64Binary(t, simd.Uint8x64.Sub, subSlice[uint8])
    84  		testUint16x32Binary(t, simd.Uint16x32.Sub, subSlice[uint16])
    85  		testUint32x16Binary(t, simd.Uint32x16.Sub, subSlice[uint32])
    86  		testUint64x8Binary(t, simd.Uint64x8.Sub, subSlice[uint64])
    87  	}
    88  }
    89  
    90  func TestMax(t *testing.T) {
    91  	// testFloat32x4Binary(t, simd.Float32x4.Max, maxSlice[float32]) // nan is wrong
    92  	// testFloat32x8Binary(t, simd.Float32x8.Max, maxSlice[float32]) // nan is wrong
    93  	// testFloat64x2Binary(t, simd.Float64x2.Max, maxSlice[float64]) // nan is wrong
    94  	// testFloat64x4Binary(t, simd.Float64x4.Max, maxSlice[float64]) // nan is wrong
    95  
    96  	testInt16x16Binary(t, simd.Int16x16.Max, maxSlice[int16])
    97  	testInt16x8Binary(t, simd.Int16x8.Max, maxSlice[int16])
    98  	testInt32x4Binary(t, simd.Int32x4.Max, maxSlice[int32])
    99  	testInt32x8Binary(t, simd.Int32x8.Max, maxSlice[int32])
   100  
   101  	if simd.X86.AVX512() {
   102  		testInt64x2Binary(t, simd.Int64x2.Max, maxSlice[int64])
   103  		testInt64x4Binary(t, simd.Int64x4.Max, maxSlice[int64])
   104  	}
   105  
   106  	testInt8x16Binary(t, simd.Int8x16.Max, maxSlice[int8])
   107  	testInt8x32Binary(t, simd.Int8x32.Max, maxSlice[int8])
   108  
   109  	testUint16x16Binary(t, simd.Uint16x16.Max, maxSlice[uint16])
   110  	testUint16x8Binary(t, simd.Uint16x8.Max, maxSlice[uint16])
   111  	testUint32x4Binary(t, simd.Uint32x4.Max, maxSlice[uint32])
   112  	testUint32x8Binary(t, simd.Uint32x8.Max, maxSlice[uint32])
   113  
   114  	if simd.X86.AVX512() {
   115  		testUint64x2Binary(t, simd.Uint64x2.Max, maxSlice[uint64])
   116  		testUint64x4Binary(t, simd.Uint64x4.Max, maxSlice[uint64])
   117  	}
   118  
   119  	testUint8x16Binary(t, simd.Uint8x16.Max, maxSlice[uint8])
   120  	testUint8x32Binary(t, simd.Uint8x32.Max, maxSlice[uint8])
   121  
   122  	if simd.X86.AVX512() {
   123  		// testFloat32x16Binary(t, simd.Float32x16.Max, maxSlice[float32]) // nan is wrong
   124  		// testFloat64x8Binary(t, simd.Float64x8.Max, maxSlice[float64]) // nan is wrong
   125  		testInt8x64Binary(t, simd.Int8x64.Max, maxSlice[int8])
   126  		testInt16x32Binary(t, simd.Int16x32.Max, maxSlice[int16])
   127  		testInt32x16Binary(t, simd.Int32x16.Max, maxSlice[int32])
   128  		testInt64x8Binary(t, simd.Int64x8.Max, maxSlice[int64])
   129  		testUint8x64Binary(t, simd.Uint8x64.Max, maxSlice[uint8])
   130  		testUint16x32Binary(t, simd.Uint16x32.Max, maxSlice[uint16])
   131  		testUint32x16Binary(t, simd.Uint32x16.Max, maxSlice[uint32])
   132  		testUint64x8Binary(t, simd.Uint64x8.Max, maxSlice[uint64])
   133  	}
   134  }
   135  
   136  func TestMin(t *testing.T) {
   137  	// testFloat32x4Binary(t, simd.Float32x4.Min, minSlice[float32]) // nan is wrong
   138  	// testFloat32x8Binary(t, simd.Float32x8.Min, minSlice[float32]) // nan is wrong
   139  	// testFloat64x2Binary(t, simd.Float64x2.Min, minSlice[float64]) // nan is wrong
   140  	// testFloat64x4Binary(t, simd.Float64x4.Min, minSlice[float64]) // nan is wrong
   141  
   142  	testInt16x16Binary(t, simd.Int16x16.Min, minSlice[int16])
   143  	testInt16x8Binary(t, simd.Int16x8.Min, minSlice[int16])
   144  	testInt32x4Binary(t, simd.Int32x4.Min, minSlice[int32])
   145  	testInt32x8Binary(t, simd.Int32x8.Min, minSlice[int32])
   146  
   147  	if simd.X86.AVX512() {
   148  		testInt64x2Binary(t, simd.Int64x2.Min, minSlice[int64])
   149  		testInt64x4Binary(t, simd.Int64x4.Min, minSlice[int64])
   150  	}
   151  
   152  	testInt8x16Binary(t, simd.Int8x16.Min, minSlice[int8])
   153  	testInt8x32Binary(t, simd.Int8x32.Min, minSlice[int8])
   154  
   155  	testUint16x16Binary(t, simd.Uint16x16.Min, minSlice[uint16])
   156  	testUint16x8Binary(t, simd.Uint16x8.Min, minSlice[uint16])
   157  	testUint32x4Binary(t, simd.Uint32x4.Min, minSlice[uint32])
   158  	testUint32x8Binary(t, simd.Uint32x8.Min, minSlice[uint32])
   159  
   160  	if simd.X86.AVX512() {
   161  		testUint64x2Binary(t, simd.Uint64x2.Min, minSlice[uint64])
   162  		testUint64x4Binary(t, simd.Uint64x4.Min, minSlice[uint64])
   163  	}
   164  
   165  	testUint8x16Binary(t, simd.Uint8x16.Min, minSlice[uint8])
   166  	testUint8x32Binary(t, simd.Uint8x32.Min, minSlice[uint8])
   167  
   168  	if simd.X86.AVX512() {
   169  		// testFloat32x16Binary(t, simd.Float32x16.Min, minSlice[float32]) // nan is wrong
   170  		// testFloat64x8Binary(t, simd.Float64x8.Min, minSlice[float64]) // nan is wrong
   171  		testInt8x64Binary(t, simd.Int8x64.Min, minSlice[int8])
   172  		testInt16x32Binary(t, simd.Int16x32.Min, minSlice[int16])
   173  		testInt32x16Binary(t, simd.Int32x16.Min, minSlice[int32])
   174  		testInt64x8Binary(t, simd.Int64x8.Min, minSlice[int64])
   175  		testUint8x64Binary(t, simd.Uint8x64.Min, minSlice[uint8])
   176  		testUint16x32Binary(t, simd.Uint16x32.Min, minSlice[uint16])
   177  		testUint32x16Binary(t, simd.Uint32x16.Min, minSlice[uint32])
   178  		testUint64x8Binary(t, simd.Uint64x8.Min, minSlice[uint64])
   179  	}
   180  }
   181  
   182  func TestAnd(t *testing.T) {
   183  	testInt16x16Binary(t, simd.Int16x16.And, andSlice[int16])
   184  	testInt16x8Binary(t, simd.Int16x8.And, andSlice[int16])
   185  	testInt32x4Binary(t, simd.Int32x4.And, andSlice[int32])
   186  	testInt32x8Binary(t, simd.Int32x8.And, andSlice[int32])
   187  	testInt64x2Binary(t, simd.Int64x2.And, andSlice[int64])
   188  	testInt64x4Binary(t, simd.Int64x4.And, andSlice[int64])
   189  	testInt8x16Binary(t, simd.Int8x16.And, andSlice[int8])
   190  	testInt8x32Binary(t, simd.Int8x32.And, andSlice[int8])
   191  
   192  	testUint16x16Binary(t, simd.Uint16x16.And, andSlice[uint16])
   193  	testUint16x8Binary(t, simd.Uint16x8.And, andSlice[uint16])
   194  	testUint32x4Binary(t, simd.Uint32x4.And, andSlice[uint32])
   195  	testUint32x8Binary(t, simd.Uint32x8.And, andSlice[uint32])
   196  	testUint64x2Binary(t, simd.Uint64x2.And, andSlice[uint64])
   197  	testUint64x4Binary(t, simd.Uint64x4.And, andSlice[uint64])
   198  	testUint8x16Binary(t, simd.Uint8x16.And, andSlice[uint8])
   199  	testUint8x32Binary(t, simd.Uint8x32.And, andSlice[uint8])
   200  
   201  	if simd.X86.AVX512() {
   202  		//	testInt8x64Binary(t, simd.Int8x64.And, andISlice[int8]) // missing
   203  		//	testInt16x32Binary(t, simd.Int16x32.And, andISlice[int16]) // missing
   204  		testInt32x16Binary(t, simd.Int32x16.And, andSlice[int32])
   205  		testInt64x8Binary(t, simd.Int64x8.And, andSlice[int64])
   206  		//	testUint8x64Binary(t, simd.Uint8x64.And, andISlice[uint8]) // missing
   207  		//	testUint16x32Binary(t, simd.Uint16x32.And, andISlice[uint16]) // missing
   208  		testUint32x16Binary(t, simd.Uint32x16.And, andSlice[uint32])
   209  		testUint64x8Binary(t, simd.Uint64x8.And, andSlice[uint64])
   210  	}
   211  }
   212  
   213  func TestAndNot(t *testing.T) {
   214  	testInt16x16Binary(t, simd.Int16x16.AndNot, andNotSlice[int16])
   215  	testInt16x8Binary(t, simd.Int16x8.AndNot, andNotSlice[int16])
   216  	testInt32x4Binary(t, simd.Int32x4.AndNot, andNotSlice[int32])
   217  	testInt32x8Binary(t, simd.Int32x8.AndNot, andNotSlice[int32])
   218  	testInt64x2Binary(t, simd.Int64x2.AndNot, andNotSlice[int64])
   219  	testInt64x4Binary(t, simd.Int64x4.AndNot, andNotSlice[int64])
   220  	testInt8x16Binary(t, simd.Int8x16.AndNot, andNotSlice[int8])
   221  	testInt8x32Binary(t, simd.Int8x32.AndNot, andNotSlice[int8])
   222  
   223  	testUint16x16Binary(t, simd.Uint16x16.AndNot, andNotSlice[uint16])
   224  	testUint16x8Binary(t, simd.Uint16x8.AndNot, andNotSlice[uint16])
   225  	testUint32x4Binary(t, simd.Uint32x4.AndNot, andNotSlice[uint32])
   226  	testUint32x8Binary(t, simd.Uint32x8.AndNot, andNotSlice[uint32])
   227  	testUint64x2Binary(t, simd.Uint64x2.AndNot, andNotSlice[uint64])
   228  	testUint64x4Binary(t, simd.Uint64x4.AndNot, andNotSlice[uint64])
   229  	testUint8x16Binary(t, simd.Uint8x16.AndNot, andNotSlice[uint8])
   230  	testUint8x32Binary(t, simd.Uint8x32.AndNot, andNotSlice[uint8])
   231  
   232  	if simd.X86.AVX512() {
   233  		testInt8x64Binary(t, simd.Int8x64.AndNot, andNotSlice[int8])
   234  		testInt16x32Binary(t, simd.Int16x32.AndNot, andNotSlice[int16])
   235  		testInt32x16Binary(t, simd.Int32x16.AndNot, andNotSlice[int32])
   236  		testInt64x8Binary(t, simd.Int64x8.AndNot, andNotSlice[int64])
   237  		testUint8x64Binary(t, simd.Uint8x64.AndNot, andNotSlice[uint8])
   238  		testUint16x32Binary(t, simd.Uint16x32.AndNot, andNotSlice[uint16])
   239  		testUint32x16Binary(t, simd.Uint32x16.AndNot, andNotSlice[uint32])
   240  		testUint64x8Binary(t, simd.Uint64x8.AndNot, andNotSlice[uint64])
   241  	}
   242  }
   243  
   244  func TestXor(t *testing.T) {
   245  	testInt16x16Binary(t, simd.Int16x16.Xor, xorSlice[int16])
   246  	testInt16x8Binary(t, simd.Int16x8.Xor, xorSlice[int16])
   247  	testInt32x4Binary(t, simd.Int32x4.Xor, xorSlice[int32])
   248  	testInt32x8Binary(t, simd.Int32x8.Xor, xorSlice[int32])
   249  	testInt64x2Binary(t, simd.Int64x2.Xor, xorSlice[int64])
   250  	testInt64x4Binary(t, simd.Int64x4.Xor, xorSlice[int64])
   251  	testInt8x16Binary(t, simd.Int8x16.Xor, xorSlice[int8])
   252  	testInt8x32Binary(t, simd.Int8x32.Xor, xorSlice[int8])
   253  
   254  	testUint16x16Binary(t, simd.Uint16x16.Xor, xorSlice[uint16])
   255  	testUint16x8Binary(t, simd.Uint16x8.Xor, xorSlice[uint16])
   256  	testUint32x4Binary(t, simd.Uint32x4.Xor, xorSlice[uint32])
   257  	testUint32x8Binary(t, simd.Uint32x8.Xor, xorSlice[uint32])
   258  	testUint64x2Binary(t, simd.Uint64x2.Xor, xorSlice[uint64])
   259  	testUint64x4Binary(t, simd.Uint64x4.Xor, xorSlice[uint64])
   260  	testUint8x16Binary(t, simd.Uint8x16.Xor, xorSlice[uint8])
   261  	testUint8x32Binary(t, simd.Uint8x32.Xor, xorSlice[uint8])
   262  
   263  	if simd.X86.AVX512() {
   264  		//	testInt8x64Binary(t, simd.Int8x64.Xor, andISlice[int8]) // missing
   265  		//	testInt16x32Binary(t, simd.Int16x32.Xor, andISlice[int16]) // missing
   266  		testInt32x16Binary(t, simd.Int32x16.Xor, xorSlice[int32])
   267  		testInt64x8Binary(t, simd.Int64x8.Xor, xorSlice[int64])
   268  		//	testUint8x64Binary(t, simd.Uint8x64.Xor, andISlice[uint8]) // missing
   269  		//	testUint16x32Binary(t, simd.Uint16x32.Xor, andISlice[uint16]) // missing
   270  		testUint32x16Binary(t, simd.Uint32x16.Xor, xorSlice[uint32])
   271  		testUint64x8Binary(t, simd.Uint64x8.Xor, xorSlice[uint64])
   272  	}
   273  }
   274  
   275  func TestOr(t *testing.T) {
   276  	testInt16x16Binary(t, simd.Int16x16.Or, orSlice[int16])
   277  	testInt16x8Binary(t, simd.Int16x8.Or, orSlice[int16])
   278  	testInt32x4Binary(t, simd.Int32x4.Or, orSlice[int32])
   279  	testInt32x8Binary(t, simd.Int32x8.Or, orSlice[int32])
   280  	testInt64x2Binary(t, simd.Int64x2.Or, orSlice[int64])
   281  	testInt64x4Binary(t, simd.Int64x4.Or, orSlice[int64])
   282  	testInt8x16Binary(t, simd.Int8x16.Or, orSlice[int8])
   283  	testInt8x32Binary(t, simd.Int8x32.Or, orSlice[int8])
   284  
   285  	testUint16x16Binary(t, simd.Uint16x16.Or, orSlice[uint16])
   286  	testUint16x8Binary(t, simd.Uint16x8.Or, orSlice[uint16])
   287  	testUint32x4Binary(t, simd.Uint32x4.Or, orSlice[uint32])
   288  	testUint32x8Binary(t, simd.Uint32x8.Or, orSlice[uint32])
   289  	testUint64x2Binary(t, simd.Uint64x2.Or, orSlice[uint64])
   290  	testUint64x4Binary(t, simd.Uint64x4.Or, orSlice[uint64])
   291  	testUint8x16Binary(t, simd.Uint8x16.Or, orSlice[uint8])
   292  	testUint8x32Binary(t, simd.Uint8x32.Or, orSlice[uint8])
   293  
   294  	if simd.X86.AVX512() {
   295  		//	testInt8x64Binary(t, simd.Int8x64.Or, andISlice[int8]) // missing
   296  		//	testInt16x32Binary(t, simd.Int16x32.Or, andISlice[int16]) // missing
   297  		testInt32x16Binary(t, simd.Int32x16.Or, orSlice[int32])
   298  		testInt64x8Binary(t, simd.Int64x8.Or, orSlice[int64])
   299  		//	testUint8x64Binary(t, simd.Uint8x64.Or, andISlice[uint8]) // missing
   300  		//	testUint16x32Binary(t, simd.Uint16x32.Or, andISlice[uint16]) // missing
   301  		testUint32x16Binary(t, simd.Uint32x16.Or, orSlice[uint32])
   302  		testUint64x8Binary(t, simd.Uint64x8.Or, orSlice[uint64])
   303  	}
   304  }
   305  
   306  func TestMul(t *testing.T) {
   307  	testFloat32x4Binary(t, simd.Float32x4.Mul, mulSlice[float32])
   308  	testFloat32x8Binary(t, simd.Float32x8.Mul, mulSlice[float32])
   309  	testFloat64x2Binary(t, simd.Float64x2.Mul, mulSlice[float64])
   310  	testFloat64x4Binary(t, simd.Float64x4.Mul, mulSlice[float64])
   311  
   312  	testInt16x16Binary(t, simd.Int16x16.Mul, mulSlice[int16])
   313  	testInt16x8Binary(t, simd.Int16x8.Mul, mulSlice[int16])
   314  	testInt32x4Binary(t, simd.Int32x4.Mul, mulSlice[int32])
   315  	testInt32x8Binary(t, simd.Int32x8.Mul, mulSlice[int32])
   316  
   317  	// testInt8x16Binary(t, simd.Int8x16.Mul, mulSlice[int8]) // nope
   318  	// testInt8x32Binary(t, simd.Int8x32.Mul, mulSlice[int8])
   319  
   320  	// TODO we should be able to do these, there's no difference between signed/unsigned Mul
   321  	// testUint16x16Binary(t, simd.Uint16x16.Mul, mulSlice[uint16])
   322  	// testUint16x8Binary(t, simd.Uint16x8.Mul, mulSlice[uint16])
   323  	// testUint32x4Binary(t, simd.Uint32x4.Mul, mulSlice[uint32])
   324  	// testUint32x8Binary(t, simd.Uint32x8.Mul, mulSlice[uint32])
   325  	// testUint64x2Binary(t, simd.Uint64x2.Mul, mulSlice[uint64])
   326  	// testUint64x4Binary(t, simd.Uint64x4.Mul, mulSlice[uint64])
   327  
   328  	// testUint8x16Binary(t, simd.Uint8x16.Mul, mulSlice[uint8]) // nope
   329  	// testUint8x32Binary(t, simd.Uint8x32.Mul, mulSlice[uint8])
   330  
   331  	if simd.X86.AVX512() {
   332  		testInt64x2Binary(t, simd.Int64x2.Mul, mulSlice[int64]) // avx512 only
   333  		testInt64x4Binary(t, simd.Int64x4.Mul, mulSlice[int64])
   334  
   335  		testFloat32x16Binary(t, simd.Float32x16.Mul, mulSlice[float32])
   336  		testFloat64x8Binary(t, simd.Float64x8.Mul, mulSlice[float64])
   337  
   338  		// testInt8x64Binary(t, simd.Int8x64.Mul, mulSlice[int8]) // nope
   339  		testInt16x32Binary(t, simd.Int16x32.Mul, mulSlice[int16])
   340  		testInt32x16Binary(t, simd.Int32x16.Mul, mulSlice[int32])
   341  		testInt64x8Binary(t, simd.Int64x8.Mul, mulSlice[int64])
   342  		// testUint8x64Binary(t, simd.Uint8x64.Mul, mulSlice[uint8]) // nope
   343  
   344  		// TODO signed should do the job
   345  		// testUint16x32Binary(t, simd.Uint16x32.Mul, mulSlice[uint16])
   346  		// testUint32x16Binary(t, simd.Uint32x16.Mul, mulSlice[uint32])
   347  		// testUint64x8Binary(t, simd.Uint64x8.Mul, mulSlice[uint64])
   348  	}
   349  }
   350  
   351  func TestDiv(t *testing.T) {
   352  	testFloat32x4Binary(t, simd.Float32x4.Div, divSlice[float32])
   353  	testFloat32x8Binary(t, simd.Float32x8.Div, divSlice[float32])
   354  	testFloat64x2Binary(t, simd.Float64x2.Div, divSlice[float64])
   355  	testFloat64x4Binary(t, simd.Float64x4.Div, divSlice[float64])
   356  
   357  	if simd.X86.AVX512() {
   358  		testFloat32x16Binary(t, simd.Float32x16.Div, divSlice[float32])
   359  		testFloat64x8Binary(t, simd.Float64x8.Div, divSlice[float64])
   360  	}
   361  }
   362
View as plain text