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.
ByteSequence implementation backed by an on-heap byte array.
Methods for manipulating arrays.
VectorFloat implementation backed by an on-heap float array.
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 an adjustable maximum size.
A buffered DataOutput that adds seek(), checksum(), and readFully methods
Encapsulates comparing node distances for GraphIndexBuilder.
RandomAccessReader that reads from a ByteBuffer
This is NOT a general "make vectors go faster" class.
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.
The standard
ThreadLocal appears to be designed to be used with relatively
short-lived Threads.A feature of an on-disk graph index.
An enum representing the features that can be stored in an on-disk graph index.
BitSet of fixed length (numBits), backed by accessible (
FixedBitSet.getBits()) long[], accessed with
an int index, implementing Bits.Implements Quick ADC-style scoring by fusing PQ-encoded neighbors into an OnDiskGraphIndex.
Represents a graph-based vector index.
A View that knows how to compute scores against a query vector.
Encapsulates the state of a graph for searching.
Builder for Concurrent GraphIndex.
Searches a graph to find nearest neighbors to a query vector.
Deprecated.
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).
Implements the storage of full-resolution vectors inline into an OnDiskGraphIndex.
A RandomAccessVectorValues that knows how to load full-resolution vectors from an index that is in the process
of being written.
A KMeans++ implementation for float vectors.
This class is used to load supporting native libraries.
A List-backed implementation of the
RandomAccessVectorValues interface.Implements Locally-Adaptive Vector Quantization (LVQ) as described in
"Similarity search in the blink of an eye with compressed indices" (https://arxiv.org/abs/2304.04759).
A Turbo LVQ vector that has been packed into a byte sequence.
A LVQ-quantized vector.
Implements the storage of LVQ-quantized vectors in an on-disk graph index.
A RandomAccessVectorValues that knows how to decode LVQ vectors from an index that is in the process
of being written.
RandomAccessValues backed by a Map.
Matrix object where each row is a VectorFloat; this makes multiplication of a matrix by a vector
a series of efficient dot products.
ByteSequence implementation backed by an on-heap MemorySegment.
MemorySegment based implementation of RandomAccessReader.VectorFloat implementation backed by an on-heap MemorySegment.
VectorTypeSupport using MemorySegments.
Experimental!
VectorizationProvider implementation that uses MemorySegment vectors and prefers native/Panama SIMD.
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.Iterator over graph nodes that includes the size –- the total
number of nodes to be iterated over.
NodesUnsorted contains scored node ids in insertion order.
Helper APIs to encode numeric values as sortable bytes and vice-versa.
A class representing a graph index stored on disk.
Write a graph index to disk, for later loading as an OnDiskGraphIndex.
Builder for OnDiskGraphIndexWriter, with optional features.
An
GraphIndex that offers concurrent access; for typical graphs you will get significant
speedups in construction and searching as you add threads.Vectorization provider that uses on-heap arrays and SIMD operations through Panama SIMD API.
A fork join pool which is sized to match the number of physical cores on the machine (avoiding hyper-thread count)
Product Quantization for float vectors.
Performs similarity comparisons with compressed vectors without decoding them.
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.
Provides an API for encapsulating similarity to another node or vector.
An ExactScoreFunction with an optimized batch `similarityTo` method for reranking
results after an approximate-scored search.
Container class for results of an ANN search, along with associated metrics about the behavior of the search.
Encapsulates comparing node distances to a specific vector for GraphSearcher.
This interface allows implementations to cache the vectors needed
for its lifetime of a single ConcurrentNeighborSet diversity computation,
since diversity computations are done pairwise for each of the potential neighbors.
Simple sample implementation of RandomAccessReader.
Implements the membership parts of an updatable BitSet (but not prev/next bits)
Deprecated.
A thread-safe
BitSet implementation that grows as needed to accommodate set(index) calls.Interface for vector compression.
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.