Struct Function2 

pub struct Function2<SS, SC = ShiftOnlyWrapped, CA = DefaultCompressedArray, S = BuildDefaultSeededHasher>
where
    SS: SeedSize,
{ /* private fields */ }

PHast (Perfect Hashing made fast) - Minimal Perfect Hash Function with very fast evaluation and size below 2 bits/key developed by Piotr Beling and Peter Sanders.

The last layer (when the number of keys is small) is constructed using regular PHast. This makes Function2 compatible with almost all SeedChoosers (including non-wrapping ShiftOnly).

It can be used with the following SeedChooser (which specify a particular PHast variant): [ShiftOnly] (PHast+ without wrapping), ShiftOnlyWrapped (PHast+ with wrapping), [ShiftSeedWrapped] (PHast/PHast+ hybrid), SeedOnly (regular PHast).

Note that some SeedChoosers can also be used with Function.

See: Piotr Beling, Peter Sanders, PHast - Perfect Hashing made fast, 2025, https://arxiv.org/abs/2504.17918

Implementations

impl<SS: SeedSize, SC: SeedChooser, CA: CompressedArray, S: BuildSeededHasher> Function2<SS, SC, CA, S>

pub fn get<K>(&self, key: &K) -> usize

where K: Hash + ?Sized,

Returns value assigned to the given key.

The returned value is in the range from 0 (inclusive) to the number of elements in the input key collection (exclusive). key must come from the input key collection given during construction.

pub fn with_vec_p_hash_sc<K>( keys: Vec<K>, params: &Params<SS>, hasher: S, seed_chooser: SC, ) -> Self

where K: Hash,

Constructs [Function] for given keys, using a single thread and given parameters: number of bits per seed, average bucket size (equals bucket_size100/100.0) and hasher.

bits_per_seed_to_100_bucket_size can be used to calculate good bucket_size100. keys cannot contain duplicates.

pub fn with_vec_p_threads_hash_sc<K>( keys: Vec<K>, params: &Params<SS>, threads_num: usize, hasher: S, seed_chooser: SC, ) -> Self

where K: Hash + Sync + Send, S: Sync, SC: Sync,

Constructs [Function] for given keys, using multiple (given number of) threads and given parameters: number of bits per seed, average bucket size (equals bucket_size100/100.0) and hasher.

bits_per_seed_to_100_bucket_size can be used to calculate good bucket_size100. keys cannot contain duplicates.

pub fn with_slice_p_hash_sc<K>( keys: &[K], params: &Params<SS>, hasher: S, seed_chooser: SC, ) -> Self

where K: Hash + Clone,

Constructs [Function] for given keys, using a single thread and given parameters: number of bits per seed, average bucket size (equals bucket_size100/100.0) and hasher.

bits_per_seed_to_100_bucket_size can be used to calculate good bucket_size100. keys cannot contain duplicates.

pub fn with_slice_p_threads_hash_sc<K>( keys: &[K], params: &Params<SS>, threads_num: usize, hasher: S, seed_chooser: SC, ) -> Self

where K: Hash + Sync + Send + Clone, S: Sync, SC: Sync,

Constructs [Function] for given keys, using multiple (given number of) threads and given parameters: number of bits per seed, average bucket size (equals bucket_size100/100.0) and hasher.

bits_per_seed_to_100_bucket_size can be used to calculate good bucket_size100. keys cannot contain duplicates.

pub fn minimal_output_range(&self, num_of_keys: usize) -> usize

Returns output range of minimal (perfect or k-perfect) function for given number of keys, i.e. 1 + maximum value that minimal function can return.

pub fn output_range(&self) -> usize

Returns output range of self, i.e. 1 + maximum value that self can return.

pub fn write(&self, output: &mut dyn Write) -> Result<()>

Writes self to the output.

pub fn write_bytes(&self) -> usize

Returns number of bytes which write will write.

pub fn read_with_hasher_sc( input: &mut dyn Read, hasher: S, seed_chooser: SC, ) -> Result<Self>

Read Self from the input. hasher and seed_chooser must be the same as used by the structure written.

impl<SS: SeedSize> Function2<SS, ShiftOnlyWrapped, DefaultCompressedArray, BuildDefaultSeededHasher>

pub fn read(input: &mut dyn Read) -> Result<Self>

Read Self from the input. Uses default hasher and seed chooser.

impl Function2<Bits8, ShiftOnlyWrapped, DefaultCompressedArray, BuildDefaultSeededHasher>

pub fn from_vec_st<K>(keys: Vec<K>) -> Self

where K: Hash,

Constructs [Function] for given keys, using a single thread.

keys cannot contain duplicates.

pub fn from_vec_mt<K>(keys: Vec<K>) -> Self

where K: Hash + Send + Sync,

Constructs [Function] for given keys, using multiple threads.

keys cannot contain duplicates.

pub fn from_slice_st<K>(keys: &[K]) -> Self

where K: Hash + Clone,

Constructs [Function] for given keys, using a single thread.

keys cannot contain duplicates.

pub fn from_slice_mt<K>(keys: &[K]) -> Self

where K: Hash + Clone + Send + Sync,

Constructs [Function] for given keys, using multiple threads.

keys cannot contain duplicates.

Trait Implementations

impl<SC, SS: SeedSize, CA, S> GetSize for Function2<SS, SC, CA, S>

where CA: GetSize,

const USES_DYN_MEM: bool = true

true if and only if the variables of this type can use dynamic (heap) memory.

fn size_bytes_dyn(&self) -> usize

Returns approximate number of bytes occupied by dynamic (heap) part of self. Same as self.size_bytes() - std::mem::size_of_val(self).

fn size_bytes_content_dyn(&self) -> usize

Returns approximate number of bytes occupied by dynamic (heap) part of self content. It usually equals to size_bytes_dyn(). However, sometimes it is smaller by the amount of memory reserved but not yet used (e.g., size_bytes_content_dyn() only takes into account the length of the vector and not its capacity).

fn size_bytes(&self) -> usize

Returns approximate, total (including heap memory) number of bytes occupied by self.