Struct IP 

pub struct IP;

Trait Implementations

impl Clone for IP

fn clone(&self) -> IP

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IP

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IP

fn default() -> IP

Returns the “default value” for a type.

impl SIMDSchema<f16, f16> for IP

type SIMDWidth = Const<1>

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

type Accumulator = 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, 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<f16, f16, V3> for IP

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 = <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, 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<f16, f16, V4> for IP

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 = <V4 as Architecture>::f32x8

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::f16x8

The type used for the left-hand side.

type Right = <V4 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 = 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<A> SIMDSchema<f32, f16, A> for IP

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 = <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 = Strategy4x2

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, 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<f32, f32> for IP

type SIMDWidth = Const<4>

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

type Accumulator = 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, x: Self::Accumulator) -> Self::Return

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

unsafe fn epilogue( &self, arch: Scalar, x: *const f32, y: *const f32, 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<f32, f32, V3> for IP

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 = <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 = 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<f32, f32, V4> for IP

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 = <V4 as Architecture>::f32x8

The type used to represent partial accumulated values.

type Left = <V4 as Architecture>::f32x8

The type used for the left-hand side.

type Right = <V4 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 = 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<i8, i8> for IP

type SIMDWidth = Const<1>

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

type Accumulator = Emulated<i32, 1>

The type used to represent partial accumulated values.

type Left = Emulated<i8, 1>

The type used for the left-hand side.

type Right = Emulated<i8, 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, 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 IP

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 = <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 IP

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 = <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 IP

type SIMDWidth = Const<1>

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

type Accumulator = Emulated<i32, 1>

The type used to represent partial accumulated values.

type Left = Emulated<u8, 1>

The type used for the left-hand side.

type Right = Emulated<u8, 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, 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 IP

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 = <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 IP

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 = <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 IP