Struct CosineStateless 

pub struct CosineStateless;

A pure Cosine Similarity function that provides a final reduction.

Trait Implementations

impl Clone for CosineStateless

fn clone(&self) -> CosineStateless

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for CosineStateless

fn default() -> CosineStateless

Returns the “default value” for a type.

impl SIMDSchema<f16, f16> for CosineStateless

type SIMDWidth = Const<1>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<Emulated<f32, 1>>

The type used to represent partial accumulated values.

type Left = Emulated<f16, 1>

The type used for the left-hand side.

type Right = Emulated<f16, 1>

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy1x1

The implementation of the main loop.

fn init(&self, arch: Scalar) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<f16, f16, V3> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<8>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V3 as Architecture>::f32x8>

The type used to represent partial accumulated values.

type Left = <V3 as Architecture>::f16x8

The type used for the left-hand side.

type Right = <V3 as Architecture>::f16x8

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x4

The implementation of the main loop.

fn init(&self, arch: V3) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<f16, f16, V4> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<16>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V4 as Architecture>::f32x16>

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::f16x16

The type used for the left-hand side.

type Right = <V4 as Architecture>::f16x16

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x4

The implementation of the main loop.

fn init(&self, arch: V4) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl<A> SIMDSchema<f32, f16, A> for CosineStateless

where A: Architecture,

type SIMDWidth = Const<8>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<A as Architecture>::f32x8>

The type used to represent partial accumulated values.

type Left = <A as Architecture>::f32x8

The type used for the left-hand side.

type Right = <A as Architecture>::f16x8

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x4

The implementation of the main loop.

fn init(&self, arch: A) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<f32, f32> for CosineStateless

type SIMDWidth = Const<4>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<Emulated<f32, 4>>

The type used to represent partial accumulated values.

type Left = Emulated<f32, 4>

The type used for the left-hand side.

type Right = Emulated<f32, 4>

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x1

The implementation of the main loop.

fn init(&self, arch: Scalar) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<f32, f32, V3> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<8>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V3 as Architecture>::f32x8>

The type used to represent partial accumulated values.

type Left = <V3 as Architecture>::f32x8

The type used for the left-hand side.

type Right = <V3 as Architecture>::f32x8

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x4

The implementation of the main loop.

fn init(&self, arch: V3) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<f32, f32, V4> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<16>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V4 as Architecture>::f32x16>

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::f32x16

The type used for the left-hand side.

type Right = <V4 as Architecture>::f32x16

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy2x4

The implementation of the main loop.

fn init(&self, arch: V4) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, acc: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<i8, i8> for CosineStateless

type SIMDWidth = Const<4>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<Emulated<i32, 4>>

The type used to represent partial accumulated values.

type Left = Emulated<i8, 4>

The type used for the left-hand side.

type Right = Emulated<i8, 4>

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy1x1

The implementation of the main loop.

fn init(&self, arch: Scalar) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

unsafe fn epilogue( &self, arch: Scalar, x: *const i8, y: *const i8, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<i8, i8, V3> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<16>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V3 as Architecture>::i32x8>

The type used to represent partial accumulated values.

type Left = <V3 as Architecture>::i8x16

The type used for the left-hand side.

type Right = <V3 as Architecture>::i8x16

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy4x1

The implementation of the main loop.

fn init(&self, arch: V3) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<i8, i8, V4> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<32>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V4 as Architecture>::i32x16>

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::i8x32

The type used for the left-hand side.

type Right = <V4 as Architecture>::i8x32

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy4x1

The implementation of the main loop.

fn init(&self, arch: V4) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<u8, u8> for CosineStateless

type SIMDWidth = Const<4>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<Emulated<i32, 4>>

The type used to represent partial accumulated values.

type Left = Emulated<u8, 4>

The type used for the left-hand side.

type Right = Emulated<u8, 4>

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy1x1

The implementation of the main loop.

fn init(&self, arch: Scalar) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

unsafe fn epilogue( &self, arch: Scalar, x: *const u8, y: *const u8, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<u8, u8, V3> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<16>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V3 as Architecture>::i32x8>

The type used to represent partial accumulated values.

type Left = <V3 as Architecture>::u8x16

The type used for the left-hand side.

type Right = <V3 as Architecture>::u8x16

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy4x1

The implementation of the main loop.

fn init(&self, arch: V3) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl SIMDSchema<u8, u8, V4> for CosineStateless

Available on x86-64 only.

type SIMDWidth = Const<32>

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = FullCosineAccumulator<<V4 as Architecture>::i32x16>

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::u8x32

The type used for the left-hand side.

type Right = <V4 as Architecture>::u8x32

The type used for the right-hand side.

type Return = f32

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = Strategy4x1

The implementation of the main loop.

fn init(&self, arch: V4) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl Copy for CosineStateless