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

Parallel stream operations for Elixir

A fast consistent hash ring implementation in Elixir

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

Unified access to tabular data

Erlang Trie Implementation

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 faster Map, augmented with a MerkleTree

Implementations of δ-CRDTs

Library for boolean satisfiability solving and expression manipulation.

Fast bounded deque using two rotating lists.

Elixir implementation of bidirectional map and multimap

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

Jump Consistent Hash NIF library for Erlang/Elixir.

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

Consistent Hash Ring

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

Algebra utilities for Elixir

SortedSet is a fast and efficient Rust backed sorted set.

Priority Search Queue

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

A simple, dependency free boolean satisfiability solver.

A splay-tree implementation

Non-empty lists in Gleam

Ordered map for Elixir lang

Immutable arrays for Gleam

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

A library for cosine similarity & simhash calculation

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

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

Elixir library computing simple combination and permutation on Enumerables.

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.

Erlang Priority Queue Implementation

An OTP application

Constraint Programming Solver

Merkle Trees for data replication purposes

Tries in Gleam

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

Double-ended queue with limited length

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.

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

Bags (or multisets) in Gleam

A double-ended queue data structure

Storing a set of closed intervals

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

Library for dealing with data structures

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

sets-like wrapper based on maps

Erlang lazy list library

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

Helper functions for working with weighted random values.

Extensions to Elixir data structures

Dependency graphs for optimal function call ordering

riak CTDT datatypes

An Elixir implementation of the Google diff_match_patch library.

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

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

Fast-and-loose PRNG experiments

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

Bloomex is a pure Elixir implementation of Scalable Bloom Filters.

GlobalConst converts large Key-Value entities to a module to make fast accessing by thousands of processes.

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

Trie based router.

A Jump Consistent Hash library

Pure Elixir AVL tree implementation

A fleet of Raft consensus groups

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

ExShards – Elixir Wrapper for cabol/shards