Algorithms and Data structures

Jump consistent hash implementation in Elixir

A fast consistent hash ring implementation in Elixir.

Computational parallel flows for Elixir

General purpose circular buffer.

Raft library

Use `:atomics` as a bit array or as an array of N-bit counters.

Generic Zipper Implementation for Erlang

Erlang Trie Implementation

A high-performance graph datastructure library for Elixir projects

Bootstrapped algebraic data types for Elixir

A SQL92 predicate evaluator in Erlang

Erlang/Elixir library for partitioned or sharded ETS tables.

A fast consistent hash ring implementation in Elixir

Parallel stream operations for Elixir

Unified access to tabular data

A dynamic data structure for efficiently indexing arbitrary boolean expressions

Murmur is a pure Elixir implementation of the non-cryptographic hash Murmur3. It aims to implement the x86_32bit, x86_128bit and x64_128bit variants.

A bitwise radix tree for prefix based matching on bitstring keys of any length.

Library for boolean satisfiability solving and expression manipulation.

Fast bounded deque using two rotating lists.

A faster Map, augmented with a MerkleTree

Implementations of δ-CRDTs

Create an alphabetical hash. Taking an existing alphabetic hash (of any length), will return the next hash in sequence. If all characters in hash are rolled over, will append a new char (increase the length by 1.) eg. 'ZZZZ' -> 'AAAAA' eg. 'AAAZ' -> 'AABA'

A pure Elixir implementation of the AKS (Agrawal-Kayal-Saxena) primality test algorithm.

Simple Elixir queue, with a constant-time `size/1` and a maximum capacity.

A high-performance graph datastructure library for Elixir projects with multigraph support

Elixir implementation of bidirectional map and multimap

Implementation of the Ramer–Douglas–Peucker algorithm for reducing the number of points used to represent a curve.

Accomplice is a library for grouping members of a list with a respect to a number of constraints.

A light ADT module for Elixir.

Elixir lib for Aho-Corasick string searching. Uses a Rust-based NIF for greatly improved performance.

A graph library. Including path finding.

A `:queue` wrapper with improvements in API and addition of Protocol implementations

A simple, dependency free boolean satisfiability solver.

Jump Consistent Hash NIF library for Erlang/Elixir.

Consistent Hash Ring

AA Tree in Pure Elixir

A splay-tree implementation

Abacus is a module for transforming other modules into metric systems. These modules (metric systems) make it possible to use functions to create values enclosed in a metric system and functions to manipulate these values.

Calculates the set of unambiguous abbreviations for a given set of strings.

Elixir lib for Aho-Corasick string searching. Uses a Rust-based NIF for greatly improved performance.

ETS-based partitioned buffer for high-throughput data processing

A very efficient way to share mutable data with :atomics and :ets

An Erlang CRDT library

NaryTree implements the data structure for n-ary tree (also called rose tree), where each node in the tree can have zero or more children. NaryTree provides methods for traversal and manipulation of the tree structure and node contents.

Small composable Heap implementation. Heaps sort elements at insert time.

Algebra utilities for Elixir

Non-empty lists in Gleam

An OTP application

Immutable arrays for Gleam

A pure Gleam package to compute the edit distance of two strings

Ordered map for Elixir lang

Aho-Corasick algorithm, implemented in Elixir using Erlang's :digraph for the graph structure

Affine Transform Library

Implementation of Walker's Alias method by Elixir

Alltid offers a simplified approach to editing deeply nested immutable data structures in Elixir.

Annealing is a library for building and running simulated annealing algorithms in Elixir.

Tries in Gleam

Data structures for the EYG IR

Utilities for hierarchical data structures with parent/child relationships

A circular buffer backed by a queue, map, or ETS

A library for cosine similarity & simhash calculation

Elixir library computing simple combination and permutation on Enumerables.

Merkle Trees for data replication purposes

A high-performance, concurrent, and mutable Cuckoo Filter for Erlang and Elixir

Convert between plain text and inverted index format

Elixir/Erlang interface to MiniZinc (https://www.minizinc.org/).

Bags (or multisets) in Gleam

Constraint Programming Solver

A fast, safe, batteries-included array for Gleam!

sets-like wrapper based on maps

Ethereum's Merkle Patricia Trie data structure

Well-structured Arrays with fast random-element-access for Elixir, offering a common interface with multiple implementations (MapArray, Erlang :array, etc.) with varying performance guarantees that can be switched in your configuration.

Erlang Priority Queue Implementation

Probabilistic data structures powered by atomics. Bloom filter, Counting bloom filter, Linear counter (cardinality)

Real-valued intervals with support for the `Enumerable` protocol.

riak CTDT datatypes

Simple Bloom Filter wrapping the fastbloom Rust crate

GenStagA data type and related functions to support an unrooted (multiple starting nodes) polytree (a tree-like graph with edges).

Double-ended queue with limited length

Traverse is a toolset to walk arbitrary Elixir Datastructures in a functional way.

Library for dealing with data structures