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

Generic Zipper Implementation for Erlang

Erlang Trie Implementation

A high-performance graph datastructure library for Elixir projects

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 fast consistent hash ring implementation in Elixir

Unified access to tabular data

Erlang/Elixir library for partitioned or sharded ETS tables.

Library for boolean satisfiability solving and expression manipulation.

Parallel stream operations for Elixir

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

A faster Map, augmented with a MerkleTree

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

Fast bounded deque using two rotating lists.

Implementations of δ-CRDTs

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

ETS-based partitioned buffer for high-throughput data processing

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

Elixir implementation of bidirectional map and multimap

A simple, dependency free boolean satisfiability solver.

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

Bootstrapped algebraic data types for Elixir

Consistent Hash Ring

A SQL92 predicate evaluator in Erlang

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.

A splay-tree implementation

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

Jump Consistent Hash NIF library for Erlang/Elixir.

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

A dynamic data structure for efficiently indexing arbitrary boolean expressions

Algebra utilities for Elixir

An OTP application

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'

Ordered map for Elixir lang

Tries in Gleam

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

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

Elixir library computing simple combination and permutation on Enumerables.

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

Non-empty lists in Gleam

Immutable arrays for Gleam

A library for cosine similarity & simhash calculation

Data structures for the EYG IR

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

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

Bags (or multisets) in Gleam

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

Ethereum's Merkle Patricia Trie data structure

Constraint Programming Solver

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.

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

DuckDB-native dataframe library for Elixir

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

A light ADT module for Elixir.

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

riak CTDT datatypes

Erlang Priority Queue Implementation

Merkle Trees for data replication purposes

sets-like wrapper based on maps

A graph library. Including path finding.

Simple Bloom Filter wrapping the fastbloom Rust crate

Double-ended queue with limited length

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

Helper functions for working with weighted random values.

Dependency graphs for optimal function call ordering

An Erlang CRDT library

Simple implementation of standard animation easing functions.

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

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

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

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

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.

AA Tree in Pure Elixir

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