archsimd

package standard library
go1.27rc3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 13, 2026 License: BSD-3-Clause Imports: 3 Imported by: 3

Documentation

Overview

Package archsimd provides access to architecture-specific SIMD operations.

This is a low-level package that exposes hardware-specific functionality. It currently supports AMD64.

This package is experimental, and not subject to the Go 1 compatibility promise. It only exists when building with the GOEXPERIMENT=simd environment variable set.

Vector types and operations

Vector types are defined as structs, such as Int8x16 and Float64x8, corresponding to the hardware's vector registers. On AMD64, 128-, 256-, and 512-bit vectors are supported.

Mask types are defined similarly, such as Mask8x16, and are represented as opaque types, handling the differences in the underlying representations. A mask can be converted to/from the corresponding integer vector type, or to/from a bitmask.

Operations are mostly defined as methods on the vector types. Most of them are compiler intrinsics and correspond directly to hardware instructions.

Common operations include:

  • Load/Store: Load a vector from memory or store a vector to memory.
  • Arithmetic: Add, Sub, Mul, etc.
  • Bitwise: And, Or, Xor, etc.
  • Comparison: Equal, Greater, etc., which produce a mask.
  • Conversion: Convert between different vector types.
  • Field selection and rearrangement: GetElem, Permute, etc.
  • Masking: Masked, Merge.

The compiler recognizes certain patterns of operations and may optimize them to more performant instructions. For example, on AVX512, an Add operation followed by Masked may be optimized to a masked add instruction. For this reason, not all hardware instructions are available as APIs.

CPU feature checks

The package provides global variables to check for CPU features available at runtime. For example, on AMD64, the X86 variable provides methods to check for AVX2, AVX512, etc. It is recommended to check for CPU features before using the corresponding vector operations.

Notes

  • This package is not portable, as the available types and operations depend on the target architecture. It is not recommended to expose the SIMD types defined in this package in public APIs.
  • For performance reasons, it is recommended to use the vector types directly as values. It is not recommended to take the address of a vector type, allocate it in the heap, or put it in an aggregate type.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ClearAVXUpperBits 

func ClearAVXUpperBits()

ClearAVXUpperBits clears the high bits of Y0-Y15 and Z0-Z15 registers. It is intended for transitioning from AVX to SSE, eliminating the performance penalties caused by false dependencies.

Note: in the future the compiler may automatically generate the instruction, making this function unnecessary.

Asm: VZEROUPPER, CPU Feature: AVX

Types

type ARM64Features added in go1.27.0 

type ARM64Features struct{}
var ARM64 ARM64Features

func (ARM64Features) PMULL added in go1.27.0 

func (ARM64Features) PMULL() bool

PMULL returns whether the CPU supports the PMULL feature.

PMULL is defined on all GOARCHes, but will only return true on GOARCH arm64.

type Float32x4 

type Float32x4 struct {
	// contains filtered or unexported fields
}

Float32x4 is a 128-bit SIMD vector of 4 float32s.

func BroadcastFloat32x4 

func BroadcastFloat32x4(x float32) Float32x4

BroadcastFloat32x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadFloat32x4 

func LoadFloat32x4(s []float32) Float32x4

LoadFloat32x4 loads a Float32x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadFloat32x4Array added in go1.27.0 

func LoadFloat32x4Array(y *[4]float32) Float32x4

LoadFloat32x4Array loads a Float32x4 from an array.

func LoadFloat32x4Part added in go1.27.0 

func LoadFloat32x4Part(s []float32) (Float32x4, int)

LoadFloat32x4Part loads a Float32x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadFloat32x4.

func (Float32x4) Abs added in go1.27.0 

func (x Float32x4) Abs() Float32x4

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX

func (Float32x4) Add 

func (x Float32x4) Add(y Float32x4) Float32x4

Add adds corresponding elements of two vectors.

Asm: VADDPS, CPU Feature: AVX

func (Float32x4) AddOddSubEven added in go1.27.0 

func (x Float32x4) AddOddSubEven(y Float32x4) Float32x4

AddOddSubEven subtracts even elements and adds odd elements of two vectors.

Asm: VADDSUBPS, CPU Feature: AVX

func (Float32x4) AsFloat64x2 deprecated 

func (x Float32x4) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Float32x4 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsInt8x16 deprecated 

func (x Float32x4) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Float32x4 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsInt16x8 deprecated 

func (x Float32x4) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Float32x4 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsInt32x4 deprecated 

func (x Float32x4) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Float32x4 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsInt64x2 deprecated 

func (x Float32x4) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Float32x4 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsUint8x16 deprecated 

func (x Float32x4) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Float32x4 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsUint16x8 deprecated 

func (x Float32x4) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Float32x4 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsUint32x4 deprecated 

func (x Float32x4) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Float32x4 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) AsUint64x2 deprecated 

func (x Float32x4) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Float32x4 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x4) Ceil 

func (x Float32x4) Ceil() Float32x4

Ceil rounds elements up to the nearest integer.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x4) CeilScaled 

func (x Float32x4) CeilScaled(prec uint8) Float32x4

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x4) CeilScaledResidue 

func (x Float32x4) CeilScaledResidue(prec uint8) Float32x4

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x4) Compress 

func (x Float32x4) Compress(mask Mask32x4) Float32x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPS, CPU Feature: AVX512

func (Float32x4) ConcatAddPairs added in go1.27.0 

func (x Float32x4) ConcatAddPairs(y Float32x4) Float32x4

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VHADDPS, CPU Feature: AVX

func (Float32x4) ConcatPermute 

func (x Float32x4) ConcatPermute(y Float32x4, indices Uint32x4) Float32x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PS, CPU Feature: AVX512

func (Float32x4) ConcatPermuteScalars added in go1.27.0 

func (x Float32x4) ConcatPermuteScalars(a, b, c, d uint8, y Float32x4) Float32x4

ConcatPermuteScalars returns the selection of four elements from the two vectors x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})

returns {4,8,25,81}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Float32x4) ConcatSubPairs added in go1.27.0 

func (x Float32x4) ConcatSubPairs(y Float32x4) Float32x4

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VHSUBPS, CPU Feature: AVX

func (Float32x4) ConvertToFloat64 

func (x Float32x4) ConvertToFloat64() Float64x4

ConvertToFloat64 converts element values to float64.

Asm: VCVTPS2PD, CPU Feature: AVX

func (Float32x4) ConvertToInt32 

func (x Float32x4) ConvertToInt32() Int32x4

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2DQ, CPU Feature: AVX

func (Float32x4) ConvertToInt64 

func (x Float32x4) ConvertToInt64() Int64x4

ConvertToInt64 converts element values to int64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2QQ, CPU Feature: AVX512

func (Float32x4) ConvertToUint32 

func (x Float32x4) ConvertToUint32() Uint32x4

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2UDQ, CPU Feature: AVX512

func (Float32x4) ConvertToUint64 

func (x Float32x4) ConvertToUint64() Uint64x4

ConvertToUint64 converts element values to uint64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2UQQ, CPU Feature: AVX512

func (Float32x4) Div 

func (x Float32x4) Div(y Float32x4) Float32x4

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPS, CPU Feature: AVX

func (Float32x4) Equal 

func (x Float32x4) Equal(y Float32x4) Mask32x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) Expand 

func (x Float32x4) Expand(mask Mask32x4) Float32x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPS, CPU Feature: AVX512

func (Float32x4) Floor 

func (x Float32x4) Floor() Float32x4

Floor rounds elements down to the nearest integer.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x4) FloorScaled 

func (x Float32x4) FloorScaled(prec uint8) Float32x4

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x4) FloorScaledResidue 

func (x Float32x4) FloorScaledResidue(prec uint8) Float32x4

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x4) GetElem 

func (x Float32x4) GetElem(index uint8) float32

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRD, CPU Feature: AVX

func (Float32x4) Greater 

func (x Float32x4) Greater(y Float32x4) Mask32x4

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) GreaterEqual 

func (x Float32x4) GreaterEqual(y Float32x4) Mask32x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) IfElse added in go1.27.0 

func (x Float32x4) IfElse(mask Mask32x4, y Float32x4) Float32x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Float32x4) IsNaN 

func (x Float32x4) IsNaN() Mask32x4

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) Len 

func (x Float32x4) Len() int

Len returns the number of elements in a Float32x4.

func (Float32x4) Less 

func (x Float32x4) Less(y Float32x4) Mask32x4

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) LessEqual 

func (x Float32x4) LessEqual(y Float32x4) Mask32x4

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) Masked 

func (x Float32x4) Masked(mask Mask32x4) Float32x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Float32x4) Max 

func (x Float32x4) Max(y Float32x4) Float32x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPS, CPU Feature: AVX

func (Float32x4) Merge deprecated 

func (x Float32x4) Merge(y Float32x4, mask Mask32x4) Float32x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Float32x4) Min 

func (x Float32x4) Min(y Float32x4) Float32x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPS, CPU Feature: AVX

func (Float32x4) Mul 

func (x Float32x4) Mul(y Float32x4) Float32x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPS, CPU Feature: AVX

func (Float32x4) MulAdd 

func (x Float32x4) MulAdd(y Float32x4, z Float32x4) Float32x4

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PS, CPU Feature: FMA

func (Float32x4) MulAddEvenSubOdd added in go1.27.0 

func (x Float32x4) MulAddEvenSubOdd(y Float32x4, z Float32x4) Float32x4

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PS, CPU Feature: FMA

func (Float32x4) MulAddOddSubEven added in go1.27.0 

func (x Float32x4) MulAddOddSubEven(y Float32x4, z Float32x4) Float32x4

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PS, CPU Feature: FMA

func (Float32x4) Neg added in go1.27.0 

func (x Float32x4) Neg() Float32x4

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX

func (Float32x4) NotEqual 

func (x Float32x4) NotEqual(y Float32x4) Mask32x4

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x4) Reciprocal 

func (x Float32x4) Reciprocal() Float32x4

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCPPS, CPU Feature: AVX

func (Float32x4) ReciprocalSqrt 

func (x Float32x4) ReciprocalSqrt() Float32x4

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRTPS, CPU Feature: AVX

func (Float32x4) Round added in go1.27.0 

func (x Float32x4) Round() Float32x4

Round rounds elements to the nearest integer, rounding ties to even.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x4) RoundScaled added in go1.27.0 

func (x Float32x4) RoundScaled(prec uint8) Float32x4

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x4) RoundScaledResidue added in go1.27.0 

func (x Float32x4) RoundScaledResidue(prec uint8) Float32x4

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x4) Scale 

func (x Float32x4) Scale(y Float32x4) Float32x4

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPS, CPU Feature: AVX512

func (Float32x4) SetElem 

func (x Float32x4) SetElem(index uint8, y float32) Float32x4

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRD, CPU Feature: AVX

func (Float32x4) Sqrt 

func (x Float32x4) Sqrt() Float32x4

Sqrt computes the square root of each element.

Asm: VSQRTPS, CPU Feature: AVX

func (Float32x4) Store 

func (x Float32x4) Store(s []float32)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Float32x4) StoreArray added in go1.27.0 

func (x Float32x4) StoreArray(y *[4]float32)

StoreArray stores a Float32x4 to an array.

func (Float32x4) StoreArrayMasked added in go1.27.0 

func (x Float32x4) StoreArrayMasked(y *[4]float32, mask Mask32x4)

StoreArrayMasked stores a Float32x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Float32x4) StorePart added in go1.27.0 

func (x Float32x4) StorePart(s []float32) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Float32x4) String 

func (x Float32x4) String() string

String returns a string representation of SIMD vector x.

func (Float32x4) Sub 

func (x Float32x4) Sub(y Float32x4) Float32x4

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPS, CPU Feature: AVX

func (Float32x4) ToBits added in go1.27.0 

func (x Float32x4) ToBits() Uint32x4

ToBits reinterprets the bits of a Float32x4 vector as a Uint32x4 vector

func (Float32x4) Trunc 

func (x Float32x4) Trunc() Float32x4

Trunc truncates elements towards zero.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x4) TruncScaled 

func (x Float32x4) TruncScaled(prec uint8) Float32x4

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x4) TruncScaledResidue 

func (x Float32x4) TruncScaledResidue(prec uint8) Float32x4

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

type Float32x8 

type Float32x8 struct {
	// contains filtered or unexported fields
}

Float32x8 is a 256-bit SIMD vector of 8 float32s.

func BroadcastFloat32x8 

func BroadcastFloat32x8(x float32) Float32x8

BroadcastFloat32x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadFloat32x8 

func LoadFloat32x8(s []float32) Float32x8

LoadFloat32x8 loads a Float32x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadFloat32x8Array added in go1.27.0 

func LoadFloat32x8Array(y *[8]float32) Float32x8

LoadFloat32x8Array loads a Float32x8 from an array.

func LoadFloat32x8Part added in go1.27.0 

func LoadFloat32x8Part(s []float32) (Float32x8, int)

LoadFloat32x8Part loads a Float32x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadFloat32x8.

func (Float32x8) Abs added in go1.27.0 

func (x Float32x8) Abs() Float32x8

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX2

func (Float32x8) Add 

func (x Float32x8) Add(y Float32x8) Float32x8

Add adds corresponding elements of two vectors.

Asm: VADDPS, CPU Feature: AVX

func (Float32x8) AddOddSubEven added in go1.27.0 

func (x Float32x8) AddOddSubEven(y Float32x8) Float32x8

AddOddSubEven subtracts even elements and adds odd elements of two vectors.

Asm: VADDSUBPS, CPU Feature: AVX

func (Float32x8) AsFloat64x4 deprecated 

func (x Float32x8) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Float32x8 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsInt8x32 deprecated 

func (x Float32x8) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Float32x8 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsInt16x16 deprecated 

func (x Float32x8) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Float32x8 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsInt32x8 deprecated 

func (x Float32x8) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Float32x8 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsInt64x4 deprecated 

func (x Float32x8) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Float32x8 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsUint8x32 deprecated 

func (x Float32x8) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Float32x8 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsUint16x16 deprecated 

func (x Float32x8) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Float32x8 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsUint32x8 deprecated 

func (x Float32x8) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Float32x8 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) AsUint64x4 deprecated 

func (x Float32x8) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Float32x8 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x8) Ceil 

func (x Float32x8) Ceil() Float32x8

Ceil rounds elements up to the nearest integer.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x8) CeilScaled 

func (x Float32x8) CeilScaled(prec uint8) Float32x8

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x8) CeilScaledResidue 

func (x Float32x8) CeilScaledResidue(prec uint8) Float32x8

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x8) Compress 

func (x Float32x8) Compress(mask Mask32x8) Float32x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPS, CPU Feature: AVX512

func (Float32x8) ConcatAddPairsGrouped added in go1.27.0 

func (x Float32x8) ConcatAddPairsGrouped(y Float32x8) Float32x8

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VHADDPS, CPU Feature: AVX

func (Float32x8) ConcatPermute 

func (x Float32x8) ConcatPermute(y Float32x8, indices Uint32x8) Float32x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PS, CPU Feature: AVX512

func (Float32x8) ConcatPermute128Scalars added in go1.27.0 

func (x Float32x8) ConcatPermute128Scalars(lo, hi uint8, y Float32x8) Float32x8

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 42, 43, 50, 51, 52, 53}.ConcatPermute128Scalars(3, 0, {60, 61, 62, 63, 70, 71, 72, 73})

returns {70, 71, 72, 73, 40, 41, 42, 43}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2F128, CPU Feature: AVX

func (Float32x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Float32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Float32x8) Float32x8

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})

returns {4,8,25,81,64,128,169,289}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Float32x8) ConcatSubPairsGrouped added in go1.27.0 

func (x Float32x8) ConcatSubPairsGrouped(y Float32x8) Float32x8

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VHSUBPS, CPU Feature: AVX

func (Float32x8) ConvertToFloat64 

func (x Float32x8) ConvertToFloat64() Float64x8

ConvertToFloat64 converts element values to float64.

Asm: VCVTPS2PD, CPU Feature: AVX512

func (Float32x8) ConvertToInt32 

func (x Float32x8) ConvertToInt32() Int32x8

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2DQ, CPU Feature: AVX

func (Float32x8) ConvertToInt64 

func (x Float32x8) ConvertToInt64() Int64x8

ConvertToInt64 converts element values to int64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2QQ, CPU Feature: AVX512

func (Float32x8) ConvertToUint32 

func (x Float32x8) ConvertToUint32() Uint32x8

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2UDQ, CPU Feature: AVX512

func (Float32x8) ConvertToUint64 

func (x Float32x8) ConvertToUint64() Uint64x8

ConvertToUint64 converts element values to uint64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2UQQ, CPU Feature: AVX512

func (Float32x8) Div 

func (x Float32x8) Div(y Float32x8) Float32x8

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPS, CPU Feature: AVX

func (Float32x8) Equal 

func (x Float32x8) Equal(y Float32x8) Mask32x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) Expand 

func (x Float32x8) Expand(mask Mask32x8) Float32x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPS, CPU Feature: AVX512

func (Float32x8) Floor 

func (x Float32x8) Floor() Float32x8

Floor rounds elements down to the nearest integer.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x8) FloorScaled 

func (x Float32x8) FloorScaled(prec uint8) Float32x8

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x8) FloorScaledResidue 

func (x Float32x8) FloorScaledResidue(prec uint8) Float32x8

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x8) GetHi 

func (x Float32x8) GetHi() Float32x4

GetHi returns the upper half of x.

Asm: VEXTRACTF128, CPU Feature: AVX

func (Float32x8) GetLo 

func (x Float32x8) GetLo() Float32x4

GetLo returns the lower half of x.

Asm: VEXTRACTF128, CPU Feature: AVX

func (Float32x8) Greater 

func (x Float32x8) Greater(y Float32x8) Mask32x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) GreaterEqual 

func (x Float32x8) GreaterEqual(y Float32x8) Mask32x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) IfElse added in go1.27.0 

func (x Float32x8) IfElse(mask Mask32x8, y Float32x8) Float32x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Float32x8) IsNaN 

func (x Float32x8) IsNaN() Mask32x8

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) Len 

func (x Float32x8) Len() int

Len returns the number of elements in a Float32x8.

func (Float32x8) Less 

func (x Float32x8) Less(y Float32x8) Mask32x8

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) LessEqual 

func (x Float32x8) LessEqual(y Float32x8) Mask32x8

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) Masked 

func (x Float32x8) Masked(mask Mask32x8) Float32x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Float32x8) Max 

func (x Float32x8) Max(y Float32x8) Float32x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPS, CPU Feature: AVX

func (Float32x8) Merge deprecated 

func (x Float32x8) Merge(y Float32x8, mask Mask32x8) Float32x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Float32x8) Min 

func (x Float32x8) Min(y Float32x8) Float32x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPS, CPU Feature: AVX

func (Float32x8) Mul 

func (x Float32x8) Mul(y Float32x8) Float32x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPS, CPU Feature: AVX

func (Float32x8) MulAdd 

func (x Float32x8) MulAdd(y Float32x8, z Float32x8) Float32x8

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PS, CPU Feature: FMA

func (Float32x8) MulAddEvenSubOdd added in go1.27.0 

func (x Float32x8) MulAddEvenSubOdd(y Float32x8, z Float32x8) Float32x8

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PS, CPU Feature: FMA

func (Float32x8) MulAddOddSubEven added in go1.27.0 

func (x Float32x8) MulAddOddSubEven(y Float32x8, z Float32x8) Float32x8

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PS, CPU Feature: FMA

func (Float32x8) Neg added in go1.27.0 

func (x Float32x8) Neg() Float32x8

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX2

func (Float32x8) NotEqual 

func (x Float32x8) NotEqual(y Float32x8) Mask32x8

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPS, CPU Feature: AVX

func (Float32x8) Permute 

func (x Float32x8) Permute(indices Uint32x8) Float32x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMPS, CPU Feature: AVX2

func (Float32x8) Reciprocal 

func (x Float32x8) Reciprocal() Float32x8

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCPPS, CPU Feature: AVX

func (Float32x8) ReciprocalSqrt 

func (x Float32x8) ReciprocalSqrt() Float32x8

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRTPS, CPU Feature: AVX

func (Float32x8) Round added in go1.27.0 

func (x Float32x8) Round() Float32x8

Round rounds elements to the nearest integer, rounding ties to even.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x8) RoundScaled added in go1.27.0 

func (x Float32x8) RoundScaled(prec uint8) Float32x8

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x8) RoundScaledResidue added in go1.27.0 

func (x Float32x8) RoundScaledResidue(prec uint8) Float32x8

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x8) Scale 

func (x Float32x8) Scale(y Float32x8) Float32x8

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPS, CPU Feature: AVX512

func (Float32x8) SetHi 

func (x Float32x8) SetHi(y Float32x4) Float32x8

SetHi returns x with its upper half set to y.

Asm: VINSERTF128, CPU Feature: AVX

func (Float32x8) SetLo 

func (x Float32x8) SetLo(y Float32x4) Float32x8

SetLo returns x with its lower half set to y.

Asm: VINSERTF128, CPU Feature: AVX

func (Float32x8) Sqrt 

func (x Float32x8) Sqrt() Float32x8

Sqrt computes the square root of each element.

Asm: VSQRTPS, CPU Feature: AVX

func (Float32x8) Store 

func (x Float32x8) Store(s []float32)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Float32x8) StoreArray added in go1.27.0 

func (x Float32x8) StoreArray(y *[8]float32)

StoreArray stores a Float32x8 to an array.

func (Float32x8) StoreArrayMasked added in go1.27.0 

func (x Float32x8) StoreArrayMasked(y *[8]float32, mask Mask32x8)

StoreArrayMasked stores a Float32x8 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Float32x8) StorePart added in go1.27.0 

func (x Float32x8) StorePart(s []float32) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Float32x8) String 

func (x Float32x8) String() string

String returns a string representation of SIMD vector x.

func (Float32x8) Sub 

func (x Float32x8) Sub(y Float32x8) Float32x8

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPS, CPU Feature: AVX

func (Float32x8) ToBits added in go1.27.0 

func (x Float32x8) ToBits() Uint32x8

ToBits reinterprets the bits of a Float32x8 vector as a Uint32x8 vector

func (Float32x8) Trunc 

func (x Float32x8) Trunc() Float32x8

Trunc truncates elements towards zero.

Asm: VROUNDPS, CPU Feature: AVX

func (Float32x8) TruncScaled 

func (x Float32x8) TruncScaled(prec uint8) Float32x8

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x8) TruncScaledResidue 

func (x Float32x8) TruncScaledResidue(prec uint8) Float32x8

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

type Float32x16 

type Float32x16 struct {
	// contains filtered or unexported fields
}

Float32x16 is a 512-bit SIMD vector of 16 float32s.

func BroadcastFloat32x16 

func BroadcastFloat32x16(x float32) Float32x16

BroadcastFloat32x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadFloat32x16 

func LoadFloat32x16(s []float32) Float32x16

LoadFloat32x16 loads a Float32x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadFloat32x16Array added in go1.27.0 

func LoadFloat32x16Array(y *[16]float32) Float32x16

LoadFloat32x16Array loads a Float32x16 from an array.

func LoadFloat32x16Part added in go1.27.0 

func LoadFloat32x16Part(s []float32) (Float32x16, int)

LoadFloat32x16Part loads a Float32x16 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadFloat32x16.

func (Float32x16) Abs added in go1.27.0 

func (x Float32x16) Abs() Float32x16

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX512

func (Float32x16) Add 

func (x Float32x16) Add(y Float32x16) Float32x16

Add adds corresponding elements of two vectors.

Asm: VADDPS, CPU Feature: AVX512

func (Float32x16) AsFloat64x8 deprecated 

func (x Float32x16) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Float32x16 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsInt8x64 deprecated 

func (x Float32x16) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Float32x16 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsInt16x32 deprecated 

func (x Float32x16) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Float32x16 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsInt32x16 deprecated 

func (x Float32x16) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Float32x16 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsInt64x8 deprecated 

func (x Float32x16) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Float32x16 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsUint8x64 deprecated 

func (x Float32x16) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Float32x16 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsUint16x32 deprecated 

func (x Float32x16) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Float32x16 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsUint32x16 deprecated 

func (x Float32x16) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Float32x16 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) AsUint64x8 deprecated 

func (x Float32x16) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Float32x16 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float32x16) CeilScaled 

func (x Float32x16) CeilScaled(prec uint8) Float32x16

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x16) CeilScaledResidue 

func (x Float32x16) CeilScaledResidue(prec uint8) Float32x16

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x16) Compress 

func (x Float32x16) Compress(mask Mask32x16) Float32x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPS, CPU Feature: AVX512

func (Float32x16) ConcatPermute 

func (x Float32x16) ConcatPermute(y Float32x16, indices Uint32x16) Float32x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PS, CPU Feature: AVX512

func (Float32x16) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Float32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Float32x16) Float32x16

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX512

func (Float32x16) ConvertToInt32 

func (x Float32x16) ConvertToInt32() Int32x16

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2DQ, CPU Feature: AVX512

func (Float32x16) ConvertToUint32 

func (x Float32x16) ConvertToUint32() Uint32x16

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPS2UDQ, CPU Feature: AVX512

func (Float32x16) Div 

func (x Float32x16) Div(y Float32x16) Float32x16

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPS, CPU Feature: AVX512

func (Float32x16) Equal 

func (x Float32x16) Equal(y Float32x16) Mask32x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) Expand 

func (x Float32x16) Expand(mask Mask32x16) Float32x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPS, CPU Feature: AVX512

func (Float32x16) FloorScaled 

func (x Float32x16) FloorScaled(prec uint8) Float32x16

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x16) FloorScaledResidue 

func (x Float32x16) FloorScaledResidue(prec uint8) Float32x16

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x16) GetHi 

func (x Float32x16) GetHi() Float32x8

GetHi returns the upper half of x.

Asm: VEXTRACTF64X4, CPU Feature: AVX512

func (Float32x16) GetLo 

func (x Float32x16) GetLo() Float32x8

GetLo returns the lower half of x.

Asm: VEXTRACTF64X4, CPU Feature: AVX512

func (Float32x16) Greater 

func (x Float32x16) Greater(y Float32x16) Mask32x16

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) GreaterEqual 

func (x Float32x16) GreaterEqual(y Float32x16) Mask32x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) IfElse added in go1.27.0 

func (x Float32x16) IfElse(mask Mask32x16, y Float32x16) Float32x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Float32x16) IsNaN 

func (x Float32x16) IsNaN() Mask32x16

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) Len 

func (x Float32x16) Len() int

Len returns the number of elements in a Float32x16.

func (Float32x16) Less 

func (x Float32x16) Less(y Float32x16) Mask32x16

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) LessEqual 

func (x Float32x16) LessEqual(y Float32x16) Mask32x16

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) Masked 

func (x Float32x16) Masked(mask Mask32x16) Float32x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Float32x16) Max 

func (x Float32x16) Max(y Float32x16) Float32x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPS, CPU Feature: AVX512

func (Float32x16) Merge deprecated 

func (x Float32x16) Merge(y Float32x16, mask Mask32x16) Float32x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Float32x16) Min 

func (x Float32x16) Min(y Float32x16) Float32x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPS, CPU Feature: AVX512

func (Float32x16) Mul 

func (x Float32x16) Mul(y Float32x16) Float32x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPS, CPU Feature: AVX512

func (Float32x16) MulAdd 

func (x Float32x16) MulAdd(y Float32x16, z Float32x16) Float32x16

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PS, CPU Feature: AVX512

func (Float32x16) MulAddEvenSubOdd added in go1.27.0 

func (x Float32x16) MulAddEvenSubOdd(y Float32x16, z Float32x16) Float32x16

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PS, CPU Feature: AVX512

func (Float32x16) MulAddOddSubEven added in go1.27.0 

func (x Float32x16) MulAddOddSubEven(y Float32x16, z Float32x16) Float32x16

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PS, CPU Feature: AVX512

func (Float32x16) Neg added in go1.27.0 

func (x Float32x16) Neg() Float32x16

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX512

func (Float32x16) NotEqual 

func (x Float32x16) NotEqual(y Float32x16) Mask32x16

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPS, CPU Feature: AVX512

func (Float32x16) Permute 

func (x Float32x16) Permute(indices Uint32x16) Float32x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMPS, CPU Feature: AVX512

func (Float32x16) Reciprocal 

func (x Float32x16) Reciprocal() Float32x16

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCP14PS, CPU Feature: AVX512

func (Float32x16) ReciprocalSqrt 

func (x Float32x16) ReciprocalSqrt() Float32x16

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRT14PS, CPU Feature: AVX512

func (Float32x16) RoundScaled added in go1.27.0 

func (x Float32x16) RoundScaled(prec uint8) Float32x16

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x16) RoundScaledResidue added in go1.27.0 

func (x Float32x16) RoundScaledResidue(prec uint8) Float32x16

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

func (Float32x16) Scale 

func (x Float32x16) Scale(y Float32x16) Float32x16

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPS, CPU Feature: AVX512

func (Float32x16) SetHi 

func (x Float32x16) SetHi(y Float32x8) Float32x16

SetHi returns x with its upper half set to y.

Asm: VINSERTF64X4, CPU Feature: AVX512

func (Float32x16) SetLo 

func (x Float32x16) SetLo(y Float32x8) Float32x16

SetLo returns x with its lower half set to y.

Asm: VINSERTF64X4, CPU Feature: AVX512

func (Float32x16) Sqrt 

func (x Float32x16) Sqrt() Float32x16

Sqrt computes the square root of each element.

Asm: VSQRTPS, CPU Feature: AVX512

func (Float32x16) Store 

func (x Float32x16) Store(s []float32)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Float32x16) StoreArray added in go1.27.0 

func (x Float32x16) StoreArray(y *[16]float32)

StoreArray stores a Float32x16 to an array.

func (Float32x16) StoreArrayMasked added in go1.27.0 

func (x Float32x16) StoreArrayMasked(y *[16]float32, mask Mask32x16)

StoreArrayMasked stores a Float32x16 to an array, at those elements enabled by mask.

Asm: VMOVDQU32, CPU Feature: AVX512

func (Float32x16) StorePart added in go1.27.0 

func (x Float32x16) StorePart(s []float32) int

StorePart stores the 16 elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Float32x16) String 

func (x Float32x16) String() string

String returns a string representation of SIMD vector x.

func (Float32x16) Sub 

func (x Float32x16) Sub(y Float32x16) Float32x16

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPS, CPU Feature: AVX512

func (Float32x16) ToBits added in go1.27.0 

func (x Float32x16) ToBits() Uint32x16

ToBits reinterprets the bits of a Float32x16 vector as a Uint32x16 vector

func (Float32x16) TruncScaled 

func (x Float32x16) TruncScaled(prec uint8) Float32x16

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPS, CPU Feature: AVX512

func (Float32x16) TruncScaledResidue 

func (x Float32x16) TruncScaledResidue(prec uint8) Float32x16

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPS, CPU Feature: AVX512

type Float64x2 

type Float64x2 struct {
	// contains filtered or unexported fields
}

Float64x2 is a 128-bit SIMD vector of 2 float64s.

func BroadcastFloat64x2 

func BroadcastFloat64x2(x float64) Float64x2

BroadcastFloat64x2 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadFloat64x2 

func LoadFloat64x2(s []float64) Float64x2

LoadFloat64x2 loads a Float64x2 from a slice of elements. If s does not have at least 2 elements, it panics.

func LoadFloat64x2Array added in go1.27.0 

func LoadFloat64x2Array(y *[2]float64) Float64x2

LoadFloat64x2Array loads a Float64x2 from an array.

func LoadFloat64x2Part added in go1.27.0 

func LoadFloat64x2Part(s []float64) (Float64x2, int)

LoadFloat64x2Part loads a Float64x2 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes. If s has 2 or more elements, the function is equivalent to LoadFloat64x2.

func (Float64x2) Abs added in go1.27.0 

func (x Float64x2) Abs() Float64x2

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX

func (Float64x2) Add 

func (x Float64x2) Add(y Float64x2) Float64x2

Add adds corresponding elements of two vectors.

Asm: VADDPD, CPU Feature: AVX

func (Float64x2) AddOddSubEven added in go1.27.0 

func (x Float64x2) AddOddSubEven(y Float64x2) Float64x2

AddOddSubEven subtracts even elements and adds odd elements of two vectors.

Asm: VADDSUBPD, CPU Feature: AVX

func (Float64x2) AsFloat32x4 deprecated 

func (x Float64x2) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Float64x2 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsInt8x16 deprecated 

func (x Float64x2) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Float64x2 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsInt16x8 deprecated 

func (x Float64x2) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Float64x2 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsInt32x4 deprecated 

func (x Float64x2) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Float64x2 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsInt64x2 deprecated 

func (x Float64x2) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Float64x2 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsUint8x16 deprecated 

func (x Float64x2) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Float64x2 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsUint16x8 deprecated 

func (x Float64x2) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Float64x2 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsUint32x4 deprecated 

func (x Float64x2) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Float64x2 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) AsUint64x2 deprecated 

func (x Float64x2) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Float64x2 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x2) Ceil 

func (x Float64x2) Ceil() Float64x2

Ceil rounds elements up to the nearest integer.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x2) CeilScaled 

func (x Float64x2) CeilScaled(prec uint8) Float64x2

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x2) CeilScaledResidue 

func (x Float64x2) CeilScaledResidue(prec uint8) Float64x2

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x2) Compress 

func (x Float64x2) Compress(mask Mask64x2) Float64x2

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPD, CPU Feature: AVX512

func (Float64x2) ConcatAddPairs added in go1.27.0 

func (x Float64x2) ConcatAddPairs(y Float64x2) Float64x2

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1].

Asm: VHADDPD, CPU Feature: AVX

func (Float64x2) ConcatPermute 

func (x Float64x2) ConcatPermute(y Float64x2, indices Uint64x2) Float64x2

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PD, CPU Feature: AVX512

func (Float64x2) ConcatPermuteScalars added in go1.27.0 

func (x Float64x2) ConcatPermuteScalars(a, b uint8, y Float64x2) Float64x2

ConcatPermuteScalars returns the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Float64x2) ConcatSubPairs added in go1.27.0 

func (x Float64x2) ConcatSubPairs(y Float64x2) Float64x2

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1] and y = [y0, y1], the result is [x0-x1, y0-y1].

Asm: VHSUBPD, CPU Feature: AVX

func (Float64x2) ConvertToFloat32 

func (x Float64x2) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32. The result vector's elements are rounded to the nearest value.

Asm: VCVTPD2PSX, CPU Feature: AVX

func (Float64x2) ConvertToInt32 

func (x Float64x2) ConvertToInt32() Int32x4

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2DQX, CPU Feature: AVX

func (Float64x2) ConvertToInt64 

func (x Float64x2) ConvertToInt64() Int64x2

ConvertToInt64 converts element values to int64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2QQ, CPU Feature: AVX512

func (Float64x2) ConvertToUint32 

func (x Float64x2) ConvertToUint32() Uint32x4

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UDQX, CPU Feature: AVX512

func (Float64x2) ConvertToUint64 

func (x Float64x2) ConvertToUint64() Uint64x2

ConvertToUint64 converts element values to uint64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UQQ, CPU Feature: AVX512

func (Float64x2) Div 

func (x Float64x2) Div(y Float64x2) Float64x2

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPD, CPU Feature: AVX

func (Float64x2) Equal 

func (x Float64x2) Equal(y Float64x2) Mask64x2

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) Expand 

func (x Float64x2) Expand(mask Mask64x2) Float64x2

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPD, CPU Feature: AVX512

func (Float64x2) Floor 

func (x Float64x2) Floor() Float64x2

Floor rounds elements down to the nearest integer.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x2) FloorScaled 

func (x Float64x2) FloorScaled(prec uint8) Float64x2

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x2) FloorScaledResidue 

func (x Float64x2) FloorScaledResidue(prec uint8) Float64x2

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x2) GetElem 

func (x Float64x2) GetElem(index uint8) float64

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRQ, CPU Feature: AVX

func (Float64x2) Greater 

func (x Float64x2) Greater(y Float64x2) Mask64x2

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) GreaterEqual 

func (x Float64x2) GreaterEqual(y Float64x2) Mask64x2

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) IfElse added in go1.27.0 

func (x Float64x2) IfElse(mask Mask64x2, y Float64x2) Float64x2

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Float64x2) IsNaN 

func (x Float64x2) IsNaN() Mask64x2

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) Len 

func (x Float64x2) Len() int

Len returns the number of elements in a Float64x2.

func (Float64x2) Less 

func (x Float64x2) Less(y Float64x2) Mask64x2

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) LessEqual 

func (x Float64x2) LessEqual(y Float64x2) Mask64x2

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) Masked 

func (x Float64x2) Masked(mask Mask64x2) Float64x2

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Float64x2) Max 

func (x Float64x2) Max(y Float64x2) Float64x2

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPD, CPU Feature: AVX

func (Float64x2) Merge deprecated 

func (x Float64x2) Merge(y Float64x2, mask Mask64x2) Float64x2

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Float64x2) Min 

func (x Float64x2) Min(y Float64x2) Float64x2

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPD, CPU Feature: AVX

func (Float64x2) Mul 

func (x Float64x2) Mul(y Float64x2) Float64x2

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPD, CPU Feature: AVX

func (Float64x2) MulAdd 

func (x Float64x2) MulAdd(y Float64x2, z Float64x2) Float64x2

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PD, CPU Feature: FMA

func (Float64x2) MulAddEvenSubOdd added in go1.27.0 

func (x Float64x2) MulAddEvenSubOdd(y Float64x2, z Float64x2) Float64x2

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PD, CPU Feature: FMA

func (Float64x2) MulAddOddSubEven added in go1.27.0 

func (x Float64x2) MulAddOddSubEven(y Float64x2, z Float64x2) Float64x2

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PD, CPU Feature: FMA

func (Float64x2) Neg added in go1.27.0 

func (x Float64x2) Neg() Float64x2

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX

func (Float64x2) NotEqual 

func (x Float64x2) NotEqual(y Float64x2) Mask64x2

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x2) Reciprocal 

func (x Float64x2) Reciprocal() Float64x2

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCP14PD, CPU Feature: AVX512

func (Float64x2) ReciprocalSqrt 

func (x Float64x2) ReciprocalSqrt() Float64x2

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRT14PD, CPU Feature: AVX512

func (Float64x2) Round added in go1.27.0 

func (x Float64x2) Round() Float64x2

Round rounds elements to the nearest integer, rounding ties to even.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x2) RoundScaled added in go1.27.0 

func (x Float64x2) RoundScaled(prec uint8) Float64x2

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x2) RoundScaledResidue added in go1.27.0 

func (x Float64x2) RoundScaledResidue(prec uint8) Float64x2

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x2) Scale 

func (x Float64x2) Scale(y Float64x2) Float64x2

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPD, CPU Feature: AVX512

func (Float64x2) SetElem 

func (x Float64x2) SetElem(index uint8, y float64) Float64x2

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRQ, CPU Feature: AVX

func (Float64x2) Sqrt 

func (x Float64x2) Sqrt() Float64x2

Sqrt computes the square root of each element.

Asm: VSQRTPD, CPU Feature: AVX

func (Float64x2) Store 

func (x Float64x2) Store(s []float64)

Store stores the elements of x into a slice. If s does not have at least 2 elements, it panics.

func (Float64x2) StoreArray added in go1.27.0 

func (x Float64x2) StoreArray(y *[2]float64)

StoreArray stores a Float64x2 to an array.

func (Float64x2) StoreArrayMasked added in go1.27.0 

func (x Float64x2) StoreArrayMasked(y *[2]float64, mask Mask64x2)

StoreArrayMasked stores a Float64x2 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Float64x2) StorePart added in go1.27.0 

func (x Float64x2) StorePart(s []float64) int

StorePart stores the 2 elements of x into the slice s. It stores as many elements as will fit in s. If s has 2 or more elements, the method is equivalent to x.Store.

func (Float64x2) String 

func (x Float64x2) String() string

String returns a string representation of SIMD vector x.

func (Float64x2) Sub 

func (x Float64x2) Sub(y Float64x2) Float64x2

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPD, CPU Feature: AVX

func (Float64x2) ToBits added in go1.27.0 

func (x Float64x2) ToBits() Uint64x2

ToBits reinterprets the bits of a Float64x2 vector as a Uint64x2 vector

func (Float64x2) Trunc 

func (x Float64x2) Trunc() Float64x2

Trunc truncates elements towards zero.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x2) TruncScaled 

func (x Float64x2) TruncScaled(prec uint8) Float64x2

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x2) TruncScaledResidue 

func (x Float64x2) TruncScaledResidue(prec uint8) Float64x2

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

type Float64x4 

type Float64x4 struct {
	// contains filtered or unexported fields
}

Float64x4 is a 256-bit SIMD vector of 4 float64s.

func BroadcastFloat64x4 

func BroadcastFloat64x4(x float64) Float64x4

BroadcastFloat64x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadFloat64x4 

func LoadFloat64x4(s []float64) Float64x4

LoadFloat64x4 loads a Float64x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadFloat64x4Array added in go1.27.0 

func LoadFloat64x4Array(y *[4]float64) Float64x4

LoadFloat64x4Array loads a Float64x4 from an array.

func LoadFloat64x4Part added in go1.27.0 

func LoadFloat64x4Part(s []float64) (Float64x4, int)

LoadFloat64x4Part loads a Float64x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadFloat64x4.

func (Float64x4) Abs added in go1.27.0 

func (x Float64x4) Abs() Float64x4

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX2

func (Float64x4) Add 

func (x Float64x4) Add(y Float64x4) Float64x4

Add adds corresponding elements of two vectors.

Asm: VADDPD, CPU Feature: AVX

func (Float64x4) AddOddSubEven added in go1.27.0 

func (x Float64x4) AddOddSubEven(y Float64x4) Float64x4

AddOddSubEven subtracts even elements and adds odd elements of two vectors.

Asm: VADDSUBPD, CPU Feature: AVX

func (Float64x4) AsFloat32x8 deprecated 

func (x Float64x4) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Float64x4 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsInt8x32 deprecated 

func (x Float64x4) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Float64x4 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsInt16x16 deprecated 

func (x Float64x4) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Float64x4 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsInt32x8 deprecated 

func (x Float64x4) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Float64x4 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsInt64x4 deprecated 

func (x Float64x4) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Float64x4 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsUint8x32 deprecated 

func (x Float64x4) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Float64x4 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsUint16x16 deprecated 

func (x Float64x4) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Float64x4 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsUint32x8 deprecated 

func (x Float64x4) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Float64x4 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) AsUint64x4 deprecated 

func (x Float64x4) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Float64x4 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x4) Ceil 

func (x Float64x4) Ceil() Float64x4

Ceil rounds elements up to the nearest integer.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x4) CeilScaled 

func (x Float64x4) CeilScaled(prec uint8) Float64x4

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x4) CeilScaledResidue 

func (x Float64x4) CeilScaledResidue(prec uint8) Float64x4

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x4) Compress 

func (x Float64x4) Compress(mask Mask64x4) Float64x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPD, CPU Feature: AVX512

func (Float64x4) ConcatAddPairsGrouped added in go1.27.0 

func (x Float64x4) ConcatAddPairsGrouped(y Float64x4) Float64x4

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1].

Asm: VHADDPD, CPU Feature: AVX

func (Float64x4) ConcatPermute 

func (x Float64x4) ConcatPermute(y Float64x4, indices Uint64x4) Float64x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PD, CPU Feature: AVX512

func (Float64x4) ConcatPermute128Scalars added in go1.27.0 

func (x Float64x4) ConcatPermute128Scalars(lo, hi uint8, y Float64x4) Float64x4

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 50, 51}.ConcatPermute128Scalars(3, 0, {60, 61, 70, 71})

returns {70, 71, 40, 41}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2F128, CPU Feature: AVX

func (Float64x4) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Float64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Float64x4) Float64x4

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Float64x4) ConcatSubPairsGrouped added in go1.27.0 

func (x Float64x4) ConcatSubPairsGrouped(y Float64x4) Float64x4

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1] and y = [y0, y1], the result is [x0-x1, y0-y1].

Asm: VHSUBPD, CPU Feature: AVX

func (Float64x4) ConvertToFloat32 

func (x Float64x4) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32. The result vector's elements are rounded to the nearest value.

Asm: VCVTPD2PSY, CPU Feature: AVX

func (Float64x4) ConvertToInt32 

func (x Float64x4) ConvertToInt32() Int32x4

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2DQY, CPU Feature: AVX

func (Float64x4) ConvertToInt64 

func (x Float64x4) ConvertToInt64() Int64x4

ConvertToInt64 converts element values to int64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2QQ, CPU Feature: AVX512

func (Float64x4) ConvertToUint32 

func (x Float64x4) ConvertToUint32() Uint32x4

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UDQY, CPU Feature: AVX512

func (Float64x4) ConvertToUint64 

func (x Float64x4) ConvertToUint64() Uint64x4

ConvertToUint64 converts element values to uint64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UQQ, CPU Feature: AVX512

func (Float64x4) Div 

func (x Float64x4) Div(y Float64x4) Float64x4

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPD, CPU Feature: AVX

func (Float64x4) Equal 

func (x Float64x4) Equal(y Float64x4) Mask64x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) Expand 

func (x Float64x4) Expand(mask Mask64x4) Float64x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPD, CPU Feature: AVX512

func (Float64x4) Floor 

func (x Float64x4) Floor() Float64x4

Floor rounds elements down to the nearest integer.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x4) FloorScaled 

func (x Float64x4) FloorScaled(prec uint8) Float64x4

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x4) FloorScaledResidue 

func (x Float64x4) FloorScaledResidue(prec uint8) Float64x4

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x4) GetHi 

func (x Float64x4) GetHi() Float64x2

GetHi returns the upper half of x.

Asm: VEXTRACTF128, CPU Feature: AVX

func (Float64x4) GetLo 

func (x Float64x4) GetLo() Float64x2

GetLo returns the lower half of x.

Asm: VEXTRACTF128, CPU Feature: AVX

func (Float64x4) Greater 

func (x Float64x4) Greater(y Float64x4) Mask64x4

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) GreaterEqual 

func (x Float64x4) GreaterEqual(y Float64x4) Mask64x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) IfElse added in go1.27.0 

func (x Float64x4) IfElse(mask Mask64x4, y Float64x4) Float64x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Float64x4) IsNaN 

func (x Float64x4) IsNaN() Mask64x4

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) Len 

func (x Float64x4) Len() int

Len returns the number of elements in a Float64x4.

func (Float64x4) Less 

func (x Float64x4) Less(y Float64x4) Mask64x4

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) LessEqual 

func (x Float64x4) LessEqual(y Float64x4) Mask64x4

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) Masked 

func (x Float64x4) Masked(mask Mask64x4) Float64x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Float64x4) Max 

func (x Float64x4) Max(y Float64x4) Float64x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPD, CPU Feature: AVX

func (Float64x4) Merge deprecated 

func (x Float64x4) Merge(y Float64x4, mask Mask64x4) Float64x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Float64x4) Min 

func (x Float64x4) Min(y Float64x4) Float64x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPD, CPU Feature: AVX

func (Float64x4) Mul 

func (x Float64x4) Mul(y Float64x4) Float64x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPD, CPU Feature: AVX

func (Float64x4) MulAdd 

func (x Float64x4) MulAdd(y Float64x4, z Float64x4) Float64x4

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PD, CPU Feature: FMA

func (Float64x4) MulAddEvenSubOdd added in go1.27.0 

func (x Float64x4) MulAddEvenSubOdd(y Float64x4, z Float64x4) Float64x4

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PD, CPU Feature: FMA

func (Float64x4) MulAddOddSubEven added in go1.27.0 

func (x Float64x4) MulAddOddSubEven(y Float64x4, z Float64x4) Float64x4

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PD, CPU Feature: FMA

func (Float64x4) Neg added in go1.27.0 

func (x Float64x4) Neg() Float64x4

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX2

func (Float64x4) NotEqual 

func (x Float64x4) NotEqual(y Float64x4) Mask64x4

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPD, CPU Feature: AVX

func (Float64x4) Permute 

func (x Float64x4) Permute(indices Uint64x4) Float64x4

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMPD, CPU Feature: AVX512

func (Float64x4) Reciprocal 

func (x Float64x4) Reciprocal() Float64x4

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCP14PD, CPU Feature: AVX512

func (Float64x4) ReciprocalSqrt 

func (x Float64x4) ReciprocalSqrt() Float64x4

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRT14PD, CPU Feature: AVX512

func (Float64x4) Round added in go1.27.0 

func (x Float64x4) Round() Float64x4

Round rounds elements to the nearest integer, rounding ties to even.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x4) RoundScaled added in go1.27.0 

func (x Float64x4) RoundScaled(prec uint8) Float64x4

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x4) RoundScaledResidue added in go1.27.0 

func (x Float64x4) RoundScaledResidue(prec uint8) Float64x4

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x4) Scale 

func (x Float64x4) Scale(y Float64x4) Float64x4

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPD, CPU Feature: AVX512

func (Float64x4) SetHi 

func (x Float64x4) SetHi(y Float64x2) Float64x4

SetHi returns x with its upper half set to y.

Asm: VINSERTF128, CPU Feature: AVX

func (Float64x4) SetLo 

func (x Float64x4) SetLo(y Float64x2) Float64x4

SetLo returns x with its lower half set to y.

Asm: VINSERTF128, CPU Feature: AVX

func (Float64x4) Sqrt 

func (x Float64x4) Sqrt() Float64x4

Sqrt computes the square root of each element.

Asm: VSQRTPD, CPU Feature: AVX

func (Float64x4) Store 

func (x Float64x4) Store(s []float64)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Float64x4) StoreArray added in go1.27.0 

func (x Float64x4) StoreArray(y *[4]float64)

StoreArray stores a Float64x4 to an array.

func (Float64x4) StoreArrayMasked added in go1.27.0 

func (x Float64x4) StoreArrayMasked(y *[4]float64, mask Mask64x4)

StoreArrayMasked stores a Float64x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Float64x4) StorePart added in go1.27.0 

func (x Float64x4) StorePart(s []float64) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Float64x4) String 

func (x Float64x4) String() string

String returns a string representation of SIMD vector x.

func (Float64x4) Sub 

func (x Float64x4) Sub(y Float64x4) Float64x4

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPD, CPU Feature: AVX

func (Float64x4) ToBits added in go1.27.0 

func (x Float64x4) ToBits() Uint64x4

ToBits reinterprets the bits of a Float64x4 vector as a Uint64x4 vector

func (Float64x4) Trunc 

func (x Float64x4) Trunc() Float64x4

Trunc truncates elements towards zero.

Asm: VROUNDPD, CPU Feature: AVX

func (Float64x4) TruncScaled 

func (x Float64x4) TruncScaled(prec uint8) Float64x4

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x4) TruncScaledResidue 

func (x Float64x4) TruncScaledResidue(prec uint8) Float64x4

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

type Float64x8 

type Float64x8 struct {
	// contains filtered or unexported fields
}

Float64x8 is a 512-bit SIMD vector of 8 float64s.

func BroadcastFloat64x8 

func BroadcastFloat64x8(x float64) Float64x8

BroadcastFloat64x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadFloat64x8 

func LoadFloat64x8(s []float64) Float64x8

LoadFloat64x8 loads a Float64x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadFloat64x8Array added in go1.27.0 

func LoadFloat64x8Array(y *[8]float64) Float64x8

LoadFloat64x8Array loads a Float64x8 from an array.

func LoadFloat64x8Part added in go1.27.0 

func LoadFloat64x8Part(s []float64) (Float64x8, int)

LoadFloat64x8Part loads a Float64x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadFloat64x8.

func (Float64x8) Abs added in go1.27.0 

func (x Float64x8) Abs() Float64x8

Abs returns the absolute values of the elements of x

Emulated, CPU Feature AVX512

func (Float64x8) Add 

func (x Float64x8) Add(y Float64x8) Float64x8

Add adds corresponding elements of two vectors.

Asm: VADDPD, CPU Feature: AVX512

func (Float64x8) AsFloat32x16 deprecated 

func (x Float64x8) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Float64x8 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsInt8x64 deprecated 

func (x Float64x8) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Float64x8 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsInt16x32 deprecated 

func (x Float64x8) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Float64x8 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsInt32x16 deprecated 

func (x Float64x8) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Float64x8 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsInt64x8 deprecated 

func (x Float64x8) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Float64x8 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsUint8x64 deprecated 

func (x Float64x8) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Float64x8 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsUint16x32 deprecated 

func (x Float64x8) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Float64x8 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsUint32x16 deprecated 

func (x Float64x8) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Float64x8 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) AsUint64x8 deprecated 

func (x Float64x8) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Float64x8 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Float64x8) CeilScaled 

func (x Float64x8) CeilScaled(prec uint8) Float64x8

CeilScaled rounds elements up with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x8) CeilScaledResidue 

func (x Float64x8) CeilScaledResidue(prec uint8) Float64x8

CeilScaledResidue computes the difference after ceiling with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x8) Compress 

func (x Float64x8) Compress(mask Mask64x8) Float64x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VCOMPRESSPD, CPU Feature: AVX512

func (Float64x8) ConcatPermute 

func (x Float64x8) ConcatPermute(y Float64x8, indices Uint64x8) Float64x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2PD, CPU Feature: AVX512

func (Float64x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Float64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Float64x8) Float64x8

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX512

func (Float64x8) ConvertToFloat32 

func (x Float64x8) ConvertToFloat32() Float32x8

ConvertToFloat32 converts element values to float32. The result vector's elements are rounded to the nearest value.

Asm: VCVTPD2PS, CPU Feature: AVX512

func (Float64x8) ConvertToInt32 

func (x Float64x8) ConvertToInt32() Int32x8

ConvertToInt32 converts element values to int32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2DQ, CPU Feature: AVX512

func (Float64x8) ConvertToInt64 

func (x Float64x8) ConvertToInt64() Int64x8

ConvertToInt64 converts element values to int64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in int64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2QQ, CPU Feature: AVX512

func (Float64x8) ConvertToUint32 

func (x Float64x8) ConvertToUint32() Uint32x8

ConvertToUint32 converts element values to uint32. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint32, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UDQ, CPU Feature: AVX512

func (Float64x8) ConvertToUint64 

func (x Float64x8) ConvertToUint64() Uint64x8

ConvertToUint64 converts element values to uint64. When a conversion is inexact, a truncated (round toward zero) value is returned. If a converted result cannot be represented in uint64, an implementation-defined architecture-specific value is returned.

Asm: VCVTTPD2UQQ, CPU Feature: AVX512

func (Float64x8) Div 

func (x Float64x8) Div(y Float64x8) Float64x8

Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.

Asm: VDIVPD, CPU Feature: AVX512

func (Float64x8) Equal 

func (x Float64x8) Equal(y Float64x8) Mask64x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) Expand 

func (x Float64x8) Expand(mask Mask64x8) Float64x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VEXPANDPD, CPU Feature: AVX512

func (Float64x8) FloorScaled 

func (x Float64x8) FloorScaled(prec uint8) Float64x8

FloorScaled rounds elements down with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x8) FloorScaledResidue 

func (x Float64x8) FloorScaledResidue(prec uint8) Float64x8

FloorScaledResidue computes the difference after flooring with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x8) GetHi 

func (x Float64x8) GetHi() Float64x4

GetHi returns the upper half of x.

Asm: VEXTRACTF64X4, CPU Feature: AVX512

func (Float64x8) GetLo 

func (x Float64x8) GetLo() Float64x4

GetLo returns the lower half of x.

Asm: VEXTRACTF64X4, CPU Feature: AVX512

func (Float64x8) Greater 

func (x Float64x8) Greater(y Float64x8) Mask64x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) GreaterEqual 

func (x Float64x8) GreaterEqual(y Float64x8) Mask64x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) IfElse added in go1.27.0 

func (x Float64x8) IfElse(mask Mask64x8, y Float64x8) Float64x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Float64x8) IsNaN 

func (x Float64x8) IsNaN() Mask64x8

IsNaN returns a mask whose elements indicate whether the corresponding elements of x are NaN.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) Len 

func (x Float64x8) Len() int

Len returns the number of elements in a Float64x8.

func (Float64x8) Less 

func (x Float64x8) Less(y Float64x8) Mask64x8

Less returns a mask whose elements indicate whether x < y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) LessEqual 

func (x Float64x8) LessEqual(y Float64x8) Mask64x8

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) Masked 

func (x Float64x8) Masked(mask Mask64x8) Float64x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Float64x8) Max 

func (x Float64x8) Max(y Float64x8) Float64x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VMAXPD, CPU Feature: AVX512

func (Float64x8) Merge deprecated 

func (x Float64x8) Merge(y Float64x8, mask Mask64x8) Float64x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Float64x8) Min 

func (x Float64x8) Min(y Float64x8) Float64x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VMINPD, CPU Feature: AVX512

func (Float64x8) Mul 

func (x Float64x8) Mul(y Float64x8) Float64x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VMULPD, CPU Feature: AVX512

func (Float64x8) MulAdd 

func (x Float64x8) MulAdd(y Float64x8, z Float64x8) Float64x8

MulAdd performs a fused (x * y) + z.

Asm: VFMADD213PD, CPU Feature: AVX512

func (Float64x8) MulAddEvenSubOdd added in go1.27.0 

func (x Float64x8) MulAddEvenSubOdd(y Float64x8, z Float64x8) Float64x8

MulAddEvenSubOdd performs a fused (x * y) - z for odd-indexed elements, and (x * y) + z for even-indexed elements.

Asm: VFMADDSUB213PD, CPU Feature: AVX512

func (Float64x8) MulAddOddSubEven added in go1.27.0 

func (x Float64x8) MulAddOddSubEven(y Float64x8, z Float64x8) Float64x8

MulAddOddSubEven performs a fused (x * y) + z for odd-indexed elements, and (x * y) - z for even-indexed elements.

Asm: VFMSUBADD213PD, CPU Feature: AVX512

func (Float64x8) Neg added in go1.27.0 

func (x Float64x8) Neg() Float64x8

Neg returns the negation of the elements of x

Emulated, CPU Feature AVX512

func (Float64x8) NotEqual 

func (x Float64x8) NotEqual(y Float64x8) Mask64x8

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VCMPPD, CPU Feature: AVX512

func (Float64x8) Permute 

func (x Float64x8) Permute(indices Uint64x8) Float64x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMPD, CPU Feature: AVX512

func (Float64x8) Reciprocal 

func (x Float64x8) Reciprocal() Float64x8

Reciprocal computes an approximate reciprocal of each element.

Asm: VRCP14PD, CPU Feature: AVX512

func (Float64x8) ReciprocalSqrt 

func (x Float64x8) ReciprocalSqrt() Float64x8

ReciprocalSqrt computes an approximate reciprocal of the square root of each element.

Asm: VRSQRT14PD, CPU Feature: AVX512

func (Float64x8) RoundScaled added in go1.27.0 

func (x Float64x8) RoundScaled(prec uint8) Float64x8

RoundScaled rounds elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x8) RoundScaledResidue added in go1.27.0 

func (x Float64x8) RoundScaledResidue(prec uint8) Float64x8

RoundScaledResidue computes the difference after rounding with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

func (Float64x8) Scale 

func (x Float64x8) Scale(y Float64x8) Float64x8

Scale multiplies each element of x by 2 raised to the power of the floor of the corresponding element in y.

Asm: VSCALEFPD, CPU Feature: AVX512

func (Float64x8) SetHi 

func (x Float64x8) SetHi(y Float64x4) Float64x8

SetHi returns x with its upper half set to y.

Asm: VINSERTF64X4, CPU Feature: AVX512

func (Float64x8) SetLo 

func (x Float64x8) SetLo(y Float64x4) Float64x8

SetLo returns x with its lower half set to y.

Asm: VINSERTF64X4, CPU Feature: AVX512

func (Float64x8) Sqrt 

func (x Float64x8) Sqrt() Float64x8

Sqrt computes the square root of each element.

Asm: VSQRTPD, CPU Feature: AVX512

func (Float64x8) Store 

func (x Float64x8) Store(s []float64)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Float64x8) StoreArray added in go1.27.0 

func (x Float64x8) StoreArray(y *[8]float64)

StoreArray stores a Float64x8 to an array.

func (Float64x8) StoreArrayMasked added in go1.27.0 

func (x Float64x8) StoreArrayMasked(y *[8]float64, mask Mask64x8)

StoreArrayMasked stores a Float64x8 to an array, at those elements enabled by mask.

Asm: VMOVDQU64, CPU Feature: AVX512

func (Float64x8) StorePart added in go1.27.0 

func (x Float64x8) StorePart(s []float64) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Float64x8) String 

func (x Float64x8) String() string

String returns a string representation of SIMD vector x.

func (Float64x8) Sub 

func (x Float64x8) Sub(y Float64x8) Float64x8

Sub subtracts corresponding elements of two vectors.

Asm: VSUBPD, CPU Feature: AVX512

func (Float64x8) ToBits added in go1.27.0 

func (x Float64x8) ToBits() Uint64x8

ToBits reinterprets the bits of a Float64x8 vector as a Uint64x8 vector

func (Float64x8) TruncScaled 

func (x Float64x8) TruncScaled(prec uint8) Float64x8

TruncScaled truncates elements with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VRNDSCALEPD, CPU Feature: AVX512

func (Float64x8) TruncScaledResidue 

func (x Float64x8) TruncScaledResidue(prec uint8) Float64x8

TruncScaledResidue computes the difference after truncating with specified precision.

A non-constant value of prec may result in significantly worse performance for this operation.

Asm: VREDUCEPD, CPU Feature: AVX512

type Int8x16 

type Int8x16 struct {
	// contains filtered or unexported fields
}

Int8x16 is a 128-bit SIMD vector of 16 int8s.

func BroadcastInt8x16 

func BroadcastInt8x16(x int8) Int8x16

BroadcastInt8x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt8x16 

func LoadInt8x16(s []int8) Int8x16

LoadInt8x16 loads an Int8x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadInt8x16Array added in go1.27.0 

func LoadInt8x16Array(y *[16]int8) Int8x16

LoadInt8x16Array loads an Int8x16 from an array.

func LoadInt8x16Part added in go1.27.0 

func LoadInt8x16Part(s []int8) (Int8x16, int)

LoadInt8x16Part loads a Int8x16 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadInt8x16.

func (Int8x16) Abs 

func (x Int8x16) Abs() Int8x16

Abs computes the absolute value of each element.

Asm: VPABSB, CPU Feature: AVX

func (Int8x16) Add 

func (x Int8x16) Add(y Int8x16) Int8x16

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX

func (Int8x16) AddSaturated 

func (x Int8x16) AddSaturated(y Int8x16) Int8x16

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSB, CPU Feature: AVX

func (Int8x16) And 

func (x Int8x16) And(y Int8x16) Int8x16

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Int8x16) AndNot 

func (x Int8x16) AndNot(y Int8x16) Int8x16

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Int8x16) AsFloat32x4 deprecated 

func (x Int8x16) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Int8x16 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsFloat64x2 deprecated 

func (x Int8x16) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Int8x16 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsInt16x8 deprecated 

func (x Int8x16) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Int8x16 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsInt32x4 deprecated 

func (x Int8x16) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Int8x16 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsInt64x2 deprecated 

func (x Int8x16) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Int8x16 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsUint8x16 deprecated 

func (x Int8x16) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Int8x16 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsUint16x8 deprecated 

func (x Int8x16) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Int8x16 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsUint32x4 deprecated 

func (x Int8x16) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Int8x16 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) AsUint64x2 deprecated 

func (x Int8x16) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Int8x16 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x16) Compress 

func (x Int8x16) Compress(mask Mask8x16) Int8x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Int8x16) ConcatPermute 

func (x Int8x16) ConcatPermute(y Int8x16, indices Uint8x16) Int8x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Int8x16) ConvertToUint8 added in go1.27.0 

func (x Int8x16) ConvertToUint8() Uint8x16

ConvertToUint8 converts a Int8x16 vector to a Uint8x16 vector

func (Int8x16) Equal 

func (x Int8x16) Equal(y Int8x16) Mask8x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX

func (Int8x16) Expand 

func (x Int8x16) Expand(mask Mask8x16) Int8x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Int8x16) ExtendLo2ToInt64 

func (x Int8x16) ExtendLo2ToInt64() Int64x2

ExtendLo2ToInt64 sign-extends 2 lowest vector element values to int64.

Asm: VPMOVSXBQ, CPU Feature: AVX

func (Int8x16) ExtendLo4ToInt32 

func (x Int8x16) ExtendLo4ToInt32() Int32x4

ExtendLo4ToInt32 sign-extends 4 lowest vector element values to int32.

Asm: VPMOVSXBD, CPU Feature: AVX

func (Int8x16) ExtendLo4ToInt64 

func (x Int8x16) ExtendLo4ToInt64() Int64x4

ExtendLo4ToInt64 sign-extends 4 lowest vector element values to int64.

Asm: VPMOVSXBQ, CPU Feature: AVX2

func (Int8x16) ExtendLo8ToInt16 

func (x Int8x16) ExtendLo8ToInt16() Int16x8

ExtendLo8ToInt16 sign-extends 8 lowest vector element values to int16.

Asm: VPMOVSXBW, CPU Feature: AVX

func (Int8x16) ExtendLo8ToInt32 

func (x Int8x16) ExtendLo8ToInt32() Int32x8

ExtendLo8ToInt32 sign-extends 8 lowest vector element values to int32.

Asm: VPMOVSXBD, CPU Feature: AVX2

func (Int8x16) ExtendLo8ToInt64 

func (x Int8x16) ExtendLo8ToInt64() Int64x8

ExtendLo8ToInt64 sign-extends 8 lowest vector element values to int64.

Asm: VPMOVSXBQ, CPU Feature: AVX512

func (Int8x16) ExtendToInt16 

func (x Int8x16) ExtendToInt16() Int16x16

ExtendToInt16 sign-extends element values to int16.

Asm: VPMOVSXBW, CPU Feature: AVX2

func (Int8x16) ExtendToInt32 

func (x Int8x16) ExtendToInt32() Int32x16

ExtendToInt32 sign-extends element values to int32.

Asm: VPMOVSXBD, CPU Feature: AVX512

func (Int8x16) GetElem 

func (x Int8x16) GetElem(index uint8) int8

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRB, CPU Feature: AVX

func (Int8x16) Greater 

func (x Int8x16) Greater(y Int8x16) Mask8x16

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTB, CPU Feature: AVX

func (Int8x16) GreaterEqual 

func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Int8x16) IfElse added in go1.27.0 

func (x Int8x16) IfElse(mask Mask8x16, y Int8x16) Int8x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Int8x16) IsZero 

func (x Int8x16) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int8x16) Len 

func (x Int8x16) Len() int

Len returns the number of elements in an Int8x16.

func (Int8x16) Less 

func (x Int8x16) Less(y Int8x16) Mask8x16

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Int8x16) LessEqual 

func (x Int8x16) LessEqual(y Int8x16) Mask8x16

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Int8x16) Masked 

func (x Int8x16) Masked(mask Mask8x16) Int8x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Int8x16) Max 

func (x Int8x16) Max(y Int8x16) Int8x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSB, CPU Feature: AVX

func (Int8x16) Merge deprecated 

func (x Int8x16) Merge(y Int8x16, mask Mask8x16) Int8x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Int8x16) Min 

func (x Int8x16) Min(y Int8x16) Int8x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSB, CPU Feature: AVX

func (Int8x16) Mul added in go1.27.0 

func (x Int8x16) Mul(y Int8x16) Int8x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX

func (Int8x16) MulSign added in go1.27.0 

func (x Int8x16) MulSign(y Int8x16) Int8x16

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGNB, CPU Feature: AVX

func (Int8x16) Neg added in go1.27.0 

func (x Int8x16) Neg() Int8x16

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX

func (Int8x16) Not 

func (x Int8x16) Not() Int8x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Int8x16) NotEqual 

func (x Int8x16) NotEqual(y Int8x16) Mask8x16

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Int8x16) OnesCount 

func (x Int8x16) OnesCount() Int8x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Int8x16) Or 

func (x Int8x16) Or(y Int8x16) Int8x16

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Int8x16) Permute 

func (x Int8x16) Permute(indices Uint8x16) Int8x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Int8x16) PermuteOrZero 

func (x Int8x16) PermuteOrZero(indices Int8x16) Int8x16

PermuteOrZero permutes x. If an index is negative, the result is 0. 

if indices[i] >= 0 {
    z[i] = x[indices[i] % len(x)]
} else {
    z[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX

func (Int8x16) SetElem 

func (x Int8x16) SetElem(index uint8, y int8) Int8x16

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRB, CPU Feature: AVX

func (Int8x16) Store 

func (x Int8x16) Store(s []int8)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Int8x16) StoreArray added in go1.27.0 

func (x Int8x16) StoreArray(y *[16]int8)

StoreArray stores an Int8x16 to an array.

func (Int8x16) StorePart added in go1.27.0 

func (x Int8x16) StorePart(s []int8) int

StorePart stores the 16 elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Int8x16) String 

func (x Int8x16) String() string

String returns a string representation of SIMD vector x.

func (Int8x16) Sub 

func (x Int8x16) Sub(y Int8x16) Int8x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX

func (Int8x16) SubSaturated 

func (x Int8x16) SubSaturated(y Int8x16) Int8x16

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSB, CPU Feature: AVX

func (Int8x16) ToBits added in go1.27.0 

func (x Int8x16) ToBits() Uint8x16

ToBits reinterprets the bits of a Int8x16 vector as a Uint8x16 vector

func (Int8x16) ToMask 

func (from Int8x16) ToMask() (to Mask8x16)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int8x16) Xor 

func (x Int8x16) Xor(y Int8x16) Int8x16

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Int8x32 

type Int8x32 struct {
	// contains filtered or unexported fields
}

Int8x32 is a 256-bit SIMD vector of 32 int8s.

func BroadcastInt8x32 

func BroadcastInt8x32(x int8) Int8x32

BroadcastInt8x32 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt8x32 

func LoadInt8x32(s []int8) Int8x32

LoadInt8x32 loads an Int8x32 from a slice of elements. If s does not have at least 32 elements, it panics.

func LoadInt8x32Array added in go1.27.0 

func LoadInt8x32Array(y *[32]int8) Int8x32

LoadInt8x32Array loads an Int8x32 from an array.

func LoadInt8x32Part added in go1.27.0 

func LoadInt8x32Part(s []int8) (Int8x32, int)

LoadInt8x32Part loads a Int8x32 from the slice s. If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes. If s has 32 or more elements, the function is equivalent to LoadInt8x32Slice.

func (Int8x32) Abs 

func (x Int8x32) Abs() Int8x32

Abs computes the absolute value of each element.

Asm: VPABSB, CPU Feature: AVX2

func (Int8x32) Add 

func (x Int8x32) Add(y Int8x32) Int8x32

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX2

func (Int8x32) AddSaturated 

func (x Int8x32) AddSaturated(y Int8x32) Int8x32

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSB, CPU Feature: AVX2

func (Int8x32) And 

func (x Int8x32) And(y Int8x32) Int8x32

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Int8x32) AndNot 

func (x Int8x32) AndNot(y Int8x32) Int8x32

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Int8x32) AsFloat32x8 deprecated 

func (x Int8x32) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Int8x32 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsFloat64x4 deprecated 

func (x Int8x32) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Int8x32 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsInt16x16 deprecated 

func (x Int8x32) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Int8x32 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsInt32x8 deprecated 

func (x Int8x32) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Int8x32 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsInt64x4 deprecated 

func (x Int8x32) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Int8x32 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsUint8x32 deprecated 

func (x Int8x32) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Int8x32 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsUint16x16 deprecated 

func (x Int8x32) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Int8x32 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsUint32x8 deprecated 

func (x Int8x32) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Int8x32 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) AsUint64x4 deprecated 

func (x Int8x32) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Int8x32 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x32) Compress 

func (x Int8x32) Compress(mask Mask8x32) Int8x32

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Int8x32) ConcatPermute 

func (x Int8x32) ConcatPermute(y Int8x32, indices Uint8x32) Int8x32

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Int8x32) ConcatPermute128Scalars added in go1.27.0 

func (x Int8x32) ConcatPermute128Scalars(lo, hi uint8, y Int8x32) Int8x32

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{0x40, 0x41, ..., 0x4f, 0x50, 0x51, ..., 0x5f}.ConcatPermute128Scalars(3, 0,
     {0x60, 0x61, ..., 0x6f, 0x70, 0x71, ..., 0x7f})

returns {0x70, 0x71, ..., 0x7f, 0x40, 0x41, ..., 0x4f}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Int8x32) ConvertToUint8 added in go1.27.0 

func (x Int8x32) ConvertToUint8() Uint8x32

ConvertToUint8 converts a Int8x32 vector to a Uint8x32 vector

func (Int8x32) Equal 

func (x Int8x32) Equal(y Int8x32) Mask8x32

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX2

func (Int8x32) Expand 

func (x Int8x32) Expand(mask Mask8x32) Int8x32

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Int8x32) ExtendToInt16 

func (x Int8x32) ExtendToInt16() Int16x32

ExtendToInt16 sign-extends element values to int16.

Asm: VPMOVSXBW, CPU Feature: AVX512

func (Int8x32) GetHi 

func (x Int8x32) GetHi() Int8x16

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int8x32) GetLo 

func (x Int8x32) GetLo() Int8x16

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int8x32) Greater 

func (x Int8x32) Greater(y Int8x32) Mask8x32

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTB, CPU Feature: AVX2

func (Int8x32) GreaterEqual 

func (x Int8x32) GreaterEqual(y Int8x32) Mask8x32

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Int8x32) IfElse added in go1.27.0 

func (x Int8x32) IfElse(mask Mask8x32, y Int8x32) Int8x32

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Int8x32) IsZero 

func (x Int8x32) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int8x32) Len 

func (x Int8x32) Len() int

Len returns the number of elements in an Int8x32.

func (Int8x32) Less 

func (x Int8x32) Less(y Int8x32) Mask8x32

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Int8x32) LessEqual 

func (x Int8x32) LessEqual(y Int8x32) Mask8x32

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Int8x32) Masked 

func (x Int8x32) Masked(mask Mask8x32) Int8x32

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Int8x32) Max 

func (x Int8x32) Max(y Int8x32) Int8x32

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSB, CPU Feature: AVX2

func (Int8x32) Merge deprecated 

func (x Int8x32) Merge(y Int8x32, mask Mask8x32) Int8x32

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Int8x32) Min 

func (x Int8x32) Min(y Int8x32) Int8x32

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSB, CPU Feature: AVX2

func (Int8x32) Mul added in go1.27.0 

func (x Int8x32) Mul(y Int8x32) Int8x32

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX2

func (Int8x32) MulSign added in go1.27.0 

func (x Int8x32) MulSign(y Int8x32) Int8x32

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGNB, CPU Feature: AVX2

func (Int8x32) Neg added in go1.27.0 

func (x Int8x32) Neg() Int8x32

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX2

func (Int8x32) Not 

func (x Int8x32) Not() Int8x32

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Int8x32) NotEqual 

func (x Int8x32) NotEqual(y Int8x32) Mask8x32

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Int8x32) OnesCount 

func (x Int8x32) OnesCount() Int8x32

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Int8x32) Or 

func (x Int8x32) Or(y Int8x32) Int8x32

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Int8x32) Permute 

func (x Int8x32) Permute(indices Uint8x32) Int8x32

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Int8x32) PermuteOrZeroGrouped 

func (x Int8x32) PermuteOrZeroGrouped(indices Int8x32) Int8x32

PermuteOrZeroGrouped permutes x within each 128-bit group. If an index is negative, the result is 0. 

let vₙ be the n'th 128-bit group of vector v
if indicesₙ[i] >= 0 {
    zₙ[i] = xₙ[indicesₙ[i] % len(xₙ)]
} else {
    zₙ[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX2

func (Int8x32) SetHi 

func (x Int8x32) SetHi(y Int8x16) Int8x32

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int8x32) SetLo 

func (x Int8x32) SetLo(y Int8x16) Int8x32

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int8x32) Store 

func (x Int8x32) Store(s []int8)

Store stores the elements of x into a slice. If s does not have at least 32 elements, it panics.

func (Int8x32) StoreArray added in go1.27.0 

func (x Int8x32) StoreArray(y *[32]int8)

StoreArray stores an Int8x32 to an array.

func (Int8x32) StorePart added in go1.27.0 

func (x Int8x32) StorePart(s []int8) int

StorePart stores the elements of x into the slice s. It stores as many elements as will fit in s. If s has 32 or more elements, the method is equivalent to x.StoreSlice.

func (Int8x32) String 

func (x Int8x32) String() string

String returns a string representation of SIMD vector x.

func (Int8x32) Sub 

func (x Int8x32) Sub(y Int8x32) Int8x32

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX2

func (Int8x32) SubSaturated 

func (x Int8x32) SubSaturated(y Int8x32) Int8x32

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSB, CPU Feature: AVX2

func (Int8x32) ToBits added in go1.27.0 

func (x Int8x32) ToBits() Uint8x32

ToBits reinterprets the bits of a Int8x32 vector as a Uint8x32 vector

func (Int8x32) ToMask 

func (from Int8x32) ToMask() (to Mask8x32)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int8x32) Xor 

func (x Int8x32) Xor(y Int8x32) Int8x32

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Int8x64 

type Int8x64 struct {
	// contains filtered or unexported fields
}

Int8x64 is a 512-bit SIMD vector of 64 int8s.

func BroadcastInt8x64 

func BroadcastInt8x64(x int8) Int8x64

BroadcastInt8x64 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512BW

func LoadInt8x64 

func LoadInt8x64(s []int8) Int8x64

LoadInt8x64 loads an Int8x64 from a slice of elements. If s does not have at least 64 elements, it panics.

func LoadInt8x64Array added in go1.27.0 

func LoadInt8x64Array(y *[64]int8) Int8x64

LoadInt8x64Array loads an Int8x64 from an array.

func LoadInt8x64Part added in go1.27.0 

func LoadInt8x64Part(s []int8) (Int8x64, int)

LoadInt8x64Part loads a Int8x64 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 64 elements, the remaining elements of the vector are filled with zeroes. If s has 64 or more elements, the function is equivalent to LoadInt8x64.

func (Int8x64) Abs 

func (x Int8x64) Abs() Int8x64

Abs computes the absolute value of each element.

Asm: VPABSB, CPU Feature: AVX512

func (Int8x64) Add 

func (x Int8x64) Add(y Int8x64) Int8x64

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX512

func (Int8x64) AddSaturated 

func (x Int8x64) AddSaturated(y Int8x64) Int8x64

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSB, CPU Feature: AVX512

func (Int8x64) And 

func (x Int8x64) And(y Int8x64) Int8x64

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Int8x64) AndNot 

func (x Int8x64) AndNot(y Int8x64) Int8x64

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Int8x64) AsFloat32x16 deprecated 

func (x Int8x64) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Int8x64 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsFloat64x8 deprecated 

func (x Int8x64) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Int8x64 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsInt16x32 deprecated 

func (x Int8x64) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Int8x64 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsInt32x16 deprecated 

func (x Int8x64) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Int8x64 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsInt64x8 deprecated 

func (x Int8x64) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Int8x64 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsUint8x64 deprecated 

func (x Int8x64) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Int8x64 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsUint16x32 deprecated 

func (x Int8x64) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Int8x64 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsUint32x16 deprecated 

func (x Int8x64) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Int8x64 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) AsUint64x8 deprecated 

func (x Int8x64) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Int8x64 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int8x64) Compress 

func (x Int8x64) Compress(mask Mask8x64) Int8x64

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Int8x64) ConcatPermute 

func (x Int8x64) ConcatPermute(y Int8x64, indices Uint8x64) Int8x64

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Int8x64) ConvertToUint8 added in go1.27.0 

func (x Int8x64) ConvertToUint8() Uint8x64

ConvertToUint8 converts a Int8x64 vector to a Uint8x64 vector

func (Int8x64) Equal 

func (x Int8x64) Equal(y Int8x64) Mask8x64

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX512

func (Int8x64) Expand 

func (x Int8x64) Expand(mask Mask8x64) Int8x64

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Int8x64) GetHi 

func (x Int8x64) GetHi() Int8x32

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int8x64) GetLo 

func (x Int8x64) GetLo() Int8x32

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int8x64) Greater 

func (x Int8x64) Greater(y Int8x64) Mask8x64

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTB, CPU Feature: AVX512

func (Int8x64) GreaterEqual 

func (x Int8x64) GreaterEqual(y Int8x64) Mask8x64

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPB, CPU Feature: AVX512

func (Int8x64) IfElse added in go1.27.0 

func (x Int8x64) IfElse(mask Mask8x64, y Int8x64) Int8x64

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Int8x64) Len 

func (x Int8x64) Len() int

Len returns the number of elements in an Int8x64.

func (Int8x64) Less 

func (x Int8x64) Less(y Int8x64) Mask8x64

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPB, CPU Feature: AVX512

func (Int8x64) LessEqual 

func (x Int8x64) LessEqual(y Int8x64) Mask8x64

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPB, CPU Feature: AVX512

func (Int8x64) Masked 

func (x Int8x64) Masked(mask Mask8x64) Int8x64

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Int8x64) Max 

func (x Int8x64) Max(y Int8x64) Int8x64

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSB, CPU Feature: AVX512

func (Int8x64) Merge deprecated 

func (x Int8x64) Merge(y Int8x64, mask Mask8x64) Int8x64

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Int8x64) Min 

func (x Int8x64) Min(y Int8x64) Int8x64

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSB, CPU Feature: AVX512

func (Int8x64) Mul added in go1.27.0 

func (x Int8x64) Mul(y Int8x64) Int8x64

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX512

func (Int8x64) Neg added in go1.27.0 

func (x Int8x64) Neg() Int8x64

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX512

func (Int8x64) Not 

func (x Int8x64) Not() Int8x64

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Int8x64) NotEqual 

func (x Int8x64) NotEqual(y Int8x64) Mask8x64

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPB, CPU Feature: AVX512

func (Int8x64) OnesCount 

func (x Int8x64) OnesCount() Int8x64

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Int8x64) Or 

func (x Int8x64) Or(y Int8x64) Int8x64

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Int8x64) Permute 

func (x Int8x64) Permute(indices Uint8x64) Int8x64

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Int8x64) PermuteOrZeroGrouped 

func (x Int8x64) PermuteOrZeroGrouped(indices Int8x64) Int8x64

PermuteOrZeroGrouped permutes x within each 128-bit group. If an index is negative, the result is 0. 

let vₙ be the n'th 128-bit group of vector v
if indicesₙ[i] >= 0 {
    zₙ[i] = xₙ[indicesₙ[i] % len(xₙ)]
} else {
    zₙ[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX512

func (Int8x64) SetHi 

func (x Int8x64) SetHi(y Int8x32) Int8x64

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int8x64) SetLo 

func (x Int8x64) SetLo(y Int8x32) Int8x64

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int8x64) Store 

func (x Int8x64) Store(s []int8)

Store stores the elements of x into a slice. If s does not have at least 64 elements, it panics.

func (Int8x64) StoreArray added in go1.27.0 

func (x Int8x64) StoreArray(y *[64]int8)

StoreArray stores an Int8x64 to an array.

func (Int8x64) StoreArrayMasked added in go1.27.0 

func (x Int8x64) StoreArrayMasked(y *[64]int8, mask Mask8x64)

StoreArrayMasked stores an Int8x64 to an array, at those elements enabled by mask.

Asm: VMOVDQU8, CPU Feature: AVX512

func (Int8x64) StorePart added in go1.27.0 

func (x Int8x64) StorePart(s []int8) int

StorePart stores the 64 elements of x into the slice s. It stores as many elements as will fit in s. If s has 64 or more elements, the method is equivalent to x.Store.

func (Int8x64) String 

func (x Int8x64) String() string

String returns a string representation of SIMD vector x.

func (Int8x64) Sub 

func (x Int8x64) Sub(y Int8x64) Int8x64

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX512

func (Int8x64) SubSaturated 

func (x Int8x64) SubSaturated(y Int8x64) Int8x64

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSB, CPU Feature: AVX512

func (Int8x64) ToBits added in go1.27.0 

func (x Int8x64) ToBits() Uint8x64

ToBits reinterprets the bits of a Int8x64 vector as a Uint8x64 vector

func (Int8x64) ToMask 

func (from Int8x64) ToMask() (to Mask8x64)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int8x64) Xor 

func (x Int8x64) Xor(y Int8x64) Int8x64

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Int16x8 

type Int16x8 struct {
	// contains filtered or unexported fields
}

Int16x8 is a 128-bit SIMD vector of 8 int16s.

func BroadcastInt16x8 

func BroadcastInt16x8(x int16) Int16x8

BroadcastInt16x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt16x8 

func LoadInt16x8(s []int16) Int16x8

LoadInt16x8 loads an Int16x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadInt16x8Array added in go1.27.0 

func LoadInt16x8Array(y *[8]int16) Int16x8

LoadInt16x8Array loads an Int16x8 from an array.

func LoadInt16x8Part added in go1.27.0 

func LoadInt16x8Part(s []int16) (Int16x8, int)

LoadInt16x8Part loads a Int16x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadInt16x8.

func (Int16x8) Abs 

func (x Int16x8) Abs() Int16x8

Abs computes the absolute value of each element.

Asm: VPABSW, CPU Feature: AVX

func (Int16x8) Add 

func (x Int16x8) Add(y Int16x8) Int16x8

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX

func (Int16x8) AddSaturated 

func (x Int16x8) AddSaturated(y Int16x8) Int16x8

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSW, CPU Feature: AVX

func (Int16x8) And 

func (x Int16x8) And(y Int16x8) Int16x8

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Int16x8) AndNot 

func (x Int16x8) AndNot(y Int16x8) Int16x8

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Int16x8) AsFloat32x4 deprecated 

func (x Int16x8) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Int16x8 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsFloat64x2 deprecated 

func (x Int16x8) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Int16x8 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsInt8x16 deprecated 

func (x Int16x8) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Int16x8 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsInt32x4 deprecated 

func (x Int16x8) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Int16x8 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsInt64x2 deprecated 

func (x Int16x8) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Int16x8 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsUint8x16 deprecated 

func (x Int16x8) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Int16x8 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsUint16x8 deprecated 

func (x Int16x8) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Int16x8 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsUint32x4 deprecated 

func (x Int16x8) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Int16x8 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) AsUint64x2 deprecated 

func (x Int16x8) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Int16x8 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x8) Compress 

func (x Int16x8) Compress(mask Mask16x8) Int16x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Int16x8) ConcatAddPairs added in go1.27.0 

func (x Int16x8) ConcatAddPairs(y Int16x8) Int16x8

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDW, CPU Feature: AVX

func (Int16x8) ConcatAddPairsSaturated added in go1.27.0 

func (x Int16x8) ConcatAddPairsSaturated(y Int16x8) Int16x8

ConcatAddPairsSaturated horizontally adds adjacent pairs of elements with saturation. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDSW, CPU Feature: AVX

func (Int16x8) ConcatPermute 

func (x Int16x8) ConcatPermute(y Int16x8, indices Uint16x8) Int16x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Int16x8) ConcatSubPairs added in go1.27.0 

func (x Int16x8) ConcatSubPairs(y Int16x8) Int16x8

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBW, CPU Feature: AVX

func (Int16x8) ConcatSubPairsSaturated added in go1.27.0 

func (x Int16x8) ConcatSubPairsSaturated(y Int16x8) Int16x8

ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements with saturation. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBSW, CPU Feature: AVX

func (Int16x8) ConvertToUint16 added in go1.27.0 

func (x Int16x8) ConvertToUint16() Uint16x8

ConvertToUint16 converts a Int16x8 vector to a Uint16x8 vector

func (Int16x8) DotProductPairs 

func (x Int16x8) DotProductPairs(y Int16x8) Int32x4

DotProductPairs multiplies the elements and add the pairs together, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDWD, CPU Feature: AVX

func (Int16x8) Equal 

func (x Int16x8) Equal(y Int16x8) Mask16x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX

func (Int16x8) Expand 

func (x Int16x8) Expand(mask Mask16x8) Int16x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Int16x8) ExtendLo2ToInt64 

func (x Int16x8) ExtendLo2ToInt64() Int64x2

ExtendLo2ToInt64 sign-extends 2 lowest vector element values to int64.

Asm: VPMOVSXWQ, CPU Feature: AVX

func (Int16x8) ExtendLo4ToInt32 

func (x Int16x8) ExtendLo4ToInt32() Int32x4

ExtendLo4ToInt32 sign-extends 4 lowest vector element values to int32.

Asm: VPMOVSXWD, CPU Feature: AVX

func (Int16x8) ExtendLo4ToInt64 

func (x Int16x8) ExtendLo4ToInt64() Int64x4

ExtendLo4ToInt64 sign-extends 4 lowest vector element values to int64.

Asm: VPMOVSXWQ, CPU Feature: AVX2

func (Int16x8) ExtendToInt32 

func (x Int16x8) ExtendToInt32() Int32x8

ExtendToInt32 sign-extends element values to int32.

Asm: VPMOVSXWD, CPU Feature: AVX2

func (Int16x8) ExtendToInt64 

func (x Int16x8) ExtendToInt64() Int64x8

ExtendToInt64 sign-extends element values to int64.

Asm: VPMOVSXWQ, CPU Feature: AVX512

func (Int16x8) GetElem 

func (x Int16x8) GetElem(index uint8) int16

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRW, CPU Feature: AVX

func (Int16x8) Greater 

func (x Int16x8) Greater(y Int16x8) Mask16x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTW, CPU Feature: AVX

func (Int16x8) GreaterEqual 

func (x Int16x8) GreaterEqual(y Int16x8) Mask16x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Int16x8) IfElse added in go1.27.0 

func (x Int16x8) IfElse(mask Mask16x8, y Int16x8) Int16x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Int16x8) InterleaveHi 

func (x Int16x8) InterleaveHi(y Int16x8) Int16x8

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX

func (Int16x8) InterleaveLo 

func (x Int16x8) InterleaveLo(y Int16x8) Int16x8

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX

func (Int16x8) IsZero 

func (x Int16x8) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int16x8) Len 

func (x Int16x8) Len() int

Len returns the number of elements in an Int16x8.

func (Int16x8) Less 

func (x Int16x8) Less(y Int16x8) Mask16x8

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Int16x8) LessEqual 

func (x Int16x8) LessEqual(y Int16x8) Mask16x8

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Int16x8) Masked 

func (x Int16x8) Masked(mask Mask16x8) Int16x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Int16x8) Max 

func (x Int16x8) Max(y Int16x8) Int16x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSW, CPU Feature: AVX

func (Int16x8) Merge deprecated 

func (x Int16x8) Merge(y Int16x8, mask Mask16x8) Int16x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Int16x8) Min 

func (x Int16x8) Min(y Int16x8) Int16x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSW, CPU Feature: AVX

func (Int16x8) Mul 

func (x Int16x8) Mul(y Int16x8) Int16x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX

func (Int16x8) MulHigh 

func (x Int16x8) MulHigh(y Int16x8) Int16x8

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHW, CPU Feature: AVX

func (Int16x8) MulSign added in go1.27.0 

func (x Int16x8) MulSign(y Int16x8) Int16x8

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGNW, CPU Feature: AVX

func (Int16x8) Neg added in go1.27.0 

func (x Int16x8) Neg() Int16x8

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX

func (Int16x8) Not 

func (x Int16x8) Not() Int16x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Int16x8) NotEqual 

func (x Int16x8) NotEqual(y Int16x8) Mask16x8

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Int16x8) OnesCount 

func (x Int16x8) OnesCount() Int16x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Int16x8) Or 

func (x Int16x8) Or(y Int16x8) Int16x8

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Int16x8) Permute 

func (x Int16x8) Permute(indices Uint16x8) Int16x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Int16x8) PermuteScalarsHi 

func (x Int16x8) PermuteScalarsHi(a, b, c, d uint8) Int16x8

PermuteScalarsHi performs a permutation of vector x using the supplied indices: 

result = {x[0], x[1], x[2], x[3], x[a+4], x[b+4], x[c+4], x[d+4]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX

func (Int16x8) PermuteScalarsLo 

func (x Int16x8) PermuteScalarsLo(a, b, c, d uint8) Int16x8

PermuteScalarsLo performs a permutation of vector x using the supplied indices: 

result = {x[a], x[b], x[c], x[d], x[4], x[5], x[6], x[7]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX512

func (Int16x8) RotateAllLeft added in go1.27.0 

func (x Int16x8) RotateAllLeft(dist uint64) Int16x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int16x8) RotateAllRight added in go1.27.0 

func (x Int16x8) RotateAllRight(dist uint64) Int16x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int16x8) SaturateToInt8 

func (x Int16x8) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSWB, CPU Feature: AVX512

func (Int16x8) SetElem 

func (x Int16x8) SetElem(index uint8, y int16) Int16x8

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRW, CPU Feature: AVX

func (Int16x8) ShiftAllLeft 

func (x Int16x8) ShiftAllLeft(shift uint64) Int16x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX

func (Int16x8) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Int16x8) ShiftAllLeftConcatMod16(y Int16x8, shift uint64) Int16x8

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Int16x8) ShiftAllRight 

func (x Int16x8) ShiftAllRight(shift uint64) Int16x8

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAW, CPU Feature: AVX

func (Int16x8) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Int16x8) ShiftAllRightConcatMod16(y Int16x8, shift uint64) Int16x8

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Int16x8) ShiftLeft 

func (x Int16x8) ShiftLeft(shift Uint16x8) Int16x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Int16x8) ShiftLeftConcatMod16 added in go1.27.0 

func (x Int16x8) ShiftLeftConcatMod16(y Int16x8, shift Uint16x8) Int16x8

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Int16x8) ShiftRight 

func (x Int16x8) ShiftRight(shift Uint16x8) Int16x8

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVW, CPU Feature: AVX512

func (Int16x8) ShiftRightConcatMod16 added in go1.27.0 

func (x Int16x8) ShiftRightConcatMod16(y Int16x8, shift Uint16x8) Int16x8

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Int16x8) Store 

func (x Int16x8) Store(s []int16)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Int16x8) StoreArray added in go1.27.0 

func (x Int16x8) StoreArray(y *[8]int16)

StoreArray stores an Int16x8 to an array.

func (Int16x8) StorePart added in go1.27.0 

func (x Int16x8) StorePart(s []int16) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Int16x8) String 

func (x Int16x8) String() string

String returns a string representation of SIMD vector x.

func (Int16x8) Sub 

func (x Int16x8) Sub(y Int16x8) Int16x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX

func (Int16x8) SubSaturated 

func (x Int16x8) SubSaturated(y Int16x8) Int16x8

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSW, CPU Feature: AVX

func (Int16x8) ToBits added in go1.27.0 

func (x Int16x8) ToBits() Uint16x8

ToBits reinterprets the bits of a Int16x8 vector as a Uint16x8 vector

func (Int16x8) ToMask 

func (from Int16x8) ToMask() (to Mask16x8)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int16x8) TruncToInt8 added in go1.27.0 

func (x Int16x8) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVWB, CPU Feature: AVX512

func (Int16x8) Xor 

func (x Int16x8) Xor(y Int16x8) Int16x8

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Int16x16 

type Int16x16 struct {
	// contains filtered or unexported fields
}

Int16x16 is a 256-bit SIMD vector of 16 int16s.

func BroadcastInt16x16 

func BroadcastInt16x16(x int16) Int16x16

BroadcastInt16x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt16x16 

func LoadInt16x16(s []int16) Int16x16

LoadInt16x16 loads an Int16x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadInt16x16Array added in go1.27.0 

func LoadInt16x16Array(y *[16]int16) Int16x16

LoadInt16x16Array loads an Int16x16 from an array.

func LoadInt16x16Part added in go1.27.0 

func LoadInt16x16Part(s []int16) (Int16x16, int)

LoadInt16x16Part loads a Int16x16 from the slice s. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadInt16x16Slice.

func (Int16x16) Abs 

func (x Int16x16) Abs() Int16x16

Abs computes the absolute value of each element.

Asm: VPABSW, CPU Feature: AVX2

func (Int16x16) Add 

func (x Int16x16) Add(y Int16x16) Int16x16

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX2

func (Int16x16) AddSaturated 

func (x Int16x16) AddSaturated(y Int16x16) Int16x16

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSW, CPU Feature: AVX2

func (Int16x16) And 

func (x Int16x16) And(y Int16x16) Int16x16

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Int16x16) AndNot 

func (x Int16x16) AndNot(y Int16x16) Int16x16

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Int16x16) AsFloat32x8 deprecated 

func (x Int16x16) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Int16x16 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsFloat64x4 deprecated 

func (x Int16x16) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Int16x16 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsInt8x32 deprecated 

func (x Int16x16) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Int16x16 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsInt32x8 deprecated 

func (x Int16x16) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Int16x16 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsInt64x4 deprecated 

func (x Int16x16) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Int16x16 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsUint8x32 deprecated 

func (x Int16x16) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Int16x16 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsUint16x16 deprecated 

func (x Int16x16) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Int16x16 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsUint32x8 deprecated 

func (x Int16x16) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Int16x16 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) AsUint64x4 deprecated 

func (x Int16x16) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Int16x16 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x16) Compress 

func (x Int16x16) Compress(mask Mask16x16) Int16x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Int16x16) ConcatAddPairsGrouped added in go1.27.0 

func (x Int16x16) ConcatAddPairsGrouped(y Int16x16) Int16x16

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDW, CPU Feature: AVX2

func (Int16x16) ConcatAddPairsSaturatedGrouped added in go1.27.0 

func (x Int16x16) ConcatAddPairsSaturatedGrouped(y Int16x16) Int16x16

ConcatAddPairsSaturatedGrouped horizontally adds adjacent pairs of elements with saturation. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDSW, CPU Feature: AVX2

func (Int16x16) ConcatPermute 

func (x Int16x16) ConcatPermute(y Int16x16, indices Uint16x16) Int16x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Int16x16) ConcatPermute128Scalars added in go1.27.0 

func (x Int16x16) ConcatPermute128Scalars(lo, hi uint8, y Int16x16) Int16x16

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 42, 43, 44, 45, 46, 47, 50, 51, 52, 53, 54, 55, 56, 57}.ConcatPermute128Scalars(3, 0,
 {60, 61, 62, 63, 64, 65, 66, 67, 70, 71, 72, 73, 74, 75, 76, 77})

returns {70, 71, 72, 73, 74, 75, 76, 77, 40, 41, 42, 43, 44, 45, 46, 47}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Int16x16) ConcatSubPairsGrouped added in go1.27.0 

func (x Int16x16) ConcatSubPairsGrouped(y Int16x16) Int16x16

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBW, CPU Feature: AVX2

func (Int16x16) ConcatSubPairsSaturatedGrouped added in go1.27.0 

func (x Int16x16) ConcatSubPairsSaturatedGrouped(y Int16x16) Int16x16

ConcatSubPairsSaturatedGrouped horizontally subtracts adjacent pairs of elements with saturation. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBSW, CPU Feature: AVX2

func (Int16x16) ConvertToUint16 added in go1.27.0 

func (x Int16x16) ConvertToUint16() Uint16x16

ConvertToUint16 converts a Int16x16 vector to a Uint16x16 vector

func (Int16x16) DotProductPairs 

func (x Int16x16) DotProductPairs(y Int16x16) Int32x8

DotProductPairs multiplies the elements and add the pairs together, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDWD, CPU Feature: AVX2

func (Int16x16) Equal 

func (x Int16x16) Equal(y Int16x16) Mask16x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX2

func (Int16x16) Expand 

func (x Int16x16) Expand(mask Mask16x16) Int16x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Int16x16) ExtendToInt32 

func (x Int16x16) ExtendToInt32() Int32x16

ExtendToInt32 sign-extends element values to int32.

Asm: VPMOVSXWD, CPU Feature: AVX512

func (Int16x16) GetHi 

func (x Int16x16) GetHi() Int16x8

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int16x16) GetLo 

func (x Int16x16) GetLo() Int16x8

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int16x16) Greater 

func (x Int16x16) Greater(y Int16x16) Mask16x16

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTW, CPU Feature: AVX2

func (Int16x16) GreaterEqual 

func (x Int16x16) GreaterEqual(y Int16x16) Mask16x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Int16x16) IfElse added in go1.27.0 

func (x Int16x16) IfElse(mask Mask16x16, y Int16x16) Int16x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Int16x16) InterleaveHiGrouped 

func (x Int16x16) InterleaveHiGrouped(y Int16x16) Int16x16

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX2

func (Int16x16) InterleaveLoGrouped 

func (x Int16x16) InterleaveLoGrouped(y Int16x16) Int16x16

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX2

func (Int16x16) IsZero 

func (x Int16x16) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int16x16) Len 

func (x Int16x16) Len() int

Len returns the number of elements in an Int16x16.

func (Int16x16) Less 

func (x Int16x16) Less(y Int16x16) Mask16x16

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Int16x16) LessEqual 

func (x Int16x16) LessEqual(y Int16x16) Mask16x16

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Int16x16) Masked 

func (x Int16x16) Masked(mask Mask16x16) Int16x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Int16x16) Max 

func (x Int16x16) Max(y Int16x16) Int16x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSW, CPU Feature: AVX2

func (Int16x16) Merge deprecated 

func (x Int16x16) Merge(y Int16x16, mask Mask16x16) Int16x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Int16x16) Min 

func (x Int16x16) Min(y Int16x16) Int16x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSW, CPU Feature: AVX2

func (Int16x16) Mul 

func (x Int16x16) Mul(y Int16x16) Int16x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX2

func (Int16x16) MulHigh 

func (x Int16x16) MulHigh(y Int16x16) Int16x16

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHW, CPU Feature: AVX2

func (Int16x16) MulSign added in go1.27.0 

func (x Int16x16) MulSign(y Int16x16) Int16x16

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGNW, CPU Feature: AVX2

func (Int16x16) Neg added in go1.27.0 

func (x Int16x16) Neg() Int16x16

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX2

func (Int16x16) Not 

func (x Int16x16) Not() Int16x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Int16x16) NotEqual 

func (x Int16x16) NotEqual(y Int16x16) Mask16x16

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Int16x16) OnesCount 

func (x Int16x16) OnesCount() Int16x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Int16x16) Or 

func (x Int16x16) Or(y Int16x16) Int16x16

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Int16x16) Permute 

func (x Int16x16) Permute(indices Uint16x16) Int16x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Int16x16) PermuteScalarsHiGrouped 

func (x Int16x16) PermuteScalarsHiGrouped(a, b, c, d uint8) Int16x16

PermuteScalarsHiGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
	  {x[0], x[1], x[2], x[3],   x[a+4], x[b+4], x[c+4], x[d+4],
		x[8], x[9], x[10], x[11], x[a+12], x[b+12], x[c+12], x[d+12]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX2

func (Int16x16) PermuteScalarsLoGrouped 

func (x Int16x16) PermuteScalarsLoGrouped(a, b, c, d uint8) Int16x16

PermuteScalarsLoGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
 {x[a], x[b], x[c], x[d],         x[4], x[5], x[6], x[7],
	 x[a+8], x[b+8], x[c+8], x[d+8], x[12], x[13], x[14], x[15]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX2

func (Int16x16) RotateAllLeft added in go1.27.0 

func (x Int16x16) RotateAllLeft(dist uint64) Int16x16

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int16x16) RotateAllRight added in go1.27.0 

func (x Int16x16) RotateAllRight(dist uint64) Int16x16

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int16x16) SaturateToInt8 

func (x Int16x16) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation.

Asm: VPMOVSWB, CPU Feature: AVX512

func (Int16x16) SetHi 

func (x Int16x16) SetHi(y Int16x8) Int16x16

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int16x16) SetLo 

func (x Int16x16) SetLo(y Int16x8) Int16x16

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int16x16) ShiftAllLeft 

func (x Int16x16) ShiftAllLeft(shift uint64) Int16x16

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX2

func (Int16x16) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Int16x16) ShiftAllLeftConcatMod16(y Int16x16, shift uint64) Int16x16

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Int16x16) ShiftAllRight 

func (x Int16x16) ShiftAllRight(shift uint64) Int16x16

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAW, CPU Feature: AVX2

func (Int16x16) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Int16x16) ShiftAllRightConcatMod16(y Int16x16, shift uint64) Int16x16

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Int16x16) ShiftLeft 

func (x Int16x16) ShiftLeft(shift Uint16x16) Int16x16

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Int16x16) ShiftLeftConcatMod16 added in go1.27.0 

func (x Int16x16) ShiftLeftConcatMod16(y Int16x16, shift Uint16x16) Int16x16

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Int16x16) ShiftRight 

func (x Int16x16) ShiftRight(shift Uint16x16) Int16x16

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVW, CPU Feature: AVX512

func (Int16x16) ShiftRightConcatMod16 added in go1.27.0 

func (x Int16x16) ShiftRightConcatMod16(y Int16x16, shift Uint16x16) Int16x16

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Int16x16) Store 

func (x Int16x16) Store(s []int16)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Int16x16) StoreArray added in go1.27.0 

func (x Int16x16) StoreArray(y *[16]int16)

StoreArray stores an Int16x16 to an array.

func (Int16x16) StorePart added in go1.27.0 

func (x Int16x16) StorePart(s []int16) int

StorePart stores the elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.StoreSlice.

func (Int16x16) String 

func (x Int16x16) String() string

String returns a string representation of SIMD vector x.

func (Int16x16) Sub 

func (x Int16x16) Sub(y Int16x16) Int16x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX2

func (Int16x16) SubSaturated 

func (x Int16x16) SubSaturated(y Int16x16) Int16x16

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSW, CPU Feature: AVX2

func (Int16x16) ToBits added in go1.27.0 

func (x Int16x16) ToBits() Uint16x16

ToBits reinterprets the bits of a Int16x16 vector as a Uint16x16 vector

func (Int16x16) ToMask 

func (from Int16x16) ToMask() (to Mask16x16)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int16x16) TruncToInt8 added in go1.27.0 

func (x Int16x16) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8.

Asm: VPMOVWB, CPU Feature: AVX512

func (Int16x16) Xor 

func (x Int16x16) Xor(y Int16x16) Int16x16

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Int16x32 

type Int16x32 struct {
	// contains filtered or unexported fields
}

Int16x32 is a 512-bit SIMD vector of 32 int16s.

func BroadcastInt16x32 

func BroadcastInt16x32(x int16) Int16x32

BroadcastInt16x32 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512BW

func LoadInt16x32 

func LoadInt16x32(s []int16) Int16x32

LoadInt16x32 loads an Int16x32 from a slice of elements. If s does not have at least 32 elements, it panics.

func LoadInt16x32Array added in go1.27.0 

func LoadInt16x32Array(y *[32]int16) Int16x32

LoadInt16x32Array loads an Int16x32 from an array.

func LoadInt16x32Part added in go1.27.0 

func LoadInt16x32Part(s []int16) (Int16x32, int)

LoadInt16x32Part loads a Int16x32 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes. If s has 32 or more elements, the function is equivalent to LoadInt16x32.

func (Int16x32) Abs 

func (x Int16x32) Abs() Int16x32

Abs computes the absolute value of each element.

Asm: VPABSW, CPU Feature: AVX512

func (Int16x32) Add 

func (x Int16x32) Add(y Int16x32) Int16x32

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX512

func (Int16x32) AddSaturated 

func (x Int16x32) AddSaturated(y Int16x32) Int16x32

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDSW, CPU Feature: AVX512

func (Int16x32) And 

func (x Int16x32) And(y Int16x32) Int16x32

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Int16x32) AndNot 

func (x Int16x32) AndNot(y Int16x32) Int16x32

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Int16x32) AsFloat32x16 deprecated 

func (x Int16x32) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Int16x32 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsFloat64x8 deprecated 

func (x Int16x32) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Int16x32 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsInt8x64 deprecated 

func (x Int16x32) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Int16x32 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsInt32x16 deprecated 

func (x Int16x32) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Int16x32 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsInt64x8 deprecated 

func (x Int16x32) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Int16x32 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsUint8x64 deprecated 

func (x Int16x32) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Int16x32 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsUint16x32 deprecated 

func (x Int16x32) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Int16x32 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsUint32x16 deprecated 

func (x Int16x32) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Int16x32 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) AsUint64x8 deprecated 

func (x Int16x32) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Int16x32 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int16x32) Compress 

func (x Int16x32) Compress(mask Mask16x32) Int16x32

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Int16x32) ConcatPermute 

func (x Int16x32) ConcatPermute(y Int16x32, indices Uint16x32) Int16x32

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Int16x32) ConvertToUint16 added in go1.27.0 

func (x Int16x32) ConvertToUint16() Uint16x32

ConvertToUint16 converts a Int16x32 vector to a Uint16x32 vector

func (Int16x32) DotProductPairs 

func (x Int16x32) DotProductPairs(y Int16x32) Int32x16

DotProductPairs multiplies the elements and add the pairs together, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDWD, CPU Feature: AVX512

func (Int16x32) Equal 

func (x Int16x32) Equal(y Int16x32) Mask16x32

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX512

func (Int16x32) Expand 

func (x Int16x32) Expand(mask Mask16x32) Int16x32

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Int16x32) GetHi 

func (x Int16x32) GetHi() Int16x16

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int16x32) GetLo 

func (x Int16x32) GetLo() Int16x16

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int16x32) Greater 

func (x Int16x32) Greater(y Int16x32) Mask16x32

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTW, CPU Feature: AVX512

func (Int16x32) GreaterEqual 

func (x Int16x32) GreaterEqual(y Int16x32) Mask16x32

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPW, CPU Feature: AVX512

func (Int16x32) IfElse added in go1.27.0 

func (x Int16x32) IfElse(mask Mask16x32, y Int16x32) Int16x32

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Int16x32) InterleaveHiGrouped 

func (x Int16x32) InterleaveHiGrouped(y Int16x32) Int16x32

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX512

func (Int16x32) InterleaveLoGrouped 

func (x Int16x32) InterleaveLoGrouped(y Int16x32) Int16x32

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX512

func (Int16x32) Len 

func (x Int16x32) Len() int

Len returns the number of elements in an Int16x32.

func (Int16x32) Less 

func (x Int16x32) Less(y Int16x32) Mask16x32

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPW, CPU Feature: AVX512

func (Int16x32) LessEqual 

func (x Int16x32) LessEqual(y Int16x32) Mask16x32

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPW, CPU Feature: AVX512

func (Int16x32) Masked 

func (x Int16x32) Masked(mask Mask16x32) Int16x32

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Int16x32) Max 

func (x Int16x32) Max(y Int16x32) Int16x32

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSW, CPU Feature: AVX512

func (Int16x32) Merge deprecated 

func (x Int16x32) Merge(y Int16x32, mask Mask16x32) Int16x32

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Int16x32) Min 

func (x Int16x32) Min(y Int16x32) Int16x32

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSW, CPU Feature: AVX512

func (Int16x32) Mul 

func (x Int16x32) Mul(y Int16x32) Int16x32

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX512

func (Int16x32) MulHigh 

func (x Int16x32) MulHigh(y Int16x32) Int16x32

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHW, CPU Feature: AVX512

func (Int16x32) Neg added in go1.27.0 

func (x Int16x32) Neg() Int16x32

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX512

func (Int16x32) Not 

func (x Int16x32) Not() Int16x32

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Int16x32) NotEqual 

func (x Int16x32) NotEqual(y Int16x32) Mask16x32

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPW, CPU Feature: AVX512

func (Int16x32) OnesCount 

func (x Int16x32) OnesCount() Int16x32

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Int16x32) Or 

func (x Int16x32) Or(y Int16x32) Int16x32

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Int16x32) Permute 

func (x Int16x32) Permute(indices Uint16x32) Int16x32

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Int16x32) PermuteScalarsHiGrouped 

func (x Int16x32) PermuteScalarsHiGrouped(a, b, c, d uint8) Int16x32

PermuteScalarsHiGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
	  {x[0], x[1], x[2], x[3],     x[a+4], x[b+4], x[c+4], x[d+4],
		x[8], x[9], x[10], x[11],   x[a+12], x[b+12], x[c+12], x[d+12],
		x[16], x[17], x[18], x[19], x[a+20], x[b+20], x[c+20], x[d+20],
		x[24], x[25], x[26], x[27], x[a+28], x[b+28], x[c+28], x[d+28]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX512

func (Int16x32) PermuteScalarsLoGrouped 

func (x Int16x32) PermuteScalarsLoGrouped(a, b, c, d uint8) Int16x32

PermuteScalarsLoGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
 {x[a], x[b], x[c], x[d],    x[4], x[5], x[6], x[7],
	x[a+8], x[b+8], x[c+8], x[d+8],     x[12], x[13], x[14], x[15],
	x[a+16], x[b+16], x[c+16], x[d+16], x[20], x[21], x[22], x[23],
	x[a+24], x[b+24], x[c+24], x[d+24], x[28], x[29], x[30], x[31]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX512

func (Int16x32) RotateAllLeft added in go1.27.0 

func (x Int16x32) RotateAllLeft(dist uint64) Int16x32

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int16x32) RotateAllRight added in go1.27.0 

func (x Int16x32) RotateAllRight(dist uint64) Int16x32

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int16x32) SaturateToInt8 

func (x Int16x32) SaturateToInt8() Int8x32

SaturateToInt8 converts element values to int8 with signed saturation.

Asm: VPMOVSWB, CPU Feature: AVX512

func (Int16x32) SetHi 

func (x Int16x32) SetHi(y Int16x16) Int16x32

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int16x32) SetLo 

func (x Int16x32) SetLo(y Int16x16) Int16x32

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int16x32) ShiftAllLeft 

func (x Int16x32) ShiftAllLeft(shift uint64) Int16x32

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX512

func (Int16x32) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Int16x32) ShiftAllLeftConcatMod16(y Int16x32, shift uint64) Int16x32

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Int16x32) ShiftAllRight 

func (x Int16x32) ShiftAllRight(shift uint64) Int16x32

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAW, CPU Feature: AVX512

func (Int16x32) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Int16x32) ShiftAllRightConcatMod16(y Int16x32, shift uint64) Int16x32

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Int16x32) ShiftLeft 

func (x Int16x32) ShiftLeft(shift Uint16x32) Int16x32

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Int16x32) ShiftLeftConcatMod16 added in go1.27.0 

func (x Int16x32) ShiftLeftConcatMod16(y Int16x32, shift Uint16x32) Int16x32

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Int16x32) ShiftRight 

func (x Int16x32) ShiftRight(shift Uint16x32) Int16x32

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVW, CPU Feature: AVX512

func (Int16x32) ShiftRightConcatMod16 added in go1.27.0 

func (x Int16x32) ShiftRightConcatMod16(y Int16x32, shift Uint16x32) Int16x32

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Int16x32) Store 

func (x Int16x32) Store(s []int16)

Store stores the elements of x into a slice. If s does not have at least 32 elements, it panics.

func (Int16x32) StoreArray added in go1.27.0 

func (x Int16x32) StoreArray(y *[32]int16)

StoreArray stores an Int16x32 to an array.

func (Int16x32) StoreArrayMasked added in go1.27.0 

func (x Int16x32) StoreArrayMasked(y *[32]int16, mask Mask16x32)

StoreArrayMasked stores an Int16x32 to an array, at those elements enabled by mask.

Asm: VMOVDQU16, CPU Feature: AVX512

func (Int16x32) StorePart added in go1.27.0 

func (x Int16x32) StorePart(s []int16) int

StorePart stores the 32 elements of x into the slice s. It stores as many elements as will fit in s. If s has 32 or more elements, the method is equivalent to x.Store.

func (Int16x32) String 

func (x Int16x32) String() string

String returns a string representation of SIMD vector x.

func (Int16x32) Sub 

func (x Int16x32) Sub(y Int16x32) Int16x32

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX512

func (Int16x32) SubSaturated 

func (x Int16x32) SubSaturated(y Int16x32) Int16x32

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBSW, CPU Feature: AVX512

func (Int16x32) ToBits added in go1.27.0 

func (x Int16x32) ToBits() Uint16x32

ToBits reinterprets the bits of a Int16x32 vector as a Uint16x32 vector

func (Int16x32) ToMask 

func (from Int16x32) ToMask() (to Mask16x32)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int16x32) TruncToInt8 added in go1.27.0 

func (x Int16x32) TruncToInt8() Int8x32

TruncToInt8 truncates element values to int8.

Asm: VPMOVWB, CPU Feature: AVX512

func (Int16x32) Xor 

func (x Int16x32) Xor(y Int16x32) Int16x32

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Int32x4 

type Int32x4 struct {
	// contains filtered or unexported fields
}

Int32x4 is a 128-bit SIMD vector of 4 int32s.

func BroadcastInt32x4 

func BroadcastInt32x4(x int32) Int32x4

BroadcastInt32x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt32x4 

func LoadInt32x4(s []int32) Int32x4

LoadInt32x4 loads an Int32x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadInt32x4Array added in go1.27.0 

func LoadInt32x4Array(y *[4]int32) Int32x4

LoadInt32x4Array loads an Int32x4 from an array.

func LoadInt32x4Part added in go1.27.0 

func LoadInt32x4Part(s []int32) (Int32x4, int)

LoadInt32x4Part loads a Int32x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadInt32x4.

func (Int32x4) Abs 

func (x Int32x4) Abs() Int32x4

Abs computes the absolute value of each element.

Asm: VPABSD, CPU Feature: AVX

func (Int32x4) Add 

func (x Int32x4) Add(y Int32x4) Int32x4

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX

func (Int32x4) And 

func (x Int32x4) And(y Int32x4) Int32x4

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Int32x4) AndNot 

func (x Int32x4) AndNot(y Int32x4) Int32x4

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Int32x4) AsFloat32x4 deprecated 

func (x Int32x4) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Int32x4 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsFloat64x2 deprecated 

func (x Int32x4) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Int32x4 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsInt8x16 deprecated 

func (x Int32x4) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Int32x4 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsInt16x8 deprecated 

func (x Int32x4) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Int32x4 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsInt64x2 deprecated 

func (x Int32x4) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Int32x4 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsUint8x16 deprecated 

func (x Int32x4) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Int32x4 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsUint16x8 deprecated 

func (x Int32x4) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Int32x4 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsUint32x4 deprecated 

func (x Int32x4) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Int32x4 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) AsUint64x2 deprecated 

func (x Int32x4) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Int32x4 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x4) Compress 

func (x Int32x4) Compress(mask Mask32x4) Int32x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Int32x4) ConcatAddPairs added in go1.27.0 

func (x Int32x4) ConcatAddPairs(y Int32x4) Int32x4

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDD, CPU Feature: AVX

func (Int32x4) ConcatPermute 

func (x Int32x4) ConcatPermute(y Int32x4, indices Uint32x4) Int32x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Int32x4) ConcatPermuteScalars added in go1.27.0 

func (x Int32x4) ConcatPermuteScalars(a, b, c, d uint8, y Int32x4) Int32x4

ConcatPermuteScalars returns the selection of four elements from the two vectors x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})

returns {4,8,25,81}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Int32x4) ConcatSubPairs added in go1.27.0 

func (x Int32x4) ConcatSubPairs(y Int32x4) Int32x4

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBD, CPU Feature: AVX

func (Int32x4) ConvertToFloat32 

func (x Int32x4) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTDQ2PS, CPU Feature: AVX

func (Int32x4) ConvertToFloat64 

func (x Int32x4) ConvertToFloat64() Float64x4

ConvertToFloat64 converts element values to float64.

Asm: VCVTDQ2PD, CPU Feature: AVX

func (Int32x4) ConvertToUint32 added in go1.27.0 

func (x Int32x4) ConvertToUint32() Uint32x4

ConvertToUint32 converts a Int32x4 vector to a Uint32x4 vector

func (Int32x4) Equal 

func (x Int32x4) Equal(y Int32x4) Mask32x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX

func (Int32x4) Expand 

func (x Int32x4) Expand(mask Mask32x4) Int32x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Int32x4) ExtendLo2ToInt64 

func (x Int32x4) ExtendLo2ToInt64() Int64x2

ExtendLo2ToInt64 sign-extends 2 lowest vector element values to int64.

Asm: VPMOVSXDQ, CPU Feature: AVX

func (Int32x4) ExtendToInt64 

func (x Int32x4) ExtendToInt64() Int64x4

ExtendToInt64 sign-extends element values to int64.

Asm: VPMOVSXDQ, CPU Feature: AVX2

func (Int32x4) GetElem 

func (x Int32x4) GetElem(index uint8) int32

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRD, CPU Feature: AVX

func (Int32x4) Greater 

func (x Int32x4) Greater(y Int32x4) Mask32x4

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTD, CPU Feature: AVX

func (Int32x4) GreaterEqual 

func (x Int32x4) GreaterEqual(y Int32x4) Mask32x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Int32x4) IfElse added in go1.27.0 

func (x Int32x4) IfElse(mask Mask32x4, y Int32x4) Int32x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Int32x4) InterleaveHi 

func (x Int32x4) InterleaveHi(y Int32x4) Int32x4

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX

func (Int32x4) InterleaveLo 

func (x Int32x4) InterleaveLo(y Int32x4) Int32x4

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX

func (Int32x4) IsZero 

func (x Int32x4) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int32x4) LeadingZeros 

func (x Int32x4) LeadingZeros() Int32x4

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Int32x4) Len 

func (x Int32x4) Len() int

Len returns the number of elements in an Int32x4.

func (Int32x4) Less 

func (x Int32x4) Less(y Int32x4) Mask32x4

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Int32x4) LessEqual 

func (x Int32x4) LessEqual(y Int32x4) Mask32x4

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Int32x4) Masked 

func (x Int32x4) Masked(mask Mask32x4) Int32x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Int32x4) Max 

func (x Int32x4) Max(y Int32x4) Int32x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSD, CPU Feature: AVX

func (Int32x4) Merge deprecated 

func (x Int32x4) Merge(y Int32x4, mask Mask32x4) Int32x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Int32x4) Min 

func (x Int32x4) Min(y Int32x4) Int32x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSD, CPU Feature: AVX

func (Int32x4) Mul 

func (x Int32x4) Mul(y Int32x4) Int32x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX

func (Int32x4) MulSign added in go1.27.0 

func (x Int32x4) MulSign(y Int32x4) Int32x4

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGND, CPU Feature: AVX

func (Int32x4) MulWidenEven added in go1.27.0 

func (x Int32x4) MulWidenEven(y Int32x4) Int64x2

MulWidenEven multiplies even-indexed elements, widening the result. Result[i] = v1[2*i] * v2[2*i].

Asm: VPMULDQ, CPU Feature: AVX

func (Int32x4) Neg added in go1.27.0 

func (x Int32x4) Neg() Int32x4

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX

func (Int32x4) Not 

func (x Int32x4) Not() Int32x4

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Int32x4) NotEqual 

func (x Int32x4) NotEqual(y Int32x4) Mask32x4

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Int32x4) OnesCount 

func (x Int32x4) OnesCount() Int32x4

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Int32x4) Or 

func (x Int32x4) Or(y Int32x4) Int32x4

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Int32x4) PermuteScalars 

func (x Int32x4) PermuteScalars(a, b, c, d uint8) Int32x4

PermuteScalars performs a permutation of vector x's elements using the supplied indices: 

result = {x[a], x[b], x[c], x[d]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table may be generated.

Asm: VPSHUFD, CPU Feature: AVX

func (Int32x4) RotateAllLeft 

func (x Int32x4) RotateAllLeft(dist uint64) Int32x4

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int32x4) RotateAllRight 

func (x Int32x4) RotateAllRight(dist uint64) Int32x4

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int32x4) RotateLeft 

func (x Int32x4) RotateLeft(y Int32x4) Int32x4

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Int32x4) RotateRight 

func (x Int32x4) RotateRight(y Int32x4) Int32x4

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Int32x4) SaturateToInt8 

func (x Int32x4) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSDB, CPU Feature: AVX512

func (Int32x4) SaturateToInt16 

func (x Int32x4) SaturateToInt16() Int16x8

SaturateToInt16 converts element values to int16 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSDW, CPU Feature: AVX512

func (Int32x4) SaturateToInt16Concat 

func (x Int32x4) SaturateToInt16Concat(y Int32x4) Int16x8

SaturateToInt16Concat converts element values to int16 with signed saturation. The converted elements from x will be packed to the lower part of the result vector, the converted elements from y will be packed to the upper part of the result vector.

Asm: VPACKSSDW, CPU Feature: AVX

func (Int32x4) SaturateToUint16Concat 

func (x Int32x4) SaturateToUint16Concat(y Int32x4) Uint16x8

SaturateToUint16Concat converts element values to uint16 with unsigned saturation. The converted elements from x will be packed to the lower part of the result vector, the converted elements from y will be packed to the upper part of the result vector.

Asm: VPACKUSDW, CPU Feature: AVX

func (Int32x4) SetElem 

func (x Int32x4) SetElem(index uint8, y int32) Int32x4

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRD, CPU Feature: AVX

func (Int32x4) ShiftAllLeft 

func (x Int32x4) ShiftAllLeft(shift uint64) Int32x4

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX

func (Int32x4) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Int32x4) ShiftAllLeftConcatMod32(y Int32x4, shift uint64) Int32x4

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Int32x4) ShiftAllRight 

func (x Int32x4) ShiftAllRight(shift uint64) Int32x4

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAD, CPU Feature: AVX

func (Int32x4) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Int32x4) ShiftAllRightConcatMod32(y Int32x4, shift uint64) Int32x4

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Int32x4) ShiftLeft 

func (x Int32x4) ShiftLeft(shift Uint32x4) Int32x4

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX2

func (Int32x4) ShiftLeftConcatMod32 added in go1.27.0 

func (x Int32x4) ShiftLeftConcatMod32(y Int32x4, shift Uint32x4) Int32x4

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Int32x4) ShiftRight 

func (x Int32x4) ShiftRight(shift Uint32x4) Int32x4

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVD, CPU Feature: AVX2

func (Int32x4) ShiftRightConcatMod32 added in go1.27.0 

func (x Int32x4) ShiftRightConcatMod32(y Int32x4, shift Uint32x4) Int32x4

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Int32x4) Store 

func (x Int32x4) Store(s []int32)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Int32x4) StoreArray added in go1.27.0 

func (x Int32x4) StoreArray(y *[4]int32)

StoreArray stores an Int32x4 to an array.

func (Int32x4) StoreArrayMasked added in go1.27.0 

func (x Int32x4) StoreArrayMasked(y *[4]int32, mask Mask32x4)

StoreArrayMasked stores an Int32x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Int32x4) StorePart added in go1.27.0 

func (x Int32x4) StorePart(s []int32) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Int32x4) String 

func (x Int32x4) String() string

String returns a string representation of SIMD vector x.

func (Int32x4) Sub 

func (x Int32x4) Sub(y Int32x4) Int32x4

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX

func (Int32x4) ToBits added in go1.27.0 

func (x Int32x4) ToBits() Uint32x4

ToBits reinterprets the bits of a Int32x4 vector as a Uint32x4 vector

func (Int32x4) ToMask 

func (from Int32x4) ToMask() (to Mask32x4)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int32x4) TruncToInt8 added in go1.27.0 

func (x Int32x4) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDB, CPU Feature: AVX512

func (Int32x4) TruncToInt16 added in go1.27.0 

func (x Int32x4) TruncToInt16() Int16x8

TruncToInt16 truncates element values to int16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDW, CPU Feature: AVX512

func (Int32x4) Xor 

func (x Int32x4) Xor(y Int32x4) Int32x4

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Int32x8 

type Int32x8 struct {
	// contains filtered or unexported fields
}

Int32x8 is a 256-bit SIMD vector of 8 int32s.

func BroadcastInt32x8 

func BroadcastInt32x8(x int32) Int32x8

BroadcastInt32x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt32x8 

func LoadInt32x8(s []int32) Int32x8

LoadInt32x8 loads an Int32x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadInt32x8Array added in go1.27.0 

func LoadInt32x8Array(y *[8]int32) Int32x8

LoadInt32x8Array loads an Int32x8 from an array.

func LoadInt32x8Part added in go1.27.0 

func LoadInt32x8Part(s []int32) (Int32x8, int)

LoadInt32x8Part loads a Int32x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadInt32x8.

func (Int32x8) Abs 

func (x Int32x8) Abs() Int32x8

Abs computes the absolute value of each element.

Asm: VPABSD, CPU Feature: AVX2

func (Int32x8) Add 

func (x Int32x8) Add(y Int32x8) Int32x8

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX2

func (Int32x8) And 

func (x Int32x8) And(y Int32x8) Int32x8

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Int32x8) AndNot 

func (x Int32x8) AndNot(y Int32x8) Int32x8

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Int32x8) AsFloat32x8 deprecated 

func (x Int32x8) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Int32x8 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsFloat64x4 deprecated 

func (x Int32x8) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Int32x8 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsInt8x32 deprecated 

func (x Int32x8) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Int32x8 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsInt16x16 deprecated 

func (x Int32x8) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Int32x8 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsInt64x4 deprecated 

func (x Int32x8) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Int32x8 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsUint8x32 deprecated 

func (x Int32x8) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Int32x8 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsUint16x16 deprecated 

func (x Int32x8) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Int32x8 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsUint32x8 deprecated 

func (x Int32x8) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Int32x8 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) AsUint64x4 deprecated 

func (x Int32x8) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Int32x8 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x8) Compress 

func (x Int32x8) Compress(mask Mask32x8) Int32x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Int32x8) ConcatAddPairsGrouped added in go1.27.0 

func (x Int32x8) ConcatAddPairsGrouped(y Int32x8) Int32x8

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDD, CPU Feature: AVX2

func (Int32x8) ConcatPermute 

func (x Int32x8) ConcatPermute(y Int32x8, indices Uint32x8) Int32x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Int32x8) ConcatPermute128Scalars added in go1.27.0 

func (x Int32x8) ConcatPermute128Scalars(lo, hi uint8, y Int32x8) Int32x8

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 42, 43, 50, 51, 52, 53}.ConcatPermute128Scalars(3, 0, {60, 61, 62, 63, 70, 71, 72, 73})

returns {70, 71, 72, 73, 40, 41, 42, 43}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Int32x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Int32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Int32x8) Int32x8

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})

returns {4,8,25,81,64,128,169,289}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Int32x8) ConcatSubPairsGrouped added in go1.27.0 

func (x Int32x8) ConcatSubPairsGrouped(y Int32x8) Int32x8

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBD, CPU Feature: AVX2

func (Int32x8) ConvertToFloat32 

func (x Int32x8) ConvertToFloat32() Float32x8

ConvertToFloat32 converts element values to float32.

Asm: VCVTDQ2PS, CPU Feature: AVX

func (Int32x8) ConvertToFloat64 

func (x Int32x8) ConvertToFloat64() Float64x8

ConvertToFloat64 converts element values to float64.

Asm: VCVTDQ2PD, CPU Feature: AVX512

func (Int32x8) ConvertToUint32 added in go1.27.0 

func (x Int32x8) ConvertToUint32() Uint32x8

ConvertToUint32 converts a Int32x8 vector to a Uint32x8 vector

func (Int32x8) Equal 

func (x Int32x8) Equal(y Int32x8) Mask32x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX2

func (Int32x8) Expand 

func (x Int32x8) Expand(mask Mask32x8) Int32x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Int32x8) ExtendToInt64 

func (x Int32x8) ExtendToInt64() Int64x8

ExtendToInt64 sign-extends element values to int64.

Asm: VPMOVSXDQ, CPU Feature: AVX512

func (Int32x8) GetHi 

func (x Int32x8) GetHi() Int32x4

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int32x8) GetLo 

func (x Int32x8) GetLo() Int32x4

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int32x8) Greater 

func (x Int32x8) Greater(y Int32x8) Mask32x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTD, CPU Feature: AVX2

func (Int32x8) GreaterEqual 

func (x Int32x8) GreaterEqual(y Int32x8) Mask32x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Int32x8) IfElse added in go1.27.0 

func (x Int32x8) IfElse(mask Mask32x8, y Int32x8) Int32x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Int32x8) InterleaveHiGrouped 

func (x Int32x8) InterleaveHiGrouped(y Int32x8) Int32x8

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX2

func (Int32x8) InterleaveLoGrouped 

func (x Int32x8) InterleaveLoGrouped(y Int32x8) Int32x8

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX2

func (Int32x8) IsZero 

func (x Int32x8) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int32x8) LeadingZeros 

func (x Int32x8) LeadingZeros() Int32x8

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Int32x8) Len 

func (x Int32x8) Len() int

Len returns the number of elements in an Int32x8.

func (Int32x8) Less 

func (x Int32x8) Less(y Int32x8) Mask32x8

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Int32x8) LessEqual 

func (x Int32x8) LessEqual(y Int32x8) Mask32x8

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Int32x8) Masked 

func (x Int32x8) Masked(mask Mask32x8) Int32x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Int32x8) Max 

func (x Int32x8) Max(y Int32x8) Int32x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSD, CPU Feature: AVX2

func (Int32x8) Merge deprecated 

func (x Int32x8) Merge(y Int32x8, mask Mask32x8) Int32x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Int32x8) Min 

func (x Int32x8) Min(y Int32x8) Int32x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSD, CPU Feature: AVX2

func (Int32x8) Mul 

func (x Int32x8) Mul(y Int32x8) Int32x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX2

func (Int32x8) MulSign added in go1.27.0 

func (x Int32x8) MulSign(y Int32x8) Int32x8

MulSign returns the product of x with the sign of y (-1, 0, or 1).

Asm: VPSIGND, CPU Feature: AVX2

func (Int32x8) MulWidenEven added in go1.27.0 

func (x Int32x8) MulWidenEven(y Int32x8) Int64x4

MulWidenEven multiplies even-indexed elements, widening the result. Result[i] = v1[2*i] * v2[2*i].

Asm: VPMULDQ, CPU Feature: AVX2

func (Int32x8) Neg added in go1.27.0 

func (x Int32x8) Neg() Int32x8

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX2

func (Int32x8) Not 

func (x Int32x8) Not() Int32x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Int32x8) NotEqual 

func (x Int32x8) NotEqual(y Int32x8) Mask32x8

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Int32x8) OnesCount 

func (x Int32x8) OnesCount() Int32x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Int32x8) Or 

func (x Int32x8) Or(y Int32x8) Int32x8

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Int32x8) Permute 

func (x Int32x8) Permute(indices Uint32x8) Int32x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMD, CPU Feature: AVX2

func (Int32x8) PermuteScalarsGrouped 

func (x Int32x8) PermuteScalarsGrouped(a, b, c, d uint8) Int32x8

PermuteScalarsGrouped performs a grouped permutation of vector x using the supplied indices: 

result = {x[a], x[b], x[c], x[d], x[a+4], x[b+4], x[c+4], x[d+4]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table may be generated.

Asm: VPSHUFD, CPU Feature: AVX2

func (Int32x8) RotateAllLeft 

func (x Int32x8) RotateAllLeft(dist uint64) Int32x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int32x8) RotateAllRight 

func (x Int32x8) RotateAllRight(dist uint64) Int32x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int32x8) RotateLeft 

func (x Int32x8) RotateLeft(y Int32x8) Int32x8

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Int32x8) RotateRight 

func (x Int32x8) RotateRight(y Int32x8) Int32x8

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Int32x8) SaturateToInt8 

func (x Int32x8) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSDB, CPU Feature: AVX512

func (Int32x8) SaturateToInt16 

func (x Int32x8) SaturateToInt16() Int16x8

SaturateToInt16 converts element values to int16 with signed saturation.

Asm: VPMOVSDW, CPU Feature: AVX512

func (Int32x8) SaturateToInt16ConcatGrouped 

func (x Int32x8) SaturateToInt16ConcatGrouped(y Int32x8) Int16x16

SaturateToInt16ConcatGrouped converts element values to int16 with signed saturation. With each 128-bit as a group: The converted elements from x will be packed to the lower part of the group in the result vector, the converted elements from y will be packed to the upper part of the group in the result vector.

Asm: VPACKSSDW, CPU Feature: AVX2

func (Int32x8) SaturateToUint16ConcatGrouped 

func (x Int32x8) SaturateToUint16ConcatGrouped(y Int32x8) Uint16x16

SaturateToUint16ConcatGrouped converts element values to uint16 with unsigned saturation. With each 128-bit as a group: The converted elements from x will be packed to the lower part of the group in the result vector, the converted elements from y will be packed to the upper part of the group in the result vector.

Asm: VPACKUSDW, CPU Feature: AVX2

func (Int32x8) SetHi 

func (x Int32x8) SetHi(y Int32x4) Int32x8

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int32x8) SetLo 

func (x Int32x8) SetLo(y Int32x4) Int32x8

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int32x8) ShiftAllLeft 

func (x Int32x8) ShiftAllLeft(shift uint64) Int32x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX2

func (Int32x8) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Int32x8) ShiftAllLeftConcatMod32(y Int32x8, shift uint64) Int32x8

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Int32x8) ShiftAllRight 

func (x Int32x8) ShiftAllRight(shift uint64) Int32x8

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAD, CPU Feature: AVX2

func (Int32x8) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Int32x8) ShiftAllRightConcatMod32(y Int32x8, shift uint64) Int32x8

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Int32x8) ShiftLeft 

func (x Int32x8) ShiftLeft(shift Uint32x8) Int32x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX2

func (Int32x8) ShiftLeftConcatMod32 added in go1.27.0 

func (x Int32x8) ShiftLeftConcatMod32(y Int32x8, shift Uint32x8) Int32x8

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Int32x8) ShiftRight 

func (x Int32x8) ShiftRight(shift Uint32x8) Int32x8

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVD, CPU Feature: AVX2

func (Int32x8) ShiftRightConcatMod32 added in go1.27.0 

func (x Int32x8) ShiftRightConcatMod32(y Int32x8, shift Uint32x8) Int32x8

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Int32x8) Store 

func (x Int32x8) Store(s []int32)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Int32x8) StoreArray added in go1.27.0 

func (x Int32x8) StoreArray(y *[8]int32)

StoreArray stores an Int32x8 to an array.

func (Int32x8) StoreArrayMasked added in go1.27.0 

func (x Int32x8) StoreArrayMasked(y *[8]int32, mask Mask32x8)

StoreArrayMasked stores an Int32x8 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Int32x8) StorePart added in go1.27.0 

func (x Int32x8) StorePart(s []int32) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Int32x8) String 

func (x Int32x8) String() string

String returns a string representation of SIMD vector x.

func (Int32x8) Sub 

func (x Int32x8) Sub(y Int32x8) Int32x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX2

func (Int32x8) ToBits added in go1.27.0 

func (x Int32x8) ToBits() Uint32x8

ToBits reinterprets the bits of a Int32x8 vector as a Uint32x8 vector

func (Int32x8) ToMask 

func (from Int32x8) ToMask() (to Mask32x8)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int32x8) TruncToInt8 added in go1.27.0 

func (x Int32x8) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDB, CPU Feature: AVX512

func (Int32x8) TruncToInt16 added in go1.27.0 

func (x Int32x8) TruncToInt16() Int16x8

TruncToInt16 truncates element values to int16.

Asm: VPMOVDW, CPU Feature: AVX512

func (Int32x8) Xor 

func (x Int32x8) Xor(y Int32x8) Int32x8

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Int32x16 

type Int32x16 struct {
	// contains filtered or unexported fields
}

Int32x16 is a 512-bit SIMD vector of 16 int32s.

func BroadcastInt32x16 

func BroadcastInt32x16(x int32) Int32x16

BroadcastInt32x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadInt32x16 

func LoadInt32x16(s []int32) Int32x16

LoadInt32x16 loads an Int32x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadInt32x16Array added in go1.27.0 

func LoadInt32x16Array(y *[16]int32) Int32x16

LoadInt32x16Array loads an Int32x16 from an array.

func LoadInt32x16Part added in go1.27.0 

func LoadInt32x16Part(s []int32) (Int32x16, int)

LoadInt32x16Part loads a Int32x16 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadInt32x16.

func (Int32x16) Abs 

func (x Int32x16) Abs() Int32x16

Abs computes the absolute value of each element.

Asm: VPABSD, CPU Feature: AVX512

func (Int32x16) Add 

func (x Int32x16) Add(y Int32x16) Int32x16

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX512

func (Int32x16) And 

func (x Int32x16) And(y Int32x16) Int32x16

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Int32x16) AndNot 

func (x Int32x16) AndNot(y Int32x16) Int32x16

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Int32x16) AsFloat32x16 deprecated 

func (x Int32x16) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Int32x16 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsFloat64x8 deprecated 

func (x Int32x16) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Int32x16 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsInt8x64 deprecated 

func (x Int32x16) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Int32x16 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsInt16x32 deprecated 

func (x Int32x16) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Int32x16 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsInt64x8 deprecated 

func (x Int32x16) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Int32x16 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsUint8x64 deprecated 

func (x Int32x16) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Int32x16 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsUint16x32 deprecated 

func (x Int32x16) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Int32x16 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsUint32x16 deprecated 

func (x Int32x16) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Int32x16 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) AsUint64x8 deprecated 

func (x Int32x16) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Int32x16 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int32x16) Compress 

func (x Int32x16) Compress(mask Mask32x16) Int32x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Int32x16) ConcatPermute 

func (x Int32x16) ConcatPermute(y Int32x16, indices Uint32x16) Int32x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Int32x16) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Int32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Int32x16) Int32x16

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX512

func (Int32x16) ConvertToFloat32 

func (x Int32x16) ConvertToFloat32() Float32x16

ConvertToFloat32 converts element values to float32.

Asm: VCVTDQ2PS, CPU Feature: AVX512

func (Int32x16) ConvertToUint32 added in go1.27.0 

func (x Int32x16) ConvertToUint32() Uint32x16

ConvertToUint32 converts a Int32x16 vector to a Uint32x16 vector

func (Int32x16) Equal 

func (x Int32x16) Equal(y Int32x16) Mask32x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX512

func (Int32x16) Expand 

func (x Int32x16) Expand(mask Mask32x16) Int32x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Int32x16) GetHi 

func (x Int32x16) GetHi() Int32x8

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int32x16) GetLo 

func (x Int32x16) GetLo() Int32x8

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int32x16) Greater 

func (x Int32x16) Greater(y Int32x16) Mask32x16

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTD, CPU Feature: AVX512

func (Int32x16) GreaterEqual 

func (x Int32x16) GreaterEqual(y Int32x16) Mask32x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPD, CPU Feature: AVX512

func (Int32x16) IfElse added in go1.27.0 

func (x Int32x16) IfElse(mask Mask32x16, y Int32x16) Int32x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Int32x16) InterleaveHiGrouped 

func (x Int32x16) InterleaveHiGrouped(y Int32x16) Int32x16

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX512

func (Int32x16) InterleaveLoGrouped 

func (x Int32x16) InterleaveLoGrouped(y Int32x16) Int32x16

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX512

func (Int32x16) LeadingZeros 

func (x Int32x16) LeadingZeros() Int32x16

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Int32x16) Len 

func (x Int32x16) Len() int

Len returns the number of elements in an Int32x16.

func (Int32x16) Less 

func (x Int32x16) Less(y Int32x16) Mask32x16

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPD, CPU Feature: AVX512

func (Int32x16) LessEqual 

func (x Int32x16) LessEqual(y Int32x16) Mask32x16

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPD, CPU Feature: AVX512

func (Int32x16) Masked 

func (x Int32x16) Masked(mask Mask32x16) Int32x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Int32x16) Max 

func (x Int32x16) Max(y Int32x16) Int32x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSD, CPU Feature: AVX512

func (Int32x16) Merge deprecated 

func (x Int32x16) Merge(y Int32x16, mask Mask32x16) Int32x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Int32x16) Min 

func (x Int32x16) Min(y Int32x16) Int32x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSD, CPU Feature: AVX512

func (Int32x16) Mul 

func (x Int32x16) Mul(y Int32x16) Int32x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX512

func (Int32x16) Neg added in go1.27.0 

func (x Int32x16) Neg() Int32x16

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX512

func (Int32x16) Not 

func (x Int32x16) Not() Int32x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Int32x16) NotEqual 

func (x Int32x16) NotEqual(y Int32x16) Mask32x16

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPD, CPU Feature: AVX512

func (Int32x16) OnesCount 

func (x Int32x16) OnesCount() Int32x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Int32x16) Or 

func (x Int32x16) Or(y Int32x16) Int32x16

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Int32x16) Permute 

func (x Int32x16) Permute(indices Uint32x16) Int32x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMD, CPU Feature: AVX512

func (Int32x16) PermuteScalarsGrouped 

func (x Int32x16) PermuteScalarsGrouped(a, b, c, d uint8) Int32x16

PermuteScalarsGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
	 {  x[a], x[b], x[c], x[d],         x[a+4], x[b+4], x[c+4], x[d+4],
		x[a+8], x[b+8], x[c+8], x[d+8], x[a+12], x[b+12], x[c+12], x[d+12]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table may be generated.

Asm: VPSHUFD, CPU Feature: AVX512

func (Int32x16) RotateAllLeft 

func (x Int32x16) RotateAllLeft(dist uint64) Int32x16

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int32x16) RotateAllRight 

func (x Int32x16) RotateAllRight(dist uint64) Int32x16

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int32x16) RotateLeft 

func (x Int32x16) RotateLeft(y Int32x16) Int32x16

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Int32x16) RotateRight 

func (x Int32x16) RotateRight(y Int32x16) Int32x16

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Int32x16) SaturateToInt8 

func (x Int32x16) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation.

Asm: VPMOVSDB, CPU Feature: AVX512

func (Int32x16) SaturateToInt16 

func (x Int32x16) SaturateToInt16() Int16x16

SaturateToInt16 converts element values to int16 with signed saturation.

Asm: VPMOVSDW, CPU Feature: AVX512

func (Int32x16) SaturateToInt16ConcatGrouped 

func (x Int32x16) SaturateToInt16ConcatGrouped(y Int32x16) Int16x32

SaturateToInt16ConcatGrouped converts element values to int16 with signed saturation. With each 128-bit as a group: The converted elements from x will be packed to the lower part of the group in the result vector, the converted elements from y will be packed to the upper part of the group in the result vector.

Asm: VPACKSSDW, CPU Feature: AVX512

func (Int32x16) SaturateToUint16ConcatGrouped 

func (x Int32x16) SaturateToUint16ConcatGrouped(y Int32x16) Uint16x32

SaturateToUint16ConcatGrouped converts element values to uint16 with unsigned saturation. With each 128-bit as a group: The converted elements from x will be packed to the lower part of the group in the result vector, the converted elements from y will be packed to the upper part of the group in the result vector.

Asm: VPACKUSDW, CPU Feature: AVX512

func (Int32x16) SetHi 

func (x Int32x16) SetHi(y Int32x8) Int32x16

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int32x16) SetLo 

func (x Int32x16) SetLo(y Int32x8) Int32x16

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int32x16) ShiftAllLeft 

func (x Int32x16) ShiftAllLeft(shift uint64) Int32x16

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX512

func (Int32x16) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Int32x16) ShiftAllLeftConcatMod32(y Int32x16, shift uint64) Int32x16

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Int32x16) ShiftAllRight 

func (x Int32x16) ShiftAllRight(shift uint64) Int32x16

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAD, CPU Feature: AVX512

func (Int32x16) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Int32x16) ShiftAllRightConcatMod32(y Int32x16, shift uint64) Int32x16

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Int32x16) ShiftLeft 

func (x Int32x16) ShiftLeft(shift Uint32x16) Int32x16

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX512

func (Int32x16) ShiftLeftConcatMod32 added in go1.27.0 

func (x Int32x16) ShiftLeftConcatMod32(y Int32x16, shift Uint32x16) Int32x16

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Int32x16) ShiftRight 

func (x Int32x16) ShiftRight(shift Uint32x16) Int32x16

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVD, CPU Feature: AVX512

func (Int32x16) ShiftRightConcatMod32 added in go1.27.0 

func (x Int32x16) ShiftRightConcatMod32(y Int32x16, shift Uint32x16) Int32x16

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Int32x16) Store 

func (x Int32x16) Store(s []int32)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Int32x16) StoreArray added in go1.27.0 

func (x Int32x16) StoreArray(y *[16]int32)

StoreArray stores an Int32x16 to an array.

func (Int32x16) StoreArrayMasked added in go1.27.0 

func (x Int32x16) StoreArrayMasked(y *[16]int32, mask Mask32x16)

StoreArrayMasked stores an Int32x16 to an array, at those elements enabled by mask.

Asm: VMOVDQU32, CPU Feature: AVX512

func (Int32x16) StorePart added in go1.27.0 

func (x Int32x16) StorePart(s []int32) int

StorePart stores the 16 elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Int32x16) String 

func (x Int32x16) String() string

String returns a string representation of SIMD vector x.

func (Int32x16) Sub 

func (x Int32x16) Sub(y Int32x16) Int32x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX512

func (Int32x16) ToBits added in go1.27.0 

func (x Int32x16) ToBits() Uint32x16

ToBits reinterprets the bits of a Int32x16 vector as a Uint32x16 vector

func (Int32x16) ToMask 

func (from Int32x16) ToMask() (to Mask32x16)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int32x16) TruncToInt8 added in go1.27.0 

func (x Int32x16) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8.

Asm: VPMOVDB, CPU Feature: AVX512

func (Int32x16) TruncToInt16 added in go1.27.0 

func (x Int32x16) TruncToInt16() Int16x16

TruncToInt16 truncates element values to int16.

Asm: VPMOVDW, CPU Feature: AVX512

func (Int32x16) Xor 

func (x Int32x16) Xor(y Int32x16) Int32x16

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Int64x2 

type Int64x2 struct {
	// contains filtered or unexported fields
}

Int64x2 is a 128-bit SIMD vector of 2 int64s.

func BroadcastInt64x2 

func BroadcastInt64x2(x int64) Int64x2

BroadcastInt64x2 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt64x2 

func LoadInt64x2(s []int64) Int64x2

LoadInt64x2 loads an Int64x2 from a slice of elements. If s does not have at least 2 elements, it panics.

func LoadInt64x2Array added in go1.27.0 

func LoadInt64x2Array(y *[2]int64) Int64x2

LoadInt64x2Array loads an Int64x2 from an array.

func LoadInt64x2Part added in go1.27.0 

func LoadInt64x2Part(s []int64) (Int64x2, int)

LoadInt64x2Part loads a Int64x2 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes. If s has 2 or more elements, the function is equivalent to LoadInt64x2.

func (Int64x2) Abs 

func (x Int64x2) Abs() Int64x2

Abs computes the absolute value of each element.

Asm: VPABSQ, CPU Feature: AVX512

func (Int64x2) Add 

func (x Int64x2) Add(y Int64x2) Int64x2

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX

func (Int64x2) And 

func (x Int64x2) And(y Int64x2) Int64x2

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Int64x2) AndNot 

func (x Int64x2) AndNot(y Int64x2) Int64x2

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Int64x2) AsFloat32x4 deprecated 

func (x Int64x2) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Int64x2 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsFloat64x2 deprecated 

func (x Int64x2) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Int64x2 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsInt8x16 deprecated 

func (x Int64x2) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Int64x2 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsInt16x8 deprecated 

func (x Int64x2) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Int64x2 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsInt32x4 deprecated 

func (x Int64x2) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Int64x2 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsUint8x16 deprecated 

func (x Int64x2) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Int64x2 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsUint16x8 deprecated 

func (x Int64x2) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Int64x2 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsUint32x4 deprecated 

func (x Int64x2) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Int64x2 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) AsUint64x2 deprecated 

func (x Int64x2) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Int64x2 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x2) Compress 

func (x Int64x2) Compress(mask Mask64x2) Int64x2

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Int64x2) ConcatPermute 

func (x Int64x2) ConcatPermute(y Int64x2, indices Uint64x2) Int64x2

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Int64x2) ConcatPermuteScalars added in go1.27.0 

func (x Int64x2) ConcatPermuteScalars(a, b uint8, y Int64x2) Int64x2

ConcatPermuteScalars returns the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Int64x2) ConvertToFloat32 

func (x Int64x2) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTQQ2PSX, CPU Feature: AVX512

func (Int64x2) ConvertToFloat64 

func (x Int64x2) ConvertToFloat64() Float64x2

ConvertToFloat64 converts element values to float64.

Asm: VCVTQQ2PD, CPU Feature: AVX512

func (Int64x2) ConvertToUint64 added in go1.27.0 

func (x Int64x2) ConvertToUint64() Uint64x2

ConvertToUint64 converts a Int64x2 vector to a Uint64x2 vector

func (Int64x2) Equal 

func (x Int64x2) Equal(y Int64x2) Mask64x2

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX

func (Int64x2) Expand 

func (x Int64x2) Expand(mask Mask64x2) Int64x2

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Int64x2) GetElem 

func (x Int64x2) GetElem(index uint8) int64

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRQ, CPU Feature: AVX

func (Int64x2) Greater 

func (x Int64x2) Greater(y Int64x2) Mask64x2

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTQ, CPU Feature: AVX

func (Int64x2) GreaterEqual 

func (x Int64x2) GreaterEqual(y Int64x2) Mask64x2

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Int64x2) IfElse added in go1.27.0 

func (x Int64x2) IfElse(mask Mask64x2, y Int64x2) Int64x2

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Int64x2) InterleaveHi 

func (x Int64x2) InterleaveHi(y Int64x2) Int64x2

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX

func (Int64x2) InterleaveLo 

func (x Int64x2) InterleaveLo(y Int64x2) Int64x2

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX

func (Int64x2) IsZero 

func (x Int64x2) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int64x2) LeadingZeros 

func (x Int64x2) LeadingZeros() Int64x2

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Int64x2) Len 

func (x Int64x2) Len() int

Len returns the number of elements in an Int64x2.

func (Int64x2) Less 

func (x Int64x2) Less(y Int64x2) Mask64x2

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Int64x2) LessEqual 

func (x Int64x2) LessEqual(y Int64x2) Mask64x2

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Int64x2) Masked 

func (x Int64x2) Masked(mask Mask64x2) Int64x2

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Int64x2) Max 

func (x Int64x2) Max(y Int64x2) Int64x2

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSQ, CPU Feature: AVX512

func (Int64x2) Merge deprecated 

func (x Int64x2) Merge(y Int64x2, mask Mask64x2) Int64x2

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Int64x2) Min 

func (x Int64x2) Min(y Int64x2) Int64x2

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSQ, CPU Feature: AVX512

func (Int64x2) Mul 

func (x Int64x2) Mul(y Int64x2) Int64x2

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Int64x2) Neg added in go1.27.0 

func (x Int64x2) Neg() Int64x2

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX

func (Int64x2) Not 

func (x Int64x2) Not() Int64x2

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Int64x2) NotEqual 

func (x Int64x2) NotEqual(y Int64x2) Mask64x2

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Int64x2) OnesCount 

func (x Int64x2) OnesCount() Int64x2

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Int64x2) Or 

func (x Int64x2) Or(y Int64x2) Int64x2

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Int64x2) RotateAllLeft 

func (x Int64x2) RotateAllLeft(dist uint64) Int64x2

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int64x2) RotateAllRight 

func (x Int64x2) RotateAllRight(dist uint64) Int64x2

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int64x2) RotateLeft 

func (x Int64x2) RotateLeft(y Int64x2) Int64x2

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Int64x2) RotateRight 

func (x Int64x2) RotateRight(y Int64x2) Int64x2

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Int64x2) SaturateToInt8 

func (x Int64x2) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQB, CPU Feature: AVX512

func (Int64x2) SaturateToInt16 

func (x Int64x2) SaturateToInt16() Int16x8

SaturateToInt16 converts element values to int16 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQW, CPU Feature: AVX512

func (Int64x2) SaturateToInt32 

func (x Int64x2) SaturateToInt32() Int32x4

SaturateToInt32 converts element values to int32 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQD, CPU Feature: AVX512

func (Int64x2) SetElem 

func (x Int64x2) SetElem(index uint8, y int64) Int64x2

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRQ, CPU Feature: AVX

func (Int64x2) ShiftAllLeft 

func (x Int64x2) ShiftAllLeft(shift uint64) Int64x2

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX

func (Int64x2) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Int64x2) ShiftAllLeftConcatMod64(y Int64x2, shift uint64) Int64x2

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Int64x2) ShiftAllRight 

func (x Int64x2) ShiftAllRight(shift uint64) Int64x2

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAQ, CPU Feature: AVX512

func (Int64x2) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Int64x2) ShiftAllRightConcatMod64(y Int64x2, shift uint64) Int64x2

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Int64x2) ShiftLeft 

func (x Int64x2) ShiftLeft(shift Uint64x2) Int64x2

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX2

func (Int64x2) ShiftLeftConcatMod64 added in go1.27.0 

func (x Int64x2) ShiftLeftConcatMod64(y Int64x2, shift Uint64x2) Int64x2

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Int64x2) ShiftRight 

func (x Int64x2) ShiftRight(shift Uint64x2) Int64x2

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVQ, CPU Feature: AVX512

func (Int64x2) ShiftRightConcatMod64 added in go1.27.0 

func (x Int64x2) ShiftRightConcatMod64(y Int64x2, shift Uint64x2) Int64x2

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Int64x2) Store 

func (x Int64x2) Store(s []int64)

Store stores the elements of x into a slice. If s does not have at least 2 elements, it panics.

func (Int64x2) StoreArray added in go1.27.0 

func (x Int64x2) StoreArray(y *[2]int64)

StoreArray stores an Int64x2 to an array.

func (Int64x2) StoreArrayMasked added in go1.27.0 

func (x Int64x2) StoreArrayMasked(y *[2]int64, mask Mask64x2)

StoreArrayMasked stores an Int64x2 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Int64x2) StorePart added in go1.27.0 

func (x Int64x2) StorePart(s []int64) int

StorePart stores the 2 elements of x into the slice s. It stores as many elements as will fit in s. If s has 2 or more elements, the method is equivalent to x.Store.

func (Int64x2) String 

func (x Int64x2) String() string

String returns a string representation of SIMD vector x.

func (Int64x2) Sub 

func (x Int64x2) Sub(y Int64x2) Int64x2

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX

func (Int64x2) ToBits added in go1.27.0 

func (x Int64x2) ToBits() Uint64x2

ToBits reinterprets the bits of a Int64x2 vector as a Uint64x2 vector

func (Int64x2) ToMask 

func (from Int64x2) ToMask() (to Mask64x2)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int64x2) TruncToInt8 added in go1.27.0 

func (x Int64x2) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Int64x2) TruncToInt16 added in go1.27.0 

func (x Int64x2) TruncToInt16() Int16x8

TruncToInt16 truncates element values to int16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQW, CPU Feature: AVX512

func (Int64x2) TruncToInt32 added in go1.27.0 

func (x Int64x2) TruncToInt32() Int32x4

TruncToInt32 truncates element values to int32. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQD, CPU Feature: AVX512

func (Int64x2) Xor 

func (x Int64x2) Xor(y Int64x2) Int64x2

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Int64x4 

type Int64x4 struct {
	// contains filtered or unexported fields
}

Int64x4 is a 256-bit SIMD vector of 4 int64s.

func BroadcastInt64x4 

func BroadcastInt64x4(x int64) Int64x4

BroadcastInt64x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadInt64x4 

func LoadInt64x4(s []int64) Int64x4

LoadInt64x4 loads an Int64x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadInt64x4Array added in go1.27.0 

func LoadInt64x4Array(y *[4]int64) Int64x4

LoadInt64x4Array loads an Int64x4 from an array.

func LoadInt64x4Part added in go1.27.0 

func LoadInt64x4Part(s []int64) (Int64x4, int)

LoadInt64x4Part loads a Int64x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadInt64x4.

func (Int64x4) Abs 

func (x Int64x4) Abs() Int64x4

Abs computes the absolute value of each element.

Asm: VPABSQ, CPU Feature: AVX512

func (Int64x4) Add 

func (x Int64x4) Add(y Int64x4) Int64x4

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX2

func (Int64x4) And 

func (x Int64x4) And(y Int64x4) Int64x4

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Int64x4) AndNot 

func (x Int64x4) AndNot(y Int64x4) Int64x4

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Int64x4) AsFloat32x8 deprecated 

func (x Int64x4) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Int64x4 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsFloat64x4 deprecated 

func (x Int64x4) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Int64x4 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsInt8x32 deprecated 

func (x Int64x4) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Int64x4 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsInt16x16 deprecated 

func (x Int64x4) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Int64x4 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsInt32x8 deprecated 

func (x Int64x4) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Int64x4 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsUint8x32 deprecated 

func (x Int64x4) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Int64x4 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsUint16x16 deprecated 

func (x Int64x4) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Int64x4 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsUint32x8 deprecated 

func (x Int64x4) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Int64x4 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) AsUint64x4 deprecated 

func (x Int64x4) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Int64x4 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x4) Compress 

func (x Int64x4) Compress(mask Mask64x4) Int64x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Int64x4) ConcatPermute 

func (x Int64x4) ConcatPermute(y Int64x4, indices Uint64x4) Int64x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Int64x4) ConcatPermute128Scalars added in go1.27.0 

func (x Int64x4) ConcatPermute128Scalars(lo, hi uint8, y Int64x4) Int64x4

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 50, 51}.ConcatPermute128Scalars(3, 0, {60, 61, 70, 71})

returns {70, 71, 40, 41}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Int64x4) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Int64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Int64x4) Int64x4

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Int64x4) ConvertToFloat32 

func (x Int64x4) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTQQ2PSY, CPU Feature: AVX512

func (Int64x4) ConvertToFloat64 

func (x Int64x4) ConvertToFloat64() Float64x4

ConvertToFloat64 converts element values to float64.

Asm: VCVTQQ2PD, CPU Feature: AVX512

func (Int64x4) ConvertToUint64 added in go1.27.0 

func (x Int64x4) ConvertToUint64() Uint64x4

ConvertToUint64 converts a Int64x4 vector to a Uint64x4 vector

func (Int64x4) Equal 

func (x Int64x4) Equal(y Int64x4) Mask64x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX2

func (Int64x4) Expand 

func (x Int64x4) Expand(mask Mask64x4) Int64x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Int64x4) GetHi 

func (x Int64x4) GetHi() Int64x2

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int64x4) GetLo 

func (x Int64x4) GetLo() Int64x2

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Int64x4) Greater 

func (x Int64x4) Greater(y Int64x4) Mask64x4

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTQ, CPU Feature: AVX2

func (Int64x4) GreaterEqual 

func (x Int64x4) GreaterEqual(y Int64x4) Mask64x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Int64x4) IfElse added in go1.27.0 

func (x Int64x4) IfElse(mask Mask64x4, y Int64x4) Int64x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Int64x4) InterleaveHiGrouped 

func (x Int64x4) InterleaveHiGrouped(y Int64x4) Int64x4

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX2

func (Int64x4) InterleaveLoGrouped 

func (x Int64x4) InterleaveLoGrouped(y Int64x4) Int64x4

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX2

func (Int64x4) IsZero 

func (x Int64x4) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Int64x4) LeadingZeros 

func (x Int64x4) LeadingZeros() Int64x4

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Int64x4) Len 

func (x Int64x4) Len() int

Len returns the number of elements in an Int64x4.

func (Int64x4) Less 

func (x Int64x4) Less(y Int64x4) Mask64x4

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Int64x4) LessEqual 

func (x Int64x4) LessEqual(y Int64x4) Mask64x4

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Int64x4) Masked 

func (x Int64x4) Masked(mask Mask64x4) Int64x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Int64x4) Max 

func (x Int64x4) Max(y Int64x4) Int64x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSQ, CPU Feature: AVX512

func (Int64x4) Merge deprecated 

func (x Int64x4) Merge(y Int64x4, mask Mask64x4) Int64x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Int64x4) Min 

func (x Int64x4) Min(y Int64x4) Int64x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSQ, CPU Feature: AVX512

func (Int64x4) Mul 

func (x Int64x4) Mul(y Int64x4) Int64x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Int64x4) Neg added in go1.27.0 

func (x Int64x4) Neg() Int64x4

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX2

func (Int64x4) Not 

func (x Int64x4) Not() Int64x4

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Int64x4) NotEqual 

func (x Int64x4) NotEqual(y Int64x4) Mask64x4

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Int64x4) OnesCount 

func (x Int64x4) OnesCount() Int64x4

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Int64x4) Or 

func (x Int64x4) Or(y Int64x4) Int64x4

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Int64x4) Permute 

func (x Int64x4) Permute(indices Uint64x4) Int64x4

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMQ, CPU Feature: AVX512

func (Int64x4) RotateAllLeft 

func (x Int64x4) RotateAllLeft(dist uint64) Int64x4

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int64x4) RotateAllRight 

func (x Int64x4) RotateAllRight(dist uint64) Int64x4

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int64x4) RotateLeft 

func (x Int64x4) RotateLeft(y Int64x4) Int64x4

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Int64x4) RotateRight 

func (x Int64x4) RotateRight(y Int64x4) Int64x4

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Int64x4) SaturateToInt8 

func (x Int64x4) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQB, CPU Feature: AVX512

func (Int64x4) SaturateToInt16 

func (x Int64x4) SaturateToInt16() Int16x8

SaturateToInt16 converts element values to int16 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQW, CPU Feature: AVX512

func (Int64x4) SaturateToInt32 

func (x Int64x4) SaturateToInt32() Int32x4

SaturateToInt32 converts element values to int32 with signed saturation.

Asm: VPMOVSQD, CPU Feature: AVX512

func (Int64x4) SetHi 

func (x Int64x4) SetHi(y Int64x2) Int64x4

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int64x4) SetLo 

func (x Int64x4) SetLo(y Int64x2) Int64x4

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Int64x4) ShiftAllLeft 

func (x Int64x4) ShiftAllLeft(shift uint64) Int64x4

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX2

func (Int64x4) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Int64x4) ShiftAllLeftConcatMod64(y Int64x4, shift uint64) Int64x4

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Int64x4) ShiftAllRight 

func (x Int64x4) ShiftAllRight(shift uint64) Int64x4

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAQ, CPU Feature: AVX512

func (Int64x4) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Int64x4) ShiftAllRightConcatMod64(y Int64x4, shift uint64) Int64x4

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Int64x4) ShiftLeft 

func (x Int64x4) ShiftLeft(shift Uint64x4) Int64x4

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX2

func (Int64x4) ShiftLeftConcatMod64 added in go1.27.0 

func (x Int64x4) ShiftLeftConcatMod64(y Int64x4, shift Uint64x4) Int64x4

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Int64x4) ShiftRight 

func (x Int64x4) ShiftRight(shift Uint64x4) Int64x4

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVQ, CPU Feature: AVX512

func (Int64x4) ShiftRightConcatMod64 added in go1.27.0 

func (x Int64x4) ShiftRightConcatMod64(y Int64x4, shift Uint64x4) Int64x4

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Int64x4) Store 

func (x Int64x4) Store(s []int64)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Int64x4) StoreArray added in go1.27.0 

func (x Int64x4) StoreArray(y *[4]int64)

StoreArray stores an Int64x4 to an array.

func (Int64x4) StoreArrayMasked added in go1.27.0 

func (x Int64x4) StoreArrayMasked(y *[4]int64, mask Mask64x4)

StoreArrayMasked stores an Int64x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Int64x4) StorePart added in go1.27.0 

func (x Int64x4) StorePart(s []int64) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Int64x4) String 

func (x Int64x4) String() string

String returns a string representation of SIMD vector x.

func (Int64x4) Sub 

func (x Int64x4) Sub(y Int64x4) Int64x4

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX2

func (Int64x4) ToBits added in go1.27.0 

func (x Int64x4) ToBits() Uint64x4

ToBits reinterprets the bits of a Int64x4 vector as a Uint64x4 vector

func (Int64x4) ToMask 

func (from Int64x4) ToMask() (to Mask64x4)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int64x4) TruncToInt8 added in go1.27.0 

func (x Int64x4) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Int64x4) TruncToInt16 added in go1.27.0 

func (x Int64x4) TruncToInt16() Int16x8

TruncToInt16 truncates element values to int16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQW, CPU Feature: AVX512

func (Int64x4) TruncToInt32 added in go1.27.0 

func (x Int64x4) TruncToInt32() Int32x4

TruncToInt32 truncates element values to int32.

Asm: VPMOVQD, CPU Feature: AVX512

func (Int64x4) Xor 

func (x Int64x4) Xor(y Int64x4) Int64x4

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Int64x8 

type Int64x8 struct {
	// contains filtered or unexported fields
}

Int64x8 is a 512-bit SIMD vector of 8 int64s.

func BroadcastInt64x8 

func BroadcastInt64x8(x int64) Int64x8

BroadcastInt64x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadInt64x8 

func LoadInt64x8(s []int64) Int64x8

LoadInt64x8 loads an Int64x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadInt64x8Array added in go1.27.0 

func LoadInt64x8Array(y *[8]int64) Int64x8

LoadInt64x8Array loads an Int64x8 from an array.

func LoadInt64x8Part added in go1.27.0 

func LoadInt64x8Part(s []int64) (Int64x8, int)

LoadInt64x8Part loads a Int64x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadInt64x8.

func (Int64x8) Abs 

func (x Int64x8) Abs() Int64x8

Abs computes the absolute value of each element.

Asm: VPABSQ, CPU Feature: AVX512

func (Int64x8) Add 

func (x Int64x8) Add(y Int64x8) Int64x8

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX512

func (Int64x8) And 

func (x Int64x8) And(y Int64x8) Int64x8

And performs a bitwise x & y.

Asm: VPANDQ, CPU Feature: AVX512

func (Int64x8) AndNot 

func (x Int64x8) AndNot(y Int64x8) Int64x8

AndNot performs a bitwise x &^ y.

Asm: VPANDNQ, CPU Feature: AVX512

func (Int64x8) AsFloat32x16 deprecated 

func (x Int64x8) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Int64x8 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsFloat64x8 deprecated 

func (x Int64x8) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Int64x8 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsInt8x64 deprecated 

func (x Int64x8) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Int64x8 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsInt16x32 deprecated 

func (x Int64x8) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Int64x8 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsInt32x16 deprecated 

func (x Int64x8) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Int64x8 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsUint8x64 deprecated 

func (x Int64x8) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Int64x8 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsUint16x32 deprecated 

func (x Int64x8) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Int64x8 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsUint32x16 deprecated 

func (x Int64x8) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Int64x8 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) AsUint64x8 deprecated 

func (x Int64x8) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Int64x8 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Int64x8) Compress 

func (x Int64x8) Compress(mask Mask64x8) Int64x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Int64x8) ConcatPermute 

func (x Int64x8) ConcatPermute(y Int64x8, indices Uint64x8) Int64x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Int64x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Int64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Int64x8) Int64x8

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX512

func (Int64x8) ConvertToFloat32 

func (x Int64x8) ConvertToFloat32() Float32x8

ConvertToFloat32 converts element values to float32.

Asm: VCVTQQ2PS, CPU Feature: AVX512

func (Int64x8) ConvertToFloat64 

func (x Int64x8) ConvertToFloat64() Float64x8

ConvertToFloat64 converts element values to float64.

Asm: VCVTQQ2PD, CPU Feature: AVX512

func (Int64x8) ConvertToUint64 added in go1.27.0 

func (x Int64x8) ConvertToUint64() Uint64x8

ConvertToUint64 converts a Int64x8 vector to a Uint64x8 vector

func (Int64x8) Equal 

func (x Int64x8) Equal(y Int64x8) Mask64x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX512

func (Int64x8) Expand 

func (x Int64x8) Expand(mask Mask64x8) Int64x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Int64x8) GetHi 

func (x Int64x8) GetHi() Int64x4

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int64x8) GetLo 

func (x Int64x8) GetLo() Int64x4

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Int64x8) Greater 

func (x Int64x8) Greater(y Int64x8) Mask64x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPGTQ, CPU Feature: AVX512

func (Int64x8) GreaterEqual 

func (x Int64x8) GreaterEqual(y Int64x8) Mask64x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPQ, CPU Feature: AVX512

func (Int64x8) IfElse added in go1.27.0 

func (x Int64x8) IfElse(mask Mask64x8, y Int64x8) Int64x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Int64x8) InterleaveHiGrouped 

func (x Int64x8) InterleaveHiGrouped(y Int64x8) Int64x8

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX512

func (Int64x8) InterleaveLoGrouped 

func (x Int64x8) InterleaveLoGrouped(y Int64x8) Int64x8

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX512

func (Int64x8) LeadingZeros 

func (x Int64x8) LeadingZeros() Int64x8

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Int64x8) Len 

func (x Int64x8) Len() int

Len returns the number of elements in an Int64x8.

func (Int64x8) Less 

func (x Int64x8) Less(y Int64x8) Mask64x8

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPQ, CPU Feature: AVX512

func (Int64x8) LessEqual 

func (x Int64x8) LessEqual(y Int64x8) Mask64x8

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPQ, CPU Feature: AVX512

func (Int64x8) Masked 

func (x Int64x8) Masked(mask Mask64x8) Int64x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Int64x8) Max 

func (x Int64x8) Max(y Int64x8) Int64x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXSQ, CPU Feature: AVX512

func (Int64x8) Merge deprecated 

func (x Int64x8) Merge(y Int64x8, mask Mask64x8) Int64x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Int64x8) Min 

func (x Int64x8) Min(y Int64x8) Int64x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINSQ, CPU Feature: AVX512

func (Int64x8) Mul 

func (x Int64x8) Mul(y Int64x8) Int64x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Int64x8) Neg added in go1.27.0 

func (x Int64x8) Neg() Int64x8

Neg returns the element-wise negation of x.

Emulated, CPU Feature: AVX512

func (Int64x8) Not 

func (x Int64x8) Not() Int64x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Int64x8) NotEqual 

func (x Int64x8) NotEqual(y Int64x8) Mask64x8

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPQ, CPU Feature: AVX512

func (Int64x8) OnesCount 

func (x Int64x8) OnesCount() Int64x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Int64x8) Or 

func (x Int64x8) Or(y Int64x8) Int64x8

Or performs a bitwise x | y.

Asm: VPORQ, CPU Feature: AVX512

func (Int64x8) Permute 

func (x Int64x8) Permute(indices Uint64x8) Int64x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMQ, CPU Feature: AVX512

func (Int64x8) RotateAllLeft 

func (x Int64x8) RotateAllLeft(dist uint64) Int64x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Int64x8) RotateAllRight 

func (x Int64x8) RotateAllRight(dist uint64) Int64x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Int64x8) RotateLeft 

func (x Int64x8) RotateLeft(y Int64x8) Int64x8

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Int64x8) RotateRight 

func (x Int64x8) RotateRight(y Int64x8) Int64x8

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Int64x8) SaturateToInt8 

func (x Int64x8) SaturateToInt8() Int8x16

SaturateToInt8 converts element values to int8 with signed saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVSQB, CPU Feature: AVX512

func (Int64x8) SaturateToInt16 

func (x Int64x8) SaturateToInt16() Int16x8

SaturateToInt16 converts element values to int16 with signed saturation.

Asm: VPMOVSQW, CPU Feature: AVX512

func (Int64x8) SaturateToInt32 

func (x Int64x8) SaturateToInt32() Int32x8

SaturateToInt32 converts element values to int32 with signed saturation.

Asm: VPMOVSQD, CPU Feature: AVX512

func (Int64x8) SetHi 

func (x Int64x8) SetHi(y Int64x4) Int64x8

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int64x8) SetLo 

func (x Int64x8) SetLo(y Int64x4) Int64x8

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Int64x8) ShiftAllLeft 

func (x Int64x8) ShiftAllLeft(shift uint64) Int64x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX512

func (Int64x8) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Int64x8) ShiftAllLeftConcatMod64(y Int64x8, shift uint64) Int64x8

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Int64x8) ShiftAllRight 

func (x Int64x8) ShiftAllRight(shift uint64) Int64x8

ShiftAllRight arithmetically shifts each element of x right by y bits. If y is greater than the element width, the result is 0 or -1.

Asm: VPSRAQ, CPU Feature: AVX512

func (Int64x8) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Int64x8) ShiftAllRightConcatMod64(y Int64x8, shift uint64) Int64x8

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Int64x8) ShiftLeft 

func (x Int64x8) ShiftLeft(shift Uint64x8) Int64x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX512

func (Int64x8) ShiftLeftConcatMod64 added in go1.27.0 

func (x Int64x8) ShiftLeftConcatMod64(y Int64x8, shift Uint64x8) Int64x8

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Int64x8) ShiftRight 

func (x Int64x8) ShiftRight(shift Uint64x8) Int64x8

ShiftRight arithmetically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0 or -1.

Asm: VPSRAVQ, CPU Feature: AVX512

func (Int64x8) ShiftRightConcatMod64 added in go1.27.0 

func (x Int64x8) ShiftRightConcatMod64(y Int64x8, shift Uint64x8) Int64x8

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Int64x8) Store 

func (x Int64x8) Store(s []int64)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Int64x8) StoreArray added in go1.27.0 

func (x Int64x8) StoreArray(y *[8]int64)

StoreArray stores an Int64x8 to an array.

func (Int64x8) StoreArrayMasked added in go1.27.0 

func (x Int64x8) StoreArrayMasked(y *[8]int64, mask Mask64x8)

StoreArrayMasked stores an Int64x8 to an array, at those elements enabled by mask.

Asm: VMOVDQU64, CPU Feature: AVX512

func (Int64x8) StorePart added in go1.27.0 

func (x Int64x8) StorePart(s []int64) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Int64x8) String 

func (x Int64x8) String() string

String returns a string representation of SIMD vector x.

func (Int64x8) Sub 

func (x Int64x8) Sub(y Int64x8) Int64x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX512

func (Int64x8) ToBits added in go1.27.0 

func (x Int64x8) ToBits() Uint64x8

ToBits reinterprets the bits of a Int64x8 vector as a Uint64x8 vector

func (Int64x8) ToMask 

func (from Int64x8) ToMask() (to Mask64x8)

ToMask returns a mask whose i'th element is set if x[i] is non-zero.

func (Int64x8) TruncToInt8 added in go1.27.0 

func (x Int64x8) TruncToInt8() Int8x16

TruncToInt8 truncates element values to int8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Int64x8) TruncToInt16 added in go1.27.0 

func (x Int64x8) TruncToInt16() Int16x8

TruncToInt16 truncates element values to int16.

Asm: VPMOVQW, CPU Feature: AVX512

func (Int64x8) TruncToInt32 added in go1.27.0 

func (x Int64x8) TruncToInt32() Int32x8

TruncToInt32 truncates element values to int32.

Asm: VPMOVQD, CPU Feature: AVX512

func (Int64x8) Xor 

func (x Int64x8) Xor(y Int64x8) Int64x8

Xor performs a bitwise x ^ y.

Asm: VPXORQ, CPU Feature: AVX512

type Mask8x16 

type Mask8x16 struct {
	// contains filtered or unexported fields
}

Mask8x16 is a mask for a SIMD vector of 16 8-bit elements.

func Mask8x16FromBits 

func Mask8x16FromBits(y uint16) Mask8x16

Mask8x16FromBits constructs a Mask8x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVB, CPU Feature: AVX512

func (Mask8x16) And 

func (x Mask8x16) And(y Mask8x16) Mask8x16

func (Mask8x16) Or 

func (x Mask8x16) Or(y Mask8x16) Mask8x16

func (Mask8x16) String added in go1.27.0 

func (x Mask8x16) String() string

String returns a string representation of SIMD mask x.

func (Mask8x16) ToBits 

func (x Mask8x16) ToBits() uint16

ToBits constructs a bitmap from a Mask8x16, where 1 means set for the indexed element, 0 means unset.

Asm: VPMOVMSKB, CPU Features: AVX

func (Mask8x16) ToInt8x16 

func (from Mask8x16) ToInt8x16() (to Int8x16)

ToInt8x16 converts from Mask8x16 to Int8x16. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask8x32 

type Mask8x32 struct {
	// contains filtered or unexported fields
}

Mask8x32 is a mask for a SIMD vector of 32 8-bit elements.

func Mask8x32FromBits 

func Mask8x32FromBits(y uint32) Mask8x32

Mask8x32FromBits constructs a Mask8x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVB, CPU Feature: AVX512

func (Mask8x32) And 

func (x Mask8x32) And(y Mask8x32) Mask8x32

func (Mask8x32) Or 

func (x Mask8x32) Or(y Mask8x32) Mask8x32

func (Mask8x32) String added in go1.27.0 

func (x Mask8x32) String() string

String returns a string representation of SIMD mask x.

func (Mask8x32) ToBits 

func (x Mask8x32) ToBits() uint32

ToBits constructs a bitmap from a Mask8x32, where 1 means set for the indexed element, 0 means unset.

Asm: VPMOVMSKB, CPU Features: AVX2

func (Mask8x32) ToInt8x32 

func (from Mask8x32) ToInt8x32() (to Int8x32)

ToInt8x32 converts from Mask8x32 to Int8x32. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask8x64 

type Mask8x64 struct {
	// contains filtered or unexported fields
}

Mask8x64 is a mask for a SIMD vector of 64 8-bit elements.

func Mask8x64FromBits 

func Mask8x64FromBits(y uint64) Mask8x64

Mask8x64FromBits constructs a Mask8x64 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVB, CPU Feature: AVX512

func (Mask8x64) And 

func (x Mask8x64) And(y Mask8x64) Mask8x64

func (Mask8x64) Or 

func (x Mask8x64) Or(y Mask8x64) Mask8x64

func (Mask8x64) String added in go1.27.0 

func (x Mask8x64) String() string

String returns a string representation of SIMD mask x.

func (Mask8x64) ToBits 

func (x Mask8x64) ToBits() uint64

ToBits constructs a bitmap from a Mask8x64, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVB, CPU Features: AVX512

func (Mask8x64) ToInt8x64 

func (from Mask8x64) ToInt8x64() (to Int8x64)

ToInt8x64 converts from Mask8x64 to Int8x64. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask16x8 

type Mask16x8 struct {
	// contains filtered or unexported fields
}

Mask16x8 is a mask for a SIMD vector of 8 16-bit elements.

func Mask16x8FromBits 

func Mask16x8FromBits(y uint8) Mask16x8

Mask16x8FromBits constructs a Mask16x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Feature: AVX512

func (Mask16x8) And 

func (x Mask16x8) And(y Mask16x8) Mask16x8

func (Mask16x8) Or 

func (x Mask16x8) Or(y Mask16x8) Mask16x8

func (Mask16x8) String added in go1.27.0 

func (x Mask16x8) String() string

String returns a string representation of SIMD mask x.

func (Mask16x8) ToBits 

func (x Mask16x8) ToBits() uint8

ToBits constructs a bitmap from a Mask16x8, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Features: AVX512

func (Mask16x8) ToInt16x8 

func (from Mask16x8) ToInt16x8() (to Int16x8)

ToInt16x8 converts from Mask16x8 to Int16x8. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask16x16 

type Mask16x16 struct {
	// contains filtered or unexported fields
}

Mask16x16 is a mask for a SIMD vector of 16 16-bit elements.

func Mask16x16FromBits 

func Mask16x16FromBits(y uint16) Mask16x16

Mask16x16FromBits constructs a Mask16x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Feature: AVX512

func (Mask16x16) And 

func (x Mask16x16) And(y Mask16x16) Mask16x16

func (Mask16x16) Or 

func (x Mask16x16) Or(y Mask16x16) Mask16x16

func (Mask16x16) String added in go1.27.0 

func (x Mask16x16) String() string

String returns a string representation of SIMD mask x.

func (Mask16x16) ToBits 

func (x Mask16x16) ToBits() uint16

ToBits constructs a bitmap from a Mask16x16, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Features: AVX512

func (Mask16x16) ToInt16x16 

func (from Mask16x16) ToInt16x16() (to Int16x16)

ToInt16x16 converts from Mask16x16 to Int16x16. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask16x32 

type Mask16x32 struct {
	// contains filtered or unexported fields
}

Mask16x32 is a mask for a SIMD vector of 32 16-bit elements.

func Mask16x32FromBits 

func Mask16x32FromBits(y uint32) Mask16x32

Mask16x32FromBits constructs a Mask16x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Feature: AVX512

func (Mask16x32) And 

func (x Mask16x32) And(y Mask16x32) Mask16x32

func (Mask16x32) Or 

func (x Mask16x32) Or(y Mask16x32) Mask16x32

func (Mask16x32) String added in go1.27.0 

func (x Mask16x32) String() string

String returns a string representation of SIMD mask x.

func (Mask16x32) ToBits 

func (x Mask16x32) ToBits() uint32

ToBits constructs a bitmap from a Mask16x32, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVW, CPU Features: AVX512

func (Mask16x32) ToInt16x32 

func (from Mask16x32) ToInt16x32() (to Int16x32)

ToInt16x32 converts from Mask16x32 to Int16x32. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask32x4 

type Mask32x4 struct {
	// contains filtered or unexported fields
}

Mask32x4 is a mask for a SIMD vector of 4 32-bit elements.

func Mask32x4FromBits 

func Mask32x4FromBits(y uint8) Mask32x4

Mask32x4FromBits constructs a Mask32x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset. Only the lower 4 bits of y are used.

Asm: KMOVD, CPU Feature: AVX512

func (Mask32x4) And 

func (x Mask32x4) And(y Mask32x4) Mask32x4

func (Mask32x4) Or 

func (x Mask32x4) Or(y Mask32x4) Mask32x4

func (Mask32x4) String added in go1.27.0 

func (x Mask32x4) String() string

String returns a string representation of SIMD mask x.

func (Mask32x4) ToBits 

func (x Mask32x4) ToBits() uint8

ToBits constructs a bitmap from a Mask32x4, where 1 means set for the indexed element, 0 means unset. Only the lower 4 bits of y are used.

Asm: VMOVMSKPS, CPU Features: AVX

func (Mask32x4) ToInt32x4 

func (from Mask32x4) ToInt32x4() (to Int32x4)

ToInt32x4 converts from Mask32x4 to Int32x4. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask32x8 

type Mask32x8 struct {
	// contains filtered or unexported fields
}

Mask32x8 is a mask for a SIMD vector of 8 32-bit elements.

func Mask32x8FromBits 

func Mask32x8FromBits(y uint8) Mask32x8

Mask32x8FromBits constructs a Mask32x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVD, CPU Feature: AVX512

func (Mask32x8) And 

func (x Mask32x8) And(y Mask32x8) Mask32x8

func (Mask32x8) Or 

func (x Mask32x8) Or(y Mask32x8) Mask32x8

func (Mask32x8) String added in go1.27.0 

func (x Mask32x8) String() string

String returns a string representation of SIMD mask x.

func (Mask32x8) ToBits 

func (x Mask32x8) ToBits() uint8

ToBits constructs a bitmap from a Mask32x8, where 1 means set for the indexed element, 0 means unset.

Asm: VMOVMSKPS, CPU Features: AVX

func (Mask32x8) ToInt32x8 

func (from Mask32x8) ToInt32x8() (to Int32x8)

ToInt32x8 converts from Mask32x8 to Int32x8. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask32x16 

type Mask32x16 struct {
	// contains filtered or unexported fields
}

Mask32x16 is a mask for a SIMD vector of 16 32-bit elements.

func Mask32x16FromBits 

func Mask32x16FromBits(y uint16) Mask32x16

Mask32x16FromBits constructs a Mask32x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVD, CPU Feature: AVX512

func (Mask32x16) And 

func (x Mask32x16) And(y Mask32x16) Mask32x16

func (Mask32x16) Or 

func (x Mask32x16) Or(y Mask32x16) Mask32x16

func (Mask32x16) String added in go1.27.0 

func (x Mask32x16) String() string

String returns a string representation of SIMD mask x.

func (Mask32x16) ToBits 

func (x Mask32x16) ToBits() uint16

ToBits constructs a bitmap from a Mask32x16, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVD, CPU Features: AVX512

func (Mask32x16) ToInt32x16 

func (from Mask32x16) ToInt32x16() (to Int32x16)

ToInt32x16 converts from Mask32x16 to Int32x16. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask64x2 

type Mask64x2 struct {
	// contains filtered or unexported fields
}

Mask64x2 is a mask for a SIMD vector of 2 64-bit elements.

func Mask64x2FromBits 

func Mask64x2FromBits(y uint8) Mask64x2

Mask64x2FromBits constructs a Mask64x2 from a bitmap value, where 1 means set for the indexed element, 0 means unset. Only the lower 2 bits of y are used.

Asm: KMOVQ, CPU Feature: AVX512

func (Mask64x2) And 

func (x Mask64x2) And(y Mask64x2) Mask64x2

func (Mask64x2) Or 

func (x Mask64x2) Or(y Mask64x2) Mask64x2

func (Mask64x2) String added in go1.27.0 

func (x Mask64x2) String() string

String returns a string representation of SIMD mask x.

func (Mask64x2) ToBits 

func (x Mask64x2) ToBits() uint8

ToBits constructs a bitmap from a Mask64x2, where 1 means set for the indexed element, 0 means unset. Only the lower 2 bits of y are used.

Asm: VMOVMSKPD, CPU Features: AVX

func (Mask64x2) ToInt64x2 

func (from Mask64x2) ToInt64x2() (to Int64x2)

ToInt64x2 converts from Mask64x2 to Int64x2. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask64x4 

type Mask64x4 struct {
	// contains filtered or unexported fields
}

Mask64x4 is a mask for a SIMD vector of 4 64-bit elements.

func Mask64x4FromBits 

func Mask64x4FromBits(y uint8) Mask64x4

Mask64x4FromBits constructs a Mask64x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset. Only the lower 4 bits of y are used.

Asm: KMOVQ, CPU Feature: AVX512

func (Mask64x4) And 

func (x Mask64x4) And(y Mask64x4) Mask64x4

func (Mask64x4) Or 

func (x Mask64x4) Or(y Mask64x4) Mask64x4

func (Mask64x4) String added in go1.27.0 

func (x Mask64x4) String() string

String returns a string representation of SIMD mask x.

func (Mask64x4) ToBits 

func (x Mask64x4) ToBits() uint8

ToBits constructs a bitmap from a Mask64x4, where 1 means set for the indexed element, 0 means unset. Only the lower 4 bits of y are used.

Asm: VMOVMSKPD, CPU Features: AVX

func (Mask64x4) ToInt64x4 

func (from Mask64x4) ToInt64x4() (to Int64x4)

ToInt64x4 converts from Mask64x4 to Int64x4. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Mask64x8 

type Mask64x8 struct {
	// contains filtered or unexported fields
}

Mask64x8 is a mask for a SIMD vector of 8 64-bit elements.

func Mask64x8FromBits 

func Mask64x8FromBits(y uint8) Mask64x8

Mask64x8FromBits constructs a Mask64x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVQ, CPU Feature: AVX512

func (Mask64x8) And 

func (x Mask64x8) And(y Mask64x8) Mask64x8

func (Mask64x8) Or 

func (x Mask64x8) Or(y Mask64x8) Mask64x8

func (Mask64x8) String added in go1.27.0 

func (x Mask64x8) String() string

String returns a string representation of SIMD mask x.

func (Mask64x8) ToBits 

func (x Mask64x8) ToBits() uint8

ToBits constructs a bitmap from a Mask64x8, where 1 means set for the indexed element, 0 means unset.

Asm: KMOVQ, CPU Features: AVX512

func (Mask64x8) ToInt64x8 

func (from Mask64x8) ToInt64x8() (to Int64x8)

ToInt64x8 converts from Mask64x8 to Int64x8. If element i in the mask is "true", all bits in element i of the resulting vector will be set.

type Uint8x16 

type Uint8x16 struct {
	// contains filtered or unexported fields
}

Uint8x16 is a 128-bit SIMD vector of 16 uint8s.

func BroadcastUint8x16 

func BroadcastUint8x16(x uint8) Uint8x16

BroadcastUint8x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint8x16 

func LoadUint8x16(s []uint8) Uint8x16

LoadUint8x16 loads an Uint8x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadUint8x16Array added in go1.27.0 

func LoadUint8x16Array(y *[16]uint8) Uint8x16

LoadUint8x16Array loads a Uint8x16 from an array.

func LoadUint8x16Part added in go1.27.0 

func LoadUint8x16Part(s []uint8) (Uint8x16, int)

LoadUint8x16Part loads a Uint8x16 from the slice s. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadInt8x16.

func (Uint8x16) AESDecryptLastRound 

func (x Uint8x16) AESDecryptLastRound(y Uint32x4) Uint8x16

AESDecryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvShiftRows(InvSubBytes(x)), y)

Asm: VAESDECLAST, CPU Feature: AVXAES

func (Uint8x16) AESDecryptOneRound 

func (x Uint8x16) AESDecryptOneRound(y Uint32x4) Uint8x16

AESDecryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvMixColumns(InvShiftRows(InvSubBytes(x))), y)

Asm: VAESDEC, CPU Feature: AVXAES

func (Uint8x16) AESEncryptLastRound 

func (x Uint8x16) AESEncryptLastRound(y Uint32x4) Uint8x16

AESEncryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey((ShiftRows(SubBytes(x))), y)

Asm: VAESENCLAST, CPU Feature: AVXAES

func (Uint8x16) AESEncryptOneRound 

func (x Uint8x16) AESEncryptOneRound(y Uint32x4) Uint8x16

AESEncryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey(MixColumns(ShiftRows(SubBytes(x))), y)

Asm: VAESENC, CPU Feature: AVXAES

func (Uint8x16) Add 

func (x Uint8x16) Add(y Uint8x16) Uint8x16

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX

func (Uint8x16) AddSaturated 

func (x Uint8x16) AddSaturated(y Uint8x16) Uint8x16

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSB, CPU Feature: AVX

func (Uint8x16) And 

func (x Uint8x16) And(y Uint8x16) Uint8x16

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Uint8x16) AndNot 

func (x Uint8x16) AndNot(y Uint8x16) Uint8x16

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Uint8x16) AsFloat32x4 deprecated 

func (x Uint8x16) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Uint8x16 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsFloat64x2 deprecated 

func (x Uint8x16) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Uint8x16 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsInt8x16 deprecated 

func (x Uint8x16) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Uint8x16 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsInt16x8 deprecated 

func (x Uint8x16) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Uint8x16 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsInt32x4 deprecated 

func (x Uint8x16) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Uint8x16 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsInt64x2 deprecated 

func (x Uint8x16) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Uint8x16 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsUint16x8 deprecated 

func (x Uint8x16) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Uint8x16 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsUint32x4 deprecated 

func (x Uint8x16) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Uint8x16 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) AsUint64x2 deprecated 

func (x Uint8x16) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Uint8x16 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x16) Average 

func (x Uint8x16) Average(y Uint8x16) Uint8x16

Average computes the rounded average of corresponding elements.

Asm: VPAVGB, CPU Feature: AVX

func (Uint8x16) BitsToInt8 added in go1.27.0 

func (x Uint8x16) BitsToInt8() Int8x16

BitsToInt8 reinterprets the bits of a Uint8x16 vector as a Int8x16 vector

func (Uint8x16) Compress 

func (x Uint8x16) Compress(mask Mask8x16) Uint8x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Uint8x16) ConcatPermute 

func (x Uint8x16) ConcatPermute(y Uint8x16, indices Uint8x16) Uint8x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Uint8x16) ConcatShiftBytesRight 

func (x Uint8x16) ConcatShiftBytesRight(y Uint8x16, shift uint64) Uint8x16

ConcatShiftBytesRight concatenates x and y and shifts it right by shift bytes. The result vector will be the lower half of the concatenated vector.

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPALIGNR, CPU Feature: AVX

func (Uint8x16) ConvertToInt8 added in go1.27.0 

func (x Uint8x16) ConvertToInt8() Int8x16

ConvertToInt8 converts a Uint8x16 vector to a Int8x16 vector

func (Uint8x16) DotProductPairsSaturated 

func (x Uint8x16) DotProductPairsSaturated(y Int8x16) Int16x8

DotProductPairsSaturated multiplies the elements and add the pairs together with saturation, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDUBSW, CPU Feature: AVX

func (Uint8x16) Equal 

func (x Uint8x16) Equal(y Uint8x16) Mask8x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX

func (Uint8x16) Expand 

func (x Uint8x16) Expand(mask Mask8x16) Uint8x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Uint8x16) ExtendLo2ToUint64 

func (x Uint8x16) ExtendLo2ToUint64() Uint64x2

ExtendLo2ToUint64 zero-extends 2 lowest vector element values to uint64.

Asm: VPMOVZXBQ, CPU Feature: AVX

func (Uint8x16) ExtendLo4ToUint32 

func (x Uint8x16) ExtendLo4ToUint32() Uint32x4

ExtendLo4ToUint32 zero-extends 4 lowest vector element values to uint32.

Asm: VPMOVZXBD, CPU Feature: AVX

func (Uint8x16) ExtendLo4ToUint64 

func (x Uint8x16) ExtendLo4ToUint64() Uint64x4

ExtendLo4ToUint64 zero-extends 4 lowest vector element values to uint64.

Asm: VPMOVZXBQ, CPU Feature: AVX2

func (Uint8x16) ExtendLo8ToUint16 

func (x Uint8x16) ExtendLo8ToUint16() Uint16x8

ExtendLo8ToUint16 zero-extends 8 lowest vector element values to uint16.

Asm: VPMOVZXBW, CPU Feature: AVX

func (Uint8x16) ExtendLo8ToUint32 

func (x Uint8x16) ExtendLo8ToUint32() Uint32x8

ExtendLo8ToUint32 zero-extends 8 lowest vector element values to uint32.

Asm: VPMOVZXBD, CPU Feature: AVX2

func (Uint8x16) ExtendLo8ToUint64 

func (x Uint8x16) ExtendLo8ToUint64() Uint64x8

ExtendLo8ToUint64 zero-extends 8 lowest vector element values to uint64.

Asm: VPMOVZXBQ, CPU Feature: AVX512

func (Uint8x16) ExtendToUint16 

func (x Uint8x16) ExtendToUint16() Uint16x16

ExtendToUint16 zero-extends element values to uint16.

Asm: VPMOVZXBW, CPU Feature: AVX2

func (Uint8x16) ExtendToUint32 

func (x Uint8x16) ExtendToUint32() Uint32x16

ExtendToUint32 zero-extends element values to uint32.

Asm: VPMOVZXBD, CPU Feature: AVX512

func (Uint8x16) GaloisFieldAffineTransform 

func (x Uint8x16) GaloisFieldAffineTransform(A Uint64x2, b uint8) Uint8x16

GaloisFieldAffineTransform returns the affine transformation A * x + b in GF(2^8). Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * x[i] + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEQB, CPU Feature: AVX512GFNI

func (Uint8x16) GaloisFieldAffineTransformInverse 

func (x Uint8x16) GaloisFieldAffineTransformInverse(A Uint64x2, b uint8) Uint8x16

GaloisFieldAffineTransformInverse returns the affine transformation A * (x⁻¹ mod P) + b in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1. Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * inv(x[i]) + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEINVQB, CPU Feature: AVX512GFNI

func (Uint8x16) GaloisFieldMul 

func (x Uint8x16) GaloisFieldMul(y Uint8x16) Uint8x16

GaloisFieldMul returns (x * y) mod P, performed in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1.

Asm: VGF2P8MULB, CPU Feature: AVX512GFNI

func (Uint8x16) GetElem 

func (x Uint8x16) GetElem(index uint8) uint8

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRB, CPU Feature: AVX

func (Uint8x16) Greater 

func (x Uint8x16) Greater(y Uint8x16) Mask8x16

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX2

func (Uint8x16) GreaterEqual 

func (x Uint8x16) GreaterEqual(y Uint8x16) Mask8x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Uint8x16) IfElse added in go1.27.0 

func (x Uint8x16) IfElse(mask Mask8x16, y Uint8x16) Uint8x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Uint8x16) IsZero 

func (x Uint8x16) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint8x16) Len 

func (x Uint8x16) Len() int

Len returns the number of elements in a Uint8x16.

func (Uint8x16) Less 

func (x Uint8x16) Less(y Uint8x16) Mask8x16

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Uint8x16) LessEqual 

func (x Uint8x16) LessEqual(y Uint8x16) Mask8x16

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Uint8x16) Masked 

func (x Uint8x16) Masked(mask Mask8x16) Uint8x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Uint8x16) Max 

func (x Uint8x16) Max(y Uint8x16) Uint8x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUB, CPU Feature: AVX

func (Uint8x16) Merge deprecated 

func (x Uint8x16) Merge(y Uint8x16, mask Mask8x16) Uint8x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Uint8x16) Min 

func (x Uint8x16) Min(y Uint8x16) Uint8x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUB, CPU Feature: AVX

func (Uint8x16) Mul added in go1.27.0 

func (x Uint8x16) Mul(y Uint8x16) Uint8x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX

func (Uint8x16) Not 

func (x Uint8x16) Not() Uint8x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Uint8x16) NotEqual 

func (x Uint8x16) NotEqual(y Uint8x16) Mask8x16

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Uint8x16) OnesCount 

func (x Uint8x16) OnesCount() Uint8x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Uint8x16) Or 

func (x Uint8x16) Or(y Uint8x16) Uint8x16

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Uint8x16) Permute 

func (x Uint8x16) Permute(indices Uint8x16) Uint8x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Uint8x16) PermuteOrZero 

func (x Uint8x16) PermuteOrZero(indices Int8x16) Uint8x16

PermuteOrZero permutes x. If an index is negative, the result is 0. 

if indices[i] >= 0 {
    z[i] = x[indices[i] % len(x)]
} else {
    z[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX

func (Uint8x16) ReshapeToUint16s added in go1.27.0 

func (x Uint8x16) ReshapeToUint16s() Uint16x8

ReshapeToUint16s reinterprets the bits of a Uint8x16 vector as a Uint16x8 vector

func (Uint8x16) ReshapeToUint32s added in go1.27.0 

func (x Uint8x16) ReshapeToUint32s() Uint32x4

ReshapeToUint32s reinterprets the bits of a Uint8x16 vector as a Uint32x4 vector

func (Uint8x16) ReshapeToUint64s added in go1.27.0 

func (x Uint8x16) ReshapeToUint64s() Uint64x2

ReshapeToUint64s reinterprets the bits of a Uint8x16 vector as a Uint64x2 vector

func (Uint8x16) SetElem 

func (x Uint8x16) SetElem(index uint8, y uint8) Uint8x16

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRB, CPU Feature: AVX

func (Uint8x16) Store 

func (x Uint8x16) Store(s []uint8)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Uint8x16) StoreArray added in go1.27.0 

func (x Uint8x16) StoreArray(y *[16]uint8)

StoreArray stores a Uint8x16 to an array.

func (Uint8x16) StorePart added in go1.27.0 

func (x Uint8x16) StorePart(s []uint8) int

StorePart stores the elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Uint8x16) String 

func (x Uint8x16) String() string

String returns a string representation of SIMD vector x.

func (Uint8x16) Sub 

func (x Uint8x16) Sub(y Uint8x16) Uint8x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX

func (Uint8x16) SubSaturated 

func (x Uint8x16) SubSaturated(y Uint8x16) Uint8x16

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSB, CPU Feature: AVX

func (Uint8x16) SumOf8AbsDiff added in go1.27.0 

func (x Uint8x16) SumOf8AbsDiff(y Uint8x16) Uint64x2

SumOf8AbsDiff computes the absolute difference of x and y and sums each group of 8 results. This method could be seen as the norm of the L1 distance of each 8-element group of the two input vectors.

Asm: VPSADBW, CPU Feature: AVX

func (Uint8x16) Xor 

func (x Uint8x16) Xor(y Uint8x16) Uint8x16

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Uint8x32 

type Uint8x32 struct {
	// contains filtered or unexported fields
}

Uint8x32 is a 256-bit SIMD vector of 32 uint8s.

func BroadcastUint8x32 

func BroadcastUint8x32(x uint8) Uint8x32

BroadcastUint8x32 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint8x32 

func LoadUint8x32(s []uint8) Uint8x32

LoadUint8x32 loads an Uint8x32 from a slice of elements. If s does not have at least 32 elements, it panics.

func LoadUint8x32Array added in go1.27.0 

func LoadUint8x32Array(y *[32]uint8) Uint8x32

LoadUint8x32Array loads a Uint8x32 from an array.

func LoadUint8x32Part added in go1.27.0 

func LoadUint8x32Part(s []uint8) (Uint8x32, int)

LoadUint8x32Part loads a Uint8x32 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes. If s has 32 or more elements, the function is equivalent to LoadUint8x32.

func (Uint8x32) AESDecryptLastRound 

func (x Uint8x32) AESDecryptLastRound(y Uint32x8) Uint8x32

AESDecryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvShiftRows(InvSubBytes(x)), y)

Asm: VAESDECLAST, CPU Feature: VAES

func (Uint8x32) AESDecryptOneRound 

func (x Uint8x32) AESDecryptOneRound(y Uint32x8) Uint8x32

AESDecryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvMixColumns(InvShiftRows(InvSubBytes(x))), y)

Asm: VAESDEC, CPU Feature: VAES

func (Uint8x32) AESEncryptLastRound 

func (x Uint8x32) AESEncryptLastRound(y Uint32x8) Uint8x32

AESEncryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey((ShiftRows(SubBytes(x))), y)

Asm: VAESENCLAST, CPU Feature: VAES

func (Uint8x32) AESEncryptOneRound 

func (x Uint8x32) AESEncryptOneRound(y Uint32x8) Uint8x32

AESEncryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey(MixColumns(ShiftRows(SubBytes(x))), y)

Asm: VAESENC, CPU Feature: VAES

func (Uint8x32) Add 

func (x Uint8x32) Add(y Uint8x32) Uint8x32

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX2

func (Uint8x32) AddSaturated 

func (x Uint8x32) AddSaturated(y Uint8x32) Uint8x32

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSB, CPU Feature: AVX2

func (Uint8x32) And 

func (x Uint8x32) And(y Uint8x32) Uint8x32

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Uint8x32) AndNot 

func (x Uint8x32) AndNot(y Uint8x32) Uint8x32

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Uint8x32) AsFloat32x8 deprecated 

func (x Uint8x32) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Uint8x32 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsFloat64x4 deprecated 

func (x Uint8x32) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Uint8x32 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsInt8x32 deprecated 

func (x Uint8x32) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Uint8x32 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsInt16x16 deprecated 

func (x Uint8x32) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Uint8x32 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsInt32x8 deprecated 

func (x Uint8x32) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Uint8x32 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsInt64x4 deprecated 

func (x Uint8x32) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Uint8x32 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsUint16x16 deprecated 

func (x Uint8x32) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Uint8x32 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsUint32x8 deprecated 

func (x Uint8x32) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Uint8x32 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) AsUint64x4 deprecated 

func (x Uint8x32) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Uint8x32 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x32) Average 

func (x Uint8x32) Average(y Uint8x32) Uint8x32

Average computes the rounded average of corresponding elements.

Asm: VPAVGB, CPU Feature: AVX2

func (Uint8x32) BitsToInt8 added in go1.27.0 

func (x Uint8x32) BitsToInt8() Int8x32

BitsToInt8 reinterprets the bits of a Uint8x32 vector as a Int8x32 vector

func (Uint8x32) Compress 

func (x Uint8x32) Compress(mask Mask8x32) Uint8x32

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Uint8x32) ConcatPermute 

func (x Uint8x32) ConcatPermute(y Uint8x32, indices Uint8x32) Uint8x32

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Uint8x32) ConcatPermute128Scalars added in go1.27.0 

func (x Uint8x32) ConcatPermute128Scalars(lo, hi uint8, y Uint8x32) Uint8x32

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{0x40, 0x41, ..., 0x4f, 0x50, 0x51, ..., 0x5f}.ConcatPermute128Scalars(3, 0,
     {0x60, 0x61, ..., 0x6f, 0x70, 0x71, ..., 0x7f})

returns {0x70, 0x71, ..., 0x7f, 0x40, 0x41, ..., 0x4f}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Uint8x32) ConcatShiftBytesRightGrouped 

func (x Uint8x32) ConcatShiftBytesRightGrouped(y Uint8x32, shift uint64) Uint8x32

ConcatShiftBytesRightGrouped concatenates x and y and shifts it right by shift bytes. The result vector will be the lower half of the concatenated vector. This operation is performed grouped by each 16 byte.

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPALIGNR, CPU Feature: AVX2

func (Uint8x32) ConvertToInt8 added in go1.27.0 

func (x Uint8x32) ConvertToInt8() Int8x32

ConvertToInt8 converts a Uint8x32 vector to a Int8x32 vector

func (Uint8x32) DotProductPairsSaturated 

func (x Uint8x32) DotProductPairsSaturated(y Int8x32) Int16x16

DotProductPairsSaturated multiplies the elements and add the pairs together with saturation, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDUBSW, CPU Feature: AVX2

func (Uint8x32) Equal 

func (x Uint8x32) Equal(y Uint8x32) Mask8x32

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX2

func (Uint8x32) Expand 

func (x Uint8x32) Expand(mask Mask8x32) Uint8x32

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Uint8x32) ExtendToUint16 

func (x Uint8x32) ExtendToUint16() Uint16x32

ExtendToUint16 zero-extends element values to uint16.

Asm: VPMOVZXBW, CPU Feature: AVX512

func (Uint8x32) GaloisFieldAffineTransform 

func (x Uint8x32) GaloisFieldAffineTransform(A Uint64x4, b uint8) Uint8x32

GaloisFieldAffineTransform returns the affine transformation A * x + b in GF(2^8). Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * x[i] + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEQB, CPU Feature: AVX512GFNI

func (Uint8x32) GaloisFieldAffineTransformInverse 

func (x Uint8x32) GaloisFieldAffineTransformInverse(A Uint64x4, b uint8) Uint8x32

GaloisFieldAffineTransformInverse returns the affine transformation A * (x⁻¹ mod P) + b in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1. Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * inv(x[i]) + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEINVQB, CPU Feature: AVX512GFNI

func (Uint8x32) GaloisFieldMul 

func (x Uint8x32) GaloisFieldMul(y Uint8x32) Uint8x32

GaloisFieldMul returns (x * y) mod P, performed in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1.

Asm: VGF2P8MULB, CPU Feature: AVX512GFNI

func (Uint8x32) GetHi 

func (x Uint8x32) GetHi() Uint8x16

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint8x32) GetLo 

func (x Uint8x32) GetLo() Uint8x16

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint8x32) Greater 

func (x Uint8x32) Greater(y Uint8x32) Mask8x32

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX2

func (Uint8x32) GreaterEqual 

func (x Uint8x32) GreaterEqual(y Uint8x32) Mask8x32

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Uint8x32) IfElse added in go1.27.0 

func (x Uint8x32) IfElse(mask Mask8x32, y Uint8x32) Uint8x32

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Uint8x32) IsZero 

func (x Uint8x32) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint8x32) Len 

func (x Uint8x32) Len() int

Len returns the number of elements in a Uint8x32.

func (Uint8x32) Less 

func (x Uint8x32) Less(y Uint8x32) Mask8x32

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Uint8x32) LessEqual 

func (x Uint8x32) LessEqual(y Uint8x32) Mask8x32

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Uint8x32) Masked 

func (x Uint8x32) Masked(mask Mask8x32) Uint8x32

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Uint8x32) Max 

func (x Uint8x32) Max(y Uint8x32) Uint8x32

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUB, CPU Feature: AVX2

func (Uint8x32) Merge deprecated 

func (x Uint8x32) Merge(y Uint8x32, mask Mask8x32) Uint8x32

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Uint8x32) Min 

func (x Uint8x32) Min(y Uint8x32) Uint8x32

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUB, CPU Feature: AVX2

func (Uint8x32) Mul added in go1.27.0 

func (x Uint8x32) Mul(y Uint8x32) Uint8x32

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX2

func (Uint8x32) Not 

func (x Uint8x32) Not() Uint8x32

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Uint8x32) NotEqual 

func (x Uint8x32) NotEqual(y Uint8x32) Mask8x32

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Uint8x32) OnesCount 

func (x Uint8x32) OnesCount() Uint8x32

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Uint8x32) Or 

func (x Uint8x32) Or(y Uint8x32) Uint8x32

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Uint8x32) Permute 

func (x Uint8x32) Permute(indices Uint8x32) Uint8x32

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Uint8x32) PermuteOrZeroGrouped 

func (x Uint8x32) PermuteOrZeroGrouped(indices Int8x32) Uint8x32

PermuteOrZeroGrouped permutes x within each 128-bit group. If an index is negative, the result is 0. 

let vₙ be the n'th 128-bit group of vector v
if indicesₙ[i] >= 0 {
    zₙ[i] = xₙ[indicesₙ[i] % len(xₙ)]
} else {
    zₙ[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX2

func (Uint8x32) ReshapeToUint16s added in go1.27.0 

func (x Uint8x32) ReshapeToUint16s() Uint16x16

ReshapeToUint16s reinterprets the bits of a Uint8x32 vector as a Uint16x16 vector

func (Uint8x32) ReshapeToUint32s added in go1.27.0 

func (x Uint8x32) ReshapeToUint32s() Uint32x8

ReshapeToUint32s reinterprets the bits of a Uint8x32 vector as a Uint32x8 vector

func (Uint8x32) ReshapeToUint64s added in go1.27.0 

func (x Uint8x32) ReshapeToUint64s() Uint64x4

ReshapeToUint64s reinterprets the bits of a Uint8x32 vector as a Uint64x4 vector

func (Uint8x32) SetHi 

func (x Uint8x32) SetHi(y Uint8x16) Uint8x32

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint8x32) SetLo 

func (x Uint8x32) SetLo(y Uint8x16) Uint8x32

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint8x32) Store 

func (x Uint8x32) Store(s []uint8)

Store stores the elements of x into a slice. If s does not have at least 32 elements, it panics.

func (Uint8x32) StoreArray added in go1.27.0 

func (x Uint8x32) StoreArray(y *[32]uint8)

StoreArray stores a Uint8x32 to an array.

func (Uint8x32) StorePart added in go1.27.0 

func (x Uint8x32) StorePart(s []uint8) int

StorePart stores the 32 elements of x into the slice s. It stores as many elements as will fit in s. If s has 32 or more elements, the method is equivalent to x.Store.

func (Uint8x32) String 

func (x Uint8x32) String() string

String returns a string representation of SIMD vector x.

func (Uint8x32) Sub 

func (x Uint8x32) Sub(y Uint8x32) Uint8x32

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX2

func (Uint8x32) SubSaturated 

func (x Uint8x32) SubSaturated(y Uint8x32) Uint8x32

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSB, CPU Feature: AVX2

func (Uint8x32) SumOf8AbsDiff added in go1.27.0 

func (x Uint8x32) SumOf8AbsDiff(y Uint8x32) Uint64x4

SumOf8AbsDiff computes the absolute difference of x and y and sums each group of 8 results. This method could be seen as the norm of the L1 distance of each 8-element group of the two input vectors.

Asm: VPSADBW, CPU Feature: AVX2

func (Uint8x32) Xor 

func (x Uint8x32) Xor(y Uint8x32) Uint8x32

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Uint8x64 

type Uint8x64 struct {
	// contains filtered or unexported fields
}

Uint8x64 is a 512-bit SIMD vector of 64 uint8s.

func BroadcastUint8x64 

func BroadcastUint8x64(x uint8) Uint8x64

BroadcastUint8x64 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512BW

func LoadUint8x64 

func LoadUint8x64(s []uint8) Uint8x64

LoadUint8x64 loads an Uint8x64 from a slice of elements. If s does not have at least 64 elements, it panics.

func LoadUint8x64Array added in go1.27.0 

func LoadUint8x64Array(y *[64]uint8) Uint8x64

LoadUint8x64Array loads a Uint8x64 from an array.

func LoadUint8x64Part added in go1.27.0 

func LoadUint8x64Part(s []uint8) (Uint8x64, int)

LoadUint8x64Part loads a Uint8x64 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 64 elements, the remaining elements of the vector are filled with zeroes. If s has 64 or more elements, the function is equivalent to LoadUint8x64.

func (Uint8x64) AESDecryptLastRound 

func (x Uint8x64) AESDecryptLastRound(y Uint32x16) Uint8x64

AESDecryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvShiftRows(InvSubBytes(x)), y)

Asm: VAESDECLAST, CPU Feature: AVX512VAES

func (Uint8x64) AESDecryptOneRound 

func (x Uint8x64) AESDecryptOneRound(y Uint32x16) Uint8x64

AESDecryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of dw array in use. result = AddRoundKey(InvMixColumns(InvShiftRows(InvSubBytes(x))), y)

Asm: VAESDEC, CPU Feature: AVX512VAES

func (Uint8x64) AESEncryptLastRound 

func (x Uint8x64) AESEncryptLastRound(y Uint32x16) Uint8x64

AESEncryptLastRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey((ShiftRows(SubBytes(x))), y)

Asm: VAESENCLAST, CPU Feature: AVX512VAES

func (Uint8x64) AESEncryptOneRound 

func (x Uint8x64) AESEncryptOneRound(y Uint32x16) Uint8x64

AESEncryptOneRound performs a series of operations in AES cipher algorithm defined in FIPS 197. x is the state array, starting from low index to high are s00, s10, s20, s30, s01, ..., s33. y is the chunk of w array in use. result = AddRoundKey(MixColumns(ShiftRows(SubBytes(x))), y)

Asm: VAESENC, CPU Feature: AVX512VAES

func (Uint8x64) Add 

func (x Uint8x64) Add(y Uint8x64) Uint8x64

Add adds corresponding elements of two vectors.

Asm: VPADDB, CPU Feature: AVX512

func (Uint8x64) AddSaturated 

func (x Uint8x64) AddSaturated(y Uint8x64) Uint8x64

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSB, CPU Feature: AVX512

func (Uint8x64) And 

func (x Uint8x64) And(y Uint8x64) Uint8x64

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Uint8x64) AndNot 

func (x Uint8x64) AndNot(y Uint8x64) Uint8x64

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Uint8x64) AsFloat32x16 deprecated 

func (x Uint8x64) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Uint8x64 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsFloat64x8 deprecated 

func (x Uint8x64) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Uint8x64 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsInt8x64 deprecated 

func (x Uint8x64) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Uint8x64 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsInt16x32 deprecated 

func (x Uint8x64) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Uint8x64 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsInt32x16 deprecated 

func (x Uint8x64) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Uint8x64 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsInt64x8 deprecated 

func (x Uint8x64) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Uint8x64 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsUint16x32 deprecated 

func (x Uint8x64) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Uint8x64 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsUint32x16 deprecated 

func (x Uint8x64) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Uint8x64 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) AsUint64x8 deprecated 

func (x Uint8x64) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Uint8x64 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint8x64) Average 

func (x Uint8x64) Average(y Uint8x64) Uint8x64

Average computes the rounded average of corresponding elements.

Asm: VPAVGB, CPU Feature: AVX512

func (Uint8x64) BitsToInt8 added in go1.27.0 

func (x Uint8x64) BitsToInt8() Int8x64

BitsToInt8 reinterprets the bits of a Uint8x64 vector as a Int8x64 vector

func (Uint8x64) Compress 

func (x Uint8x64) Compress(mask Mask8x64) Uint8x64

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSB, CPU Feature: AVX512VBMI2

func (Uint8x64) ConcatPermute 

func (x Uint8x64) ConcatPermute(y Uint8x64, indices Uint8x64) Uint8x64

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2B, CPU Feature: AVX512VBMI

func (Uint8x64) ConcatShiftBytesRightGrouped 

func (x Uint8x64) ConcatShiftBytesRightGrouped(y Uint8x64, shift uint64) Uint8x64

ConcatShiftBytesRightGrouped concatenates x and y and shifts it right by shift bytes. The result vector will be the lower half of the concatenated vector. This operation is performed grouped by each 16 byte.

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPALIGNR, CPU Feature: AVX512

func (Uint8x64) ConvertToInt8 added in go1.27.0 

func (x Uint8x64) ConvertToInt8() Int8x64

ConvertToInt8 converts a Uint8x64 vector to a Int8x64 vector

func (Uint8x64) DotProductPairsSaturated 

func (x Uint8x64) DotProductPairsSaturated(y Int8x64) Int16x32

DotProductPairsSaturated multiplies the elements and add the pairs together with saturation, yielding a vector of half as many elements with twice the input element size.

Asm: VPMADDUBSW, CPU Feature: AVX512

func (Uint8x64) Equal 

func (x Uint8x64) Equal(y Uint8x64) Mask8x64

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQB, CPU Feature: AVX512

func (Uint8x64) Expand 

func (x Uint8x64) Expand(mask Mask8x64) Uint8x64

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDB, CPU Feature: AVX512VBMI2

func (Uint8x64) GaloisFieldAffineTransform 

func (x Uint8x64) GaloisFieldAffineTransform(A Uint64x8, b uint8) Uint8x64

GaloisFieldAffineTransform returns the affine transformation A * x + b in GF(2^8). Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * x[i] + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEQB, CPU Feature: AVX512GFNI

func (Uint8x64) GaloisFieldAffineTransformInverse 

func (x Uint8x64) GaloisFieldAffineTransformInverse(A Uint64x8, b uint8) Uint8x64

GaloisFieldAffineTransformInverse returns the affine transformation A * (x⁻¹ mod P) + b in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1. Each element of A is interpreted as an 8x8 matrix of bits. Each element of x is interpreted as an 8-element vector of bits. The b argument is likewise an 8-element vector of bits. The result is z[i] = A[i/8] * inv(x[i]) + b, where * and + are performed in GF2.

A non-constant value of b may result in significantly worse performance for this operation.

Asm: VGF2P8AFFINEINVQB, CPU Feature: AVX512GFNI

func (Uint8x64) GaloisFieldMul 

func (x Uint8x64) GaloisFieldMul(y Uint8x64) Uint8x64

GaloisFieldMul returns (x * y) mod P, performed in GF(2^8), where the characteristic polynomial P is x^8 + x^4 + x^3 + x + 1.

Asm: VGF2P8MULB, CPU Feature: AVX512GFNI

func (Uint8x64) GetHi 

func (x Uint8x64) GetHi() Uint8x32

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint8x64) GetLo 

func (x Uint8x64) GetLo() Uint8x32

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint8x64) Greater 

func (x Uint8x64) Greater(y Uint8x64) Mask8x64

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPUB, CPU Feature: AVX512

func (Uint8x64) GreaterEqual 

func (x Uint8x64) GreaterEqual(y Uint8x64) Mask8x64

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPUB, CPU Feature: AVX512

func (Uint8x64) IfElse added in go1.27.0 

func (x Uint8x64) IfElse(mask Mask8x64, y Uint8x64) Uint8x64

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Uint8x64) Len 

func (x Uint8x64) Len() int

Len returns the number of elements in a Uint8x64.

func (Uint8x64) Less 

func (x Uint8x64) Less(y Uint8x64) Mask8x64

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPUB, CPU Feature: AVX512

func (Uint8x64) LessEqual 

func (x Uint8x64) LessEqual(y Uint8x64) Mask8x64

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPUB, CPU Feature: AVX512

func (Uint8x64) Masked 

func (x Uint8x64) Masked(mask Mask8x64) Uint8x64

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Uint8x64) Max 

func (x Uint8x64) Max(y Uint8x64) Uint8x64

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUB, CPU Feature: AVX512

func (Uint8x64) Merge deprecated 

func (x Uint8x64) Merge(y Uint8x64, mask Mask8x64) Uint8x64

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Uint8x64) Min 

func (x Uint8x64) Min(y Uint8x64) Uint8x64

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUB, CPU Feature: AVX512

func (Uint8x64) Mul added in go1.27.0 

func (x Uint8x64) Mul(y Uint8x64) Uint8x64

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Emulated, CPU Feature: AVX512

func (Uint8x64) Not 

func (x Uint8x64) Not() Uint8x64

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Uint8x64) NotEqual 

func (x Uint8x64) NotEqual(y Uint8x64) Mask8x64

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPUB, CPU Feature: AVX512

func (Uint8x64) OnesCount 

func (x Uint8x64) OnesCount() Uint8x64

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTB, CPU Feature: AVX512BITALG

func (Uint8x64) Or 

func (x Uint8x64) Or(y Uint8x64) Uint8x64

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Uint8x64) Permute 

func (x Uint8x64) Permute(indices Uint8x64) Uint8x64

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMB, CPU Feature: AVX512VBMI

func (Uint8x64) PermuteOrZeroGrouped 

func (x Uint8x64) PermuteOrZeroGrouped(indices Int8x64) Uint8x64

PermuteOrZeroGrouped permutes x within each 128-bit group. If an index is negative, the result is 0. 

let vₙ be the n'th 128-bit group of vector v
if indicesₙ[i] >= 0 {
    zₙ[i] = xₙ[indicesₙ[i] % len(xₙ)]
} else {
    zₙ[i] = 0
}

Asm: VPSHUFB, CPU Feature: AVX512

func (Uint8x64) ReshapeToUint16s added in go1.27.0 

func (x Uint8x64) ReshapeToUint16s() Uint16x32

ReshapeToUint16s reinterprets the bits of a Uint8x64 vector as a Uint16x32 vector

func (Uint8x64) ReshapeToUint32s added in go1.27.0 

func (x Uint8x64) ReshapeToUint32s() Uint32x16

ReshapeToUint32s reinterprets the bits of a Uint8x64 vector as a Uint32x16 vector

func (Uint8x64) ReshapeToUint64s added in go1.27.0 

func (x Uint8x64) ReshapeToUint64s() Uint64x8

ReshapeToUint64s reinterprets the bits of a Uint8x64 vector as a Uint64x8 vector

func (Uint8x64) SetHi 

func (x Uint8x64) SetHi(y Uint8x32) Uint8x64

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint8x64) SetLo 

func (x Uint8x64) SetLo(y Uint8x32) Uint8x64

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint8x64) Store 

func (x Uint8x64) Store(s []uint8)

Store stores the elements of x into a slice. If s does not have at least 64 elements, it panics.

func (Uint8x64) StoreArray added in go1.27.0 

func (x Uint8x64) StoreArray(y *[64]uint8)

StoreArray stores a Uint8x64 to an array.

func (Uint8x64) StoreArrayMasked added in go1.27.0 

func (x Uint8x64) StoreArrayMasked(y *[64]uint8, mask Mask8x64)

StoreArrayMasked stores a Uint8x64 to an array, at those elements enabled by mask.

Asm: VMOVDQU8, CPU Feature: AVX512

func (Uint8x64) StorePart added in go1.27.0 

func (x Uint8x64) StorePart(s []uint8) int

StorePart stores the 64 elements of x into the slice s. It stores as many elements as will fit in s. If s has 64 or more elements, the method is equivalent to x.Store.

func (Uint8x64) String 

func (x Uint8x64) String() string

String returns a string representation of SIMD vector x.

func (Uint8x64) Sub 

func (x Uint8x64) Sub(y Uint8x64) Uint8x64

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBB, CPU Feature: AVX512

func (Uint8x64) SubSaturated 

func (x Uint8x64) SubSaturated(y Uint8x64) Uint8x64

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSB, CPU Feature: AVX512

func (Uint8x64) SumOf8AbsDiff added in go1.27.0 

func (x Uint8x64) SumOf8AbsDiff(y Uint8x64) Uint64x8

SumOf8AbsDiff computes the absolute difference of x and y and sums each group of 8 results. This method could be seen as the norm of the L1 distance of each 8-element group of the two input vectors.

Asm: VPSADBW, CPU Feature: AVX512

func (Uint8x64) Xor 

func (x Uint8x64) Xor(y Uint8x64) Uint8x64

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Uint16x8 

type Uint16x8 struct {
	// contains filtered or unexported fields
}

Uint16x8 is a 128-bit SIMD vector of 8 uint16s.

func BroadcastUint16x8 

func BroadcastUint16x8(x uint16) Uint16x8

BroadcastUint16x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint16x8 

func LoadUint16x8(s []uint16) Uint16x8

LoadUint16x8 loads an Uint16x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadUint16x8Array added in go1.27.0 

func LoadUint16x8Array(y *[8]uint16) Uint16x8

LoadUint16x8Array loads a Uint16x8 from an array.

func LoadUint16x8Part added in go1.27.0 

func LoadUint16x8Part(s []uint16) (Uint16x8, int)

LoadUint16x8Part loads a Uint16x8 from the slice s. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadInt16x8.

func (Uint16x8) Add 

func (x Uint16x8) Add(y Uint16x8) Uint16x8

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX

func (Uint16x8) AddSaturated 

func (x Uint16x8) AddSaturated(y Uint16x8) Uint16x8

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSW, CPU Feature: AVX

func (Uint16x8) And 

func (x Uint16x8) And(y Uint16x8) Uint16x8

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Uint16x8) AndNot 

func (x Uint16x8) AndNot(y Uint16x8) Uint16x8

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Uint16x8) AsFloat32x4 deprecated 

func (x Uint16x8) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Uint16x8 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsFloat64x2 deprecated 

func (x Uint16x8) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Uint16x8 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsInt8x16 deprecated 

func (x Uint16x8) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Uint16x8 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsInt16x8 deprecated 

func (x Uint16x8) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Uint16x8 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsInt32x4 deprecated 

func (x Uint16x8) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Uint16x8 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsInt64x2 deprecated 

func (x Uint16x8) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Uint16x8 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsUint8x16 deprecated 

func (x Uint16x8) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Uint16x8 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsUint32x4 deprecated 

func (x Uint16x8) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Uint16x8 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) AsUint64x2 deprecated 

func (x Uint16x8) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Uint16x8 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x8) Average 

func (x Uint16x8) Average(y Uint16x8) Uint16x8

Average computes the rounded average of corresponding elements.

Asm: VPAVGW, CPU Feature: AVX

func (Uint16x8) BitsToInt16 added in go1.27.0 

func (x Uint16x8) BitsToInt16() Int16x8

BitsToInt16 reinterprets the bits of a Uint16x8 vector as a Int16x8 vector

func (Uint16x8) Compress 

func (x Uint16x8) Compress(mask Mask16x8) Uint16x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Uint16x8) ConcatAddPairs added in go1.27.0 

func (x Uint16x8) ConcatAddPairs(y Uint16x8) Uint16x8

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDW, CPU Feature: AVX

func (Uint16x8) ConcatPermute 

func (x Uint16x8) ConcatPermute(y Uint16x8, indices Uint16x8) Uint16x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Uint16x8) ConcatSubPairs added in go1.27.0 

func (x Uint16x8) ConcatSubPairs(y Uint16x8) Uint16x8

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBW, CPU Feature: AVX

func (Uint16x8) ConvertToInt16 added in go1.27.0 

func (x Uint16x8) ConvertToInt16() Int16x8

ConvertToInt16 converts a Uint16x8 vector to a Int16x8 vector

func (Uint16x8) Equal 

func (x Uint16x8) Equal(y Uint16x8) Mask16x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX

func (Uint16x8) Expand 

func (x Uint16x8) Expand(mask Mask16x8) Uint16x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Uint16x8) ExtendLo2ToUint64 

func (x Uint16x8) ExtendLo2ToUint64() Uint64x2

ExtendLo2ToUint64 zero-extends 2 lowest vector element values to uint64.

Asm: VPMOVZXWQ, CPU Feature: AVX

func (Uint16x8) ExtendLo4ToUint32 

func (x Uint16x8) ExtendLo4ToUint32() Uint32x4

ExtendLo4ToUint32 zero-extends 4 lowest vector element values to uint32.

Asm: VPMOVZXWD, CPU Feature: AVX

func (Uint16x8) ExtendLo4ToUint64 

func (x Uint16x8) ExtendLo4ToUint64() Uint64x4

ExtendLo4ToUint64 zero-extends 4 lowest vector element values to uint64.

Asm: VPMOVZXWQ, CPU Feature: AVX2

func (Uint16x8) ExtendToUint32 

func (x Uint16x8) ExtendToUint32() Uint32x8

ExtendToUint32 zero-extends element values to uint32.

Asm: VPMOVZXWD, CPU Feature: AVX2

func (Uint16x8) ExtendToUint64 

func (x Uint16x8) ExtendToUint64() Uint64x8

ExtendToUint64 zero-extends element values to uint64.

Asm: VPMOVZXWQ, CPU Feature: AVX512

func (Uint16x8) GetElem 

func (x Uint16x8) GetElem(index uint8) uint16

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRW, CPU Feature: AVX

func (Uint16x8) Greater 

func (x Uint16x8) Greater(y Uint16x8) Mask16x8

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX

func (Uint16x8) GreaterEqual 

func (x Uint16x8) GreaterEqual(y Uint16x8) Mask16x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Uint16x8) IfElse added in go1.27.0 

func (x Uint16x8) IfElse(mask Mask16x8, y Uint16x8) Uint16x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Uint16x8) InterleaveHi 

func (x Uint16x8) InterleaveHi(y Uint16x8) Uint16x8

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX

func (Uint16x8) InterleaveLo 

func (x Uint16x8) InterleaveLo(y Uint16x8) Uint16x8

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX

func (Uint16x8) IsZero 

func (x Uint16x8) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint16x8) Len 

func (x Uint16x8) Len() int

Len returns the number of elements in a Uint16x8.

func (Uint16x8) Less 

func (x Uint16x8) Less(y Uint16x8) Mask16x8

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Uint16x8) LessEqual 

func (x Uint16x8) LessEqual(y Uint16x8) Mask16x8

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Uint16x8) Masked 

func (x Uint16x8) Masked(mask Mask16x8) Uint16x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Uint16x8) Max 

func (x Uint16x8) Max(y Uint16x8) Uint16x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUW, CPU Feature: AVX

func (Uint16x8) Merge deprecated 

func (x Uint16x8) Merge(y Uint16x8, mask Mask16x8) Uint16x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Uint16x8) Min 

func (x Uint16x8) Min(y Uint16x8) Uint16x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUW, CPU Feature: AVX

func (Uint16x8) Mul 

func (x Uint16x8) Mul(y Uint16x8) Uint16x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX

func (Uint16x8) MulHigh 

func (x Uint16x8) MulHigh(y Uint16x8) Uint16x8

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHUW, CPU Feature: AVX

func (Uint16x8) Not 

func (x Uint16x8) Not() Uint16x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Uint16x8) NotEqual 

func (x Uint16x8) NotEqual(y Uint16x8) Mask16x8

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Uint16x8) OnesCount 

func (x Uint16x8) OnesCount() Uint16x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Uint16x8) Or 

func (x Uint16x8) Or(y Uint16x8) Uint16x8

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Uint16x8) Permute 

func (x Uint16x8) Permute(indices Uint16x8) Uint16x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Uint16x8) PermuteScalarsHi 

func (x Uint16x8) PermuteScalarsHi(a, b, c, d uint8) Uint16x8

PermuteScalarsHi performs a permutation of vector x using the supplied indices: 

result = {x[0], x[1], x[2], x[3], x[a+4], x[b+4], x[c+4], x[d+4]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX

func (Uint16x8) PermuteScalarsLo 

func (x Uint16x8) PermuteScalarsLo(a, b, c, d uint8) Uint16x8

PermuteScalarsLo performs a permutation of vector x using the supplied indices: 

result = {x[a], x[b], x[c], x[d], x[4], x[5], x[6], x[7]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX512

func (Uint16x8) ReshapeToUint8s added in go1.27.0 

func (x Uint16x8) ReshapeToUint8s() Uint8x16

ReshapeToUint8s reinterprets the bits of a Uint16x8 vector as a Uint8x16 vector

func (Uint16x8) ReshapeToUint32s added in go1.27.0 

func (x Uint16x8) ReshapeToUint32s() Uint32x4

ReshapeToUint32s reinterprets the bits of a Uint16x8 vector as a Uint32x4 vector

func (Uint16x8) ReshapeToUint64s added in go1.27.0 

func (x Uint16x8) ReshapeToUint64s() Uint64x2

ReshapeToUint64s reinterprets the bits of a Uint16x8 vector as a Uint64x2 vector

func (Uint16x8) RotateAllLeft added in go1.27.0 

func (x Uint16x8) RotateAllLeft(dist uint64) Uint16x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint16x8) RotateAllRight added in go1.27.0 

func (x Uint16x8) RotateAllRight(dist uint64) Uint16x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint16x8) SaturateToUint8 

func (x Uint16x8) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSWB, CPU Feature: AVX512

func (Uint16x8) SetElem 

func (x Uint16x8) SetElem(index uint8, y uint16) Uint16x8

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRW, CPU Feature: AVX

func (Uint16x8) ShiftAllLeft 

func (x Uint16x8) ShiftAllLeft(shift uint64) Uint16x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX

func (Uint16x8) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Uint16x8) ShiftAllLeftConcatMod16(y Uint16x8, shift uint64) Uint16x8

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Uint16x8) ShiftAllRight 

func (x Uint16x8) ShiftAllRight(shift uint64) Uint16x8

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLW, CPU Feature: AVX

func (Uint16x8) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Uint16x8) ShiftAllRightConcatMod16(y Uint16x8, shift uint64) Uint16x8

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Uint16x8) ShiftLeft 

func (x Uint16x8) ShiftLeft(shift Uint16x8) Uint16x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Uint16x8) ShiftLeftConcatMod16 added in go1.27.0 

func (x Uint16x8) ShiftLeftConcatMod16(y Uint16x8, shift Uint16x8) Uint16x8

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Uint16x8) ShiftRight 

func (x Uint16x8) ShiftRight(shift Uint16x8) Uint16x8

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVW, CPU Feature: AVX512

func (Uint16x8) ShiftRightConcatMod16 added in go1.27.0 

func (x Uint16x8) ShiftRightConcatMod16(y Uint16x8, shift Uint16x8) Uint16x8

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Uint16x8) Store 

func (x Uint16x8) Store(s []uint16)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Uint16x8) StoreArray added in go1.27.0 

func (x Uint16x8) StoreArray(y *[8]uint16)

StoreArray stores a Uint16x8 to an array.

func (Uint16x8) StorePart added in go1.27.0 

func (x Uint16x8) StorePart(s []uint16) int

StorePart stores the elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Uint16x8) String 

func (x Uint16x8) String() string

String returns a string representation of SIMD vector x.

func (Uint16x8) Sub 

func (x Uint16x8) Sub(y Uint16x8) Uint16x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX

func (Uint16x8) SubSaturated 

func (x Uint16x8) SubSaturated(y Uint16x8) Uint16x8

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSW, CPU Feature: AVX

func (Uint16x8) TruncToUint8 added in go1.27.0 

func (x Uint16x8) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVWB, CPU Feature: AVX512

func (Uint16x8) Xor 

func (x Uint16x8) Xor(y Uint16x8) Uint16x8

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Uint16x16 

type Uint16x16 struct {
	// contains filtered or unexported fields
}

Uint16x16 is a 256-bit SIMD vector of 16 uint16s.

func BroadcastUint16x16 

func BroadcastUint16x16(x uint16) Uint16x16

BroadcastUint16x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint16x16 

func LoadUint16x16(s []uint16) Uint16x16

LoadUint16x16 loads an Uint16x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadUint16x16Array added in go1.27.0 

func LoadUint16x16Array(y *[16]uint16) Uint16x16

LoadUint16x16Array loads a Uint16x16 from an array.

func LoadUint16x16Part added in go1.27.0 

func LoadUint16x16Part(s []uint16) (Uint16x16, int)

LoadUint16x16Part loads a Uint16x16 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadUint16x16.

func (Uint16x16) Add 

func (x Uint16x16) Add(y Uint16x16) Uint16x16

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX2

func (Uint16x16) AddSaturated 

func (x Uint16x16) AddSaturated(y Uint16x16) Uint16x16

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSW, CPU Feature: AVX2

func (Uint16x16) And 

func (x Uint16x16) And(y Uint16x16) Uint16x16

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Uint16x16) AndNot 

func (x Uint16x16) AndNot(y Uint16x16) Uint16x16

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Uint16x16) AsFloat32x8 deprecated 

func (x Uint16x16) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Uint16x16 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsFloat64x4 deprecated 

func (x Uint16x16) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Uint16x16 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsInt8x32 deprecated 

func (x Uint16x16) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Uint16x16 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsInt16x16 deprecated 

func (x Uint16x16) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Uint16x16 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsInt32x8 deprecated 

func (x Uint16x16) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Uint16x16 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsInt64x4 deprecated 

func (x Uint16x16) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Uint16x16 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsUint8x32 deprecated 

func (x Uint16x16) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Uint16x16 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsUint32x8 deprecated 

func (x Uint16x16) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Uint16x16 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) AsUint64x4 deprecated 

func (x Uint16x16) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Uint16x16 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x16) Average 

func (x Uint16x16) Average(y Uint16x16) Uint16x16

Average computes the rounded average of corresponding elements.

Asm: VPAVGW, CPU Feature: AVX2

func (Uint16x16) BitsToInt16 added in go1.27.0 

func (x Uint16x16) BitsToInt16() Int16x16

BitsToInt16 reinterprets the bits of a Uint16x16 vector as a Int16x16 vector

func (Uint16x16) Compress 

func (x Uint16x16) Compress(mask Mask16x16) Uint16x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Uint16x16) ConcatAddPairsGrouped added in go1.27.0 

func (x Uint16x16) ConcatAddPairsGrouped(y Uint16x16) Uint16x16

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDW, CPU Feature: AVX2

func (Uint16x16) ConcatPermute 

func (x Uint16x16) ConcatPermute(y Uint16x16, indices Uint16x16) Uint16x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Uint16x16) ConcatPermute128Scalars added in go1.27.0 

func (x Uint16x16) ConcatPermute128Scalars(lo, hi uint8, y Uint16x16) Uint16x16

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 42, 43, 44, 45, 46, 47, 50, 51, 52, 53, 54, 55, 56, 57}.ConcatPermute128Scalars(3, 0,
 {60, 61, 62, 63, 64, 65, 66, 67, 70, 71, 72, 73, 74, 75, 76, 77})

returns {70, 71, 72, 73, 74, 75, 76, 77, 40, 41, 42, 43, 44, 45, 46, 47}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Uint16x16) ConcatSubPairsGrouped added in go1.27.0 

func (x Uint16x16) ConcatSubPairsGrouped(y Uint16x16) Uint16x16

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBW, CPU Feature: AVX2

func (Uint16x16) ConvertToInt16 added in go1.27.0 

func (x Uint16x16) ConvertToInt16() Int16x16

ConvertToInt16 converts a Uint16x16 vector to a Int16x16 vector

func (Uint16x16) Equal 

func (x Uint16x16) Equal(y Uint16x16) Mask16x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX2

func (Uint16x16) Expand 

func (x Uint16x16) Expand(mask Mask16x16) Uint16x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Uint16x16) ExtendToUint32 

func (x Uint16x16) ExtendToUint32() Uint32x16

ExtendToUint32 zero-extends element values to uint32.

Asm: VPMOVZXWD, CPU Feature: AVX512

func (Uint16x16) GetHi 

func (x Uint16x16) GetHi() Uint16x8

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint16x16) GetLo 

func (x Uint16x16) GetLo() Uint16x8

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint16x16) Greater 

func (x Uint16x16) Greater(y Uint16x16) Mask16x16

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX2

func (Uint16x16) GreaterEqual 

func (x Uint16x16) GreaterEqual(y Uint16x16) Mask16x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Uint16x16) IfElse added in go1.27.0 

func (x Uint16x16) IfElse(mask Mask16x16, y Uint16x16) Uint16x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Uint16x16) InterleaveHiGrouped 

func (x Uint16x16) InterleaveHiGrouped(y Uint16x16) Uint16x16

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX2

func (Uint16x16) InterleaveLoGrouped 

func (x Uint16x16) InterleaveLoGrouped(y Uint16x16) Uint16x16

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX2

func (Uint16x16) IsZero 

func (x Uint16x16) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint16x16) Len 

func (x Uint16x16) Len() int

Len returns the number of elements in a Uint16x16.

func (Uint16x16) Less 

func (x Uint16x16) Less(y Uint16x16) Mask16x16

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Uint16x16) LessEqual 

func (x Uint16x16) LessEqual(y Uint16x16) Mask16x16

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Uint16x16) Masked 

func (x Uint16x16) Masked(mask Mask16x16) Uint16x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Uint16x16) Max 

func (x Uint16x16) Max(y Uint16x16) Uint16x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUW, CPU Feature: AVX2

func (Uint16x16) Merge deprecated 

func (x Uint16x16) Merge(y Uint16x16, mask Mask16x16) Uint16x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Uint16x16) Min 

func (x Uint16x16) Min(y Uint16x16) Uint16x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUW, CPU Feature: AVX2

func (Uint16x16) Mul 

func (x Uint16x16) Mul(y Uint16x16) Uint16x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX2

func (Uint16x16) MulHigh 

func (x Uint16x16) MulHigh(y Uint16x16) Uint16x16

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHUW, CPU Feature: AVX2

func (Uint16x16) Not 

func (x Uint16x16) Not() Uint16x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Uint16x16) NotEqual 

func (x Uint16x16) NotEqual(y Uint16x16) Mask16x16

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Uint16x16) OnesCount 

func (x Uint16x16) OnesCount() Uint16x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Uint16x16) Or 

func (x Uint16x16) Or(y Uint16x16) Uint16x16

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Uint16x16) Permute 

func (x Uint16x16) Permute(indices Uint16x16) Uint16x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Uint16x16) PermuteScalarsHiGrouped 

func (x Uint16x16) PermuteScalarsHiGrouped(a, b, c, d uint8) Uint16x16

PermuteScalarsHiGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
  {x[0], x[1], x[2], x[3],   x[a+4], x[b+4], x[c+4], x[d+4],
	x[8], x[9], x[10], x[11], x[a+12], x[b+12], x[c+12], x[d+12]}

Each group is of size 128-bit.

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX2

func (Uint16x16) PermuteScalarsLoGrouped 

func (x Uint16x16) PermuteScalarsLoGrouped(a, b, c, d uint8) Uint16x16

PermuteScalarsLoGrouped performs a grouped permutation of vector x using the supplied indices: 

 result = {x[a], x[b], x[c], x[d],         x[4], x[5], x[6], x[7],
	x[a+8], x[b+8], x[c+8], x[d+8], x[12], x[13], x[14], x[15]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX2

func (Uint16x16) ReshapeToUint8s added in go1.27.0 

func (x Uint16x16) ReshapeToUint8s() Uint8x32

ReshapeToUint8s reinterprets the bits of a Uint16x16 vector as a Uint8x32 vector

func (Uint16x16) ReshapeToUint32s added in go1.27.0 

func (x Uint16x16) ReshapeToUint32s() Uint32x8

ReshapeToUint32s reinterprets the bits of a Uint16x16 vector as a Uint32x8 vector

func (Uint16x16) ReshapeToUint64s added in go1.27.0 

func (x Uint16x16) ReshapeToUint64s() Uint64x4

ReshapeToUint64s reinterprets the bits of a Uint16x16 vector as a Uint64x4 vector

func (Uint16x16) RotateAllLeft added in go1.27.0 

func (x Uint16x16) RotateAllLeft(dist uint64) Uint16x16

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint16x16) RotateAllRight added in go1.27.0 

func (x Uint16x16) RotateAllRight(dist uint64) Uint16x16

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint16x16) SaturateToUint8 

func (x Uint16x16) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation.

Asm: VPMOVUSWB, CPU Feature: AVX512

func (Uint16x16) SetHi 

func (x Uint16x16) SetHi(y Uint16x8) Uint16x16

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint16x16) SetLo 

func (x Uint16x16) SetLo(y Uint16x8) Uint16x16

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint16x16) ShiftAllLeft 

func (x Uint16x16) ShiftAllLeft(shift uint64) Uint16x16

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX2

func (Uint16x16) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Uint16x16) ShiftAllLeftConcatMod16(y Uint16x16, shift uint64) Uint16x16

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Uint16x16) ShiftAllRight 

func (x Uint16x16) ShiftAllRight(shift uint64) Uint16x16

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLW, CPU Feature: AVX2

func (Uint16x16) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Uint16x16) ShiftAllRightConcatMod16(y Uint16x16, shift uint64) Uint16x16

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Uint16x16) ShiftLeft 

func (x Uint16x16) ShiftLeft(shift Uint16x16) Uint16x16

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Uint16x16) ShiftLeftConcatMod16 added in go1.27.0 

func (x Uint16x16) ShiftLeftConcatMod16(y Uint16x16, shift Uint16x16) Uint16x16

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Uint16x16) ShiftRight 

func (x Uint16x16) ShiftRight(shift Uint16x16) Uint16x16

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVW, CPU Feature: AVX512

func (Uint16x16) ShiftRightConcatMod16 added in go1.27.0 

func (x Uint16x16) ShiftRightConcatMod16(y Uint16x16, shift Uint16x16) Uint16x16

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Uint16x16) Store 

func (x Uint16x16) Store(s []uint16)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Uint16x16) StoreArray added in go1.27.0 

func (x Uint16x16) StoreArray(y *[16]uint16)

StoreArray stores a Uint16x16 to an array.

func (Uint16x16) StorePart added in go1.27.0 

func (x Uint16x16) StorePart(s []uint16) int

StorePart stores the 16 elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Uint16x16) String 

func (x Uint16x16) String() string

String returns a string representation of SIMD vector x.

func (Uint16x16) Sub 

func (x Uint16x16) Sub(y Uint16x16) Uint16x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX2

func (Uint16x16) SubSaturated 

func (x Uint16x16) SubSaturated(y Uint16x16) Uint16x16

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSW, CPU Feature: AVX2

func (Uint16x16) TruncToUint8 added in go1.27.0 

func (x Uint16x16) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8.

Asm: VPMOVWB, CPU Feature: AVX512

func (Uint16x16) Xor 

func (x Uint16x16) Xor(y Uint16x16) Uint16x16

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Uint16x32 

type Uint16x32 struct {
	// contains filtered or unexported fields
}

Uint16x32 is a 512-bit SIMD vector of 32 uint16s.

func BroadcastUint16x32 

func BroadcastUint16x32(x uint16) Uint16x32

BroadcastUint16x32 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512BW

func LoadUint16x32 

func LoadUint16x32(s []uint16) Uint16x32

LoadUint16x32 loads an Uint16x32 from a slice of elements. If s does not have at least 32 elements, it panics.

func LoadUint16x32Array added in go1.27.0 

func LoadUint16x32Array(y *[32]uint16) Uint16x32

LoadUint16x32Array loads a Uint16x32 from an array.

func LoadUint16x32Part added in go1.27.0 

func LoadUint16x32Part(s []uint16) (Uint16x32, int)

LoadUint16x32Part loads a Uint16x32 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes. If s has 32 or more elements, the function is equivalent to LoadUint16x32.

func (Uint16x32) Add 

func (x Uint16x32) Add(y Uint16x32) Uint16x32

Add adds corresponding elements of two vectors.

Asm: VPADDW, CPU Feature: AVX512

func (Uint16x32) AddSaturated 

func (x Uint16x32) AddSaturated(y Uint16x32) Uint16x32

AddSaturated adds corresponding elements of two vectors with saturation.

Asm: VPADDUSW, CPU Feature: AVX512

func (Uint16x32) And 

func (x Uint16x32) And(y Uint16x32) Uint16x32

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Uint16x32) AndNot 

func (x Uint16x32) AndNot(y Uint16x32) Uint16x32

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Uint16x32) AsFloat32x16 deprecated 

func (x Uint16x32) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Uint16x32 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsFloat64x8 deprecated 

func (x Uint16x32) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Uint16x32 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsInt8x64 deprecated 

func (x Uint16x32) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Uint16x32 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsInt16x32 deprecated 

func (x Uint16x32) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Uint16x32 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsInt32x16 deprecated 

func (x Uint16x32) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Uint16x32 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsInt64x8 deprecated 

func (x Uint16x32) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Uint16x32 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsUint8x64 deprecated 

func (x Uint16x32) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Uint16x32 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsUint32x16 deprecated 

func (x Uint16x32) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Uint16x32 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) AsUint64x8 deprecated 

func (x Uint16x32) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Uint16x32 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint16x32) Average 

func (x Uint16x32) Average(y Uint16x32) Uint16x32

Average computes the rounded average of corresponding elements.

Asm: VPAVGW, CPU Feature: AVX512

func (Uint16x32) BitsToInt16 added in go1.27.0 

func (x Uint16x32) BitsToInt16() Int16x32

BitsToInt16 reinterprets the bits of a Uint16x32 vector as a Int16x32 vector

func (Uint16x32) Compress 

func (x Uint16x32) Compress(mask Mask16x32) Uint16x32

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSW, CPU Feature: AVX512VBMI2

func (Uint16x32) ConcatPermute 

func (x Uint16x32) ConcatPermute(y Uint16x32, indices Uint16x32) Uint16x32

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2W, CPU Feature: AVX512

func (Uint16x32) ConvertToInt16 added in go1.27.0 

func (x Uint16x32) ConvertToInt16() Int16x32

ConvertToInt16 converts a Uint16x32 vector to a Int16x32 vector

func (Uint16x32) Equal 

func (x Uint16x32) Equal(y Uint16x32) Mask16x32

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQW, CPU Feature: AVX512

func (Uint16x32) Expand 

func (x Uint16x32) Expand(mask Mask16x32) Uint16x32

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDW, CPU Feature: AVX512VBMI2

func (Uint16x32) GetHi 

func (x Uint16x32) GetHi() Uint16x16

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint16x32) GetLo 

func (x Uint16x32) GetLo() Uint16x16

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint16x32) Greater 

func (x Uint16x32) Greater(y Uint16x32) Mask16x32

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPUW, CPU Feature: AVX512

func (Uint16x32) GreaterEqual 

func (x Uint16x32) GreaterEqual(y Uint16x32) Mask16x32

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPUW, CPU Feature: AVX512

func (Uint16x32) IfElse added in go1.27.0 

func (x Uint16x32) IfElse(mask Mask16x32, y Uint16x32) Uint16x32

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Uint16x32) InterleaveHiGrouped 

func (x Uint16x32) InterleaveHiGrouped(y Uint16x32) Uint16x32

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHWD, CPU Feature: AVX512

func (Uint16x32) InterleaveLoGrouped 

func (x Uint16x32) InterleaveLoGrouped(y Uint16x32) Uint16x32

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLWD, CPU Feature: AVX512

func (Uint16x32) Len 

func (x Uint16x32) Len() int

Len returns the number of elements in a Uint16x32.

func (Uint16x32) Less 

func (x Uint16x32) Less(y Uint16x32) Mask16x32

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPUW, CPU Feature: AVX512

func (Uint16x32) LessEqual 

func (x Uint16x32) LessEqual(y Uint16x32) Mask16x32

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPUW, CPU Feature: AVX512

func (Uint16x32) Masked 

func (x Uint16x32) Masked(mask Mask16x32) Uint16x32

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Uint16x32) Max 

func (x Uint16x32) Max(y Uint16x32) Uint16x32

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUW, CPU Feature: AVX512

func (Uint16x32) Merge deprecated 

func (x Uint16x32) Merge(y Uint16x32, mask Mask16x32) Uint16x32

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Uint16x32) Min 

func (x Uint16x32) Min(y Uint16x32) Uint16x32

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUW, CPU Feature: AVX512

func (Uint16x32) Mul 

func (x Uint16x32) Mul(y Uint16x32) Uint16x32

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLW, CPU Feature: AVX512

func (Uint16x32) MulHigh 

func (x Uint16x32) MulHigh(y Uint16x32) Uint16x32

MulHigh multiplies elements and stores the high part of the result.

Asm: VPMULHUW, CPU Feature: AVX512

func (Uint16x32) Not 

func (x Uint16x32) Not() Uint16x32

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Uint16x32) NotEqual 

func (x Uint16x32) NotEqual(y Uint16x32) Mask16x32

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPUW, CPU Feature: AVX512

func (Uint16x32) OnesCount 

func (x Uint16x32) OnesCount() Uint16x32

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTW, CPU Feature: AVX512BITALG

func (Uint16x32) Or 

func (x Uint16x32) Or(y Uint16x32) Uint16x32

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Uint16x32) Permute 

func (x Uint16x32) Permute(indices Uint16x32) Uint16x32

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMW, CPU Feature: AVX512

func (Uint16x32) PermuteScalarsHiGrouped 

func (x Uint16x32) PermuteScalarsHiGrouped(a, b, c, d uint8) Uint16x32

PermuteScalarsHiGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
	 {  x[0], x[1], x[2], x[3],     x[a+4], x[b+4], x[c+4], x[d+4],
		x[8], x[9], x[10], x[11],   x[a+12], x[b+12], x[c+12], x[d+12],
		x[16], x[17], x[18], x[19], x[a+20], x[b+20], x[c+20], x[d+20],
		x[24], x[25], x[26], x[27], x[a+28], x[b+28], x[c+28], x[d+28]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFHW, CPU Feature: AVX512

func (Uint16x32) PermuteScalarsLoGrouped 

func (x Uint16x32) PermuteScalarsLoGrouped(a, b, c, d uint8) Uint16x32

PermuteScalarsLoGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
 {x[a], x[b], x[c], x[d],    x[4], x[5], x[6], x[7],
	x[a+8], x[b+8], x[c+8], x[d+8],     x[12], x[13], x[14], x[15],
	x[a+16], x[b+16], x[c+16], x[d+16], x[20], x[21], x[22], x[23],
	x[a+24], x[b+24], x[c+24], x[d+24], x[28], x[29], x[30], x[31]}

Each group is of size 128-bit.

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFLW, CPU Feature: AVX512

func (Uint16x32) ReshapeToUint8s added in go1.27.0 

func (x Uint16x32) ReshapeToUint8s() Uint8x64

ReshapeToUint8s reinterprets the bits of a Uint16x32 vector as a Uint8x64 vector

func (Uint16x32) ReshapeToUint32s added in go1.27.0 

func (x Uint16x32) ReshapeToUint32s() Uint32x16

ReshapeToUint32s reinterprets the bits of a Uint16x32 vector as a Uint32x16 vector

func (Uint16x32) ReshapeToUint64s added in go1.27.0 

func (x Uint16x32) ReshapeToUint64s() Uint64x8

ReshapeToUint64s reinterprets the bits of a Uint16x32 vector as a Uint64x8 vector

func (Uint16x32) RotateAllLeft added in go1.27.0 

func (x Uint16x32) RotateAllLeft(dist uint64) Uint16x32

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint16x32) RotateAllRight added in go1.27.0 

func (x Uint16x32) RotateAllRight(dist uint64) Uint16x32

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint16x32) SaturateToUint8 

func (x Uint16x32) SaturateToUint8() Uint8x32

SaturateToUint8 converts element values to uint8 with unsigned saturation.

Asm: VPMOVUSWB, CPU Feature: AVX512

func (Uint16x32) SetHi 

func (x Uint16x32) SetHi(y Uint16x16) Uint16x32

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint16x32) SetLo 

func (x Uint16x32) SetLo(y Uint16x16) Uint16x32

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint16x32) ShiftAllLeft 

func (x Uint16x32) ShiftAllLeft(shift uint64) Uint16x32

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLW, CPU Feature: AVX512

func (Uint16x32) ShiftAllLeftConcatMod16 added in go1.27.0 

func (x Uint16x32) ShiftAllLeftConcatMod16(y Uint16x32, shift uint64) Uint16x32

ShiftAllLeftConcatMod16 shifts x[i] left by shift%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDW, CPU Feature: AVX512VBMI2

func (Uint16x32) ShiftAllRight 

func (x Uint16x32) ShiftAllRight(shift uint64) Uint16x32

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLW, CPU Feature: AVX512

func (Uint16x32) ShiftAllRightConcatMod16 added in go1.27.0 

func (x Uint16x32) ShiftAllRightConcatMod16(y Uint16x32, shift uint64) Uint16x32

ShiftAllRightConcatMod16 shifts x[i] right by shift%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%16)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDW, CPU Feature: AVX512VBMI2

func (Uint16x32) ShiftLeft 

func (x Uint16x32) ShiftLeft(shift Uint16x32) Uint16x32

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVW, CPU Feature: AVX512

func (Uint16x32) ShiftLeftConcatMod16 added in go1.27.0 

func (x Uint16x32) ShiftLeftConcatMod16(y Uint16x32, shift Uint16x32) Uint16x32

ShiftLeftConcatMod16 shifts x[i] left by shift[i]%16, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%16)

Asm: VPSHLDVW, CPU Feature: AVX512VBMI2

func (Uint16x32) ShiftRight 

func (x Uint16x32) ShiftRight(shift Uint16x32) Uint16x32

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVW, CPU Feature: AVX512

func (Uint16x32) ShiftRightConcatMod16 added in go1.27.0 

func (x Uint16x32) ShiftRightConcatMod16(y Uint16x32, shift Uint16x32) Uint16x32

ShiftRightConcatMod16 shifts x[i] right by shift[i]%16, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%16)

Asm: VPSHRDVW, CPU Feature: AVX512VBMI2

func (Uint16x32) Store 

func (x Uint16x32) Store(s []uint16)

Store stores the elements of x into a slice. If s does not have at least 32 elements, it panics.

func (Uint16x32) StoreArray added in go1.27.0 

func (x Uint16x32) StoreArray(y *[32]uint16)

StoreArray stores a Uint16x32 to an array.

func (Uint16x32) StoreArrayMasked added in go1.27.0 

func (x Uint16x32) StoreArrayMasked(y *[32]uint16, mask Mask16x32)

StoreArrayMasked stores a Uint16x32 to an array, at those elements enabled by mask.

Asm: VMOVDQU16, CPU Feature: AVX512

func (Uint16x32) StorePart added in go1.27.0 

func (x Uint16x32) StorePart(s []uint16) int

StorePart stores the 32 elements of x into the slice s. It stores as many elements as will fit in s. If s has 32 or more elements, the method is equivalent to x.Store.

func (Uint16x32) String 

func (x Uint16x32) String() string

String returns a string representation of SIMD vector x.

func (Uint16x32) Sub 

func (x Uint16x32) Sub(y Uint16x32) Uint16x32

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBW, CPU Feature: AVX512

func (Uint16x32) SubSaturated 

func (x Uint16x32) SubSaturated(y Uint16x32) Uint16x32

SubSaturated subtracts corresponding elements of two vectors with saturation.

Asm: VPSUBUSW, CPU Feature: AVX512

func (Uint16x32) TruncToUint8 added in go1.27.0 

func (x Uint16x32) TruncToUint8() Uint8x32

TruncToUint8 truncates element values to uint8.

Asm: VPMOVWB, CPU Feature: AVX512

func (Uint16x32) Xor 

func (x Uint16x32) Xor(y Uint16x32) Uint16x32

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Uint32x4 

type Uint32x4 struct {
	// contains filtered or unexported fields
}

Uint32x4 is a 128-bit SIMD vector of 4 uint32s.

func BroadcastUint32x4 

func BroadcastUint32x4(x uint32) Uint32x4

BroadcastUint32x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint32x4 

func LoadUint32x4(s []uint32) Uint32x4

LoadUint32x4 loads an Uint32x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadUint32x4Array added in go1.27.0 

func LoadUint32x4Array(y *[4]uint32) Uint32x4

LoadUint32x4Array loads a Uint32x4 from an array.

func LoadUint32x4Part added in go1.27.0 

func LoadUint32x4Part(s []uint32) (Uint32x4, int)

LoadUint32x4Part loads a Uint32x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadUint32x4.

func (Uint32x4) AESInvMixColumns 

func (x Uint32x4) AESInvMixColumns() Uint32x4

AESInvMixColumns performs the InvMixColumns operation in AES cipher algorithm defined in FIPS 197. x is the chunk of w array in use. result = InvMixColumns(x)

Asm: VAESIMC, CPU Feature: AVXAES

func (Uint32x4) AESRoundKeyGenAssist 

func (x Uint32x4) AESRoundKeyGenAssist(rconVal uint8) Uint32x4

AESRoundKeyGenAssist performs some components of KeyExpansion in AES cipher algorithm defined in FIPS 197. x is an array of AES words, but only x[0] and x[2] are used. r is a value from the Rcon constant array. result[0] = XOR(SubWord(RotWord(x[0])), r) result[1] = SubWord(x[1]) result[2] = XOR(SubWord(RotWord(x[2])), r) result[3] = SubWord(x[3])

A non-constant value of rconVal may result in significantly worse performance for this operation.

Asm: VAESKEYGENASSIST, CPU Feature: AVXAES

func (Uint32x4) Add 

func (x Uint32x4) Add(y Uint32x4) Uint32x4

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX

func (Uint32x4) And 

func (x Uint32x4) And(y Uint32x4) Uint32x4

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Uint32x4) AndNot 

func (x Uint32x4) AndNot(y Uint32x4) Uint32x4

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Uint32x4) AsFloat32x4 deprecated 

func (x Uint32x4) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Uint32x4 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsFloat64x2 deprecated 

func (x Uint32x4) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Uint32x4 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsInt8x16 deprecated 

func (x Uint32x4) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Uint32x4 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsInt16x8 deprecated 

func (x Uint32x4) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Uint32x4 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsInt32x4 deprecated 

func (x Uint32x4) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Uint32x4 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsInt64x2 deprecated 

func (x Uint32x4) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Uint32x4 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsUint8x16 deprecated 

func (x Uint32x4) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Uint32x4 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsUint16x8 deprecated 

func (x Uint32x4) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Uint32x4 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) AsUint64x2 deprecated 

func (x Uint32x4) AsUint64x2() Uint64x2

AsUint64x2 reinterprets the bits of a Uint32x4 vector as a Uint64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x4) BitsToFloat32 added in go1.27.0 

func (x Uint32x4) BitsToFloat32() Float32x4

BitsToFloat32 reinterprets the bits of a Uint32x4 vector as a Float32x4 vector

func (Uint32x4) BitsToInt32 added in go1.27.0 

func (x Uint32x4) BitsToInt32() Int32x4

BitsToInt32 reinterprets the bits of a Uint32x4 vector as a Int32x4 vector

func (Uint32x4) Compress 

func (x Uint32x4) Compress(mask Mask32x4) Uint32x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Uint32x4) ConcatAddPairs added in go1.27.0 

func (x Uint32x4) ConcatAddPairs(y Uint32x4) Uint32x4

ConcatAddPairs horizontally adds adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDD, CPU Feature: AVX

func (Uint32x4) ConcatPermute 

func (x Uint32x4) ConcatPermute(y Uint32x4, indices Uint32x4) Uint32x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Uint32x4) ConcatPermuteScalars added in go1.27.0 

func (x Uint32x4) ConcatPermuteScalars(a, b, c, d uint8, y Uint32x4) Uint32x4

ConcatPermuteScalars returns the selection of four elements from the two vectors x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})

returns {4,8,25,81}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Uint32x4) ConcatSubPairs added in go1.27.0 

func (x Uint32x4) ConcatSubPairs(y Uint32x4) Uint32x4

ConcatSubPairs horizontally subtracts adjacent pairs of elements. For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBD, CPU Feature: AVX

func (Uint32x4) ConvertToFloat32 

func (x Uint32x4) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTUDQ2PS, CPU Feature: AVX512

func (Uint32x4) ConvertToFloat64 

func (x Uint32x4) ConvertToFloat64() Float64x4

ConvertToFloat64 converts element values to float64.

Asm: VCVTUDQ2PD, CPU Feature: AVX512

func (Uint32x4) ConvertToInt32 added in go1.27.0 

func (x Uint32x4) ConvertToInt32() Int32x4

ConvertToInt32 converts a Uint32x4 vector to a Int32x4 vector

func (Uint32x4) Equal 

func (x Uint32x4) Equal(y Uint32x4) Mask32x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX

func (Uint32x4) Expand 

func (x Uint32x4) Expand(mask Mask32x4) Uint32x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Uint32x4) ExtendLo2ToUint64 

func (x Uint32x4) ExtendLo2ToUint64() Uint64x2

ExtendLo2ToUint64 zero-extends 2 lowest vector element values to uint64.

Asm: VPMOVZXDQ, CPU Feature: AVX

func (Uint32x4) ExtendToUint64 

func (x Uint32x4) ExtendToUint64() Uint64x4

ExtendToUint64 zero-extends element values to uint64.

Asm: VPMOVZXDQ, CPU Feature: AVX2

func (Uint32x4) GetElem 

func (x Uint32x4) GetElem(index uint8) uint32

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRD, CPU Feature: AVX

func (Uint32x4) Greater 

func (x Uint32x4) Greater(y Uint32x4) Mask32x4

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX

func (Uint32x4) GreaterEqual 

func (x Uint32x4) GreaterEqual(y Uint32x4) Mask32x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Uint32x4) IfElse added in go1.27.0 

func (x Uint32x4) IfElse(mask Mask32x4, y Uint32x4) Uint32x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Uint32x4) InterleaveHi 

func (x Uint32x4) InterleaveHi(y Uint32x4) Uint32x4

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX

func (Uint32x4) InterleaveLo 

func (x Uint32x4) InterleaveLo(y Uint32x4) Uint32x4

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX

func (Uint32x4) IsZero 

func (x Uint32x4) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint32x4) LeadingZeros 

func (x Uint32x4) LeadingZeros() Uint32x4

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Uint32x4) Len 

func (x Uint32x4) Len() int

Len returns the number of elements in a Uint32x4.

func (Uint32x4) Less 

func (x Uint32x4) Less(y Uint32x4) Mask32x4

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Uint32x4) LessEqual 

func (x Uint32x4) LessEqual(y Uint32x4) Mask32x4

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Uint32x4) Masked 

func (x Uint32x4) Masked(mask Mask32x4) Uint32x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Uint32x4) Max 

func (x Uint32x4) Max(y Uint32x4) Uint32x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUD, CPU Feature: AVX

func (Uint32x4) Merge deprecated 

func (x Uint32x4) Merge(y Uint32x4, mask Mask32x4) Uint32x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Uint32x4) Min 

func (x Uint32x4) Min(y Uint32x4) Uint32x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUD, CPU Feature: AVX

func (Uint32x4) Mul 

func (x Uint32x4) Mul(y Uint32x4) Uint32x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX

func (Uint32x4) MulWidenEven added in go1.27.0 

func (x Uint32x4) MulWidenEven(y Uint32x4) Uint64x2

MulWidenEven multiplies even-indexed elements, widening the result. Result[i] = v1[2*i] * v2[2*i].

Asm: VPMULUDQ, CPU Feature: AVX

func (Uint32x4) Not 

func (x Uint32x4) Not() Uint32x4

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Uint32x4) NotEqual 

func (x Uint32x4) NotEqual(y Uint32x4) Mask32x4

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Uint32x4) OnesCount 

func (x Uint32x4) OnesCount() Uint32x4

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Uint32x4) Or 

func (x Uint32x4) Or(y Uint32x4) Uint32x4

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Uint32x4) PermuteScalars 

func (x Uint32x4) PermuteScalars(a, b, c, d uint8) Uint32x4

PermuteScalars performs a permutation of vector x's elements using the supplied indices: 

result = {x[a], x[b], x[c], x[d]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table may be generated.

Asm: VPSHUFD, CPU Feature: AVX

func (Uint32x4) ReshapeToUint8s added in go1.27.0 

func (x Uint32x4) ReshapeToUint8s() Uint8x16

ReshapeToUint8s reinterprets the bits of a Uint32x4 vector as a Uint8x16 vector

func (Uint32x4) ReshapeToUint16s added in go1.27.0 

func (x Uint32x4) ReshapeToUint16s() Uint16x8

ReshapeToUint16s reinterprets the bits of a Uint32x4 vector as a Uint16x8 vector

func (Uint32x4) ReshapeToUint64s added in go1.27.0 

func (x Uint32x4) ReshapeToUint64s() Uint64x2

ReshapeToUint64s reinterprets the bits of a Uint32x4 vector as a Uint64x2 vector

func (Uint32x4) RotateAllLeft 

func (x Uint32x4) RotateAllLeft(dist uint64) Uint32x4

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint32x4) RotateAllRight 

func (x Uint32x4) RotateAllRight(dist uint64) Uint32x4

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint32x4) RotateLeft 

func (x Uint32x4) RotateLeft(y Uint32x4) Uint32x4

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Uint32x4) RotateRight 

func (x Uint32x4) RotateRight(y Uint32x4) Uint32x4

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Uint32x4) SHA1FourRounds 

func (x Uint32x4) SHA1FourRounds(constant uint8, y Uint32x4) Uint32x4

SHA1FourRounds performs 4 rounds of B loop in SHA1 algorithm defined in FIPS 180-4. x contains the state variables a, b, c and d from upper to lower order. y contains the W array elements (with the state variable e added to the upper element) from upper to lower order. result = the state variables a', b', c', d' updated after 4 rounds. constant = 0 for the first 20 rounds of the loop, 1 for the next 20 rounds of the loop..., 3 for the last 20 rounds of the loop.

A non-constant value of constant may result in significantly worse performance for this operation.

Asm: SHA1RNDS4, CPU Feature: SHA

func (Uint32x4) SHA1Message1 

func (x Uint32x4) SHA1Message1(y Uint32x4) Uint32x4

SHA1Message1 does the XORing of 1 in SHA1 algorithm defined in FIPS 180-4. x = {W3, W2, W1, W0} y = {0, 0, W5, W4} result = {W3^W5, W2^W4, W1^W3, W0^W2}.

Asm: SHA1MSG1, CPU Feature: SHA

func (Uint32x4) SHA1Message2 

func (x Uint32x4) SHA1Message2(y Uint32x4) Uint32x4

SHA1Message2 does the calculation of 3 and 4 in SHA1 algorithm defined in FIPS 180-4. x = result of 2. y = {W15, W14, W13} result = {W19, W18, W17, W16}

Asm: SHA1MSG2, CPU Feature: SHA

func (Uint32x4) SHA1NextE 

func (x Uint32x4) SHA1NextE(y Uint32x4) Uint32x4

SHA1NextE calculates the state variable e' updated after 4 rounds in SHA1 algorithm defined in FIPS 180-4. x contains the state variable a (before the 4 rounds), placed in the upper element. y is the elements of W array for next 4 rounds from upper to lower order. result = the elements of the W array for the next 4 rounds, with the updated state variable e' added to the upper element, from upper to lower order. For the last round of the loop, you can specify zero for y to obtain the e' value itself, or better off specifying H4:0:0:0 for y to get e' added to H4. (Note that the value of e' is computed only from x, and values of y don't affect the computation of the value of e'.)

Asm: SHA1NEXTE, CPU Feature: SHA

func (Uint32x4) SHA256Message1 

func (x Uint32x4) SHA256Message1(y Uint32x4) Uint32x4

SHA256Message1 does the sigma and addition of 1 in SHA256 algorithm defined in FIPS 180-4. x = {W0, W1, W2, W3} y = {W4, 0, 0, 0} result = {W0+σ(W1), W1+σ(W2), W2+σ(W3), W3+σ(W4)}

Asm: SHA256MSG1, CPU Feature: SHA

func (Uint32x4) SHA256Message2 

func (x Uint32x4) SHA256Message2(y Uint32x4) Uint32x4

SHA256Message2 does the sigma and addition of 3 in SHA256 algorithm defined in FIPS 180-4. x = result of 2 y = {0, 0, W14, W15} result = {W16, W17, W18, W19}

Asm: SHA256MSG2, CPU Feature: SHA

func (Uint32x4) SHA256TwoRounds 

func (x Uint32x4) SHA256TwoRounds(y Uint32x4, z Uint32x4) Uint32x4

SHA256TwoRounds does 2 rounds of B loop to calculate updated state variables in SHA256 algorithm defined in FIPS 180-4. x = {h, g, d, c} y = {f, e, b, a} z = {W0+K0, W1+K1} result = {f', e', b', a'} The K array is a 64-DWORD constant array defined in page 11 of FIPS 180-4. Each element of the K array is to be added to the corresponding element of the W array to make the input data z. The updated state variables c', d', g', h' are not returned by this instruction, because they are equal to the input data y (the state variables a, b, e, f before the 2 rounds).

Asm: SHA256RNDS2, CPU Feature: SHA

func (Uint32x4) SaturateToUint8 

func (x Uint32x4) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSDB, CPU Feature: AVX512

func (Uint32x4) SaturateToUint16 

func (x Uint32x4) SaturateToUint16() Uint16x8

SaturateToUint16 converts element values to uint16 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSDW, CPU Feature: AVX512

func (Uint32x4) SetElem 

func (x Uint32x4) SetElem(index uint8, y uint32) Uint32x4

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRD, CPU Feature: AVX

func (Uint32x4) ShiftAllLeft 

func (x Uint32x4) ShiftAllLeft(shift uint64) Uint32x4

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX

func (Uint32x4) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Uint32x4) ShiftAllLeftConcatMod32(y Uint32x4, shift uint64) Uint32x4

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Uint32x4) ShiftAllRight 

func (x Uint32x4) ShiftAllRight(shift uint64) Uint32x4

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLD, CPU Feature: AVX

func (Uint32x4) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Uint32x4) ShiftAllRightConcatMod32(y Uint32x4, shift uint64) Uint32x4

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Uint32x4) ShiftLeft 

func (x Uint32x4) ShiftLeft(shift Uint32x4) Uint32x4

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX2

func (Uint32x4) ShiftLeftConcatMod32 added in go1.27.0 

func (x Uint32x4) ShiftLeftConcatMod32(y Uint32x4, shift Uint32x4) Uint32x4

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Uint32x4) ShiftRight 

func (x Uint32x4) ShiftRight(shift Uint32x4) Uint32x4

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVD, CPU Feature: AVX2

func (Uint32x4) ShiftRightConcatMod32 added in go1.27.0 

func (x Uint32x4) ShiftRightConcatMod32(y Uint32x4, shift Uint32x4) Uint32x4

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Uint32x4) Store 

func (x Uint32x4) Store(s []uint32)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Uint32x4) StoreArray added in go1.27.0 

func (x Uint32x4) StoreArray(y *[4]uint32)

StoreArray stores a Uint32x4 to an array.

func (Uint32x4) StoreArrayMasked added in go1.27.0 

func (x Uint32x4) StoreArrayMasked(y *[4]uint32, mask Mask32x4)

StoreArrayMasked stores a Uint32x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Uint32x4) StorePart added in go1.27.0 

func (x Uint32x4) StorePart(s []uint32) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Uint32x4) String 

func (x Uint32x4) String() string

String returns a string representation of SIMD vector x.

func (Uint32x4) Sub 

func (x Uint32x4) Sub(y Uint32x4) Uint32x4

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX

func (Uint32x4) TruncToUint8 added in go1.27.0 

func (x Uint32x4) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDB, CPU Feature: AVX512

func (Uint32x4) TruncToUint16 added in go1.27.0 

func (x Uint32x4) TruncToUint16() Uint16x8

TruncToUint16 truncates element values to uint16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDW, CPU Feature: AVX512

func (Uint32x4) Xor 

func (x Uint32x4) Xor(y Uint32x4) Uint32x4

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Uint32x8 

type Uint32x8 struct {
	// contains filtered or unexported fields
}

Uint32x8 is a 256-bit SIMD vector of 8 uint32s.

func BroadcastUint32x8 

func BroadcastUint32x8(x uint32) Uint32x8

BroadcastUint32x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint32x8 

func LoadUint32x8(s []uint32) Uint32x8

LoadUint32x8 loads an Uint32x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadUint32x8Array added in go1.27.0 

func LoadUint32x8Array(y *[8]uint32) Uint32x8

LoadUint32x8Array loads a Uint32x8 from an array.

func LoadUint32x8Part added in go1.27.0 

func LoadUint32x8Part(s []uint32) (Uint32x8, int)

LoadUint32x8Part loads a Uint32x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadUint32x8.

func (Uint32x8) Add 

func (x Uint32x8) Add(y Uint32x8) Uint32x8

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX2

func (Uint32x8) And 

func (x Uint32x8) And(y Uint32x8) Uint32x8

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Uint32x8) AndNot 

func (x Uint32x8) AndNot(y Uint32x8) Uint32x8

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Uint32x8) AsFloat32x8 deprecated 

func (x Uint32x8) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Uint32x8 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsFloat64x4 deprecated 

func (x Uint32x8) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Uint32x8 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsInt8x32 deprecated 

func (x Uint32x8) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Uint32x8 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsInt16x16 deprecated 

func (x Uint32x8) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Uint32x8 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsInt32x8 deprecated 

func (x Uint32x8) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Uint32x8 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsInt64x4 deprecated 

func (x Uint32x8) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Uint32x8 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsUint8x32 deprecated 

func (x Uint32x8) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Uint32x8 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsUint16x16 deprecated 

func (x Uint32x8) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Uint32x8 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) AsUint64x4 deprecated 

func (x Uint32x8) AsUint64x4() Uint64x4

AsUint64x4 reinterprets the bits of a Uint32x8 vector as a Uint64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x8) BitsToFloat32 added in go1.27.0 

func (x Uint32x8) BitsToFloat32() Float32x8

BitsToFloat32 reinterprets the bits of a Uint32x8 vector as a Float32x8 vector

func (Uint32x8) BitsToInt32 added in go1.27.0 

func (x Uint32x8) BitsToInt32() Int32x8

BitsToInt32 reinterprets the bits of a Uint32x8 vector as a Int32x8 vector

func (Uint32x8) Compress 

func (x Uint32x8) Compress(mask Mask32x8) Uint32x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Uint32x8) ConcatAddPairsGrouped added in go1.27.0 

func (x Uint32x8) ConcatAddPairsGrouped(y Uint32x8) Uint32x8

ConcatAddPairsGrouped horizontally adds adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].

Asm: VPHADDD, CPU Feature: AVX2

func (Uint32x8) ConcatPermute 

func (x Uint32x8) ConcatPermute(y Uint32x8, indices Uint32x8) Uint32x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Uint32x8) ConcatPermute128Scalars added in go1.27.0 

func (x Uint32x8) ConcatPermute128Scalars(lo, hi uint8, y Uint32x8) Uint32x8

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 42, 43, 50, 51, 52, 53}.ConcatPermute128Scalars(3, 0, {60, 61, 62, 63, 70, 71, 72, 73})

returns {70, 71, 72, 73, 40, 41, 42, 43}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Uint32x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Uint32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two. a is the source index of the least element in the output, and b, c, and d are the indices of the 2nd, 3rd, and 4th elements in the output. For example, 

{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})

returns {4,8,25,81,64,128,169,289}.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX

func (Uint32x8) ConcatSubPairsGrouped added in go1.27.0 

func (x Uint32x8) ConcatSubPairsGrouped(y Uint32x8) Uint32x8

ConcatSubPairsGrouped horizontally subtracts adjacent pairs of elements. With each 128-bit as a group: for x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0-x1, x2-x3, ..., y0-y1, y2-y3, ...].

Asm: VPHSUBD, CPU Feature: AVX2

func (Uint32x8) ConvertToFloat32 

func (x Uint32x8) ConvertToFloat32() Float32x8

ConvertToFloat32 converts element values to float32.

Asm: VCVTUDQ2PS, CPU Feature: AVX512

func (Uint32x8) ConvertToFloat64 

func (x Uint32x8) ConvertToFloat64() Float64x8

ConvertToFloat64 converts element values to float64.

Asm: VCVTUDQ2PD, CPU Feature: AVX512

func (Uint32x8) ConvertToInt32 added in go1.27.0 

func (x Uint32x8) ConvertToInt32() Int32x8

ConvertToInt32 converts a Uint32x8 vector to a Int32x8 vector

func (Uint32x8) Equal 

func (x Uint32x8) Equal(y Uint32x8) Mask32x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX2

func (Uint32x8) Expand 

func (x Uint32x8) Expand(mask Mask32x8) Uint32x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Uint32x8) ExtendToUint64 

func (x Uint32x8) ExtendToUint64() Uint64x8

ExtendToUint64 zero-extends element values to uint64.

Asm: VPMOVZXDQ, CPU Feature: AVX512

func (Uint32x8) GetHi 

func (x Uint32x8) GetHi() Uint32x4

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint32x8) GetLo 

func (x Uint32x8) GetLo() Uint32x4

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint32x8) Greater 

func (x Uint32x8) Greater(y Uint32x8) Mask32x8

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX2

func (Uint32x8) GreaterEqual 

func (x Uint32x8) GreaterEqual(y Uint32x8) Mask32x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Uint32x8) IfElse added in go1.27.0 

func (x Uint32x8) IfElse(mask Mask32x8, y Uint32x8) Uint32x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Uint32x8) InterleaveHiGrouped 

func (x Uint32x8) InterleaveHiGrouped(y Uint32x8) Uint32x8

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX2

func (Uint32x8) InterleaveLoGrouped 

func (x Uint32x8) InterleaveLoGrouped(y Uint32x8) Uint32x8

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX2

func (Uint32x8) IsZero 

func (x Uint32x8) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint32x8) LeadingZeros 

func (x Uint32x8) LeadingZeros() Uint32x8

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Uint32x8) Len 

func (x Uint32x8) Len() int

Len returns the number of elements in a Uint32x8.

func (Uint32x8) Less 

func (x Uint32x8) Less(y Uint32x8) Mask32x8

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Uint32x8) LessEqual 

func (x Uint32x8) LessEqual(y Uint32x8) Mask32x8

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Uint32x8) Masked 

func (x Uint32x8) Masked(mask Mask32x8) Uint32x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Uint32x8) Max 

func (x Uint32x8) Max(y Uint32x8) Uint32x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUD, CPU Feature: AVX2

func (Uint32x8) Merge deprecated 

func (x Uint32x8) Merge(y Uint32x8, mask Mask32x8) Uint32x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Uint32x8) Min 

func (x Uint32x8) Min(y Uint32x8) Uint32x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUD, CPU Feature: AVX2

func (Uint32x8) Mul 

func (x Uint32x8) Mul(y Uint32x8) Uint32x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX2

func (Uint32x8) MulWidenEven added in go1.27.0 

func (x Uint32x8) MulWidenEven(y Uint32x8) Uint64x4

MulWidenEven multiplies even-indexed elements, widening the result. Result[i] = v1[2*i] * v2[2*i].

Asm: VPMULUDQ, CPU Feature: AVX2

func (Uint32x8) Not 

func (x Uint32x8) Not() Uint32x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Uint32x8) NotEqual 

func (x Uint32x8) NotEqual(y Uint32x8) Mask32x8

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Uint32x8) OnesCount 

func (x Uint32x8) OnesCount() Uint32x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Uint32x8) Or 

func (x Uint32x8) Or(y Uint32x8) Uint32x8

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Uint32x8) Permute 

func (x Uint32x8) Permute(indices Uint32x8) Uint32x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMD, CPU Feature: AVX2

func (Uint32x8) PermuteScalarsGrouped 

func (x Uint32x8) PermuteScalarsGrouped(a, b, c, d uint8) Uint32x8

PermuteScalarsGrouped performs a grouped permutation of vector x using the supplied indices: 

result = {x[a], x[b], x[c], x[d], x[a+4], x[b+4], x[c+4], x[d+4]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFD, CPU Feature: AVX2

func (Uint32x8) ReshapeToUint8s added in go1.27.0 

func (x Uint32x8) ReshapeToUint8s() Uint8x32

ReshapeToUint8s reinterprets the bits of a Uint32x8 vector as a Uint8x32 vector

func (Uint32x8) ReshapeToUint16s added in go1.27.0 

func (x Uint32x8) ReshapeToUint16s() Uint16x16

ReshapeToUint16s reinterprets the bits of a Uint32x8 vector as a Uint16x16 vector

func (Uint32x8) ReshapeToUint64s added in go1.27.0 

func (x Uint32x8) ReshapeToUint64s() Uint64x4

ReshapeToUint64s reinterprets the bits of a Uint32x8 vector as a Uint64x4 vector

func (Uint32x8) RotateAllLeft 

func (x Uint32x8) RotateAllLeft(dist uint64) Uint32x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint32x8) RotateAllRight 

func (x Uint32x8) RotateAllRight(dist uint64) Uint32x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint32x8) RotateLeft 

func (x Uint32x8) RotateLeft(y Uint32x8) Uint32x8

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Uint32x8) RotateRight 

func (x Uint32x8) RotateRight(y Uint32x8) Uint32x8

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Uint32x8) SaturateToUint8 

func (x Uint32x8) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSDB, CPU Feature: AVX512

func (Uint32x8) SaturateToUint16 

func (x Uint32x8) SaturateToUint16() Uint16x8

SaturateToUint16 converts element values to uint16 with unsigned saturation.

Asm: VPMOVUSDW, CPU Feature: AVX512

func (Uint32x8) SetHi 

func (x Uint32x8) SetHi(y Uint32x4) Uint32x8

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint32x8) SetLo 

func (x Uint32x8) SetLo(y Uint32x4) Uint32x8

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint32x8) ShiftAllLeft 

func (x Uint32x8) ShiftAllLeft(shift uint64) Uint32x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX2

func (Uint32x8) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Uint32x8) ShiftAllLeftConcatMod32(y Uint32x8, shift uint64) Uint32x8

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Uint32x8) ShiftAllRight 

func (x Uint32x8) ShiftAllRight(shift uint64) Uint32x8

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLD, CPU Feature: AVX2

func (Uint32x8) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Uint32x8) ShiftAllRightConcatMod32(y Uint32x8, shift uint64) Uint32x8

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Uint32x8) ShiftLeft 

func (x Uint32x8) ShiftLeft(shift Uint32x8) Uint32x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX2

func (Uint32x8) ShiftLeftConcatMod32 added in go1.27.0 

func (x Uint32x8) ShiftLeftConcatMod32(y Uint32x8, shift Uint32x8) Uint32x8

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Uint32x8) ShiftRight 

func (x Uint32x8) ShiftRight(shift Uint32x8) Uint32x8

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVD, CPU Feature: AVX2

func (Uint32x8) ShiftRightConcatMod32 added in go1.27.0 

func (x Uint32x8) ShiftRightConcatMod32(y Uint32x8, shift Uint32x8) Uint32x8

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Uint32x8) Store 

func (x Uint32x8) Store(s []uint32)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Uint32x8) StoreArray added in go1.27.0 

func (x Uint32x8) StoreArray(y *[8]uint32)

StoreArray stores a Uint32x8 to an array.

func (Uint32x8) StoreArrayMasked added in go1.27.0 

func (x Uint32x8) StoreArrayMasked(y *[8]uint32, mask Mask32x8)

StoreArrayMasked stores a Uint32x8 to an array, at those elements enabled by mask.

Asm: VMASKMOVD, CPU Feature: AVX2

func (Uint32x8) StorePart added in go1.27.0 

func (x Uint32x8) StorePart(s []uint32) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Uint32x8) String 

func (x Uint32x8) String() string

String returns a string representation of SIMD vector x.

func (Uint32x8) Sub 

func (x Uint32x8) Sub(y Uint32x8) Uint32x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX2

func (Uint32x8) TruncToUint8 added in go1.27.0 

func (x Uint32x8) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVDB, CPU Feature: AVX512

func (Uint32x8) TruncToUint16 added in go1.27.0 

func (x Uint32x8) TruncToUint16() Uint16x8

TruncToUint16 truncates element values to uint16.

Asm: VPMOVDW, CPU Feature: AVX512

func (Uint32x8) Xor 

func (x Uint32x8) Xor(y Uint32x8) Uint32x8

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Uint32x16 

type Uint32x16 struct {
	// contains filtered or unexported fields
}

Uint32x16 is a 512-bit SIMD vector of 16 uint32s.

func BroadcastUint32x16 

func BroadcastUint32x16(x uint32) Uint32x16

BroadcastUint32x16 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadUint32x16 

func LoadUint32x16(s []uint32) Uint32x16

LoadUint32x16 loads an Uint32x16 from a slice of elements. If s does not have at least 16 elements, it panics.

func LoadUint32x16Array added in go1.27.0 

func LoadUint32x16Array(y *[16]uint32) Uint32x16

LoadUint32x16Array loads a Uint32x16 from an array.

func LoadUint32x16Part added in go1.27.0 

func LoadUint32x16Part(s []uint32) (Uint32x16, int)

LoadUint32x16Part loads a Uint32x16 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes. If s has 16 or more elements, the function is equivalent to LoadUint32x16.

func (Uint32x16) Add 

func (x Uint32x16) Add(y Uint32x16) Uint32x16

Add adds corresponding elements of two vectors.

Asm: VPADDD, CPU Feature: AVX512

func (Uint32x16) And 

func (x Uint32x16) And(y Uint32x16) Uint32x16

And performs a bitwise x & y.

Asm: VPANDD, CPU Feature: AVX512

func (Uint32x16) AndNot 

func (x Uint32x16) AndNot(y Uint32x16) Uint32x16

AndNot performs a bitwise x &^ y.

Asm: VPANDND, CPU Feature: AVX512

func (Uint32x16) AsFloat32x16 deprecated 

func (x Uint32x16) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Uint32x16 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsFloat64x8 deprecated 

func (x Uint32x16) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Uint32x16 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsInt8x64 deprecated 

func (x Uint32x16) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Uint32x16 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsInt16x32 deprecated 

func (x Uint32x16) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Uint32x16 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsInt32x16 deprecated 

func (x Uint32x16) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Uint32x16 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsInt64x8 deprecated 

func (x Uint32x16) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Uint32x16 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsUint8x64 deprecated 

func (x Uint32x16) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Uint32x16 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsUint16x32 deprecated 

func (x Uint32x16) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Uint32x16 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) AsUint64x8 deprecated 

func (x Uint32x16) AsUint64x8() Uint64x8

AsUint64x8 reinterprets the bits of a Uint32x16 vector as a Uint64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint32x16) BitsToFloat32 added in go1.27.0 

func (x Uint32x16) BitsToFloat32() Float32x16

BitsToFloat32 reinterprets the bits of a Uint32x16 vector as a Float32x16 vector

func (Uint32x16) BitsToInt32 added in go1.27.0 

func (x Uint32x16) BitsToInt32() Int32x16

BitsToInt32 reinterprets the bits of a Uint32x16 vector as a Int32x16 vector

func (Uint32x16) Compress 

func (x Uint32x16) Compress(mask Mask32x16) Uint32x16

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSD, CPU Feature: AVX512

func (Uint32x16) ConcatPermute 

func (x Uint32x16) ConcatPermute(y Uint32x16, indices Uint32x16) Uint32x16

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2D, CPU Feature: AVX512

func (Uint32x16) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Uint32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Uint32x16) Uint32x16

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of four elements from x and y, where selector values in the range 0-3 specify elements from x and values in the range 4-7 specify the 0-3 elements of y. When the selectors are constants and can be the selection can be implemented in a single instruction, it will be, otherwise it requires two.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPS, CPU Feature: AVX512

func (Uint32x16) ConvertToFloat32 

func (x Uint32x16) ConvertToFloat32() Float32x16

ConvertToFloat32 converts element values to float32.

Asm: VCVTUDQ2PS, CPU Feature: AVX512

func (Uint32x16) ConvertToInt32 added in go1.27.0 

func (x Uint32x16) ConvertToInt32() Int32x16

ConvertToInt32 converts a Uint32x16 vector to a Int32x16 vector

func (Uint32x16) Equal 

func (x Uint32x16) Equal(y Uint32x16) Mask32x16

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQD, CPU Feature: AVX512

func (Uint32x16) Expand 

func (x Uint32x16) Expand(mask Mask32x16) Uint32x16

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDD, CPU Feature: AVX512

func (Uint32x16) GetHi 

func (x Uint32x16) GetHi() Uint32x8

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint32x16) GetLo 

func (x Uint32x16) GetLo() Uint32x8

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint32x16) Greater 

func (x Uint32x16) Greater(y Uint32x16) Mask32x16

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPUD, CPU Feature: AVX512

func (Uint32x16) GreaterEqual 

func (x Uint32x16) GreaterEqual(y Uint32x16) Mask32x16

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPUD, CPU Feature: AVX512

func (Uint32x16) IfElse added in go1.27.0 

func (x Uint32x16) IfElse(mask Mask32x16, y Uint32x16) Uint32x16

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Uint32x16) InterleaveHiGrouped 

func (x Uint32x16) InterleaveHiGrouped(y Uint32x16) Uint32x16

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHDQ, CPU Feature: AVX512

func (Uint32x16) InterleaveLoGrouped 

func (x Uint32x16) InterleaveLoGrouped(y Uint32x16) Uint32x16

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLDQ, CPU Feature: AVX512

func (Uint32x16) LeadingZeros 

func (x Uint32x16) LeadingZeros() Uint32x16

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTD, CPU Feature: AVX512

func (Uint32x16) Len 

func (x Uint32x16) Len() int

Len returns the number of elements in a Uint32x16.

func (Uint32x16) Less 

func (x Uint32x16) Less(y Uint32x16) Mask32x16

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPUD, CPU Feature: AVX512

func (Uint32x16) LessEqual 

func (x Uint32x16) LessEqual(y Uint32x16) Mask32x16

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPUD, CPU Feature: AVX512

func (Uint32x16) Masked 

func (x Uint32x16) Masked(mask Mask32x16) Uint32x16

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Uint32x16) Max 

func (x Uint32x16) Max(y Uint32x16) Uint32x16

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUD, CPU Feature: AVX512

func (Uint32x16) Merge deprecated 

func (x Uint32x16) Merge(y Uint32x16, mask Mask32x16) Uint32x16

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Uint32x16) Min 

func (x Uint32x16) Min(y Uint32x16) Uint32x16

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUD, CPU Feature: AVX512

func (Uint32x16) Mul 

func (x Uint32x16) Mul(y Uint32x16) Uint32x16

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLD, CPU Feature: AVX512

func (Uint32x16) Not 

func (x Uint32x16) Not() Uint32x16

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Uint32x16) NotEqual 

func (x Uint32x16) NotEqual(y Uint32x16) Mask32x16

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPUD, CPU Feature: AVX512

func (Uint32x16) OnesCount 

func (x Uint32x16) OnesCount() Uint32x16

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTD, CPU Feature: AVX512VPOPCNTDQ

func (Uint32x16) Or 

func (x Uint32x16) Or(y Uint32x16) Uint32x16

Or performs a bitwise x | y.

Asm: VPORD, CPU Feature: AVX512

func (Uint32x16) Permute 

func (x Uint32x16) Permute(indices Uint32x16) Uint32x16

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMD, CPU Feature: AVX512

func (Uint32x16) PermuteScalarsGrouped 

func (x Uint32x16) PermuteScalarsGrouped(a, b, c, d uint8) Uint32x16

PermuteScalarsGrouped performs a grouped permutation of vector x using the supplied indices: 

 result =
	 {  x[a], x[b], x[c], x[d],         x[a+4], x[b+4], x[c+4], x[d+4],
		x[a+8], x[b+8], x[c+8], x[d+8], x[a+12], x[b+12], x[c+12], x[d+12]}

Parameters a,b,c,d should have values between 0 and 3. If a through d are constants, then an instruction will be inlined, otherwise a jump table is generated.

Asm: VPSHUFD, CPU Feature: AVX512

func (Uint32x16) ReshapeToUint8s added in go1.27.0 

func (x Uint32x16) ReshapeToUint8s() Uint8x64

ReshapeToUint8s reinterprets the bits of a Uint32x16 vector as a Uint8x64 vector

func (Uint32x16) ReshapeToUint16s added in go1.27.0 

func (x Uint32x16) ReshapeToUint16s() Uint16x32

ReshapeToUint16s reinterprets the bits of a Uint32x16 vector as a Uint16x32 vector

func (Uint32x16) ReshapeToUint64s added in go1.27.0 

func (x Uint32x16) ReshapeToUint64s() Uint64x8

ReshapeToUint64s reinterprets the bits of a Uint32x16 vector as a Uint64x8 vector

func (Uint32x16) RotateAllLeft 

func (x Uint32x16) RotateAllLeft(dist uint64) Uint32x16

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint32x16) RotateAllRight 

func (x Uint32x16) RotateAllRight(dist uint64) Uint32x16

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint32x16) RotateLeft 

func (x Uint32x16) RotateLeft(y Uint32x16) Uint32x16

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVD, CPU Feature: AVX512

func (Uint32x16) RotateRight 

func (x Uint32x16) RotateRight(y Uint32x16) Uint32x16

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVD, CPU Feature: AVX512

func (Uint32x16) SaturateToUint8 

func (x Uint32x16) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation.

Asm: VPMOVUSDB, CPU Feature: AVX512

func (Uint32x16) SaturateToUint16 

func (x Uint32x16) SaturateToUint16() Uint16x16

SaturateToUint16 converts element values to uint16 with unsigned saturation.

Asm: VPMOVUSDW, CPU Feature: AVX512

func (Uint32x16) SetHi 

func (x Uint32x16) SetHi(y Uint32x8) Uint32x16

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint32x16) SetLo 

func (x Uint32x16) SetLo(y Uint32x8) Uint32x16

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint32x16) ShiftAllLeft 

func (x Uint32x16) ShiftAllLeft(shift uint64) Uint32x16

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLD, CPU Feature: AVX512

func (Uint32x16) ShiftAllLeftConcatMod32 added in go1.27.0 

func (x Uint32x16) ShiftAllLeftConcatMod32(y Uint32x16, shift uint64) Uint32x16

ShiftAllLeftConcatMod32 shifts x[i] left by shift%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDD, CPU Feature: AVX512VBMI2

func (Uint32x16) ShiftAllRight 

func (x Uint32x16) ShiftAllRight(shift uint64) Uint32x16

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLD, CPU Feature: AVX512

func (Uint32x16) ShiftAllRightConcatMod32 added in go1.27.0 

func (x Uint32x16) ShiftAllRightConcatMod32(y Uint32x16, shift uint64) Uint32x16

ShiftAllRightConcatMod32 shifts x[i] right by shift%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%32)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDD, CPU Feature: AVX512VBMI2

func (Uint32x16) ShiftLeft 

func (x Uint32x16) ShiftLeft(shift Uint32x16) Uint32x16

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVD, CPU Feature: AVX512

func (Uint32x16) ShiftLeftConcatMod32 added in go1.27.0 

func (x Uint32x16) ShiftLeftConcatMod32(y Uint32x16, shift Uint32x16) Uint32x16

ShiftLeftConcatMod32 shifts x[i] left by shift[i]%32, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%32)

Asm: VPSHLDVD, CPU Feature: AVX512VBMI2

func (Uint32x16) ShiftRight 

func (x Uint32x16) ShiftRight(shift Uint32x16) Uint32x16

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVD, CPU Feature: AVX512

func (Uint32x16) ShiftRightConcatMod32 added in go1.27.0 

func (x Uint32x16) ShiftRightConcatMod32(y Uint32x16, shift Uint32x16) Uint32x16

ShiftRightConcatMod32 shifts x[i] right by shift[i]%32, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%32)

Asm: VPSHRDVD, CPU Feature: AVX512VBMI2

func (Uint32x16) Store 

func (x Uint32x16) Store(s []uint32)

Store stores the elements of x into a slice. If s does not have at least 16 elements, it panics.

func (Uint32x16) StoreArray added in go1.27.0 

func (x Uint32x16) StoreArray(y *[16]uint32)

StoreArray stores a Uint32x16 to an array.

func (Uint32x16) StoreArrayMasked added in go1.27.0 

func (x Uint32x16) StoreArrayMasked(y *[16]uint32, mask Mask32x16)

StoreArrayMasked stores a Uint32x16 to an array, at those elements enabled by mask.

Asm: VMOVDQU32, CPU Feature: AVX512

func (Uint32x16) StorePart added in go1.27.0 

func (x Uint32x16) StorePart(s []uint32) int

StorePart stores the 16 elements of x into the slice s. It stores as many elements as will fit in s. If s has 16 or more elements, the method is equivalent to x.Store.

func (Uint32x16) String 

func (x Uint32x16) String() string

String returns a string representation of SIMD vector x.

func (Uint32x16) Sub 

func (x Uint32x16) Sub(y Uint32x16) Uint32x16

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBD, CPU Feature: AVX512

func (Uint32x16) TruncToUint8 added in go1.27.0 

func (x Uint32x16) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8.

Asm: VPMOVDB, CPU Feature: AVX512

func (Uint32x16) TruncToUint16 added in go1.27.0 

func (x Uint32x16) TruncToUint16() Uint16x16

TruncToUint16 truncates element values to uint16.

Asm: VPMOVDW, CPU Feature: AVX512

func (Uint32x16) Xor 

func (x Uint32x16) Xor(y Uint32x16) Uint32x16

Xor performs a bitwise x ^ y.

Asm: VPXORD, CPU Feature: AVX512

type Uint64x2 

type Uint64x2 struct {
	// contains filtered or unexported fields
}

Uint64x2 is a 128-bit SIMD vector of 2 uint64s.

func BroadcastUint64x2 

func BroadcastUint64x2(x uint64) Uint64x2

BroadcastUint64x2 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint64x2 

func LoadUint64x2(s []uint64) Uint64x2

LoadUint64x2 loads an Uint64x2 from a slice of elements. If s does not have at least 2 elements, it panics.

func LoadUint64x2Array added in go1.27.0 

func LoadUint64x2Array(y *[2]uint64) Uint64x2

LoadUint64x2Array loads a Uint64x2 from an array.

func LoadUint64x2Part added in go1.27.0 

func LoadUint64x2Part(s []uint64) (Uint64x2, int)

LoadUint64x2Part loads a Uint64x2 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes. If s has 2 or more elements, the function is equivalent to LoadUint64x2.

func (Uint64x2) Add 

func (x Uint64x2) Add(y Uint64x2) Uint64x2

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX

func (Uint64x2) And 

func (x Uint64x2) And(y Uint64x2) Uint64x2

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX

func (Uint64x2) AndNot 

func (x Uint64x2) AndNot(y Uint64x2) Uint64x2

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX

func (Uint64x2) AsFloat32x4 deprecated 

func (x Uint64x2) AsFloat32x4() Float32x4

AsFloat32x4 reinterprets the bits of a Uint64x2 vector as a Float32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsFloat64x2 deprecated 

func (x Uint64x2) AsFloat64x2() Float64x2

AsFloat64x2 reinterprets the bits of a Uint64x2 vector as a Float64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsInt8x16 deprecated 

func (x Uint64x2) AsInt8x16() Int8x16

AsInt8x16 reinterprets the bits of a Uint64x2 vector as a Int8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsInt16x8 deprecated 

func (x Uint64x2) AsInt16x8() Int16x8

AsInt16x8 reinterprets the bits of a Uint64x2 vector as a Int16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsInt32x4 deprecated 

func (x Uint64x2) AsInt32x4() Int32x4

AsInt32x4 reinterprets the bits of a Uint64x2 vector as a Int32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsInt64x2 deprecated 

func (x Uint64x2) AsInt64x2() Int64x2

AsInt64x2 reinterprets the bits of a Uint64x2 vector as a Int64x2 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsUint8x16 deprecated 

func (x Uint64x2) AsUint8x16() Uint8x16

AsUint8x16 reinterprets the bits of a Uint64x2 vector as a Uint8x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsUint16x8 deprecated 

func (x Uint64x2) AsUint16x8() Uint16x8

AsUint16x8 reinterprets the bits of a Uint64x2 vector as a Uint16x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) AsUint32x4 deprecated 

func (x Uint64x2) AsUint32x4() Uint32x4

AsUint32x4 reinterprets the bits of a Uint64x2 vector as a Uint32x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x2) BitsToFloat64 added in go1.27.0 

func (x Uint64x2) BitsToFloat64() Float64x2

BitsToFloat64 reinterprets the bits of a Uint64x2 vector as a Float64x2 vector

func (Uint64x2) BitsToInt64 added in go1.27.0 

func (x Uint64x2) BitsToInt64() Int64x2

BitsToInt64 reinterprets the bits of a Uint64x2 vector as a Int64x2 vector

func (Uint64x2) CarrylessMultiplyEven added in go1.27.0 

func (x Uint64x2) CarrylessMultiplyEven(y Uint64x2) Uint64x2

CarrylessMultiplyEven computes the carryless multiplications of selected even halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX

func (Uint64x2) CarrylessMultiplyEvenOdd added in go1.27.0 

func (x Uint64x2) CarrylessMultiplyEvenOdd(y Uint64x2) Uint64x2

CarrylessMultiplyEvenOdd computes the carryless multiplications of selected even half of x's elements and odd half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX

func (Uint64x2) CarrylessMultiplyOdd added in go1.27.0 

func (x Uint64x2) CarrylessMultiplyOdd(y Uint64x2) Uint64x2

CarrylessMultiplyOdd computes the carryless multiplications of selected odd halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX

func (Uint64x2) CarrylessMultiplyOddEven added in go1.27.0 

func (x Uint64x2) CarrylessMultiplyOddEven(y Uint64x2) Uint64x2

CarrylessMultiplyOddEven computes the carryless multiplications of selected odd half of x's elements and even half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX

func (Uint64x2) Compress 

func (x Uint64x2) Compress(mask Mask64x2) Uint64x2

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Uint64x2) ConcatPermute 

func (x Uint64x2) ConcatPermute(y Uint64x2, indices Uint64x2) Uint64x2

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Uint64x2) ConcatPermuteScalars added in go1.27.0 

func (x Uint64x2) ConcatPermuteScalars(a, b uint8, y Uint64x2) Uint64x2

ConcatPermuteScalars returns the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Uint64x2) ConvertToFloat32 

func (x Uint64x2) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTUQQ2PSX, CPU Feature: AVX512

func (Uint64x2) ConvertToFloat64 

func (x Uint64x2) ConvertToFloat64() Float64x2

ConvertToFloat64 converts element values to float64.

Asm: VCVTUQQ2PD, CPU Feature: AVX512

func (Uint64x2) ConvertToInt64 added in go1.27.0 

func (x Uint64x2) ConvertToInt64() Int64x2

ConvertToInt64 converts a Uint64x2 vector to a Int64x2 vector

func (Uint64x2) Equal 

func (x Uint64x2) Equal(y Uint64x2) Mask64x2

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX

func (Uint64x2) Expand 

func (x Uint64x2) Expand(mask Mask64x2) Uint64x2

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Uint64x2) GetElem 

func (x Uint64x2) GetElem(index uint8) uint64

GetElem returns the index'th element of x.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPEXTRQ, CPU Feature: AVX

func (Uint64x2) Greater 

func (x Uint64x2) Greater(y Uint64x2) Mask64x2

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX

func (Uint64x2) GreaterEqual 

func (x Uint64x2) GreaterEqual(y Uint64x2) Mask64x2

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX

func (Uint64x2) IfElse added in go1.27.0 

func (x Uint64x2) IfElse(mask Mask64x2, y Uint64x2) Uint64x2

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

func (Uint64x2) InterleaveHi 

func (x Uint64x2) InterleaveHi(y Uint64x2) Uint64x2

InterleaveHi interleaves the elements of the high halves of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX

func (Uint64x2) InterleaveLo 

func (x Uint64x2) InterleaveLo(y Uint64x2) Uint64x2

InterleaveLo interleaves the elements of the low halves of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX

func (Uint64x2) IsZero 

func (x Uint64x2) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint64x2) LeadingZeros 

func (x Uint64x2) LeadingZeros() Uint64x2

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Uint64x2) Len 

func (x Uint64x2) Len() int

Len returns the number of elements in a Uint64x2.

func (Uint64x2) Less 

func (x Uint64x2) Less(y Uint64x2) Mask64x2

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX

func (Uint64x2) LessEqual 

func (x Uint64x2) LessEqual(y Uint64x2) Mask64x2

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX

func (Uint64x2) Masked 

func (x Uint64x2) Masked(mask Mask64x2) Uint64x2

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX

func (Uint64x2) Max 

func (x Uint64x2) Max(y Uint64x2) Uint64x2

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUQ, CPU Feature: AVX512

func (Uint64x2) Merge deprecated 

func (x Uint64x2) Merge(y Uint64x2, mask Mask64x2) Uint64x2

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX

Deprecated: use x.IfElse(mask, y)

func (Uint64x2) Min 

func (x Uint64x2) Min(y Uint64x2) Uint64x2

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUQ, CPU Feature: AVX512

func (Uint64x2) Mul 

func (x Uint64x2) Mul(y Uint64x2) Uint64x2

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Uint64x2) Not 

func (x Uint64x2) Not() Uint64x2

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX

func (Uint64x2) NotEqual 

func (x Uint64x2) NotEqual(y Uint64x2) Mask64x2

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX

func (Uint64x2) OnesCount 

func (x Uint64x2) OnesCount() Uint64x2

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Uint64x2) Or 

func (x Uint64x2) Or(y Uint64x2) Uint64x2

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX

func (Uint64x2) ReshapeToUint8s added in go1.27.0 

func (x Uint64x2) ReshapeToUint8s() Uint8x16

ReshapeToUint8s reinterprets the bits of a Uint64x2 vector as a Uint8x16 vector

func (Uint64x2) ReshapeToUint16s added in go1.27.0 

func (x Uint64x2) ReshapeToUint16s() Uint16x8

ReshapeToUint16s reinterprets the bits of a Uint64x2 vector as a Uint16x8 vector

func (Uint64x2) ReshapeToUint32s added in go1.27.0 

func (x Uint64x2) ReshapeToUint32s() Uint32x4

ReshapeToUint32s reinterprets the bits of a Uint64x2 vector as a Uint32x4 vector

func (Uint64x2) RotateAllLeft 

func (x Uint64x2) RotateAllLeft(dist uint64) Uint64x2

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint64x2) RotateAllRight 

func (x Uint64x2) RotateAllRight(dist uint64) Uint64x2

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint64x2) RotateLeft 

func (x Uint64x2) RotateLeft(y Uint64x2) Uint64x2

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Uint64x2) RotateRight 

func (x Uint64x2) RotateRight(y Uint64x2) Uint64x2

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Uint64x2) SaturateToUint8 

func (x Uint64x2) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQB, CPU Feature: AVX512

func (Uint64x2) SaturateToUint16 

func (x Uint64x2) SaturateToUint16() Uint16x8

SaturateToUint16 converts element values to uint16 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQW, CPU Feature: AVX512

func (Uint64x2) SaturateToUint32 

func (x Uint64x2) SaturateToUint32() Uint32x4

SaturateToUint32 converts element values to uint32 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQD, CPU Feature: AVX512

func (Uint64x2) SetElem 

func (x Uint64x2) SetElem(index uint8, y uint64) Uint64x2

SetElem returns x with the index'th element set to y.

A non-constant value of index may result in significantly worse performance for this operation.

Asm: VPINSRQ, CPU Feature: AVX

func (Uint64x2) ShiftAllLeft 

func (x Uint64x2) ShiftAllLeft(shift uint64) Uint64x2

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX

func (Uint64x2) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Uint64x2) ShiftAllLeftConcatMod64(y Uint64x2, shift uint64) Uint64x2

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Uint64x2) ShiftAllRight 

func (x Uint64x2) ShiftAllRight(shift uint64) Uint64x2

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLQ, CPU Feature: AVX

func (Uint64x2) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Uint64x2) ShiftAllRightConcatMod64(y Uint64x2, shift uint64) Uint64x2

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Uint64x2) ShiftLeft 

func (x Uint64x2) ShiftLeft(shift Uint64x2) Uint64x2

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX2

func (Uint64x2) ShiftLeftConcatMod64 added in go1.27.0 

func (x Uint64x2) ShiftLeftConcatMod64(y Uint64x2, shift Uint64x2) Uint64x2

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Uint64x2) ShiftRight 

func (x Uint64x2) ShiftRight(shift Uint64x2) Uint64x2

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVQ, CPU Feature: AVX2

func (Uint64x2) ShiftRightConcatMod64 added in go1.27.0 

func (x Uint64x2) ShiftRightConcatMod64(y Uint64x2, shift Uint64x2) Uint64x2

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Uint64x2) Store 

func (x Uint64x2) Store(s []uint64)

Store stores the elements of x into a slice. If s does not have at least 2 elements, it panics.

func (Uint64x2) StoreArray added in go1.27.0 

func (x Uint64x2) StoreArray(y *[2]uint64)

StoreArray stores a Uint64x2 to an array.

func (Uint64x2) StoreArrayMasked added in go1.27.0 

func (x Uint64x2) StoreArrayMasked(y *[2]uint64, mask Mask64x2)

StoreArrayMasked stores a Uint64x2 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Uint64x2) StorePart added in go1.27.0 

func (x Uint64x2) StorePart(s []uint64) int

StorePart stores the 2 elements of x into the slice s. It stores as many elements as will fit in s. If s has 2 or more elements, the method is equivalent to x.Store.

func (Uint64x2) String 

func (x Uint64x2) String() string

String returns a string representation of SIMD vector x.

func (Uint64x2) Sub 

func (x Uint64x2) Sub(y Uint64x2) Uint64x2

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX

func (Uint64x2) TruncToUint8 added in go1.27.0 

func (x Uint64x2) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Uint64x2) TruncToUint16 added in go1.27.0 

func (x Uint64x2) TruncToUint16() Uint16x8

TruncToUint16 truncates element values to uint16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQW, CPU Feature: AVX512

func (Uint64x2) TruncToUint32 added in go1.27.0 

func (x Uint64x2) TruncToUint32() Uint32x4

TruncToUint32 truncates element values to uint32. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQD, CPU Feature: AVX512

func (Uint64x2) Xor 

func (x Uint64x2) Xor(y Uint64x2) Uint64x2

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX

type Uint64x4 

type Uint64x4 struct {
	// contains filtered or unexported fields
}

Uint64x4 is a 256-bit SIMD vector of 4 uint64s.

func BroadcastUint64x4 

func BroadcastUint64x4(x uint64) Uint64x4

BroadcastUint64x4 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX2

func LoadUint64x4 

func LoadUint64x4(s []uint64) Uint64x4

LoadUint64x4 loads an Uint64x4 from a slice of elements. If s does not have at least 4 elements, it panics.

func LoadUint64x4Array added in go1.27.0 

func LoadUint64x4Array(y *[4]uint64) Uint64x4

LoadUint64x4Array loads a Uint64x4 from an array.

func LoadUint64x4Part added in go1.27.0 

func LoadUint64x4Part(s []uint64) (Uint64x4, int)

LoadUint64x4Part loads a Uint64x4 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes. If s has 4 or more elements, the function is equivalent to LoadUint64x4.

func (Uint64x4) Add 

func (x Uint64x4) Add(y Uint64x4) Uint64x4

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX2

func (Uint64x4) And 

func (x Uint64x4) And(y Uint64x4) Uint64x4

And performs a bitwise x & y.

Asm: VPAND, CPU Feature: AVX2

func (Uint64x4) AndNot 

func (x Uint64x4) AndNot(y Uint64x4) Uint64x4

AndNot performs a bitwise x &^ y.

Asm: VPANDN, CPU Feature: AVX2

func (Uint64x4) AsFloat32x8 deprecated 

func (x Uint64x4) AsFloat32x8() Float32x8

AsFloat32x8 reinterprets the bits of a Uint64x4 vector as a Float32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsFloat64x4 deprecated 

func (x Uint64x4) AsFloat64x4() Float64x4

AsFloat64x4 reinterprets the bits of a Uint64x4 vector as a Float64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsInt8x32 deprecated 

func (x Uint64x4) AsInt8x32() Int8x32

AsInt8x32 reinterprets the bits of a Uint64x4 vector as a Int8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsInt16x16 deprecated 

func (x Uint64x4) AsInt16x16() Int16x16

AsInt16x16 reinterprets the bits of a Uint64x4 vector as a Int16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsInt32x8 deprecated 

func (x Uint64x4) AsInt32x8() Int32x8

AsInt32x8 reinterprets the bits of a Uint64x4 vector as a Int32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsInt64x4 deprecated 

func (x Uint64x4) AsInt64x4() Int64x4

AsInt64x4 reinterprets the bits of a Uint64x4 vector as a Int64x4 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsUint8x32 deprecated 

func (x Uint64x4) AsUint8x32() Uint8x32

AsUint8x32 reinterprets the bits of a Uint64x4 vector as a Uint8x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsUint16x16 deprecated 

func (x Uint64x4) AsUint16x16() Uint16x16

AsUint16x16 reinterprets the bits of a Uint64x4 vector as a Uint16x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) AsUint32x8 deprecated 

func (x Uint64x4) AsUint32x8() Uint32x8

AsUint32x8 reinterprets the bits of a Uint64x4 vector as a Uint32x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x4) BitsToFloat64 added in go1.27.0 

func (x Uint64x4) BitsToFloat64() Float64x4

BitsToFloat64 reinterprets the bits of a Uint64x4 vector as a Float64x4 vector

func (Uint64x4) BitsToInt64 added in go1.27.0 

func (x Uint64x4) BitsToInt64() Int64x4

BitsToInt64 reinterprets the bits of a Uint64x4 vector as a Int64x4 vector

func (Uint64x4) CarrylessMultiplyEven added in go1.27.0 

func (x Uint64x4) CarrylessMultiplyEven(y Uint64x4) Uint64x4

CarrylessMultiplyEven computes the carryless multiplications of selected even halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX2

func (Uint64x4) CarrylessMultiplyEvenOdd added in go1.27.0 

func (x Uint64x4) CarrylessMultiplyEvenOdd(y Uint64x4) Uint64x4

CarrylessMultiplyEvenOdd computes the carryless multiplications of selected even half of x's elements and odd half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX2

func (Uint64x4) CarrylessMultiplyOdd added in go1.27.0 

func (x Uint64x4) CarrylessMultiplyOdd(y Uint64x4) Uint64x4

CarrylessMultiplyOdd computes the carryless multiplications of selected odd halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX2

func (Uint64x4) CarrylessMultiplyOddEven added in go1.27.0 

func (x Uint64x4) CarrylessMultiplyOddEven(y Uint64x4) Uint64x4

CarrylessMultiplyOddEven computes the carryless multiplications of selected odd half of x's elements and even half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX2

func (Uint64x4) Compress 

func (x Uint64x4) Compress(mask Mask64x4) Uint64x4

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Uint64x4) ConcatPermute 

func (x Uint64x4) ConcatPermute(y Uint64x4, indices Uint64x4) Uint64x4

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Uint64x4) ConcatPermute128Scalars added in go1.27.0 

func (x Uint64x4) ConcatPermute128Scalars(lo, hi uint8, y Uint64x4) Uint64x4

ConcatPermute128Scalars treats the 256-bit vectors x and y as a single vector of four 128-bit elements, and returns a 256-bit result formed by concatenating the two elements specified by lo and hi. For example, 

{40, 41, 50, 51}.ConcatPermute128Scalars(3, 0, {60, 61, 70, 71})

returns {70, 71, 40, 41}.

lo, hi should be between 0 and 3, inclusive; other values may result in a runtime panic.

A non-constant value of lo, hi may result in significantly worse performance for this operation.

Asm: VPERM2I128, CPU Feature: AVX2

func (Uint64x4) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Uint64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Uint64x4) Uint64x4

ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX

func (Uint64x4) ConvertToFloat32 

func (x Uint64x4) ConvertToFloat32() Float32x4

ConvertToFloat32 converts element values to float32.

Asm: VCVTUQQ2PSY, CPU Feature: AVX512

func (Uint64x4) ConvertToFloat64 

func (x Uint64x4) ConvertToFloat64() Float64x4

ConvertToFloat64 converts element values to float64.

Asm: VCVTUQQ2PD, CPU Feature: AVX512

func (Uint64x4) ConvertToInt64 added in go1.27.0 

func (x Uint64x4) ConvertToInt64() Int64x4

ConvertToInt64 converts a Uint64x4 vector to a Int64x4 vector

func (Uint64x4) Equal 

func (x Uint64x4) Equal(y Uint64x4) Mask64x4

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX2

func (Uint64x4) Expand 

func (x Uint64x4) Expand(mask Mask64x4) Uint64x4

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Uint64x4) GetHi 

func (x Uint64x4) GetHi() Uint64x2

GetHi returns the upper half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint64x4) GetLo 

func (x Uint64x4) GetLo() Uint64x2

GetLo returns the lower half of x.

Asm: VEXTRACTI128, CPU Feature: AVX2

func (Uint64x4) Greater 

func (x Uint64x4) Greater(y Uint64x4) Mask64x4

Greater returns a mask whose elements indicate whether x > y.

Emulated, CPU Feature: AVX2

func (Uint64x4) GreaterEqual 

func (x Uint64x4) GreaterEqual(y Uint64x4) Mask64x4

GreaterEqual returns a mask whose elements indicate whether x >= y.

Emulated, CPU Feature: AVX2

func (Uint64x4) IfElse added in go1.27.0 

func (x Uint64x4) IfElse(mask Mask64x4, y Uint64x4) Uint64x4

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

func (Uint64x4) InterleaveHiGrouped 

func (x Uint64x4) InterleaveHiGrouped(y Uint64x4) Uint64x4

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX2

func (Uint64x4) InterleaveLoGrouped 

func (x Uint64x4) InterleaveLoGrouped(y Uint64x4) Uint64x4

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX2

func (Uint64x4) IsZero 

func (x Uint64x4) IsZero() bool

IsZero returns true if all elements of x are zeros.

This method compiles to VPTEST x, x. x.And(y).IsZero() and x.AndNot(y).IsZero() will be optimized to VPTEST x, y.

Asm: VPTEST, CPU Feature: AVX

func (Uint64x4) LeadingZeros 

func (x Uint64x4) LeadingZeros() Uint64x4

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Uint64x4) Len 

func (x Uint64x4) Len() int

Len returns the number of elements in a Uint64x4.

func (Uint64x4) Less 

func (x Uint64x4) Less(y Uint64x4) Mask64x4

Less returns a mask whose elements indicate whether x < y.

Emulated, CPU Feature: AVX2

func (Uint64x4) LessEqual 

func (x Uint64x4) LessEqual(y Uint64x4) Mask64x4

LessEqual returns a mask whose elements indicate whether x <= y.

Emulated, CPU Feature: AVX2

func (Uint64x4) Masked 

func (x Uint64x4) Masked(mask Mask64x4) Uint64x4

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX2

func (Uint64x4) Max 

func (x Uint64x4) Max(y Uint64x4) Uint64x4

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUQ, CPU Feature: AVX512

func (Uint64x4) Merge deprecated 

func (x Uint64x4) Merge(y Uint64x4, mask Mask64x4) Uint64x4

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX2

Deprecated: use x.IfElse(mask, y)

func (Uint64x4) Min 

func (x Uint64x4) Min(y Uint64x4) Uint64x4

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUQ, CPU Feature: AVX512

func (Uint64x4) Mul 

func (x Uint64x4) Mul(y Uint64x4) Uint64x4

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Uint64x4) Not 

func (x Uint64x4) Not() Uint64x4

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX2

func (Uint64x4) NotEqual 

func (x Uint64x4) NotEqual(y Uint64x4) Mask64x4

NotEqual returns a mask whose elements indicate whether x != y.

Emulated, CPU Feature: AVX2

func (Uint64x4) OnesCount 

func (x Uint64x4) OnesCount() Uint64x4

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Uint64x4) Or 

func (x Uint64x4) Or(y Uint64x4) Uint64x4

Or performs a bitwise x | y.

Asm: VPOR, CPU Feature: AVX2

func (Uint64x4) Permute 

func (x Uint64x4) Permute(indices Uint64x4) Uint64x4

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMQ, CPU Feature: AVX512

func (Uint64x4) ReshapeToUint8s added in go1.27.0 

func (x Uint64x4) ReshapeToUint8s() Uint8x32

ReshapeToUint8s reinterprets the bits of a Uint64x4 vector as a Uint8x32 vector

func (Uint64x4) ReshapeToUint16s added in go1.27.0 

func (x Uint64x4) ReshapeToUint16s() Uint16x16

ReshapeToUint16s reinterprets the bits of a Uint64x4 vector as a Uint16x16 vector

func (Uint64x4) ReshapeToUint32s added in go1.27.0 

func (x Uint64x4) ReshapeToUint32s() Uint32x8

ReshapeToUint32s reinterprets the bits of a Uint64x4 vector as a Uint32x8 vector

func (Uint64x4) RotateAllLeft 

func (x Uint64x4) RotateAllLeft(dist uint64) Uint64x4

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint64x4) RotateAllRight 

func (x Uint64x4) RotateAllRight(dist uint64) Uint64x4

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint64x4) RotateLeft 

func (x Uint64x4) RotateLeft(y Uint64x4) Uint64x4

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Uint64x4) RotateRight 

func (x Uint64x4) RotateRight(y Uint64x4) Uint64x4

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Uint64x4) SaturateToUint8 

func (x Uint64x4) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQB, CPU Feature: AVX512

func (Uint64x4) SaturateToUint16 

func (x Uint64x4) SaturateToUint16() Uint16x8

SaturateToUint16 converts element values to uint16 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQW, CPU Feature: AVX512

func (Uint64x4) SaturateToUint32 

func (x Uint64x4) SaturateToUint32() Uint32x4

SaturateToUint32 converts element values to uint32 with unsigned saturation.

Asm: VPMOVUSQD, CPU Feature: AVX512

func (Uint64x4) SetHi 

func (x Uint64x4) SetHi(y Uint64x2) Uint64x4

SetHi returns x with its upper half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint64x4) SetLo 

func (x Uint64x4) SetLo(y Uint64x2) Uint64x4

SetLo returns x with its lower half set to y.

Asm: VINSERTI128, CPU Feature: AVX2

func (Uint64x4) ShiftAllLeft 

func (x Uint64x4) ShiftAllLeft(shift uint64) Uint64x4

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX2

func (Uint64x4) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Uint64x4) ShiftAllLeftConcatMod64(y Uint64x4, shift uint64) Uint64x4

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Uint64x4) ShiftAllRight 

func (x Uint64x4) ShiftAllRight(shift uint64) Uint64x4

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLQ, CPU Feature: AVX2

func (Uint64x4) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Uint64x4) ShiftAllRightConcatMod64(y Uint64x4, shift uint64) Uint64x4

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Uint64x4) ShiftLeft 

func (x Uint64x4) ShiftLeft(shift Uint64x4) Uint64x4

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX2

func (Uint64x4) ShiftLeftConcatMod64 added in go1.27.0 

func (x Uint64x4) ShiftLeftConcatMod64(y Uint64x4, shift Uint64x4) Uint64x4

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Uint64x4) ShiftRight 

func (x Uint64x4) ShiftRight(shift Uint64x4) Uint64x4

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVQ, CPU Feature: AVX2

func (Uint64x4) ShiftRightConcatMod64 added in go1.27.0 

func (x Uint64x4) ShiftRightConcatMod64(y Uint64x4, shift Uint64x4) Uint64x4

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Uint64x4) Store 

func (x Uint64x4) Store(s []uint64)

Store stores the elements of x into a slice. If s does not have at least 4 elements, it panics.

func (Uint64x4) StoreArray added in go1.27.0 

func (x Uint64x4) StoreArray(y *[4]uint64)

StoreArray stores a Uint64x4 to an array.

func (Uint64x4) StoreArrayMasked added in go1.27.0 

func (x Uint64x4) StoreArrayMasked(y *[4]uint64, mask Mask64x4)

StoreArrayMasked stores a Uint64x4 to an array, at those elements enabled by mask.

Asm: VMASKMOVQ, CPU Feature: AVX2

func (Uint64x4) StorePart added in go1.27.0 

func (x Uint64x4) StorePart(s []uint64) int

StorePart stores the 4 elements of x into the slice s. It stores as many elements as will fit in s. If s has 4 or more elements, the method is equivalent to x.Store.

func (Uint64x4) String 

func (x Uint64x4) String() string

String returns a string representation of SIMD vector x.

func (Uint64x4) Sub 

func (x Uint64x4) Sub(y Uint64x4) Uint64x4

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX2

func (Uint64x4) TruncToUint8 added in go1.27.0 

func (x Uint64x4) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Uint64x4) TruncToUint16 added in go1.27.0 

func (x Uint64x4) TruncToUint16() Uint16x8

TruncToUint16 truncates element values to uint16. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQW, CPU Feature: AVX512

func (Uint64x4) TruncToUint32 added in go1.27.0 

func (x Uint64x4) TruncToUint32() Uint32x4

TruncToUint32 truncates element values to uint32.

Asm: VPMOVQD, CPU Feature: AVX512

func (Uint64x4) Xor 

func (x Uint64x4) Xor(y Uint64x4) Uint64x4

Xor performs a bitwise x ^ y.

Asm: VPXOR, CPU Feature: AVX2

type Uint64x8 

type Uint64x8 struct {
	// contains filtered or unexported fields
}

Uint64x8 is a 512-bit SIMD vector of 8 uint64s.

func BroadcastUint64x8 

func BroadcastUint64x8(x uint64) Uint64x8

BroadcastUint64x8 returns a vector with the input x assigned to all elements of the output.

Emulated, CPU Feature: AVX512F

func LoadUint64x8 

func LoadUint64x8(s []uint64) Uint64x8

LoadUint64x8 loads an Uint64x8 from a slice of elements. If s does not have at least 8 elements, it panics.

func LoadUint64x8Array added in go1.27.0 

func LoadUint64x8Array(y *[8]uint64) Uint64x8

LoadUint64x8Array loads a Uint64x8 from an array.

func LoadUint64x8Part added in go1.27.0 

func LoadUint64x8Part(s []uint64) (Uint64x8, int)

LoadUint64x8Part loads a Uint64x8 from the slice s, it returns the loaded vector and the number of elements loaded. If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes. If s has 8 or more elements, the function is equivalent to LoadUint64x8.

func (Uint64x8) Add 

func (x Uint64x8) Add(y Uint64x8) Uint64x8

Add adds corresponding elements of two vectors.

Asm: VPADDQ, CPU Feature: AVX512

func (Uint64x8) And 

func (x Uint64x8) And(y Uint64x8) Uint64x8

And performs a bitwise x & y.

Asm: VPANDQ, CPU Feature: AVX512

func (Uint64x8) AndNot 

func (x Uint64x8) AndNot(y Uint64x8) Uint64x8

AndNot performs a bitwise x &^ y.

Asm: VPANDNQ, CPU Feature: AVX512

func (Uint64x8) AsFloat32x16 deprecated 

func (x Uint64x8) AsFloat32x16() Float32x16

AsFloat32x16 reinterprets the bits of a Uint64x8 vector as a Float32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsFloat64x8 deprecated 

func (x Uint64x8) AsFloat64x8() Float64x8

AsFloat64x8 reinterprets the bits of a Uint64x8 vector as a Float64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsInt8x64 deprecated 

func (x Uint64x8) AsInt8x64() Int8x64

AsInt8x64 reinterprets the bits of a Uint64x8 vector as a Int8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsInt16x32 deprecated 

func (x Uint64x8) AsInt16x32() Int16x32

AsInt16x32 reinterprets the bits of a Uint64x8 vector as a Int16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsInt32x16 deprecated 

func (x Uint64x8) AsInt32x16() Int32x16

AsInt32x16 reinterprets the bits of a Uint64x8 vector as a Int32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsInt64x8 deprecated 

func (x Uint64x8) AsInt64x8() Int64x8

AsInt64x8 reinterprets the bits of a Uint64x8 vector as a Int64x8 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsUint8x64 deprecated 

func (x Uint64x8) AsUint8x64() Uint8x64

AsUint8x64 reinterprets the bits of a Uint64x8 vector as a Uint8x64 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsUint16x32 deprecated 

func (x Uint64x8) AsUint16x32() Uint16x32

AsUint16x32 reinterprets the bits of a Uint64x8 vector as a Uint16x32 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) AsUint32x16 deprecated 

func (x Uint64x8) AsUint32x16() Uint32x16

AsUint32x16 reinterprets the bits of a Uint64x8 vector as a Uint32x16 vector

Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>

func (Uint64x8) BitsToFloat64 added in go1.27.0 

func (x Uint64x8) BitsToFloat64() Float64x8

BitsToFloat64 reinterprets the bits of a Uint64x8 vector as a Float64x8 vector

func (Uint64x8) BitsToInt64 added in go1.27.0 

func (x Uint64x8) BitsToInt64() Int64x8

BitsToInt64 reinterprets the bits of a Uint64x8 vector as a Int64x8 vector

func (Uint64x8) CarrylessMultiplyEven added in go1.27.0 

func (x Uint64x8) CarrylessMultiplyEven(y Uint64x8) Uint64x8

CarrylessMultiplyEven computes the carryless multiplications of selected even halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ

func (Uint64x8) CarrylessMultiplyEvenOdd added in go1.27.0 

func (x Uint64x8) CarrylessMultiplyEvenOdd(y Uint64x8) Uint64x8

CarrylessMultiplyEvenOdd computes the carryless multiplications of selected even half of x's elements and odd half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ

func (Uint64x8) CarrylessMultiplyOdd added in go1.27.0 

func (x Uint64x8) CarrylessMultiplyOdd(y Uint64x8) Uint64x8

CarrylessMultiplyOdd computes the carryless multiplications of selected odd halves of the elements of x and y.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ

func (Uint64x8) CarrylessMultiplyOddEven added in go1.27.0 

func (x Uint64x8) CarrylessMultiplyOddEven(y Uint64x8) Uint64x8

CarrylessMultiplyOddEven computes the carryless multiplications of selected odd half of x's elements and even half of y's elements.

A carryless multiplication uses bitwise XOR instead of add-with-carry, for example (in base two): 

11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101

This also models multiplication of polynomials with coefficients from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 = x**2 + 0x + 1 = x**2 + 1 modeled by 101. (Note that "+" adds polynomial terms, but coefficients "add" with XOR.)

Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ

func (Uint64x8) Compress 

func (x Uint64x8) Compress(mask Mask64x8) Uint64x8

Compress packs the masked elements of x into the lower indexed elements of z, zeroing any remaining elements.

Asm: VPCOMPRESSQ, CPU Feature: AVX512

func (Uint64x8) ConcatPermute 

func (x Uint64x8) ConcatPermute(y Uint64x8, indices Uint64x8) Uint64x8

ConcatPermute performs a full permutation of vector x, y using indices: 

result = {xy[indices[0]], xy[indices[1]], ..., xy[indices[n]]}

where xy is the concatenation of x (lower half) and y (upper half). Only the needed bits to represent xy's index are used in indices' elements.

Asm: VPERMI2Q, CPU Feature: AVX512

func (Uint64x8) ConcatPermuteScalarsGrouped added in go1.27.0 

func (x Uint64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Uint64x8) Uint64x8

ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors of the vectors x and y, the selection of two elements from the two vectors x and y, where selector values in the range 0-1 specify elements from x and values in the range 2-3 specify the 0-1 elements of y. When the selectors are constants the selection can be implemented in a single instruction.

If the selectors are not constant this will translate to a function call.

Asm: VSHUFPD, CPU Feature: AVX512

func (Uint64x8) ConvertToFloat32 

func (x Uint64x8) ConvertToFloat32() Float32x8

ConvertToFloat32 converts element values to float32.

Asm: VCVTUQQ2PS, CPU Feature: AVX512

func (Uint64x8) ConvertToFloat64 

func (x Uint64x8) ConvertToFloat64() Float64x8

ConvertToFloat64 converts element values to float64.

Asm: VCVTUQQ2PD, CPU Feature: AVX512

func (Uint64x8) ConvertToInt64 added in go1.27.0 

func (x Uint64x8) ConvertToInt64() Int64x8

ConvertToInt64 converts a Uint64x8 vector to a Int64x8 vector

func (Uint64x8) Equal 

func (x Uint64x8) Equal(y Uint64x8) Mask64x8

Equal returns a mask whose elements indicate whether x == y.

Asm: VPCMPEQQ, CPU Feature: AVX512

func (Uint64x8) Expand 

func (x Uint64x8) Expand(mask Mask64x8) Uint64x8

Expand expands the lower elements of x into the masked elements of z.

Asm: VPEXPANDQ, CPU Feature: AVX512

func (Uint64x8) GetHi 

func (x Uint64x8) GetHi() Uint64x4

GetHi returns the upper half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint64x8) GetLo 

func (x Uint64x8) GetLo() Uint64x4

GetLo returns the lower half of x.

Asm: VEXTRACTI64X4, CPU Feature: AVX512

func (Uint64x8) Greater 

func (x Uint64x8) Greater(y Uint64x8) Mask64x8

Greater returns a mask whose elements indicate whether x > y.

Asm: VPCMPUQ, CPU Feature: AVX512

func (Uint64x8) GreaterEqual 

func (x Uint64x8) GreaterEqual(y Uint64x8) Mask64x8

GreaterEqual returns a mask whose elements indicate whether x >= y.

Asm: VPCMPUQ, CPU Feature: AVX512

func (Uint64x8) IfElse added in go1.27.0 

func (x Uint64x8) IfElse(mask Mask64x8, y Uint64x8) Uint64x8

IfElse returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

func (Uint64x8) InterleaveHiGrouped 

func (x Uint64x8) InterleaveHiGrouped(y Uint64x8) Uint64x8

InterleaveHiGrouped interleaves the elements of the high half of each 128-bit subvector of x and y.

Asm: VPUNPCKHQDQ, CPU Feature: AVX512

func (Uint64x8) InterleaveLoGrouped 

func (x Uint64x8) InterleaveLoGrouped(y Uint64x8) Uint64x8

InterleaveLoGrouped interleaves the elements of the low half of each 128-bit subvector of x and y.

Asm: VPUNPCKLQDQ, CPU Feature: AVX512

func (Uint64x8) LeadingZeros 

func (x Uint64x8) LeadingZeros() Uint64x8

LeadingZeros counts the leading zeros of each element in x.

Asm: VPLZCNTQ, CPU Feature: AVX512

func (Uint64x8) Len 

func (x Uint64x8) Len() int

Len returns the number of elements in a Uint64x8.

func (Uint64x8) Less 

func (x Uint64x8) Less(y Uint64x8) Mask64x8

Less returns a mask whose elements indicate whether x < y.

Asm: VPCMPUQ, CPU Feature: AVX512

func (Uint64x8) LessEqual 

func (x Uint64x8) LessEqual(y Uint64x8) Mask64x8

LessEqual returns a mask whose elements indicate whether x <= y.

Asm: VPCMPUQ, CPU Feature: AVX512

func (Uint64x8) Masked 

func (x Uint64x8) Masked(mask Mask64x8) Uint64x8

Masked returns x but with elements zeroed where mask is false.

Emulated, CPU Feature: AVX512

func (Uint64x8) Max 

func (x Uint64x8) Max(y Uint64x8) Uint64x8

Max computes the maximum of each pair of corresponding elements in x and y.

Asm: VPMAXUQ, CPU Feature: AVX512

func (Uint64x8) Merge deprecated 

func (x Uint64x8) Merge(y Uint64x8, mask Mask64x8) Uint64x8

Merge returns x but with elements set to y where mask is false.

Emulated, CPU Feature: AVX512

Deprecated: use x.IfElse(mask, y)

func (Uint64x8) Min 

func (x Uint64x8) Min(y Uint64x8) Uint64x8

Min computes the minimum of each pair of corresponding elements in x and y.

Asm: VPMINUQ, CPU Feature: AVX512

func (Uint64x8) Mul 

func (x Uint64x8) Mul(y Uint64x8) Uint64x8

Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.

Asm: VPMULLQ, CPU Feature: AVX512

func (Uint64x8) Not 

func (x Uint64x8) Not() Uint64x8

Not returns the bitwise complement of x.

Emulated, CPU Feature: AVX512

func (Uint64x8) NotEqual 

func (x Uint64x8) NotEqual(y Uint64x8) Mask64x8

NotEqual returns a mask whose elements indicate whether x != y.

Asm: VPCMPUQ, CPU Feature: AVX512

func (Uint64x8) OnesCount 

func (x Uint64x8) OnesCount() Uint64x8

OnesCount counts the number of set bits in each element.

Asm: VPOPCNTQ, CPU Feature: AVX512VPOPCNTDQ

func (Uint64x8) Or 

func (x Uint64x8) Or(y Uint64x8) Uint64x8

Or performs a bitwise x | y.

Asm: VPORQ, CPU Feature: AVX512

func (Uint64x8) Permute 

func (x Uint64x8) Permute(indices Uint64x8) Uint64x8

Permute permutes x. 

z[i] = x[indices[i] % len(x)]

Asm: VPERMQ, CPU Feature: AVX512

func (Uint64x8) ReshapeToUint8s added in go1.27.0 

func (x Uint64x8) ReshapeToUint8s() Uint8x64

ReshapeToUint8s reinterprets the bits of a Uint64x8 vector as a Uint8x64 vector

func (Uint64x8) ReshapeToUint16s added in go1.27.0 

func (x Uint64x8) ReshapeToUint16s() Uint16x32

ReshapeToUint16s reinterprets the bits of a Uint64x8 vector as a Uint16x32 vector

func (Uint64x8) ReshapeToUint32s added in go1.27.0 

func (x Uint64x8) ReshapeToUint32s() Uint32x16

ReshapeToUint32s reinterprets the bits of a Uint64x8 vector as a Uint32x16 vector

func (Uint64x8) RotateAllLeft 

func (x Uint64x8) RotateAllLeft(dist uint64) Uint64x8

RotateAllLeft rotates all elements left by the specified amount

Emulated

func (Uint64x8) RotateAllRight 

func (x Uint64x8) RotateAllRight(dist uint64) Uint64x8

RotateAllRight rotates all elements right by the specified amount

Emulated

func (Uint64x8) RotateLeft 

func (x Uint64x8) RotateLeft(y Uint64x8) Uint64x8

RotateLeft rotates each element in x to the left by the number of bits specified by y's corresponding elements.

Asm: VPROLVQ, CPU Feature: AVX512

func (Uint64x8) RotateRight 

func (x Uint64x8) RotateRight(y Uint64x8) Uint64x8

RotateRight rotates each element in x to the right by the number of bits specified by y's corresponding elements.

Asm: VPRORVQ, CPU Feature: AVX512

func (Uint64x8) SaturateToUint8 

func (x Uint64x8) SaturateToUint8() Uint8x16

SaturateToUint8 converts element values to uint8 with unsigned saturation. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVUSQB, CPU Feature: AVX512

func (Uint64x8) SaturateToUint16 

func (x Uint64x8) SaturateToUint16() Uint16x8

SaturateToUint16 converts element values to uint16 with unsigned saturation.

Asm: VPMOVUSQW, CPU Feature: AVX512

func (Uint64x8) SaturateToUint32 

func (x Uint64x8) SaturateToUint32() Uint32x8

SaturateToUint32 converts element values to uint32 with unsigned saturation.

Asm: VPMOVUSQD, CPU Feature: AVX512

func (Uint64x8) SetHi 

func (x Uint64x8) SetHi(y Uint64x4) Uint64x8

SetHi returns x with its upper half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint64x8) SetLo 

func (x Uint64x8) SetLo(y Uint64x4) Uint64x8

SetLo returns x with its lower half set to y.

Asm: VINSERTI64X4, CPU Feature: AVX512

func (Uint64x8) ShiftAllLeft 

func (x Uint64x8) ShiftAllLeft(shift uint64) Uint64x8

ShiftAllLeft shifts each element of x left by y bits. If y is greater than the element width, the result is 0.

Asm: VPSLLQ, CPU Feature: AVX512

func (Uint64x8) ShiftAllLeftConcatMod64 added in go1.27.0 

func (x Uint64x8) ShiftAllLeftConcatMod64(y Uint64x8, shift uint64) Uint64x8

ShiftAllLeftConcatMod64 shifts x[i] left by shift%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHLDQ, CPU Feature: AVX512VBMI2

func (Uint64x8) ShiftAllRight 

func (x Uint64x8) ShiftAllRight(shift uint64) Uint64x8

ShiftAllRight logically shifts each element of x right by y bits. If y is greater than the element width, the result is 0.

Asm: VPSRLQ, CPU Feature: AVX512

func (Uint64x8) ShiftAllRightConcatMod64 added in go1.27.0 

func (x Uint64x8) ShiftAllRightConcatMod64(y Uint64x8, shift uint64) Uint64x8

ShiftAllRightConcatMod64 shifts x[i] right by shift%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift%64)

A non-constant value of shift may result in significantly worse performance for this operation.

Asm: VPSHRDQ, CPU Feature: AVX512VBMI2

func (Uint64x8) ShiftLeft 

func (x Uint64x8) ShiftLeft(shift Uint64x8) Uint64x8

ShiftLeft shifts x[i] left by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSLLVQ, CPU Feature: AVX512

func (Uint64x8) ShiftLeftConcatMod64 added in go1.27.0 

func (x Uint64x8) ShiftLeftConcatMod64(y Uint64x8, shift Uint64x8) Uint64x8

ShiftLeftConcatMod64 shifts x[i] left by shift[i]%64, filing any empted lower bits with the high bits of y[i]. 

z[i] = concat(x[i], y[i]) << (shift[i]%64)

Asm: VPSHLDVQ, CPU Feature: AVX512VBMI2

func (Uint64x8) ShiftRight 

func (x Uint64x8) ShiftRight(shift Uint64x8) Uint64x8

ShiftRight logically shifts x[i] right by y[i] bits. If y[i] is greater than the element width, the result is 0.

Asm: VPSRLVQ, CPU Feature: AVX512

func (Uint64x8) ShiftRightConcatMod64 added in go1.27.0 

func (x Uint64x8) ShiftRightConcatMod64(y Uint64x8, shift Uint64x8) Uint64x8

ShiftRightConcatMod64 shifts x[i] right by shift[i]%64, filling any emptied upper bits with the low bits of y[i]. 

z[i] = concat(y[i], x[i]) >> (shift[i]%64)

Asm: VPSHRDVQ, CPU Feature: AVX512VBMI2

func (Uint64x8) Store 

func (x Uint64x8) Store(s []uint64)

Store stores the elements of x into a slice. If s does not have at least 8 elements, it panics.

func (Uint64x8) StoreArray added in go1.27.0 

func (x Uint64x8) StoreArray(y *[8]uint64)

StoreArray stores a Uint64x8 to an array.

func (Uint64x8) StoreArrayMasked added in go1.27.0 

func (x Uint64x8) StoreArrayMasked(y *[8]uint64, mask Mask64x8)

StoreArrayMasked stores a Uint64x8 to an array, at those elements enabled by mask.

Asm: VMOVDQU64, CPU Feature: AVX512

func (Uint64x8) StorePart added in go1.27.0 

func (x Uint64x8) StorePart(s []uint64) int

StorePart stores the 8 elements of x into the slice s. It stores as many elements as will fit in s. If s has 8 or more elements, the method is equivalent to x.Store.

func (Uint64x8) String 

func (x Uint64x8) String() string

String returns a string representation of SIMD vector x.

func (Uint64x8) Sub 

func (x Uint64x8) Sub(y Uint64x8) Uint64x8

Sub subtracts corresponding elements of two vectors.

Asm: VPSUBQ, CPU Feature: AVX512

func (Uint64x8) TruncToUint8 added in go1.27.0 

func (x Uint64x8) TruncToUint8() Uint8x16

TruncToUint8 truncates element values to uint8. Results are packed to low elements in the returned vector, its upper elements are zeroed.

Asm: VPMOVQB, CPU Feature: AVX512

func (Uint64x8) TruncToUint16 added in go1.27.0 

func (x Uint64x8) TruncToUint16() Uint16x8

TruncToUint16 truncates element values to uint16.

Asm: VPMOVQW, CPU Feature: AVX512

func (Uint64x8) TruncToUint32 added in go1.27.0 

func (x Uint64x8) TruncToUint32() Uint32x8

TruncToUint32 truncates element values to uint32.

Asm: VPMOVQD, CPU Feature: AVX512

func (Uint64x8) Xor 

func (x Uint64x8) Xor(y Uint64x8) Uint64x8

Xor performs a bitwise x ^ y.

Asm: VPXORQ, CPU Feature: AVX512

type X86Features 

type X86Features struct{}
var X86 X86Features

func (X86Features) AVX 

func (X86Features) AVX() bool

AVX returns whether the CPU supports the AVX feature.

AVX is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX2 

func (X86Features) AVX2() bool

AVX2 returns whether the CPU supports the AVX2 feature.

If it returns true, then the CPU also supports AVX.

AVX2 is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512 

func (X86Features) AVX512() bool

AVX512 returns whether the CPU supports the AVX512F+CD+BW+DQ+VL features.

These five CPU features are bundled together, and no use of AVX-512 is allowed unless all of these features are supported together. Nearly every CPU that has shipped with any support for AVX-512 has supported all five of these features.

If it returns true, then the CPU also supports AVX and AVX2.

AVX512 is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512BITALG 

func (X86Features) AVX512BITALG() bool

AVX512BITALG returns whether the CPU supports the AVX512BITALG feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512BITALG is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512GFNI 

func (X86Features) AVX512GFNI() bool

AVX512GFNI returns whether the CPU supports the AVX512GFNI feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512GFNI is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VAES 

func (X86Features) AVX512VAES() bool

AVX512VAES returns whether the CPU supports the AVX512VAES feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512VAES is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VBMI 

func (X86Features) AVX512VBMI() bool

AVX512VBMI returns whether the CPU supports the AVX512VBMI feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512VBMI is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VBMI2 

func (X86Features) AVX512VBMI2() bool

AVX512VBMI2 returns whether the CPU supports the AVX512VBMI2 feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512VBMI2 is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VNNI 

func (X86Features) AVX512VNNI() bool

AVX512VNNI returns whether the CPU supports the AVX512VNNI feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512VNNI is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VPCLMULQDQ 

func (X86Features) AVX512VPCLMULQDQ() bool

AVX512VPCLMULQDQ returns whether the CPU supports the AVX512VPCLMULQDQ feature.

AVX512VPCLMULQDQ is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVX512VPOPCNTDQ 

func (X86Features) AVX512VPOPCNTDQ() bool

AVX512VPOPCNTDQ returns whether the CPU supports the AVX512VPOPCNTDQ feature.

If it returns true, then the CPU also supports AVX, AVX2, and AVX512.

AVX512VPOPCNTDQ is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVXAES 

func (X86Features) AVXAES() bool

AVXAES returns whether the CPU supports the AVXAES feature.

If it returns true, then the CPU also supports AES and AVX.

AVXAES is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) AVXVNNI 

func (X86Features) AVXVNNI() bool

AVXVNNI returns whether the CPU supports the AVXVNNI feature.

If it returns true, then the CPU also supports AVX and AVX2.

AVXVNNI is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) FMA 

func (X86Features) FMA() bool

FMA returns whether the CPU supports the FMA feature.

If it returns true, then the CPU also supports AVX.

FMA is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) SHA 

func (X86Features) SHA() bool

SHA returns whether the CPU supports the SHA feature.

SHA is defined on all GOARCHes, but will only return true on GOARCH amd64.

func (X86Features) VAES 

func (X86Features) VAES() bool

VAES returns whether the CPU supports the VAES feature.

If it returns true, then the CPU also supports AVX.

VAES is defined on all GOARCHes, but will only return true on GOARCH amd64.

Notes

Bugs

  • Using reflect Call to call a vector function/method may not work.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.