EngineType

public protocol EngineType

Tensor operation engine for a device


                    
                    
                    Device

Undocumented

Declaration

Swift

associatedtype Device : DeviceType where Self == Self.Device.Engine

Simple operations


                    
                    
                    fill(value:result:count:)

Fills a buffer with a given value

Declaration

Swift

static func fill<N>(value: N, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`value`	Value to fill the buffer with
`result`	Buffer to fill
`count`	Number of elements to write


                    
                    
                    vAdd(lhs:rhs:result:count:)

Element-wise Vector-vector add

Declaration

Swift

static func vAdd<N>(lhs: Buffer<N, Device>, rhs: Buffer<N, Device>, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`lhs`	First summand
`rhs`	Second summand
`result`	Result buffer
`count`	Number of elements to add


                    
                    
                    vNeg(val:result:count:)

Element-wise Vector negate

Declaration

Swift

static func vNeg<N>(val: Buffer<N, Device>, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`val`	Vector to negate
`result`	Result buffer
`count`	Number of elements to negate


                    
                    
                    vSub(lhs:rhs:result:count:)

Element-wise Vector-vector subtract

Declaration

Swift

static func vSub<N>(lhs: Buffer<N, Device>, rhs: Buffer<N, Device>, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`lhs`	Left-hand side vector
`rhs`	Right-hand side vector
`result`	Result bufffer
`count`	Number of elements to subtract


                    
                    
                    vMul(lhs:rhs:result:count:)

Element-wise Vector-vector multiply

Declaration

Swift

static func vMul<N>(lhs: Buffer<N, Device>, rhs: Buffer<N, Device>, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`lhs`	First factor
`rhs`	Second factor
`result`	Result buffer
`count`	Number of elements to multiply


                    
                    
                    vDiv(lhs:rhs:result:count:)

Element-wise Vector-vector divide

Declaration

Swift

static func vDiv<N>(lhs: Buffer<N, Device>, rhs: Buffer<N, Device>, result: Buffer<N, Device>, count: Int) where N : NumericType

Parameters

`lhs`	Dividend
`rhs`	Divisor
`result`	Result buffer
`count`	Number of elements to divide

Matrix operations


                    
                    
                    fillDiagonal(values:target:)

Matrix diagonal fill in-place

Declaration

Swift

static func fillDiagonal<N>(values: ShapedBuffer<N, Device>, target: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Values to fill the diagonal with
`target`	Matrix to be filled


                    
                    
                    fillDiagonal(value:target:)

Matrix diagonal fill in-place

Declaration

Swift

static func fillDiagonal<N>(value: N, target: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`value`	Value to fill the diagonal with
`target`	Matrix to be filled


                    
                    
                    extractDiagonal(values:target:)

Extracts the diagonal of a matrix

Declaration

Swift

static func extractDiagonal<N>(values: ShapedBuffer<N, Device>, target: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`value`	Matrix to extract diagonal from
`target`	Vector to write diagonal values to


                    
                    
                    gemm(lhs:rhs:result:alpha:beta:transposeFirst:transposeSecond:)

Matrix multiply add in-place

Declaration

Swift

static func gemm<N>(lhs: ShapedBuffer<N, Device>, rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, alpha: N, beta: N, transposeFirst: Bool, transposeSecond: Bool) where N : NumericType

Parameters

`lhs`	Left-hand side matrix
`rhs`	Right-hand side matrix
`result`	Summand and result buffer
`alpha`	Matrix multiplication scale
`beta`	Add scale
`transposeFirst`	Whether to transpose the first matrix
`transposeSecond`	Whether to transpose the second matrix


                    
                    
                    band(buffer:result:belowDiagonal:aboveDiagonal:)

Band matrix extraction

Declaration

Swift

static func band<N>(buffer: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, belowDiagonal: Int?, aboveDiagonal: Int?) where N : NumericType

Parameters

`buffer`	Source matrix
`result`	Result buffer
`belowDiagonal`	Number of elements below diagonal to keep, nil for all elements
`aboveDiagonal`	Number of elements above diagonal to keep, nil for all elements

Broadcasting


                    
                    
                    broadcastAdd(lhs:rhs:result:)

Broadcast adds two buffers

Declaration

Swift

static func broadcastAdd<N>(lhs: ShapedBuffer<N, Device>, rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First summand
`rhs`	Second summand
`result`	Sum vector


                    
                    
                    broadcastSub(lhs:rhs:result:)

Broadcast subtracts one vector from another

Declaration

Swift

static func broadcastSub<N>(lhs: ShapedBuffer<N, Device>, rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	Left-hand side vector
`rhs`	Vector to subtact from lhs
`result`	Result buffer


                    
                    
                    broadcastMul(lhs:rhs:result:)

Broadcast multiplies two buffers

Declaration

Swift

static func broadcastMul<N>(lhs: ShapedBuffer<N, Device>, rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First factor
`rhs`	Second factor
`result`	Product vector


                    
                    
                    broadcastDiv(lhs:rhs:result:)

Broadcast divides one vector by another

Declaration

Swift

static func broadcastDiv<N>(lhs: ShapedBuffer<N, Device>, rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	Left-hand side vector
`rhs`	Vector to divide lhs with
`result`	Result buffer

Reduction


                    
                    
                    reduceSum(values:result:axis:)

Reduces one buffer into another along one axis by computing the sum.

Declaration

Swift

static func reduceSum<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, axis: Int) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`axis`	Axis to reduce along


                    
                    
                    reduceMax(values:result:context:axis:)

Reduces one buffer into another along one axis by computing the maximum.

Declaration

Swift

static func reduceMax<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>?, axis: Int) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`context`	Context vector that stores the argmax
`axis`	Axis to reduce along


                    
                    
                    reduceMin(values:result:context:axis:)

Reduces one buffer into another along one axis by computing the minimum.

Declaration

Swift

static func reduceMin<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>?, axis: Int) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`context`	Context vector that stores the argmin
`axis`	Axis to reduce along


                    
                    
                    reduceMean(values:result:axis:)

Reduces one buffer into another along one axis by computing the mean.

Declaration

Swift

static func reduceMean<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, axis: Int) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`axis`	Axis to reduce along


                    
                    
                    reduceSum(values:result:axes:)

Reduces one buffer into another along multiple axes by computing the sum.

Declaration

Swift

static func reduceSum<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, axes: [Int]) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`axes`	Axes to reduce along


                    
                    
                    reduceMax(values:result:context:axes:)

Reduces one buffer into another along multiple axes by computing the maximum.

Declaration

Swift

static func reduceMax<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>?, axes: [Int]) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`context`	Context buffer that stores the argmax
`axes`	Axes to reduce along


                    
                    
                    reduceMin(values:result:context:axes:)

Reduces one buffer into another along multiple axes by computing the minimum.

Declaration

Swift

static func reduceMin<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>?, axes: [Int]) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`context`	Context buffer that stores the argmin
`axes`	Axes to reduce along


                    
                    
                    reduceMean(values:result:axes:)

Reduces one buffer into another along multiple axes by computing the mean.

Declaration

Swift

static func reduceMean<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, axes: [Int]) where N : NumericType

Parameters

`values`	Buffer to reduce
`result`	Result buffer
`axes`	Axes to reduce along


                    
                    
                    sum(values:result:)

Computes the sum of a buffer

Declaration

Swift

static func sum<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer to sum up
`result`	Result buffer


                    
                    
                    mean(values:result:)

Computes the mean of a buffer

Declaration

Swift

static func mean<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer to compute the mean of
`result`	Result buffer


                    
                    
                    max(values:result:)

Stores the maximum value in result and returns the argmax

Declaration

Swift

@discardableResult
static func max<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) -> Int where N : NumericType

Parameters

`values`	Value buffer
`result`	Result buffer


                    
                    
                    min(values:result:)

Stores the minimum value in result and returns the argmin

Declaration

Swift

@discardableResult
static func min<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) -> Int where N : NumericType

Parameters

`values`	Value buffer
`result`	Result buffer


                    
                    
                    argmax(values:count:)

Computes the argmax of a buffer

Declaration

Swift

static func argmax<N>(values: Buffer<N, Device>, count: Int) -> (Int, N) where N : NumericType

Parameters

`values`	Buffer to compute the argmax of
`count`	Number of elements in the buffer

Element-wise functions


                    
                    
                    exp(values:result:)

Element-wise exponentiate

Declaration

Swift

static func exp<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to exponentiate
`result`	Result buffer


                    
                    
                    log(values:result:)

Element-wise log

Declaration

Swift

static func log<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the log of
`result`	Result buffer


                    
                    
                    sqrt(values:result:)

Element-wise square root

Declaration

Swift

static func sqrt<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the square root of
`result`	Result buffer


                    
                    
                    relu(values:result:)

Element-wise recitified linear unit

Declaration

Swift

static func relu<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the relu of
`result`	Result buffer


                    
                    
                    heaviside(values:result:)

Element-wise heaviside step function

Declaration

Swift

static func heaviside<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the heaviside step function of
`result`	Result buffer


                    
                    
                    sin(values:result:)

Element-wise sine

Declaration

Swift

static func sin<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the sine of
`result`	Result buffer


                    
                    
                    cos(values:result:)

Element-wise cosine

Declaration

Swift

static func cos<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the cosine of
`result`	Result buffer


                    
                    
                    tan(values:result:)

Element-wise tangent

Declaration

Swift

static func tan<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the tangent of
`result`	Result buffer


                    
                    
                    sinh(values:result:)

Element-wise hyperbolic sine

Declaration

Swift

static func sinh<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the hyperbolic sine of
`result`	Result buffer


                    
                    
                    cosh(values:result:)

Element-wise hyperbolic cosine

Declaration

Swift

static func cosh<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the hyperbolic cosine of
`result`	Result buffer


                    
                    
                    tanh(values:result:)

Element-wise hyperbolic tangent

Declaration

Swift

static func tanh<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer of values to compute the hyperbolic tangent of
`result`	Result buffer


                    
                    
                    max(_:_:result:)

Element-wise maximum

Declaration

Swift

static func max<N>(_ lhs: ShapedBuffer<N, Device>, _ rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First buffer
`rhs`	Second buffer
`result`	Result buffer


                    
                    
                    max(_:_:result:context:)

Element-wise maximum

Declaration

Swift

static func max<N>(_ lhs: ShapedBuffer<N, Device>, _ rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First buffer
`rhs`	Second buffer
`result`	Result buffer
`context`	Context buffer


                    
                    
                    min(_:_:result:)

Element-wise minimum

Declaration

Swift

static func min<N>(_ lhs: ShapedBuffer<N, Device>, _ rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First buffer
`rhs`	Second buffer
`result`	Result buffer


                    
                    
                    min(_:_:result:context:)

Element-wise minimum

Declaration

Swift

static func min<N>(_ lhs: ShapedBuffer<N, Device>, _ rhs: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, context: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lhs`	First buffer
`rhs`	Second buffer
`result`	Result buffer
`context`	Context buffer

Shuffling


                    
                    
                    scatter(reduced:context:result:axis:ignoreIndex:)

Scatters elements to indices determined by the context along the specified axis.

Declaration

Swift

static func scatter<N>(reduced: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>, result: ShapedBuffer<N, Device>, axis: Int, ignoreIndex: Int32) where N : NumericType

Parameters

`reduced`	Values to scatter
`context`	Index vector
`result`	Buffer to scatter to
`axis`	Axis to scatter along


                    
                    
                    gather(expanded:context:result:axis:ignoreIndex:)

Gathers elements from indices determined by the context along the specified axis

Declaration

Swift

static func gather<N>(expanded: ShapedBuffer<N, Device>, context: ShapedBuffer<Int32, Device>, result: ShapedBuffer<N, Device>, axis: Int, ignoreIndex: Int32) where N : NumericType

Parameters

`expanded`	Buffer to gather elements from
`context`	Index vector
`result`	Result buffer
`axis`	Axis to gather along


                    
                    
                    permuteAxes(values:result:arangement:)

Performs an axis permutation / transpose oepration

Declaration

Swift

static func permuteAxes<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, arangement: [Int]) where N : NumericType

Parameters

`values`	Buffer of values to permute
`result`	Result buffer
`arangement`	Arangement of axes.


                    
                    
                    permuteAxesAdd(values:add:result:arangement:)

Performs an axis permutation / transpose oepration and adds another value vector

Declaration

Swift

static func permuteAxesAdd<N>(values: ShapedBuffer<N, Device>, add: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, arangement: [Int]) where N : NumericType

Parameters

`values`	Buffer of values to permute
`add`	Buffer of values to add to the result
`result`	Result buffer
`arangement`	Arangement of axes.


                    
                    
                    subscriptRead(values:result:index:)

Reads elements from the given index

Declaration

Swift

static func subscriptRead<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, index: [Int?])

Parameters

`values`	Buffer of values to read
`result`	Buffer to write the values to
`index`	Index to read from, nil values indicate that all values along the corresponding axis should be read


                    
                    
                    subscriptWrite(values:result:index:)

Writes elements to the result tensor at the given index

Declaration

Swift

static func subscriptWrite<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, index: [Int?])

Parameters

`values`	Values to write
`result`	Buffer to write to
`index`	Index to write to, nil values indicate that all values along the corresponding axis should be written


                    
                    
                    subscriptReadAdd(values:add:result:index:)

Reads elements from the given index and adds a second vector

Declaration

Swift

static func subscriptReadAdd<N>(values: ShapedBuffer<N, Device>, add: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, index: [Int?]) where N : NumericType

Parameters

`values`	Buffer of values to read
`add`	Buffer to add
`result`	Buffer to write the values to
`index`	Index to read from, nil values indicate that all values along the corresponding axis should be read


                    
                    
                    subscriptWriteAdd(values:add:result:index:)

Writes elements to the result tensor at the given index and adds a second vector

Declaration

Swift

static func subscriptWriteAdd<N>(values: ShapedBuffer<N, Device>, add: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, index: [Int?]) where N : NumericType

Parameters

`values`	Values to write
`add`	Buffer to add
`result`	Buffer to write to
`index`	Index to write to, nil values indicate that all values along the corresponding axis should be written


                    
                    
                    reverse(values:result:)

Reverses the order of elements along the first dimension of the buffer

Declaration

Swift

static func reverse<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>)

Parameters

`values`	Buffer to reverse
`result`	Result buffer


                    
                    
                    reverseAdd(values:add:result:)

Reverses the order of elements along the first dimension of the buffer and adds a second buffer

Declaration

Swift

static func reverseAdd<N>(values: ShapedBuffer<N, Device>, add: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`values`	Buffer to reverse
`add`	Buffer to add
`result`	Result buffer


                    
                    
                    stack(buffers:result:axis:)

Stacks the given array of buffers along the stacking axis into the result buffer.

Declaration

Swift

static func stack<N>(buffers: [ShapedBuffer<N, Device>], result: ShapedBuffer<N, Device>, axis: Int)

Parameters

`buffers`	Buffers to stack
`result`	Result buffer
`axis`	Axis to stack the buffers along


                    
                    
                    unstackAdd(stacked:add:result:axis:)

Reverses the stacking operation and adds a list of buffers to the unstacked results

Declaration

Swift

static func unstackAdd<N>(stacked: ShapedBuffer<N, Device>, add: [ShapedBuffer<N, Device>], result: [ShapedBuffer<N, Device>], axis: Int) where N : NumericType

Parameters

`stacked`	Buffer that stores elements of stacked buffers
`add`	Buffers to add to the corresponding result buffers
`result`	Buffers to write the result to
`axis`	Axis to unstack along


                    
                    
                    unstack(stacked:result:axis:)

Reverses the stacking operation

Declaration

Swift

static func unstack<N>(stacked: ShapedBuffer<N, Device>, result: [ShapedBuffer<N, Device>], axis: Int) where N : NumericType

Parameters

`stacked`	Buffer that stores elements of stacked buffers
`result`	Buffers to write the result to
`axis`	Axis to unstack along


                    
                    
                    arange(lowerBound:upperBound:result:)

Writes linear interpolation values from lowerBound to upperBound into the result buffer.

Declaration

Swift

static func arange<N>(lowerBound: N, upperBound: N, result: ShapedBuffer<N, Device>) where N : NumericType

Parameters

`lowerBound`	Start value
`upperBound`	End value
`result`	Result buffer

Convolution Helpers


                    
                    
                    img2col(values:result:kernelWidth:kernelHeight:padding:stride:)

Performs an img2col transformation that extracts all windows for a convolution into a matrix.

Declaration

Swift

static func img2col<N>(values: ShapedBuffer<N, Device>, result: ShapedBuffer<N, Device>, kernelWidth: Int, kernelHeight: Int, padding: Int, stride: Int) where N : NumericType

Parameters

`values`	Image buffer, shape [batchSize, channels, height, width]
`result`	Result buffer, shape [channels * kernelWidth * kernelHeight, number of windows]
`kernelWidth`	Width of the convolution kernel
`kernelHeight`	Height of the convolution kernel
`padding`	Zero padding applied around the input image
`stride`	Stride, with which the window is moved over the input image


                    
                    
                    col2img(matrix:image:kernelWidth:kernelHeight:padding:stride:)

Performs an col2img transformation that aggregates all windows from a convolution matrix into an image tensor.

Declaration

Swift

static func col2img<N>(matrix: ShapedBuffer<N, Device>, image: ShapedBuffer<N, Device>, kernelWidth: Int, kernelHeight: Int, padding: Int, stride: Int) where N : NumericType

Parameters

`values`	Buffer, shape [channels * kernelWidth * kernelHeight, number of windows]
`result`	Image buffer, shape [batchSize, channels, height, width]
`kernelWidth`	Width of the convolution kernel
`kernelHeight`	Height of the convolution kernel
`padding`	Zero padding applied around the input image
`stride`	Stride, with which the window is moved over the input image