Lib.rs

rand

Random number generators and other randomness functionality

crc

Rust implementation of CRC(16, 32, 64) with support of various standards

twox-hash

A Rust implementation of the XXHash and XXH3 algorithms

rand_jitter

Random number generator based on timing jitter

bytecount

count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast

ahash

A non-cryptographic hash function using AES-NI for high performance

crc-any

To compute CRC values by providing the length of bits, expression, reflection, an initial value and a final xor value. It has many built-in CRC functions.

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

oorandom

A tiny, robust PRNG implementation

fake

An easy to use library for generating fake data like name, number, address, lorem, dates, etc

adler32

Minimal Adler32 implementation for Rust

pathfinding

Pathfinding, flow, and graph algorithms

numext-fixed-uint

Fixed-size uint types

fst

Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)

twoway

Fast substring search for strings and byte strings. Optional SSE4.2 acceleration (if detected at runtime) using pcmpestri. Memchr is the only mandatory dependency. The two way algorithm…

alphanumeric-sort

This crate can help you sort order for files and folders whose names contain numerals

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

bio

A bioinformatics library for Rust. This library provides implementations of many algorithms and data structures that are useful for bioinformatics, but also in other fields.

dmsort

Fast adaptive sorting for when most of your data is already in order. dmsort can be 2-5 times faster than Rust’s default sort when more than 80% of the elements are already in order

ratelimit_meter

A leaky-bucket-as-a-meter rate-limiting implementation in Rust

rdrand

An implementation of random number generator based on rdrand and rdseed instructions

fastrand

A simple and fast random number generator

highway

Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function

triple_buffer

An implementation of triple buffering, useful for sharing frequently updated data between threads

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

radiate

Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems

fastcdc

FastCDC (content defined chunking) in pure Rust

ncollide2d

2 and 3-dimensional collision detection library in Rust

md5

The package provides the MD5 hash function

regex-syntax

A regular expression parser

pcg_rand

An implementation of the PCG family of random number generators in pure Rust

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

wyhash

Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator

whatlang

Natural language detection library. Identifies language of a given text.

passwords

This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them

rustc-hash

speed, non-cryptographic hash used in rustc

lp-modeler

A linear programming modeller written in Rust. This api helps to write LP model and use solver such as CBC, Gurobi, lp_solve, …

rust-lapper

A fast and easy interval overlap library

jubjub

Implementation of the Jubjub elliptic curve group

rand_chacha

ChaCha random number generator

multihash

Implementation of the multihash format

triple_accel

Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.

vpsearch

Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces

textnonce

Text based random nonce generator

counting_sort

Counting sort implementation for Iterators

crc32c

Safe implementation for SSE 4.2 CRC32C instructions, with software fallback

vek

Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience

nanoid

A tiny, secure, URL-friendly, unique string ID generator for Rust

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

leaky-bucket

Futures-aware rate limiter implementation

fsm_gen

FSM (finite state machine) DSL for code generation (c++ at the moment)

flo_curves

Library for manipulating Bezier curves

dusk-plonk

A pure-Rust implementation of the PLONK ZK-Proof algorithm

numext-constructor

Fixed-size uint and hash constructor

ff

Library for building and interfacing with finite fields

monotonic_solver

A monotonic solver designed to be easy to use with Rust enum expressions

strength_reduce

Faster integer division and modulus operations

rand_regex

Generates random strings and byte strings matching a regex

probability

The package provides a probability-theory toolbox

fxhash

A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc

out

Provides fast min and max functionality for collections

permutator

Get a lexicographic cartesian product and lexicographic permutation at any specific index from data. Generate complete lexicographic cartesian product from single or multiple set of data…

nonogrid

Efficient nonogram solver

graphplan

Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust

is_sorted

Is an Iterator sorted?

random_color

Rust crate for generating random attractive colors

hnsw

Fast approximate nearest neighbors

streaming-stats

Experimental crate for computing basic statistics on streams

k

k is for kinematics

dissimilar

Diff library with semantic cleanup, based on Google’s diff-match-patch

adler

A simple clean-room implementation of the Adler-32 checksum

ipopt

Rust language bindings for the Ipopt non-linear constrained optimization library

rs_algo

Common sorting algorithms and other common computer science algorithms

metrohash

Rust implementation of MetroHash, a high quality, high performance hash algorithm

ranges

This crate provides a generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible

nanorand

A tiny, fast, zero-dep library for random number generation

basic_dsp

Digital signal processing based on real or complex vectors in time or frequency domain

gcd

Small Rust library (with no dependencies) for calculating greatest common divisor

bao

a general-purpose cryptographic tree hash

noise

Procedural noise generation library

hungarian

A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm

worley-noise

Worley noise implementation

treediff

Find the difference between arbitrary data structures

xoroshiro128

Fast psuedo-random number generators

sdset

Set operations for sorted and deduplicated slices. Much performances! Such Wow!

cdchunking

Content-defined chunking

acacia

A spatial partitioning and tree library

rsgenetic

A library providing genetic algorithm execution

governor

A rate-limiting implementation in Rust

muldiv

Provides a trait for numeric types to perform combined multiplication and division with overflow protection

random-pick

Pick an element from a slice randomly by given weights

wildmatch

Simple string matching with questionmark and star wildcard operator

yada

Yada is a yet another double-array trie library aiming for fast search and compact data representation

levenberg-marquardt

Levenberg-Marquardt algorithm built on top of nalgebra

mop

Flexible and modular single or multi-objective solver for contiguous and discrete problems

convert-base

convert the radix (base) of digits stored in a vector

cdshealpix

Rust implementation of the HEALPix tesselation

natord

Natural ordering for Rust

microfft

Embedded-friendly Fast Fourier Transforms

safe-mix

Implementation of the Collective Coin Flip algorithm

friedrich

Gaussian Process Regression

tree-index

Index a flat-tree

rs-graph

A library for graph algorithms and combinatorial optimization

extendhash

Rust Hash Extender

test-data-generation

A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

boyer-moore-magiclen

Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust

rand_distr

Sampling from random number distributions

zipf

A fast generator of discrete, bounded Zipf-distributed random numbers

vrp-core

A core algorithms to solve a Vehicle Routing Problem

id_tree_layout

A library to visualize trees from the ‘id_tree’ crate

galm

GalM is pattern matching library

simplers_optimization

A Rust implementation of the Simple(x) black-box optimization algorithm

voracious_radix_sort

State of the art radix sort algorithms. Single thread and multi thread versions.

sorting_rs

Collection of sorting algorithms implemented in Rust

pos_pso

Particle Swarm Optimizer

faiss

High-level bindings for Faiss, the vector similarity search engine

hybrid-clocks

Hybrid Logical Clocks

simsearch

A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)

poi

A pragmatic point-free theorem prover assistant

rust-3d

2D/3D library written in rust

vsprintf

Rust bindings to the libc vsprintf function

flat_spatial

Flat spatial partitionning algorithms and data structures

dlt

DLT (direct linear transform) algorithm for camera calibration

geozero

Zero-Copy reading and writing of geospatial data

amadeus-streaming

SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling

seqdiff

Diff between two sequences

crunch

A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind

dasp_interpolate

An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc

xxhrs

Safe XXHash and XXH3 bindings

accurate

(more or less) accurate floating point algorithms

ncollide3d

2 and 3-dimensional collision detection library in Rust

accrete

Rust port of Accrete, planetary system generation algorithm. Based on ‘Formation of Planetary Systems by Aggregation: A Computer Simulation’ by Stephen H. Dole. Improved and extended…

fakeit

Fake data generator library with 130+ functions

pikkr

JSON Parser which picks up values directly without performing tokenization in Rust

cauchy

Trait for real and complex numbers

eddie

Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler

nlopt

Wrapper for the nlopt library

pubgrub

PubGrub version solving algorithm

smawk

Functions for finding row-minima in a totally monotone matrix

appr_dbscan_rust

Rust implementation of the approximated DBSCAN algorithm introduced by Gan and Tao

const-random-macro

Provides the procedural macro used by const-random

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

robust

Robust predicates for computational geometry

bitintr

Portable Bit Manipulation Intrinsics

color-thief

Grabs the dominant color or a representative color palette from an image

cassowary

A Rust implementation of the Cassowary linear constraint solving algorithm. The Cassowary algorithm is designed for naturally laying out user interfaces using linear constraints, like…

xorf

Library implementing xor filters - faster and smaller than bloom and cuckoo filters

zvxryb-broadphase

A broadphase collision detection library

color_space

library for converting between color spaces and comparing colors

glicko2

Implementation of the glicko2 rating system

sublime_fuzzy

Fuzzy matching algorithm based on Sublime Text’s string search. Check out the repository’s releases for a summarized changelog.

hnsw_rs

Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin

astro

Advanced algorithms for astronomy

building_blocks_procgen

Algorithms for procedural generation of voxel data

petal-neighbors

Nearest neighbor search algorithms including a ball tree and a vantage point tree

detect-lang

Language detection given paths and extensions

maglev

Maglev - Google’s consistent hashing algorithm

median

An implementation of an efficient O(n) median filter

fuzzyhash

Pure Rust fuzzy hash implementation

punkt

An implementation of a Punkt sentence tokenizer

multistream-batch

Implementations of batching algorithms

afsort

American Flag sort implementation for faster sorting of Strings

hypernonsense

Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space

nqueens-oxigen

N Queens problem resolution using oxigen

fuse-rust

Fuse is a super lightweight library which provides a simple way to do fuzzy searching. Fuse-Rust is a port of Fuse-Swift, written purely in rust

coord_transforms

A Rust crate use for performing coordinate transformations

varint-rs

A small, zero dependency varint implementation in Rust

gut

Geometry utilities: storing, manipulating and processing geometries

vrf

Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves

chull

Convex hull approximation

rendezvous_hash

An implementation of Rendezvous hashing algorithm

startin

A Delaunay triangulator for terrains

zeros

Extensions for hashing crates

superslice

Extensions for slices

merging-iterator

An iterator to return the elements of two independently ordered iterators in order

sub-strs

For finding sub strings

twofloat

Double-double arithmetic functionality

diffus-derive

Finds the difference between two instances of any data structure. Supports derive on structs and enums.

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

slice-group-by

Iterators over groups in a slice

osqp

The OSQP (Operator Splitting Quadratic Program) solver

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

enso-prelude

An augmented standard library in the vein of Haskell’s prelude

hyperloglogplus

HyperLogLog implementations

geo-clipper

Boolean operations on polygons

algos

A collection of algorithms in Rust

symspell

Spelling correction & Fuzzy search

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

sorts

A collection of sorting algorithms

adqselect

A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu

suffix_array

Suffix array construction and searching algorithms for in-memory binary data

levenshtein

Levenshtein algorithm

iter-set

Set operations on sorted, deduplicated iterators

permu-rs

A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.

sfcgal

High-level bindings to SFCGAL and conversion from/to other geometry libraries

meowhash

Meow hash function

fallible-iterator

Fallible iterator traits

wkb

Convert geo-types from georust to/from Well Known Binary

diffr-lib

An implementation of Myers diff algorithm

names

A library to generate random name strings suitable for use in container instances, project names, application instances, etc

random-access-storage

Abstract interface to implement random-access instances

easy_reader

Move forward, backward or randomly through the lines of huge files. Easily and fastly.

timely_sort

Sorting infrastructure for timely dataflow

programinduction

A library for program induction and learning representations

primes

A package for calculating primes using the Sieve of Eratosthenes, and using that to check if a number is prime and calculating factors. Includes an iterator over all primes.

rl-bandit

A simple multi-armed bandit implementation

vec_mut_scan

Forward scan over a vector with mutation and item removal

crc64fast

SIMD accelerated CRC64 calculation

addchain

Generate addition chains

atomic-traits

The traits for generic atomic operations

rand_derive2

Generate customizable random types with the rand crate

baseperm

A tool for generating valid permutations of encoded inputs

endicon

Implementations of codicon traits for endianness encodings

gear

Collision avoidance path planning for robotics

avalog

An experimental implementation of Avatar Logic with a Prolog-like syntax

tailcall

Safe, zero-cost tail recursion

toposort-scc

An implementation of Kahn’s algorithm for topological sorting and Kosaraju’s algorithm for strongly connected components

geos-sys

GEOS C API bindings

beehave

A simple library for defining and evaluating a hierarchical state machine (behaviour tree)

normalize-line-endings

Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n

gurobi

An unofficial Rust API for Gurobi optimizer

kmeans

Small and fast library for k-means clustering calculations

external_sort

Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams

crc16

A CRC16 implementation

pso

Particle Swarm Optimizer

permutohedron

Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.

bibicode

A crate to convert any integer from one numeral system to another

codebreaker

Decrypt & encrypt any cheat code for CodeBreaker PS2

qptrie

A QP-Trie implementation for Rust

permutation_iterator

A Rust library for iterating over random permutations using O(1) (i.e. constant) space.

genevo

genevo provides building blocks to run simulations of optimization and search problems using genetic algorithms (GA). Execute genetic algorithm (GA) simulations in a customizable and extensible way

qframework

A experimental micor framework for clear design, based on queue model

poisson-diskus

Poisson disk distribution sampling

md6

Implementation of the MD6 hash function for Rust via FFI

introsort

Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly

extprim

Extra primitive types (u128, i128)

lonlat_bng

Convert longitude and latitude coordinates to BNG coordinates, and vice versa

bufferpool

A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions

optimization

Collection of optimization algorithms

hashers

A collection of non-cryptographic hashing algorithms for Rust

extsort

External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator

sobol

A Sobol sequence generator for Rust

conshash

A library to do consistent hashing in Rust

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

toolbox

Simple tools for daily use

line-col

Convert string slice indices into line/column numbers

special

The package provides special functions

overlord

Overlord consensus procotol

geo-raycasting

Ray Casting algorithm for the geo crate

order-stat

Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm

lv03

Conversion between the Swiss coordinate system (LV03/CH1903 or LV95/CH1903+) and WGS84 coordinates

rustlex_fsa

Library for manipulating (deterministic) finite automata

faiss-sys

Native bindings for Faiss

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

buldak

It is a library that provides various sorting functions

loaded_dice

A simple sampler for loaded dices, implementing the alias method

filter

Kalman filters and other optimal and non-optimal estimation filters in Rust

symmetric-shadowcasting

Simple implementation of the shadow casting FOV algorithm

zwohash

A fast, deterministic, non-cryptographic hash for use in hash tables

wy

Rust implementation of wyhash algorithms

rs-snowflake

The snowflake algorithm rust version

hashed-permutation

A fast, instant-access way to permute a range of numbers

lttb

An implementation of the Largest Triangle Three Buckets algorithm

rlstats-rs

API wrapper for https://rocketleaguestats.com/

vec-drain-where

alternative Vec::drain_filter impl

count-min-sketch

Count-min-sketch implementation

midas_rs

Rust lib port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)

acap

As Close As Possible — nearest neighbor search in Rust

liblbfgs

Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS

halton

A module for generating Halton sequences

rvs-c-api

C-API for Rvs - A library for defining and evaluating random variables using a simple DSL

IntegerScaling

Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction

probminhash

Minhash algorithms for weighted Jaccard index

weighted_levenshtein

Generic implementation of Levenshtein distance allowing arbitrary weighting of operations

benchfun

Benchmarking functions to use for optimization algorithms

rusty_grammar

A modified CYK algorithm to work for Language

bloom-filters

Rust port of https://github.com/tylertreat/BoomFilters

opensimplex_noise_rs

OpenSimplex noise algorithm implementation in Rust

basic_dsp_matrix

Digital signal processing based on real or complex vectors in time or frequency domain

traversal

Generic and lazy tree traversal algorithms

graphene

A general purpose, extensible Graph Theory data type and algorithm library for Rust

sorted_intersection

Intersection Iterator Over Sorted Iterators

bromberg_sl2

Cayley hashing as in ‘Navigating in the Cayley Graph of SL₂(𝔽ₚ)’

rdx

A collection of traits and algorithms to ease using radix sorts

rand_mt

Reference Mersenne Twister random number generators

censor

A simple text profanity filter

maze_generator

A library of different maze generation algorithms

simple_gaussian

Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.

petal-decomposition

Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)

rusty_planner

Artificial intelligence planning & reasoning library for Rust

poisson2d

Poisson disk sampling generator

subslice

Fast subslice search

paginator

This crate is used for generating pagination bar

cutter

A simple usefull functions for parsing text. Used for cutting between strings.

rootfind

Root-finding algorithms

sortrs

An introspective sort implementation

rdp

An FFI wrapper for the Ramer–Douglas–Peucker and Visvalingam-Whyatt algorithms

rust-algorithm

algorithm

raft

The rust language implementation of Raft algorithm

sample_planning

Sample Based Planner

galois_2p8

Basic Arithmetic over all GF(2^8) fields

primecount

Rust wrapper for https://github.com/kimwalisch/primecount

flo_binding

Declarative binding library for Rust

simplerand

Simple and fast random number generator

block-array-cow

In memory array de-duplication, useful for efficient storing of a history of data versions

tdigest

T-Digest algorithm in Rust

pdqsort

Pattern-defeating quicksort

concorde

reconfigurable lattice agreement

rtriangulate

Delaunay triangulation on a set of points

supermemo2

A simple crate that implements the supermemo2 spaced repetition algorithm

moodyblues-sdk

A tracer SDK for Overlord like consensus algorithm

hashring

A minimal implementation of consistent hashing

batsat

Extensible SAT solver in Rust

cobs

This is an implementation of the Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the “sentinel” value)…

marching-squares

Parallelized marching squares algorithm for constructing closed isolines / contour lines

robust-binary-search

Robust Binary Search provides a binary search implementation which is robust against errors during the search

probably

A library with various approximate computing algorithms

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

howto

instant coding answers via the command line

spooks

Spook in Rust

vrp-pragmatic

An extension logic for solving rich VRP

indented-blocks

parser for indented blocks

hotsax

An implementation of the HOTSAX and HOTSAX based discord discovery algorithms

sort-it

Various sorting algorithms

hilbert

Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm

human-sort

Human sort (natural sort) implementation

radsort

Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)

quasirandom

Quasirandom number generation

nats-types

Enumerations and types for representing NATS protocol messages

rusted_list

A ever sorted list for rust that is operating on binary search

darwin-rs

Evolutionary algorithms library written in Rust

phreak_facts

Rule matching algorithm focussed on speed

eight-point

Eight-point algorithm for essential matrix estimation

vecshard

Split Vecs in constant time

llrb-index

Left Leaning Red Black index

pinyin-order

A Rust library that helps sort a string vector by Pinyin. Rust 字符串向量按拼音排序

ordist

Order distance package

sorted-vec

Create and maintain sorted vectors

hutton-rust

The Hutton cipher implemented as a Rust crate

enso-shapely

Automated typeclass derivation

java_random

The java LCG and random module implementation in rust

alass-core

Automatic Language-Agnostic Subtitle Synchronization (Library)

bitreader

BitReader helps reading individual bits from a slice of bytes. You can read “unusual” numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer.

bls-signatures-rs

Open source implementation of Bonneh-Lynn-Shacham (BLS) signatures written in Rust

competitive-hpp

Competitive Programming Library for AtCoder with Rust

statest

Rust crate for statistical test

urandom

Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms

bip_dht

Implementation of the bittorrent mainline DHT

count_sort

O(n) sorting library for large datasets with small range of possible values

vose-alias

An implementation of the Vose Alias method to sample an element out of a list, given a discrete probablity distribution

voronator

Implements the Voronoi diagram construction as a dual of the Delaunay triangulation for a set of points and the construction of a centroidal tesselation of a Delaunay triangulation

bsa3-hash

The hash function used in BSA files for The Elder Scrolls III: Morrowind

xbar

An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm

aliasmethod

Implementation of Walker’s Alias method

hamming

Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.

bravery_router

Radix Tree implementation

algebraics

algebraic numbers library

dedup_signature

This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents

raftlog

An implementation of distributed replicated log based on the Raft algorithm

permut_lib

Simple function to generate permutations on a dictionry of a u8 chars set. I used it for generate unic Items into my proc macros.

kangarootwelve_xkcp

An FFI wrapper for the XKCP implementation of the KangarooTwelve hash function

fastvlq

A fast variant of Variable-Length Quantity with a focus on speed and no_std support

indexed_bitvec

An indexed bitvector with (hopefully) fast rank and select operations

phpass

PHPass, the WordPress password hasher, re-implemented in rust

modulo

Simple modulo operation

mersenne_twister

Mersenne Twister pseudorandom number generator

ffts

Rust binding for ffts (The Fastest Fourier Transform in the South)

raft4rs

Rust impl for raft

dummy

Macros implementation of #[derive(Dummy)]

consistent_hashing

ConsistentHashing Alogrithm in Rust

dia-range

Ranges for all integers

rustgraphblas

Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector

gearhash

Fast, SIMD-accelerated hash function for content-defined chunking

cap-rand

Capability-oriented random number generators

fuss

Small, lightweight simplex noise generator for Rust

uniset

A hierarchical, growable bit set with support for in-place atomic operations

delaunay2d

A library to compute Delaunay triangulations and Voronoi diagrams in 2D space

smbus-pec

Minimal portable implementation of SMBus Packet Error Code calculation algorithm

highwayhash

Bindings to AVX-2-optimized SIP-like hash functions

english-numbers

Convert integers to written English number format

dists

2d distribution generator

permutation

Small utility for creating, manipulating, and applying permutations

clock-zones

A library for handling clock zones

sort

lis

Longest increasing subsequence algorithm

postcard-cobs

This is an implementation of the Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the “sentinel” value)…

rand_core

Core random number generator traits and tools for implementation

potpack

Rust port of the potpack algorithm

trassel

Unique ID integers that scale

random-string

Allows to generate random strings based on a given charset and length

sorty

A plugin to check whether the ‘extern crate’, ‘mod’ and ‘use’ declarations are in their sorted format

dekker

Implementation of Dekker’s algorithm for mutual exclusion

labelgraph

A simple to use graph implementation, allowing random access to nodes via labels

buf-min

Minimal buffer traits

spaces

Set/space primitives for defining machine learning problems

noise_rs

The perlin and simplex noise implementation in 2d and 3d

fast_inv_sqrt

Fast inverse square root algorithm implementation

libbruteforce

This library helps you to brute force hashes (e.g. passwords). It includes a set of pre-configured hashing functions, like md5 or sha256. You can also provide your own hashing function…

fractal

The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes

algorithmica

Rust Algorithms

xorshift

Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators

small-ord-set

A set data-structure represented by a sorted SmallVec

xorshift128plus-rs

A simple implementation of the XorShift128+ pseudorandom number generator in Rust

gitignored

A Rust implementation of the gitignore algorithm

qrs_detector

Realtime ECG QRS detector algorithm

dancing-links

Exact cover solver using dancing links technique

rstat

Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures

search_with_google

A simple library to crawl the google search page

fsm

A simple Finite State Machine library, provide State and Event types, then create a machine with an initial state, give it some transition behaviours and you have your state machine!

rand-array-iid

Create arrays whose elements are independently identically distributed

just-argon2

Bindings to the argon2 C library

zhang_hilbert

Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al

ccl-fxhash

A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc. This is a fork designed for use with ccl. Rights go to the original creator.

rtt

Rapidly-Exploring random trees path planning algorithm

livesplit-title-abbreviations

livesplit-title-abbreviations encapsulates the algorithm that LiveSplit uses to abbreviate game titles

random-access-disk

Continuously read,write to disk, using random offsets and lengths

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

nilsimsa

Implementation of the Nilsimsa locality-sensitive hashing algorithm

rast

A toy implementation of the raft consistency protocol focused on speed

floydrivest

A lightweight crate that brings the Floyd-Rivest implementation of nth_element

bcmp

bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set

haikunator

Generate Heroku-like random names to use in your Rust applications

kahan

Provides types to perform Kahan summation

quicksort

A quicksort implementation for in-place sorting

str-distance

Distance metrics to evaluate distances between strings

algs4

Algorithms, 4ed. MOOC in Coursera. in Rust.

is_prime

Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm

newton_rootfinder

Newton based methods for root finding

primitive_traits

Traits over primitive types. Particularly stuff not covered by num-*.

fxsm

A state machine procedural macro for enums

rational_deduction

Rust implementation of the rational deduction algorithm

fletcher

An implementation of Fletcher’s Checksum algorithm in rust

rand04_compat

Wrappers for compatibility with rand 0.4

dubble

A generic implementation of double-buffering

triangular

A Delauney triangulation library

turing

hash function library

kddbscan

A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)

srand

Random number generators and other randomness functionality with simple apis to use

blake

Implementation of the BLAKE hash function for Rust via FFI

rustmt

A MT19937 PRNG implementation for rust

xxhash-rust

Implementation of xxhash

ai_kit

Collection of classic AI algorithms with convenient interfaces

partition

partition slices in-place by a predicate

dynalock

A lease based distributed locking algorithm with support for DynamoDB

rjq

Redis job queue

extfsm

Extended Finite State Machine with internal event queue and entry/exit transitions

git-release-name

A simple library for turning git shas into release names

spatium

Spatium. Calc distance between sequences.

rand_krull

Krull64 non-cryptographic RNG (random number generator)

rustneat

Implementation of NeuroEvolution of Augmenting Topologies NEAT http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf with a Continuous-Time Recurrent Neural Networks

sfmt

Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)

tilecover

Generate the minimum number of tiles to cover a geometry

dubins_path

Dubins Path pathfinding algorithm