Struct L1Norm 

pub struct L1Norm;

Trait Implementations

impl Clone for L1Norm

fn clone(&self) -> L1Norm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for L1Norm

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

Formats the value using the given formatter.

impl Default for L1Norm

fn default() -> L1Norm

Returns the “default value” for a type.

impl SIMDSchema<f16, f16> for L1Norm

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.

unsafe fn epilogue( &self, _arch: Scalar, _x: *const Half, _y: *const Half, _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<f16, f16, V3> for L1Norm

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 L1Norm

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 = 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, 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 L1Norm

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 L1Norm

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 L1Norm

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