Popularity

4.2

Declining

Activity

0.0

Stable

Stars 29

Watchers 3

Forks 5

Last Commit over 4 years ago

Monthly Downloads: 157

Programming language: Elixir

License: MIT License

Tags: Algorithms And Data Structures

memoize alternatives and similar packages

Based on the "Algorithms and Data structures" category.
Alternatively, view memoize alternatives based on common mentions on social networks and blogs.

flow

9.6 3.9 memoize VS flow

Computational parallel flows on top of GenStage
witchcraft

9.4 3.8 memoize VS witchcraft

Monads and other dark magic for Elixir

Run Linux Software Faster and Safer than Linux with Unikernels

Promo github.com/nanovms

fuse

8.9 7.7 memoize VS fuse

A Circuit Breaker for Erlang
matrex

8.8 0.0 memoize VS matrex

A blazing fast matrix library for Elixir/Erlang with C implementation using CBLAS.
simple_bayes

8.6 0.0 memoize VS simple_bayes

A Naive Bayes machine learning implementation in Elixir.
fsm

8.3 0.0 memoize VS fsm

Finite State Machine data structure
monadex

8.1 0.0 memoize VS monadex

Upgrade your pipelines with monads.
exconstructor

8.1 4.4 memoize VS exconstructor

An Elixir library for generating struct constructors that handle external data with ease.
datastructures

7.8 0.0 memoize VS datastructures

Datastructures for Elixir.
loom

7.8 0.0 memoize VS loom

A CRDT library with δ-CRDT support.
erlang-algorithms

7.7 0.0 memoize VS erlang-algorithms

Implementations of popular data structures and algorithms
monad

7.5 0.0 memoize VS monad

Monads and do-syntax for Elixir
trie

7.4 0.3 memoize VS trie

Erlang Trie Implementation
remodel

7.0 0.0 memoize VS remodel

:necktie: An Elixir presenter package used to transform map structures. "ActiveModel::Serializer for Elixir"
lz4

6.9 0.0 L1 memoize VS lz4

LZ4 bindings for Erlang
merkle_tree

6.4 0.0 memoize VS merkle_tree

:evergreen_tree: Merkle Tree implementation in pure Elixir
parallel_stream

6.4 0.0 memoize VS parallel_stream

A parallelized stream implementation for Elixir
Exads

6.3 0.0 memoize VS Exads

Algorithms and Data Structures collection in Elixir
bloomex

6.3 1.7 memoize VS bloomex

:hibiscus: A pure Elixir implementation of Scalable Bloom Filters
sfmt

6.3 5.2 memoize VS sfmt

sfmt-erlang: SIMD-oriented Fast Mersenne Twister (SFMT) for Erlang
MapDiff

6.1 2.7 memoize VS MapDiff

Calculates the difference between two (nested) maps, and returns a map representing the patch of changes.
graphmath

6.1 5.5 memoize VS graphmath

An Elixir library for performing 2D and 3D mathematics.
the_fuzz

5.9 0.0 memoize VS the_fuzz

String metrics and phonetic algorithms for Elixir (e.g. Dice/Sorensen, Hamming, Jaccard, Jaro, Jaro-Winkler, Levenshtein, Metaphone, N-Gram, NYSIIS, Overlap, Ratcliff/Obershelp, Refined NYSIIS, Refined Soundex, Soundex, Weighted Levenshtein)
exmatrix

5.9 0.0 memoize VS exmatrix

Elixir library implementing a parallel matrix multiplication algorithm and other utilities for working with matrices. Used for benchmarking computationally intensive concurrent code.
dataframe

5.6 0.0 memoize VS dataframe

Package providing functionality similar to Python's Pandas or R's data.frame()
DeepMerge

5.6 0.0 memoize VS DeepMerge

Deep (recursive) merge for maps, keywords and others in Elixir
ecto_materialized_path

5.4 0.0 memoize VS ecto_materialized_path

Tree structure & hierarchy for ecto models
parex

5.3 0.0 memoize VS parex

An elixir module for parallel execution of functions/processes
blocking_queue

5.2 0.0 memoize VS blocking_queue

A blocking queue written in Elixir.
red_black_tree

5.1 0.0 memoize VS red_black_tree

Red-black tree implementation for Elixir.
hash_ring_ex

4.9 0.0 memoize VS hash_ring_ex

A consistent hash ring implemention for Elixir
sleeplocks

4.9 1.2 memoize VS sleeplocks

BEAM friendly spinlocks for Elixir/Erlang
simhash

4.8 0.0 memoize VS simhash

Elixir implementation of Simhash
array

4.4 0.0 memoize VS array

An Elixir wrapper library for Erlang's array
cuid

4.4 0.0 memoize VS cuid

Collision-resistant ids, in Elixir
murmur

4.3 3.2 memoize VS murmur

:speech_balloon: An implementation of the non-cryptographic hash Murmur3
gen_fsm

4.3 0.0 memoize VS gen_fsm

Elixir wrapper around OTP's gen_fsm
ratio

4.2 0.8 memoize VS ratio

Rational number library for Elixir.
bitmap

4.2 0.0 memoize VS bitmap

Bitmap implementation in Elixir using binaries and integers. Fast space efficient data structure for lookups
cuckoo

4.0 1.7 memoize VS cuckoo

:bird: Cuckoo Filters in Elixir
sorted_set

3.9 0.0 memoize VS sorted_set

Sorted Set library for Elixir
aruspex

3.9 0.0 memoize VS aruspex

A configurable constraint solver
tinymt

3.7 0.0 memoize VS tinymt

Tiny Mersenne Twister (TinyMT) for Erlang.
paratize

3.6 0.0 memoize VS paratize

Elixir library providing some handy parallel processing facilities that supports configuring number of workers and timeout.
eastar

3.6 0.0 memoize VS eastar

A* graph pathfinding in pure Elixir
exor_filter

3.4 2.0 memoize VS exor_filter

Erlang nif for xor_filter. 'Faster and Smaller Than Bloom and Cuckoo Filters'.
luhn

3.4 0.8 memoize VS luhn

Luhn algorithm in Elixir
combination

3.4 0.0 memoize VS combination

A simple combinatorics library providing combination and permutation.
tfidf

3.3 0.0 memoize VS tfidf

tf-idf elixir
Mappable

3.3 0.0 memoize VS Mappable

Simple module that provides unified, simple interface for converting between different dictionary-like data types in Elixir.

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.

Do you think we are missing an alternative of memoize or a related project?

Add another 'Algorithms and Data structures' Package

Popular Comparisons

README

DefMemo

A memoization macro (defmemo) for Elixir.

Adapted from : (Gustavo Brunoro) https://gist.github.com/brunoro/6159378

I found Gustavo's Gist when looking at memoization and elixir and fixed it to work with version 1.0.x. Since then I've fixed a few of the problems with the original implementation:

will correctly memoize the results of functions with identical signatures but in different modules.
will work with 'when' guard clauses in function definitions. (That was fun!)
Added lots of lovely tests.

Usage

Add defmemo to your mix.exs file:

{:defmemo, "~> 0.1.0"}

And run:

mix deps.get

Before using a defmemo'd function (it's fine to define them), start_link must be called. e.g.

DefMemo.start_link

or you can add :defmemo into the applications section of your mix.exs:

[applications: [:logger, :defmemo]]

Example

defmodule FibMemo do
  import DefMemo

  defmemo fibs(0), do: 0
  defmemo fibs(1), do: 1
  defmemo fibs(n), do: fibs(n - 1) + fibs(n - 2)

  def fib_10 do
    fibs(10)
  end
end

Performance

As you would expect for something like fibs, memoization provides dramatic performance improvements:

UNMEMOIZED VS MEMOIZED
***********************
fib (unmemoized)
function -> {result, running time(μs)}
==================================
fibs(30) -> {832040, 31089}
fibs(30) -> {832040, 31833}

FibMemo (memoized)
==================================
fibs(30) -> {832040, 79}
fibs(30) -> {832040, 3}
fibs(50) -> {12586269025, 103}
fibs(50) -> {12586269025, 3}

Note that these have also improved from version 0.1 to 0.1.1. The above numbers are on the low end of the spectrum with access ranging from 2 to 15 μs for me.

TODO

Add test for supervisor crashing.
Look at injecting the type of result table used.
Better documentation.
More tests (alwaaaays with the testing!)
Test with some biger data (e.g. for something like web crawling)
~~Supervisor ~~
Redis Based ResultTable - I've been playing with this - obviously there are limitations on type and it's slower than gen server but there are of course circumstances where it could be useful but for the most part its not a good "fit".

memoize

DefMemo - Ryuk's little puppy! Bring apples.