All Classes and Interfaces
Class
Description
A min heap that stores longs; a primitive priority queue that like all priority queues maintains
a partial ordering of its elements such that the least element can always be found in constant
time.
Methods for manipulating arrays.
A
BitSet implementation that offers concurrent reads and writes through an AtomicLongArray as bit storage.Binary Quantization of float vectors: each float is compressed to a single bit,
and similarity is computed with a simple Hamming distance.
Interface for Bitset-like structures.
Bits with all bits set.
Bits with no bits set.
Base implementation for a bit set.
A variety of high efficiency bit twiddling routines and encoders for primitives.
An AbstractLongHeap with a fixed maximum size, allocated at construction time.
A concurrent set of neighbors that encapsulates diversity/pruning mechanics.
Some useful constants.
Default provider returning scalar implementations.
A map (but not a Map) of int -> T where the int keys are dense-ish and start at zero,
but the size of the map is not known in advance.
Indicates that an API is experimental and may change or be removed in future releases
with no prior notice.
BitSet of fixed length (numBits), backed by accessible (
FixedBitSet.getBits()) long[], accessed with
an int index, implementing Bits.Represents a graph-based vector index.
Builder for Concurrent GraphIndex.
Searches a graph to find nearest neighbors to a query vector.
Builder
A
BitSet implementation that grows as needed to accommodate set(index) calls.An AbstractLongHeap that can grow in size (unbounded, except for memory and array size limits).
A KMeans++ implementation for float vectors.
A List-backed implementation of the
RandomAccessVectorValues interface.NodeArray encodes nodeids and their scores relative to some other element
(a query vector, or another graph node) as a pair of growable arrays.
NodeQueue uses a
AbstractLongHeap to store lists of nodes in a graph,
represented as a node id with an associated score packed together as a sortable long, which is sorted
primarily by score.Encapsulates comparing node distances.
Provides an API for encapsulating similarity to another node or vector.
Iterator over graph nodes that includes the size –- the total
number of nodes to be iterated over.
Helper APIs to encode numeric values as sortable bytes and vice-versa.
An
GraphIndex that offers concurrent access; for typical graphs you will get significant
speedups in construction and searching as you add threads.A fork join pool which is sized to match the number of physical cores on the machine (avoiding hyper-thread count)
This is important for heavily vectorized sections of the code since it can easily saturate memory bandwidth.
Allows any object to be pooled and released when work is done.
Wrapper class for items in the pool
These are AutoClosable and are intended to be used
in a try-with-resources statement.
Product Quantization for float vectors.
Estimates the size (memory representation) of Java objects.
This is a subset of DataInput, plus seek and readFully methods, which allows implementations
to use more efficient options like FloatBuffer for bulk reads.
Provides random access to vectors by dense ordinal.
Container class for results of an ANN search, along with associated metrics about the behavior of the search.
Simple sample implementation of RandomAccessReader.
A bit set that only stores longs that have at least one bit which is set.
A thread-safe
BitSet implementation that grows as needed to accommodate set(index) calls.Interface for vector compression.
The numeric datatype of the vector values.
A provider of vectorization implementations.
Vector similarity function; used in search to return top K most similar vectors to a target
vector.
Utilities for computations with numeric arrays
Interface for implementations of VectorUtil support.
Methods or classes marked VisibleForTesting are intended for internal use only
and may change without warning, regardless of their visibility.