Lib.rs

rand

Random number generators and other randomness functionality

crc

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

rand_jitter

Random number generator based on timing jitter

twox-hash

A Rust implementation of the XXHash algorithm

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.

adler32

Minimal Adler32 implementation for Rust

bytecount

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

fake

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

pathfinding

Pathfinding, flow, and graph algorithms

fst

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

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

oorandom

A tiny, robust PRNG implementation

md5

The package provides the MD5 hash function

rdrand

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

fastcdc

FastCDC (content defined chunking) in pure Rust

highway

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

ratelimit_meter

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

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

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…

fastrand

A simple and fast random number generator

rustc-hash

speed, non-cryptographic hash used in rustc

ncollide2d

2 and 3-dimensional collision detection library in Rust

radiate

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

passwords

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

whatlang

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

vek

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

jubjub

Implementation of the Jubjub elliptic curve group

triple_buffer

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

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

rand_chacha

ChaCha random number generator

vpsearch

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

triple_accel

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

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

rand_regex

Generates random strings and byte strings matching a regex

out

Provides fast min and max functionality for collections

wyhash

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

counting_sort

Counting sort implementation for Iterators

regex-syntax

A regular expression parser

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, …

nanoid

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

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.

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

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…

strength_reduce

Faster integer division and modulus operations

fxhash

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

quantiles

a collection of approximate quantile algorithms

multihash

Implementation of the multihash format

streaming-stats

Experimental crate for computing basic statistics on streams

rust-lapper

A fast and easy interval overlap library

graphplan

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

worley-noise

Worley noise implementation

textnonce

Text based random nonce generator

nonogrid

Efficient nonogram solver

crc32c

Safe implementation for SSE 4.2 CRC32C instructions, with software fallback

k

k is for kinematics

poi

A pragmatic point-free theorem prover assistant

basic_dsp

Digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations…

acacia

A spatial partitioning and tree library

ff

Library for building and interfacing with finite fields

hnsw

Fast approximate nearest neighbors

ipopt

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

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

dissimilar

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

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

bao

a general-purpose cryptographic tree hash

numext-fixed-uint

Fixed-size uint types

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

convert-base

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

rsgenetic

A library providing genetic algorithm execution

treediff

Find the difference between arbitrary data structures

sdset

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

boyer-moore-magiclen

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

probability

The package provides a probability-theory toolbox

cdchunking

Content-defined chunking

noise

Procedural noise generation library

cauchy

Trait for real and complex numbers

mop

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

cdshealpix

Rust implementation of the HEALPix tesselation

hungarian

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

zipf

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

levenberg-marquardt

Levenberg-Marquardt algorithm built on top of nalgebra

rs-graph

A library for graph algorithms and combinatorial optimization

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

xoroshiro128

Fast psuedo-random number generators

pikkr

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

governor

A rate-limiting implementation in Rust

extendhash

Rust Hash Extender

dasp_interpolate

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

tree-index

Index a flat-tree

simsearch

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

safe-mix

Implementation of the Collective Coin Flip algorithm

baseperm

A tool for generating valid permutations of encoded inputs

nanorand

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

flo_curves

Library for manipulating Bezier curves

rust-3d

2D/3D library written in rust

galm

GalM is pattern matching library

random-pick

Pick an element from a slice randomly by given weights

rand_distr

Sampling from random number distributions

test-data-generation

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

adler

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

eddie

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

seqdiff

Diff between two sequences

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

natord

Natural ordering for Rust

timely_sort

Sorting infrastructure for timely dataflow

hybrid-clocks

Hybrid Logical Clocks

zvxryb-broadphase

A broadphase collision detection library

vrf

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

fuzzyhash

Pure Rust fuzzy hash implementation

leaky-bucket

Futures-aware rate limiter implementation

fakeit

Fake data generator library with 130+ functions

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

muldiv

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

xxhrs

Safe XXHash and XXH3 bindings

dusk-plonk

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

glicko2

Implementation of the glicko2 rating system

nqueens-oxigen

N Queens problem resolution using oxigen

smawk

Functions for finding row-minima in a totally monotone matrix

sublime_fuzzy

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

xorf

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

superslice

Extensions for slices

crunch

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

gut

Geometry utilities: storing, manipulating and processing geometries

flat_spatial

Flat spatial partitionning algorithms and data structures

wildmatch

Simple string matching with questionmark and star wildcard operator

astro

Advanced algorithms for astronomy

bitintr

Portable Bit Manipulation Intrinsics

is_sorted

Is an Iterator sorted?

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…

vrp-pragmatic

An extension logic for solving rich VRP

afsort

American Flag sort implementation for faster sorting of Strings

meowhash

Meow hash function

petal-neighbors

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

punkt

An implementation of a Punkt sentence tokenizer

color-thief

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

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

diffus-derive

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

detect-lang

Language detection given paths and extensions

algos

A collection of algorithms in Rust

multistream-batch

Implementations of batching algorithms

median

An implementation of an efficient O(n) median filter

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

zeros

Extensions for hashing crates

hypernonsense

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

startin

A Delaunay triangulator for terrains

gcd

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

suffix_array

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

coord_transforms

A Rust crate use for performing coordinate transformations

diffr-lib

An implementation of Myers diff algorithm

robust

Robust predicates for computational geometry

crc16

A CRC16 implementation

chull

Convex hull approximation

easy_reader

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

hnsw_rs

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

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.

ncollide3d

2 and 3-dimensional collision detection library in Rust

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

slice-group-by

Iterators over groups in a slice

codebreaker

Decrypt & encrypt any cheat code for CodeBreaker PS2

color_space

library for converting between color spaces and comparing colors

sfcgal

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

crc64fast

SIMD accelerated CRC64 calculation

fallible-iterator

Fallible iterator traits

vsprintf

Rust bindings to the libc vsprintf function

random-access-storage

Abstract interface to implement random-access instances

hyperloglogplus

HyperLogLog implementations

external_sort

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

symspell

Spelling correction & Fuzzy search

overlord

Overlord consensus procotol

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

twofloat

Double-double arithmetic functionality

moving_min_max

Tracking minimum or maximum of sliding windows

optimization

Collection of optimization algorithms

atomic-traits

The traits for generic atomic operations

sorts

A collection of sorting algorithms

voracious_radix_sort

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

adqselect

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

levenshtein

Levenshtein algorithm

tailcall

Safe, zero-cost tail recursion

permu-rs

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

gear

Collision avoidance path planning for robotics

urandom

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

pso

Particle Swarm Optimizer

wkb

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

eudex

A blazingly fast phonetic reduction/hashing algorithm

const-random-macro

Provides the procedural macro used by const-random

unbounded-interval-tree

An interval tree working with inclusive/exclusive bounds, as well as unbounded intervals. Provides helpers to fetch overlapping intervals, and difference of intervals.

programinduction

A library for program induction and learning representations

permutation_iterator

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

yada

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

extsort

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

rl-bandit

A simple multi-armed bandit implementation

sobol

A Sobol sequence generator for Rust

accrete

Rust port of Accrete, planetary system accretion simulation algorithm by Stephen H. Dole, published as ‘Formation of Planetary Systems by Aggregation: A Computer Simulation’ with some…

qptrie

A QP-Trie implementation for Rust

vec_mut_scan

Forward scan over a vector with mutation and item removal

dlt

DLT (direct linear transform) algorithm for camera calibration

microfft

Embedded-friendly Fast Fourier Transforms

bufferpool

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

conshash

A library to do consistent hashing in Rust

endicon

Implementations of codicon traits for endianness encodings

filter

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

toolbox

Simple tools for daily use

toposort-scc

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

beehave

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

traversal

Generic and lazy tree traversal algorithms

gurobi

An unofficial Rust API for Gurobi optimizer

geos-sys

GEOS C API bindings

permutohedron

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

rand_mt

Reference Mersenne Twister random number generators

iter-set

Set operations on sorted, deduplicated iterators

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

bidir-map

Bidirectional map implementation for Rust

bibicode

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

lonlat_bng

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

special

The package provides special functions

simple_gaussian

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

names

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

halton

A module for generating Halton sequences

normalize-line-endings

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

addchain

Generate addition chains

loaded_dice

A simple sampler for loaded dices, implementing the alias method

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

linear_solver

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

line-col

Convert string slice indices into line/column numbers

rendezvous_hash

An implementation of Rendezvous hashing algorithm

rustlex_fsa

Library for manipulating (deterministic) finite automata

hashers

A collection of non-cryptographic hashing algorithms for Rust

rdp

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

faiss-sys

Native bindings for Faiss

md6

Implementation of the MD6 hash function for Rust via FFI

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.

lttb

An implementation of the Largest Triangle Three Buckets algorithm

vecshard

Split Vecs in constant time

petal-decomposition

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

howto

instant coding answers via the command line

order-stat

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

opensimplex_noise_rs

OpenSimplex noise algorithm implementation in Rust

zwohash

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

acap

As Close As Possible — nearest neighbor search in Rust

vec-drain-where

alternative Vec::drain_filter impl

sample_planning

Sample Based Planner

midas_rs

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

bravery_router

Radix Tree implementation

tilecover

Generate the minimum number of tiles to cover a geometry

marching-squares

Parallelized marching squares algorithm for constructing closed isolines / contour lines

simplers_optimization

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

IntegerScaling

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

tdigest

T-Digest algorithm in Rust

friedrich

Gaussian Process Regression

rvs-c-api

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

nlopt

Wrapper for the nlopt library

flo_binding

Declarative binding library for Rust

lol-core

A Raft implementation with thin abstraction layer

hotsax

An implementation of the HOTSAX and HOTSAX based discord discovery algorithms

wy

Rust implementation of wyhash algorithms

benchfun

Benchmarking functions to use for optimization algorithms

basic_dsp_matrix

This lib offers the same operations defined in basic_dsp_vector for matrices. It doesn’t offer complete matrix algebra by itself and instead is meant to be used in combination with other matrix libs…

rusty_grammar

A modified CYK algorithm to work for Language

supermemo2

A simple crate that implements the supermemo2 spaced repetition algorithm

graphene

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

extprim

Extra primitive types (u128, i128)

paginator

This crate is used for generating pagination bar

sorted_intersection

Intersection Iterator Over Sorted Iterators

batsat

Extensible SAT solver in Rust

radsort

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

rdx

A collection of traits and algorithms to ease using radix sorts

hilbert

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

hashed-permutation

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

maze_generator

A library of different maze generation algorithms

sortrs

An introspective sort implementation

rootfind

Root-finding algorithms

macro_machine

State machine generator using macros

dia-range

Ranges for all integers

nats-types

Enumerations and types for representing NATS protocol messages

rusted_list

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

symmetric-shadowcasting

Simple implementation of the shadow casting FOV algorithm

count-min-sketch

Count-min-sketch implementation

rust-algorithm

algorithm

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)…

spooks

Spook in Rust

galois_2p8

Basic Arithmetic over all GF(2^8) fields

phreak_engine

Rule matching algorithm focussed on speed

raft

The rust language implementation of Raft algorithm

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

concorde

reconfigurable lattice agreement

darwin-rs

Evolutionary algorithms library written in Rust

gearhash

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

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

rtriangulate

Delaunay triangulation on a set of points

algebraics

algebraic numbers library

qframework

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

alass-core

Automatic Language-Agnostic Subtitle Synchronization (Library)

fsm_gen

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

rs_algo

Common sorting algorithms and other common computer science algorithms

rand_derive2

Generate customizable random types with the rand crate

raftlog

An implementation of distributed replicated log based on the Raft algorithm

pdqsort

Pattern-defeating quicksort

numext-fixed-hash

Fixed-size hash types

subslice

Fast subslice search

sort-it

Various sorting algorithms

human-sort

Human sort (natural sort) implementation

competitive-hpp

Competitive Programming Library for AtCoder with Rust

random_color

Rust crate for generating random attractive colors

primitive_traits

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

quasirandom

Quasirandom number generation

uniset

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

eight-point

Eight-point algorithm for essential matrix estimation

sorted-vec

Create and maintain sorted vectors

bsa3-hash

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

sort

consistent_hashing

ConsistentHashing Alogrithm in Rust

merging-iterator

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

smbus-pec

Minimal portable implementation of SMBus Packet Error Code calculation algorithm

str-distance

Distance metrics to evaluate distances between strings

raft4rs

Rust impl for raft

indented-blocks

parser for indented blocks

rand04_compat

Wrappers for compatibility with rand 0.4

dekker

Implementation of Dekker’s algorithm for mutual exclusion

lis

Longest increasing subsequence algorithm

qrs_detector

Realtime ECG QRS detector 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.

fractal

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

aliasmethod

Implementation of Walker’s Alias method

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…

search_with_google

A simple library to crawl the google search page

sub-strs

For finding sub strings

bls-signatures-rs

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

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

accurate

(more or less) accurate floating point algorithms

bip_dht

Implementation of the bittorrent mainline DHT

count_sort

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

rand_core

Core random number generator traits and tools for implementation

xbar

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

dedup_signature

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

rs-snowflake

The snowflake algorithm rust version

rast

A toy implementation of the raft consistency protocol focused on speed

kangarootwelve_xkcp

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

grapl-graph-descriptions

A library for interacting with Grapl graphs

indexed_bitvec

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

potpack

Rust port of the potpack algorithm

sbitty

library defining bitwise operations on standard integers type

dummy

Macros implementation of #[derive(Dummy)]

java_random

The java LCG and random module implementation in rust

ffts

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

spaces

Set/space primitives for defining machine learning problems

matfile-ndarray

Utility library to convert between matfile and ndarray array formats

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.

fuss

Small, lightweight simplex noise generator for Rust

fletcher

An implementation of Fletcher’s Checksum algorithm in rust

sprs-ldl

Sparse cholesky factorization

xorshift128plus-rs

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

weighted_levenshtein

Generic implementation of Levenshtein distance allowing arbitrary weighting of operations

kahan

Provides types to perform Kahan summation

delaunay2d

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

triangular

A Delauney triangulation library

vrp-scientific

An extension logic for solving scientific VRP

random-access-disk

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

highwayhash

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

english-numbers

Convert integers to written English number format

dists

2d distribution generator

rustmt

A MT19937 PRNG implementation for rust

spatium

Spatium. Calc distance between sequences.

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

bloom-filters

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

srand

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

sorty

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

labelgraph

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

noise_rs

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

permutation

Small utility for creating, manipulating, and applying permutations

zhang_hilbert

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

tinysort

The lowest memory footprint sorting algorithm

fast_inv_sqrt

Fast inverse square root algorithm implementation

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!

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

rle-bitset

A no-std, no-alloc trait for querying and manipulating bits in a [usize] and iterating their run lengths

just-argon2

Bindings to the argon2 C library

dubins_path

Dubins Path pathfinding algorithm

hamming

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

crc24

CRC-24 implementation (IETF RFC2440-compatible)

gitignored

A Rust implementation of the gitignore algorithm

grp_api

API for crate grp 0.1.0

rtt

Rapidly-Exploring random trees path planning algorithm

weighted-rs

A libray for weighted balancing algorithm

livesplit-title-abbreviations

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

geo-clipper

Boolean operations on polygons

xorshift

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

cdivsufsort

Rust bindings for Yuta Mori’s divsufsort

fastblur

Linear-time gaussian blur

crcxx

universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms

haikunator

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

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

quicksort

A quicksort implementation for in-place sorting

algs4

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

newton_rootfinder

Newton based methods for root finding

is_prime

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

mix-distribution

Mixture distributions

fxsm

A state machine procedural macro for enums

turing

hash function library

pack

Solver for packing puzzle

dubble

A generic implementation of double-buffering

primecount

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

sorting

The world’s best, finest and inefficient sorting algorithms

wookong-solo

Wookong Solo driver crate

ai_kit

Collection of classic AI algorithms with convenient interfaces

rjq

Redis job queue

partition

partition slices in-place by a predicate

dynalock

A lease based distributed locking algorithm with support for DynamoDB

phpass

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

yz-nomstr

A simple escaped string literal parser using nom

git-release-name

A simple library for turning git shas into release names

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

kendalls

Kendall’s tau rank correlation

sfmt

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

xxh

XXHash algorithm implementation for Rust

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)…

modulo

Simple modulo operation

bolt-client-macros

Procedural macros for bolt-client

needle

Fast search functions for finding things in Strings, Arrays and iterators

arborist

A surgical tool for interacting with binary trees

rustomaton

A small Rust library for automaton (DFA, NFA, Regex) manipulation

wu-diff

Compute differences between two slices using wu(the O(NP)) algorithm

libblockchain

A Blockchain implementation

every-range

Iterator for interleaving included and excluded ranges

gen-combinations

A general combination generator

basic-hll

The basic HyperLogLog algorithm

topological-sort

Performs topological sorting

audiograph

An audio graph optimised for performance and limiting runtime allocations

octree

Octree algorithm for nearest neighbor search in 3D space

clusterphobia

Algorithms and data structures for unassisted clustering that employ the Hilbert Curve

mecs

An ecs library with a focus on iteration performance

sha

Rust Secure Hash Algorithm (SHA) Library

noisy

A procedural noise generation library written for Rust

smoothed_z_score

Smoothed z-score algo (very robust thresholding algorithm)

cplex-sys

Low level bindings to the Cplex C-API

mersenne_twister

Mersenne Twister pseudorandom number generator

t1ha

An implementation of the T1AH (Fast Positive Hash) hash function

reingold-tilford

A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)

ingrid

Dynamic two-dimensional arrays with algorithms

streaming_algorithms

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

oqs

Bindings for Open Quantum Safe, a library for quantum-resistant cryptographic algorithms

munkres

Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)

honestintervals

Comprehensive, correctly rounding interval arithmetic library

fibonacci_series

Fibonacci Sequence. The Fibonacci Sequence is the series of numbers: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, … The next number is found by adding up the two numbers before it.

lz_fnv

Fowler-Noll-Vo hash functions for various integer types

bisection

Rust implementation of the Python bisect module

extfsm

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

graph_solver

An undirected graph constraint solver for node and edge colors