Popularity

4.3

Stable

Activity

0.0

Stable

Stars 32

Watchers 4

Forks 5

Last Commit over 5 years ago

Monthly Downloads: 8

Programming language: Elixir

License: MIT License

Tags: Algorithms And Data Structures

bitmap alternatives and similar packages

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

flow

9.6 0.0 bitmap VS flow

Computational parallel flows on top of GenStage
witchcraft

9.5 0.0 bitmap VS witchcraft

Monads and other dark magic for Elixir

Access the most powerful time series database as a service

Ingest, store, & analyze all types of time series data in a fully-managed, purpose-built database. Keep data forever with low-cost storage and superior data compression.

Promo www.influxdata.com

fuse

8.9 0.0 bitmap VS fuse

A Circuit Breaker for Erlang
matrex

8.7 0.0 bitmap VS matrex

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

8.6 0.0 bitmap VS simple_bayes

A Naive Bayes machine learning implementation in Elixir.
fsm

8.3 0.0 bitmap VS fsm

Finite State Machine data structure
exconstructor

8.1 2.8 bitmap VS exconstructor

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

8.1 0.0 bitmap VS monadex

Upgrade your pipelines with monads.
datastructures

7.7 0.0 bitmap VS datastructures

Datastructures for Elixir.
erlang-algorithms

7.7 0.0 bitmap VS erlang-algorithms

Implementations of popular data structures and algorithms
loom

7.7 0.0 bitmap VS loom

A CRDT library with δ-CRDT support.
monad

7.5 0.0 bitmap VS monad

Monads and do-syntax for Elixir
trie

7.5 0.0 bitmap VS trie

Erlang Trie Implementation
remodel

7.0 0.0 bitmap VS remodel

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

6.9 0.0 L1 bitmap VS lz4

LZ4 bindings for Erlang
MapDiff

6.7 0.0 bitmap VS MapDiff

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

6.6 0.0 bitmap VS parallel_stream

A parallelized stream implementation for Elixir
merkle_tree

6.5 0.0 bitmap VS merkle_tree

:evergreen_tree: Merkle Tree implementation in pure Elixir
bloomex

6.4 0.0 bitmap VS bloomex

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

6.4 4.4 bitmap VS sfmt

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

6.4 10.0 bitmap VS aja

Extension of the Elixir standard library focused on data stuctures, data manipulation and performance
Exads

6.3 0.0 bitmap VS Exads

Algorithms and Data Structures collection in Elixir
graphmath

6.2 0.0 bitmap VS graphmath

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

6.0 0.0 bitmap VS DeepMerge

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

5.8 0.0 bitmap VS exmatrix

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

5.7 0.0 bitmap 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)
ecto_materialized_path

5.6 0.0 bitmap VS ecto_materialized_path

Tree structure & hierarchy for ecto models
dataframe

5.5 0.0 bitmap VS dataframe

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

5.2 0.0 bitmap VS sleeplocks

BEAM friendly spinlocks for Elixir/Erlang
red_black_tree

5.1 0.0 bitmap VS red_black_tree

Red-black tree implementation for Elixir.
blocking_queue

5.1 0.0 bitmap VS blocking_queue

A blocking queue written in Elixir.
parex

5.0 0.0 bitmap VS parex

An elixir module for parallel execution of functions/processes
ratio

4.9 3.9 bitmap VS ratio

Rational number library for Elixir.
cuid

4.8 0.0 bitmap VS cuid

Collision-resistant ids, in Elixir
Conrex

4.8 0.0 bitmap VS Conrex

An Elixir implementation of the CONREC algorithm for topographic or isochrone maps.
hash_ring_ex

4.7 0.0 bitmap VS hash_ring_ex

A consistent hash ring implemention for Elixir
simhash

4.6 0.0 bitmap VS simhash

Elixir implementation of Simhash
array

4.5 0.0 bitmap VS array

An Elixir wrapper library for Erlang's array
murmur

4.4 0.0 bitmap VS murmur

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

4.3 0.0 bitmap VS memoize

DefMemo - Ryuk's little puppy! Bring apples.
aruspex

4.2 0.0 bitmap VS aruspex

A configurable constraint solver
cuckoo

4.1 0.0 bitmap VS cuckoo

:bird: Cuckoo Filters in Elixir
gen_fsm

4.1 0.0 bitmap VS gen_fsm

Elixir wrapper around OTP's gen_fsm
qex

4.0 2.8 bitmap VS qex

Queue data structure for Elixir-lang
eastar

3.9 0.0 bitmap VS eastar

A* graph pathfinding in pure Elixir
sorted_set

3.8 0.0 bitmap VS sorted_set

Sorted Set library for Elixir
luhn

3.8 0.0 bitmap VS luhn

Luhn algorithm in Elixir
Closure Table

3.7 10.0 bitmap VS Closure Table

Closure Table for Elixir - a simple solution for storing and manipulating complex hierarchies. It provides in-memory and Ecto adapters.
paratize

3.7 0.0 bitmap VS paratize

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

3.7 0.0 bitmap VS tinymt

Tiny Mersenne Twister (TinyMT) for Erlang.

* 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 bitmap or a related project?

Add another 'Algorithms and Data structures' Package

Popular Comparisons

README

Bitmap

In computing, a bitmap is a mapping from some domain (for example, a range of integers) to bits, that is, values which are zero or one. It is also called a bit array or bitmap index.

This is an Elixir implementation of a bit array. Two implementations are provided as part of the library, Binary and Integer. Integers are the default due to clear performance superiority based on benchmarks provided below.

It is a fast space efficient data structure for lookups.

Note: Index is zero based in the implementation

Examples

iex> bitmap = Bitmap.new(5)
<<0::size(5)>> # 00000
iex> Bitmap.set(bitmap, 2)
<<4::size(5)>> # 00100
iex> bitmap |> Bitmap.set(2) |> Bitmap.set(3)
<<6::size(5)>> # 00110
iex> bitmap |> Bitmap.set(2) |> Bitmap.set(3) |> Bitmap.unset(2)
<<2::size(5)>> # 00010

Read the latest documentation here for elaborate description and more examples on how to use the library.

Benchmark using `Benchfella`

Results are based on sources present inside the bench/ directory.

Bitmaps of size 1,000,000 are used to get benchmark on performance of the two implementations provided in the library - Binary and Integer.

Benchmark Bitmap.Integer.at           100000000   0.05 µs/op
Benchmark Bitmap.Integer.unset_all    100000000   0.06 µs/op
Benchmark Bitmap.Integer.set?         100000000   0.07 µs/op
Benchmark Bitmap.Integer.new           10000000   0.11 µs/op
Benchmark Bitmap.Integer.set             500000   7.50 µs/op
Benchmark Bitmap.Integer.toggle          500000   7.52 µs/op
Benchmark Bitmap.Integer.toggle_all      100000   21.33 µs/op
Benchmark Bitmap.Integer.unset           100000   22.83 µs/op
Benchmark Bitmap.Binary.unset_all         50000   74.54 µs/op
Benchmark Bitmap.Binary.new               20000   79.34 µs/op
Benchmark Bitmap.Binary.set?              20000   90.18 µs/op
Benchmark Bitmap.Binary.at                20000   99.70 µs/op
Benchmark Bitmap.Binary.toggle            10000   169.97 µs/op
Benchmark Bitmap.Binary.unset             10000   207.38 µs/op
Benchmark Bitmap.Binary.set               10000   208.58 µs/op
Benchmark Bitmap.Integer.set_all             10   111083.80 µs/op
Benchmark Bitmap.Binary.set_all              10   143833.10 µs/op
Benchmark Bitmap.Binary.to_string             1   80530194.00 µs/op
Benchmark Bitmap.Integer.to_string            1   89035291.00 µs/op
Benchmark Bitmap.Binary.toggle_all            1   451542225.00 µs/op

License

This project is available under MIT License.

*Note that all licence references and agreements mentioned in the bitmap README section above are relevant to that project's source code only.

bitmap

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