Struct BitSliceBase 

pub struct BitSliceBase<const NBITS: usize, Repr, Ptr, Perm = Dense, Len = Dynamic>
where
    Repr: Representation<NBITS>,
    Ptr: AsPtr<Type = u8>,
    Perm: PermutationStrategy<NBITS>,
    Len: Length,
{ /* private fields */ }

A generalized representation for packed small bit integer encodings over a contiguous span of memory.

Think of this as a Rust slice, but supporting integer elements with fewer than 8-bits. The borrowed representations BitSlice and MutBitSlice consist of just a pointer and a length and are therefore just 16-bytes in size and amenable to the niche optimization.

Parameters

• NBITS: The number of bits occupied by each entry in the vector.

• Repr: The storage representation for each collection of 8-bits. This representation defines the domain of the encoding (i.e., range of realized values) as well as how this domain is mapped into NBITS bits.

• Ptr: The storage type for the contiguous memory. Possible representations are:

  • diskann_quantization::bits::SlicePtr<'_, u8>: For immutable views.
  • diskann_quantization::bits::MutSlicePtr<'_, u8>: For mutable views.
  • Box<[u8]>: For standalone vectors.

• Perm: By default, this type uses a dense storage strategy where the least significant bit of the value at index i occurs directly after the most significant bit of the value at index i-1.

  Different permutations can be used to enable faster distance computations between compressed vectors and full-precision vectors by enabling faster SIMD unpacking.

• Len: The representation for the length of the vector. This may only be one of the two families of types:

  • diskann_quantization::bits::Dynamic: For instances with a run-time length.
  • diskann_quantization::bits::Static<N>: For instances with a compile-time known length of N.

Examples

Canonical Bit Slice

The canonical BitSlice stores unsigned integers of NBITS densely in memory. That is, for a type BitSliceBase<3, Unsigned, _>, the layout is as follows:

|<--LSB-- byte 0 --MSB--->|<--LSB-- byte 1 --MSB--->|
| a0 a1 a2 b0 b1 b2 c0 c1 | c2 d0 d1 d2 e0 e1 e2 f0 |
|<-- A -->|<-- B ->|<--- C -->|<-- D ->|<-- E ->|<- F

An example is shown below:

use diskann_quantization::bits::{BoxedBitSlice, Unsigned};
// Create a new boxed bit-slice with capacity for 10 dimensions.
let mut x = BoxedBitSlice::<3, Unsigned>::new_boxed(10);
assert_eq!(x.len(), 10);
// The number of bytes in the canonical representation is computed by
// ceil((len * NBITS) / 8);
assert_eq!(x.bytes(), 4);

// Assign values.
x.set(0, 1).unwrap(); // assign the value 1 to index 0
x.set(1, 5).unwrap(); // assign the value 5 to index 1
assert_eq!(x.get(0).unwrap(), 1); // retrieve the value at index 0
assert_eq!(x.get(1).unwrap(), 5); // retrieve the value at index 1

// Assigning out-of-bounds will result in an error.
let err = x.set(1, 10).unwrap_err();
assert!(matches!(diskann_quantization::bits::SetError::EncodingError, err));
// The old value is left untouched.
assert_eq!(x.get(1).unwrap(), 5);

// `BoxedBitSlice` allows itself to be consumed, returning the underlying storage.
let y = x.into_inner();
assert_eq!(y.len(), BoxedBitSlice::<3, Unsigned>::bytes_for(10));

The above example demonstrates a boxed bit slice - a type that owns its underlying memory. However, this is not always ergonomic when interfacing with data stores. For this, the viewing interface can be used.

use diskann_quantization::bits::{MutBitSlice, Unsigned};

let mut x: Vec<u8> = vec![0; 4];
let mut slice = MutBitSlice::<3, Unsigned>::new(x.as_mut_slice(), 10).unwrap();
assert_eq!(slice.len(), 10);
assert_eq!(slice.bytes(), 4);

// The slice reference behaves just like boxed slice.
slice.set(0, 5).unwrap();
assert_eq!(slice.get(0).unwrap(), 5);

// Note - if the number of bytes required for the provided dimensions does not match
// the length of the provided span, than slice construction will return an error.
let err = MutBitSlice::<3, Unsigned>::new(x.as_mut_slice(), 11).unwrap_err();
assert_eq!(err.to_string(), "input span has length 4 bytes but expected 5");

Implementations

impl<const NBITS: usize, Repr, Ptr, Perm, Len> BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS>, Ptr: AsPtr<Type = u8>, Perm: PermutationStrategy<NBITS>, Len: Length,

pub fn bytes_for(count: usize) -> usize

Return the exact number of bytes required to store count values.

pub unsafe fn new_unchecked<Pre, Count>(precursor: Pre, count: Count) -> Self

where Count: Into<Len>, Pre: Precursor<Ptr>,

Construct a new BitSlice without checking preconditions.

Safety

Requires the following to avoid undefined behavior:

• precursor.precursor_len() == Self::bytes_for(<Count as Into<Len>>::into(count).value()).

This is checked in debug builds.

pub fn new<Pre, Count>( precursor: Pre, count: Count, ) -> Result<Self, ConstructionError>

where Count: Into<Len>, Pre: Precursor<Ptr>,

Construct a new BitSlice from the precursor capable of holding count encoded elements of size `NBITS.

Requirements

The number of bytes pointed to by the precursor must be equal to the number of bytes required by the layout. That is:

• precursor.precursor_len() == Self::bytes_for(<Count as Into<Len>>::into(count).value()).

pub fn len(&self) -> usize

Return the number of elements contained in the slice.

pub fn is_empty(&self) -> bool

Return whether or not the slice is empty.

pub fn bytes(&self) -> usize

Return the number of bytes occupied by this slice.

pub fn get(&self, i: usize) -> Result<i64, GetError>

Return the value at logical index i.

pub unsafe fn get_unchecked(&self, i: usize) -> i64

Return the value at logical index i.

Safety

Argument i must be in bounds: 0 <= i < self.len().

pub fn set(&mut self, i: usize, value: i64) -> Result<(), SetError>

where Ptr: AsMutPtr<Type = u8>,

Encode and assign value to logical index i.

pub unsafe fn set_unchecked(&mut self, i: usize, encoded: u8)

where Ptr: AsMutPtr<Type = u8>,

Assign value to logical index i.

Safety

Argument i must be in bounds: 0 <= i < self.len().

pub fn domain(&self) -> Repr::Domain

Return the domain of acceptable values.

pub fn as_ptr(&self) -> *const u8

Return a pointer to the beginning of the memory associated with this slice.

NOTE

The memory span underlying this instances is valid for self.bytes(), not necessarily self.len().

impl<const NBITS: usize, Repr, Perm, Len> BitSliceBase<NBITS, Repr, Poly<[u8], GlobalAllocator>, Perm, Len>

where Repr: Representation<NBITS>, Perm: PermutationStrategy<NBITS>, Len: Length,

pub fn new_boxed<Count>(count: Count) -> Self

where Count: Into<Len>,

Construct a new owning BitSlice capable of holding Count logical values. The slice is initialized in a valid but undefined state.

Example

use diskann_quantization::bits::{BoxedBitSlice, Unsigned};
let mut x = BoxedBitSlice::<3, Unsigned>::new_boxed(4);
x.set(0, 0).unwrap();
x.set(1, 2).unwrap();
x.set(2, 4).unwrap();
x.set(3, 6).unwrap();

assert_eq!(x.get(0).unwrap(), 0);
assert_eq!(x.get(1).unwrap(), 2);
assert_eq!(x.get(2).unwrap(), 4);
assert_eq!(x.get(3).unwrap(), 6);

impl<const NBITS: usize, Repr, Perm, Len, A> BitSliceBase<NBITS, Repr, Poly<[u8], A>, Perm, Len>

where Repr: Representation<NBITS>, Perm: PermutationStrategy<NBITS>, Len: Length, A: AllocatorCore,

pub fn new_in<Count>(count: Count, allocator: A) -> Result<Self, AllocatorError>

where Count: Into<Len>,

Construct a new owning BitSlice capable of holding Count logical values using the provided allocator.

The slice is initialized in a valid but undefined state.

Example

use diskann_quantization::{
    alloc::GlobalAllocator,
    bits::{BoxedBitSlice, Unsigned}
};
let mut x = BoxedBitSlice::<3, Unsigned>::new_in(4, GlobalAllocator).unwrap();
x.set(0, 0).unwrap();
x.set(1, 2).unwrap();
x.set(2, 4).unwrap();
x.set(3, 6).unwrap();

assert_eq!(x.get(0).unwrap(), 0);
assert_eq!(x.get(1).unwrap(), 2);
assert_eq!(x.get(2).unwrap(), 4);
assert_eq!(x.get(3).unwrap(), 6);

pub fn into_inner(self) -> Poly<[u8], A>

Consume self and return the boxed allocation.

Trait Implementations

impl<const NBITS: usize, Repr, Ptr, Perm, Len> Clone for BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS> + Clone, Ptr: AsPtr<Type = u8> + Clone, Perm: PermutationStrategy<NBITS> + Clone, Len: Length + Clone,

fn clone(&self) -> BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> CompressInto<&[T], BitSliceBase<1, Binary, MutSlicePtr<'_, u8>>> for BinaryQuantizer

where T: PartialOrd + Default,

fn compress_into( &self, from: &[T], into: MutBitSlice<'_, 1, Binary>, ) -> Result<(), Self::Error>

Compress the source vector into a binary representation.

This works by mapping positive numbers (as defined by v > T::default()) to 1 and negative numbers (as defined by v <= T::default()) to -1.

Panics

Panics if from.len() != into.len().

type Error = Infallible

Errors that may occur during compression.

type Output = ()

An output type resulting from compression.

impl<const NBITS: usize, T, Perm> CompressInto<&[T], BitSliceBase<NBITS, Unsigned, MutSlicePtr<'_, u8>, Perm>> for ScalarQuantizer

where T: Copy + Into<f32>, Unsigned: Representation<NBITS>, Perm: PermutationStrategy<NBITS>,

fn compress_into( &self, from: &[T], into: MutBitSlice<'_, NBITS, Unsigned, Perm>, ) -> Result<(), Self::Error>

Compress the input vector from into the bitslice into.

This method does not compute compensation coefficients required for fast inner product computations. If only L2 distances is desired, this method can be slightly faster.

Error

Returns an error if the input contains NaN.

Panics

Panics if:

• from.len() != self.dim(): Vector to be compressed must have the same dimensionality as the quantizer.
• into.len() != self.dim(): Compressed vector must have the same dimensionality as the quantizer.

type Error = InputContainsNaN

Errors that may occur during compression.

type Output = ()

An output type resulting from compression.

impl<const NBITS: usize, Repr, Ptr, Perm, Len> Debug for BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS> + Debug, Ptr: AsPtr<Type = u8> + Debug, Perm: PermutationStrategy<NBITS> + Debug, Len: Length + Debug,

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

Formats the value using the given formatter.

impl<'a, Ptr> From<&'a BitSliceBase<8, Unsigned, Ptr>> for &'a [u8]

where Ptr: AsPtr<Type = u8>,

fn from(slice: &'a BitSliceBase<8, Unsigned, Ptr>) -> Self

Converts to this type from the input type.

impl PureDistanceFunction<&[f32], BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<&[f32], BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<f32>, UnequalLengths>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

impl PureDistanceFunction<BitSliceBase<1, Binary, SlicePtr<'_, u8>>, BitSliceBase<1, Binary, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for Hamming

Compute the hamming distance between x and y.

Returns an error if the arguments have different lengths.

fn evaluate( x: BitSlice<'_, 1, Binary>, y: BitSlice<'_, 1, Binary>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<4, Unsigned, SlicePtr<'_, u8>, BitTranspose>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, BitTranspose>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for InnerProduct

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl PureDistanceFunction<BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, Result<MathematicalValue<u32>, UnequalLengths>> for SquaredL2

fn evaluate( x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

impl<'this, const NBITS: usize, Repr, Ptr, Perm, Len> Reborrow<'this> for BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS>, Ptr: AsPtr<Type = u8>, Perm: PermutationStrategy<NBITS>, Len: Length,

type Target = BitSliceBase<NBITS, Repr, SlicePtr<'this, u8>, Perm, Len>

fn reborrow(&'this self) -> Self::Target

Borrow self into a generalized reference type and reborrow

impl<'this, const NBITS: usize, Repr, Ptr, Perm, Len> ReborrowMut<'this> for BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS>, Ptr: AsMutPtr<Type = u8>, Perm: PermutationStrategy<NBITS>, Len: Length,

type Target = BitSliceBase<NBITS, Repr, MutSlicePtr<'this, u8>, Perm, Len>

fn reborrow_mut(&'this mut self) -> Self::Target

Mutably borrow self into a generalized reference type and reborrow.

impl<A> Target2<A, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

where A: Architecture,

Compute the inner product between bitvectors x and y.

Returns an error if the arguments have different lengths.

fn run( self, _: A, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<A> Target2<A, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

where A: Architecture,

Compute the squared L2 distance between bitvectors x and y.

Returns an error if the arguments have different lengths.

fn run( self, _: A, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<A> Target2<A, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>, BitTranspose>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

where A: Architecture,

The strategy is to compute the inner product <x, y> by decomposing the problem into groups of 64-dimensions.

For each group, we load the 64-bits of y into a word bits. And the four 64-bit words of the group in x in b0, b1, b2, and b3`.

Note that bit i in b0 is bit-0 of the i-th value in ths group. Likewise, bit i in b1 is bit-1 of the same word.

This means that we can compute the partial inner product for this group as

(bits & b0).count_ones()                // Contribution of bit 0
    + 2 * (bits & b1).count_ones()      // Contribution of bit 1
    + 4 * (bits & b2).count_ones()      // Contribution of bit 2
    + 8 * (bits & b3).count_ones()      // Contribution of bit 3

We process as many full groups as we can.

To handle the remainder, we need to be careful about acessing y because BitSlice only guarantees the validity of reads at the byte level. That is - we cannot assume that a full 64-bit read is valid.

The bit-tranposed x, on the other hand, guarantees allocations in blocks of 4 * 64-bits, so it can be treated as normal.

fn run( self, _: A, x: BitSlice<'_, N, Unsigned, BitTranspose>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<A> Target2<A, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

where A: Architecture, InnerProduct: for<'a> Target2<A, MathematicalValue<f32>, &'a [u8], &'a [u8]>,

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This can directly invoke the methods implemented in vector because BitSlice<'_, 8, Unsigned> is isomorphic to &[u8].

fn run( self, arch: A, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<A> Target2<A, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

where A: Architecture, SquaredL2: for<'a> Target2<A, MathematicalValue<f32>, &'a [u8], &'a [u8]>,

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This can directly invoke the methods implemented in vector because BitSlice<'_, 8, Unsigned> is isomorphic to &[u8].

fn run( self, arch: A, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<const N: usize> Target2<Scalar, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<N, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

where Unsigned: Representation<N>,

fn run( self, _: Scalar, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

A fallback implementation that uses scaler indexing to retrieve values from the corresponding BitSlice.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<Scalar, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Performance

This function uses a generic implementation and therefore is not very fast.

fn run( self, _: Scalar, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

The main trick here is avoiding explicit conversion from 1 bit integers to 32-bit floating-point numbers by using _mm256_permutevar_ps, which performs a shuffle on two independent 128-bit lanes of f32 values in a register A using the lower 2-bits of each 32-bit integer in a register B.

Importantly, this instruction only takes a single cycle and we can avoid any kind of masking. Going the route of conversion would require and AND operation to isolate bottom bits and a somewhat lengthy 32-bit integer to f32 conversion instruction.

The overall strategy broadcasts a 32-bit integer (consisting of 32, 1-bit values) across 8 lanes into a register A.

Each lane is then shifted by a different amount so:

• Lane 0 has value 0 as its least significant bit (LSB)
• Lane 1 has value 1 as its LSB.
• Lane 2 has value 2 as its LSB.
• etc.

These LSB’s are used to power the shuffle function to convert to f32 values (either 0.0 or 1.0) and we can FMA as needed.

To process the next group of 8 values, we shift all lanes in A by 8-bits so lane 0 has value 8 as its LSB, lane 1 has value 9 etc.

A total of three shifts are applied to extract all 32 1-bit value as f32 in order.

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

The strategy used here is almost identical to that used for 1-bit distances. The main difference is that now we use the full 2-bit shuffle capabilities of _mm256_permutevar_ps and ths relatives sizes of the shifts are slightly different.

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

The strategy here is similar to the 1 and 2-bit strategies. However, instead of using _mm256_permutevar_ps, we now go directly for 32-bit integer to 32-bit floating point.

This is because the shuffle intrinsic only supports 2-bit shuffles.

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This implementation is optimized around x86 with the AVX2 vector extension. Specifically, we try to hit Wide::<i32, 8> as SIMDDotProduct<Wide<i16, 8>> so we can hit the _mm256_madd_epi16 intrinsic.

Also note that AVX2 does not have 16-bit integer bit-shift instructions. Instead, we have to use 32-bit integer shifts and then bit-cast to 16-bit intrinsics. This works because we need to apply the same shift to all lanes.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Available on x86-64 only.

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This implementation is optimized around x86 with the AVX2 vector extension. Specifically, we try to hit Wide::<i32, 8> as SIMDDotProduct<Wide<i16, 8>> so we can hit the _mm256_madd_epi16 intrinsic.

Also note that AVX2 does not have 16-bit integer bit-shift instructions. Instead, we have to use 32-bit integer shifts and then bit-cast to 16-bit intrinsics. This works because we need to apply the same shift to all lanes.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This implementation is optimized around x86 with the AVX2 vector extension. Specifically, we try to hit Wide::<i32, 8> as SIMDDotProduct<Wide<i16, 8>> so we can hit the _mm256_madd_epi16 intrinsic.

Also note that AVX2 does not have 16-bit integer bit-shift instructions. Instead, we have to use 32-bit integer shifts and then bit-cast to 16-bit intrinsics. This works because we need to apply the same shift to all lanes.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

Available on x86-64 only.

Compute the squared L2 distance between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This implementation is optimized around x86 with the AVX2 vector extension. Specifically, we try to hit Wide::<i32, 8> as SIMDDotProduct<Wide<i16, 8>> so we can hit the _mm256_madd_epi16 intrinsic.

Also note that AVX2 does not have 16-bit integer bit-shift instructions. Instead, we have to use 32-bit integer shifts and then bit-cast to 16-bit intrinsics. This works because we need to apply the same shift to all lanes.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Computes the inner product of 8-bit unsigned × 1-bit unsigned vectors using V3 intrinsics.

For each 32-element block we load 32 bytes from x and 4 bytes (32 bits) from y. ANDing the data with the mask created from 4 bytes from y zeroes unselected lanes. Finally, _mm256_sad_epu8 horizontally sums the masked bytes in groups of 8.

The main loop is 4× unrolled, processing 128 elements per iteration.

Overflow

Each sad output lane holds at most 8 × 255 = 2_040. Accumulated across d/32 blocks, the per-lane max is (d/32) × 2_040. At dim = 3072: 96 × 2_040 = 195_840, well within i32 range.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Computes the inner product of 8-bit unsigned × 2-bit unsigned vectors using AVX2.

Strategy

Unpack each 16-byte chunk of y into 64 crumb values via a two-level cascade: first [unpack_half_bytes] splits bytes into nibbles, then a second pass splits nibbles into crumbs (masked with 0x03). Each unpacked half is paired with 32 bytes of x and multiplied via _mm256_maddubs_epi16.

The main loop is 4× unrolled: eight i16 products (4 blocks × 2 halves) are summed in i16 before a single _mm256_madd_epi16(…, 1) widens to i32. This is safe because 8 × (255 × 3 × 2) = 12_240 < i16::MAX.

impl Target2<V3, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

fn run( self, arch: V3, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Computes the inner product of 8-bit unsigned × 4-bit unsigned vectors using V3 intrinsics.

Strategy

Unpack each 16-byte chunk of y into 32 nibble values via [unpack_half_bytes], then multiply with the corresponding 32 bytes of x using _mm256_maddubs_epi16 (u8 × u8 → i16, pairwise horizontal add).

The main loop is 4× unrolled: four i16 products are summed in i16 before a single _mm256_madd_epi16(…, 1) widens to i32. This is safe because 4 × (255 × 15 × 2) = 30_600 < i16::MAX.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<f32>, UnequalLengths>, &[f32], BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: &[f32], y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<f32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

Available on x86-64 only.

Compute the inner product between x and y.

Returns an error if the arguments have different lengths.

Implementation Notes

This is optimized around the __mm512_dpbusd_epi32 VNNI instruction, which computes the pairwise dot product between vectors of 8-bit integers and accumulates groups of 4 with an i32 accumulation vector.

One quirk of this instruction is that one argument must be unsigned and the other must be signed. Since thie kernsl works on 2-bit integers, this is not a limitation. Just something to be aware of.

Since AVX512 does not have an 8-bit shift instruction, we generally load data as u32x16 (which has a native shift) and bit-cast it to u8x64 as needed.

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<3, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<5, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<6, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<7, Unsigned, SlicePtr<'_, u8>>> for SquaredL2

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<1, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<2, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl Target2<V4, Result<MathematicalValue<u32>, UnequalLengths>, BitSliceBase<8, Unsigned, SlicePtr<'_, u8>>, BitSliceBase<4, Unsigned, SlicePtr<'_, u8>>> for InnerProduct

fn run( self, arch: V4, x: BitSlice<'_, N, Unsigned, Dense>, y: BitSlice<'_, N, Unsigned, Dense>, ) -> MathematicalResult<u32>

Run the operation with the provided Architecture.

impl<const NBITS: usize, Repr, Ptr, Perm, Len> Copy for BitSliceBase<NBITS, Repr, Ptr, Perm, Len>

where Repr: Representation<NBITS> + Copy, Ptr: AsPtr<Type = u8> + Copy, Perm: PermutationStrategy<NBITS> + Copy, Len: Length + Copy,