Weights version that uses f64 and works well with numerical optimization.

Build `ls::CMap` with given number of bits per code fragment.

CompressedArray implementation by Elias-Fano from `cacheline_ef` crate. Experimental.

Cost function for bucket weights optimization that exposes weights as deltas.

Cost function for direct bucket weights optimization.

Cost function for bucket weights optimization that exposes 5 weights: first as absolute, last as relative, middle and rest as weighted average coeffic

Cost function for bucket weights optimization that exposes 7 weights: first as absolute, last as relative, middle and rest as weighted average coeffic

Collision solver that permits assigning only one value (few equal values) to each index.

Trait for collecting (and summarizing or reporting) events during querying of a minimal perfect hashing function.

All statistics/results.

The trait that is implemented for the array of `u64` and extends it with methods for accessing and modifying single bits or arbitrary fragments consis

Iterator over indices of bits set to 1 (if `B` is `true`) or 0 (if `B` is `false`) in slice of `u64`.

Iterator over bits in slice of `u64`. It yields `true` for bit 1 and `false` for 0.

The trait that is implemented for `Box<[u64]>` and extends it with bit-oriented constructors.

Evaluate bucket to be activate.

Coding builder.

/ Read-only data shared by all threads.

Family of hash functions that allows the creation of [`Hasher`] instances initialized with a given seed.

Building statistics

Trait for collecting (and summarizing or reporting) events during construction of a minimal perfect hashing function.

Report events occurred during building a minimal perfect hashing function to the wrapped writer.

Builds [`Sequence`] of values added by push methods. After adding values in non-decreasing order by [`Self::push`] method, [`Self::finish`] can be cal

Helper structure for building fingerprinting-based minimal perfect hash function (FMPH).

Compressed static function (immutable map) that maps hashable keys to values of any type. To represent a function *f:X→Y*, it uses the space slightly

Finger-printing based compressed static function (immutable map) that maps hashable keys to values of any type. To represent a function *f:X→Y*, it u

Implementation of [`KeySet`] that initially stores another [`KeySet`] (which is usually succinct but slow, such as [`DynamicKeySet`]), but when number

Iterator over the fragments of (unreversed) code.

Succinct representation of minimum-redundancy coding (huffman tree of some degree in the canonical form).

A bijection between values and codewords. Codewords are sequences of fragments. Each fragment occupies constant number of bits.

Solves value collisions during construction of fingerprinting based maps. Remembers which indices are under collision and decides which collisions are

Builds `CollisionSolver`.

Trait that determines the sampling density of select values by [`CombinedSampling`].

Implementation of `CompressedArray` that stores each value with the same number of bits required to store the largest one.

Implementation of `CompressedArray` that stores each value with the same number of bits required to store the largest one. It uses unaligned memory re

Compressed array of usize integers that can be used by `PHast`.

Builder used to construct `CompressedArray`.

Minimal perfect hashing benchmark.

Compact sequences benchmark.

Minimal perfect hashing benchmark.

Coding benchmark.

Static function benchmark.

The PHast core which is responsible for mapping key hashes to buckets and slices.

Wraps `CostFn`, stores the best value and cost, works with many optimization framework.

Cost function that can work with many optimizers via `Cost`.

SIZE must be the power of 2

SIZE in 64-bit segments, must be the power of two

Decoder that decodes a value for given code, consuming one codeword fragment (and going one level down the huffman tree) at a time. Time complexity o

Decoder that decodes a value for codeword given fragment by fragment.