SIMD vectors

The simd module provides fixed-size vectors of numbers and lane masks. Operations work on corresponding lanes. With gcc and clang they compile to the target's SIMD instructions (SSE/AVX, NEON, ...); other C compilers and the non-C backends use scalar loops with the same results.

import simd

fn main() {
    a := simd.f32x4(1, 2, 3, 4)
    b := simd.splat_f32x4(2)
    println((a * b).to_array()) // [2.0, 4.0, 6.0, 8.0]
    println(a.dot(b)) // 20.0
}

Types

A vector type is named after its lane type and lane count: F32x8 holds eight f32 lanes.

Comparisons return a mask named after the lane width and count: Mask32x4 belongs to F32x4, I32x4 and U32x4, and Mask8x16 to I8x16 and U8x16. V has no f16 type, so there are no f16 vectors.

Operations

In the list below, T stands for a vector type such as F32x8 and t for its lower-case name.

• Creating: simd.t(lanes...) for up to eight lanes, simd.splat_t(x), simd.from_array_t(arr).
• Loading and storing: simd.load_t_at(src, offset) and v.store_at(mut dst, offset) panic when the slice is too short. simd.load_t(src) and v.store(mut dst) return an error instead, and simd.load_t_part(src) and v.store_part(mut dst) handle the final lanes of a loop: load_t_part zero-fills the missing lanes and both reject slices longer than a vector.
• Lanes: v[i], v[i] = x (they panic when i is out of range) and v.to_array().
• Arithmetic: + - * / and the methods add sub mul div, minimum, maximum; neg and abs for signed and float vectors; sqrt and mul_add for float vectors.
• Bitwise operations on integer vectors: and or xor not, shl(count) and shr(count).
• Comparisons: eq ne lt le gt ge return a mask.
• Reductions: sum, min, max, min_element, max_element and a.dot(b).
• Conversions between lane types of the same width keep the lane count, for example F32x4.to_i32x4, I32x4.to_f32x4, I32x4.to_u32x4 and I8x16.to_u8x16.
• Masks: simd.splat_mask32x4(b), simd.from_array_mask32x4(arr), m[i], m[i] = b, m.to_array(), all, any, count, and, or, xor and not.
• Selecting: simd.select_t(mask, a, b) takes the lanes of a where the mask is set and the lanes of b elsewhere.

== compares whole vectors bit for bit, as V does for every struct. Use eq for a lane mask.

Masks and select make branch-free loops possible:

import simd

// clamp_negatives replaces the negative values of data by zero.
fn clamp_negatives(mut data []f32) {
    zero := simd.splat_f32x8(0)
    mut i := 0
    for ; i + 8 <= data.len; i += 8 {
        v := simd.load_f32x8_at(data, i)
        simd.select_f32x8(v.lt(zero), zero, v).store_at(mut data, i)
    }
    tail := simd.load_f32x8_part(data[i..]) or { panic(err) }
    simd.select_f32x8(tail.lt(zero), zero, tail).store_part(mut data[i..]) or { panic(err) }
}

fn main() {
    mut data := []f32{len: 11, init: f32(index) - 5}
    clamp_negatives(mut data)
    println(data) // [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
    a := simd.i32x4(3, -7, 8, 0)
    big := a.gt(simd.splat_i32x4(2))
    println('${big.count()} ${big.any()} ${big.all()}') // 2 true false
}

Semantics

• Integer + - *, neg, abs, sum and dot wrap on overflow. Integer / truncates toward zero and panics when a lane of the divisor is zero; min / -1 wraps to min.
• shl and an unsigned shr give zero lanes for a count of the lane width or more. A signed shr is arithmetic and fills the lanes with their sign bit for such counts.
• Float operations follow IEEE 754. minimum and maximum return the other lane when one lane is NaN, and the lane of the receiver when the lanes compare equal (such as -0.0 and 0.0).
• min_element and max_element return the index of the first lane holding the smallest or largest value, and min and max return that lane. For float vectors, NaN lanes are ignored, and index 0 is returned when every lane is NaN.
• sum and dot add in lane order, so the vector and scalar paths round identically. mul_add and dot do not promise fused rounding: the C compiler may contract them when its flags allow it, as GCC does by default.
• Float to integer conversions truncate toward zero, map NaN to 0 and saturate out-of-range values. Integer to float conversions round to nearest. Conversions between signed and unsigned lanes keep the bits.

Lowering

The vectors are structs holding a fixed array, so they can be stored in arrays and structs and need no particular alignment. On the C backend, element-wise operations call the helpers in simd.h: with gcc and clang these load the lanes into vectors declared with __attribute__((vector_size(N))), and the C compiler splits vectors wider than the target's registers. Pass for example -cflags -mavx2 to use 256-bit instructions on x86-64. TCC, MSVC and builds with -cflags -DV_SIMD_FORCE_SCALAR use scalar C loops; reductions, integer division and conversions are scalar V code on every path. The non-C backends use scalar V code throughout.

vectors_generated.v, vectors_generated.c.v, simd.h and vectors_generated_test.v are written by gen.vsh. After editing it, regenerate them with v run vlib/simd/gen.vsh.

On V's ARM64 backend (-b arm64), the five F32x4 arithmetic operators are lowered to single NEON instructions instead of the scalar loop. The generator gives those operators a named helper call on non-C backends (see vhelper in gen.vsh), with @[noinline] so the call stays visible; the backend matches the callee by name in vlib/v/gen/arm64/gen.v and emits fadd/fsub/fmul/ fdiv/fsqrt on four f32 lanes. Every other type keeps the scalar loop.

fn broadcast_f32x4(value f32) F32x4

broadcast_f32x4 copies value into all four lanes. It is the same as splat_f32x4.

fn f32x2(a f32, b f32) F32x2

f32x2 creates a F32x2 from its lanes in lane order.

fn f32x4(a f32, b f32, c f32, d f32) F32x4

f32x4 creates a F32x4 from its lanes in lane order.

fn f32x8(a f32, b f32, c f32, d f32, e f32, f f32, g f32, h f32) F32x8

f32x8 creates a F32x8 from its lanes in lane order.

fn f64x2(a f64, b f64) F64x2

f64x2 creates a F64x2 from its lanes in lane order.

fn f64x4(a f64, b f64, c f64, d f64) F64x4

f64x4 creates a F64x4 from its lanes in lane order.

fn f64x8(a f64, b f64, c f64, d f64, e f64, f f64, g f64, h f64) F64x8

f64x8 creates a F64x8 from its lanes in lane order.

fn from_array_f32x16(values [16]f32) F32x16

from_array_f32x16 returns a F32x16 holding values in lane order.

fn from_array_f32x2(values [2]f32) F32x2

from_array_f32x2 returns a F32x2 holding values in lane order.

fn from_array_f32x4(values [4]f32) F32x4

from_array_f32x4 returns a F32x4 holding values in lane order.

fn from_array_f32x8(values [8]f32) F32x8

from_array_f32x8 returns a F32x8 holding values in lane order.

fn from_array_f64x2(values [2]f64) F64x2

from_array_f64x2 returns a F64x2 holding values in lane order.

fn from_array_f64x4(values [4]f64) F64x4

from_array_f64x4 returns a F64x4 holding values in lane order.

fn from_array_f64x8(values [8]f64) F64x8

from_array_f64x8 returns a F64x8 holding values in lane order.

fn from_array_i16x16(values [16]i16) I16x16

from_array_i16x16 returns a I16x16 holding values in lane order.

fn from_array_i16x32(values [32]i16) I16x32

from_array_i16x32 returns a I16x32 holding values in lane order.

fn from_array_i16x4(values [4]i16) I16x4

from_array_i16x4 returns a I16x4 holding values in lane order.

fn from_array_i16x8(values [8]i16) I16x8

from_array_i16x8 returns a I16x8 holding values in lane order.

fn from_array_i32x16(values [16]i32) I32x16

from_array_i32x16 returns a I32x16 holding values in lane order.

fn from_array_i32x2(values [2]i32) I32x2

from_array_i32x2 returns a I32x2 holding values in lane order.

fn from_array_i32x4(values [4]i32) I32x4

from_array_i32x4 returns a I32x4 holding values in lane order.

fn from_array_i32x8(values [8]i32) I32x8

from_array_i32x8 returns a I32x8 holding values in lane order.

fn from_array_i64x2(values [2]i64) I64x2

from_array_i64x2 returns a I64x2 holding values in lane order.

fn from_array_i64x4(values [4]i64) I64x4

from_array_i64x4 returns a I64x4 holding values in lane order.

fn from_array_i64x8(values [8]i64) I64x8

from_array_i64x8 returns a I64x8 holding values in lane order.

fn from_array_i8x16(values [16]i8) I8x16

from_array_i8x16 returns a I8x16 holding values in lane order.

fn from_array_i8x32(values [32]i8) I8x32

from_array_i8x32 returns a I8x32 holding values in lane order.

fn from_array_i8x64(values [64]i8) I8x64

from_array_i8x64 returns a I8x64 holding values in lane order.

fn from_array_i8x8(values [8]i8) I8x8

from_array_i8x8 returns a I8x8 holding values in lane order.

fn from_array_mask16x16(values [16]bool) Mask16x16

from_array_mask16x16 returns a Mask16x16 with lane i set when values[i] is true.

fn from_array_mask16x32(values [32]bool) Mask16x32

from_array_mask16x32 returns a Mask16x32 with lane i set when values[i] is true.

fn from_array_mask16x4(values [4]bool) Mask16x4

from_array_mask16x4 returns a Mask16x4 with lane i set when values[i] is true.

fn from_array_mask16x8(values [8]bool) Mask16x8

from_array_mask16x8 returns a Mask16x8 with lane i set when values[i] is true.

fn from_array_mask32x16(values [16]bool) Mask32x16

from_array_mask32x16 returns a Mask32x16 with lane i set when values[i] is true.

fn from_array_mask32x2(values [2]bool) Mask32x2

from_array_mask32x2 returns a Mask32x2 with lane i set when values[i] is true.

fn from_array_mask32x4(values [4]bool) Mask32x4

from_array_mask32x4 returns a Mask32x4 with lane i set when values[i] is true.

fn from_array_mask32x8(values [8]bool) Mask32x8

from_array_mask32x8 returns a Mask32x8 with lane i set when values[i] is true.

fn from_array_mask64x2(values [2]bool) Mask64x2

from_array_mask64x2 returns a Mask64x2 with lane i set when values[i] is true.

fn from_array_mask64x4(values [4]bool) Mask64x4

from_array_mask64x4 returns a Mask64x4 with lane i set when values[i] is true.

fn from_array_mask64x8(values [8]bool) Mask64x8

from_array_mask64x8 returns a Mask64x8 with lane i set when values[i] is true.

fn from_array_mask8x16(values [16]bool) Mask8x16

from_array_mask8x16 returns a Mask8x16 with lane i set when values[i] is true.

fn from_array_mask8x32(values [32]bool) Mask8x32

from_array_mask8x32 returns a Mask8x32 with lane i set when values[i] is true.

fn from_array_mask8x64(values [64]bool) Mask8x64

from_array_mask8x64 returns a Mask8x64 with lane i set when values[i] is true.

fn from_array_mask8x8(values [8]bool) Mask8x8

from_array_mask8x8 returns a Mask8x8 with lane i set when values[i] is true.

fn from_array_u16x16(values [16]u16) U16x16

from_array_u16x16 returns a U16x16 holding values in lane order.

fn from_array_u16x32(values [32]u16) U16x32

from_array_u16x32 returns a U16x32 holding values in lane order.

fn from_array_u16x4(values [4]u16) U16x4

from_array_u16x4 returns a U16x4 holding values in lane order.

fn from_array_u16x8(values [8]u16) U16x8

from_array_u16x8 returns a U16x8 holding values in lane order.

fn from_array_u32x16(values [16]u32) U32x16

from_array_u32x16 returns a U32x16 holding values in lane order.

fn from_array_u32x2(values [2]u32) U32x2

from_array_u32x2 returns a U32x2 holding values in lane order.

fn from_array_u32x4(values [4]u32) U32x4

from_array_u32x4 returns a U32x4 holding values in lane order.

fn from_array_u32x8(values [8]u32) U32x8

from_array_u32x8 returns a U32x8 holding values in lane order.

fn from_array_u64x2(values [2]u64) U64x2

from_array_u64x2 returns a U64x2 holding values in lane order.

fn from_array_u64x4(values [4]u64) U64x4

from_array_u64x4 returns a U64x4 holding values in lane order.

fn from_array_u64x8(values [8]u64) U64x8

from_array_u64x8 returns a U64x8 holding values in lane order.

fn from_array_u8x16(values [16]u8) U8x16

from_array_u8x16 returns a U8x16 holding values in lane order.

fn from_array_u8x32(values [32]u8) U8x32

from_array_u8x32 returns a U8x32 holding values in lane order.

fn from_array_u8x64(values [64]u8) U8x64

from_array_u8x64 returns a U8x64 holding values in lane order.

fn from_array_u8x8(values [8]u8) U8x8

from_array_u8x8 returns a U8x8 holding values in lane order.

fn i16x4(a i16, b i16, c i16, d i16) I16x4

i16x4 creates a I16x4 from its lanes in lane order.

fn i16x8(a i16, b i16, c i16, d i16, e i16, f i16, g i16, h i16) I16x8

i16x8 creates a I16x8 from its lanes in lane order.

fn i32x2(a i32, b i32) I32x2

i32x2 creates a I32x2 from its lanes in lane order.

fn i32x4(a i32, b i32, c i32, d i32) I32x4

i32x4 creates a I32x4 from its lanes in lane order.

fn i32x8(a i32, b i32, c i32, d i32, e i32, f i32, g i32, h i32) I32x8

i32x8 creates a I32x8 from its lanes in lane order.

fn i64x2(a i64, b i64) I64x2

i64x2 creates a I64x2 from its lanes in lane order.

fn i64x4(a i64, b i64, c i64, d i64) I64x4

i64x4 creates a I64x4 from its lanes in lane order.

fn i64x8(a i64, b i64, c i64, d i64, e i64, f i64, g i64, h i64) I64x8

i64x8 creates a I64x8 from its lanes in lane order.

fn i8x8(a i8, b i8, c i8, d i8, e i8, f i8, g i8, h i8) I8x8

i8x8 creates a I8x8 from its lanes in lane order.

fn load_f32x16(src []f32) !F32x16

load_f32x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_f32x16_at(src []f32, offset int) F32x16

load_f32x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_f32x16_part(src []f32) !F32x16

load_f32x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_f32x2(src []f32) !F32x2

load_f32x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_f32x2_at(src []f32, offset int) F32x2

load_f32x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_f32x2_part(src []f32) !F32x2

load_f32x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_f32x4(src []f32) !F32x4

load_f32x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_f32x4_at(src []f32, offset int) F32x4

load_f32x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_f32x4_part(src []f32) !F32x4

load_f32x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_f32x8(src []f32) !F32x8

load_f32x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_f32x8_at(src []f32, offset int) F32x8

load_f32x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_f32x8_part(src []f32) !F32x8

load_f32x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_f64x2(src []f64) !F64x2

load_f64x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_f64x2_at(src []f64, offset int) F64x2

load_f64x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_f64x2_part(src []f64) !F64x2

load_f64x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_f64x4(src []f64) !F64x4

load_f64x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_f64x4_at(src []f64, offset int) F64x4

load_f64x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_f64x4_part(src []f64) !F64x4

load_f64x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_f64x8(src []f64) !F64x8

load_f64x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_f64x8_at(src []f64, offset int) F64x8

load_f64x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_f64x8_part(src []f64) !F64x8

load_f64x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_i16x16(src []i16) !I16x16

load_i16x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_i16x16_at(src []i16, offset int) I16x16

load_i16x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_i16x16_part(src []i16) !I16x16

load_i16x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_i16x32(src []i16) !I16x32

load_i16x32 loads 32 values from the start of src. It returns an error if src has fewer than 32 values.

fn load_i16x32_at(src []i16, offset int) I16x32

load_i16x32_at loads 32 values starting at src[offset]. It panics if offset is negative or fewer than 32 values follow it.

fn load_i16x32_part(src []i16) !I16x32

load_i16x32_part loads up to 32 values from src and zero-fills the remaining lanes. It returns an error if src has more than 32 values.

fn load_i16x4(src []i16) !I16x4

load_i16x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_i16x4_at(src []i16, offset int) I16x4

load_i16x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_i16x4_part(src []i16) !I16x4

load_i16x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_i16x8(src []i16) !I16x8

load_i16x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_i16x8_at(src []i16, offset int) I16x8

load_i16x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_i16x8_part(src []i16) !I16x8

load_i16x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_i32x16(src []i32) !I32x16

load_i32x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_i32x16_at(src []i32, offset int) I32x16

load_i32x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_i32x16_part(src []i32) !I32x16

load_i32x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_i32x2(src []i32) !I32x2

load_i32x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_i32x2_at(src []i32, offset int) I32x2

load_i32x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_i32x2_part(src []i32) !I32x2

load_i32x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_i32x4(src []i32) !I32x4

load_i32x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_i32x4_at(src []i32, offset int) I32x4

load_i32x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_i32x4_part(src []i32) !I32x4

load_i32x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_i32x8(src []i32) !I32x8

load_i32x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_i32x8_at(src []i32, offset int) I32x8

load_i32x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_i32x8_part(src []i32) !I32x8

load_i32x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_i64x2(src []i64) !I64x2

load_i64x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_i64x2_at(src []i64, offset int) I64x2

load_i64x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_i64x2_part(src []i64) !I64x2

load_i64x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_i64x4(src []i64) !I64x4

load_i64x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_i64x4_at(src []i64, offset int) I64x4

load_i64x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_i64x4_part(src []i64) !I64x4

load_i64x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_i64x8(src []i64) !I64x8

load_i64x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_i64x8_at(src []i64, offset int) I64x8

load_i64x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_i64x8_part(src []i64) !I64x8

load_i64x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_i8x16(src []i8) !I8x16

load_i8x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_i8x16_at(src []i8, offset int) I8x16

load_i8x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_i8x16_part(src []i8) !I8x16

load_i8x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_i8x32(src []i8) !I8x32

load_i8x32 loads 32 values from the start of src. It returns an error if src has fewer than 32 values.

fn load_i8x32_at(src []i8, offset int) I8x32

load_i8x32_at loads 32 values starting at src[offset]. It panics if offset is negative or fewer than 32 values follow it.

fn load_i8x32_part(src []i8) !I8x32

load_i8x32_part loads up to 32 values from src and zero-fills the remaining lanes. It returns an error if src has more than 32 values.

fn load_i8x64(src []i8) !I8x64

load_i8x64 loads 64 values from the start of src. It returns an error if src has fewer than 64 values.

fn load_i8x64_at(src []i8, offset int) I8x64

load_i8x64_at loads 64 values starting at src[offset]. It panics if offset is negative or fewer than 64 values follow it.

fn load_i8x64_part(src []i8) !I8x64

load_i8x64_part loads up to 64 values from src and zero-fills the remaining lanes. It returns an error if src has more than 64 values.

fn load_i8x8(src []i8) !I8x8

load_i8x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_i8x8_at(src []i8, offset int) I8x8

load_i8x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_i8x8_part(src []i8) !I8x8

load_i8x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_u16x16(src []u16) !U16x16

load_u16x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_u16x16_at(src []u16, offset int) U16x16

load_u16x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_u16x16_part(src []u16) !U16x16

load_u16x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_u16x32(src []u16) !U16x32

load_u16x32 loads 32 values from the start of src. It returns an error if src has fewer than 32 values.

fn load_u16x32_at(src []u16, offset int) U16x32

load_u16x32_at loads 32 values starting at src[offset]. It panics if offset is negative or fewer than 32 values follow it.

fn load_u16x32_part(src []u16) !U16x32

load_u16x32_part loads up to 32 values from src and zero-fills the remaining lanes. It returns an error if src has more than 32 values.

fn load_u16x4(src []u16) !U16x4

load_u16x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_u16x4_at(src []u16, offset int) U16x4

load_u16x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_u16x4_part(src []u16) !U16x4

load_u16x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_u16x8(src []u16) !U16x8

load_u16x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_u16x8_at(src []u16, offset int) U16x8

load_u16x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_u16x8_part(src []u16) !U16x8

load_u16x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_u32x16(src []u32) !U32x16

load_u32x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_u32x16_at(src []u32, offset int) U32x16

load_u32x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_u32x16_part(src []u32) !U32x16

load_u32x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_u32x2(src []u32) !U32x2

load_u32x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_u32x2_at(src []u32, offset int) U32x2

load_u32x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_u32x2_part(src []u32) !U32x2

load_u32x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_u32x4(src []u32) !U32x4

load_u32x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_u32x4_at(src []u32, offset int) U32x4

load_u32x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_u32x4_part(src []u32) !U32x4

load_u32x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_u32x8(src []u32) !U32x8

load_u32x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_u32x8_at(src []u32, offset int) U32x8

load_u32x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_u32x8_part(src []u32) !U32x8

load_u32x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_u64x2(src []u64) !U64x2

load_u64x2 loads 2 values from the start of src. It returns an error if src has fewer than 2 values.

fn load_u64x2_at(src []u64, offset int) U64x2

load_u64x2_at loads 2 values starting at src[offset]. It panics if offset is negative or fewer than 2 values follow it.

fn load_u64x2_part(src []u64) !U64x2

load_u64x2_part loads up to 2 values from src and zero-fills the remaining lanes. It returns an error if src has more than 2 values.

fn load_u64x4(src []u64) !U64x4

load_u64x4 loads 4 values from the start of src. It returns an error if src has fewer than 4 values.

fn load_u64x4_at(src []u64, offset int) U64x4

load_u64x4_at loads 4 values starting at src[offset]. It panics if offset is negative or fewer than 4 values follow it.

fn load_u64x4_part(src []u64) !U64x4

load_u64x4_part loads up to 4 values from src and zero-fills the remaining lanes. It returns an error if src has more than 4 values.

fn load_u64x8(src []u64) !U64x8

load_u64x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_u64x8_at(src []u64, offset int) U64x8

load_u64x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_u64x8_part(src []u64) !U64x8

load_u64x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn load_u8x16(src []u8) !U8x16

load_u8x16 loads 16 values from the start of src. It returns an error if src has fewer than 16 values.

fn load_u8x16_at(src []u8, offset int) U8x16

load_u8x16_at loads 16 values starting at src[offset]. It panics if offset is negative or fewer than 16 values follow it.

fn load_u8x16_part(src []u8) !U8x16

load_u8x16_part loads up to 16 values from src and zero-fills the remaining lanes. It returns an error if src has more than 16 values.

fn load_u8x32(src []u8) !U8x32

load_u8x32 loads 32 values from the start of src. It returns an error if src has fewer than 32 values.

fn load_u8x32_at(src []u8, offset int) U8x32

load_u8x32_at loads 32 values starting at src[offset]. It panics if offset is negative or fewer than 32 values follow it.

fn load_u8x32_part(src []u8) !U8x32

load_u8x32_part loads up to 32 values from src and zero-fills the remaining lanes. It returns an error if src has more than 32 values.

fn load_u8x64(src []u8) !U8x64

load_u8x64 loads 64 values from the start of src. It returns an error if src has fewer than 64 values.

fn load_u8x64_at(src []u8, offset int) U8x64

load_u8x64_at loads 64 values starting at src[offset]. It panics if offset is negative or fewer than 64 values follow it.

fn load_u8x64_part(src []u8) !U8x64

load_u8x64_part loads up to 64 values from src and zero-fills the remaining lanes. It returns an error if src has more than 64 values.

fn load_u8x8(src []u8) !U8x8

load_u8x8 loads 8 values from the start of src. It returns an error if src has fewer than 8 values.

fn load_u8x8_at(src []u8, offset int) U8x8

load_u8x8_at loads 8 values starting at src[offset]. It panics if offset is negative or fewer than 8 values follow it.

fn load_u8x8_part(src []u8) !U8x8

load_u8x8_part loads up to 8 values from src and zero-fills the remaining lanes. It returns an error if src has more than 8 values.

fn select_f32x16(mask Mask32x16, a F32x16, b F32x16) F32x16

select_f32x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f32x2(mask Mask32x2, a F32x2, b F32x2) F32x2

select_f32x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f32x4(mask Mask32x4, a F32x4, b F32x4) F32x4

select_f32x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f32x8(mask Mask32x8, a F32x8, b F32x8) F32x8

select_f32x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f64x2(mask Mask64x2, a F64x2, b F64x2) F64x2

select_f64x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f64x4(mask Mask64x4, a F64x4, b F64x4) F64x4

select_f64x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_f64x8(mask Mask64x8, a F64x8, b F64x8) F64x8

select_f64x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i16x16(mask Mask16x16, a I16x16, b I16x16) I16x16

select_i16x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i16x32(mask Mask16x32, a I16x32, b I16x32) I16x32

select_i16x32 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i16x4(mask Mask16x4, a I16x4, b I16x4) I16x4

select_i16x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i16x8(mask Mask16x8, a I16x8, b I16x8) I16x8

select_i16x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i32x16(mask Mask32x16, a I32x16, b I32x16) I32x16

select_i32x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i32x2(mask Mask32x2, a I32x2, b I32x2) I32x2

select_i32x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i32x4(mask Mask32x4, a I32x4, b I32x4) I32x4

select_i32x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i32x8(mask Mask32x8, a I32x8, b I32x8) I32x8

select_i32x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i64x2(mask Mask64x2, a I64x2, b I64x2) I64x2

select_i64x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i64x4(mask Mask64x4, a I64x4, b I64x4) I64x4

select_i64x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i64x8(mask Mask64x8, a I64x8, b I64x8) I64x8

select_i64x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i8x16(mask Mask8x16, a I8x16, b I8x16) I8x16

select_i8x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i8x32(mask Mask8x32, a I8x32, b I8x32) I8x32

select_i8x32 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i8x64(mask Mask8x64, a I8x64, b I8x64) I8x64

select_i8x64 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_i8x8(mask Mask8x8, a I8x8, b I8x8) I8x8

select_i8x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u16x16(mask Mask16x16, a U16x16, b U16x16) U16x16

select_u16x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u16x32(mask Mask16x32, a U16x32, b U16x32) U16x32

select_u16x32 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u16x4(mask Mask16x4, a U16x4, b U16x4) U16x4

select_u16x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u16x8(mask Mask16x8, a U16x8, b U16x8) U16x8

select_u16x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u32x16(mask Mask32x16, a U32x16, b U32x16) U32x16

select_u32x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u32x2(mask Mask32x2, a U32x2, b U32x2) U32x2

select_u32x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u32x4(mask Mask32x4, a U32x4, b U32x4) U32x4

select_u32x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u32x8(mask Mask32x8, a U32x8, b U32x8) U32x8

select_u32x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u64x2(mask Mask64x2, a U64x2, b U64x2) U64x2

select_u64x2 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u64x4(mask Mask64x4, a U64x4, b U64x4) U64x4

select_u64x4 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u64x8(mask Mask64x8, a U64x8, b U64x8) U64x8

select_u64x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u8x16(mask Mask8x16, a U8x16, b U8x16) U8x16

select_u8x16 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u8x32(mask Mask8x32, a U8x32, b U8x32) U8x32

select_u8x32 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u8x64(mask Mask8x64, a U8x64, b U8x64) U8x64

select_u8x64 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn select_u8x8(mask Mask8x8, a U8x8, b U8x8) U8x8

select_u8x8 returns the lanes of a where mask is set and the lanes of b where it is clear.

fn splat_f32x16(value f32) F32x16

splat_f32x16 returns a F32x16 with every lane set to value.

fn splat_f32x2(value f32) F32x2

splat_f32x2 returns a F32x2 with every lane set to value.

fn splat_f32x4(value f32) F32x4

splat_f32x4 returns a F32x4 with every lane set to value.

fn splat_f32x8(value f32) F32x8

splat_f32x8 returns a F32x8 with every lane set to value.

fn splat_f64x2(value f64) F64x2

splat_f64x2 returns a F64x2 with every lane set to value.

fn splat_f64x4(value f64) F64x4

splat_f64x4 returns a F64x4 with every lane set to value.

fn splat_f64x8(value f64) F64x8

splat_f64x8 returns a F64x8 with every lane set to value.

fn splat_i16x16(value i16) I16x16

splat_i16x16 returns a I16x16 with every lane set to value.

fn splat_i16x32(value i16) I16x32

splat_i16x32 returns a I16x32 with every lane set to value.

fn splat_i16x4(value i16) I16x4

splat_i16x4 returns a I16x4 with every lane set to value.

fn splat_i16x8(value i16) I16x8

splat_i16x8 returns a I16x8 with every lane set to value.

fn splat_i32x16(value i32) I32x16

splat_i32x16 returns a I32x16 with every lane set to value.

fn splat_i32x2(value i32) I32x2

splat_i32x2 returns a I32x2 with every lane set to value.

fn splat_i32x4(value i32) I32x4

splat_i32x4 returns a I32x4 with every lane set to value.

fn splat_i32x8(value i32) I32x8

splat_i32x8 returns a I32x8 with every lane set to value.

fn splat_i64x2(value i64) I64x2

splat_i64x2 returns a I64x2 with every lane set to value.

fn splat_i64x4(value i64) I64x4

splat_i64x4 returns a I64x4 with every lane set to value.

fn splat_i64x8(value i64) I64x8

splat_i64x8 returns a I64x8 with every lane set to value.

fn splat_i8x16(value i8) I8x16

splat_i8x16 returns a I8x16 with every lane set to value.

fn splat_i8x32(value i8) I8x32

splat_i8x32 returns a I8x32 with every lane set to value.

fn splat_i8x64(value i8) I8x64

splat_i8x64 returns a I8x64 with every lane set to value.

fn splat_i8x8(value i8) I8x8

splat_i8x8 returns a I8x8 with every lane set to value.

fn splat_mask16x16(value bool) Mask16x16

splat_mask16x16 returns a Mask16x16 with every lane set to value.

fn splat_mask16x32(value bool) Mask16x32

splat_mask16x32 returns a Mask16x32 with every lane set to value.

fn splat_mask16x4(value bool) Mask16x4

splat_mask16x4 returns a Mask16x4 with every lane set to value.

fn splat_mask16x8(value bool) Mask16x8

splat_mask16x8 returns a Mask16x8 with every lane set to value.

fn splat_mask32x16(value bool) Mask32x16

splat_mask32x16 returns a Mask32x16 with every lane set to value.

fn splat_mask32x2(value bool) Mask32x2

splat_mask32x2 returns a Mask32x2 with every lane set to value.

fn splat_mask32x4(value bool) Mask32x4

splat_mask32x4 returns a Mask32x4 with every lane set to value.

fn splat_mask32x8(value bool) Mask32x8

splat_mask32x8 returns a Mask32x8 with every lane set to value.

fn splat_mask64x2(value bool) Mask64x2

splat_mask64x2 returns a Mask64x2 with every lane set to value.

fn splat_mask64x4(value bool) Mask64x4

splat_mask64x4 returns a Mask64x4 with every lane set to value.

fn splat_mask64x8(value bool) Mask64x8

splat_mask64x8 returns a Mask64x8 with every lane set to value.

fn splat_mask8x16(value bool) Mask8x16

splat_mask8x16 returns a Mask8x16 with every lane set to value.

fn splat_mask8x32(value bool) Mask8x32

splat_mask8x32 returns a Mask8x32 with every lane set to value.

fn splat_mask8x64(value bool) Mask8x64

splat_mask8x64 returns a Mask8x64 with every lane set to value.

fn splat_mask8x8(value bool) Mask8x8

splat_mask8x8 returns a Mask8x8 with every lane set to value.

fn splat_u16x16(value u16) U16x16

splat_u16x16 returns a U16x16 with every lane set to value.

fn splat_u16x32(value u16) U16x32

splat_u16x32 returns a U16x32 with every lane set to value.

fn splat_u16x4(value u16) U16x4

splat_u16x4 returns a U16x4 with every lane set to value.

fn splat_u16x8(value u16) U16x8

splat_u16x8 returns a U16x8 with every lane set to value.

fn splat_u32x16(value u32) U32x16

splat_u32x16 returns a U32x16 with every lane set to value.

fn splat_u32x2(value u32) U32x2

splat_u32x2 returns a U32x2 with every lane set to value.

fn splat_u32x4(value u32) U32x4

splat_u32x4 returns a U32x4 with every lane set to value.

fn splat_u32x8(value u32) U32x8

splat_u32x8 returns a U32x8 with every lane set to value.

fn splat_u64x2(value u64) U64x2

splat_u64x2 returns a U64x2 with every lane set to value.

fn splat_u64x4(value u64) U64x4

splat_u64x4 returns a U64x4 with every lane set to value.

fn splat_u64x8(value u64) U64x8

splat_u64x8 returns a U64x8 with every lane set to value.

fn splat_u8x16(value u8) U8x16

splat_u8x16 returns a U8x16 with every lane set to value.

fn splat_u8x32(value u8) U8x32

splat_u8x32 returns a U8x32 with every lane set to value.

fn splat_u8x64(value u8) U8x64

splat_u8x64 returns a U8x64 with every lane set to value.

fn splat_u8x8(value u8) U8x8

splat_u8x8 returns a U8x8 with every lane set to value.

fn u16x4(a u16, b u16, c u16, d u16) U16x4

u16x4 creates a U16x4 from its lanes in lane order.

fn u16x8(a u16, b u16, c u16, d u16, e u16, f u16, g u16, h u16) U16x8

u16x8 creates a U16x8 from its lanes in lane order.

fn u32x2(a u32, b u32) U32x2

u32x2 creates a U32x2 from its lanes in lane order.

fn u32x4(a u32, b u32, c u32, d u32) U32x4

u32x4 creates a U32x4 from its lanes in lane order.

fn u32x8(a u32, b u32, c u32, d u32, e u32, f u32, g u32, h u32) U32x8

u32x8 creates a U32x8 from its lanes in lane order.

fn u64x2(a u64, b u64) U64x2

u64x2 creates a U64x2 from its lanes in lane order.

fn u64x4(a u64, b u64, c u64, d u64) U64x4

u64x4 creates a U64x4 from its lanes in lane order.

fn u64x8(a u64, b u64, c u64, d u64, e u64, f u64, g u64, h u64) U64x8

u64x8 creates a U64x8 from its lanes in lane order.

fn u8x8(a u8, b u8, c u8, d u8, e u8, f u8, g u8, h u8) U8x8

u8x8 creates a U8x8 from its lanes in lane order.

struct F32x16 {
mut:
	values [16]f32
}

F32x16 holds 16 f32 lanes (512 bits).

fn (v F32x16) to_array() [16]f32

to_array returns the lanes in order.

fn (v F32x16) [] (i int) f32

[] returns lane i. It panics if i is out of range.

fn (mut v F32x16) []= (i int, value f32)

[]= sets lane i to value. It panics if i is out of range.

fn (v F32x16) store(mut dst []f32) !

store writes all 16 lanes to the start of dst. It returns an error if dst has fewer than 16 elements.

fn (v F32x16) store_part(mut dst []f32) !

store_part writes one lane for each element of dst, up to 16 elements. It returns an error if dst has more than 16 elements.

fn (v F32x16) store_at(mut dst []f32, offset int)

store_at writes all 16 lanes to dst, starting at dst[offset]. It panics if offset is negative or fewer than 16 elements follow it.

fn (a F32x16) + (b F32x16) F32x16

• adds corresponding lanes.

fn (a F32x16) - (b F32x16) F32x16

• subtracts corresponding lanes.

fn (a F32x16) * (b F32x16) F32x16

• multiplies corresponding lanes.

fn (a F32x16) / (b F32x16) F32x16

/ divides corresponding lanes.

fn (a F32x16) add(b F32x16) F32x16

add returns a + b.

fn (a F32x16) sub(b F32x16) F32x16

sub returns a - b.

fn (a F32x16) mul(b F32x16) F32x16

mul returns a * b.

fn (a F32x16) div(b F32x16) F32x16

div returns a / b.

fn (a F32x16) neg() F32x16

neg negates each lane.

fn (a F32x16) abs() F32x16

abs returns the absolute value of each lane by clearing its sign bit.

fn (a F32x16) minimum(b F32x16) F32x16

minimum returns the smaller of each pair of lanes. When one lane is NaN, the other lane is returned. Equal lanes, such as -0.0 and 0.0, return the lane of a.

fn (a F32x16) maximum(b F32x16) F32x16

maximum returns the larger of each pair of lanes. When one lane is NaN, the other lane is returned. Equal lanes, such as -0.0 and 0.0, return the lane of a.

fn (a F32x16) sqrt() F32x16

sqrt returns the square root of each lane.

fn (v F32x16) mul_add(multiplier F32x16, addend F32x16) F32x16

mul_add returns v * multiplier + addend for each lane. It does not promise fused rounding.

fn (a F32x16) eq(b F32x16) Mask32x16

eq returns a mask of the lanes where a is equal to b.

fn (a F32x16) ne(b F32x16) Mask32x16

ne returns a mask of the lanes where a is not equal to b.

fn (a F32x16) lt(b F32x16) Mask32x16

lt returns a mask of the lanes where a is less than b.

fn (a F32x16) le(b F32x16) Mask32x16

le returns a mask of the lanes where a is less than or equal to b.

fn (a F32x16) gt(b F32x16) Mask32x16

gt returns a mask of the lanes where a is greater than b.

fn (a F32x16) ge(b F32x16) Mask32x16

ge returns a mask of the lanes where a is greater than or equal to b.

fn (v F32x16) sum() f32

sum adds the lanes in lane order.

fn (v F32x16) min_element() int

min_element returns the index of the first lane holding the smallest value. NaN lanes are ignored. If every lane is NaN, it returns 0.

fn (v F32x16) min() f32

min returns the smallest lane value, the lane at index min_element(). NaN lanes are ignored unless every lane is NaN.

fn (v F32x16) max_element() int

max_element returns the index of the first lane holding the largest value. NaN lanes are ignored. If every lane is NaN, it returns 0.

fn (v F32x16) max() f32

max returns the largest lane value, the lane at index max_element(). NaN lanes are ignored unless every lane is NaN.

fn (a F32x16) dot(b F32x16) f32

dot multiplies corresponding lanes and adds the products in lane order.

fn (v F32x16) to_i32x16() I32x16

to_i32x16 converts each lane to i32. It truncates toward zero, maps NaN to 0 and saturates values outside the range of i32.

fn (v F32x16) to_u32x16() U32x16

to_u32x16 converts each lane to u32. It truncates toward zero, maps NaN to 0 and saturates values outside the range of u32.

struct F32x2 {
mut:
	values [2]f32
}

F32x2 holds 2 f32 lanes (64 bits).

fn (v F32x2) to_array() [2]f32

to_array returns the lanes in order.

fn (v F32x2) [] (i int) f32

[] returns lane i. It panics if i is out of range.

fn (mut v F32x2) []= (i int, value f32)

[]= sets lane i to value. It panics if i is out of range.

fn (v F32x2) store(mut dst []f32) !

store writes all 2 lanes to the start of dst. It returns an error if dst has fewer than 2 elements.

fn (v F32x2) store_part(mut dst []f32) !

store_part writes one lane for each element of dst, up to 2 elements. It returns an error if dst has more than 2 elements.

fn (v F32x2) store_at(mut dst []f32, offset int)

store_at writes all 2 lanes to dst, starting at dst[offset]. It panics if offset is negative or fewer than 2 elements follow it.

fn (a F32x2) + (b F32x2) F32x2

• adds corresponding lanes.

fn (a F32x2) - (b F32x2) F32x2

• subtracts corresponding lanes.

fn (a F32x2) * (b F32x2) F32x2

• multiplies corresponding lanes.

fn (a F32x2) / (b F32x2) F32x2

/ divides corresponding lanes.

fn (a F32x2) add(b F32x2) F32x2

add returns a + b.

fn (a F32x2) sub(b F32x2) F32x2

sub returns a - b.

fn (a F32x2) mul(b F32x2) F32x2

mul returns a * b.

fn (a F32x2) div(b F32x2) F32x2

div returns a / b.

fn (a F32x2) neg() F32x2

neg negates each lane.

fn (a F32x2) abs() F32x2

abs returns the absolute value of each lane by clearing its sign bit.

fn (a F32x2) minimum(b F32x2) F32x2

minimum returns the smaller of each pair of lanes. When one lane is NaN, the other lane is returned. Equal lanes, such as -0.0 and 0.0, return the lane of a.

fn (a F32x2) maximum(b F32x2) F32x2

maximum returns the larger of each pair of lanes. When one lane is NaN, the other lane is returned. Equal lanes, such as -0.0 and 0.0, return the lane of a.

fn (a F32x2) sqrt() F32x2

sqrt returns the square root of each lane.

fn (v F32x2) mul_add(multiplier F32x2, addend F32x2) F32x2

mul_add returns v * multiplier + addend for each lane. It does not promise fused rounding.

fn (a F32x2) eq(b F32x2) Mask32x2

eq returns a mask of the lanes where a is equal to b.

fn (a F32x2) ne(b F32x2) Mask32x2

ne returns a mask of the lanes where a is not equal to b.

fn (a F32x2) lt(b F32x2) Mask32x2

lt returns a mask of the lanes where a is less than b.

fn (a F32x2) le(b F32x2) Mask32x2

le returns a mask of the lanes where a is less than or equal to b.

fn (a F32x2) gt(b F32x2) Mask32x2

gt returns a mask of the lanes where a is greater than b.

fn (a F32x2) ge(b F32x2) Mask32x2

ge returns a mask of the lanes where a is greater than or equal to b.

fn (v F32x2) sum() f32

sum adds the lanes in lane order.

fn (v F32x2) min_element() int

min_element returns the index of the first lane holding the smallest value. NaN lanes are ignored. If every lane is NaN, it returns 0.

fn (v F32x2) min() f32

min returns the smallest lane value, the lane at index min_element(). NaN lanes are ignored unless every lane is NaN.

fn (v F32x2) max_element() int

max_element returns the index of the first lane holding the largest value. NaN lanes are ignored. If every lane is NaN, it returns 0.

fn (v F32x2) max() f32

max returns the largest lane value, the lane at index max_element(). NaN lanes are ignored unless every lane is NaN.

fn (a F32x2) dot(b F32x2) f32

dot multiplies corresponding lanes and adds the products in lane order.

fn (v F32x2) to_i32x2() I32x2

to_i32x2 converts each lane to i32. It truncates toward zero, maps NaN to 0 and saturates values outside the range of i32.

fn (v F32x2) to_u32x2() U32x2

to_u32x2 converts each lane to u32. It truncates toward zero, maps NaN to 0 and saturates values outside the range of u32.

struct F32x4 {
mut:
	values [4]f32
}

F32x4 holds 4 f32 lanes (128 bits).

fn (v F32x4) to_array() [4]f32

to_array returns the lanes in order.

fn (v F32x4) [] (i int) f32

[] returns lane i. It panics if i is out of range.

fn (mut v F32x4) []= (i int, value f32)

[]= sets lane i to value. It panics if i is out of range.

fn (v F32x4) store(mut dst []f32) !

store writes all 4 lanes to the start of dst. It returns an error if dst has fewer than 4 elements.

fn (v F32x4) store_part(mut dst []f32) !

store_part writes one lane for each element of dst, up to 4 elements. It returns an error if dst has more than 4 elements.

fn (v F32x4) store_at(mut dst []f32, offset int)

store_at writes all 4 lanes to dst, starting at dst[offset]. It panics if offset is negative or fewer than 4 elements follow it.