`nupp.simd`

Explicit SIMD support.

simd.species returns a species for an element: as wide as the running code's vector registers, and one lane wide where there are none, so a kernel is written once and species:over runs it a chunk at a time, the last chunk under its tail mask:

local array = require("nupp.mem.array")
local span = require("nupp.mem.span")
local simd = require("nupp.simd")

@aot
local function countQuotes(borrows source: span.Span<uint8>): uint32
    local species = simd.species(array.uint8)
    local found: uint32 = 0
    for at, active in species:over(#source) do
        found = found + ((species:load(source, at, active) == 34) & active):count()
    end
    return found
end

Loads are span-checked, inactive tail lanes read as zero, and bits() maps the first logical lane to bit zero. A vector and a mask have no boxed Lua representation in compiled code, where they are registers. In a body running as ordinary Lua a preferred species is one lane wide, so a vector is a number and a mask a boolean, and a fixed species simd.species(array.float, 4) is its four lanes, so a vector is a table of four numbers and a mask of four booleans. simd.vectors is the species where there are vector registers and nil where there are none, for a kernel that keeps a hand-written scalar loop of its own.

Use explicit vectors when SIMD execution is part of the algorithm: shuffles, transposes, prefix scans, fixed-tree reductions, gathers, compress, expand, or any loop that should run in vector lanes. simd.reducer accepts scalar contributions or explicit vector-plus-mask contributions, and simd.horizontal reduces a vector to one value.

See SIMD programming for the complete SIMD contract.

Module contents

Types

Type	Kind	Description
`AlgebraicDot`	record	A dot product permitting reassociation and multiply-add contraction.
`AlgebraicProduct`	record	A floating-point product whose named contract permits reassociation.
`AlgebraicSum`	record	A floating-point sum whose named contract permits reassociation.
`All`	record	Whether every contribution is true; true for an empty loop.
`AndBits`	record
`Any`	record	Whether any contribution is true; false for an empty loop.
`CompensatedSum`	record	A floating-point sum carrying the rounding error each addition discards.
`Count`	record	Counts true contributions exactly, modulo 2^64.
`Fixed`	interface	A target-neutral fixed logical lane count.
`IntegerArgMax`	record	First one-based logical position of the integer extremum; zero when empty.
`IntegerArgMin`	record	First one-based logical position of the integer extremum; zero when empty.
`IntegerMax`	record	An integer extremum including its initial value.
`IntegerMin`	record	An integer extremum including its initial value.
`Mask`	interface	One predicate bit per lane of Vector<T, S>.
`NumberArgMax`	record	First logical position, or zero when empty.
`NumberArgMin`	record	First logical position, or zero when empty.
`NumberMax`	record	Floating extremum including the initial value; NaNs are canonicalized.
`NumberMin`	record	Floating extremum including the initial value; NaNs are canonicalized.
`OrBits`	record
`OrderedDot`	record	A dot product committed in logical iteration order without contraction.
`OrderedProduct`	record	A floating-point product committed in logical iteration order.
`OrderedSum`	record	A floating-point sum committed in logical iteration order.
`PairwiseDot`	record	A non-contracting dot product using the adjacent-pair sum tree.
`PairwiseProduct`	record	A floating-point product using the width-independent adjacent-pair tree.
`PairwiseSum`	record	A floating-point sum using the width-independent adjacent-pair tree.
`Preferred`	interface	Target-selected native species identity.
`PropagatingArgMax`	record	First logical position, or zero when empty.
`PropagatingArgMin`	record	First logical position, or zero when empty.
`PropagatingMax`	record	Floating extremum including the initial value; NaNs are canonicalized.
`PropagatingMin`	record	Floating extremum including the initial value; NaNs are canonicalized.
`Reducer`	interface	What every reducer shares: contributions go in through add, and value returns the finished reduction as a T.
`Species`	interface	Operations whose lane count is selected from T and S at AOT lowering.
`Vector`	interface	An immutable register-as-data value.
`WrappingProduct`	record
`WrappingSum`	record	Fixed-width reducers name their element with its array witness, as a species does.
`XorBits`	record

Functions

Function	Kind	Description
`horizontal.algebraicDot`	function	As ordinary Lua the vectors are one lane each, which is the product.
`horizontal.algebraicProduct`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.algebraicSum`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.andBits`	function	The bitwise and of every lane of an integer vector.
`horizontal.integerMax`	function	The largest lane of an integer vector, by the element's signedness.
`horizontal.integerMin`	function	The smallest lane of an integer vector, by the element's signedness.
`horizontal.numberArgMax`	function	As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.
`horizontal.numberArgMin`	function	As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.
`horizontal.numberMax`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.numberMin`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.orBits`	function	The bitwise or of every lane of an integer vector.
`horizontal.orderedDot`	function	As ordinary Lua the vectors are one lane each, which is the product.
`horizontal.orderedProduct`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.orderedSum`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.pairwiseDot`	function	As ordinary Lua the vectors are one lane each, which is the product.
`horizontal.pairwiseProduct`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.pairwiseSum`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.propagatingArgMax`	function	As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.
`horizontal.propagatingArgMin`	function	The one-based lane holding the matching reduction's answer.
`horizontal.propagatingMax`	function	As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.
`horizontal.propagatingMin`	function	The smallest lane, and the largest, under the contract the name selects.
`horizontal.wrappingProduct`	function	The lanes of an integer vector multiplied, wrapping in the lane's width.
`horizontal.wrappingSum`	function	The lanes of an integer vector summed, wrapping in the lane's own width: a byte vector's sum wraps at a byte, as...
`horizontal.xorBits`	function	The bitwise exclusive or of every lane of an integer vector.
`lane.binary`	function
`lane.fromStorage`	function	The N-lane vector a stored Fixed field holds: storage is the field's C array, lane i at index i - 1, each wrapped...
`lane.method`	function
`lane.unary`	function
`reducer.all`	function	Constructs an all reducer.
`reducer.andBits`	function	Constructs a bitwise and over element, including the supplied initial value.
`reducer.any`	function	Constructs an any reducer.
`reducer.count`	function	Constructs a count reducer.
`reducer.integerArgMax`	function	Constructs an integer argmax reducer.
`reducer.integerArgMin`	function	Constructs an integer argmin reducer.
`reducer.integerMax`	function	Constructs an integer max reducer.
`reducer.integerMin`	function	Constructs an integer min reducer.
`reducer.orBits`	function	Constructs a bitwise or over element, including the supplied initial value.
`reducer.wrappingProduct`	function	Constructs a wrapping product over element, including the supplied initial value.
`reducer.wrappingSum`	function	Constructs a wrapping sum over element, including the supplied initial value.
`reducer.xorBits`	function	Constructs a bitwise exclusive or over element, including the supplied initial value.
`transpose`	function	Transposes a square tile of Fixed row vectors into N column vectors.

Values

Value	Kind	Description
`horizontal`	variable	Named horizontal operations over an explicit register value.
`lane`	variable	The lane operations, as the code generator calls them for a value the checker typed as a vector or a mask: a binary...
`reducer`	variable	Closed reduction values for scalar or explicit masked vector contributions.

Types#

`AlgebraicDot`record#

record simd.AlgebraicDot<T is float | number> is simd.Reducer<T> ...

A dot product permitting reassociation and multiply-add contraction.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them. Ordinary Lua rounds each product before adding it; native lowering may fuse the two.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, left: T | simd.Vector<T, S>, right: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the do block around it. As ordinary Lua a preferred species is one lane wide, so the vector is that lane's value and the mask a boolean; a fixed species contributes its lanes in order, each under its own lane of the mask.

Arguments

Name	Type	Description
`self`	`any`
`left`	`T \| simd.Vector<T, S>`
`right`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`AlgebraicProduct`record#

record simd.AlgebraicProduct<T is float | number> is simd.Reducer<T> ...

A floating-point product whose named contract permits reassociation.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`AlgebraicSum`record#

record simd.AlgebraicSum<T is float | number> is simd.Reducer<T> ...

A floating-point sum whose named contract permits reassociation.

Ordinary Lua has no lane width to exploit, so its executable reference uses a left fold. Native lowering may use several accumulators.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`All`record#

record simd.All is simd.Reducer<boolean> ...

Whether every contribution is true; true for an empty loop.

Members

Name	Kind	Description
`total`	field
`add`	method	active selects the lanes of a mask that contribute, each lane's truth in lane order, as one masked contribution per...
`value`	method

`total`field#

total: boolean

@private

`add`method#

add: function add<T, S>(self, value: boolean | simd.Mask<T, S>, active: simd.Mask<T, S>?): nil

active selects the lanes of a mask that contribute, each lane's truth in lane order, as one masked contribution per iteration of the do block around it. As ordinary Lua a preferred species is one lane wide, so both masks are booleans; a fixed species contributes its lanes in order, each under its own lane of active.

Arguments

Name	Type	Description
`self`	`any`
`value`	`boolean \| simd.Mask<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): boolean

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`boolean`

`AndBits`record#

record simd.AndBits<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`operation`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: T

@private

`operation`method#

operation: function(T, T): T

@private

Arguments

Name	Type	Description
`?`	`T`
`?`	`T`

Returns

Type	Description
`T`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`Any`record#

record simd.Any is simd.Reducer<boolean> ...

Whether any contribution is true; false for an empty loop.

Members

Name	Kind	Description
`total`	field
`add`	method	active selects the lanes of a mask that contribute, each lane's truth in lane order, as one masked contribution per...
`value`	method

`total`field#

total: boolean

@private

`add`method#

add: function add<T, S>(self, value: boolean | simd.Mask<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`boolean \| simd.Mask<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): boolean

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`boolean`

`CompensatedSum`record#

record simd.CompensatedSum<T is float | number> is simd.Reducer<T> ...

A floating-point sum carrying the rounding error each addition discards.

Ordered, pairwise and algebraic sums differ in how they associate, and each discards the low bits of every addition it makes. This one keeps them: the part that did not fit rides alongside the running total and is added back at the end, which recovers the totals an ordered sum loses entirely -- 1 + 1e100 + 1 - 1e100 returns two here and zero there.

Compensating is not the same as exact. The answer is enormously closer to the correctly rounded total than the other three, and like them it still depends on the order the contributions arrived in, which is why its contribution edges stay serial rather than being reassociated.

Neumaier's form rather than Kahan's: it compensates the larger operand as well as the smaller, so a large value added to a small running total does not lose its correction, which is the case plain Kahan gets wrong.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them. A float reducer keeps its total and its compensation in binary32.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`compensation`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`compensation`field#

compensation: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`Count`record#

record simd.Count is simd.Reducer<uint64> ...

Counts true contributions exactly, modulo 2^64.

Members

Name	Kind	Description
`total`	field
`add`	method	active selects the lanes of a mask that contribute, each lane's truth in lane order, as one masked contribution per...
`value`	method

`total`field#

total: uint64

@private

`add`method#

add: function add<T, S>(self, value: boolean | simd.Mask<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`boolean \| simd.Mask<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): uint64

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`uint64`

`Fixed`interface#

sealed interface simd.Fixed<const N: integer>

A target-neutral fixed logical lane count.

Type parameters

Name	Description
`N`

`IntegerArgMax`record#

record simd.IntegerArgMax<T is int32 | uint32 | int64 | uint64> is simd.Reducer<integer> ...

First one-based logical position of the integer extremum; zero when empty.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: T?

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of the do block around it. Lane i of the vector has logical position base + i, where base advances by the species' lane count for every vector contribution and by one for every scalar one, whether or not a lane was active. As ordinary Lua a preferred species is one lane wide, so the vector is that lane's value and the mask a boolean; a fixed species contributes its lanes in order, each taking a position.

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`IntegerArgMin`record#

record simd.IntegerArgMin<T is int32 | uint32 | int64 | uint64> is simd.Reducer<integer> ...

First one-based logical position of the integer extremum; zero when empty.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: T?

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`IntegerMax`record#

record simd.IntegerMax<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

An integer extremum including its initial value.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: T

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`IntegerMin`record#

record simd.IntegerMin<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

An integer extremum including its initial value.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: T

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`Mask`interface#

sealed interface simd.Mask<T, S> ...

One predicate bit per lane of Vector<T, S>.

Type parameters

Name	Description
`T`
`S`

Members

Name	Kind	Description
`__eq`	metamethod
`__unm`	metamethod
`select`	method
`any`	method
`all`	method
`count`	method
`first`	method	Returns the first set lane, or zero when the mask is empty.
`bits`	method	Returns lane bits in a uint64; bit zero denotes lane one.

`__eq`metamethod#

__eq: function(left: simd.Mask<T, S>, right: simd.Mask<T, S>): simd.Mask<T, S>

Arguments

Name	Type	Description
`left`	`simd.Mask<T, S>`
`right`	`simd.Mask<T, S>`

Returns

Type	Description
`simd.Mask<T, S>`

`__unm`metamethod#

__unm: function(value: simd.Mask<T, S>): simd.Mask<T, S>

Arguments

Name	Type	Description
`value`	`simd.Mask<T, S>`

Returns

Type	Description
`simd.Mask<T, S>`

`select`method#

select: function(
    borrows self: simd.Mask<T, S>,
    whenTrue: simd.Vector<T, S> | T,
    whenFalse: simd.Vector<T, S> | T
): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`
`whenTrue`	`simd.Vector<T, S> \| T`
`whenFalse`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`any`method#

any: function(borrows self: simd.Mask<T, S>): boolean

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`

Returns

Type	Description
`boolean`

`all`method#

all: function(borrows self: simd.Mask<T, S>): boolean

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`

Returns

Type	Description
`boolean`

`count`method#

count: function(borrows self: simd.Mask<T, S>): uint32

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`

Returns

Type	Description
`uint32`

`first`method#

first: function(borrows self: simd.Mask<T, S>): uint32

Returns the first set lane, or zero when the mask is empty.

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`

Returns

Type	Description
`uint32`

`bits`method#

bits: function(borrows self: simd.Mask<T, S>): uint64

Returns lane bits in a uint64; bit zero denotes lane one.

Arguments

Name	Type	Description
`borrows self`	`simd.Mask<T, S>`

Returns

Type	Description
`uint64`

`NumberArgMax`record#

record simd.NumberArgMax<T is float | number> is simd.Reducer<integer> ...

First logical position, or zero when empty. A number wins over every NaN. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: number

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`NumberArgMin`record#

record simd.NumberArgMin<T is float | number> is simd.Reducer<integer> ...

First logical position, or zero when empty. A number wins over every NaN. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: number

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`NumberMax`record#

record simd.NumberMax<T is float | number> is simd.Reducer<T> ...

Floating extremum including the initial value; NaNs are canonicalized. A number wins over every NaN. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: number

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`NumberMin`record#

record simd.NumberMin<T is float | number> is simd.Reducer<T> ...

Floating extremum including the initial value; NaNs are canonicalized. A number wins over every NaN. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: number

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`OrBits`record#

record simd.OrBits<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`operation`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: T

@private

`operation`method#

operation: function(T, T): T

@private

Arguments

Name	Type	Description
`?`	`T`
`?`	`T`

Returns

Type	Description
`T`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`OrderedDot`record#

record simd.OrderedDot<T is float | number> is simd.Reducer<T> ...

A dot product committed in logical iteration order without contraction.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them. Each product rounds before it is added.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, left: T | simd.Vector<T, S>, right: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`left`	`T \| simd.Vector<T, S>`
`right`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`OrderedProduct`record#

record simd.OrderedProduct<T is float | number> is simd.Reducer<T> ...

A floating-point product committed in logical iteration order.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`OrderedSum`record#

record simd.OrderedSum<T is float | number> is simd.Reducer<T> ...

A floating-point sum committed in logical iteration order.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: number

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`PairwiseDot`record#

record simd.PairwiseDot<T is float | number> is simd.Reducer<T> ...

A non-contracting dot product using the adjacent-pair sum tree.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`sum`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`sum`field#

sum: simd.PairwiseSum<T>

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, left: T | simd.Vector<T, S>, right: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`left`	`T \| simd.Vector<T, S>`
`right`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`PairwiseProduct`record#

record simd.PairwiseProduct<T is float | number> is simd.Reducer<T> ...

A floating-point product using the width-independent adjacent-pair tree.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`partials`	field
`count`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`partials`field#

partials: {number?}

@private

`count`field#

count: integer

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`PairwiseSum`record#

record simd.PairwiseSum<T is float | number> is simd.Reducer<T> ...

A floating-point sum using the width-independent adjacent-pair tree.

T is the element it accumulates in: number is binary64, and float is binary32, each contribution and every operation's result rounded as nupp.math.f32 rounds them.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`partials`	field
`count`	field
`round`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`partials`field#

partials: {number?}

@private

`count`field#

count: integer

@private

`round`method#

round: function(number): number

@private

Arguments

Name	Type	Description
`?`	`number`

Returns

Type	Description
`number`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`Preferred`interface#

sealed interface simd.Preferred

Target-selected native species identity.

`PropagatingArgMax`record#

record simd.PropagatingArgMax<T is float | number> is simd.Reducer<integer> ...

First logical position, or zero when empty. A NaN wins over every number. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: number

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`PropagatingArgMin`record#

record simd.PropagatingArgMin<T is float | number> is simd.Reducer<integer> ...

First logical position, or zero when empty. A NaN wins over every number. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`position`	field
`count`	field
`add`	method	active selects the lanes of a vector that are candidates, in lane order, as one masked contribution per iteration of...
`value`	method

`best`field#

best: number

@private

`position`field#

position: integer

@private

`count`field#

count: integer

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): integer

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`integer`

`PropagatingMax`record#

record simd.PropagatingMax<T is float | number> is simd.Reducer<T> ...

Floating extremum including the initial value; NaNs are canonicalized. A NaN wins over every number. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: number

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`PropagatingMin`record#

record simd.PropagatingMin<T is float | number> is simd.Reducer<T> ...

Floating extremum including the initial value; NaNs are canonicalized. A NaN wins over every number. Signed zero follows -0 < +0.

T is the element: number or float. An extremum rounds nothing, so the two differ only in what a vector contribution is a vector of.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`best`	field
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`best`field#

best: number

@private

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`Reducer`interface#

interface simd.Reducer<T> ...

What every reducer shares: contributions go in through add, and value returns the finished reduction as a T.

What add takes depends on the family -- one value, two for a dot product, and an optional mask beside a vector -- so this names the member without fixing its parameters. Contribute through the concrete reducer; code that only finishes a reduction can take any Reducer<T>.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`add`	method	Contributes to the reduction; the concrete reducer states its parameters.
`value`	method	Returns the finished reduction.

`add`method#

add: function(self: simd.Reducer<T>, value: never, ...: never): nil

@readonly

Contributes to the reduction; the concrete reducer states its parameters.

Arguments

Name	Type	Description
`self`	`simd.Reducer<T>`
`value`	`never`
`...`	`never`

Returns

Type	Description
`nil`

`value`method#

value: function(self: simd.Reducer<T>): T

@readonly

Returns the finished reduction.

Arguments

Name	Type	Description
`self`	`simd.Reducer<T>`

Returns

Type	Description
`T`

`Species`interface#

sealed interface simd.Species<T, S> ...

Operations whose lane count is selected from T and S at AOT lowering.

Type parameters

Name	Description
`T`
`S`

Members

Name	Kind	Description
`lanes`	field
`convert`	method	Converts each lane using LuaJIT FFI numeric conversion rules.
`reinterpret`	method	Preserves every lane's bits.
`widen`	method	The species of the next wider element of this one's family and signedness -- uint8 to uint16, int32 to int64, float...
`narrow`	method	The species of the next narrower element with this species' lane count, the inverse of widen: a widened species...
`splat`	method
`iota`	method
`tail`	method
`mask`	method	A mask of this species: every lane from one boolean, or lane for lane from another species' mask with the same lane...
`over`	method	The chunks of a span of count elements, for a loop written once: for at, active in species:over(input) do ...
`map`	method	A scalar operation on every lane: a closed-set math operation such as math.sqrt over a floating species, one of the...
`load`	method	The next lanes of a span from offset, or one named field of its rows.
`store`	method	Writes the next lanes of a span or one named field of its rows.
`loadPairs`	method	The next 2 lanes elements from offset, dealt out a lane at a time: the first vector holds the elements at odd...
`loadTriples`	method	The next 3 lanes elements, lane i of the jth vector reading element 3 (i - 1) + j of the run.
`loadQuads`	method	The next 4 lanes elements, lane i of the jth vector reading element 4 (i - 1) + j of the run.
`storePairs`	method	The inverse of loadPairs: 2 lanes elements from offset, alternating a lane of first with the same lane of second.
`storeTriples`	method	The inverse of loadTriples.
`storeQuads`	method	The inverse of loadQuads.
`gather`	method	Reads one-based element indices.
`scatter`	method	Writes one-based element indices, ignoring inactive or out-of-range lanes.
`scatterUnchecked`	method	Asserts that all active indices are unique, without checking them.

`lanes`field#

lanes: uint32

@readonly

`convert`method#

convert: function<U>(borrows self: simd.Species<T, S>, value: simd.Vector<U, S>): simd.Vector<T, S>

Converts each lane using LuaJIT FFI numeric conversion rules. Integer narrowing keeps low bits; float-to-integer truncates through int64, except uint64 which accepts the union of signed and unsigned ranges. Integer-to-float follows LuaJIT's double intermediate, including the possible double rounding when converting a 64-bit integer to float. NaN, infinities and out-of-range inputs have target-specific results, never undefined behavior. Both species must have the same lane count.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`value`	`simd.Vector<U, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`reinterpret`method#

reinterpret: function<U>(borrows self: simd.Species<T, S>, value: simd.Vector<U, S>): simd.Vector<T, S>

Preserves every lane's bits. Element widths and lane counts must match.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`value`	`simd.Vector<U, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`widen`method#

widen: function<W>(borrows self: simd.Species<T, S>, wider: StorageWitness<W>): simd.Species<W, S>

The species of the next wider element of this one's family and signedness -- uint8 to uint16, int32 to int64, float to number -- with this species' logical lane count, named by the wider element's storage witness. A Fixed<N> species widens to the Fixed<N> species of that element. A Preferred one widens to a species holding as many lanes as its own register does, twice what the wider element's preferred species holds, so a widened vector occupies two native registers the way a Fixed<N> past one register does. It is the species a byte kernel converts into for a sum its bytes would overflow, without naming a register width:

local bytes = assert(simd.species(array.uint8))
local wide = bytes:widen(array.uint16)
local weighted = wide:convert(bytes:load(reds, at + 1)) * 77

The widened species keeps the checker's species identity S, so it reads as simd.Species<uint16, simd.Preferred>, the type simd.species(array.uint16) also has. They are different species once the function is lowered, one with the lane count of a uint8 register and the other with its own, and a vector of one meets a vector of the other only through convert, which is refused there when the counts differ. Nothing is wider than 64 bits: widening a 64-bit species is refused where the function is lowered, as is a witness that is not the next wider element.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`wider`	`StorageWitness<W>`

Returns

Type	Description
`simd.Species<W, S>`

`narrow`method#

narrow: function<W>(borrows self: simd.Species<T, S>, narrower: StorageWitness<W>): simd.Species<W, S>

The species of the next narrower element with this species' lane count, the inverse of widen: a widened species narrows back to the species it came from, and a Preferred species narrows to one holding half the lanes the narrower element's own register does. Nothing is narrower than 8 bits.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`narrower`	`StorageWitness<W>`

Returns

Type	Description
`simd.Species<W, S>`

`splat`method#

splat: function(borrows self: simd.Species<T, S>, value: T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`value`	`T`

Returns

Type	Description
`simd.Vector<T, S>`

`iota`method#

iota: function(borrows self: simd.Species<T, S>, first: T, step: T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`first`	`T`
`step`	`T`

Returns

Type	Description
`simd.Vector<T, S>`

`tail`method#

tail: function(borrows self: simd.Species<T, S>, active: integer): simd.Mask<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`active`	`integer`

Returns

Type	Description
`simd.Mask<T, S>`

`mask`method#

mask: function(borrows self: simd.Species<T, S>, value: boolean): simd.Mask<T, S>
& function<U>(borrows self: simd.Species<T, S>, value: simd.Mask<U, S>): simd.Mask<T, S>

A mask of this species: every lane from one boolean, or lane for lane from another species' mask with the same lane count, which is what carries a comparison of one element type to a select on another.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`value`	`boolean`

Returns

Type	Description
`simd.Mask<T, S>`

`over`method#

over: function(borrows self: simd.Species<T, S>, count: integer): function(): (uint32?, simd.Mask<T, S>)

The chunks of a span of count elements, for a loop written once: for at, active in species:over(#input) do ... end visits every element from offset one, lanes at a time, binding at to the one-based offset of the chunk and active to its mask. Every chunk but the last is full, and an access under its mask is the unmasked one the loop's own bound proves; the last chunk's mask is the tail. Pass active to every load and store, and to every reducer contribution, and the loop is the whole strip-mined algorithm: no separate tail, no scalar continuation.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`count`	`integer`

Returns

Type	Description
`function(): (uint32?, simd.Mask<T, S>)`

`map`method#

map: function(
    borrows self: simd.Species<T, S>,
    operation: function(...: any): T | number,
    ...: simd.Vector<T, S>
): simd.Vector<T, S>

A scalar operation on every lane: a closed-set math operation such as math.sqrt over a floating species, one of the corrected binary32 operations nupp.math.f32.fma, min and max over a float species, or a pure helper of this element taking one argument per vector. The operands must be locals.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`operation`	`function(...: any): T \| number`
`...`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`load`method#

load: function(
    borrows self: simd.Species<T, S>,
    borrows source: Span<T>,
    offset: integer,
    active: simd.Mask<T, S>?
): simd.Vector<T, S>
    & function<E>(
        borrows self: simd.Species<T, S>,
        borrows source: Span<E>,
        offset: integer,
        field: string,
        active: simd.Mask<T, S>?
    ): simd.Vector<T, S>

    & function(
        borrows self: simd.Species<T, S>,
        borrows source: WriteSpan<T>,
        offset: integer,
        active: simd.Mask<T, S>?
    ): simd.Vector<T, S>
    & function<E>(
        borrows self: simd.Species<T, S>,
        borrows source: WriteSpan<E>,
        offset: integer,
        field: string,
        active: simd.Mask<T, S>?
    ): simd.Vector<T, S>
    & function<E>(
        borrows self: simd.Species<T, S>,
        borrows source: SoaWriteToken & SoaWriteSpan<E>,
        offset: integer,
        field: string,
        active: simd.Mask<T, S>?
    ): simd.Vector<T, S>
    & function(
        borrows self: simd.Species<T, S>,
        borrows source: SoaReadView,
        offset: integer,
        field: string,
        active: simd.Mask<T, S>?
    ): simd.Vector<T, S>

The next lanes of a span from offset, or one named field of its rows. A field in a span of structs is strided; a SoA row field is contiguous. active limits the lanes. The vector retains no storage borrow.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`borrows source`	`Span<E>`
`offset`	`integer`
`field`	`string`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`simd.Vector<T, S>`

`store`method#

store: function(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    offset: integer,
    value: simd.Vector<T, S>,
    active: simd.Mask<T, S>?
): nil
    & function<E>(
        borrows self: simd.Species<T, S>,
        exclusive destination: WriteSpan<E>,
        offset: integer,
        field: string,
        value: simd.Vector<T, S>,
        active: simd.Mask<T, S>?
    ): nil
    & function<E>(
        borrows self: simd.Species<T, S>,
        exclusive destination: SoaWriteToken & SoaWriteSpan<E>,
        offset: integer,
        field: string,
        value: simd.Vector<T, S>,
        active: simd.Mask<T, S>?
    ): nil

Writes the next lanes of a span or one named field of its rows. Other fields are unchanged.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<E>`
`offset`	`integer`
`field`	`string`
`value`	`simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`loadPairs`method#

loadPairs: function(
    borrows self: simd.Species<T, S>,
    borrows source: Span<T>,
    offset: integer
): (simd.Vector<T, S>, simd.Vector<T, S>)
    & function(
        borrows self: simd.Species<T, S>,
        borrows source: WriteSpan<T>,
        offset: integer
    ): (simd.Vector<T, S>, simd.Vector<T, S>)

The next 2 * lanes elements from offset, dealt out a lane at a time: the first vector holds the elements at odd positions of the run and the second those at even ones, so interleaved pairs arrive as two vectors of their halves. Elements past the span read zero. The results initialize locals, local re, im = s:loadPairs(zs, at + 1).

On NEON this is one ld2; loadTriples and loadQuads are ld3 and ld4, which is what a three-byte or four-byte record costs to de-interleave there.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`borrows source`	`Span<T>`
`offset`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`
`simd.Vector<T, S>`

`loadTriples`method#

loadTriples: function(
    borrows self: simd.Species<T, S>,
    borrows source: Span<T>,
    offset: integer
): (simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>)
    & function(
        borrows self: simd.Species<T, S>,
        borrows source: WriteSpan<T>,
        offset: integer
    ): (simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>)

The next 3 * lanes elements, lane i of the jth vector reading element 3 * (i - 1) + j of the run.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`borrows source`	`Span<T>`
`offset`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`
`simd.Vector<T, S>`
`simd.Vector<T, S>`

`loadQuads`method#

loadQuads: function(
    borrows self: simd.Species<T, S>,
    borrows source: Span<T>,
    offset: integer
): (simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>)
    & function(
        borrows self: simd.Species<T, S>,
        borrows source: WriteSpan<T>,
        offset: integer
    ): (simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>, simd.Vector<T, S>)

The next 4 * lanes elements, lane i of the jth vector reading element 4 * (i - 1) + j of the run.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`borrows source`	`Span<T>`
`offset`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`
`simd.Vector<T, S>`
`simd.Vector<T, S>`
`simd.Vector<T, S>`

`storePairs`method#

storePairs: function(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    offset: integer,
    first: simd.Vector<T, S>,
    second: simd.Vector<T, S>
): nil

The inverse of loadPairs: 2 * lanes elements from offset, alternating a lane of first with the same lane of second. Elements past the span are not written.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<T>`
`offset`	`integer`
`first`	`simd.Vector<T, S>`
`second`	`simd.Vector<T, S>`

Returns

Type	Description
`nil`

`storeTriples`method#

storeTriples: function(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    offset: integer,
    first: simd.Vector<T, S>,
    second: simd.Vector<T, S>,
    third: simd.Vector<T, S>
): nil

The inverse of loadTriples.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<T>`
`offset`	`integer`
`first`	`simd.Vector<T, S>`
`second`	`simd.Vector<T, S>`
`third`	`simd.Vector<T, S>`

Returns

Type	Description
`nil`

`storeQuads`method#

storeQuads: function(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    offset: integer,
    first: simd.Vector<T, S>,
    second: simd.Vector<T, S>,
    third: simd.Vector<T, S>,
    fourth: simd.Vector<T, S>
): nil

The inverse of loadQuads.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<T>`
`offset`	`integer`
`first`	`simd.Vector<T, S>`
`second`	`simd.Vector<T, S>`
`third`	`simd.Vector<T, S>`
`fourth`	`simd.Vector<T, S>`

Returns

Type	Description
`nil`

`gather`method#

gather: function<I>(
    borrows self: simd.Species<T, S>,
    borrows source: Span<T>,
    indices: simd.Vector<I, S>,
    active: simd.Mask<T, S>?
): simd.Vector<T, S>

Reads one-based element indices. Inactive or out-of-range lanes return zero. Indices use int32, uint32, int64 or uint64 and must have the same logical lane count as this species at every emitted tier.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`borrows source`	`Span<T>`
`indices`	`simd.Vector<I, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`simd.Vector<T, S>`

`scatter`method#

scatter: function<I>(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    indices: simd.Vector<I, S>,
    value: simd.Vector<T, S>,
    active: simd.Mask<T, S>?
): nil

Writes one-based element indices, ignoring inactive or out-of-range lanes. The compiler must prove that indices are unique; currently a directly supplied constant, non-wrapping iota provides that proof. No runtime collision check is emitted.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<T>`
`indices`	`simd.Vector<I, S>`
`value`	`simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`scatterUnchecked`method#

scatterUnchecked: function<I>(
    borrows self: simd.Species<T, S>,
    exclusive destination: WriteSpan<T>,
    indices: simd.Vector<I, S>,
    value: simd.Vector<T, S>,
    active: simd.Mask<T, S>?
): nil

Asserts that all active indices are unique, without checking them. Duplicate active indices are undefined behavior, even if the values agree. This promises no winning lane or accumulation order and does not authorize collisions between separate scatter operations. Bounds and inactive lanes behave as in scatter.

Arguments

Name	Type	Description
`borrows self`	`simd.Species<T, S>`
`exclusive destination`	`WriteSpan<T>`
`indices`	`simd.Vector<I, S>`
`value`	`simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`Vector`interface#

sealed interface simd.Vector<T, S> ...

An immutable register-as-data value.

Type parameters

Name	Description
`T`
`S`

Members

Name	Kind	Description
`__add`	metamethod
`__sub`	metamethod
`__mul`	metamethod
`__div`	metamethod
`__mod`	metamethod	% and // are Lua's: the remainder takes the divisor's sign and the quotient rounds toward negative infinity, lane by...
`__unm`	metamethod
`__eq`	metamethod
`__lt`	metamethod
`__le`	metamethod
`propagatingMin`	method	The smaller of each lane pair, and the larger, under the contract the name selects.
`propagatingMax`	method
`numberMin`	method	numberMin returns the operand that is not NaN, and the canonical NaN only when both are, which is IEEE-754's minNum.
`numberMax`	method
`fma`	method	self multiplier + addend with one rounding per lane: the product is exact and only the sum rounds, so the two-step...
`saturatingAdd`	method	self + other and self - other clamped to the element's range rather than wrapped: a byte that would reach 300...
`saturatingSub`	method
`popcount`	method	The number of one bits in each lane's two's complement representation at the element's width, so -1 on a signed byte...
`mulHigh`	method	The high half of each lane's full-width product: the bits above the element's width of self other taken at twice...
`extract`	method	Lane indices are one-based and decided when the function is lowered: a literal, the species' lanes, or +, - and over...
`insert`	method
`reverse`	method	Reverses logical lane order.
`interleave`	method	Alternates lanes from self and other, then splits that sequence into two species-width results.
`deinterleave`	method	Returns the odd and even lanes of self followed by other.
`rotateLeft`	method	Rotates logical lanes.
`rotateRight`	method
`align`	method	Selects a species-width window from previous ..
`swizzle`	method	Every lane read from another lane this vector names at run time.
`compress`	method	Packs selected lanes toward lane one and zeroes the remainder.
`expand`	method	Distributes packed lanes into selected positions and zeroes the rest.
`orderedPrefixSum`	method	Inclusive, logical-lane-order prefix operations.
`prefixXor`	method

`__add`metamethod#

__add: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`__sub`metamethod#

__sub: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`__mul`metamethod#

__mul: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`__div`metamethod#

__div: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`__mod`metamethod#

__mod: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Vector<T, S>

% and // are Lua's: the remainder takes the divisor's sign and the quotient rounds toward negative infinity, lane by lane, as a - floor(a / b) * b and floor(a / b) on a floating species and exactly on an integer one. An integer lane divided by zero returns zero, as / does, rather than trapping.

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`__unm`metamethod#

__unm: function(value: simd.Vector<T, S>): simd.Vector<T, S>

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`__eq`metamethod#

__eq: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Mask<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Mask<T, S>`

`__lt`metamethod#

__lt: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Mask<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Mask<T, S>`

`__le`metamethod#

__le: function(left: simd.Vector<T, S>, right: simd.Vector<T, S> | T): simd.Mask<T, S>

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Mask<T, S>`

`propagatingMin`method#

propagatingMin: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

The smaller of each lane pair, and the larger, under the contract the name selects. There is no unqualified min: the two disagree on every pair containing a NaN, and which one a program wanted is not recoverable from the call.

propagatingMin returns the canonical NaN whenever either operand is NaN, which is nupp.math.f32.min's contract and what makes a reduction built on it independent of which lane the NaN landed in and of how many lanes the target chose. -0 is the smaller zero and +0 the larger, so an equal pair of zeros is ordered by sign rather than by position. -inf and +inf are ordinary values at the ends of the order.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`propagatingMax`method#

propagatingMax: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`numberMin`method#

numberMin: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

numberMin returns the operand that is not NaN, and the canonical NaN only when both are, which is IEEE-754's minNum. It is the contract for a scan looking for the smallest real measurement in data that carries NaN for a missing one. Zeros and infinities behave as they do above.

A reduction over it depends on how many lanes were NaN, which is the price of ignoring them and the reason it is not the default.

An integer element has no NaN, so the two contracts coincide there and either spelling returns the same value.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`numberMax`method#

numberMax: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`fma`method#

fma: function(
    borrows self: simd.Vector<T, S>,
    multiplier: simd.Vector<T, S> | T,
    addend: simd.Vector<T, S> | T
): simd.Vector<T, S>

self * multiplier + addend with one rounding per lane: the product is exact and only the sum rounds, so the two-step form's second rounding, and its overflow in a product the sum would have brought back, do not happen. On a float species this is nupp.math.f32.fma's contract, the binary64 fused operation on a number one, and a NaN lane returns the canonical NaN either way. A floating species only; an integer product has nothing to round.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`multiplier`	`simd.Vector<T, S> \| T`
`addend`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`saturatingAdd`method#

saturatingAdd: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

self + other and self - other clamped to the element's range rather than wrapped: a byte that would reach 300 returns 255, and an unsigned lane taken below zero returns zero. An integer species only.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`saturatingSub`method#

saturatingSub: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`popcount`method#

popcount: function(borrows self: simd.Vector<T, S>): simd.Vector<T, S>

The number of one bits in each lane's two's complement representation at the element's width, so -1 on a signed byte returns 8. An integer species only.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`mulHigh`method#

mulHigh: function(borrows self: simd.Vector<T, S>, other: simd.Vector<T, S> | T): simd.Vector<T, S>

The high half of each lane's full-width product: the bits above the element's width of self * other taken at twice that width, signed or unsigned as the element is. * returns the low half, so the two together are the whole product; alone, this is the fixed-point multiply, (a * b) >> bits, that a scaled reciprocal turns a division into. An integer species only.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S> \| T`

Returns

Type	Description
`simd.Vector<T, S>`

`extract`method#

extract: function(borrows self: simd.Vector<T, S>, lane: integer): T

Lane indices are one-based and decided when the function is lowered: a literal, the species' lanes, or +, - and * over those, so lanes names the last lane of any species and lanes - 1 the one before it. An index past the lanes the tier gives the species is refused there.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`lane`	`integer`

Returns

Type	Description
`T`

`insert`method#

insert: function(borrows self: simd.Vector<T, S>, lane: integer, value: T): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`lane`	`integer`
`value`	`T`

Returns

Type	Description
`simd.Vector<T, S>`

`reverse`method#

reverse: function(borrows self: simd.Vector<T, S>): simd.Vector<T, S>

Reverses logical lane order.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`interleave`method#

interleave: function(
    borrows self: simd.Vector<T, S>,
    other: simd.Vector<T, S>
): (simd.Vector<T, S>, simd.Vector<T, S>)

Alternates lanes from self and other, then splits that sequence into two species-width results. No lane bits are changed.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`
`simd.Vector<T, S>`

`deinterleave`method#

deinterleave: function(
    borrows self: simd.Vector<T, S>,
    other: simd.Vector<T, S>
): (simd.Vector<T, S>, simd.Vector<T, S>)

Returns the odd and even lanes of self followed by other. This is the inverse of interleave, including for odd logical lane counts.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`
`simd.Vector<T, S>`

`rotateLeft`method#

rotateLeft: function(borrows self: simd.Vector<T, S>, count: integer): simd.Vector<T, S>

Rotates logical lanes. Counts are reduced modulo the species width.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`count`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`

`rotateRight`method#

rotateRight: function(borrows self: simd.Vector<T, S>, count: integer): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`count`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`

`align`method#

align: function(borrows self: simd.Vector<T, S>, previous: simd.Vector<T, S>, offset: integer): simd.Vector<T, S>

Selects a species-width window from previous .. self. Offset zero returns self; positive offsets bring trailing lanes of previous into the beginning. The offset is decided when the function is lowered, on the terms extract's lane is, and one past the lanes returns previous whole.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`previous`	`simd.Vector<T, S>`
`offset`	`integer`

Returns

Type	Description
`simd.Vector<T, S>`

`swizzle`method#

swizzle: function(
    borrows self: simd.Vector<T, S>,
    indices: simd.Vector<T, S>,
    other: simd.Vector<T, S>?,
    third: simd.Vector<T, S>?,
    fourth: simd.Vector<T, S>?
): simd.Vector<T, S>

Every lane read from another lane this vector names at run time.

Lane i returns self:extract(indices:extract(i)), and zero where that index is outside 1..lanes. Zero rather than a refusal because the native instructions return zero for an out-of-range byte and a check per lane would cost more than the lookup.

This is the table lookup: a table is a vector, so there is no table type and no constructor taking one entry per argument. A sixteen-entry byte table is a Fixed<16> vector of constants, or a preferred-width one with those sixteen entries repeated, and looking up in it is this.

With other, the lanes of both are numbered in one run: an index in 1..lanes reads self and one in lanes+1..2*lanes reads other. That is the shape align needs and one vector cannot reach, and it is what makes this one operation rather than a family of them. third and fourth continue the run to three and four tables, which is how a 64-entry byte table on a sixteen-lane species is one lookup. They are optional on the same terms load's mask is. An index a lane cannot hold -- past 255 for bytes -- is not reachable.

The indices are read as lane numbers, so the element must be an integer one. A float vector has no lane numbering to offer.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`indices`	`simd.Vector<T, S>`
`other`	`simd.Vector<T, S>?`
`third`	`simd.Vector<T, S>?`
`fourth`	`simd.Vector<T, S>?`

Returns

Type	Description
`simd.Vector<T, S>`

`compress`method#

compress: function(borrows self: simd.Vector<T, S>, selected: simd.Mask<T, S>): simd.Vector<T, S>

Packs selected lanes toward lane one and zeroes the remainder.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`selected`	`simd.Mask<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`expand`method#

expand: function(borrows self: simd.Vector<T, S>, selected: simd.Mask<T, S>): simd.Vector<T, S>

Distributes packed lanes into selected positions and zeroes the rest.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`
`selected`	`simd.Mask<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`orderedPrefixSum`method#

orderedPrefixSum: function(borrows self: simd.Vector<T, S>): simd.Vector<T, S>

Inclusive, logical-lane-order prefix operations. The ordered sum adds lanes from the first, the way orderedSum does.

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`prefixXor`method#

prefixXor: function(borrows self: simd.Vector<T, S>): simd.Vector<T, S>

Arguments

Name	Type	Description
`borrows self`	`simd.Vector<T, S>`

Returns

Type	Description
`simd.Vector<T, S>`

`WrappingProduct`record#

record simd.WrappingProduct<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`operation`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: T

@private

`operation`method#

operation: function(T, T): T

@private

Arguments

Name	Type	Description
`?`	`T`
`?`	`T`

Returns

Type	Description
`T`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`WrappingSum`record#

record simd.WrappingSum<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

Fixed-width reducers name their element with its array witness, as a species does. Their initial value participates in the fold. Narrow storage loads contribute to i32 or u32; i64 and u64 never pass through a Lua double.

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`operation`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: T

@private

`operation`method#

operation: function(T, T): T

@private

Arguments

Name	Type	Description
`?`	`T`
`?`	`T`

Returns

Type	Description
`T`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

`XorBits`record#

record simd.XorBits<T is int32 | uint32 | int64 | uint64> is simd.Reducer<T> ...

Type parameters

Name	Description
`T`

Members

Name	Kind	Description
`total`	field
`operation`	method
`add`	method	active selects the lanes of a vector that contribute, in lane order, as one masked contribution per iteration of the...
`value`	method

`total`field#

total: T

@private

`operation`method#

operation: function(T, T): T

@private

Arguments

Name	Type	Description
`?`	`T`
`?`	`T`

Returns

Type	Description
`T`

`add`method#

add: function add<S>(self, value: T | simd.Vector<T, S>, active: simd.Mask<T, S>?): nil

Arguments

Name	Type	Description
`self`	`any`
`value`	`T \| simd.Vector<T, S>`
`active`	`simd.Mask<T, S>?`

Returns

Type	Description
`nil`

`value`method#

value: function value(self): T

Arguments

Name	Type	Description
`self`	`any`

Returns

Type	Description
`T`

Functions#

`horizontal.algebraicDot`function#

function horizontal.algebraicDot<T, S>(left: simd.Vector<T, S>, right: simd.Vector<T, S>): T

As ordinary Lua the vectors are one lane each, which is the product.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.algebraicProduct`function#

function horizontal.algebraicProduct<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.algebraicSum`function#

function horizontal.algebraicSum<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.andBits`function#

function horizontal.andBits<T, S>(value: simd.Vector<T, S>): T

The bitwise and of every lane of an integer vector. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.integerMax`function#

function horizontal.integerMax<T, S>(value: simd.Vector<T, S>): T

The largest lane of an integer vector, by the element's signedness. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.integerMin`function#

function horizontal.integerMin<T, S>(value: simd.Vector<T, S>): T

The smallest lane of an integer vector, by the element's signedness. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.numberArgMax`function#

function horizontal.numberArgMax<T, S>(value: simd.Vector<T, S>): integer

As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`integer`

`horizontal.numberArgMin`function#

function horizontal.numberArgMin<T, S>(value: simd.Vector<T, S>): integer

As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`integer`

`horizontal.numberMax`function#

function horizontal.numberMax<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.numberMin`function#

function horizontal.numberMin<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.orBits`function#

function horizontal.orBits<T, S>(value: simd.Vector<T, S>): T

The bitwise or of every lane of an integer vector. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.orderedDot`function#

function horizontal.orderedDot<T, S>(left: simd.Vector<T, S>, right: simd.Vector<T, S>): T

As ordinary Lua the vectors are one lane each, which is the product.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.orderedProduct`function#

function horizontal.orderedProduct<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.orderedSum`function#

function horizontal.orderedSum<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.pairwiseDot`function#

function horizontal.pairwiseDot<T, S>(left: simd.Vector<T, S>, right: simd.Vector<T, S>): T

As ordinary Lua the vectors are one lane each, which is the product.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`left`	`simd.Vector<T, S>`
`right`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.pairwiseProduct`function#

function horizontal.pairwiseProduct<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.pairwiseSum`function#

function horizontal.pairwiseSum<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.propagatingArgMax`function#

function horizontal.propagatingArgMax<T, S>(value: simd.Vector<T, S>): integer

As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`integer`

`horizontal.propagatingArgMin`function#

function horizontal.propagatingArgMin<T, S>(value: simd.Vector<T, S>): integer

The one-based lane holding the matching reduction's answer.

The lowest such lane when several tie, which is the logical-index tie rule every lane-selecting operation here uses. propagatingArgMin returns the lowest NaN lane when any lane is NaN, because that is the lane whose element is what propagatingMin returns; numberArgMin skips NaN lanes and returns the lowest only when every lane is NaN. Either way the identity value:extract(horizontal.<name>ArgMin(value)) holds against the reduction of the same name.

A lane index rather than a lane and its value, because an AOT expression returns a value and extract already spells the pair. As ordinary Lua a preferred-species vector is one lane, which is the position; a fixed-species vector is searched.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`integer`

`horizontal.propagatingMax`function#

function horizontal.propagatingMax<T, S>(value: simd.Vector<T, S>): T

As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.propagatingMin`function#

function horizontal.propagatingMin<T, S>(value: simd.Vector<T, S>): T

The smallest lane, and the largest, under the contract the name selects.

These take no order where the sums and products above take three: min and max round nothing, so every association of them returns the same value and three names would have named one answer. What they do take is the NaN contract, for the same reason Vector.propagatingMin and Vector.numberMin are separate names -- and each is the elementwise operation of that name, folded over the lanes.

propagatingMin returns the canonical NaN when any lane is NaN, so its answer does not depend on how many lanes the target chose. numberMin returns the smallest lane that is not NaN, and the canonical NaN only when every lane is. -0 is the smaller zero under both. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.wrappingProduct`function#

function horizontal.wrappingProduct<T, S>(value: simd.Vector<T, S>): T

The lanes of an integer vector multiplied, wrapping in the lane's width. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.wrappingSum`function#

function horizontal.wrappingSum<T, S>(value: simd.Vector<T, S>): T

The lanes of an integer vector summed, wrapping in the lane's own width: a byte vector's sum wraps at a byte, as simd.reducer.wrappingSum wraps at its element. Every association returns the same, so there is one name. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`horizontal.xorBits`function#

function horizontal.xorBits<T, S>(value: simd.Vector<T, S>): T

The bitwise exclusive or of every lane of an integer vector. As ordinary Lua a preferred-species vector is one lane, which is the reduction; a fixed-species vector is folded.

Type parameters

Name	Description
`T`
`S`

Arguments

Name	Type	Description
`value`	`simd.Vector<T, S>`

Returns

Type	Description
`T`

`lane.binary`function#

function lane.binary(op: string, element: string, a: any, b: any): any

Arguments

Name	Type	Description
`op`	`string`
`element`	`string`
`a`	`any`
`b`	`any`

Returns

Type	Description
`any`

Raises

Type	Condition
`string`	when the operator is not one the lanes have

`lane.fromStorage`function#

function lane.fromStorage(element: string, n: integer, storage: any): any

The N-lane vector a stored Fixed<N> field holds: storage is the field's C array, lane i at index i - 1, each wrapped to the element as a load wraps it. Writing the field back is the assignment itself, since the FFI copies an N-lane table into an N-element array.

Arguments

Name	Type	Description
`element`	`string`
`n`	`integer`
`storage`	`any`

Returns

Type	Description
`any`

`lane.method`function#

function lane.method(name: string, element: string, receiver: any, ...: any): any

Arguments

Name	Type	Description
`name`	`string`
`element`	`string`
`receiver`	`any`
`...`	`any`

Returns

Type	Description
`any`

Raises

Type	Condition
`string`	when the method is not one the lanes have

`lane.unary`function#

function lane.unary(op: string, element: string, a: any): any

Arguments

Name	Type	Description
`op`	`string`
`element`	`string`
`a`	`any`

Returns

Type	Description
`any`

`reducer.all`function#

function reducer.all(): simd.All

Constructs an all reducer.

Returns

Type	Description
`simd.All`

`reducer.andBits`function#

function reducer.andBits<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.AndBits<T>

Constructs a bitwise and over element, including the supplied initial value.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.AndBits<T>`

`reducer.any`function#

function reducer.any(): simd.Any

Constructs an any reducer.

Returns

Type	Description
`simd.Any`

`reducer.count`function#

function reducer.count(): simd.Count

Constructs a count reducer.

Returns

Type	Description
`simd.Count`

`reducer.integerArgMax`function#

function reducer.integerArgMax<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>): simd.IntegerArgMax<T>

Constructs an integer argmax reducer.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`

Returns

Type	Description
`simd.IntegerArgMax<T>`

`reducer.integerArgMin`function#

function reducer.integerArgMin<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>): simd.IntegerArgMin<T>

Constructs an integer argmin reducer.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`

Returns

Type	Description
`simd.IntegerArgMin<T>`

`reducer.integerMax`function#

function reducer.integerMax<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.IntegerMax<T>

Constructs an integer max reducer.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.IntegerMax<T>`

`reducer.integerMin`function#

function reducer.integerMin<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.IntegerMin<T>

Constructs an integer min reducer.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.IntegerMin<T>`

`reducer.orBits`function#

function reducer.orBits<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.OrBits<T>

Constructs a bitwise or over element, including the supplied initial value.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.OrBits<T>`

`reducer.wrappingProduct`function#

function reducer.wrappingProduct<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.WrappingProduct<T>

Constructs a wrapping product over element, including the supplied initial value.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.WrappingProduct<T>`

`reducer.wrappingSum`function#

function reducer.wrappingSum<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.WrappingSum<T>

Constructs a wrapping sum over element, including the supplied initial value.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.WrappingSum<T>`

`reducer.xorBits`function#

function reducer.xorBits<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>, initial: Given(T)): simd.XorBits<T>

Constructs a bitwise exclusive or over element, including the supplied initial value.

Type parameters

Name	Description
`T`

Arguments

Name	Type	Description
`element`	`StorageWitness<T>`
`initial`	`Given(T)`

Returns

Type	Description
`simd.XorBits<T>`

`transpose`function#

local transpose: function<Rows...>(
    ...: Rows...
): unpackof Transposed(Rows..., simd.Vector<uint32, simd.Fixed<2>>, simd.Fixed<2>)

Transposes a square tile of Fixed row vectors into N column vectors. All rows have the same element type; lane bits are preserved. Results are separate native vectors, not a table, and cannot escape the AOT kernel.

Type parameters

Name	Description
`Rows`

Arguments

Name	Type	Description
`...`	`Rows...`

Returns

Type	Description
`unpackof Transposed(Rows..., simd.Vector<uint32, simd.Fixed<2>>, simd.Fixed<2>)`

Values#

`horizontal`variable#

local horizontal

Named horizontal operations over an explicit register value.

Ordered operations follow logical lane order. Pairwise operations use the adjacent-pair tree. Algebraic operations permit reassociation; only algebraicDot additionally permits multiply-add contraction. Those three orders are floating-point contracts, because addition rounds; the wrapping, bitwise and integer extremum operations below are the integer contracts, which return the same under every association and so take one name each.

`lane`variable#

local lane

The lane operations, as the code generator calls them for a value the checker typed as a vector or a mask: a binary operator, a unary one, and a method. element is the element name, or "mask" for a mask. Each returns an N-lane form lane by lane through the one-lane operation beneath it.

`reducer`variable#

local reducer: {
    orderedSum: function(initial: number): simd.OrderedSum<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.OrderedSum<T>,
    pairwiseSum: function(initial: number): simd.PairwiseSum<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.PairwiseSum<T>,
    compensatedSum: function(initial: number): simd.CompensatedSum<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.CompensatedSum<T>,
    algebraicSum: function(initial: number): simd.AlgebraicSum<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.AlgebraicSum<T>,
    orderedProduct: function(initial: number): simd.OrderedProduct<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.OrderedProduct<T>,
    pairwiseProduct: function(initial: number): simd.PairwiseProduct<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.PairwiseProduct<T>,
    algebraicProduct: function(initial: number): simd.AlgebraicProduct<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.AlgebraicProduct<T>,
    orderedDot: function(initial: number): simd.OrderedDot<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.OrderedDot<T>,
    pairwiseDot: function(initial: number): simd.PairwiseDot<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.PairwiseDot<T>,
    algebraicDot: function(initial: number): simd.AlgebraicDot<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.AlgebraicDot<T>,
    wrappingSum: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.WrappingSum<T>,
    wrappingProduct: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.WrappingProduct<T>,
    andBits: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.AndBits<T>,
    orBits: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.OrBits<T>,
    xorBits: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.XorBits<T>,
    any: function(): simd.Any,
    all: function(): simd.All,
    count: function(): simd.Count,
    integerMin: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.IntegerMin<T>,
    integerMax: function<T is int32 | uint32 | int64 | uint64>(
        element: StorageWitness<T>,
        initial: Given(T)
    ): simd.IntegerMax<T>,
    integerArgMin: function<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>): simd.IntegerArgMin<T>,
    integerArgMax: function<T is int32 | uint32 | int64 | uint64>(element: StorageWitness<T>): simd.IntegerArgMax<T>,
    propagatingMin: function(initial: number): simd.PropagatingMin<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.PropagatingMin<T>,
    propagatingMax: function(initial: number): simd.PropagatingMax<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.PropagatingMax<T>,
    propagatingArgMin: function(): simd.PropagatingArgMin<number>
    & function<T is float | number>(element: StorageWitness<T>): simd.PropagatingArgMin<T>,
    propagatingArgMax: function(): simd.PropagatingArgMax<number>
    & function<T is float | number>(element: StorageWitness<T>): simd.PropagatingArgMax<T>,
    numberMin: function(initial: number): simd.NumberMin<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.NumberMin<T>,
    numberMax: function(initial: number): simd.NumberMax<number>
    & function<T is float | number>(element: StorageWitness<T>, initial: number): simd.NumberMax<T>,
    numberArgMin: function(): simd.NumberArgMin<number>
    & function<T is float | number>(element: StorageWitness<T>): simd.NumberArgMin<T>,
    numberArgMax: function(): simd.NumberArgMax<number>
    & function<T is float | number>(element: StorageWitness<T>): simd.NumberArgMax<T>
}

Closed reduction values for scalar or explicit masked vector contributions.

One reducer takes scalar contributions and masked vector contributions in any mix, in program order; every masked contribution belongs to one do block, which is the reducer's region. A floating-point reducer is constructed either from its initial value alone, which accumulates in number, or from an element witness and the initial value -- pairwiseSum(array.float, 0.0) -- which accumulates in the float or number the witness names. An integer reducer always names its element with its witness, because an int32 and a uint32 are the same Lua number.

nupp.simd

Module contents

Types

Functions

Values

Types#

AlgebraicDotrecord#

Type parameters

Members

totalfield#

roundmethod#

Arguments

Returns

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

AlgebraicProductrecord#

Type parameters

Members

totalfield#

roundmethod#

Arguments

Returns

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

AlgebraicSumrecord#

Type parameters

Members

totalfield#

roundmethod#

Arguments

Returns

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

Allrecord#

Members

totalfield#

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

AndBitsrecord#

Type parameters

Members

totalfield#

operationmethod#

Arguments

Returns

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

Anyrecord#

Members

totalfield#

addmethod#

Arguments

Returns

valuemethod#

Arguments

Returns

CompensatedSumrecord#

Type parameters

Members

totalfield#

`nupp.simd`

`AlgebraicDot`record#

`total`field#

`round`method#

`add`method#

`value`method#

`AlgebraicProduct`record#

`total`field#

`round`method#

`add`method#

`value`method#

`AlgebraicSum`record#

`total`field#

`round`method#

`add`method#

`value`method#

`All`record#

`total`field#

`add`method#

`value`method#

`AndBits`record#

`total`field#

`operation`method#

`add`method#

`value`method#

`Any`record#

`total`field#

`add`method#

`value`method#

`CompensatedSum`record#

`total`field#

`compensation`field#

`round`method#

`add`method#

`value`method#

`Count`record#

`total`field#

`add`method#

`value`method#

`Fixed`interface#

`IntegerArgMax`record#

`best`field#

`position`field#

`count`field#

`add`method#

`value`method#

`IntegerArgMin`record#

`best`field#

`position`field#

`count`field#

`add`method#

`value`method#

`IntegerMax`record#

`best`field#

`add`method#

`value`method#

`IntegerMin`record#

`best`field#

`add`method#

`value`method#

`Mask`interface#

`__eq`metamethod#