Source file src/simd/simd_emulated.go

     1  // Copyright 2026 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 || wasm || arm64)
     6  
     7  package simd
     8  
     9  import (
    10  	"internal/strconv"
    11  	"math"
    12  	"math/bits"
    13  )
    14  
    15  // VectorBitSize returns the bit length of the emulated vector (fixed to 128).
    16  func VectorBitSize() int {
    17  	return 128
    18  }
    19  
    20  // Emulated returns whether simd is emulated.
    21  func Emulated() bool {
    22  	return true
    23  }
    24  
    25  // HasHardwareCarrylessMultiply returns whether this platform
    26  // has a hardware-implemented version of carryless multiply.
    27  // With default GODEBUG=simd settings, if this is false,
    28  // it is emulated and merely slow, but with non-default settings
    29  // this can indicate the possibility of a missing instruction
    30  // that will fail ("SIGILL") if it is executed.
    31  func HasHardwareCarrylessMultiply() bool {
    32  	return false
    33  }
    34  
    35  type number interface {
    36  	~int8 | ~int16 | ~int32 | ~int64 | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64
    37  }
    38  
    39  func sliceToString[T number](x []T) string {
    40  	s := ""
    41  	pfx := "{"
    42  	for _, y := range x {
    43  		s += pfx
    44  		pfx = ","
    45  		switch e := any(y).(type) {
    46  		case int8:
    47  			s += strconv.Itoa(int(e))
    48  		case int16:
    49  			s += strconv.Itoa(int(e))
    50  		case int32:
    51  			s += strconv.Itoa(int(e))
    52  		case int64:
    53  			s += strconv.FormatInt(int64(e), 10)
    54  		case uint8:
    55  			s += strconv.FormatUint(uint64(e), 10)
    56  		case uint16:
    57  			s += strconv.FormatUint(uint64(e), 10)
    58  		case uint32:
    59  			s += strconv.FormatUint(uint64(e), 10)
    60  		case uint64:
    61  			s += strconv.FormatUint(uint64(e), 10)
    62  		case float32:
    63  			s += strconv.FormatFloat(float64(e), 'g', -1, 32)
    64  		case float64:
    65  			s += strconv.FormatFloat(e, 'g', -1, 64)
    66  		}
    67  	}
    68  	s += "}"
    69  	return s
    70  }
    71  
    72  // LoadInt8s loads a slice of int8 into an Int8s vector.
    73  func LoadInt8s(s []int8) Int8s {
    74  	var a, b uint64
    75  	for i := 0; i < 16; i++ {
    76  		val := uint64(uint8(s[i]))
    77  		if i < 8 {
    78  			a |= val << (8 * i)
    79  		} else {
    80  			b |= val << (8 * (i - 8))
    81  		}
    82  	}
    83  	return Int8s{a: a, b: b}
    84  }
    85  
    86  // LoadInt8sPart loads a partial slice of int8 into an Int8s vector.
    87  func LoadInt8sPart(s []int8) (Int8s, int) {
    88  	var a, b uint64
    89  	n := len(s)
    90  	if n > 16 {
    91  		n = 16
    92  	}
    93  	for i := 0; i < n; i++ {
    94  		val := uint64(uint8(s[i]))
    95  		if i < 8 {
    96  			a |= val << (8 * i)
    97  		} else {
    98  			b |= val << (8 * (i - 8))
    99  		}
   100  	}
   101  	return Int8s{a: a, b: b}, n
   102  }
   103  
   104  func (x Int8s) get(i int) int8 {
   105  	if i < 8 {
   106  		return int8(x.a >> (8 * i))
   107  	}
   108  	return int8(x.b >> (8 * (i - 8)))
   109  }
   110  
   111  func (x *Int8s) set(i int, v int8) {
   112  	val := uint64(uint8(v))
   113  	if i < 8 {
   114  		mask := uint64(0xff) << (8 * i)
   115  		x.a = (x.a &^ mask) | (val << (8 * i))
   116  	} else {
   117  		mask := uint64(0xff) << (8 * (i - 8))
   118  		x.b = (x.b &^ mask) | (val << (8 * (i - 8)))
   119  	}
   120  }
   121  
   122  // Abs returns the element-wise absolute value of x.
   123  func (x Int8s) Abs() Int8s {
   124  	var res Int8s
   125  	for i := 0; i < 16; i++ {
   126  		v := x.get(i)
   127  		if v < 0 {
   128  			res.set(i, -v)
   129  		} else {
   130  			res.set(i, v)
   131  		}
   132  	}
   133  	return res
   134  }
   135  
   136  // Add returns the element-wise sum of x and y.
   137  func (x Int8s) Add(y Int8s) Int8s {
   138  	var res Int8s
   139  	for i := 0; i < 16; i++ {
   140  		res.set(i, x.get(i)+y.get(i))
   141  	}
   142  	return res
   143  }
   144  
   145  // AddSaturated returns the element-wise saturated sum of x and y.
   146  func (x Int8s) AddSaturated(y Int8s) Int8s {
   147  	var res Int8s
   148  	for i := 0; i < 16; i++ {
   149  		sum := int(x.get(i)) + int(y.get(i))
   150  		if sum > math.MaxInt8 {
   151  			res.set(i, math.MaxInt8)
   152  		} else if sum < math.MinInt8 {
   153  			res.set(i, math.MinInt8)
   154  		} else {
   155  			res.set(i, int8(sum))
   156  		}
   157  	}
   158  	return res
   159  }
   160  
   161  // And returns the bitwise AND of x and y.
   162  func (x Int8s) And(y Int8s) Int8s {
   163  	return Int8s{a: x.a & y.a, b: x.b & y.b}
   164  }
   165  
   166  // AndNot returns the bitwise AND NOT of x and y.
   167  func (x Int8s) AndNot(y Int8s) Int8s {
   168  	return Int8s{a: x.a &^ y.a, b: x.b &^ y.b}
   169  }
   170  
   171  // Equal returns a mask indicating where x and y are equal.
   172  func (x Int8s) Equal(y Int8s) Mask8s {
   173  	var res Mask8s
   174  	for i := 0; i < 16; i++ {
   175  		if x.get(i) == y.get(i) {
   176  			res.set(i, true)
   177  		}
   178  	}
   179  	return res
   180  }
   181  
   182  // Greater returns a mask indicating where x is greater than y.
   183  func (x Int8s) Greater(y Int8s) Mask8s {
   184  	var res Mask8s
   185  	for i := 0; i < 16; i++ {
   186  		if x.get(i) > y.get(i) {
   187  			res.set(i, true)
   188  		}
   189  	}
   190  	return res
   191  }
   192  
   193  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
   194  func (x Int8s) GreaterEqual(y Int8s) Mask8s {
   195  	var res Mask8s
   196  	for i := 0; i < 16; i++ {
   197  		if x.get(i) >= y.get(i) {
   198  			res.set(i, true)
   199  		}
   200  	}
   201  	return res
   202  }
   203  
   204  // Less returns a mask indicating where x is less than y.
   205  func (x Int8s) Less(y Int8s) Mask8s {
   206  	var res Mask8s
   207  	for i := 0; i < 16; i++ {
   208  		if x.get(i) < y.get(i) {
   209  			res.set(i, true)
   210  		}
   211  	}
   212  	return res
   213  }
   214  
   215  // LessEqual returns a mask indicating where x is less than or equal to y.
   216  func (x Int8s) LessEqual(y Int8s) Mask8s {
   217  	var res Mask8s
   218  	for i := 0; i < 16; i++ {
   219  		if x.get(i) <= y.get(i) {
   220  			res.set(i, true)
   221  		}
   222  	}
   223  	return res
   224  }
   225  
   226  // NotEqual returns a mask indicating where x and y are not equal.
   227  func (x Int8s) NotEqual(y Int8s) Mask8s {
   228  	var res Mask8s
   229  	for i := 0; i < 16; i++ {
   230  		if x.get(i) != y.get(i) {
   231  			res.set(i, true)
   232  		}
   233  	}
   234  	return res
   235  }
   236  
   237  // Len returns the number of elements in the vector.
   238  func (x Int8s) Len() int {
   239  	return 16
   240  }
   241  
   242  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
   243  func (x Int8s) Masked(mask Mask8s) Int8s {
   244  	return Int8s{a: x.a & mask.a, b: x.b & mask.b}
   245  }
   246  
   247  // Max returns the element-wise maximum of x and y.
   248  func (x Int8s) Max(y Int8s) Int8s {
   249  	var res Int8s
   250  	for i := 0; i < 16; i++ {
   251  		vx := x.get(i)
   252  		vy := y.get(i)
   253  		if vx > vy {
   254  			res.set(i, vx)
   255  		} else {
   256  			res.set(i, vy)
   257  		}
   258  	}
   259  	return res
   260  }
   261  
   262  // Mul returns the element-wise product of x and y.
   263  func (x Int8s) Mul(y Int8s) Int8s {
   264  	var res Int8s
   265  	for i := 0; i < 16; i++ {
   266  		res.set(i, x.get(i)*y.get(i))
   267  	}
   268  	return res
   269  }
   270  
   271  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
   272  func (x Int8s) IfElse(mask Mask8s, y Int8s) Int8s {
   273  	return Int8s{
   274  		a: (x.a & mask.a) | (y.a &^ mask.a),
   275  		b: (x.b & mask.b) | (y.b &^ mask.b),
   276  	}
   277  }
   278  
   279  // Min returns the element-wise minimum of x and y.
   280  func (x Int8s) Min(y Int8s) Int8s {
   281  	var res Int8s
   282  	for i := 0; i < 16; i++ {
   283  		vx := x.get(i)
   284  		vy := y.get(i)
   285  		if vx < vy {
   286  			res.set(i, vx)
   287  		} else {
   288  			res.set(i, vy)
   289  		}
   290  	}
   291  	return res
   292  }
   293  
   294  // Neg returns the element-wise negation of x.
   295  func (x Int8s) Neg() Int8s {
   296  	var res Int8s
   297  	for i := 0; i < 16; i++ {
   298  		res.set(i, -x.get(i))
   299  	}
   300  	return res
   301  }
   302  
   303  // Not returns the bitwise NOT of x.
   304  func (x Int8s) Not() Int8s {
   305  	return Int8s{a: ^x.a, b: ^x.b}
   306  }
   307  
   308  // Or returns the bitwise OR of x and y.
   309  func (x Int8s) Or(y Int8s) Int8s {
   310  	return Int8s{a: x.a | y.a, b: x.b | y.b}
   311  }
   312  
   313  // Store stores the vector elements into the slice s.
   314  func (x Int8s) Store(s []int8) {
   315  	for i := 0; i < 16 && i < len(s); i++ {
   316  		s[i] = x.get(i)
   317  	}
   318  }
   319  
   320  // StorePart stores a partial vector into the slice s.
   321  func (x Int8s) StorePart(s []int8) int {
   322  	x.Store(s)
   323  	return min(len(s), x.Len())
   324  }
   325  
   326  // String returns a string representation of the vector.
   327  func (x Int8s) String() string {
   328  	var parts [16]int8
   329  	for i := 0; i < 16; i++ {
   330  		parts[i] = x.get(i)
   331  	}
   332  	return sliceToString(parts[:])
   333  }
   334  
   335  // Sub returns the element-wise difference of x and y.
   336  func (x Int8s) Sub(y Int8s) Int8s {
   337  	var res Int8s
   338  	for i := 0; i < 16; i++ {
   339  		res.set(i, x.get(i)-y.get(i))
   340  	}
   341  	return res
   342  }
   343  
   344  // SubSaturated returns the element-wise saturated difference of x and y.
   345  func (x Int8s) SubSaturated(y Int8s) Int8s {
   346  	var res Int8s
   347  	for i := 0; i < 16; i++ {
   348  		diff := int(x.get(i)) - int(y.get(i))
   349  		if diff > math.MaxInt8 {
   350  			res.set(i, math.MaxInt8)
   351  		} else if diff < math.MinInt8 {
   352  			res.set(i, math.MinInt8)
   353  		} else {
   354  			res.set(i, int8(diff))
   355  		}
   356  	}
   357  	return res
   358  }
   359  
   360  // ToMask returns a mask representation of the vector.
   361  func (x Int8s) ToMask() Mask8s {
   362  	var res Mask8s
   363  	for i := 0; i < 16; i++ {
   364  		if x.get(i) != 0 {
   365  			res.set(i, true)
   366  		}
   367  	}
   368  	return res
   369  }
   370  
   371  // Xor returns the bitwise XOR of x and y.
   372  func (x Int8s) Xor(y Int8s) Int8s {
   373  	return Int8s{a: x.a ^ y.a, b: x.b ^ y.b}
   374  }
   375  
   376  // ConvertToUint8 converts the vector elements to uint8.
   377  func (x Int8s) ConvertToUint8() Uint8s {
   378  	return Uint8s{a: x.a, b: x.b}
   379  }
   380  
   381  // ToBits reinterprets the vector bits as a Uint8s vector.
   382  func (x Int8s) ToBits() Uint8s {
   383  	return Uint8s{a: x.a, b: x.b}
   384  }
   385  
   386  // LoadInt16s loads a slice of int16 into an Int16s vector.
   387  func LoadInt16s(s []int16) Int16s {
   388  	var a, b uint64
   389  	for i := 0; i < 8; i++ {
   390  		val := uint64(uint16(s[i]))
   391  		if i < 4 {
   392  			a |= val << (16 * i)
   393  		} else {
   394  			b |= val << (16 * (i - 4))
   395  		}
   396  	}
   397  	return Int16s{a: a, b: b}
   398  }
   399  
   400  // LoadInt16sPart loads a partial slice of int16 into an Int16s vector.
   401  func LoadInt16sPart(s []int16) (Int16s, int) {
   402  	var a, b uint64
   403  	n := len(s)
   404  	if n > 8 {
   405  		n = 8
   406  	}
   407  	for i := 0; i < n; i++ {
   408  		val := uint64(uint16(s[i]))
   409  		if i < 4 {
   410  			a |= val << (16 * i)
   411  		} else {
   412  			b |= val << (16 * (i - 4))
   413  		}
   414  	}
   415  	return Int16s{a: a, b: b}, n
   416  }
   417  
   418  func (x Int16s) get(i int) int16 {
   419  	if i < 4 {
   420  		return int16(x.a >> (16 * i))
   421  	}
   422  	return int16(x.b >> (16 * (i - 4)))
   423  }
   424  
   425  func (x *Int16s) set(i int, v int16) {
   426  	val := uint64(uint16(v))
   427  	if i < 4 {
   428  		mask := uint64(0xffff) << (16 * i)
   429  		x.a = (x.a &^ mask) | (val << (16 * i))
   430  	} else {
   431  		mask := uint64(0xffff) << (16 * (i - 4))
   432  		x.b = (x.b &^ mask) | (val << (16 * (i - 4)))
   433  	}
   434  }
   435  
   436  // Abs returns the element-wise absolute value of x.
   437  func (x Int16s) Abs() Int16s {
   438  	var res Int16s
   439  	for i := 0; i < 8; i++ {
   440  		v := x.get(i)
   441  		if v < 0 {
   442  			res.set(i, -v)
   443  		} else {
   444  			res.set(i, v)
   445  		}
   446  	}
   447  	return res
   448  }
   449  
   450  // Add returns the element-wise sum of x and y.
   451  func (x Int16s) Add(y Int16s) Int16s {
   452  	var res Int16s
   453  	for i := 0; i < 8; i++ {
   454  		res.set(i, x.get(i)+y.get(i))
   455  	}
   456  	return res
   457  }
   458  
   459  // AddSaturated returns the element-wise saturated sum of x and y.
   460  func (x Int16s) AddSaturated(y Int16s) Int16s {
   461  	var res Int16s
   462  	for i := 0; i < 8; i++ {
   463  		sum := int(x.get(i)) + int(y.get(i))
   464  		if sum > math.MaxInt16 {
   465  			res.set(i, math.MaxInt16)
   466  		} else if sum < math.MinInt16 {
   467  			res.set(i, math.MinInt16)
   468  		} else {
   469  			res.set(i, int16(sum))
   470  		}
   471  	}
   472  	return res
   473  }
   474  
   475  // And returns the bitwise AND of x and y.
   476  func (x Int16s) And(y Int16s) Int16s {
   477  	return Int16s{a: x.a & y.a, b: x.b & y.b}
   478  }
   479  
   480  // AndNot returns the bitwise AND NOT of x and y.
   481  func (x Int16s) AndNot(y Int16s) Int16s {
   482  	return Int16s{a: x.a &^ y.a, b: x.b &^ y.b}
   483  }
   484  
   485  // Equal returns a mask indicating where x and y are equal.
   486  func (x Int16s) Equal(y Int16s) Mask16s {
   487  	var res Mask16s
   488  	for i := 0; i < 8; i++ {
   489  		if x.get(i) == y.get(i) {
   490  			res.set(i, true)
   491  		}
   492  	}
   493  	return res
   494  }
   495  
   496  // Greater returns a mask indicating where x is greater than y.
   497  func (x Int16s) Greater(y Int16s) Mask16s {
   498  	var res Mask16s
   499  	for i := 0; i < 8; i++ {
   500  		if x.get(i) > y.get(i) {
   501  			res.set(i, true)
   502  		}
   503  	}
   504  	return res
   505  }
   506  
   507  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
   508  func (x Int16s) GreaterEqual(y Int16s) Mask16s {
   509  	var res Mask16s
   510  	for i := 0; i < 8; i++ {
   511  		if x.get(i) >= y.get(i) {
   512  			res.set(i, true)
   513  		}
   514  	}
   515  	return res
   516  }
   517  
   518  // Less returns a mask indicating where x is less than y.
   519  func (x Int16s) Less(y Int16s) Mask16s {
   520  	var res Mask16s
   521  	for i := 0; i < 8; i++ {
   522  		if x.get(i) < y.get(i) {
   523  			res.set(i, true)
   524  		}
   525  	}
   526  	return res
   527  }
   528  
   529  // LessEqual returns a mask indicating where x is less than or equal to y.
   530  func (x Int16s) LessEqual(y Int16s) Mask16s {
   531  	var res Mask16s
   532  	for i := 0; i < 8; i++ {
   533  		if x.get(i) <= y.get(i) {
   534  			res.set(i, true)
   535  		}
   536  	}
   537  	return res
   538  }
   539  
   540  // NotEqual returns a mask indicating where x and y are not equal.
   541  func (x Int16s) NotEqual(y Int16s) Mask16s {
   542  	var res Mask16s
   543  	for i := 0; i < 8; i++ {
   544  		if x.get(i) != y.get(i) {
   545  			res.set(i, true)
   546  		}
   547  	}
   548  	return res
   549  }
   550  
   551  // Len returns the number of elements in the vector.
   552  func (x Int16s) Len() int {
   553  	return 8
   554  }
   555  
   556  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
   557  func (x Int16s) Masked(mask Mask16s) Int16s {
   558  	return Int16s{a: x.a & mask.a, b: x.b & mask.b}
   559  }
   560  
   561  // Max returns the element-wise maximum of x and y.
   562  func (x Int16s) Max(y Int16s) Int16s {
   563  	var res Int16s
   564  	for i := 0; i < 8; i++ {
   565  		vx := x.get(i)
   566  		vy := y.get(i)
   567  		if vx > vy {
   568  			res.set(i, vx)
   569  		} else {
   570  			res.set(i, vy)
   571  		}
   572  	}
   573  	return res
   574  }
   575  
   576  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
   577  func (x Int16s) IfElse(mask Mask16s, y Int16s) Int16s {
   578  	return Int16s{
   579  		a: (x.a & mask.a) | (y.a &^ mask.a),
   580  		b: (x.b & mask.b) | (y.b &^ mask.b),
   581  	}
   582  }
   583  
   584  // Min returns the element-wise minimum of x and y.
   585  func (x Int16s) Min(y Int16s) Int16s {
   586  	var res Int16s
   587  	for i := 0; i < 8; i++ {
   588  		vx := x.get(i)
   589  		vy := y.get(i)
   590  		if vx < vy {
   591  			res.set(i, vx)
   592  		} else {
   593  			res.set(i, vy)
   594  		}
   595  	}
   596  	return res
   597  }
   598  
   599  // Mul returns the element-wise product of x and y.
   600  func (x Int16s) Mul(y Int16s) Int16s {
   601  	var res Int16s
   602  	for i := 0; i < 8; i++ {
   603  		res.set(i, x.get(i)*y.get(i))
   604  	}
   605  	return res
   606  }
   607  
   608  // Neg returns the element-wise negation of x.
   609  func (x Int16s) Neg() Int16s {
   610  	var res Int16s
   611  	for i := 0; i < 8; i++ {
   612  		res.set(i, -x.get(i))
   613  	}
   614  	return res
   615  }
   616  
   617  // Not returns the bitwise NOT of x.
   618  func (x Int16s) Not() Int16s {
   619  	return Int16s{a: ^x.a, b: ^x.b}
   620  }
   621  
   622  // Or returns the bitwise OR of x and y.
   623  func (x Int16s) Or(y Int16s) Int16s {
   624  	return Int16s{a: x.a | y.a, b: x.b | y.b}
   625  }
   626  
   627  // ShiftAllLeft shifts all elements left by y bits.
   628  func (x Int16s) ShiftAllLeft(y uint8) Int16s {
   629  	var res Int16s
   630  	for i := 0; i < 8; i++ {
   631  		res.set(i, x.get(i)<<y)
   632  	}
   633  	return res
   634  }
   635  
   636  // ShiftAllRight shifts all elements right by y bits.
   637  func (x Int16s) ShiftAllRight(y uint8) Int16s {
   638  	var res Int16s
   639  	for i := 0; i < 8; i++ {
   640  		res.set(i, x.get(i)>>y)
   641  	}
   642  	return res
   643  }
   644  
   645  // RotateAllLeft rotates all elements left by dist bits.
   646  func (x Int16s) RotateAllLeft(dist uint64) Int16s {
   647  	var res Int16s
   648  	d := dist & 15
   649  	for i := 0; i < 8; i++ {
   650  		u := uint16(x.get(i))
   651  		r := (u << d) | (u >> ((16 - d) & 15))
   652  		res.set(i, int16(r))
   653  	}
   654  	return res
   655  }
   656  
   657  // RotateAllRight rotates all elements right by dist bits.
   658  func (x Int16s) RotateAllRight(dist uint64) Int16s {
   659  	var res Int16s
   660  	d := dist & 15
   661  	for i := 0; i < 8; i++ {
   662  		u := uint16(x.get(i))
   663  		r := (u >> d) | (u << ((16 - d) & 15))
   664  		res.set(i, int16(r))
   665  	}
   666  	return res
   667  }
   668  
   669  // Store stores the vector elements into the slice s.
   670  func (x Int16s) Store(s []int16) {
   671  	for i := 0; i < 8 && i < len(s); i++ {
   672  		s[i] = x.get(i)
   673  	}
   674  }
   675  
   676  // StorePart stores a partial vector into the slice s.
   677  func (x Int16s) StorePart(s []int16) int {
   678  	x.Store(s)
   679  	return min(len(s), x.Len())
   680  }
   681  
   682  // String returns a string representation of the vector.
   683  func (x Int16s) String() string {
   684  	var parts [8]int16
   685  	for i := 0; i < 8; i++ {
   686  		parts[i] = x.get(i)
   687  	}
   688  	return sliceToString(parts[:])
   689  }
   690  
   691  // Sub returns the element-wise difference of x and y.
   692  func (x Int16s) Sub(y Int16s) Int16s {
   693  	var res Int16s
   694  	for i := 0; i < 8; i++ {
   695  		res.set(i, x.get(i)-y.get(i))
   696  	}
   697  	return res
   698  }
   699  
   700  // SubSaturated returns the element-wise saturated difference of x and y.
   701  func (x Int16s) SubSaturated(y Int16s) Int16s {
   702  	var res Int16s
   703  	for i := 0; i < 8; i++ {
   704  		diff := int(x.get(i)) - int(y.get(i))
   705  		if diff > math.MaxInt16 {
   706  			res.set(i, math.MaxInt16)
   707  		} else if diff < math.MinInt16 {
   708  			res.set(i, math.MinInt16)
   709  		} else {
   710  			res.set(i, int16(diff))
   711  		}
   712  	}
   713  	return res
   714  }
   715  
   716  // ToMask returns a mask representation of the vector.
   717  func (x Int16s) ToMask() Mask16s {
   718  	var res Mask16s
   719  	for i := 0; i < 8; i++ {
   720  		if x.get(i) != 0 {
   721  			res.set(i, true)
   722  		}
   723  	}
   724  	return res
   725  }
   726  
   727  // Xor returns the bitwise XOR of x and y.
   728  func (x Int16s) Xor(y Int16s) Int16s {
   729  	return Int16s{a: x.a ^ y.a, b: x.b ^ y.b}
   730  }
   731  
   732  // ConvertToUint16 converts the vector elements to uint16.
   733  func (x Int16s) ConvertToUint16() Uint16s {
   734  	return Uint16s{a: x.a, b: x.b}
   735  }
   736  
   737  // ToBits reinterprets the vector bits as a Uint16s vector.
   738  func (x Int16s) ToBits() Uint16s {
   739  	return Uint16s{a: x.a, b: x.b}
   740  }
   741  
   742  // LoadInt32s loads a slice of int32 into an Int32s vector.
   743  func LoadInt32s(s []int32) Int32s {
   744  	var a, b uint64
   745  	for i := 0; i < 4; i++ {
   746  		val := uint64(uint32(s[i]))
   747  		if i < 2 {
   748  			a |= val << (32 * i)
   749  		} else {
   750  			b |= val << (32 * (i - 2))
   751  		}
   752  	}
   753  	return Int32s{a: a, b: b}
   754  }
   755  
   756  // LoadInt32sPart loads a partial slice of int32 into an Int32s vector.
   757  func LoadInt32sPart(s []int32) (Int32s, int) {
   758  	var a, b uint64
   759  	n := len(s)
   760  	if n > 4 {
   761  		n = 4
   762  	}
   763  	for i := 0; i < n; i++ {
   764  		val := uint64(uint32(s[i]))
   765  		if i < 2 {
   766  			a |= val << (32 * i)
   767  		} else {
   768  			b |= val << (32 * (i - 2))
   769  		}
   770  	}
   771  	return Int32s{a: a, b: b}, n
   772  }
   773  
   774  func (x Int32s) get(i int) int32 {
   775  	if i < 2 {
   776  		return int32(x.a >> (32 * i))
   777  	}
   778  	return int32(x.b >> (32 * (i - 2)))
   779  }
   780  
   781  func (x *Int32s) set(i int, v int32) {
   782  	val := uint64(uint32(v))
   783  	if i < 2 {
   784  		mask := uint64(0xffffffff) << (32 * i)
   785  		x.a = (x.a &^ mask) | (val << (32 * i))
   786  	} else {
   787  		mask := uint64(0xffffffff) << (32 * (i - 2))
   788  		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
   789  	}
   790  }
   791  
   792  // Abs returns the element-wise absolute value of x.
   793  func (x Int32s) Abs() Int32s {
   794  	var res Int32s
   795  	for i := 0; i < 4; i++ {
   796  		v := x.get(i)
   797  		if v < 0 {
   798  			res.set(i, -v)
   799  		} else {
   800  			res.set(i, v)
   801  		}
   802  	}
   803  	return res
   804  }
   805  
   806  // Add returns the element-wise sum of x and y.
   807  func (x Int32s) Add(y Int32s) Int32s {
   808  	var res Int32s
   809  	for i := 0; i < 4; i++ {
   810  		res.set(i, x.get(i)+y.get(i))
   811  	}
   812  	return res
   813  }
   814  
   815  // And returns the bitwise AND of x and y.
   816  func (x Int32s) And(y Int32s) Int32s {
   817  	return Int32s{a: x.a & y.a, b: x.b & y.b}
   818  }
   819  
   820  // AndNot returns the bitwise AND NOT of x and y.
   821  func (x Int32s) AndNot(y Int32s) Int32s {
   822  	return Int32s{a: x.a &^ y.a, b: x.b &^ y.b}
   823  }
   824  
   825  // ConvertToFloat32 converts the vector elements to float32.
   826  func (x Int32s) ConvertToFloat32() Float32s {
   827  	var res Float32s
   828  	for i := 0; i < 4; i++ {
   829  		res.set(i, float32(x.get(i)))
   830  	}
   831  	return res
   832  }
   833  
   834  // Equal returns a mask indicating where x and y are equal.
   835  func (x Int32s) Equal(y Int32s) Mask32s {
   836  	var res Mask32s
   837  	for i := 0; i < 4; i++ {
   838  		if x.get(i) == y.get(i) {
   839  			res.set(i, true)
   840  		}
   841  	}
   842  	return res
   843  }
   844  
   845  // Greater returns a mask indicating where x is greater than y.
   846  func (x Int32s) Greater(y Int32s) Mask32s {
   847  	var res Mask32s
   848  	for i := 0; i < 4; i++ {
   849  		if x.get(i) > y.get(i) {
   850  			res.set(i, true)
   851  		}
   852  	}
   853  	return res
   854  }
   855  
   856  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
   857  func (x Int32s) GreaterEqual(y Int32s) Mask32s {
   858  	var res Mask32s
   859  	for i := 0; i < 4; i++ {
   860  		if x.get(i) >= y.get(i) {
   861  			res.set(i, true)
   862  		}
   863  	}
   864  	return res
   865  }
   866  
   867  // Less returns a mask indicating where x is less than y.
   868  func (x Int32s) Less(y Int32s) Mask32s {
   869  	var res Mask32s
   870  	for i := 0; i < 4; i++ {
   871  		if x.get(i) < y.get(i) {
   872  			res.set(i, true)
   873  		}
   874  	}
   875  	return res
   876  }
   877  
   878  // LessEqual returns a mask indicating where x is less than or equal to y.
   879  func (x Int32s) LessEqual(y Int32s) Mask32s {
   880  	var res Mask32s
   881  	for i := 0; i < 4; i++ {
   882  		if x.get(i) <= y.get(i) {
   883  			res.set(i, true)
   884  		}
   885  	}
   886  	return res
   887  }
   888  
   889  // NotEqual returns a mask indicating where x and y are not equal.
   890  func (x Int32s) NotEqual(y Int32s) Mask32s {
   891  	var res Mask32s
   892  	for i := 0; i < 4; i++ {
   893  		if x.get(i) != y.get(i) {
   894  			res.set(i, true)
   895  		}
   896  	}
   897  	return res
   898  }
   899  
   900  // Len returns the number of elements in the vector.
   901  func (x Int32s) Len() int {
   902  	return 4
   903  }
   904  
   905  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
   906  func (x Int32s) Masked(mask Mask32s) Int32s {
   907  	return Int32s{a: x.a & mask.a, b: x.b & mask.b}
   908  }
   909  
   910  // Max returns the element-wise maximum of x and y.
   911  func (x Int32s) Max(y Int32s) Int32s {
   912  	var res Int32s
   913  	for i := 0; i < 4; i++ {
   914  		vx := x.get(i)
   915  		vy := y.get(i)
   916  		if vx > vy {
   917  			res.set(i, vx)
   918  		} else {
   919  			res.set(i, vy)
   920  		}
   921  	}
   922  	return res
   923  }
   924  
   925  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
   926  func (x Int32s) IfElse(mask Mask32s, y Int32s) Int32s {
   927  	return Int32s{
   928  		a: (x.a & mask.a) | (y.a &^ mask.a),
   929  		b: (x.b & mask.b) | (y.b &^ mask.b),
   930  	}
   931  }
   932  
   933  // Min returns the element-wise minimum of x and y.
   934  func (x Int32s) Min(y Int32s) Int32s {
   935  	var res Int32s
   936  	for i := 0; i < 4; i++ {
   937  		vx := x.get(i)
   938  		vy := y.get(i)
   939  		if vx < vy {
   940  			res.set(i, vx)
   941  		} else {
   942  			res.set(i, vy)
   943  		}
   944  	}
   945  	return res
   946  }
   947  
   948  // Mul returns the element-wise product of x and y.
   949  func (x Int32s) Mul(y Int32s) Int32s {
   950  	var res Int32s
   951  	for i := 0; i < 4; i++ {
   952  		res.set(i, x.get(i)*y.get(i))
   953  	}
   954  	return res
   955  }
   956  
   957  // Neg returns the element-wise negation of x.
   958  func (x Int32s) Neg() Int32s {
   959  	var res Int32s
   960  	for i := 0; i < 4; i++ {
   961  		res.set(i, -x.get(i))
   962  	}
   963  	return res
   964  }
   965  
   966  // Not returns the bitwise NOT of x.
   967  func (x Int32s) Not() Int32s {
   968  	return Int32s{a: ^x.a, b: ^x.b}
   969  }
   970  
   971  // Or returns the bitwise OR of x and y.
   972  func (x Int32s) Or(y Int32s) Int32s {
   973  	return Int32s{a: x.a | y.a, b: x.b | y.b}
   974  }
   975  
   976  // ShiftAllLeft shifts all elements left by y bits.
   977  func (x Int32s) ShiftAllLeft(y uint8) Int32s {
   978  	var res Int32s
   979  	for i := 0; i < 4; i++ {
   980  		res.set(i, x.get(i)<<y)
   981  	}
   982  	return res
   983  }
   984  
   985  // ShiftAllRight shifts all elements right by y bits.
   986  func (x Int32s) ShiftAllRight(y uint8) Int32s {
   987  	var res Int32s
   988  	for i := 0; i < 4; i++ {
   989  		res.set(i, x.get(i)>>y)
   990  	}
   991  	return res
   992  }
   993  
   994  // RotateAllLeft rotates all elements left by dist bits.
   995  func (x Int32s) RotateAllLeft(dist uint64) Int32s {
   996  	var res Int32s
   997  	d := dist & 31
   998  	for i := 0; i < 4; i++ {
   999  		u := uint32(x.get(i))
  1000  		r := (u << d) | (u >> ((32 - d) & 31))
  1001  		res.set(i, int32(r))
  1002  	}
  1003  	return res
  1004  }
  1005  
  1006  // RotateAllRight rotates all elements right by dist bits.
  1007  func (x Int32s) RotateAllRight(dist uint64) Int32s {
  1008  	var res Int32s
  1009  	d := dist & 31
  1010  	for i := 0; i < 4; i++ {
  1011  		u := uint32(x.get(i))
  1012  		r := (u >> d) | (u << ((32 - d) & 31))
  1013  		res.set(i, int32(r))
  1014  	}
  1015  	return res
  1016  }
  1017  
  1018  // Store stores the vector elements into the slice s.
  1019  func (x Int32s) Store(s []int32) {
  1020  	for i := 0; i < 4 && i < len(s); i++ {
  1021  		s[i] = x.get(i)
  1022  	}
  1023  }
  1024  
  1025  // StorePart stores a partial vector into the slice s.
  1026  func (x Int32s) StorePart(s []int32) int {
  1027  	x.Store(s)
  1028  	return min(len(s), x.Len())
  1029  }
  1030  
  1031  // String returns a string representation of the vector.
  1032  func (x Int32s) String() string {
  1033  	var parts [4]int32
  1034  	for i := 0; i < 4; i++ {
  1035  		parts[i] = x.get(i)
  1036  	}
  1037  	return sliceToString(parts[:])
  1038  }
  1039  
  1040  // Sub returns the element-wise difference of x and y.
  1041  func (x Int32s) Sub(y Int32s) Int32s {
  1042  	var res Int32s
  1043  	for i := 0; i < 4; i++ {
  1044  		res.set(i, x.get(i)-y.get(i))
  1045  	}
  1046  	return res
  1047  }
  1048  
  1049  // ToMask returns a mask representation of the vector.
  1050  func (x Int32s) ToMask() Mask32s {
  1051  	var res Mask32s
  1052  	for i := 0; i < 4; i++ {
  1053  		if x.get(i) != 0 {
  1054  			res.set(i, true)
  1055  		}
  1056  	}
  1057  	return res
  1058  }
  1059  
  1060  // Xor returns the bitwise XOR of x and y.
  1061  func (x Int32s) Xor(y Int32s) Int32s {
  1062  	return Int32s{a: x.a ^ y.a, b: x.b ^ y.b}
  1063  }
  1064  
  1065  // ConvertToUint32 converts the vector elements to uint32.
  1066  func (x Int32s) ConvertToUint32() Uint32s {
  1067  	return Uint32s{a: x.a, b: x.b}
  1068  }
  1069  
  1070  // ToBits reinterprets the vector bits as a Uint32s vector.
  1071  func (x Int32s) ToBits() Uint32s {
  1072  	return Uint32s{a: x.a, b: x.b}
  1073  }
  1074  
  1075  // LoadInt64s loads a slice of int64 into an Int64s vector.
  1076  func LoadInt64s(s []int64) Int64s {
  1077  	var a, b uint64
  1078  	a = uint64(s[0])
  1079  	b = uint64(s[1])
  1080  	return Int64s{a: a, b: b}
  1081  }
  1082  
  1083  // LoadInt64sPart loads a partial slice of int64 into an Int64s vector.
  1084  func LoadInt64sPart(s []int64) (Int64s, int) {
  1085  	var a, b uint64
  1086  	if len(s) > 0 {
  1087  		a = uint64(s[0])
  1088  	}
  1089  	if len(s) > 1 {
  1090  		b = uint64(s[1])
  1091  	}
  1092  	return Int64s{a: a, b: b}, len(s)
  1093  }
  1094  
  1095  func (x Int64s) get(i int) int64 {
  1096  	if i == 0 {
  1097  		return int64(x.a)
  1098  	}
  1099  	return int64(x.b)
  1100  }
  1101  
  1102  func (x *Int64s) set(i int, v int64) {
  1103  	if i == 0 {
  1104  		x.a = uint64(v)
  1105  	} else {
  1106  		x.b = uint64(v)
  1107  	}
  1108  }
  1109  
  1110  // Add returns the element-wise sum of x and y.
  1111  func (x Int64s) Add(y Int64s) Int64s {
  1112  	return Int64s{a: x.a + y.a, b: x.b + y.b}
  1113  }
  1114  
  1115  // And returns the bitwise AND of x and y.
  1116  func (x Int64s) And(y Int64s) Int64s {
  1117  	return Int64s{a: x.a & y.a, b: x.b & y.b}
  1118  }
  1119  
  1120  // AndNot returns the bitwise AND NOT of x and y.
  1121  func (x Int64s) AndNot(y Int64s) Int64s {
  1122  	return Int64s{a: x.a &^ y.a, b: x.b &^ y.b}
  1123  }
  1124  
  1125  // Equal returns a mask indicating where x and y are equal.
  1126  func (x Int64s) Equal(y Int64s) Mask64s {
  1127  	var res Mask64s
  1128  	if x.a == y.a {
  1129  		res.a = ^uint64(0)
  1130  	}
  1131  	if x.b == y.b {
  1132  		res.b = ^uint64(0)
  1133  	}
  1134  	return res
  1135  }
  1136  
  1137  // Greater returns a mask indicating where x is greater than y.
  1138  func (x Int64s) Greater(y Int64s) Mask64s {
  1139  	var res Mask64s
  1140  	if int64(x.a) > int64(y.a) {
  1141  		res.a = ^uint64(0)
  1142  	}
  1143  	if int64(x.b) > int64(y.b) {
  1144  		res.b = ^uint64(0)
  1145  	}
  1146  	return res
  1147  }
  1148  
  1149  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  1150  func (x Int64s) GreaterEqual(y Int64s) Mask64s {
  1151  	var res Mask64s
  1152  	if int64(x.a) >= int64(y.a) {
  1153  		res.a = ^uint64(0)
  1154  	}
  1155  	if int64(x.b) >= int64(y.b) {
  1156  		res.b = ^uint64(0)
  1157  	}
  1158  	return res
  1159  }
  1160  
  1161  // Less returns a mask indicating where x is less than y.
  1162  func (x Int64s) Less(y Int64s) Mask64s {
  1163  	var res Mask64s
  1164  	if int64(x.a) < int64(y.a) {
  1165  		res.a = ^uint64(0)
  1166  	}
  1167  	if int64(x.b) < int64(y.b) {
  1168  		res.b = ^uint64(0)
  1169  	}
  1170  	return res
  1171  }
  1172  
  1173  // LessEqual returns a mask indicating where x is less than or equal to y.
  1174  func (x Int64s) LessEqual(y Int64s) Mask64s {
  1175  	var res Mask64s
  1176  	if int64(x.a) <= int64(y.a) {
  1177  		res.a = ^uint64(0)
  1178  	}
  1179  	if int64(x.b) <= int64(y.b) {
  1180  		res.b = ^uint64(0)
  1181  	}
  1182  	return res
  1183  }
  1184  
  1185  // NotEqual returns a mask indicating where x and y are not equal.
  1186  func (x Int64s) NotEqual(y Int64s) Mask64s {
  1187  	var res Mask64s
  1188  	if x.a != y.a {
  1189  		res.a = ^uint64(0)
  1190  	}
  1191  	if x.b != y.b {
  1192  		res.b = ^uint64(0)
  1193  	}
  1194  	return res
  1195  }
  1196  
  1197  // Len returns the number of elements in the vector.
  1198  func (x Int64s) Len() int {
  1199  	return 2
  1200  }
  1201  
  1202  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  1203  func (x Int64s) Masked(mask Mask64s) Int64s {
  1204  	return Int64s{a: x.a & mask.a, b: x.b & mask.b}
  1205  }
  1206  
  1207  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  1208  func (x Int64s) IfElse(mask Mask64s, y Int64s) Int64s {
  1209  	return Int64s{
  1210  		a: (x.a & mask.a) | (y.a &^ mask.a),
  1211  		b: (x.b & mask.b) | (y.b &^ mask.b),
  1212  	}
  1213  }
  1214  
  1215  // Neg returns the element-wise negation of x.
  1216  func (x Int64s) Neg() Int64s {
  1217  	return Int64s{a: uint64(-int64(x.a)), b: uint64(-int64(x.b))}
  1218  }
  1219  
  1220  // Not returns the bitwise NOT of x.
  1221  func (x Int64s) Not() Int64s {
  1222  	return Int64s{a: ^x.a, b: ^x.b}
  1223  }
  1224  
  1225  // Or returns the bitwise OR of x and y.
  1226  func (x Int64s) Or(y Int64s) Int64s {
  1227  	return Int64s{a: x.a | y.a, b: x.b | y.b}
  1228  }
  1229  
  1230  // ShiftAllLeft shifts all elements left by y bits.
  1231  func (x Int64s) ShiftAllLeft(y uint8) Int64s {
  1232  	return Int64s{a: x.a << y, b: x.b << y}
  1233  }
  1234  
  1235  // RotateAllLeft rotates all elements left by dist bits.
  1236  func (x Int64s) RotateAllLeft(dist uint64) Int64s {
  1237  	d := dist & 63
  1238  	return Int64s{
  1239  		a: (x.a << d) | (x.a >> ((64 - d) & 63)),
  1240  		b: (x.b << d) | (x.b >> ((64 - d) & 63)),
  1241  	}
  1242  }
  1243  
  1244  // RotateAllRight rotates all elements right by dist bits.
  1245  func (x Int64s) RotateAllRight(dist uint64) Int64s {
  1246  	d := dist & 63
  1247  	return Int64s{
  1248  		a: (x.a >> d) | (x.a << ((64 - d) & 63)),
  1249  		b: (x.b >> d) | (x.b << ((64 - d) & 63)),
  1250  	}
  1251  }
  1252  
  1253  // Store stores the vector elements into the slice s.
  1254  func (x Int64s) Store(s []int64) {
  1255  	if len(s) > 0 {
  1256  		s[0] = int64(x.a)
  1257  	}
  1258  	if len(s) > 1 {
  1259  		s[1] = int64(x.b)
  1260  	}
  1261  }
  1262  
  1263  // StorePart stores a partial vector into the slice s.
  1264  func (x Int64s) StorePart(s []int64) int {
  1265  	x.Store(s)
  1266  	return min(len(s), x.Len())
  1267  }
  1268  
  1269  // String returns a string representation of the vector.
  1270  func (x Int64s) String() string {
  1271  	return sliceToString([]int64{int64(x.a), int64(x.b)})
  1272  }
  1273  
  1274  // Sub returns the element-wise difference of x and y.
  1275  func (x Int64s) Sub(y Int64s) Int64s {
  1276  	return Int64s{a: x.a - y.a, b: x.b - y.b}
  1277  }
  1278  
  1279  // ToMask returns a mask representation of the vector.
  1280  func (x Int64s) ToMask() Mask64s {
  1281  	var res Mask64s
  1282  	if x.a != 0 {
  1283  		res.a = ^uint64(0)
  1284  	}
  1285  	if x.b != 0 {
  1286  		res.b = ^uint64(0)
  1287  	}
  1288  	return res
  1289  }
  1290  
  1291  // Xor returns the bitwise XOR of x and y.
  1292  func (x Int64s) Xor(y Int64s) Int64s {
  1293  	return Int64s{a: x.a ^ y.a, b: x.b ^ y.b}
  1294  }
  1295  
  1296  // ConvertToUint64 converts the vector elements to uint64.
  1297  func (x Int64s) ConvertToUint64() Uint64s {
  1298  	return Uint64s{a: x.a, b: x.b}
  1299  }
  1300  
  1301  // ToBits reinterprets the vector bits as a Uint64s vector.
  1302  func (x Int64s) ToBits() Uint64s {
  1303  	return Uint64s{a: x.a, b: x.b}
  1304  }
  1305  
  1306  // LoadUint8s loads a slice of uint8 into an Uint8s vector.
  1307  func LoadUint8s(s []uint8) Uint8s {
  1308  	var a, b uint64
  1309  	for i := 0; i < 16; i++ {
  1310  		val := uint64(s[i])
  1311  		if i < 8 {
  1312  			a |= val << (8 * i)
  1313  		} else {
  1314  			b |= val << (8 * (i - 8))
  1315  		}
  1316  	}
  1317  	return Uint8s{a: a, b: b}
  1318  }
  1319  
  1320  // LoadUint8sPart loads a partial slice of uint8 into an Uint8s vector.
  1321  func LoadUint8sPart(s []uint8) (Uint8s, int) {
  1322  	var a, b uint64
  1323  	n := len(s)
  1324  	if n > 16 {
  1325  		n = 16
  1326  	}
  1327  	for i := 0; i < n; i++ {
  1328  		val := uint64(s[i])
  1329  		if i < 8 {
  1330  			a |= val << (8 * i)
  1331  		} else {
  1332  			b |= val << (8 * (i - 8))
  1333  		}
  1334  	}
  1335  	return Uint8s{a: a, b: b}, n
  1336  }
  1337  
  1338  func (x Uint8s) get(i int) uint8 {
  1339  	if i < 8 {
  1340  		return uint8(x.a >> (8 * i))
  1341  	}
  1342  	return uint8(x.b >> (8 * (i - 8)))
  1343  }
  1344  
  1345  func (x *Uint8s) set(i int, v uint8) {
  1346  	val := uint64(v)
  1347  	if i < 8 {
  1348  		mask := uint64(0xff) << (8 * i)
  1349  		x.a = (x.a &^ mask) | (val << (8 * i))
  1350  	} else {
  1351  		mask := uint64(0xff) << (8 * (i - 8))
  1352  		x.b = (x.b &^ mask) | (val << (8 * (i - 8)))
  1353  	}
  1354  }
  1355  
  1356  // Add returns the element-wise sum of x and y.
  1357  func (x Uint8s) Add(y Uint8s) Uint8s {
  1358  	var res Uint8s
  1359  	for i := 0; i < 16; i++ {
  1360  		res.set(i, x.get(i)+y.get(i))
  1361  	}
  1362  	return res
  1363  }
  1364  
  1365  // AddSaturated returns the element-wise saturated sum of x and y.
  1366  func (x Uint8s) AddSaturated(y Uint8s) Uint8s {
  1367  	var res Uint8s
  1368  	for i := 0; i < 16; i++ {
  1369  		sum := int(x.get(i)) + int(y.get(i))
  1370  		if sum > math.MaxUint8 {
  1371  			res.set(i, math.MaxUint8)
  1372  		} else {
  1373  			res.set(i, uint8(sum))
  1374  		}
  1375  	}
  1376  	return res
  1377  }
  1378  
  1379  // And returns the bitwise AND of x and y.
  1380  func (x Uint8s) And(y Uint8s) Uint8s {
  1381  	return Uint8s{a: x.a & y.a, b: x.b & y.b}
  1382  }
  1383  
  1384  // AndNot returns the bitwise AND NOT of x and y.
  1385  func (x Uint8s) AndNot(y Uint8s) Uint8s {
  1386  	return Uint8s{a: x.a &^ y.a, b: x.b &^ y.b}
  1387  }
  1388  
  1389  // Average returns the element-wise average of x and y.
  1390  func (x Uint8s) Average(y Uint8s) Uint8s {
  1391  	var res Uint8s
  1392  	for i := 0; i < 16; i++ {
  1393  		res.set(i, uint8((int(x.get(i))+int(y.get(i))+1)>>1))
  1394  	}
  1395  	return res
  1396  }
  1397  
  1398  // Equal returns a mask indicating where x and y are equal.
  1399  func (x Uint8s) Equal(y Uint8s) Mask8s {
  1400  	var res Mask8s
  1401  	for i := 0; i < 16; i++ {
  1402  		if x.get(i) == y.get(i) {
  1403  			res.set(i, true)
  1404  		}
  1405  	}
  1406  	return res
  1407  }
  1408  
  1409  // NotEqual returns a mask indicating where x and y are not equal.
  1410  func (x Uint8s) NotEqual(y Uint8s) Mask8s {
  1411  	var res Mask8s
  1412  	for i := 0; i < 16; i++ {
  1413  		if x.get(i) != y.get(i) {
  1414  			res.set(i, true)
  1415  		}
  1416  	}
  1417  	return res
  1418  }
  1419  
  1420  // Len returns the number of elements in the vector.
  1421  func (x Uint8s) Len() int {
  1422  	return 16
  1423  }
  1424  
  1425  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  1426  func (x Uint8s) Masked(mask Mask8s) Uint8s {
  1427  	return Uint8s{a: x.a & mask.a, b: x.b & mask.b}
  1428  }
  1429  
  1430  // Max returns the element-wise maximum of x and y.
  1431  func (x Uint8s) Max(y Uint8s) Uint8s {
  1432  	var res Uint8s
  1433  	for i := 0; i < 16; i++ {
  1434  		vx := x.get(i)
  1435  		vy := y.get(i)
  1436  		if vx > vy {
  1437  			res.set(i, vx)
  1438  		} else {
  1439  			res.set(i, vy)
  1440  		}
  1441  	}
  1442  	return res
  1443  }
  1444  
  1445  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  1446  func (x Uint8s) IfElse(mask Mask8s, y Uint8s) Uint8s {
  1447  	return Uint8s{
  1448  		a: (x.a & mask.a) | (y.a &^ mask.a),
  1449  		b: (x.b & mask.b) | (y.b &^ mask.b),
  1450  	}
  1451  }
  1452  
  1453  // Min returns the element-wise minimum of x and y.
  1454  func (x Uint8s) Min(y Uint8s) Uint8s {
  1455  	var res Uint8s
  1456  	for i := 0; i < 16; i++ {
  1457  		vx := x.get(i)
  1458  		vy := y.get(i)
  1459  		if vx < vy {
  1460  			res.set(i, vx)
  1461  		} else {
  1462  			res.set(i, vy)
  1463  		}
  1464  	}
  1465  	return res
  1466  }
  1467  
  1468  // Mul returns the element-wise product of x and y.
  1469  func (x Uint8s) Mul(y Uint8s) Uint8s {
  1470  	var res Uint8s
  1471  	for i := 0; i < 16; i++ {
  1472  		res.set(i, x.get(i)*y.get(i))
  1473  	}
  1474  	return res
  1475  }
  1476  
  1477  // Not returns the bitwise NOT of x.
  1478  func (x Uint8s) Not() Uint8s {
  1479  	return Uint8s{a: ^x.a, b: ^x.b}
  1480  }
  1481  
  1482  // Or returns the bitwise OR of x and y.
  1483  func (x Uint8s) Or(y Uint8s) Uint8s {
  1484  	return Uint8s{a: x.a | y.a, b: x.b | y.b}
  1485  }
  1486  
  1487  // Store stores the vector elements into the slice s.
  1488  func (x Uint8s) Store(s []uint8) {
  1489  	for i := 0; i < 16 && i < len(s); i++ {
  1490  		s[i] = x.get(i)
  1491  	}
  1492  }
  1493  
  1494  // StorePart stores a partial vector into the slice s.
  1495  func (x Uint8s) StorePart(s []uint8) int {
  1496  	x.Store(s)
  1497  	return min(len(s), x.Len())
  1498  }
  1499  
  1500  // String returns a string representation of the vector.
  1501  func (x Uint8s) String() string {
  1502  	var parts [16]uint8
  1503  	for i := 0; i < 16; i++ {
  1504  		parts[i] = x.get(i)
  1505  	}
  1506  	return sliceToString(parts[:])
  1507  }
  1508  
  1509  // Sub returns the element-wise difference of x and y.
  1510  func (x Uint8s) Sub(y Uint8s) Uint8s {
  1511  	var res Uint8s
  1512  	for i := 0; i < 16; i++ {
  1513  		res.set(i, x.get(i)-y.get(i))
  1514  	}
  1515  	return res
  1516  }
  1517  
  1518  // SubSaturated returns the element-wise saturated difference of x and y.
  1519  func (x Uint8s) SubSaturated(y Uint8s) Uint8s {
  1520  	var res Uint8s
  1521  	for i := 0; i < 16; i++ {
  1522  		vx := x.get(i)
  1523  		vy := y.get(i)
  1524  		if vx < vy {
  1525  			res.set(i, 0)
  1526  		} else {
  1527  			res.set(i, vx-vy)
  1528  		}
  1529  	}
  1530  	return res
  1531  }
  1532  
  1533  // Xor returns the bitwise XOR of x and y.
  1534  func (x Uint8s) Xor(y Uint8s) Uint8s {
  1535  	return Uint8s{a: x.a ^ y.a, b: x.b ^ y.b}
  1536  }
  1537  
  1538  // BitsToInt8 reinterprets the vector bits as an Int8s vector.
  1539  func (x Uint8s) BitsToInt8() Int8s {
  1540  	return Int8s{a: x.a, b: x.b}
  1541  }
  1542  
  1543  // ConvertToInt8 converts the vector elements to int8.
  1544  func (x Uint8s) ConvertToInt8() Int8s {
  1545  	return Int8s{a: x.a, b: x.b}
  1546  }
  1547  
  1548  // ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
  1549  func (x Uint8s) ReshapeToUint16s() Uint16s {
  1550  	return Uint16s{a: x.a, b: x.b}
  1551  }
  1552  
  1553  // ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
  1554  func (x Uint8s) ReshapeToUint32s() Uint32s {
  1555  	return Uint32s{a: x.a, b: x.b}
  1556  }
  1557  
  1558  // ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
  1559  func (x Uint8s) ReshapeToUint64s() Uint64s {
  1560  	return Uint64s{a: x.a, b: x.b}
  1561  }
  1562  
  1563  // LoadUint16s loads a slice of uint16 into an Uint16s vector.
  1564  func LoadUint16s(s []uint16) Uint16s {
  1565  	var a, b uint64
  1566  	for i := 0; i < 8; i++ {
  1567  		val := uint64(s[i])
  1568  		if i < 4 {
  1569  			a |= val << (16 * i)
  1570  		} else {
  1571  			b |= val << (16 * (i - 4))
  1572  		}
  1573  	}
  1574  	return Uint16s{a: a, b: b}
  1575  }
  1576  
  1577  // LoadUint16sPart loads a partial slice of uint16 into an Uint16s vector.
  1578  func LoadUint16sPart(s []uint16) (Uint16s, int) {
  1579  	var a, b uint64
  1580  	n := len(s)
  1581  	if n > 8 {
  1582  		n = 8
  1583  	}
  1584  	for i := 0; i < n; i++ {
  1585  		val := uint64(s[i])
  1586  		if i < 4 {
  1587  			a |= val << (16 * i)
  1588  		} else {
  1589  			b |= val << (16 * (i - 4))
  1590  		}
  1591  	}
  1592  	return Uint16s{a: a, b: b}, n
  1593  }
  1594  
  1595  func (x Uint16s) get(i int) uint16 {
  1596  	if i < 4 {
  1597  		return uint16(x.a >> (16 * i))
  1598  	}
  1599  	return uint16(x.b >> (16 * (i - 4)))
  1600  }
  1601  
  1602  func (x *Uint16s) set(i int, v uint16) {
  1603  	val := uint64(v)
  1604  	if i < 4 {
  1605  		mask := uint64(0xffff) << (16 * i)
  1606  		x.a = (x.a &^ mask) | (val << (16 * i))
  1607  	} else {
  1608  		mask := uint64(0xffff) << (16 * (i - 4))
  1609  		x.b = (x.b &^ mask) | (val << (16 * (i - 4)))
  1610  	}
  1611  }
  1612  
  1613  // Add returns the element-wise sum of x and y.
  1614  func (x Uint16s) Add(y Uint16s) Uint16s {
  1615  	var res Uint16s
  1616  	for i := 0; i < 8; i++ {
  1617  		res.set(i, x.get(i)+y.get(i))
  1618  	}
  1619  	return res
  1620  }
  1621  
  1622  // AddSaturated returns the element-wise saturated sum of x and y.
  1623  func (x Uint16s) AddSaturated(y Uint16s) Uint16s {
  1624  	var res Uint16s
  1625  	for i := 0; i < 8; i++ {
  1626  		sum := int(x.get(i)) + int(y.get(i))
  1627  		if sum > math.MaxUint16 {
  1628  			res.set(i, math.MaxUint16)
  1629  		} else {
  1630  			res.set(i, uint16(sum))
  1631  		}
  1632  	}
  1633  	return res
  1634  }
  1635  
  1636  // And returns the bitwise AND of x and y.
  1637  func (x Uint16s) And(y Uint16s) Uint16s {
  1638  	return Uint16s{a: x.a & y.a, b: x.b & y.b}
  1639  }
  1640  
  1641  // AndNot returns the bitwise AND NOT of x and y.
  1642  func (x Uint16s) AndNot(y Uint16s) Uint16s {
  1643  	return Uint16s{a: x.a &^ y.a, b: x.b &^ y.b}
  1644  }
  1645  
  1646  // Average returns the element-wise average of x and y.
  1647  func (x Uint16s) Average(y Uint16s) Uint16s {
  1648  	var res Uint16s
  1649  	for i := 0; i < 8; i++ {
  1650  		res.set(i, uint16((int(x.get(i))+int(y.get(i))+1)>>1))
  1651  	}
  1652  	return res
  1653  }
  1654  
  1655  // Equal returns a mask indicating where x and y are equal.
  1656  func (x Uint16s) Equal(y Uint16s) Mask16s {
  1657  	var res Mask16s
  1658  	for i := 0; i < 8; i++ {
  1659  		if x.get(i) == y.get(i) {
  1660  			res.set(i, true)
  1661  		}
  1662  	}
  1663  	return res
  1664  }
  1665  
  1666  // Greater returns a mask indicating where x is greater than y.
  1667  func (x Uint16s) Greater(y Uint16s) Mask16s {
  1668  	var res Mask16s
  1669  	for i := 0; i < 8; i++ {
  1670  		if x.get(i) > y.get(i) {
  1671  			res.set(i, true)
  1672  		}
  1673  	}
  1674  	return res
  1675  }
  1676  
  1677  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  1678  func (x Uint16s) GreaterEqual(y Uint16s) Mask16s {
  1679  	var res Mask16s
  1680  	for i := 0; i < 8; i++ {
  1681  		if x.get(i) >= y.get(i) {
  1682  			res.set(i, true)
  1683  		}
  1684  	}
  1685  	return res
  1686  }
  1687  
  1688  // Less returns a mask indicating where x is less than y.
  1689  func (x Uint16s) Less(y Uint16s) Mask16s {
  1690  	var res Mask16s
  1691  	for i := 0; i < 8; i++ {
  1692  		if x.get(i) < y.get(i) {
  1693  			res.set(i, true)
  1694  		}
  1695  	}
  1696  	return res
  1697  }
  1698  
  1699  // LessEqual returns a mask indicating where x is less than or equal to y.
  1700  func (x Uint16s) LessEqual(y Uint16s) Mask16s {
  1701  	var res Mask16s
  1702  	for i := 0; i < 8; i++ {
  1703  		if x.get(i) <= y.get(i) {
  1704  			res.set(i, true)
  1705  		}
  1706  	}
  1707  	return res
  1708  }
  1709  
  1710  // NotEqual returns a mask indicating where x and y are not equal.
  1711  func (x Uint16s) NotEqual(y Uint16s) Mask16s {
  1712  	var res Mask16s
  1713  	for i := 0; i < 8; i++ {
  1714  		if x.get(i) != y.get(i) {
  1715  			res.set(i, true)
  1716  		}
  1717  	}
  1718  	return res
  1719  }
  1720  
  1721  // Len returns the number of elements in the vector.
  1722  func (x Uint16s) Len() int {
  1723  	return 8
  1724  }
  1725  
  1726  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  1727  func (x Uint16s) Masked(mask Mask16s) Uint16s {
  1728  	return Uint16s{a: x.a & mask.a, b: x.b & mask.b}
  1729  }
  1730  
  1731  // Max returns the element-wise maximum of x and y.
  1732  func (x Uint16s) Max(y Uint16s) Uint16s {
  1733  	var res Uint16s
  1734  	for i := 0; i < 8; i++ {
  1735  		vx := x.get(i)
  1736  		vy := y.get(i)
  1737  		if vx > vy {
  1738  			res.set(i, vx)
  1739  		} else {
  1740  			res.set(i, vy)
  1741  		}
  1742  	}
  1743  	return res
  1744  }
  1745  
  1746  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  1747  func (x Uint16s) IfElse(mask Mask16s, y Uint16s) Uint16s {
  1748  	return Uint16s{
  1749  		a: (x.a & mask.a) | (y.a &^ mask.a),
  1750  		b: (x.b & mask.b) | (y.b &^ mask.b),
  1751  	}
  1752  }
  1753  
  1754  // Min returns the element-wise minimum of x and y.
  1755  func (x Uint16s) Min(y Uint16s) Uint16s {
  1756  	var res Uint16s
  1757  	for i := 0; i < 8; i++ {
  1758  		vx := x.get(i)
  1759  		vy := y.get(i)
  1760  		if vx < vy {
  1761  			res.set(i, vx)
  1762  		} else {
  1763  			res.set(i, vy)
  1764  		}
  1765  	}
  1766  	return res
  1767  }
  1768  
  1769  // Mul returns the element-wise product of x and y.
  1770  func (x Uint16s) Mul(y Uint16s) Uint16s {
  1771  	var res Uint16s
  1772  	for i := 0; i < 8; i++ {
  1773  		res.set(i, x.get(i)*y.get(i))
  1774  	}
  1775  	return res
  1776  }
  1777  
  1778  // Not returns the bitwise NOT of x.
  1779  func (x Uint16s) Not() Uint16s {
  1780  	return Uint16s{a: ^x.a, b: ^x.b}
  1781  }
  1782  
  1783  // Or returns the bitwise OR of x and y.
  1784  func (x Uint16s) Or(y Uint16s) Uint16s {
  1785  	return Uint16s{a: x.a | y.a, b: x.b | y.b}
  1786  }
  1787  
  1788  // ShiftAllLeft shifts all elements left by y bits.
  1789  func (x Uint16s) ShiftAllLeft(y uint8) Uint16s {
  1790  	var res Uint16s
  1791  	for i := 0; i < 8; i++ {
  1792  		res.set(i, x.get(i)<<y)
  1793  	}
  1794  	return res
  1795  }
  1796  
  1797  // ShiftAllRight shifts all elements right by y bits.
  1798  func (x Uint16s) ShiftAllRight(y uint8) Uint16s {
  1799  	var res Uint16s
  1800  	for i := 0; i < 8; i++ {
  1801  		res.set(i, x.get(i)>>y)
  1802  	}
  1803  	return res
  1804  }
  1805  
  1806  // RotateAllLeft rotates all elements left by dist bits.
  1807  func (x Uint16s) RotateAllLeft(dist uint64) Uint16s {
  1808  	var res Uint16s
  1809  	d := dist & 15
  1810  	for i := 0; i < 8; i++ {
  1811  		u := x.get(i)
  1812  		r := (u << d) | (u >> ((16 - d) & 15))
  1813  		res.set(i, r)
  1814  	}
  1815  	return res
  1816  }
  1817  
  1818  // RotateAllRight rotates all elements right by dist bits.
  1819  func (x Uint16s) RotateAllRight(dist uint64) Uint16s {
  1820  	var res Uint16s
  1821  	d := dist & 15
  1822  	for i := 0; i < 8; i++ {
  1823  		u := x.get(i)
  1824  		r := (u >> d) | (u << ((16 - d) & 15))
  1825  		res.set(i, r)
  1826  	}
  1827  	return res
  1828  }
  1829  
  1830  // Store stores the vector elements into the slice s.
  1831  func (x Uint16s) Store(s []uint16) {
  1832  	for i := 0; i < 8 && i < len(s); i++ {
  1833  		s[i] = x.get(i)
  1834  	}
  1835  }
  1836  
  1837  // StorePart stores a partial vector into the slice s.
  1838  func (x Uint16s) StorePart(s []uint16) int {
  1839  	x.Store(s)
  1840  	return min(len(s), x.Len())
  1841  }
  1842  
  1843  // String returns a string representation of the vector.
  1844  func (x Uint16s) String() string {
  1845  	var parts [8]uint16
  1846  	for i := 0; i < 8; i++ {
  1847  		parts[i] = x.get(i)
  1848  	}
  1849  	return sliceToString(parts[:])
  1850  }
  1851  
  1852  // Sub returns the element-wise difference of x and y.
  1853  func (x Uint16s) Sub(y Uint16s) Uint16s {
  1854  	var res Uint16s
  1855  	for i := 0; i < 8; i++ {
  1856  		res.set(i, x.get(i)-y.get(i))
  1857  	}
  1858  	return res
  1859  }
  1860  
  1861  // SubSaturated returns the element-wise saturated difference of x and y.
  1862  func (x Uint16s) SubSaturated(y Uint16s) Uint16s {
  1863  	var res Uint16s
  1864  	for i := 0; i < 8; i++ {
  1865  		vx := x.get(i)
  1866  		vy := y.get(i)
  1867  		if vx < vy {
  1868  			res.set(i, 0)
  1869  		} else {
  1870  			res.set(i, vx-vy)
  1871  		}
  1872  	}
  1873  	return res
  1874  }
  1875  
  1876  // Xor returns the bitwise XOR of x and y.
  1877  func (x Uint16s) Xor(y Uint16s) Uint16s {
  1878  	return Uint16s{a: x.a ^ y.a, b: x.b ^ y.b}
  1879  }
  1880  
  1881  // BitsToInt16 reinterprets the vector bits as an Int16s vector.
  1882  func (x Uint16s) BitsToInt16() Int16s {
  1883  	return Int16s{a: x.a, b: x.b}
  1884  }
  1885  
  1886  // ConvertToInt16 converts the vector elements to int16.
  1887  func (x Uint16s) ConvertToInt16() Int16s {
  1888  	return Int16s{a: x.a, b: x.b}
  1889  }
  1890  
  1891  // ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
  1892  func (x Uint16s) ReshapeToUint32s() Uint32s {
  1893  	return Uint32s{a: x.a, b: x.b}
  1894  }
  1895  
  1896  // ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
  1897  func (x Uint16s) ReshapeToUint64s() Uint64s {
  1898  	return Uint64s{a: x.a, b: x.b}
  1899  }
  1900  
  1901  // ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
  1902  func (x Uint16s) ReshapeToUint8s() Uint8s {
  1903  	return Uint8s{a: x.a, b: x.b}
  1904  }
  1905  
  1906  // LoadUint32s loads a slice of uint32 into an Uint32s vector.
  1907  func LoadUint32s(s []uint32) Uint32s {
  1908  	var a, b uint64
  1909  	for i := 0; i < 4; i++ {
  1910  		val := uint64(s[i])
  1911  		if i < 2 {
  1912  			a |= val << (32 * i)
  1913  		} else {
  1914  			b |= val << (32 * (i - 2))
  1915  		}
  1916  	}
  1917  	return Uint32s{a: a, b: b}
  1918  }
  1919  
  1920  // LoadUint32sPart loads a partial slice of uint32 into an Uint32s vector.
  1921  func LoadUint32sPart(s []uint32) (Uint32s, int) {
  1922  	var a, b uint64
  1923  	n := len(s)
  1924  	if n > 4 {
  1925  		n = 4
  1926  	}
  1927  	for i := 0; i < n; i++ {
  1928  		val := uint64(s[i])
  1929  		if i < 2 {
  1930  			a |= val << (32 * i)
  1931  		} else {
  1932  			b |= val << (32 * (i - 2))
  1933  		}
  1934  	}
  1935  	return Uint32s{a: a, b: b}, n
  1936  }
  1937  
  1938  func (x Uint32s) get(i int) uint32 {
  1939  	if i < 2 {
  1940  		return uint32(x.a >> (32 * i))
  1941  	}
  1942  	return uint32(x.b >> (32 * (i - 2)))
  1943  }
  1944  
  1945  func (x *Uint32s) set(i int, v uint32) {
  1946  	val := uint64(v)
  1947  	if i < 2 {
  1948  		mask := uint64(0xffffffff) << (32 * i)
  1949  		x.a = (x.a &^ mask) | (val << (32 * i))
  1950  	} else {
  1951  		mask := uint64(0xffffffff) << (32 * (i - 2))
  1952  		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
  1953  	}
  1954  }
  1955  
  1956  // Add returns the element-wise sum of x and y.
  1957  func (x Uint32s) Add(y Uint32s) Uint32s {
  1958  	var res Uint32s
  1959  	for i := 0; i < 4; i++ {
  1960  		res.set(i, x.get(i)+y.get(i))
  1961  	}
  1962  	return res
  1963  }
  1964  
  1965  // And returns the bitwise AND of x and y.
  1966  func (x Uint32s) And(y Uint32s) Uint32s {
  1967  	return Uint32s{a: x.a & y.a, b: x.b & y.b}
  1968  }
  1969  
  1970  // AndNot returns the bitwise AND NOT of x and y.
  1971  func (x Uint32s) AndNot(y Uint32s) Uint32s {
  1972  	return Uint32s{a: x.a &^ y.a, b: x.b &^ y.b}
  1973  }
  1974  
  1975  // Equal returns a mask indicating where x and y are equal.
  1976  func (x Uint32s) Equal(y Uint32s) Mask32s {
  1977  	var res Mask32s
  1978  	for i := 0; i < 4; i++ {
  1979  		if x.get(i) == y.get(i) {
  1980  			res.set(i, true)
  1981  		}
  1982  	}
  1983  	return res
  1984  }
  1985  
  1986  // Greater returns a mask indicating where x is greater than y.
  1987  func (x Uint32s) Greater(y Uint32s) Mask32s {
  1988  	var res Mask32s
  1989  	for i := 0; i < 4; i++ {
  1990  		if x.get(i) > y.get(i) {
  1991  			res.set(i, true)
  1992  		}
  1993  	}
  1994  	return res
  1995  }
  1996  
  1997  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  1998  func (x Uint32s) GreaterEqual(y Uint32s) Mask32s {
  1999  	var res Mask32s
  2000  	for i := 0; i < 4; i++ {
  2001  		if x.get(i) >= y.get(i) {
  2002  			res.set(i, true)
  2003  		}
  2004  	}
  2005  	return res
  2006  }
  2007  
  2008  // Less returns a mask indicating where x is less than y.
  2009  func (x Uint32s) Less(y Uint32s) Mask32s {
  2010  	var res Mask32s
  2011  	for i := 0; i < 4; i++ {
  2012  		if x.get(i) < y.get(i) {
  2013  			res.set(i, true)
  2014  		}
  2015  	}
  2016  	return res
  2017  }
  2018  
  2019  // LessEqual returns a mask indicating where x is less than or equal to y.
  2020  func (x Uint32s) LessEqual(y Uint32s) Mask32s {
  2021  	var res Mask32s
  2022  	for i := 0; i < 4; i++ {
  2023  		if x.get(i) <= y.get(i) {
  2024  			res.set(i, true)
  2025  		}
  2026  	}
  2027  	return res
  2028  }
  2029  
  2030  // NotEqual returns a mask indicating where x and y are not equal.
  2031  func (x Uint32s) NotEqual(y Uint32s) Mask32s {
  2032  	var res Mask32s
  2033  	for i := 0; i < 4; i++ {
  2034  		if x.get(i) != y.get(i) {
  2035  			res.set(i, true)
  2036  		}
  2037  	}
  2038  	return res
  2039  }
  2040  
  2041  // Len returns the number of elements in the vector.
  2042  func (x Uint32s) Len() int {
  2043  	return 4
  2044  }
  2045  
  2046  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  2047  func (x Uint32s) Masked(mask Mask32s) Uint32s {
  2048  	return Uint32s{a: x.a & mask.a, b: x.b & mask.b}
  2049  }
  2050  
  2051  // Max returns the element-wise maximum of x and y.
  2052  func (x Uint32s) Max(y Uint32s) Uint32s {
  2053  	var res Uint32s
  2054  	for i := 0; i < 4; i++ {
  2055  		vx := x.get(i)
  2056  		vy := y.get(i)
  2057  		if vx > vy {
  2058  			res.set(i, vx)
  2059  		} else {
  2060  			res.set(i, vy)
  2061  		}
  2062  	}
  2063  	return res
  2064  }
  2065  
  2066  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  2067  func (x Uint32s) IfElse(mask Mask32s, y Uint32s) Uint32s {
  2068  	return Uint32s{
  2069  		a: (x.a & mask.a) | (y.a &^ mask.a),
  2070  		b: (x.b & mask.b) | (y.b &^ mask.b),
  2071  	}
  2072  }
  2073  
  2074  // Min returns the element-wise minimum of x and y.
  2075  func (x Uint32s) Min(y Uint32s) Uint32s {
  2076  	var res Uint32s
  2077  	for i := 0; i < 4; i++ {
  2078  		vx := x.get(i)
  2079  		vy := y.get(i)
  2080  		if vx < vy {
  2081  			res.set(i, vx)
  2082  		} else {
  2083  			res.set(i, vy)
  2084  		}
  2085  	}
  2086  	return res
  2087  }
  2088  
  2089  // Mul returns the element-wise product of x and y.
  2090  func (x Uint32s) Mul(y Uint32s) Uint32s {
  2091  	var res Uint32s
  2092  	for i := 0; i < 4; i++ {
  2093  		res.set(i, x.get(i)*y.get(i))
  2094  	}
  2095  	return res
  2096  }
  2097  
  2098  // Not returns the bitwise NOT of x.
  2099  func (x Uint32s) Not() Uint32s {
  2100  	return Uint32s{a: ^x.a, b: ^x.b}
  2101  }
  2102  
  2103  // Or returns the bitwise OR of x and y.
  2104  func (x Uint32s) Or(y Uint32s) Uint32s {
  2105  	return Uint32s{a: x.a | y.a, b: x.b | y.b}
  2106  }
  2107  
  2108  // ShiftAllLeft shifts all elements left by y bits.
  2109  func (x Uint32s) ShiftAllLeft(y uint8) Uint32s {
  2110  	var res Uint32s
  2111  	for i := 0; i < 4; i++ {
  2112  		res.set(i, x.get(i)<<y)
  2113  	}
  2114  	return res
  2115  }
  2116  
  2117  // ShiftAllRight shifts all elements right by y bits.
  2118  func (x Uint32s) ShiftAllRight(y uint8) Uint32s {
  2119  	var res Uint32s
  2120  	for i := 0; i < 4; i++ {
  2121  		res.set(i, x.get(i)>>y)
  2122  	}
  2123  	return res
  2124  }
  2125  
  2126  // RotateAllLeft rotates all elements left by dist bits.
  2127  func (x Uint32s) RotateAllLeft(dist uint64) Uint32s {
  2128  	var res Uint32s
  2129  	d := dist & 31
  2130  	for i := 0; i < 4; i++ {
  2131  		u := x.get(i)
  2132  		r := (u << d) | (u >> ((32 - d) & 31))
  2133  		res.set(i, r)
  2134  	}
  2135  	return res
  2136  }
  2137  
  2138  // RotateAllRight rotates all elements right by dist bits.
  2139  func (x Uint32s) RotateAllRight(dist uint64) Uint32s {
  2140  	var res Uint32s
  2141  	d := dist & 31
  2142  	for i := 0; i < 4; i++ {
  2143  		u := x.get(i)
  2144  		r := (u >> d) | (u << ((32 - d) & 31))
  2145  		res.set(i, r)
  2146  	}
  2147  	return res
  2148  }
  2149  
  2150  // Store stores the vector elements into the slice s.
  2151  func (x Uint32s) Store(s []uint32) {
  2152  	for i := 0; i < 4 && i < len(s); i++ {
  2153  		s[i] = x.get(i)
  2154  	}
  2155  }
  2156  
  2157  // StorePart stores a partial vector into the slice s.
  2158  func (x Uint32s) StorePart(s []uint32) int {
  2159  	x.Store(s)
  2160  	return min(len(s), x.Len())
  2161  }
  2162  
  2163  // String returns a string representation of the vector.
  2164  func (x Uint32s) String() string {
  2165  	var parts [4]uint32
  2166  	for i := 0; i < 4; i++ {
  2167  		parts[i] = x.get(i)
  2168  	}
  2169  	return sliceToString(parts[:])
  2170  }
  2171  
  2172  // Sub returns the element-wise difference of x and y.
  2173  func (x Uint32s) Sub(y Uint32s) Uint32s {
  2174  	var res Uint32s
  2175  	for i := 0; i < 4; i++ {
  2176  		res.set(i, x.get(i)-y.get(i))
  2177  	}
  2178  	return res
  2179  }
  2180  
  2181  // Xor returns the bitwise XOR of x and y.
  2182  func (x Uint32s) Xor(y Uint32s) Uint32s {
  2183  	return Uint32s{a: x.a ^ y.a, b: x.b ^ y.b}
  2184  }
  2185  
  2186  // BitsToFloat32 reinterprets the vector bits as a Float32s vector.
  2187  func (x Uint32s) BitsToFloat32() Float32s {
  2188  	return Float32s{a: x.a, b: x.b}
  2189  }
  2190  
  2191  // BitsToInt32 reinterprets the vector bits as an Int32s vector.
  2192  func (x Uint32s) BitsToInt32() Int32s {
  2193  	return Int32s{a: x.a, b: x.b}
  2194  }
  2195  
  2196  // ConvertToInt32 converts the vector elements to int32.
  2197  func (x Uint32s) ConvertToInt32() Int32s {
  2198  	return Int32s{a: x.a, b: x.b}
  2199  }
  2200  
  2201  // ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
  2202  func (x Uint32s) ReshapeToUint16s() Uint16s {
  2203  	return Uint16s{a: x.a, b: x.b}
  2204  }
  2205  
  2206  // ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
  2207  func (x Uint32s) ReshapeToUint64s() Uint64s {
  2208  	return Uint64s{a: x.a, b: x.b}
  2209  }
  2210  
  2211  // ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
  2212  func (x Uint32s) ReshapeToUint8s() Uint8s {
  2213  	return Uint8s{a: x.a, b: x.b}
  2214  }
  2215  
  2216  // LoadUint64s loads a slice of uint64 into an Uint64s vector.
  2217  func LoadUint64s(s []uint64) Uint64s {
  2218  	var a, b uint64
  2219  	a = s[0]
  2220  	b = s[1]
  2221  	return Uint64s{a: a, b: b}
  2222  }
  2223  
  2224  // LoadUint64sPart loads a partial slice of uint64 into an Uint64s vector.
  2225  func LoadUint64sPart(s []uint64) (Uint64s, int) {
  2226  	n := len(s)
  2227  	var a, b uint64
  2228  	if n > 0 {
  2229  		a = s[0]
  2230  	}
  2231  	if n > 1 {
  2232  		b = s[1]
  2233  	}
  2234  	return Uint64s{a: a, b: b}, n
  2235  }
  2236  
  2237  func (x Uint64s) get(i int) uint64 {
  2238  	if i == 0 {
  2239  		return x.a
  2240  	}
  2241  	return x.b
  2242  }
  2243  
  2244  func (x *Uint64s) set(i int, v uint64) {
  2245  	if i == 0 {
  2246  		x.a = v
  2247  	} else {
  2248  		x.b = v
  2249  	}
  2250  }
  2251  
  2252  // Add returns the element-wise sum of x and y.
  2253  func (x Uint64s) Add(y Uint64s) Uint64s {
  2254  	return Uint64s{a: x.a + y.a, b: x.b + y.b}
  2255  }
  2256  
  2257  // And returns the bitwise AND of x and y.
  2258  func (x Uint64s) And(y Uint64s) Uint64s {
  2259  	return Uint64s{a: x.a & y.a, b: x.b & y.b}
  2260  }
  2261  
  2262  // AndNot returns the bitwise AND NOT of x and y.
  2263  func (x Uint64s) AndNot(y Uint64s) Uint64s {
  2264  	return Uint64s{a: x.a &^ y.a, b: x.b &^ y.b}
  2265  }
  2266  
  2267  // Equal returns a mask indicating where x and y are equal.
  2268  func (x Uint64s) Equal(y Uint64s) Mask64s {
  2269  	var res Mask64s
  2270  	if x.a == y.a {
  2271  		res.a = ^uint64(0)
  2272  	}
  2273  	if x.b == y.b {
  2274  		res.b = ^uint64(0)
  2275  	}
  2276  	return res
  2277  }
  2278  
  2279  // Greater returns a mask indicating where x is greater than y.
  2280  func (x Uint64s) Greater(y Uint64s) Mask64s {
  2281  	var res Mask64s
  2282  	for i := 0; i < 2; i++ {
  2283  		if x.get(i) > y.get(i) {
  2284  			res.set(i, true)
  2285  		}
  2286  	}
  2287  	return res
  2288  }
  2289  
  2290  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  2291  func (x Uint64s) GreaterEqual(y Uint64s) Mask64s {
  2292  	var res Mask64s
  2293  	for i := 0; i < 2; i++ {
  2294  		if x.get(i) >= y.get(i) {
  2295  			res.set(i, true)
  2296  		}
  2297  	}
  2298  	return res
  2299  }
  2300  
  2301  // Less returns a mask indicating where x is less than y.
  2302  func (x Uint64s) Less(y Uint64s) Mask64s {
  2303  	var res Mask64s
  2304  	for i := 0; i < 2; i++ {
  2305  		if x.get(i) < y.get(i) {
  2306  			res.set(i, true)
  2307  		}
  2308  	}
  2309  	return res
  2310  }
  2311  
  2312  // LessEqual returns a mask indicating where x is less than or equal to y.
  2313  func (x Uint64s) LessEqual(y Uint64s) Mask64s {
  2314  	var res Mask64s
  2315  	for i := 0; i < 2; i++ {
  2316  		if x.get(i) <= y.get(i) {
  2317  			res.set(i, true)
  2318  		}
  2319  	}
  2320  	return res
  2321  }
  2322  
  2323  // NotEqual returns a mask indicating where x and y are not equal.
  2324  func (x Uint64s) NotEqual(y Uint64s) Mask64s {
  2325  	var res Mask64s
  2326  	if x.a != y.a {
  2327  		res.a = ^uint64(0)
  2328  	}
  2329  	if x.b != y.b {
  2330  		res.b = ^uint64(0)
  2331  	}
  2332  	return res
  2333  }
  2334  
  2335  // Len returns the number of elements in the vector.
  2336  func (x Uint64s) Len() int {
  2337  	return 2
  2338  }
  2339  
  2340  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  2341  func (x Uint64s) Masked(mask Mask64s) Uint64s {
  2342  	return Uint64s{a: x.a & mask.a, b: x.b & mask.b}
  2343  }
  2344  
  2345  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  2346  func (x Uint64s) IfElse(mask Mask64s, y Uint64s) Uint64s {
  2347  	return Uint64s{
  2348  		a: (x.a & mask.a) | (y.a &^ mask.a),
  2349  		b: (x.b & mask.b) | (y.b &^ mask.b),
  2350  	}
  2351  }
  2352  
  2353  // Not returns the bitwise NOT of x.
  2354  func (x Uint64s) Not() Uint64s {
  2355  	return Uint64s{a: ^x.a, b: ^x.b}
  2356  }
  2357  
  2358  // Or returns the bitwise OR of x and y.
  2359  func (x Uint64s) Or(y Uint64s) Uint64s {
  2360  	return Uint64s{a: x.a | y.a, b: x.b | y.b}
  2361  }
  2362  
  2363  // ShiftAllLeft shifts all elements left by y bits.
  2364  func (x Uint64s) ShiftAllLeft(y uint8) Uint64s {
  2365  	return Uint64s{a: x.a << y, b: x.b << y}
  2366  }
  2367  
  2368  // ShiftAllRight shifts all elements right by y bits.
  2369  func (x Uint64s) ShiftAllRight(y uint8) Uint64s {
  2370  	return Uint64s{a: x.a >> y, b: x.b >> y}
  2371  }
  2372  
  2373  // RotateAllLeft rotates all elements left by dist bits.
  2374  func (x Uint64s) RotateAllLeft(dist uint64) Uint64s {
  2375  	d := dist & 63
  2376  	return Uint64s{
  2377  		a: (x.a << d) | (x.a >> ((64 - d) & 63)),
  2378  		b: (x.b << d) | (x.b >> ((64 - d) & 63)),
  2379  	}
  2380  }
  2381  
  2382  // RotateAllRight rotates all elements right by dist bits.
  2383  func (x Uint64s) RotateAllRight(dist uint64) Uint64s {
  2384  	d := dist & 63
  2385  	return Uint64s{
  2386  		a: (x.a >> d) | (x.a << ((64 - d) & 63)),
  2387  		b: (x.b >> d) | (x.b << ((64 - d) & 63)),
  2388  	}
  2389  }
  2390  
  2391  // Store stores the vector elements into the slice s.
  2392  func (x Uint64s) Store(s []uint64) {
  2393  	if len(s) > 0 {
  2394  		s[0] = x.a
  2395  	}
  2396  	if len(s) > 1 {
  2397  		s[1] = x.b
  2398  	}
  2399  }
  2400  
  2401  // StorePart stores a partial vector into the slice s.
  2402  func (x Uint64s) StorePart(s []uint64) int {
  2403  	x.Store(s)
  2404  	return min(len(s), x.Len())
  2405  }
  2406  
  2407  // String returns a string representation of the vector.
  2408  func (x Uint64s) String() string {
  2409  	return sliceToString([]uint64{x.a, x.b})
  2410  }
  2411  
  2412  // Sub returns the element-wise difference of x and y.
  2413  func (x Uint64s) Sub(y Uint64s) Uint64s {
  2414  	return Uint64s{a: x.a - y.a, b: x.b - y.b}
  2415  }
  2416  
  2417  // Xor returns the bitwise XOR of x and y.
  2418  func (x Uint64s) Xor(y Uint64s) Uint64s {
  2419  	return Uint64s{a: x.a ^ y.a, b: x.b ^ y.b}
  2420  }
  2421  
  2422  // BitsToFloat64 reinterprets the vector bits as a Float64s vector.
  2423  func (x Uint64s) BitsToFloat64() Float64s {
  2424  	return Float64s{a: x.a, b: x.b}
  2425  }
  2426  
  2427  // BitsToInt64 reinterprets the vector bits as an Int64s vector.
  2428  func (x Uint64s) BitsToInt64() Int64s {
  2429  	return Int64s{a: x.a, b: x.b}
  2430  }
  2431  
  2432  // ConvertToInt64 converts the vector elements to int64.
  2433  func (x Uint64s) ConvertToInt64() Int64s {
  2434  	return Int64s{a: x.a, b: x.b}
  2435  }
  2436  
  2437  // ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
  2438  func (x Uint64s) ReshapeToUint16s() Uint16s {
  2439  	return Uint16s{a: x.a, b: x.b}
  2440  }
  2441  
  2442  // ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
  2443  func (x Uint64s) ReshapeToUint32s() Uint32s {
  2444  	return Uint32s{a: x.a, b: x.b}
  2445  }
  2446  
  2447  // ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
  2448  func (x Uint64s) ReshapeToUint8s() Uint8s {
  2449  	return Uint8s{a: x.a, b: x.b}
  2450  }
  2451  
  2452  // LoadFloat32s loads a slice of float32 into an Float32s vector.
  2453  func LoadFloat32s(s []float32) Float32s {
  2454  	var a, b uint64
  2455  	for i := 0; i < 4; i++ {
  2456  		val := uint64(math.Float32bits(s[i]))
  2457  		if i < 2 {
  2458  			a |= val << (32 * i)
  2459  		} else {
  2460  			b |= val << (32 * (i - 2))
  2461  		}
  2462  	}
  2463  	return Float32s{a: a, b: b}
  2464  }
  2465  
  2466  // LoadFloat32sPart loads a partial slice of float32 into an Float32s vector.
  2467  func LoadFloat32sPart(s []float32) (Float32s, int) {
  2468  	var a, b uint64
  2469  	n := len(s)
  2470  	if n > 4 {
  2471  		n = 4
  2472  	}
  2473  	for i := 0; i < n; i++ {
  2474  		val := uint64(math.Float32bits(s[i]))
  2475  		if i < 2 {
  2476  			a |= val << (32 * i)
  2477  		} else {
  2478  			b |= val << (32 * (i - 2))
  2479  		}
  2480  	}
  2481  	return Float32s{a: a, b: b}, n
  2482  }
  2483  
  2484  func (x Float32s) get(i int) float32 {
  2485  	if i < 2 {
  2486  		return math.Float32frombits(uint32(x.a >> (32 * i)))
  2487  	}
  2488  	return math.Float32frombits(uint32(x.b >> (32 * (i - 2))))
  2489  }
  2490  
  2491  func (x *Float32s) set(i int, v float32) {
  2492  	val := uint64(math.Float32bits(v))
  2493  	if i < 2 {
  2494  		mask := uint64(0xffffffff) << (32 * i)
  2495  		x.a = (x.a &^ mask) | (val << (32 * i))
  2496  	} else {
  2497  		mask := uint64(0xffffffff) << (32 * (i - 2))
  2498  		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
  2499  	}
  2500  }
  2501  
  2502  // Abs returns the element-wise absolute value of x.
  2503  func (x Float32s) Abs() Float32s {
  2504  	var res Float32s
  2505  	for i := 0; i < 4; i++ {
  2506  		v := x.get(i)
  2507  		if v < 0 {
  2508  			res.set(i, -v)
  2509  		} else {
  2510  			res.set(i, v)
  2511  		}
  2512  	}
  2513  	return res
  2514  }
  2515  
  2516  // Add returns the element-wise sum of x and y.
  2517  func (x Float32s) Add(y Float32s) Float32s {
  2518  	var res Float32s
  2519  	res.set(0, x.get(0)+y.get(0))
  2520  	res.set(1, x.get(1)+y.get(1))
  2521  	res.set(2, x.get(2)+y.get(2))
  2522  	res.set(3, x.get(3)+y.get(3))
  2523  	return res
  2524  }
  2525  
  2526  // ConvertToInt32 converts the vector elements to int32.
  2527  func (x Float32s) ConvertToInt32() Int32s {
  2528  	var res Int32s
  2529  	for i := 0; i < 4; i++ {
  2530  		res.set(i, int32(x.get(i)))
  2531  	}
  2532  	return res
  2533  }
  2534  
  2535  // Div returns the element-wise quotient of x and y.
  2536  func (x Float32s) Div(y Float32s) Float32s {
  2537  	var res Float32s
  2538  	for i := 0; i < 4; i++ {
  2539  		res.set(i, x.get(i)/y.get(i))
  2540  	}
  2541  	return res
  2542  }
  2543  
  2544  // Equal returns a mask indicating where x and y are equal.
  2545  func (x Float32s) Equal(y Float32s) Mask32s {
  2546  	var res Mask32s
  2547  	for i := 0; i < 4; i++ {
  2548  		if x.get(i) == y.get(i) {
  2549  			res.set(i, true)
  2550  		}
  2551  	}
  2552  	return res
  2553  }
  2554  
  2555  // Greater returns a mask indicating where x is greater than y.
  2556  func (x Float32s) Greater(y Float32s) Mask32s {
  2557  	var res Mask32s
  2558  	for i := 0; i < 4; i++ {
  2559  		if x.get(i) > y.get(i) {
  2560  			res.set(i, true)
  2561  		}
  2562  	}
  2563  	return res
  2564  }
  2565  
  2566  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  2567  func (x Float32s) GreaterEqual(y Float32s) Mask32s {
  2568  	var res Mask32s
  2569  	for i := 0; i < 4; i++ {
  2570  		if x.get(i) >= y.get(i) {
  2571  			res.set(i, true)
  2572  		}
  2573  	}
  2574  	return res
  2575  }
  2576  
  2577  // Len returns the number of elements in the vector.
  2578  func (x Float32s) Len() int {
  2579  	return 4
  2580  }
  2581  
  2582  // Less returns a mask indicating where x is less than y.
  2583  func (x Float32s) Less(y Float32s) Mask32s {
  2584  	var res Mask32s
  2585  	for i := 0; i < 4; i++ {
  2586  		if x.get(i) < y.get(i) {
  2587  			res.set(i, true)
  2588  		}
  2589  	}
  2590  	return res
  2591  }
  2592  
  2593  // LessEqual returns a mask indicating where x is less than or equal to y.
  2594  func (x Float32s) LessEqual(y Float32s) Mask32s {
  2595  	var res Mask32s
  2596  	for i := 0; i < 4; i++ {
  2597  		if x.get(i) <= y.get(i) {
  2598  			res.set(i, true)
  2599  		}
  2600  	}
  2601  	return res
  2602  }
  2603  
  2604  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  2605  func (x Float32s) Masked(mask Mask32s) Float32s {
  2606  	return Float32s{a: x.a & mask.a, b: x.b & mask.b}
  2607  }
  2608  
  2609  // Max returns the element-wise maximum of x and y.
  2610  func (x Float32s) Max(y Float32s) Float32s {
  2611  	var res Float32s
  2612  	for i := 0; i < 4; i++ {
  2613  		vx := x.get(i)
  2614  		vy := y.get(i)
  2615  		if vx > vy {
  2616  			res.set(i, vx)
  2617  		} else {
  2618  			res.set(i, vy)
  2619  		}
  2620  	}
  2621  	return res
  2622  }
  2623  
  2624  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  2625  func (x Float32s) IfElse(mask Mask32s, y Float32s) Float32s {
  2626  	return Float32s{
  2627  		a: (x.a & mask.a) | (y.a &^ mask.a),
  2628  		b: (x.b & mask.b) | (y.b &^ mask.b),
  2629  	}
  2630  }
  2631  
  2632  // Min returns the element-wise minimum of x and y.
  2633  func (x Float32s) Min(y Float32s) Float32s {
  2634  	var res Float32s
  2635  	for i := 0; i < 4; i++ {
  2636  		vx := x.get(i)
  2637  		vy := y.get(i)
  2638  		if vx < vy {
  2639  			res.set(i, vx)
  2640  		} else {
  2641  			res.set(i, vy)
  2642  		}
  2643  	}
  2644  	return res
  2645  }
  2646  
  2647  // Mul returns the element-wise product of x and y.
  2648  func (x Float32s) Mul(y Float32s) Float32s {
  2649  	var res Float32s
  2650  	res.set(0, x.get(0)*y.get(0))
  2651  	res.set(1, x.get(1)*y.get(1))
  2652  	res.set(2, x.get(2)*y.get(2))
  2653  	res.set(3, x.get(3)*y.get(3))
  2654  	return res
  2655  }
  2656  
  2657  // MulAdd returns x * y + z element-wise.
  2658  func (x Float32s) MulAdd(y, z Float32s) Float32s {
  2659  	var res Float32s
  2660  
  2661  	res.set(0, x.get(0)*y.get(0)+z.get(0))
  2662  	res.set(1, x.get(1)*y.get(1)+z.get(1))
  2663  	res.set(2, x.get(2)*y.get(2)+z.get(2))
  2664  	res.set(3, x.get(3)*y.get(3)+z.get(3))
  2665  	return res
  2666  }
  2667  
  2668  // Neg returns the element-wise negation of x.
  2669  func (x Float32s) Neg() Float32s {
  2670  	var res Float32s
  2671  	for i := 0; i < 4; i++ {
  2672  		res.set(i, -(x.get(i)))
  2673  	}
  2674  	return res
  2675  }
  2676  
  2677  // NotEqual returns a mask indicating where x and y are not equal.
  2678  func (x Float32s) NotEqual(y Float32s) Mask32s {
  2679  	var res Mask32s
  2680  	for i := 0; i < 4; i++ {
  2681  		if x.get(i) != y.get(i) {
  2682  			res.set(i, true)
  2683  		}
  2684  	}
  2685  	return res
  2686  }
  2687  
  2688  // Sqrt returns the element-wise square root of x.
  2689  func (x Float32s) Sqrt() Float32s {
  2690  	var res Float32s
  2691  	for i := 0; i < 4; i++ {
  2692  		res.set(i, float32(math.Sqrt(float64(x.get(i)))))
  2693  	}
  2694  	return res
  2695  }
  2696  
  2697  // Store stores the vector elements into the slice s.
  2698  func (x Float32s) Store(s []float32) {
  2699  	for i := 0; i < 4 && i < len(s); i++ {
  2700  		s[i] = x.get(i)
  2701  	}
  2702  }
  2703  
  2704  // StorePart stores a partial vector into the slice s.
  2705  func (x Float32s) StorePart(s []float32) int {
  2706  	x.Store(s)
  2707  	return min(len(s), x.Len())
  2708  }
  2709  
  2710  // String returns a string representation of the vector.
  2711  func (x Float32s) String() string {
  2712  	var parts [4]float32
  2713  	for i := 0; i < 4; i++ {
  2714  		parts[i] = x.get(i)
  2715  	}
  2716  	return sliceToString(parts[:])
  2717  }
  2718  
  2719  // Sub returns the element-wise difference of x and y.
  2720  func (x Float32s) Sub(y Float32s) Float32s {
  2721  	var res Float32s
  2722  	for i := 0; i < 4; i++ {
  2723  		res.set(i, x.get(i)-y.get(i))
  2724  	}
  2725  	return res
  2726  }
  2727  
  2728  // ToBits reinterprets the vector bits as a Uint32s vector.
  2729  func (x Float32s) ToBits() Uint32s {
  2730  	return Uint32s{a: x.a, b: x.b}
  2731  }
  2732  
  2733  // LoadFloat64s loads a slice of float64 into an Float64s vector.
  2734  func LoadFloat64s(s []float64) Float64s {
  2735  	var a, b uint64
  2736  	a = math.Float64bits(s[0])
  2737  	b = math.Float64bits(s[1])
  2738  	return Float64s{a: a, b: b}
  2739  }
  2740  
  2741  // LoadFloat64sPart loads a partial slice of float64 into an Float64s vector.
  2742  func LoadFloat64sPart(s []float64) (Float64s, int) {
  2743  	n := len(s)
  2744  	var a, b uint64
  2745  	if n > 0 {
  2746  		a = math.Float64bits(s[0])
  2747  	}
  2748  	if n > 1 {
  2749  		b = math.Float64bits(s[1])
  2750  	}
  2751  	return Float64s{a: a, b: b}, n
  2752  }
  2753  
  2754  func (x Float64s) get(i int) float64 {
  2755  	if i == 0 {
  2756  		return math.Float64frombits(x.a)
  2757  	}
  2758  	return math.Float64frombits(x.b)
  2759  }
  2760  
  2761  func (x *Float64s) set(i int, v float64) {
  2762  	if i == 0 {
  2763  		x.a = math.Float64bits(v)
  2764  	} else {
  2765  		x.b = math.Float64bits(v)
  2766  	}
  2767  }
  2768  
  2769  // Abs returns the element-wise absolute value of x.
  2770  func (x Float64s) Abs() Float64s {
  2771  	var res Float64s
  2772  	for i := 0; i < 4; i++ {
  2773  		v := x.get(i)
  2774  		if v < 0 {
  2775  			res.set(i, -v)
  2776  		} else {
  2777  			res.set(i, v)
  2778  		}
  2779  	}
  2780  	return res
  2781  }
  2782  
  2783  // Add returns the element-wise sum of x and y.
  2784  func (x Float64s) Add(y Float64s) Float64s {
  2785  	var res Float64s
  2786  	res.set(0, x.get(0)+y.get(0))
  2787  	res.set(1, x.get(1)+y.get(1))
  2788  	return res
  2789  }
  2790  
  2791  // Div returns the element-wise quotient of x and y.
  2792  func (x Float64s) Div(y Float64s) Float64s {
  2793  	var res Float64s
  2794  	res.set(0, x.get(0)/y.get(0))
  2795  	res.set(1, x.get(1)/y.get(1))
  2796  	return res
  2797  }
  2798  
  2799  // Equal returns a mask indicating where x and y are equal.
  2800  func (x Float64s) Equal(y Float64s) Mask64s {
  2801  	var res Mask64s
  2802  	if x.get(0) == y.get(0) {
  2803  		res.a = ^uint64(0)
  2804  	}
  2805  	if x.get(1) == y.get(1) {
  2806  		res.b = ^uint64(0)
  2807  	}
  2808  	return res
  2809  }
  2810  
  2811  // Greater returns a mask indicating where x is greater than y.
  2812  func (x Float64s) Greater(y Float64s) Mask64s {
  2813  	var res Mask64s
  2814  	if x.get(0) > y.get(0) {
  2815  		res.a = ^uint64(0)
  2816  	}
  2817  	if x.get(1) > y.get(1) {
  2818  		res.b = ^uint64(0)
  2819  	}
  2820  	return res
  2821  }
  2822  
  2823  // GreaterEqual returns a mask indicating where x is greater than or equal to y.
  2824  func (x Float64s) GreaterEqual(y Float64s) Mask64s {
  2825  	var res Mask64s
  2826  	if x.get(0) >= y.get(0) {
  2827  		res.a = ^uint64(0)
  2828  	}
  2829  	if x.get(1) >= y.get(1) {
  2830  		res.b = ^uint64(0)
  2831  	}
  2832  	return res
  2833  }
  2834  
  2835  // Len returns the number of elements in the vector.
  2836  func (x Float64s) Len() int {
  2837  	return 2
  2838  }
  2839  
  2840  // Less returns a mask indicating where x is less than y.
  2841  func (x Float64s) Less(y Float64s) Mask64s {
  2842  	var res Mask64s
  2843  	if x.get(0) < y.get(0) {
  2844  		res.a = ^uint64(0)
  2845  	}
  2846  	if x.get(1) < y.get(1) {
  2847  		res.b = ^uint64(0)
  2848  	}
  2849  	return res
  2850  }
  2851  
  2852  // LessEqual returns a mask indicating where x is less than or equal to y.
  2853  func (x Float64s) LessEqual(y Float64s) Mask64s {
  2854  	var res Mask64s
  2855  	if x.get(0) <= y.get(0) {
  2856  		res.a = ^uint64(0)
  2857  	}
  2858  	if x.get(1) <= y.get(1) {
  2859  		res.b = ^uint64(0)
  2860  	}
  2861  	return res
  2862  }
  2863  
  2864  // Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
  2865  func (x Float64s) Masked(mask Mask64s) Float64s {
  2866  	return Float64s{a: x.a & mask.a, b: x.b & mask.b}
  2867  }
  2868  
  2869  // Max returns the element-wise maximum of x and y.
  2870  func (x Float64s) Max(y Float64s) Float64s {
  2871  	var res Float64s
  2872  	vx := x.get(0)
  2873  	vy := y.get(0)
  2874  	if vx > vy {
  2875  		res.set(0, vx)
  2876  	} else {
  2877  		res.set(0, vy)
  2878  	}
  2879  	vx = x.get(1)
  2880  	vy = y.get(1)
  2881  	if vx > vy {
  2882  		res.set(1, vx)
  2883  	} else {
  2884  		res.set(1, vy)
  2885  	}
  2886  	return res
  2887  }
  2888  
  2889  // IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
  2890  func (x Float64s) IfElse(mask Mask64s, y Float64s) Float64s {
  2891  	return Float64s{
  2892  		a: (x.a & mask.a) | (y.a &^ mask.a),
  2893  		b: (x.b & mask.b) | (y.b &^ mask.b),
  2894  	}
  2895  }
  2896  
  2897  // Min returns the element-wise minimum of x and y.
  2898  func (x Float64s) Min(y Float64s) Float64s {
  2899  	var res Float64s
  2900  	vx := x.get(0)
  2901  	vy := y.get(0)
  2902  	if vx < vy {
  2903  		res.set(0, vx)
  2904  	} else {
  2905  		res.set(0, vy)
  2906  	}
  2907  	vx = x.get(1)
  2908  	vy = y.get(1)
  2909  	if vx < vy {
  2910  		res.set(1, vx)
  2911  	} else {
  2912  		res.set(1, vy)
  2913  	}
  2914  	return res
  2915  }
  2916  
  2917  // Mul returns the element-wise product of x and y.
  2918  func (x Float64s) Mul(y Float64s) Float64s {
  2919  	var res Float64s
  2920  	res.set(0, x.get(0)*y.get(0))
  2921  	res.set(1, x.get(1)*y.get(1))
  2922  	return res
  2923  }
  2924  
  2925  // MulAdd returns x * y + z element-wise.
  2926  func (x Float64s) MulAdd(y, z Float64s) Float64s {
  2927  	var res Float64s
  2928  	res.set(0, x.get(0)*y.get(0)+z.get(0))
  2929  	res.set(1, x.get(1)*y.get(1)+z.get(1))
  2930  	return res
  2931  }
  2932  
  2933  // Neg returns the element-wise negation of x.
  2934  func (x Float64s) Neg() Float64s {
  2935  	var res Float64s
  2936  	for i := 0; i < 4; i++ {
  2937  		res.set(i, -(x.get(i)))
  2938  	}
  2939  	return res
  2940  }
  2941  
  2942  // NotEqual returns a mask indicating where x and y are not equal.
  2943  func (x Float64s) NotEqual(y Float64s) Mask64s {
  2944  	var res Mask64s
  2945  	if x.get(0) != y.get(0) {
  2946  		res.a = ^uint64(0)
  2947  	}
  2948  	if x.get(1) != y.get(1) {
  2949  		res.b = ^uint64(0)
  2950  	}
  2951  	return res
  2952  }
  2953  
  2954  // Sqrt returns the element-wise square root of x.
  2955  func (x Float64s) Sqrt() Float64s {
  2956  	var res Float64s
  2957  	res.set(0, math.Sqrt(x.get(0)))
  2958  	res.set(1, math.Sqrt(x.get(1)))
  2959  	return res
  2960  }
  2961  
  2962  // Store stores the vector elements into the slice s.
  2963  func (x Float64s) Store(s []float64) {
  2964  	if len(s) > 0 {
  2965  		s[0] = x.get(0)
  2966  	}
  2967  	if len(s) > 1 {
  2968  		s[1] = x.get(1)
  2969  	}
  2970  }
  2971  
  2972  // StorePart stores a partial vector into the slice s.
  2973  func (x Float64s) StorePart(s []float64) int {
  2974  	x.Store(s)
  2975  	return min(len(s), x.Len())
  2976  }
  2977  
  2978  // String returns a string representation of the vector.
  2979  func (x Float64s) String() string {
  2980  	return sliceToString([]float64{x.get(0), x.get(1)})
  2981  }
  2982  
  2983  // Sub returns the element-wise difference of x and y.
  2984  func (x Float64s) Sub(y Float64s) Float64s {
  2985  	var res Float64s
  2986  	res.set(0, x.get(0)-y.get(0))
  2987  	res.set(1, x.get(1)-y.get(1))
  2988  	return res
  2989  }
  2990  
  2991  // ToBits reinterprets the vector bits as a Uint64s vector.
  2992  func (x Float64s) ToBits() Uint64s {
  2993  	return Uint64s{a: x.a, b: x.b}
  2994  }
  2995  
  2996  func (x *Mask8s) set(i int, v bool) {
  2997  	if v {
  2998  		if i < 8 {
  2999  			mask := uint64(0xff) << (8 * i)
  3000  			x.a |= mask
  3001  		} else {
  3002  			mask := uint64(0xff) << (8 * (i - 8))
  3003  			x.b |= mask
  3004  		}
  3005  	}
  3006  }
  3007  
  3008  // And returns the bitwise AND of x and y.
  3009  func (x Mask8s) And(y Mask8s) Mask8s {
  3010  	return Mask8s{a: x.a & y.a, b: x.b & y.b}
  3011  }
  3012  
  3013  // Or returns the bitwise OR of x and y.
  3014  func (x Mask8s) Or(y Mask8s) Mask8s {
  3015  	return Mask8s{a: x.a | y.a, b: x.b | y.b}
  3016  }
  3017  
  3018  // String returns a string representation of the vector.
  3019  func (x Mask8s) String() string {
  3020  	var s [16]int8
  3021  	x.ToInt8s().Neg().Store(s[:])
  3022  	return sliceToString(s[:])
  3023  }
  3024  
  3025  // ToInt8s converts the mask to an Int8s vector.
  3026  func (x Mask8s) ToInt8s() Int8s {
  3027  	return Int8s{a: x.a, b: x.b}
  3028  }
  3029  
  3030  func (x *Mask16s) set(i int, v bool) {
  3031  	if v {
  3032  		if i < 4 {
  3033  			mask := uint64(0xffff) << (16 * i)
  3034  			x.a |= mask
  3035  		} else {
  3036  			mask := uint64(0xffff) << (16 * (i - 4))
  3037  			x.b |= mask
  3038  		}
  3039  	}
  3040  }
  3041  
  3042  // And returns the bitwise AND of x and y.
  3043  func (x Mask16s) And(y Mask16s) Mask16s {
  3044  	return Mask16s{a: x.a & y.a, b: x.b & y.b}
  3045  }
  3046  
  3047  // Or returns the bitwise OR of x and y.
  3048  func (x Mask16s) Or(y Mask16s) Mask16s {
  3049  	return Mask16s{a: x.a | y.a, b: x.b | y.b}
  3050  }
  3051  
  3052  // String returns a string representation of the vector.
  3053  func (x Mask16s) String() string {
  3054  	var s [8]int16
  3055  	x.ToInt16s().Neg().Store(s[:])
  3056  	return sliceToString(s[:])
  3057  }
  3058  
  3059  // ToInt16s converts the mask to an Int16s vector.
  3060  func (x Mask16s) ToInt16s() Int16s {
  3061  	return Int16s{a: x.a, b: x.b}
  3062  }
  3063  
  3064  func (x *Mask32s) set(i int, v bool) {
  3065  	if v {
  3066  		if i < 2 {
  3067  			mask := uint64(0xffffffff) << (32 * i)
  3068  			x.a |= mask
  3069  		} else {
  3070  			mask := uint64(0xffffffff) << (32 * (i - 2))
  3071  			x.b |= mask
  3072  		}
  3073  	}
  3074  }
  3075  
  3076  // And returns the bitwise AND of x and y.
  3077  func (x Mask32s) And(y Mask32s) Mask32s {
  3078  	return Mask32s{a: x.a & y.a, b: x.b & y.b}
  3079  }
  3080  
  3081  // Or returns the bitwise OR of x and y.
  3082  func (x Mask32s) Or(y Mask32s) Mask32s {
  3083  	return Mask32s{a: x.a | y.a, b: x.b | y.b}
  3084  }
  3085  
  3086  // String returns a string representation of the vector.
  3087  func (x Mask32s) String() string {
  3088  	var s [4]int32
  3089  	x.ToInt32s().Neg().Store(s[:])
  3090  	return sliceToString(s[:])
  3091  }
  3092  
  3093  // ToInt32s converts the mask to an Int32s vector.
  3094  func (x Mask32s) ToInt32s() Int32s {
  3095  	return Int32s{a: x.a, b: x.b}
  3096  }
  3097  
  3098  func (x *Mask64s) set(i int, v bool) {
  3099  	if v {
  3100  		if i == 0 {
  3101  			x.a = ^uint64(0)
  3102  		} else {
  3103  			x.b = ^uint64(0)
  3104  		}
  3105  	}
  3106  }
  3107  
  3108  // And returns the bitwise AND of x and y.
  3109  func (x Mask64s) And(y Mask64s) Mask64s {
  3110  	return Mask64s{a: x.a & y.a, b: x.b & y.b}
  3111  }
  3112  
  3113  // Or returns the bitwise OR of x and y.
  3114  func (x Mask64s) Or(y Mask64s) Mask64s {
  3115  	return Mask64s{a: x.a | y.a, b: x.b | y.b}
  3116  }
  3117  
  3118  // String returns a string representation of the vector.
  3119  func (x Mask64s) String() string {
  3120  	var s [2]int64
  3121  	x.ToInt64s().Neg().Store(s[:])
  3122  	return sliceToString(s[:])
  3123  }
  3124  
  3125  // ToInt64s converts the mask to an Int64s vector.
  3126  func (x Mask64s) ToInt64s() Int64s {
  3127  	return Int64s{a: x.a, b: x.b}
  3128  }
  3129  
  3130  func newT(lo, hi uint64) Uint64s {
  3131  	return Uint64s{a: lo, b: hi}
  3132  }
  3133  
  3134  // mwl returns the 128-bit product of the lower halves of x and y
  3135  func (x Uint64s) mwl(y Uint64s) Uint64s {
  3136  	hi, lo := bits.Mul64(x.a, y.a)
  3137  	return Uint64s{a: lo, b: hi}
  3138  }
  3139  
  3140  var (
  3141  	// For mK, bits J such that J mod 5 == K are set
  3142  	m0 = newT(0x1084210842108421, 0x2108421084210842)
  3143  	m1 = newT(0x2108421084210842, 0x4210842108421084)
  3144  	m2 = newT(0x4210842108421084, 0x8421084210842108)
  3145  	m3 = newT(0x8421084210842108, 0x0842108421084210)
  3146  	m4 = newT(0x0842108421084210, 0x1084210842108421)
  3147  )
  3148  
  3149  func (x Uint64s) clmul(y Uint64s) Uint64s {
  3150  	x0 := x.And(m0)
  3151  	x1 := x.And(m1)
  3152  	x2 := x.And(m2)
  3153  	x3 := x.And(m3)
  3154  	x4 := x.And(m4)
  3155  
  3156  	y0 := y.And(m0)
  3157  	y1 := y.And(m1)
  3158  	y2 := y.And(m2)
  3159  	y3 := y.And(m3)
  3160  	y4 := y.And(m4)
  3161  
  3162  	// sum of x, y indices == K mod 5; mask index = K
  3163  	z := (x0.mwl(y0)).Xor(x1.mwl(y4)).Xor(x4.mwl(y1)).Xor(x2.mwl(y3)).Xor(x3.mwl(y2)).And(m0)
  3164  	z = (x3.mwl(y3)).Xor(x2.mwl(y4)).Xor(x4.mwl(y2)).Xor(x0.mwl(y1)).Xor(x1.mwl(y0)).And(m1).Or(z)
  3165  	z = (x1.mwl(y1)).Xor(x3.mwl(y4)).Xor(x4.mwl(y3)).Xor(x0.mwl(y2)).Xor(x2.mwl(y0)).And(m2).Or(z)
  3166  	z = (x4.mwl(y4)).Xor(x0.mwl(y3)).Xor(x3.mwl(y0)).Xor(x1.mwl(y2)).Xor(x2.mwl(y1)).And(m3).Or(z)
  3167  	z = (x2.mwl(y2)).Xor(x0.mwl(y4)).Xor(x4.mwl(y0)).Xor(x1.mwl(y3)).Xor(x3.mwl(y1)).And(m4).Or(z)
  3168  
  3169  	return z
  3170  }
  3171  
  3172  // CarrylessMultiplyEven computes the carryless
  3173  // multiplications of selected even halves of the elements of x and y.
  3174  // The result fills the 128 bits of each even-odd pair.
  3175  //
  3176  // A carryless multiplication uses bitwise XOR instead of
  3177  // add-with-carry, for example (in base two):
  3178  //
  3179  //	11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
  3180  //
  3181  // This also models multiplication of polynomials with coefficients
  3182  // from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
  3183  // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
  3184  // polynomial terms, but coefficients "add" with XOR.)
  3185  func (x Uint64s) CarrylessMultiplyEven(y Uint64s) Uint64s {
  3186  	return x.clmul(y)
  3187  }
  3188  
  3189  // CarrylessMultiplyOdd computes the carryless
  3190  // multiplications of selected odd halves of the elements of x and y.
  3191  // The result fills the 128 bits of each even-odd pair.
  3192  //
  3193  // A carryless multiplication uses bitwise XOR instead of
  3194  // add-with-carry, for example (in base two):
  3195  //
  3196  //	11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
  3197  //
  3198  // This also models multiplication of polynomials with coefficients
  3199  // from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
  3200  // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
  3201  // polynomial terms, but coefficients "add" with XOR.)
  3202  func (x Uint64s) CarrylessMultiplyOdd(y Uint64s) Uint64s {
  3203  	x.a = x.b
  3204  	y.a = y.b
  3205  	return x.clmul(y)
  3206  }
  3207  
  3208  const (
  3209  	by8  = 0x0101010101010101
  3210  	by16 = 0x0001000100010001
  3211  )
  3212  
  3213  // BroadcastInt8s fills the elements of a slice with its argument value.
  3214  func BroadcastInt8s(x int8) Int8s {
  3215  	v := (255 & uint64(x)) * by8
  3216  	return Int8s{a: v, b: v}
  3217  }
  3218  
  3219  // BroadcastInt16s fills the elements of a slice with its argument value.
  3220  func BroadcastInt16s(x int16) Int16s {
  3221  	v := (65535 & uint64(x)) * by16
  3222  	return Int16s{a: v, b: v}
  3223  }
  3224  
  3225  // BroadcastInt32s fills the elements of a slice with its argument value.
  3226  func BroadcastInt32s(x int32) Int32s {
  3227  	v := uint64(x) & 0xffffffff
  3228  	v = v<<32 | v
  3229  	return Int32s{a: v, b: v}
  3230  }
  3231  
  3232  // BroadcastInt64s fills the elements of a slice with its argument value.
  3233  func BroadcastInt64s(x int64) Int64s {
  3234  	v := uint64(x)
  3235  	return Int64s{a: v, b: v}
  3236  }
  3237  
  3238  // BroadcastUint8s fills the elements of a slice with its argument value.
  3239  func BroadcastUint8s(x uint8) Uint8s {
  3240  	v := uint64(x) * by8
  3241  	return Uint8s{a: v, b: v}
  3242  
  3243  }
  3244  
  3245  // BroadcastUint16s fills the elements of a slice with its argument value.
  3246  func BroadcastUint16s(x uint16) Uint16s {
  3247  	v := uint64(x) * by16
  3248  	return Uint16s{a: v, b: v}
  3249  
  3250  }
  3251  
  3252  // BroadcastUint32s fills the elements of a slice with its argument value.
  3253  func BroadcastUint32s(x uint32) Uint32s {
  3254  	v := uint64(x)
  3255  	v = v<<32 | v
  3256  	return Uint32s{a: v, b: v}
  3257  }
  3258  
  3259  // BroadcastUint64s fills the elements of a slice with its argument value.
  3260  func BroadcastUint64s(x uint64) Uint64s {
  3261  	return Uint64s{a: x, b: x}
  3262  }
  3263  
  3264  // BroadcastFloat32s fills the elements of a slice with its argument value.
  3265  func BroadcastFloat32s(x float32) Float32s {
  3266  	v := uint64(math.Float32bits(x))
  3267  	v = v<<32 | v
  3268  	return Float32s{a: v, b: v}
  3269  }
  3270  
  3271  // BroadcastFloat64s fills the elements of a slice with its argument value.
  3272  func BroadcastFloat64s(x float64) Float64s {
  3273  	v := math.Float64bits(x)
  3274  	return Float64s{a: v, b: v}
  3275  }
  3276  

View as plain text