Algorithms and Data structures

Jump consistent hash implementation in Elixir

A fast consistent hash ring implementation in Elixir.

Raft library

Computational parallel flows for Elixir

Generic Zipper Implementation for Erlang

General purpose circular buffer.

Erlang/Elixir library for partitioned or sharded ETS tables.

A high-performance graph datastructure library for Elixir projects

A fast consistent hash ring implementation in Elixir

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

Parallel stream operations for Elixir

Erlang Trie Implementation

Unified access to tabular data

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

A faster Map, augmented with a MerkleTree

Implementations of δ-CRDTs

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.

Library for boolean satisfiability solving and expression manipulation.

Fast bounded deque using two rotating lists.

Bootstrapped algebraic data types for Elixir

A SQL92 predicate evaluator in Erlang

A dynamic data structure for efficiently indexing arbitrary boolean expressions

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

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.

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'

Consistent Hash Ring

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

Jump Consistent Hash NIF library for Erlang/Elixir.

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

A graph library. Including path finding.

Priority Search Queue

Algebra utilities for Elixir

A simple, dependency free boolean satisfiability solver.

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

Non-empty lists in Gleam

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

A splay-tree implementation

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.

Immutable arrays for Gleam

Ordered map for Elixir lang

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

SortedSet is a fast and efficient Rust backed sorted set.

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

A light ADT module for Elixir.

A library for cosine similarity & simhash calculation

Permutation is a package and protocol for calculating the possible permutations or combinations of an Enumerable.

An OTP application

AA Tree in Pure Elixir

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 library computing simple combination and permutation on Enumerables.

Merkle Trees for data replication purposes

Tries in Gleam

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.

An Erlang CRDT library

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

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

Bags (or multisets) in Gleam

Double-ended queue with limited length

Constraint Programming Solver

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

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

sets-like wrapper based on maps

Erlang lazy list library

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

Erlang Priority Queue Implementation

Dependency graphs for optimal function call ordering

Library for dealing with data structures

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

A double-ended queue data structure

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

RingBuffer - size limited queue, like a ring or cyclic buffer. With non blocking and non locking writers.

A Rose Tree and Zipper in Elixir with a slew of navigation primitives.

Trie based router.

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.

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

riak CTDT datatypes

An Elixir implementation of the Google diff_match_patch library.

Sorts a list of maps per a list of sort specs.

Conflict-free Replicated Data Types

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