Algorithms and Data structures

Jump consistent hash implementation in Elixir

A fast consistent hash ring implementation in Elixir.

Raft library

Generic Zipper Implementation for Erlang

Computational parallel flows for Elixir

General purpose circular buffer.

Parallel stream operations for Elixir

A fast consistent hash ring implementation in Elixir

Erlang/Elixir library for partitioned or sharded ETS tables.

A high-performance graph datastructure library for Elixir projects

Erlang Trie Implementation

Unified access to tabular data

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

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.

Implementations of δ-CRDTs

A faster Map, augmented with a MerkleTree

Fast bounded deque using two rotating lists.

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

Consistent Hash Ring

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

Elixir implementation of bidirectional map and multimap

SortedSet is a fast and efficient Rust backed sorted set.

Jump Consistent Hash NIF library for Erlang/Elixir.

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

Priority Search Queue

Algebra utilities for Elixir

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

A splay-tree implementation

Ordered map for Elixir lang

A library for cosine similarity & simhash calculation

A simple, dependency free boolean satisfiability solver.

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

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

Elixir library computing simple combination and permutation on Enumerables.

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.

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

A double-ended queue data structure

A Jump Consistent Hash library

Erlang Priority Queue 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.

Erlang lazy list library

Immutable arrays for Gleam

An OTP application

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

sets-like wrapper based on maps

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

Tries in Gleam

Double-ended queue with limited length

Dependency graphs for optimal function call ordering

Helper functions for working with weighted random values.

Storing a set of closed intervals

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

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

Library for dealing with data structures

Bloomex is a pure Elixir implementation of Scalable Bloom Filters.

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

Merkle Trees for data replication purposes

riak CTDT datatypes

Pure Elixir AVL tree implementation

Non-empty lists in Gleam

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

Bags (or multisets) in Gleam

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

Fast-and-loose PRNG experiments

Trie based router.

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

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

Constraint Programming Solver

An Elixir implementation of the Google diff_match_patch library.

Monads, Functors and Do-Notation for Erlang

ExShards – Elixir Wrapper for cabol/shards

Extensions to Elixir data structures

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

An efficient implementation of double ended fifo queues

A vectors library for the Gleam programming language

Elixir wrapper of `:digraph` with a pinch of protocols and sigils

A fleet of Raft consensus groups

An efficient Elixir implementation of the binary GCD algorithm (Stein's algorithm) for computing the greatest common divisor (GCD) of two or more non-negative integers using only bitwise operations and subtraction.

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

LexoRank on Elixir. An implementation of a list ordering system.

Monadic types collection. Option (Maybe) - some(val)/none(). Result - ok(val)/error(err).

Library for boolean satisfiability solving and expression manipulation.

Easily sort by multiple fields in a readable manner