src/simd/archsimd/ops_sve.go

// Code generated by 'simdgen -o godefs -goroot $GOROOT -arch sve -arm64Path $ARM64_ISA_PATH go_sve.yaml types.yaml categories.yaml'; DO NOT EDIT.

//go:build goexperiment.simd && arm64

package archsimd

/* Abs */

// Abs returns the elementwise absolute value of x.
//
// Asm: ZFABS, CPU Feature: SVE
func (x Float32s) Abs() (z Float32s)

// Abs returns the elementwise absolute value of x.
//
// Asm: ZFABS, CPU Feature: SVE
func (x Float64s) Abs() (z Float64s)

// Abs returns the elementwise absolute value of x.
//
// Asm: ZABS, CPU Feature: SVE
func (x Int8s) Abs() (z Uint8s)

// Abs returns the elementwise absolute value of x.
//
// Asm: ZABS, CPU Feature: SVE
func (x Int16s) Abs() (z Uint16s)

// Abs returns the elementwise absolute value of x.
//
// Asm: ZABS, CPU Feature: SVE
func (x Int32s) Abs() (z Uint32s)

// Abs returns the elementwise absolute value of x.
//
// Asm: ZABS, CPU Feature: SVE
func (x Int64s) Abs() (z Uint64s)

/* Add */

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZFADD, CPU Feature: SVE
func (x Float32s) Add(y Float32s) (z Float32s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZFADD, CPU Feature: SVE
func (x Float64s) Add(y Float64s) (z Float64s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Int8s) Add(y Int8s) (z Int8s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Int16s) Add(y Int16s) (z Int16s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Int32s) Add(y Int32s) (z Int32s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Int64s) Add(y Int64s) (z Int64s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Uint8s) Add(y Uint8s) (z Uint8s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Uint16s) Add(y Uint16s) (z Uint16s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Uint32s) Add(y Uint32s) (z Uint32s)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: ZADD, CPU Feature: SVE
func (x Uint64s) Add(y Uint64s) (z Uint64s)

/* AddSaturated */

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZSQADD, CPU Feature: SVE
func (x Int8s) AddSaturated(y Int8s) (z Int8s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZSQADD, CPU Feature: SVE
func (x Int16s) AddSaturated(y Int16s) (z Int16s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZSQADD, CPU Feature: SVE
func (x Int32s) AddSaturated(y Int32s) (z Int32s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZSQADD, CPU Feature: SVE
func (x Int64s) AddSaturated(y Int64s) (z Int64s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZUQADD, CPU Feature: SVE
func (x Uint8s) AddSaturated(y Uint8s) (z Uint8s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZUQADD, CPU Feature: SVE
func (x Uint16s) AddSaturated(y Uint16s) (z Uint16s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZUQADD, CPU Feature: SVE
func (x Uint32s) AddSaturated(y Uint32s) (z Uint32s)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: ZUQADD, CPU Feature: SVE
func (x Uint64s) AddSaturated(y Uint64s) (z Uint64s)

/* And */

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Int8s) And(y Int8s) (z Int8s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Int16s) And(y Int16s) (z Int16s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Int32s) And(y Int32s) (z Int32s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Int64s) And(y Int64s) (z Int64s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Uint8s) And(y Uint8s) (z Uint8s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Uint16s) And(y Uint16s) (z Uint16s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Uint32s) And(y Uint32s) (z Uint32s)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: ZAND, CPU Feature: SVE
func (x Uint64s) And(y Uint64s) (z Uint64s)

/* AndNot */

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Int8s) AndNot(y Int8s) (z Int8s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Int16s) AndNot(y Int16s) (z Int16s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Int32s) AndNot(y Int32s) (z Int32s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Int64s) AndNot(y Int64s) (z Int64s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Uint8s) AndNot(y Uint8s) (z Uint8s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Uint16s) AndNot(y Uint16s) (z Uint16s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Uint32s) AndNot(y Uint32s) (z Uint32s)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: ZBIC, CPU Feature: SVE
func (x Uint64s) AndNot(y Uint64s) (z Uint64s)

/* Ceil */

// Ceil rounds elements up to the nearest integer.
//
// Asm: ZFRINTP, CPU Feature: SVE
func (x Float32s) Ceil() Float32s

// Ceil rounds elements up to the nearest integer.
//
// Asm: ZFRINTP, CPU Feature: SVE
func (x Float64s) Ceil() Float64s

/* ConvertToInt32 */

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// Asm: ZFCVTZS, CPU Feature: SVE
func (x Float32s) ConvertToInt32() (z Int32s)

/* Div */

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
//
// Asm: ZFDIV, CPU Feature: SVE
func (x Float32s) Div(y Float32s) (z Float32s)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
//
// Asm: ZFDIV, CPU Feature: SVE
func (x Float64s) Div(y Float64s) (z Float64s)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt32
// by -1 results in MinInt32, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
//
// Asm: ZSDIV, CPU Feature: SVE
func (x Int32s) Div(y Int32s) (z Int32s)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt64
// by -1 results in MinInt64, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
//
// Asm: ZSDIV, CPU Feature: SVE
func (x Int64s) Div(y Int64s) (z Int64s)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
//
// Asm: ZUDIV, CPU Feature: SVE
func (x Uint32s) Div(y Uint32s) (z Uint32s)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
//
// Asm: ZUDIV, CPU Feature: SVE
func (x Uint64s) Div(y Uint64s) (z Uint64s)

/* Equal */

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZFCMEQ, CPU Feature: SVE
func (x Float32s) Equal(y Float32s) (z Mask32s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZFCMEQ, CPU Feature: SVE
func (x Float64s) Equal(y Float64s) (z Mask64s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Int8s) Equal(y Int8s) (z Mask8s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Int16s) Equal(y Int16s) (z Mask16s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Int32s) Equal(y Int32s) (z Mask32s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Int64s) Equal(y Int64s) (z Mask64s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Uint8s) Equal(y Uint8s) (z Mask8s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Uint16s) Equal(y Uint16s) (z Mask16s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Uint32s) Equal(y Uint32s) (z Mask32s)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: ZCMPEQ, CPU Feature: SVE
func (x Uint64s) Equal(y Uint64s) (z Mask64s)

/* Floor */

// Floor rounds elements down to the nearest integer.
//
// Asm: ZFRINTM, CPU Feature: SVE
func (x Float32s) Floor() Float32s

// Floor rounds elements down to the nearest integer.
//
// Asm: ZFRINTM, CPU Feature: SVE
func (x Float64s) Floor() Float64s

/* Greater */

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZFCMGT, CPU Feature: SVE
func (x Float32s) Greater(y Float32s) (z Mask32s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZFCMGT, CPU Feature: SVE
func (x Float64s) Greater(y Float64s) (z Mask64s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPGT, CPU Feature: SVE
func (x Int8s) Greater(y Int8s) (z Mask8s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPGT, CPU Feature: SVE
func (x Int16s) Greater(y Int16s) (z Mask16s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPGT, CPU Feature: SVE
func (x Int32s) Greater(y Int32s) (z Mask32s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPGT, CPU Feature: SVE
func (x Int64s) Greater(y Int64s) (z Mask64s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPHI, CPU Feature: SVE
func (x Uint8s) Greater(y Uint8s) (z Mask8s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPHI, CPU Feature: SVE
func (x Uint16s) Greater(y Uint16s) (z Mask16s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPHI, CPU Feature: SVE
func (x Uint32s) Greater(y Uint32s) (z Mask32s)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: ZCMPHI, CPU Feature: SVE
func (x Uint64s) Greater(y Uint64s) (z Mask64s)

/* GreaterEqual */

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZFCMGE, CPU Feature: SVE
func (x Float32s) GreaterEqual(y Float32s) (z Mask32s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZFCMGE, CPU Feature: SVE
func (x Float64s) GreaterEqual(y Float64s) (z Mask64s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPGE, CPU Feature: SVE
func (x Int8s) GreaterEqual(y Int8s) (z Mask8s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPGE, CPU Feature: SVE
func (x Int16s) GreaterEqual(y Int16s) (z Mask16s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPGE, CPU Feature: SVE
func (x Int32s) GreaterEqual(y Int32s) (z Mask32s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPGE, CPU Feature: SVE
func (x Int64s) GreaterEqual(y Int64s) (z Mask64s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPHS, CPU Feature: SVE
func (x Uint8s) GreaterEqual(y Uint8s) (z Mask8s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPHS, CPU Feature: SVE
func (x Uint16s) GreaterEqual(y Uint16s) (z Mask16s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPHS, CPU Feature: SVE
func (x Uint32s) GreaterEqual(y Uint32s) (z Mask32s)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: ZCMPHS, CPU Feature: SVE
func (x Uint64s) GreaterEqual(y Uint64s) (z Mask64s)

/* Max */

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZFMAX, CPU Feature: SVE
func (x Float32s) Max(y Float32s) (z Float32s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZFMAX, CPU Feature: SVE
func (x Float64s) Max(y Float64s) (z Float64s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZSMAX, CPU Feature: SVE
func (x Int8s) Max(y Int8s) (z Int8s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZSMAX, CPU Feature: SVE
func (x Int16s) Max(y Int16s) (z Int16s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZSMAX, CPU Feature: SVE
func (x Int32s) Max(y Int32s) (z Int32s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZSMAX, CPU Feature: SVE
func (x Int64s) Max(y Int64s) (z Int64s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZUMAX, CPU Feature: SVE
func (x Uint8s) Max(y Uint8s) (z Uint8s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZUMAX, CPU Feature: SVE
func (x Uint16s) Max(y Uint16s) (z Uint16s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZUMAX, CPU Feature: SVE
func (x Uint32s) Max(y Uint32s) (z Uint32s)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: ZUMAX, CPU Feature: SVE
func (x Uint64s) Max(y Uint64s) (z Uint64s)

/* Min */

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZFMIN, CPU Feature: SVE
func (x Float32s) Min(y Float32s) (z Float32s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZFMIN, CPU Feature: SVE
func (x Float64s) Min(y Float64s) (z Float64s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZSMIN, CPU Feature: SVE
func (x Int8s) Min(y Int8s) (z Int8s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZSMIN, CPU Feature: SVE
func (x Int16s) Min(y Int16s) (z Int16s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZSMIN, CPU Feature: SVE
func (x Int32s) Min(y Int32s) (z Int32s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZSMIN, CPU Feature: SVE
func (x Int64s) Min(y Int64s) (z Int64s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZUMIN, CPU Feature: SVE
func (x Uint8s) Min(y Uint8s) (z Uint8s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZUMIN, CPU Feature: SVE
func (x Uint16s) Min(y Uint16s) (z Uint16s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZUMIN, CPU Feature: SVE
func (x Uint32s) Min(y Uint32s) (z Uint32s)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: ZUMIN, CPU Feature: SVE
func (x Uint64s) Min(y Uint64s) (z Uint64s)

/* Mul */

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZFMUL, CPU Feature: SVE
func (x Float32s) Mul(y Float32s) (z Float32s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZFMUL, CPU Feature: SVE
func (x Float64s) Mul(y Float64s) (z Float64s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Int8s) Mul(y Int8s) (z Int8s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Int16s) Mul(y Int16s) (z Int16s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Int32s) Mul(y Int32s) (z Int32s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Int64s) Mul(y Int64s) (z Int64s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Uint8s) Mul(y Uint8s) (z Uint8s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Uint16s) Mul(y Uint16s) (z Uint16s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Uint32s) Mul(y Uint32s) (z Uint32s)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: ZMUL, CPU Feature: SVE
func (x Uint64s) Mul(y Uint64s) (z Uint64s)

/* MulAdd */

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZFMLA, CPU Feature: SVE
func (x Float32s) MulAdd(y Float32s, z Float32s) (w Float32s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZFMLA, CPU Feature: SVE
func (x Float64s) MulAdd(y Float64s, z Float64s) (w Float64s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Int8s) MulAdd(y Int8s, z Int8s) (w Int8s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Int16s) MulAdd(y Int16s, z Int16s) (w Int16s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Int32s) MulAdd(y Int32s, z Int32s) (w Int32s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Int64s) MulAdd(y Int64s, z Int64s) (w Int64s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Uint8s) MulAdd(y Uint8s, z Uint8s) (w Uint8s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Uint16s) MulAdd(y Uint16s, z Uint16s) (w Uint16s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Uint32s) MulAdd(y Uint32s, z Uint32s) (w Uint32s)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: ZMLA, CPU Feature: SVE
func (x Uint64s) MulAdd(y Uint64s, z Uint64s) (w Uint64s)

/* MulHigh */

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZSMULH, CPU Feature: SVE
func (x Int8s) MulHigh(y Int8s) Int8s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZSMULH, CPU Feature: SVE
func (x Int16s) MulHigh(y Int16s) Int16s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZSMULH, CPU Feature: SVE
func (x Int32s) MulHigh(y Int32s) Int32s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZSMULH, CPU Feature: SVE
func (x Int64s) MulHigh(y Int64s) Int64s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZUMULH, CPU Feature: SVE
func (x Uint8s) MulHigh(y Uint8s) Uint8s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZUMULH, CPU Feature: SVE
func (x Uint16s) MulHigh(y Uint16s) Uint16s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZUMULH, CPU Feature: SVE
func (x Uint32s) MulHigh(y Uint32s) Uint32s

// MulHigh multiplies elements and stores the high part of the result.
//
// Asm: ZUMULH, CPU Feature: SVE
func (x Uint64s) MulHigh(y Uint64s) Uint64s

/* Neg */

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZFNEG, CPU Feature: SVE
func (x Float32s) Neg() (z Float32s)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZFNEG, CPU Feature: SVE
func (x Float64s) Neg() (z Float64s)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZNEG, CPU Feature: SVE
func (x Int8s) Neg() (z Int8s)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZNEG, CPU Feature: SVE
func (x Int16s) Neg() (z Int16s)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZNEG, CPU Feature: SVE
func (x Int32s) Neg() (z Int32s)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: ZNEG, CPU Feature: SVE
func (x Int64s) Neg() (z Int64s)

/* NotEqual */

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZFCMNE, CPU Feature: SVE
func (x Float32s) NotEqual(y Float32s) (z Mask32s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZFCMNE, CPU Feature: SVE
func (x Float64s) NotEqual(y Float64s) (z Mask64s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Int8s) NotEqual(y Int8s) (z Mask8s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Int16s) NotEqual(y Int16s) (z Mask16s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Int32s) NotEqual(y Int32s) (z Mask32s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Int64s) NotEqual(y Int64s) (z Mask64s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Uint8s) NotEqual(y Uint8s) (z Mask8s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Uint16s) NotEqual(y Uint16s) (z Mask16s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Uint32s) NotEqual(y Uint32s) (z Mask32s)

// NotEqual returns a mask indicating which elements of x and y are not equal.
//
// Asm: ZCMPNE, CPU Feature: SVE
func (x Uint64s) NotEqual(y Uint64s) (z Mask64s)

/* Or */

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Int8s) Or(y Int8s) (z Int8s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Int16s) Or(y Int16s) (z Int16s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Int32s) Or(y Int32s) (z Int32s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Int64s) Or(y Int64s) (z Int64s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Uint8s) Or(y Uint8s) (z Uint8s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Uint16s) Or(y Uint16s) (z Uint16s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Uint32s) Or(y Uint32s) (z Uint32s)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: ZORR, CPU Feature: SVE
func (x Uint64s) Or(y Uint64s) (z Uint64s)

/* ReduceMax */

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
//
// Asm: ZFMAXVS, CPU Feature: SVE
func (x Float32s) ReduceMax() (z float32)

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
//
// Asm: ZFMAXVD, CPU Feature: SVE
func (x Float64s) ReduceMax() (z float64)

/* ReduceSum */

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
//
// Asm: ZFADDVS, CPU Feature: SVE
func (x Float32s) ReduceSum() (z float32)

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
//
// Asm: ZFADDVD, CPU Feature: SVE
func (x Float64s) ReduceSum() (z float64)

/* Round */

// Round rounds elements to the nearest integer, rounding ties to even.
//
// Asm: ZFRINTN, CPU Feature: SVE
func (x Float32s) Round() Float32s

// Round rounds elements to the nearest integer, rounding ties to even.
//
// Asm: ZFRINTN, CPU Feature: SVE
func (x Float64s) Round() Float64s

/* ShiftAllLeft */

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Int8s) ShiftAllLeft(shift uint64) (z Int8s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Int16s) ShiftAllLeft(shift uint64) (z Int16s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Int32s) ShiftAllLeft(shift uint64) (z Int32s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Int64s) ShiftAllLeft(shift uint64) (z Int64s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Uint8s) ShiftAllLeft(shift uint64) (z Uint8s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Uint16s) ShiftAllLeft(shift uint64) (z Uint16s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Uint32s) ShiftAllLeft(shift uint64) (z Uint32s)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: ZLSL, CPU Feature: SVE
func (x Uint64s) ShiftAllLeft(shift uint64) (z Uint64s)

/* Sqrt */

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
//
// Asm: ZFSQRT, CPU Feature: SVE
func (x Float32s) Sqrt() (z Float32s)

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
//
// Asm: ZFSQRT, CPU Feature: SVE
func (x Float64s) Sqrt() (z Float64s)

/* Sub */

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZFSUB, CPU Feature: SVE
func (x Float32s) Sub(y Float32s) (z Float32s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZFSUB, CPU Feature: SVE
func (x Float64s) Sub(y Float64s) (z Float64s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Int8s) Sub(y Int8s) (z Int8s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Int16s) Sub(y Int16s) (z Int16s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Int32s) Sub(y Int32s) (z Int32s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Int64s) Sub(y Int64s) (z Int64s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Uint8s) Sub(y Uint8s) (z Uint8s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Uint16s) Sub(y Uint16s) (z Uint16s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Uint32s) Sub(y Uint32s) (z Uint32s)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: ZSUB, CPU Feature: SVE
func (x Uint64s) Sub(y Uint64s) (z Uint64s)

/* SubSaturated */

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZSQSUB, CPU Feature: SVE
func (x Int8s) SubSaturated(y Int8s) (z Int8s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZSQSUB, CPU Feature: SVE
func (x Int16s) SubSaturated(y Int16s) (z Int16s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZSQSUB, CPU Feature: SVE
func (x Int32s) SubSaturated(y Int32s) (z Int32s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZSQSUB, CPU Feature: SVE
func (x Int64s) SubSaturated(y Int64s) (z Int64s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZUQSUB, CPU Feature: SVE
func (x Uint8s) SubSaturated(y Uint8s) (z Uint8s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZUQSUB, CPU Feature: SVE
func (x Uint16s) SubSaturated(y Uint16s) (z Uint16s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZUQSUB, CPU Feature: SVE
func (x Uint32s) SubSaturated(y Uint32s) (z Uint32s)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: ZUQSUB, CPU Feature: SVE
func (x Uint64s) SubSaturated(y Uint64s) (z Uint64s)

/* Trunc */

// Trunc truncates elements towards zero.
//
// Asm: ZFRINTZ, CPU Feature: SVE
func (x Float32s) Trunc() Float32s

// Trunc truncates elements towards zero.
//
// Asm: ZFRINTZ, CPU Feature: SVE
func (x Float64s) Trunc() Float64s

/* Xor */

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Int8s) Xor(y Int8s) (z Int8s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Int16s) Xor(y Int16s) (z Int16s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Int32s) Xor(y Int32s) (z Int32s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Int64s) Xor(y Int64s) (z Int64s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Uint8s) Xor(y Uint8s) (z Uint8s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Uint16s) Xor(y Uint16s) (z Uint16s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Uint32s) Xor(y Uint32s) (z Uint32s)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: ZEOR, CPU Feature: SVE
func (x Uint64s) Xor(y Uint64s) (z Uint64s)

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8s) BitsToInt8() (z Int8s)

// ConvertToInt8 converts each element of x to int8.
func (x Uint8s) ConvertToInt8() (z Int8s)

// ConvertToUint8 converts each element of x to uint8.
func (x Int8s) ConvertToUint8() (z Uint8s)

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8s) ToBits() (z Uint8s)

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯ | 15     ....     0 | 15     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint8s) ReshapeToUint16s() (z Uint16s)

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯ | 31               ....               0 | 31               ....               0 |
//	⋯                    z[1]                                    z[0]
func (x Uint8s) ReshapeToUint32s() (z Uint32s)

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯    x[15]     x[14]    ⋯     x[9]      x[8]      x[7]      x[6]    ⋯     x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	⋯ | 63                 ....                 0 | 63                 ....                 0 |
//	⋯                      z[1]                                        z[0]
func (x Uint8s) ReshapeToUint64s() (z Uint64s)

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16s) BitsToInt16() (z Int16s)

// ConvertToInt16 converts each element of x to int16.
func (x Uint16s) ConvertToInt16() (z Int16s)

// ConvertToUint16 converts each element of x to uint16.
func (x Int16s) ConvertToUint16() (z Uint16s)

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16s) ToBits() (z Uint16s)

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 15     ....     0 | 15     ....     0 |
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint16s) ReshapeToUint8s() (z Uint8s)

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯ | 31     ....     0 | 31     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint16s) ReshapeToUint32s() (z Uint32s)

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯ | 63               ....               0 | 63               ....               0 |
//	⋯                    z[1]                                    z[0]
func (x Uint16s) ReshapeToUint64s() (z Uint64s)

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32s) BitsToFloat32() (z Float32s)

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32s) ToBits() (z Uint32s)

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32s) BitsToInt32() (z Int32s)

// ConvertToInt32 converts each element of x to int32.
func (x Uint32s) ConvertToInt32() (z Int32s)

// ConvertToUint32 converts each element of x to uint32.
func (x Int32s) ConvertToUint32() (z Uint32s)

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32s) ToBits() (z Uint32s)

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                    x[1]                                    x[0]
//	⋯ | 31               ....               0 | 31               ....               0 |
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯     z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint32s) ReshapeToUint8s() (z Uint8s)

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 31     ....     0 | 31     ....     0 |
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32s) ReshapeToUint16s() (z Uint16s)

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	⋯ | 63     ....     0 | 63     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint32s) ReshapeToUint64s() (z Uint64s)

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64s) BitsToFloat64() (z Float64s)

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64s) ToBits() (z Uint64s)

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64s) BitsToInt64() (z Int64s)

// ConvertToInt64 converts each element of x to int64.
func (x Uint64s) ConvertToInt64() (z Int64s)

// ConvertToUint64 converts each element of x to uint64.
func (x Int64s) ConvertToUint64() (z Uint64s)

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64s) ToBits() (z Uint64s)

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                      x[1]                                        x[0]
//	⋯ | 63                 ....                 0 | 63                 ....                 0 |
//	⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	⋯    z[15]     z[14]    ⋯     z[9]      z[8]      z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64s) ReshapeToUint8s() (z Uint8s)

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                    x[1]                                    x[0]
//	⋯ | 63               ....               0 | 63               ....               0 |
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯     z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint64s) ReshapeToUint16s() (z Uint16s)

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 63     ....     0 | 63     ....     0 |
//	⋯ | 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint64s) ReshapeToUint32s() (z Uint32s)