-
rand
Random number generators and other randomness functionality
-
crc
Rust implementation of CRC(16, 32, 64) with support of various standards
-
rustfft
High-performance FFT library written in pure Rust
-
twox-hash
A Rust implementation of the XXHash and XXH3 algorithms
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
rand_core
Core random number generator traits and tools for implementation
-
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.
-
pathfinding
Pathfinding, flow, and graph algorithms
-
fastrand
A simple and fast random number generator
-
ff
Library for building and interfacing with finite fields
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
highway
Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
passwords
This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them
-
bitpacking
Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.
-
timely
A low-latency data-parallel dataflow system in Rust
-
alphanumeric-sort
This crate can help you sort order for files and folders whose names contain numerals
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
dusk-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
dissimilar
Diff library with semantic cleanup, based on Google’s diff-match-patch
-
oorandom
A tiny, robust PRNG implementation
-
roots
Library of well known algorithms for numerical root finding
-
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
-
rustc-hash
speed, non-cryptographic hash used in rustc
-
rdrand
An implementation of random number generator based on rdrand and rdseed instructions
-
triple_buffer
An implementation of triple buffering, useful for sharing frequently updated data between threads
-
whatlang
Natural language detection library. Identifies language of a given text.
-
crypto-bigint
Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…
-
xorf
Library implementing xor filters - faster and smaller than bloom and cuckoo filters
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
rust-lapper
A fast and easy interval overlap library
-
slice-group-by
Iterators over groups in a slice
-
test-data-generation
A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data
-
simdutf8
SIMD-accelerated UTF-8 validation
-
k
k is for kinematics
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
jubjub
Implementation of the Jubjub elliptic curve group
-
rand_chacha
ChaCha random number generator
-
rand_distr
Sampling from random number distributions
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
differential-dataflow
An incremental data-parallel dataflow platform
-
counting_sort
Counting sort implementation for Iterators
-
convert-base
convert the radix (base) of digits stored in a vector
-
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
-
screwsat
A simple condlict driven clause learning sat solver
-
gcd
Calculate the greatest common divisor
-
numext-fixed-uint
Fixed-size uint types
-
lfest
A leveraged perpetual futures exchange for simulated trading is a high performance backtesting exchange
-
quantiles
a collection of approximate quantile algorithms
-
nlopt
Wrapper for the nlopt library
-
rand_regex
Generates random strings and byte strings matching a regex
-
rustdct
Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust
-
yada
Yada is a yet another double-array trie library aiming for fast search and compact data representation
-
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
-
adler32
Minimal Adler32 implementation for Rust
-
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…
-
integer-sqrt
An implementation of integer square root algorithm for primitive rust types
-
rand_mt
Reference Mersenne Twister random number generators
-
transvoxel
Implementation of Eric Lengyel’s Transvoxel Algorithm
-
broccoli
broadphase collision detection algorithms
-
glass_pumpkin
A cryptographically secure prime number generator based on rust’s own num-bigint and num-integer
-
chalk-solve
Combines the chalk-engine with chalk-ir
-
delaunator
A very fast 2D Delaunay triangulation library
-
boostvoronoi
Boost voronoi ported to 100% rust
-
wildmatch
Simple string matching with questionmark and star wildcard operator
-
vectora
A vector computation library
-
ids_service
Library that allows to generate unique Ids
-
hilbert
Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm
-
probability
The package provides a probability-theory toolbox
-
cap-rand
Capability-based random number generators
-
md5
The package provides the MD5 hash function
-
numext-constructor
Fixed-size uint and hash constructor
-
svg2polylines
Convert SVG data to a list of polylines (aka polygonal chains or polygonal paths)
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
regex-syntax
A regular expression parser
-
graph
A library of high-performant graph algorithms
-
linregress
ordinary least squared linear regression with some basic statistics
-
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters’s Pattern Defeating Quickselect
-
pso-rs
An easy-to-use, simple Particle Swarm Optimization implementation in Rust
-
fake
An easy to use library for generating fake data like name, number, address, lorem, dates, etc
-
permutation
Small utility for creating, manipulating, and applying permutations
-
robust
Robust adaptive floating-point predicates for computational geometry
-
naive_opt
The optimized naive string-search algorithm
-
xxhash-rust
Implementation of xxhash
-
hexagonal_pathfinding_astar
A-Star pathfinding algorithm tailored for traversing a bespoke collection of weighted hexagons
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
adler
A simple clean-room implementation of the Adler-32 checksum
-
out
Provides fast min and max functionality for collections
-
chalk-engine
Core trait engine from Chalk project
-
earcutr
port of MapBox’s earcut triangulation code to Rust language
-
iset
Map and set with interval keys (x..y)
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
hex2d
Helper library for working with 2d hex-grid maps
-
fuzzyhash
Pure Rust fuzzy hash implementation
-
rdst
A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes
-
autodiff
An automatic differentiation library
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
multistream-batch
Implementations of batching algorithms
-
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…
-
extendhash
Rust Hash Extender
-
radiate
Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems
-
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
memx
memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
tinymt
Rust implementation of TinyMT 64/32 - a lightweight variant of Mersenne Twister PRNG
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
treediff
Find the difference between arbitrary data structures
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
nonogrid
Efficient nonogram solver
-
iter-read
A Read implementation for iterators over u8 and related types
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
vrf
Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves
-
maglev
Maglev - Google’s consistent hashing algorithm
-
tailcall
Safe, zero-cost tail recursion
-
avalog
An experimental implementation of Avatar Logic with a Prolog-like syntax
-
pubgrub
PubGrub version solving algorithm
-
nohash-hasher
An implementation of
std::hash::Hasherwhich does not hash at all -
probminhash
Minhash algorithms for weighted Jaccard index
-
fastcdc
FastCDC (content defined chunking) in pure Rust
-
seal
Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
cdshealpix
Rust implementation of the HEALPix tesselation
-
random-pick
Pick an element from a slice randomly by given weights
-
strength_reduce
Faster integer division and modulus operations
-
id_tree_layout
A library to visualize trees from the ‘id_tree’ crate
-
rust-stemmers
A rust implementation of some popular snowball stemming algorithms
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
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
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
magpie
Reasonably efficient Othello library built with bitboards
-
hashicorp-lru
The project is moved to caches, please see crate caches
-
hierarchical_pathfinding
Quickly approximate Paths on a Grid
-
binary-merge
Minimum comparison merge of two sorted sequences with random access
-
iter-set
Set operations on sorted, deduplicated iterators
-
random_color
Rust crate for generating random attractive colors
-
flo_binding
Declarative binding library for Rust
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
tokenizations
Tokenizations alignments library
-
ring_buffer
RingBuffer is a queue with added random access
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
actionable
An enum-based async framework for building permission-driven APIs
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
subslice
Fast subslice search
-
faiss
High-level bindings for Faiss, the vector similarity search engine
-
rs-graph
A library for graph algorithms and combinatorial optimization
-
historian
a high performance zero-config histogram implementation
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
geo-clipper
Boolean operations on polygons
-
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…
-
worley-noise
Worley noise implementation
-
metrohash
Rust implementation of MetroHash, a high quality, high performance hash algorithm
-
rust-spice
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
multihash
Implementation of the multihash format
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
simsearch
A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)
-
median
An implementation of an efficient O(n) median filter
-
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)…
-
osqp
The OSQP (Operator Splitting Quadratic Program) solver
-
luhn3
A Luhn validation library
-
fnv
Fowler–Noll–Vo hash function
-
romu
A pseudo random number generator using the Romu algorithm
-
ahrs
A Rust port of Madgwick’s AHRS algorithm
-
hora
Hora Search Everywhere
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
genx
An easy to use and modular genetic algorithms library
-
bsa3-hash
The hash function used in BSA files for The Elder Scrolls III: Morrowind
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
sets
Sets implemented as generic vectors. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
weighted-rs
A libray for weighted balancing algorithm
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
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
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
fallible-iterator
Fallible iterator traits
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
poi
A pragmatic point-free theorem prover assistant
-
simplers_optimization
A Rust implementation of the Simple(x) black-box optimization algorithm
-
blake
Implementation of the BLAKE hash function for Rust via FFI
-
smbus-pec
Minimal portable implementation of SMBus Packet Error Code calculation algorithm
-
relp-num
Number types for the relp crate
-
quasirandom
Quasirandom number generation
-
metaheuristics-nature
A collection of nature-inspired meta-heuristic algorithms
-
coord2d
rust lib for coordinate in 2d system
-
boyer-moore-magiclen
Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust
-
muldiv
Provides a trait for numeric types to perform combined multiplication and division with overflow protection
-
simple-simplex
Generates 2d simplex noise values and applies Fractal Brownian Motion
-
uaparser
A Rust implementation of the UA Parser
-
overlord
Overlord consensus procotol
-
levenberg-marquardt
Levenberg-Marquardt algorithm built on top of nalgebra
-
noise
Procedural noise generation library
-
topo_sort
A ‘cycle-safe’ topological sort for a set of nodes with dependencies
-
board-game
A board game abstraction and generic utilities around it
-
simd-adler32
A SIMD-accelerated Adler-32 rolling hash algorithm implementation
-
svdlibrs
A Rust port of LAS2 from SVDLIBC
-
levenshtein-diff
Generic implementation of Levenshtein’s algorithm that also allows you to generate the edits required to convert a source sequence to a target, and apply them to the source sequence to regenerate the target
-
tdigest
T-Digest algorithm in Rust
-
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.
-
incrementalmerkletree
Implementation of an Incremental Merkle Tree
-
elm-solve-deps
A dependency solver for the elm ecosystem
-
poisson-diskus
Poisson disk distribution sampling
-
wasmium-random
Generate random numeric, alphabet, alphanumeric, BIP39 and EFF random bytes
-
ru_annoy
A rust implementation of annoy(https://github.com/spotify/annoy) (Index serving only). Providing C api as well
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
rexl
Common Library for Rust
-
fletcher
A dependency free implementation of the Fletcher’s checksum algorithm
-
simplerand
Simple and fast random number generator
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
hyperid
Superfast id generator
-
fastvlq
A fast variant of Variable-Length Quantity with a focus on speed and no_std support
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
intersect2d
Line segment intersection detection
-
reed-solomon-16
Reed-Solomon GF(2^16) erasure coding with O(n log n) complexity
-
sobol
A Sobol sequence generator for Rust
-
minimax-alpha-beta
An implementation of Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
polylabel
A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions
-
rake
Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm
-
bit-iter
Iterate forward or backwards over the positions of set bits in a word
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
gut
Geometry utilities: storing, manipulating and processing geometries
-
rrt
Path finding using dual-RRT connect
-
fleetfs_raft
The rust language implementation of Raft algorithm
-
sample-consensus
Abstractions for sample consensus algorithms such as RANSAC
-
zeros
Keccak implementation
-
hyperloglogplus
HyperLogLog implementations
-
cdchunking
Content-defined chunking
-
ritehash
A tiny, fast, zero-dep and no_std fxhash fork. More up to date.
-
graphplan
Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
acap
As Close As Possible — nearest neighbor search in Rust
-
astro
Advanced algorithms for astronomy
-
block-aligner
SIMD-accelerated library for computing global and X-drop affine gap sequence alignments using an adaptive block-based algorithm
-
fuzzy_rocks
A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
ms_toollib
Algorithms for Minesweeper
-
weighted_rand
A weighted random sampling crate using Walker’s Alias Method
-
is_sorted
Is an Iterator sorted?
-
qsv-stats
Experimental crate for computing basic statistics on streams
-
trade_aggregation
Aggregate raw trades into candles using different methods
-
raft
The rust language implementation of Raft algorithm
-
bytestream
Provides a convenient way of writing binary data to a buffer
-
fi-night
Statically typed Finite State Machine and Pushdown Automaton implementation
-
extsort
External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
lv03
Conversion between the Swiss coordinate system (LV03/CH1903 or LV95/CH1903+) and WGS84 coordinates
-
afsort
American Flag sort implementation for faster sorting of Strings
-
color_space
library for converting between color spaces and comparing colors
-
pqc_kyber
A rust implementation of the post-quantum Kyber KEM algorithm
-
sm
💋 SM – a static State Machine library
-
special
The package provides special functions
-
transpose
Utility for transposing multi-dimensional data
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
markov_rs
A simple and fast Markov chain generator in Rust
-
pagino
Handle pagination’s logic
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
sub-strs
For finding sub strings
-
linked_hash_set
HashSet with insertion ordering
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
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…
-
contest-algorithms
Common algorithms and data structures for programming contests
-
algorithmica
Rust Algorithms
-
lev_distance
A copy of Levenshtein distance implementation from Rust Compiler
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
punkt
An implementation of a Punkt sentence tokenizer
-
alea
A crate for randomness
-
atomic-traits
The traits for generic atomic operations
-
reed-solomon-novelpoly
An implementation of a reed solomon code / encoder / decoder with complexity
O(n lg(n)) -
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
highs
Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.
-
staticstep
Provides truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
chalk-recursive
Recursive solver for the Chalk project
-
caches
This is a Rust implementation for popular caches (support no_std)
-
nuid
A highly performant unique identifier generator
-
twofloat
Double-double arithmetic functionality
-
convolve2d
Easy and extensible pure rust image convolutions
-
graph_builder
A building block for high-performant graph algorithms
-
newton_rootfinder
Newton based methods for root finding
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
scru128
SCRU128: Sortable, Clock and Random number-based Unique identifier
-
rand_pcg
Selected PCG random number generators
-
array-bin-ops
Efficient array binary operations
-
quadtree-f32
Simple, dependency-free ID-based quadtree
-
skelly
Skeleton animation and IK
-
rsgenetic
A library providing genetic algorithm execution
-
rolling-dual-crc
Rolling CRC with 32-bit CRC32C and 64-bit CRC64/XZ
-
sudoku-solver
Simple backtracking algorithm for solving sudoku
-
rendezvous_hash
An implementation of Rendezvous hashing algorithm
-
secwords
secure and safe password container
-
forceatlas2
fast force-directed generic n-dimension graph layout
-
fullcodec-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
rgeometry
High-Level Computational Geometry
-
squirrel3-rs
Simple and reliable random number generator
-
cyclic-poly-23
A rolling, decomposable hash algorithm
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
fp-growth
An implementation of the FP-Growth algorithm in pure Rust
-
gfxmath-vec3
A simple 3D math library
-
libhumancode
A
no_stdcompatible library that provides a function to enode binary data up to 150 bits in a human friendly format -
idgenerator
A powerful unique id generator. Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity…
-
bloom_filter_plush
rust_bloom_filter
-
raft-proto
Protocol definitions for the rust language implementation of the Raft algorithm
-
pasture-algorithms
Point cloud algorithms for pasture
-
geometry-predicates
A Rust port of robust geometric predicates
-
powierza-coefficient
Powierża coefficient is a statistic for gauging if one string is an abbreviation of another
-
wyhash
Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator
-
cauchy
Trait for real and complex numbers
-
human-sort
Human sort (natural sort) implementation
-
adam_fov_rs
A rust implementation of Adam Milazzo’s FOV algorithm http://www.adammil.net/blog/v125_Roguelike_Vision_Algorithms.html#mine
-
annembed
a Rust implemntation of a dimension reduction à la Umap
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
eddie
Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler
-
vrp-pragmatic
An extension logic for solving rich VRP
-
hotdrink-rs
An implementation of HotDrink in Rust
-
varint-rs
A small, zero dependency varint implementation in Rust
-
sbitty
library defining bitwise operations on standard integers type
-
circbuf
A growable circular buffer for working with bytes
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
partition
partition slices in-place by a predicate
-
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
qframework
A experimental micor framework for clear design, based on queue model
-
movavg
Generic Moving Average calculation
-
java_random
The java LCG and random module implementation in rust
-
bromberg_sl2
Cayley hashing as in ‘Navigating in the Cayley Graph of SL₂(𝔽ₚ)’
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
programinduction
A library for program induction and learning representations
-
pikkr
JSON Parser which picks up values directly without performing tokenization in Rust
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
md6
Implementation of the MD6 hash function for Rust via FFI
-
edge-detection
The canny edge detection algorithm
-
bit_combi_iter
An iterator to iterate all bit combinations less than given unsigned integer
-
gcd-bitwise
The binary Euclidean algorithm for computing gcd
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
toposort-scc
An implementation of Kahn’s algorithm for topological sorting and Kosaraju’s algorithm for strongly connected components
-
fakeit
Fake data generator library with 130+ functions
-
library_of_babel
Implementation of Library of Babel in Rust
-
faiss-sys
Native bindings for Faiss
-
numext-fixed-hash
Fixed-size hash types
-
hashed-permutation
A fast, instant-access way to permute a range of numbers
-
diffr-lib
An implementation of Myers diff algorithm
-
consistent_hash_ring
A flexible and efficient consistent hash ring
-
bindet
Fast file type detection
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
sparse_linear_assignment
Solvers for sparse linear assignment problem based on the auction algorithm
-
search-sort
Implementation of few searching and sorting algorithms
-
count-min-sketch
Count-min-sketch implementation
-
relp
Rust Exact Linear Programming
-
sparse-interp
Basic univariate polynomial arithmetic and sparse polynomial interpolation
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
color-thief
Grabs the dominant color or a representative color palette from an image
-
accurate
(more or less) accurate floating point algorithms
-
sfmt
Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)
-
backtrack
Solve hard constraints easily
-
rounded-div
Get rounded result of an integer division
-
beehave
A simple library for defining and evaluating a hierarchical state machine (behaviour tree)
-
morton-encoding
A crate for encoding and decoding Morton (“Z-order”) keys
-
mersenne_twister
Mersenne Twister pseudorandom number generator
-
hash_avatar
rust生成随机头像的库
-
dasp_interpolate
An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc
-
navig18xx
Construct 18xx tiles and maps, and find optimal route combinations
-
zw-fast-quantile
Zhang-Wang fast quantile algorithm in Rust
-
clock-zones
A library for handling clock zones
-
omnitigs
Omnitig-related algorithms
-
linfa-datasets
Collection of small datasets for Linfa
-
memx-cdy
The fast memory functions like a libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
vsprintf
Rust bindings to the libc vsprintf function
-
ncollide3d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
hnsw
Fast approximate nearest neighbors
-
optimum
Future Framework to solve optimization problems
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
bigbit
Implements the BigBit format, allowing for compact storage of arbitrarily large numbers
-
hybrid-clocks
Hybrid Logical Clocks
-
vec-drain-where
alternative
Vec::drain_filterimpl -
elements-frequency
Finds the frequency of elements in a list
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
line-col
Convert string slice indices into line/column numbers
-
mushin
Compile-time creation of neural networks
-
soft-edge
efficient bithackery for making 3D collision meshes out of grids and stacked tile maps
-
poker
A crate for speedy poker hand evaluation
-
macro_machine
State machine generator using macros
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
probables
This crate is the replicate of BTree. It contains some functions that are nesscary for BTree. Currently this version support wrapper method called traits, implemention, structs and module testing…
-
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
extra_waiters
Wait for notifications without a Mutex
-
rootfind
Root-finding algorithms
-
rust-3d
2D/3D library written in rust
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
glicko2
Implementation of the glicko2 rating system
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
building_blocks_search
Search algorithms for voxel data
-
stringslice
A collection of methods to slice strings based on character indices rather than bytes
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
competitive-programming-rs
Competitive Programming Library in Rust
-
external_sort
Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
dusk-hades
Implementation of Hades252 permutation algorithm over the Bls12-381 Scalar field
-
enso-prelude
An augmented standard library in the vein of Haskell’s prelude
-
clf
flush the cpu cache line by __builtin_clear_cache()
-
lfu
An LFU cache implementation
-
tiny_tco
A tiny dirt simple no_std tail call optimization library
-
vecshard
Split Vecs in constant time
-
toolbox
Simple tools for daily use
-
chull
Convex hull approximation
-
mincost
A collection of modern heuristic optimization toolkit
-
crczoo
CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms
-
arc-interner
An interner that deallocates unused values
-
rustlex_fsa
Library for manipulating (deterministic) finite automata
-
lol-core
A Raft implementation in Rust language
-
redux-rs
A Rust implementation of Redux
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
porco
Composable probability distributions
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
nqueens-oxigen
N Queens problem resolution using oxigen
-
dryip
Short 🩸 Rust 🦀 code snippets for inspiration
-
sortedvec
a sorted vector that enables quick lookups
-
pretree
Pretree is a package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
rlp-iter
An iterator following a space-filling pattern over a given range
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
libdivsufsort-rs
A rust wrapper of libdivsufsort
-
typeables
Typeables: Rust crate of type aliases. By SixArm.com.
-
seqdiff
Diff between two sequences
-
safe-mix
Implementation of the Collective Coin Flip algorithm
-
rta-for-fps-lib
An Implementation of the paper ‘Response Time Analysis for Fixed Priority Servers’ by Hamann et al
-
verhoeff
The Verhoeff algorithm, for number checksums
-
kendalls
Kendall’s tau rank correlation
-
iter_columns
Iterate over columns easily
-
wkb
Convert geo-types from georust to/from Well Known Binary
-
big_num
A big number implement in rust
-
gabble
Library crate for generating random pseudo-words
-
blurhash-ng
A pure Rust implementation of blurhash
-
ext-sort
rust external sort algorithm implementation
-
rtriangulate
Delaunay triangulation on a set of points
-
ssb-multiformats
Key, feed id, and message hash types used by Secure Scuttlebutt
-
pikkr-annika
JSON Parser which picks up values directly without performing tokenization in Rust. Reuploaded by Annika due to her compile problems.
-
hashring
A minimal implementation of consistent hashing
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
pcg_rand
An implementation of the PCG family of random number generators in pure Rust
-
m4ri-sys
Bindings to m4ri
-
search_trees
Utilities for binary search tree, red-black tree, and AVL tree
-
detect-lang
Language detection given paths and extensions
-
voprf
An implementation of a verifiable oblivious pseudorandom function (VOPRF)
-
buf-min
Minimal utf-8 safe buffer traits
-
layered-bitset
Bit set implementation using layered structure
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
peak_finder
An algorithm for identifying peaks from line data, such as from accelerometer or spectral data
-
halton
A module for generating Halton sequences
-
hungarian
A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
froggy-rand
Random number generation without state for games
-
signrel
Trait expressing relationship between integers of different signedness
-
seadawg
SeaDawg is a library that implements the online algorithm for Direct Acyclic Word Graph (DAWG) and Compact Direct Acyclic Word Graph (CDAWG)
-
wfc-rs
Binding to the krychu/wfc C library
-
iterslide
A “sliding window” iterator
-
murmur3
A rust implementation of Murmur3 hash
-
phpass
PHPass, the WordPress password hasher, re-implemented in rust
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
meowhash
Meow hash function
-
four-bar
Four🍀bar library provides simulation and synthesis function for four-bar linkage mechanism
-
cumath
Cuda-based matrix/vector computations
-
hash-roll
Rolling hashes & Content Defined Chunking (cdc)
-
darwin-rs
Evolutionary algorithms library written in Rust
-
anchorhash
A consistent hashing algorithm that outperforms state-of-the-art algorithms
-
elipdotter
Embeddable full text search engine
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
time_wheel
An implementation of timer uses time-wheel algorithm
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
yada_mod
Yada is a yet another double-array trie library aiming for fast search and compact data representation. This fork added a tokenization function
-
modulo
Simple modulo operation
-
enso-optics
An implementation of functional optics
-
ordslice
Extensions for ordered slices
-
distance
A collection of approximate string matching algorithms
-
munkres
Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)
-
uncertain
Fast and correct computations with uncertain values
-
sark_pathfinding
A simple implementation of the astar pathfinding algorthim from red blob games https://www.redblobgames.com/pathfinding/a-star/implementation.html
-
sparse_graph
Sparse graph algorithms
-
favannat
Algorithms to evaluate the function encoded in ANN-like structures
-
easey
Easing functions for interpolation between 0.0 and 1.0
-
algos
A collection of algorithms in Rust
-
hoeffding_integer_d
Hoeffding’s Dependence coefficient presented as an integer between minimum and maximum integer values of the statistic. Hoeffding’s D is like Pearsons correlation R, but accepts a wide range of nonlinear situations…
-
sungod
0-Dependency random numbers to brighten your day
-
bishop
Library for visualizing keys and hashes using OpenSSH’s Drunken Bishop algorithm
-
crfs
Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)
-
english-numbers
Convert integers to written English number format
-
visionmagic
Collection of vision & graphics algorithms
-
microstate
Finite state machine, inspired by micromachine
-
rab-core
Rusty Armor Builds - Algorithms, Armors and skill management
-
winapi-hash
Windows API hashing implementation
-
rectcut-rs
Rust implementation of the rectcut concept from https://halt.software/dead-simple-layouts/
-
parallel-factorial
Simple, fast, parallel factorial calculator
-
fast_poisson
An implementation of Bridson’s algorithm for fast Poisson disk sampling
-
rusty_planner
Artificial intelligence planning & reasoning library for Rust
-
fft2d
Fourier transform for 2D data such as images
-
delaunay2d
A library to compute Delaunay triangulations and Voronoi diagrams in 2D space
-
dedup_signature
This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
fullcodec_rand_xorshift
Xorshift random number generator
-
closest-sum-pair
Finds a pair in a list that has the closest sum to a given number
-
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.
-
lp-solvers
.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK
-
geos-sys
GEOS C API bindings
-
just-argon2
Bindings to the argon2 C library
-
endicon
Implementations of codicon traits for endianness encodings
-
deranged
Ranged integers
-
fang_oost
A library implementing Fang and Oosterlee’s algorithm for inverting characteristic functions
-
random-branch
Provides a macro to select a random branch like match
-
den
A general delta encoded network difference algorithm
-
libpermute
A
no_stdcompatible library that provides a function to permute the items of a slice -
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
numext-fixed-uint-hack
A internal crate used by numext-fixed-uint
-
xorshift128plus-rs
A simple implementation of the XorShift128+ pseudorandom number generator in Rust
-
xorshift
Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
conshash
A library to do consistent hashing in Rust
-
cueball-static-resolver
This is an implementation of the cueball Resolver trait that provides a static list of backends for use by the connection pool
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
symspell
Spelling correction & Fuzzy search
-
iobuf
A contiguous region of bytes, useful for I/O operations
-
reciprocal
Baseline implementation of integer division by constants
-
zvxryb-broadphase
A broadphase collision detection library
-
fuzzy_dbscan
An implementation of the FuzzyDBSCAN algorithm
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
gfxmath-vec2
A simple 2D math library
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
probably
A library with various approximate computing algorithms
-
adler32fast
Fast, SIMD-accelerated Adler-32 checksum computation
-
kahan
Provides types to perform Kahan summation
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
summed-area-table
Implementation of a summed area table
-
brace-expand
Rust crate which performs brace expansion of strings, as in shells like Bash etc
-
srand
Random number generators and other randomness functionality with simple apis to use
-
crcany
Compute any CRC
-
labelgraph
A simple to use graph implementation, allowing random access to nodes via labels
-
mycrc
Create your own cyclic redundancy check (CRC)
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
sort-rs
A crate exposing sorting algorithms
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
lambert
lamber-rust is a crate helping to convert Lambert coordinates to WGS84
-
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
funtools
a collection of fun iterators to tinker with
-
extprim
Extra primitive types (u128, i128)
-
fast_inv_sqrt
Fast inverse square root algorithm implementation
-
xxhrs
Safe XXHash and XXH3 bindings
-
jandom
Port of Java’s Random
-
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
thirtyseconds
Short Rust 🦀 code snippets for inspiration
-
html2pango
Library to convert html to pango
-
travelling_salesman
Travelling Salesman Problem Solvers
-
extrema
C++’s minmax_element implementation in rust
-
batsat
Extensible SAT solver in Rust
-
mini-kanren
miniKANREN in Rust
-
selfsimilar
A fast generator of discrete self similar random numbers
-
algebraics
algebraic numbers library
-
gurobi
An unofficial Rust API for Gurobi optimizer
-
honestintervals
Comprehensive, correctly rounding interval arithmetic library
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
gear
Collision avoidance path planning for robotics
-
fera
An aggregation of algorithms, data structures and supporting crates
-
mx3
Implementation of the mx3 algorithm providing a bit mixer, pseudo-random number generator, and hash function
-
patmatch
A configurable pattern matching / wildcard matching library
-
onlinecode
An implementation of “Online Codes”, a type of Fountain Code
-
dia-ip-range
Ranges for IP v4
-
mecs
An ecs library with a focus on iteration performance
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
g2poly
Primitive implementation of polynomials over the field GF(2)
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
lttb
An implementation of the Largest Triangle Three Buckets algorithm
-
lis
Longest increasing subsequence algorithm
-
noisy
A procedural noise generation library written for Rust
-
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
dns-cookie
Algorithms for Domain Name System (DNS) Cookies construction
-
rdx
A collection of traits and algorithms to ease using radix sorts
-
permutation_iterator
A Rust library for iterating over random permutations using O(1) (i.e. constant) space.
-
utm
Convert latitudes and longitudes to UTM coordinates
-
chalk-ir
Chalk’s internal representation of types, goals, and clauses
-
benchfun
Benchmarking functions to use for optimization algorithms
-
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
-
actionable-macros
Macros for
actionable -
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
search-autocompletion
A Rust implementation of Search Auto Completion
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
sprs-ldl
Sparse cholesky factorization
-
basic-hll
The basic HyperLogLog algorithm
-
IntegerScaling
Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction
-
needle
Fast search functions for finding things in Strings, Arrays and iterators
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
lfa
Native rust implementations of linear function approximators
-
buldak
It is a library that provides various sorting functions
-
redc
Unsigned integer types which are constrained within a modular field using montgomery multiplication, never overflowing or exceeding the modulo
-
tree-edit-distance
Find the lowest cost sequence of edits between two trees
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
supermemo2
A simple crate that implements the supermemo2 spaced repetition algorithm
-
sort-it
Various sorting algorithms
-
vrp-scientific
An extension logic for solving scientific VRP
-
persist-es
A backing logic for an RDBMS implementation of an event store for cqrs-es
-
eytzinger-map
array/vec based map using eytzinger search algorithm
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
zero-copy-pads
Padding/aligning values without heap allocation
-
num-cmp
Comparison between differently typed numbers
-
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)…
-
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.
-
stalin-binary-search
alike binary search but any checking element which is not target one is eliminated
-
asearch
Approximate pattern matching on Rust
-
pdqsort
Pattern-defeating quicksort
-
spatium
Spatium. Calc distance between sequences.
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
multistochgrad
Stochastic Gradient, Multithreaded
-
fuss
Small, lightweight simplex noise generator for Rust
-
lax
LAPACK wrapper without ndarray
-
traversal
Generic and lazy tree traversal algorithms
-
optimization
Collection of optimization algorithms
-
sorted-insert
This crate provides traits to insert elements to a sorted collection and keep the order
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
blurhash
A pure Rust implementation of blurhash
-
czt
The package provides an algorithm to compute the chirp Z-transform
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
simple-tiled-wfc
A simple library which lets a user to use a tiled Wave Function Collapse algorithm implementation
-
trajectory
Trajectory interpolation
-
all_shortest_path
A simple Floyd-Warshall algorithm implementation
-
rast
A toy implementation of the raft consistency protocol focused on speed
-
cdivsufsort
Rust bindings for Yuta Mori’s divsufsort
-
strider
ringbuffer operations on multiple values at once with an efficient implementation. useful for moving a window with variable step through a possibly infinite stream of values while avoiding unnecessary memory allocations
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
streamhist
Implementation of streaming histogram
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
tars
A Rust library providing useful technical indicators
-
perm
Permutation iterator
-
floyd-warshall-alg
Floyd-Warshall algorithm supporting customization
-
geomorph
Simple conversion between different coordinate systems
-
smoothed_z_score
Smoothed z-score algo (very robust thresholding algorithm)
-
gbps
Rust implementation of gossip-based peer sampling
-
fxsm
A state machine procedural macro for enums
-
randomkit
numpy.randomfor Rust -
highhash
High-speed hashing algorithms for Rust
-
wookong-solo
Wookong Solo driver crate
-
competitive-hpp
Competitive Programming Library for AtCoder with Rust
-
force_graph
Force-directed graph algorithm
-
pso
Particle Swarm Optimizer
-
kmpsearch
String/Byte pattern searching within byte slices or strings, using the Knuth Morris Pratt algorithm
-
gpu-sw
GPU-SW, GPGPU-enabled SW algorithm
-
otp-rs
RFC-complaint one-time password algorithms written in Rust
-
aliasmethod
Implementation of Walker’s Alias method
-
bernoulli
An exact Bernoulli distribution
-
xrunits
A strong type unit library
-
lutz
Rust implementation of “An Algorithm for the Real Time Analysis of Digitised Images” by R. K. Lutz
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
fixed_trigonometry
Fixed point numerical approimations to trigonometric functions
-
figfont
Read and parse a FIGlet font in plain or zipped format
-
svd-expander
Expands arrays and resolves inheritance chains in CMSIS-SVD specifications
-
rust-algorithm
algorithm
-
mpmc-map
Mpmc async map implementation for highly concurrent low-write access
-
librualg
Collection of basic algorithms for everyday development
-
xoroshiro128
Fast psuedo-random number generators
-
hash-algorithms
Hash, generally translated as hash, hash, or transliterated as hash, is to transform any length of input (also known as pre image) into fixed length output through hash algorithm, and the output is the hash value…
-
total-space
Explore the total space of states of communicating finite state machines
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
plumtree
A Rust implementation of Plumtree algorithm
-
triangulate
Subdivides polygons into equivalent triangles
-
cityhash-rs
Rust no_std implementation of Google Cityhash v1.0.2, v1.0.3, and v1.1.0
-
phreak_facts
Rule matching algorithm focussed on speed
-
symbolic_polynomials
A library for manipulation of polynomials over the integers
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
tlsh
Rust port of Trend Micro Locality Sensitive Hashing
-
mur3
The rust language implementation of MurmurHash3
-
nohash
An implementation of
std::hash::Hasherwhich does not hash at all -
augmented-convert-sample-rate
Simplistic dev-quality implementation of audio sample-rate conversion
-
byond-crc32
Fast CRC-32/BYOND checksum computation
-
perlin2d
Lightning fast 2D Perlin Noise generator
-
parser-pda
Example of a simple parser pushdown automaton implementation
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
rand04_compat
Wrappers for compatibility with rand 0.4
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
collision
A collision extension to cgmath
-
rustimization
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
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.
-
aviary
Aviary bird combinators for Rust
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
every-range
Iterator for interleaving included and excluded ranges
-
fractal
The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes
-
enso-shapely
Automated typeclass derivation
-
mcmf
This crate is for solving instances of the minimum cost maximum flow problem. It uses the network simplex algorithm from the LEMON graph optimization library.
-
n18io
Manages the (de)serialisation of 18xx tiles and maps
-
stal
Set algebra solver for Redis
-
interp
A Rust implementation of Matlab’s interp1 function
-
raftlog
An implementation of distributed replicated log based on the Raft algorithm
-
rosalind
Crate contains solutions of problems published on Rosalind.info
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
hutton-rust
The Hutton cipher implemented as a Rust crate
-
str-distance
Distance metrics to evaluate distances between strings
-
co_sort
Sort arrays given a permutation
-
revonet
Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
sorting
The world’s best, finest and inefficient sorting algorithms
-
polystem
Popular stemming algorithms for Information Retrieval
-
barnes
A multithreaded Barnes Hut Algorithm implementation
-
gray-codes
Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection
-
dsalgo
A package for Datastructures and Algorithms
-
measurement-units
Rust library for basic measurements units conversion such as length, mass, time, volume, percents
-
gc-shadowstack
Shadow stack algorithm implementation for GC object rooting
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
rijksdriehoek
Convert coordinates between rijksdriehoek and wgs84
-
random-trait
Rust library for a random trait meant to produce random generic types
-
filter
Kalman filters and other optimal and non-optimal estimation filters in Rust
-
count_sort
O(n) sorting library for large datasets with small range of possible values
-
hostlist-parser
Parses hostlist expressions into a Vec of Strings
-
sorting-vec
Sorts a vector using a btreemap
-
leemaze
A generalized Lee Algorithm - Fastest Flood Fill Path type - solver for 2d, 3d, 4d or even 5d binary block mazes (5d Vec<Vec<Vec<Vec<Vec>>>>). # Convert your data into a vector maze of wall trues and open falses…
-
symmetric-shadowcasting
Simple implementation of the shadow casting FOV algorithm
-
soundchange-english
Reimplementation of Mark Rosenfelder’s pronunciation algorithm for English
-
baseperm
A tool for generating valid permutations of encoded inputs
-
integer-cbrt
An implementation of integer cube root algorithm for primitive rust types
-
solve-leetcode
Solutions to leetcode in rust
-
gitignored
A Rust implementation of the gitignore algorithm
-
hash_by_ref
A simple NewType that wraps Rc and allows to use the reference identity/pointer value of Rc as keys in hashmap
-
block-mesh
Fast algorithms for generating voxel block meshes from arrays
-
wyhash2
A simple wyhash2 implementation in rust
-
raftmodel
A logic model for the raft consensus algorithm
-
numlib
A simple numerical library implementing common numberical algorithms in rust
-
sra
A collection of spaced repetition algorithms
-
kddbscan
A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)
-
t1ha
An implementation of the T1AH (Fast Positive Hash) hash function
-
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
sorts
A collection of sorting algorithms
-
moving-least-squares-image
Image deformation using moving least squares
-
guid-partition-types
A small crate designed to work with parition types and their GUIDs
-
algo
Algorithms & Data Structure implementations
-
tailcall-impl
The procedural macro implementation for the tailcall crate
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
tiamat
a PRNG library
-
qrs_detector
Realtime ECG QRS detector algorithm
-
transducers
A transducer library for Rust
-
fossil-delta
Provides functions for calculating differences between strings and applying calculated deltas
-
non-dominated-sort
Fast Non-Dominated Sort Algorithm
-
simplex
A Linear Programming solver
-
distributed-cards
Implements the mental poker shuffling algorithm
-
location_based_sharding
Right sized sharding algorithm
-
aleph-alpha-tokenizer
A fast implementation of a wordpiece-inspired tokenizer
-
refset
A non-owning HashSet
-
numcmp
Comparison between differently typed numbers
-
pack
Solver for packing puzzle
-
hotsax
An implementation of the HOTSAX and HOTSAX based discord discovery algorithms
-
word_sensitive
A library for sensitive string matching, the implementation language is rust, and the algorithm used is ac
-
cogset
Generic implementations of clustering algorithms. Includes k-means, DBSCAN and OPTICS.
-
ntru
Implementation of the NTRUEncrypt algorithm. Interface to libntru.
-
pcg-mwc
A fast non-cryptographic psudo random number generator
-
dubble
A generic implementation of double-buffering
-
gpp-solver
A small hybrid push-pull solver/planner that has the best of both worlds
-
trassel
Unique ID integers that scale
-
rust-graph
A graph library for Rust
-
mikktspace
Mikkelsen tangent space algorithm
-
machinebox
A client SDK for communicating with machinebox boxes
-
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!
-
koper
The koper project
-
wuf
A fast weighted implementation to the union-find problem with path compression
-
fxtypemap
A fast type map based on internal hasher used in Firefox and Rustc
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
phi-detector
An Implementation of Phi Accrual Failure Detector
-
mona
Transform nested container types
-
inohashmap
fast and efficient insert only string hashmap
-
indented-blocks
parser for indented blocks
-
bytekey2
lexicographic sort-order preserving binary encoding
-
jumpconsistenthash
Implementation of Jump consistent hash i.e. ‘A Fast, Minimal Memory, Consistent Hash Algorithm’ from Google
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
rure
A C API for Rust’s regular expression library
-
hilbert_curve
A simple implementation of Hilbert curve mapping algorithms in Rust
-
rs-graph-derive
Automatic implementation of graph types
-
streemap
Set of tree map algorithms (binary, squarified, …)
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
kmeans
Small and fast library for k-means clustering calculations
-
fsm-rust-jb
Simple FSM (with effects, like Mealy machine) implementation in Rust
-
largest-remainder-method
The largest remainder method
-
fastblur
Linear-time gaussian blur
-
inin
It is a library written in Rust to parse and validate the Iranian national ID number
-
stack
DSTs and arrays on the stack!
-
cloth_bumpmap
Creates a bump map used in the clothify algorithm in GIMP (GNU Image Manipulation Program)
-
astar
A generic implementation of the A* pathfinding algorithm
-
zerobuf
A growable chunk of zeroed memory
-
cdt
Fast, robust constrained Delaunay triangulation
-
octree
Octree algorithm for nearest neighbor search in 3D space
-
bufferpool
A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
fuzzy-filter
A fast implementation (O(n)) of fuzzy-filtering
-
addchain
Generate addition chains
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse’s LDL algorithm
-
sdcons
An implementation of geo-replicated distributed consensus algorithm: SDPaxos
-
crc24
CRC-24 implementation (IETF RFC2440-compatible)
-
rust-spice-derive
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
endian-hasher
Endianness wrapper for Hashers
-
gearhash
Fast, SIMD-accelerated hash function for content-defined chunking
-
sdbm
SDBM is a non-cryptographic hashing algorithm
-
cutter
A simple usefull functions for parsing text. Used for cutting between strings.
-
consistent-rs
Consistent hash package for Rust
-
abc
An implementation of Karaboga’s Artificial Bee Colony algorithm
-
xxhash-c
Safe wrapper to xxhash
-
triangulation
A collection of triangulation algorithms
-
fluent-comparisons-macros
Macros for the fluent-comparisons crate
-
prng
pseudo random number generator
-
bidir-map
Bidirectional map implementation for Rust
-
collectables
Collectables: Rust crate of collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
blossom
Implementation of the Blossom algorithm to get a maximum matching in an undirected graph
-
statistical
A simple statistics library
-
alg_ds
Algorithms & data structures
-
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.
-
bgjk
Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect
-
fifo-set
FIFO queue with unique elements
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
cinnabar
Rust library of graph algorithms and data strctures
-
realfft
Real-to-complex FFT and complex-to-real iFFT for Rust
-
but-what-about
A permutation & combination calculation crate for rust
-
rustmt
A MT19937 PRNG implementation for rust
-
rand_jitter
Random number generator based on timing jitter
-
statest
Rust crate for statistical test
-
iobuffer
A simple memory-based buffer for IO reading and writing
-
aont
All-Or-Nothing-Transform
-
fastcmp
A fast byte slice comparison library
-
hidden-median
Finds the median of two lists, when merged without breaking sorted state
-
redblackbst
Rust Algorithms
-
asdf-pixel-sort
ASDF pixel sorting
-
maze_generator
A library of different maze generation algorithms
-
chalk-macros
Macros for Chalk
-
unik
A Powerful Universally Unique Identifier (UUID)
-
crc16
A CRC16 implementation
-
aristeia
An evolutionary computation library
-
audiograph
An audio graph optimised for performance and limiting runtime allocations
-
superslice
Extensions for slices
-
acacia
A spatial partitioning and tree library
-
wy
Rust implementation of wyhash algorithms
-
rosomaxa
A rosomaxa algorithm and other building blocks for building a solver for optimization problems
-
idalloc
A library for different methods of allocating unique identifiers efficiently
-
picorand
A zero-dependency, no_std-compatible, easily extendable library intended for fast random number generation using the WyRand PRNG with a pico-sized footprint
-
rl-bandit
A simple multi-armed bandit implementation
-
eom
Configurable ODE/PDE solver
-
coloring
Convert values to color simply and securely
-
lindel
A crate for Hilbert and Morton encoding and decoding; in a word, linearising and delinearising
-
basichll
The basic HyperLogLog algorithm
-
dia-range
Ranges for all integers
-
raft-consensus
Raft consensus algorithm implementation
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
deepmesa-encoding
A collection of data structures and algorithms designed for performance
-
soundchange
Tool for implementing sound change algorithms in Rust
-
rust-selfsimilar
A fast generator of discrete self similar random numbers
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
generic-floyd-warshall
A generic implementation of the Floyd-Warshall algorithm for array-like types
-
numext-fixed-uint-core
A internal crate used by numext-fixed-uint
-
phreak_rules
Rule matching algorithm focussed on speed
-
simple_gaussian
Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.
-
radixal
Digits iteration for unsigned integer types
-
dedup_iter
Deduplicating iterator adapters
-
stacked-sandwich
Find all occurances of a number in a row/column sorted matrix; in square root of linear time!
-
geo-visibility
Compute visibility polygon
-
polylabel-mini
[Fork of polylabel-rs] A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions
-
rand04
Re-export of rand 0.4, so it can be used together with a later version of rand
-
bstr_parse
Adds the ability to parse numbers out of
&[u8]s -
graph-neighbor-matching
Graph similarity score using neighbor matching
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
msws
Middle Square Weyl Sequence pseudorandom number generator
-
hyperbitbit
Implementation of HyperBitBit data structure
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
dancing-links
Exact cover solver using dancing links technique
-
heapp
Some heap operations on slice
-
dpc-simplemap
Simple map with default value and compacting
-
rand_hc
HC128 random number generator
-
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
itertree
Hobby project to experiment with tree traversal using iterators
-
galil-seiferas
General string search in constant space, linear time, for nonorderable alphabets
-
envelope
An interpolatable Envelope trait along with a generic 2D Point trait. Useful for controlling parameters over time.
-
building_blocks_procgen
Algorithms for procedural generation of voxel data
-
spiral
Iterate over a 2D structure in a spiral pattern
-
indexed_bitvec_core
Core operations on indexed bitvectors including (hopefully) fast rank and select operations
-
streamlined-ntru-prime
Rust implementation of the Streamline NTRU Prime algorithm
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
editdistancewf
Compute the edit-distance between vectors using the Wagner-Fischer algorithm
-
sift4
This crate provides the sift4 string distance algorithm. It is very fast and returns results similar to levenshtein
-
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
invisible-snake
A building block for high-performant graph algorithms
-
gfxmath-vec4
A simple 3D math library
-
gossip
A generic gossip library that uses gossip-based peer sampling
-
dary
This crate provides double-array construction and search functions
-
boostvoronoi_ext
Boost voronoi private workspace
-
map_split
A library providing simultaneous mutable access to disjoint portions values stored in a hash map
-
rusty-train
A graphical user interface for constructing 18xx maps and identifying optimal train routes
-
checksum
Calculates crc32/crc64 file checksums written in Rust
-
crcany-core
Core implementation of crcany library
-
rstat
Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures
-
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
int_cmp
Small library for comparing unsigned integers with signed integers
-
cbuf
Non-thread-shareable, simple and efficient Circular Buffer implementation that can store N elements when full (typical circular buffer implementations store N-1) without using separate flags
-
zip-fill
Iterator library
-
kagemeka
Kagemeka’s Rust Package
-
crcxx
universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms
-
primitive_traits
Traits over primitive types. Particularly stuff not covered by num-*.
-
quadtree_rs
Point/region Quadtree with support for overlapping regions
-
random_access_unicode
Provide random access to the unicode characters in a file
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
hamming-heap
Amortized constant time min heaps for binary features in nearest neighbor searches
-
noice
Fork of noise-rs, a procedural noise generation library
-
compressible-map
A hash map that allows compressing the least recently used values
-
bruteforce
This is a no_std-compatible brute force/string generation rust-nightly library
-
lisa
lisa - longest increasing subsequence algorithm [ O( nlogn ) ]
-
numext-fixed-hash-hack
A internal crate used by numext-fixed-hash
-
onemax-oxigen
OneMax simple problem resolution using oxigen
-
reingold-tilford
A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)
-
tinysort
The lowest memory footprint sorting algorithm
-
linear_solver
A linear solver designed to be easy to use with Rust enum expressions
-
pqgrams
This package implements a basic version of the PQ-Grams tree-edit-distance approximation algorithm, as generically as possible. It defines traits that you can define for your label-types and tree-types…
-
tonemap
A collection of tonemapping algorithms
-
rust-sort
Implementation of common sorting algorithms, purely for learning
-
is-odd
Returns true if the given number is odd
-
enso-lazy-reader
An efficient buffered reader
-
tilecover
Generate the minimum number of tiles to cover a geometry
-
nd_array
Crate for linear algebra that tries to have a similar api to numpy
-
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
polytope
Data structures and methods for constructing polytopes
-
crc32c-hw
Hardware-accelerated (SSE 4.2) implementation of CRC32C with software fallback
-
dwt
The package provides an algorithm to compute the discrete wavelet transform
-
sorting_explorer
An exploration of various sorting algorithms
-
bft-core
An efficient and stable Rust library of BFT core for distributed system
-
kdvtree
K-dimensional tree space-partitioning data structure
-
cumsum
Cumulative sum
-
piston-history_tree
A persistent history tree for undo/redo
-
rand_num_gen
random number generator trait
-
iterative_methods
Iterative methods and associated utilities as StreamingIterators
-
rng-cli
A random data generator CLI tool. Prints an infinite stream of data generated from a selected PRNG algorithm to stdout. Basically a CLI frontend for the
randcrate. -
icub3d_sudoku_solver
A sudoku solver
-
geo-offset
Add margin and padding to geometric shapes
-
rand_xorshift
Xorshift random number generator
-
integrators
Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators
-
quadtree-cd
A quadtree-based data structure for placing shapes such as rotated rectangles in bounded 2D space, checking for collision with already placed items
-
iso_iec_7064
Support for check digit operations conforming to ISO/IEC 7064
-
moving-least-squares
Image deformation using moving least squares
-
arenavec
An arena backed implementation of vectors and related types
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
squares-rnd
Simple and fast counter based non-crypto random generator
-
safe-modular-arithmetic
Implementation of modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
algosort
Implementation of sorting algorithms
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
dft
The package provides an algorithm to compute the discrete Fourier transform
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc