-
rand
Random number generators and other randomness functionality
-
twox-hash
A Rust implementation of the XXHash and XXH3 algorithms
-
fastrand
A simple and fast random number generator
-
crc
Rust implementation of CRC(16, 32, 64) with support of various standards
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
pathfinding
Pathfinding, flow, and graph algorithms
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
ff
Library for building and interfacing with finite fields
-
rand_distr
Sampling from random number distributions
-
rand_core
Core random number generator traits and tools for implementation
-
crc32fast
Fast, SIMD-accelerated CRC32 (IEEE) checksum computation
-
ultraviolet
A crate to do linear algebra, fast
-
passwords
This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them
-
timely
A low-latency data-parallel dataflow system in Rust
-
dusk-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
numext-constructor
Fixed-size uint and hash constructor
-
leaky-bucket
Futures-aware rate limiter implementation
-
fake
An easy to use library for generating fake data like name, number, address, lorem, dates, etc
-
oorandom
A tiny, robust PRNG implementation
-
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.
-
rustc-hash
speed, non-cryptographic hash used in rustc
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
k
k is for kinematics
-
rdrand
An implementation of random number generator based on rdrand and rdseed instructions
-
governor
A rate-limiting implementation in Rust
-
adler32
Minimal Adler32 implementation for Rust
-
bitpacking
Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.
-
roots
Library of well known algorithms for numerical root finding
-
lfest
A leveraged perpetual futures exchange for simulated trading is a high performance backtesting exchange
-
jubjub
Implementation of the Jubjub elliptic curve group
-
ncollide3d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
rust-lapper
A fast and easy interval overlap library
-
numext-fixed-uint
Fixed-size uint types
-
highway
Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
differential-dataflow
An incremental data-parallel dataflow platform
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
alphanumeric-sort
This crate can help you sort order for files and folders whose names contain numerals
-
xorf
Library implementing xor filters - faster and smaller than bloom and cuckoo filters
-
integer-sqrt
An implementation of integer square root algorithm for primitive rust types
-
triple_buffer
An implementation of triple buffering, useful for sharing frequently updated data between threads
-
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.
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
wildmatch
Simple string matching with questionmark and star wildcard operator
-
rsgenetic
A library providing genetic algorithm execution
-
fastcdc
FastCDC (content defined chunking) in pure Rust
-
screwsat
A simple condlict driven clause learning sat solver
-
chalk-solve
Combines the chalk-engine with chalk-ir
-
dissimilar
Diff library with semantic cleanup, based on Google’s diff-match-patch
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
multihash
Implementation of the multihash format
-
treediff
Find the difference between arbitrary data structures
-
random_color
Rust crate for generating random attractive colors
-
gcd
Small Rust library (with no dependencies) for calculating greatest common divisor
-
md5
The package provides the MD5 hash function
-
glass_pumpkin
A cryptographically secure prime number generator based on rust’s own num-bigint and num-integer
-
earcutr
port of MapBox’s earcut triangulation code to Rust language
-
counting_sort
Counting sort implementation for Iterators
-
linregress
ordinary least squared linear regression with some basic statistics
-
slice-group-by
Iterators over groups in a slice
-
rand_regex
Generates random strings and byte strings matching a regex
-
levenshtein
Levenshtein algorithm
-
cap-rand
Capability-based random number generators
-
simdutf8
SIMD-accelerated UTF-8 validation
-
ids_service
Library that allows to generate unique Ids
-
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
-
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)…
-
adler
A simple clean-room implementation of the Adler-32 checksum
-
quantiles
a collection of approximate quantile algorithms
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
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, …
-
robust
Robust adaptive floating-point predicates for computational geometry
-
svg2polylines
Convert SVG data to a list of polylines (aka polygonal chains or polygonal paths)
-
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
-
probability
The package provides a probability-theory toolbox
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
broccoli
broadphase collision detection algorithms
-
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
autodiff
An automatic differentiation library
-
regex-syntax
A regular expression parser
-
poi
A pragmatic point-free theorem prover assistant
-
chalk-engine
Core trait engine from Chalk project
-
xxhash-rust
Implementation of xxhash
-
rust-spice
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
boostvoronoi
Boost voronoi ported to 100% rust
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
delaunator
A very fast 2D Delaunay triangulation library
-
fuzzyhash
Pure Rust fuzzy hash implementation
-
rtbvh
BVH library with various build algorithms and high performance using packet traversal
-
median
An implementation of an efficient O(n) median filter
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
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
-
radiate
Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems
-
flo_curves
Library for manipulating Bezier curves
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
grb
A Rust API for Gurobi optimizer
-
pso-rs
An easy-to-use, simple Particle Swarm Optimization implementation in Rust
-
tailcall
Safe, zero-cost tail recursion
-
is_sorted
Is an Iterator sorted?
-
tinymt
Rust implementation of TinyMT 64/32 - a lightweight variant of Mersenne Twister PRNG
-
naive_opt
The optimized naive string-search algorithm
-
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
microfft
Embedded-friendly Fast Fourier Transforms
-
raft
The rust language implementation of Raft algorithm
-
nanoid
A tiny, secure, URL-friendly, unique string ID generator for Rust
-
actionable
An enum-based async framework for building permission-driven APIs
-
id_tree_layout
A library to visualize trees from the ‘id_tree’ crate
-
graph
A building block for high-performant graph algorithms
-
multistream-batch
Implementations of batching algorithms
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
random-pick
Pick an element from a slice randomly by given weights
-
pubgrub
PubGrub version solving algorithm
-
simsearch
A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)
-
wyhash
Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator
-
frank_jwt
Implementation of JSON JWT
-
chalk-recursive
Recursive solver for the Chalk project
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
rand_mt
Reference Mersenne Twister random number generators
-
hierarchical_pathfinding
Quickly approximate Paths on a Grid
-
noise
Procedural noise generation library
-
tokenizations
Tokenizations alignments library
-
nlopt
Wrapper for the nlopt library
-
coord2d
rust lib for coordinate in 2d system
-
sfsm
Generate static state machines
-
metrohash
Rust implementation of MetroHash, a high quality, high performance hash algorithm
-
crc16
A CRC16 implementation
-
memx
memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
probminhash
Minhash algorithms for weighted Jaccard index
-
fallible-iterator
Fallible iterator traits
-
osqp
The OSQP (Operator Splitting Quadratic Program) solver
-
hora
Hora Search Everywhere
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
hashicorp-lru
The project is moved to caches, please see crate caches
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
ahrs
A Rust port of Madgwick’s AHRS algorithm
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
extendhash
Rust Hash Extender
-
hexagonal_pathfinding_astar
A-Star pathfinding algorithm tailored for traversing a bespoke collection of weighted hexagons
-
muldiv
Provides a trait for numeric types to perform combined multiplication and division with overflow protection
-
ring_buffer
RingBuffer is a queue with added random access
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
leaky-bucket-lite
Slimmed down, lazy futures-aware rate limiter implementation
-
cdshealpix
Rust implementation of the HEALPix tesselation
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
fi-night
Statically typed Finite State Machine and Pushdown Automaton implementation
-
faiss
High-level bindings for Faiss, the vector similarity search engine
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
ru_annoy
A rust implementation of annoy(https://github.com/spotify/annoy) (Index serving only). Providing C api as well
-
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…
-
rust-stemmers
A rust implementation of some popular snowball stemming algorithms
-
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.
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
poisson-diskus
Poisson disk distribution sampling
-
linked_hash_set
HashSet with insertion ordering
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
avalog
An experimental implementation of Avatar Logic with a Prolog-like syntax
-
seal
Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment
-
dusk-poseidon
Implementation of Poseidon hash algorithm over the Bls12-381 Scalar field
-
extsort
External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator
-
rs-graph
A library for graph algorithms and combinatorial optimization
-
historian
a high performance zero-config histogram implementation
-
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
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
worley-noise
Worley noise implementation
-
out
Provides fast min and max functionality for collections
-
rdst
A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
rrt
Path finding using dual-RRT connect
-
weighted-rs
A libray for weighted balancing algorithm
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
levenberg-marquardt
Levenberg-Marquardt algorithm built on top of nalgebra
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
bitintr
Portable Bit Manipulation Intrinsics
-
contest-algorithms
Common algorithms and data structures for programming contests
-
zeros
Keccak implementation
-
colors-transform
Module for convert and transform colors
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
gut
Geometry utilities: storing, manipulating and processing geometries
-
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…
-
boyer-moore-magiclen
Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust
-
rake
Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm
-
raft-proto
Protocol definitions for the rust language implementation of the Raft algorithm
-
strength_reduce
Faster integer division and modulus operations
-
enso-prelude
An augmented standard library in the vein of Haskell’s prelude
-
sobol
A Sobol sequence generator for Rust
-
n18tile
Defines 18xx tile elements and track networks
-
cdchunking
Content-defined chunking
-
pqc_kyber
A rust implementation of the post-quantum Kyber KEM algorithm
-
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…
-
lp-solvers
.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK
-
transvoxel
Implementation of Eric Lengyel’s Transvoxel Algorithm
-
hyperid
Superfast id generator
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
md6
Implementation of the MD6 hash function for Rust via FFI
-
astro
Advanced algorithms for astronomy
-
sm
💋 SM – a static State Machine library
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
fleetfs_raft
The rust language implementation of Raft algorithm
-
geo-clipper
Boolean operations on polygons
-
convert-base
convert the radix (base) of digits stored in a vector
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
luhn3
A Luhn validation library
-
special
The package provides special functions
-
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
-
hyperloglogplus
HyperLogLog implementations
-
test-data-generation
A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
genx
An easy to use and modular genetic algorithms library
-
graphplan
Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in 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…
-
cauchy
Trait for real and complex numbers
-
minimax-alpha-beta
An implementation of Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
fastvlq
A fast variant of Variable-Length Quantity with a focus on speed and no_std support
-
coord_transforms
A Rust crate use for performing coordinate transformations
-
nohash-hasher
An implementation of
std::hash::Hasherwhich does not hash at all -
atomic-traits
The traits for generic atomic operations
-
punkt
An implementation of a Punkt sentence tokenizer
-
simplers_optimization
A Rust implementation of the Simple(x) black-box optimization algorithm
-
relp
Rust Exact Linear Programming
-
rand_chacha
ChaCha random number generator
-
bishop
Library for visualizing keys and hashes using OpenSSH’s Drunken Bishop algorithm
-
flo_binding
Declarative binding library for Rust
-
hnsw
Fast approximate nearest neighbors
-
backtrack
Solve hard constraints easily
-
partition
partition slices in-place by a predicate
-
almost-raft
An implementation of Raft leader election
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
pagino
Handle pagination’s logic
-
fuzzy_rocks
A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
safe-mix
Implementation of the Collective Coin Flip algorithm
-
lv03
Conversion between the Swiss coordinate system (LV03/CH1903 or LV95/CH1903+) and WGS84 coordinates
-
yada
Yada is a yet another double-array trie library aiming for fast search and compact data representation
-
kendalls
Kendall’s tau rank correlation
-
numext-fixed-uint-hack
A internal crate used by numext-fixed-uint
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
subslice
Fast subslice search
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
color_space
library for converting between color spaces and comparing colors
-
trade_aggregation
Aggregate raw trades into candles using different methods
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
consistent_hash_ring
A flexible and efficient consistent hash ring
-
programinduction
A library for program induction and learning representations
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
magpie
Reasonably efficient Othello library built with bitboards
-
sub-strs
For finding sub strings
-
enso-optics
An implementation of functional optics
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
bromberg_sl2
Cayley hashing as in ‘Navigating in the Cayley Graph of SL₂(𝔽ₚ)’
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
reed-solomon-novelpoly
An implementation of a reed solomon code / encoder / decoder with complexity
O(n lg(n)) -
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
sets
Sets implemented as generic vectors. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.
-
simd-adler32
A SIMD-accelerated Adler-32 rolling hash algorithm implementation
-
board-game
A board game abstraction and generic utilities around it
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
bloom_filter_plus
rust_bloom_filter
-
poker
A crate for speedy poker hand evaluation
-
fakeit
Fake data generator library with 130+ functions
-
block-aligner
SIMD-accelerated library for computing global and X-drop affine gap sequence alignments using an adaptive block-based algorithm
-
varint-rs
A small, zero dependency varint implementation in Rust
-
algorithmica
Rust Algorithms
-
chalk-ir
Chalk’s internal representation of types, goals, and clauses
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
alea
A crate for randomness
-
bindet
Fast file type detection
-
vsprintf
Rust bindings to the libc vsprintf function
-
accurate
(more or less) accurate floating point algorithms
-
powierza-coefficient
Powierża coefficient is a statistic for gauging if one string is an abbreviation of another
-
intersect2d
Line segment intersection detection
-
bit-iter
Iterate forward or backwards over the positions of set bits in a word
-
permutation
Small utility for creating, manipulating, and applying permutations
-
svdlibrs
A Rust port of LAS2 from SVDLIBC
-
movavg
Generic Moving Average calculation
-
skelly
Skeleton animation and IK
-
metaheuristics-nature
A collection of nature-inspired meta-heuristic algorithms
-
pcg_rand
An implementation of the PCG family of random number generators in pure Rust
-
hybrid-clocks
Hybrid Logical Clocks
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.
-
fletcher
A dependency free implementation of the Fletcher’s checksum algorithm
-
crczoo
CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms
-
etagere
Dynamic 2D texture atlas allocation using the shelf packing algorithm
-
mushin
Compile-time creation of neural networks
-
hotdrink-rs
An implementation of HotDrink in Rust
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
rendezvous_hash
An implementation of Rendezvous hashing algorithm
-
beehave
A simple library for defining and evaluating a hierarchical state machine (behaviour tree)
-
faiss-sys
Native bindings for Faiss
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
circbuf
A growable circular buffer for working with bytes
-
tugger-apple
Random functionality related to Apple platforms
-
secwords
secure and safe password container
-
rulinalg
A linear algebra library
-
paginator
This crate is used for generating pagination bar
-
forceatlas2
fast force-directed generic n-dimension graph layout
-
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
ca-formats
Parsing pattern files for Conway’s Game of Life
-
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
twofloat
Double-double arithmetic functionality
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
bit_combi_iter
An iterator to iterate all bit combinations less than given unsigned integer
-
fp-growth
An implementation of the FP-Growth algorithm in pure Rust
-
wtools
Collection of general purpose tools for solving problems. Fundamentally extend the language without spoiling namespace, so may be used solely or in conjunction with another module of such kind.
-
eddie
Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler
-
morphorm
A UI layout engine
-
qsv-stats
Experimental crate for computing basic statistics on streams
-
sungod
0-Dependency random numbers to brighten your day
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
sparse_linear_assignment
Solvers for sparse linear assignment problem based on the auction algorithm
-
human-sort
Human sort (natural sort) implementation
-
seqdiff
Diff between two sequences
-
closest-sum-pair
Finds a pair in a list that has the closest sum to a given number
-
qframework
A experimental micor framework for clear design, based on queue model
-
diffr-lib
An implementation of Myers diff algorithm
-
newton_rootfinder
Newton based methods for root finding
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
morton-encoding
A crate for encoding and decoding Morton (“Z-order”) keys
-
iterslide
A “sliding window” iterator
-
arc-interner
An interner that deallocates unused values
-
java_random
The java LCG and random module implementation in rust
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
maglev
Maglev - Google’s consistent hashing algorithm
-
vrp-pragmatic
An extension logic for solving rich VRP
-
nqueens-oxigen
N Queens problem resolution using oxigen
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
rustlex_fsa
Library for manipulating (deterministic) finite automata
-
linfa-datasets
Collection of small datasets for Linfa
-
debouncr
A simple no-std input debouncer to detect rising and falling edges with minimal RAM requirements
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
count-min-sketch
Count-min-sketch implementation
-
vec-drain-where
alternative
Vec::drain_filterimpl -
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters’s pdqsort
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
dasp_interpolate
An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc
-
toposort-scc
An implementation of Kahn’s algorithm for topological sorting and Kosaraju’s algorithm for strongly connected components
-
line-col
Convert string slice indices into line/column numbers
-
pretree
Pretree is a package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
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…
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
rand_isaac
ISAAC random number generator
-
rgeometry
High-Level Computational Geometry
-
m4ri-sys
Bindings to m4ri
-
clock-zones
A library for handling clock zones
-
hash_avatar
rust生成随机头像的库
-
rta-for-fps-lib
An Implementation of the paper ‘Response Time Analysis for Fixed Priority Servers’ by Hamann et al
-
search-sort
Implementation of few searching and sorting algorithms
-
detect-lang
Language detection given paths and extensions
-
pikkr
JSON Parser which picks up values directly without performing tokenization in Rust
-
iter_columns
Iterate over columns easily
-
glicko2
Implementation of the glicko2 rating system
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
external_sort
Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
geometry-predicates
A Rust port of robust geometric predicates
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
scru128
SCRU128: Sortable, Clock and Random number-based Unique identifier
-
macro_machine
State machine generator using macros
-
iter-set
Set operations on sorted, deduplicated iterators
-
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.
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
distance
A collection of approximate string matching algorithms
-
rust-3d
2D/3D library written in rust
-
building_blocks_search
Search algorithms for voxel data
-
lutz
Rust implementation of “An Algorithm for the Real Time Analysis of Digitised Images” by R. K. Lutz
-
sudoku-solver
Simple backtracking algorithm for solving sudoku
-
rexl
A simple algorithm library for Rust
-
porco
Composable probability distributions
-
relp-num
Number types for the relp crate
-
extprim
Extra primitive types (u128, i128)
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
anchorhash
A consistent hashing algorithm that outperforms state-of-the-art algorithms
-
libdivsufsort-rs
A rust wrapper of libdivsufsort
-
trajectory
Trajectory interpolation
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
sort-it
Various sorting algorithms
-
rootfind
Root-finding algorithms
-
visionmagic
Collection of vision & graphics algorithms
-
tiny_tco
A tiny dirt simple no_std tail call optimization library
-
wkb
Convert geo-types from georust to/from Well Known Binary
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
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
-
list-fn
A generic lazy list
-
ordslice
Extensions for ordered slices
-
hungarian
A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
graphblas_sparse_linear_algebra
Wrapper for SuiteSparse:GraphBLAS
-
extra_waiters
Wait for notifications without a Mutex
-
mersenne_twister
Mersenne Twister pseudorandom number generator
-
memx-cdy
The fast memory functions like a libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
rtriangulate
Delaunay triangulation on a set of points
-
competitive-programming-rs
Competitive Programming Library in Rust
-
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
munkres
Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)
-
color-thief
Grabs the dominant color or a representative color palette from an image
-
darwin-rs
Evolutionary algorithms library written in Rust
-
vrf
Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
fast_poisson
An implementation of Bridson’s algorithm for fast Poisson disk sampling
-
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
-
lfu
An LFU cache implementation
-
onlinecode
An implementation of “Online Codes”, a type of Fountain Code
-
rab-core
Rusty Armor Builds - Algorithms, Armors and skill management
-
endicon
Implementations of codicon traits for endianness encodings
-
halton
A module for generating Halton sequences
-
mincost
A collection of modern heuristic optimization toolkit
-
library_of_babel
Implementation of Library of Babel in Rust
-
sfmt
Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
meowhash
Meow hash function
-
lol-core
A Raft implementation in Rust language
-
multistochgrad
Stochastic Gradient, Multithreaded
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
modulo
Simple modulo operation
-
rusty_planner
Artificial intelligence planning & reasoning library for Rust
-
xorshift
Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators
-
pasture-algorithms
Point cloud algorithms for pasture
-
quasirandom
Quasirandom number generation
-
phpass
PHPass, the WordPress password hasher, re-implemented in rust
-
seek_bufread
A drop-in replacement for std::io::BufReader with seeking support
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
murmur3
A rust implementation of Murmur3 hash
-
buf-min
Minimal utf-8 safe buffer traits
-
ritehash
A tiny, fast, zero-dep and no_std fxhash fork. More up to date.
-
winapi-hash
Windows API hashing implementation
-
batsat
Extensible SAT solver in Rust
-
vecshard
Split Vecs in constant time
-
xxhrs
Safe XXHash and XXH3 bindings
-
time_wheel
An implementation of timer uses time-wheel algorithm
-
english-numbers
Convert integers to written English number format
-
random-branch
Provides a macro to select a random branch like match
-
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
qptrie
A QP-Trie implementation for Rust
-
caches
This is a Rust implementation for popular caches (support no_std)
-
numext-fixed-hash
Fixed-size hash types
-
symspell
Spelling correction & Fuzzy search
-
actionable-macros
Macros for
actionable -
gurobi
An unofficial Rust API for Gurobi optimizer
-
permutation_iterator
A Rust library for iterating over random permutations using O(1) (i.e. constant) space.
-
funtools
a collection of fun iterators to tinker with
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
uncertain
Fast and correct computations with uncertain values
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
layered-bitset
Bit set implementation using layered structure
-
pikkr-annika
JSON Parser which picks up values directly without performing tokenization in Rust. Reuploaded by Annika due to her compile problems.
-
rfc-4226
Implementation of IETF RFC 4226 (HOTP)
-
mx3
Implementation of the mx3 algorithm providing a bit mixer, pseudo-random number generator, and hash function
-
bsa3-hash
The hash function used in BSA files for The Elder Scrolls III: Morrowind
-
reciprocal
Baseline implementation of integer division by constants
-
omnitigs
Omnitig-related algorithms
-
dedup_signature
This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
probably
A library with various approximate computing algorithms
-
pdqsort
Pattern-defeating quicksort
-
algos
A collection of algorithms in Rust
-
zvxryb-broadphase
A broadphase collision detection library
-
hash-roll
Rolling hashes & Content Defined Chunking (cdc)
-
nuid
A highly performant unique identifier generator
-
hilbert
Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm
-
fang_oost
A library implementing Fang and Oosterlee’s algorithm for inverting characteristic functions
-
mpmc-map
Mpmc async map implementation for highly concurrent low-write access
-
statistical
A simple statistics library
-
triangulate
Subdivides polygons into equivalent triangles
-
utm
Convert latitudes and longitudes to UTM coordinates
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
clf
flush the cpu cache line by __builtin_clear_cache()
-
elements-frequency
Finds the frequency of elements in a list
-
toolbox
Simple tools for daily use
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
gossip
A generic gossip library that uses gossip-based peer sampling
-
sdcons
An implementation of geo-replicated distributed consensus algorithm: SDPaxos
-
noisy
A procedural noise generation library written for Rust
-
stringslice
A collection of methods to slice strings based on character indices rather than bytes
-
search-autocompletion
A Rust implementation of Search Auto Completion
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
n18hex
Defines the geometry of hexagonal tiles for 18xx
-
rand_pcg
Selected PCG random number generators
-
summed-area-table
Implementation of a summed area table
-
delaunay2d
A library to compute Delaunay triangulations and Voronoi diagrams in 2D space
-
mikktspace
Mikkelsen tangent space algorithm
-
benchfun
Benchmarking functions to use for optimization algorithms
-
enso-shapely
Automated typeclass derivation
-
fuss
Small, lightweight simplex noise generator for Rust
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
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
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
conshash
A library to do consistent hashing in Rust
-
patmatch
A configurable pattern matching / wildcard matching library
-
labelgraph
A simple to use graph implementation, allowing random access to nodes via labels
-
rustfft
High-performance FFT library written in pure Rust
-
fast_inv_sqrt
Fast inverse square root algorithm implementation
-
sparse_graph
Sparse graph algorithms
-
brace-expand
Rust crate which performs brace expansion of strings, as in shells like Bash etc
-
moving-least-squares-image
Image deformation using moving least squares
-
sprs-ldl
Sparse cholesky factorization
-
xorshift128plus-rs
A simple implementation of the XorShift128+ pseudorandom number generator in Rust
-
fuzzy_dbscan
An implementation of the FuzzyDBSCAN algorithm
-
moodyblues-sdk
A tracer SDK for Overlord like consensus algorithm
-
kahan
Provides types to perform Kahan summation
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
lis
Longest increasing subsequence algorithm
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
favannat
Algorithms to evaluate the function encoded in ANN-like structures
-
perm
Permutation iterator
-
tree-edit-distance
Find the lowest cost sequence of edits between two trees
-
livesplit-title-abbreviations
livesplit-title-abbreviations encapsulates the algorithm that LiveSplit uses to abbreviate game titles
-
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
mycrc
Create your own cyclic redundancy check (CRC)
-
IntegerScaling
Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction
-
textnonce
Text based random nonce generator
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
rdx
A collection of traits and algorithms to ease using radix sorts
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
imgthin
A fast parallel algorithm for thinning digital patterns
-
streamhist
Implementation of streaming histogram
-
lambert
lamber-rust is a crate helping to convert Lambert coordinates to WGS84
-
hamt-rs
A Hash Array Mapped Trie implementation based on the Ideal Hash Trees paper by Phil Bagwell
-
lttb
An implementation of the Largest Triangle Three Buckets algorithm
-
adler32fast
Fast, SIMD-accelerated Adler-32 checksum computation
-
efd
Elliptical Fourier Descriptor (EFD) curve fitting in Rust
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
extrema
C++’s minmax_element implementation in rust
-
tailcall-impl
The procedural macro implementation for the tailcall crate
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
hashring
A minimal implementation of consistent hashing
-
geos-sys
GEOS C API bindings
-
violin
decentralized network coordinate system using the vivaldi algorithm
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
bravery_router
Radix Tree implementation
-
sorting-vec
Sorts a vector using a btreemap
-
tlsh
Rust port of Trend Micro Locality Sensitive Hashing
-
count_sort
O(n) sorting library for large datasets with small range of possible values
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
fera
An aggregation of algorithms, data structures and supporting crates
-
just-argon2
Bindings to the argon2 C library
-
bloom_filter_plush
rust_bloom_filter
-
srand
Random number generators and other randomness functionality with simple apis to use
-
algebraics
algebraic numbers library
-
asearch
Approximate pattern matching on Rust
-
sep-sys
Low-level bindings to SEP - C library for Source Extraction and Photometry
-
librualg
Collection of basic algorithms for everyday development
-
integer-cbrt
An implementation of integer cube root algorithm for primitive rust types
-
nats-types
Enumerations and types for representing NATS protocol messages
-
interp
A Rust implementation of Matlab’s interp1 function
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
simple-tiled-wfc
A simple library which lets a user to use a tiled Wave Function Collapse algorithm implementation
-
buldak
It is a library that provides various sorting functions
-
nohash
An implementation of
std::hash::Hasherwhich does not hash at all -
rjq
Redis job queue
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
uaparser
A Rust implementation of the UA Parser
-
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…
-
fast_ode
Fast Runge-Kutta implementation
-
figfont
Read and parse a FIGlet font in plain or zipped format
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
needle
Fast search functions for finding things in Strings, Arrays and iterators
-
concorde
reconfigurable lattice agreement
-
sorts
A collection of sorting algorithms
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
async-jobs
Asynchronous job orchestration for Rust
-
perlin2d
Lightning fast 2D Perlin Noise generator
-
eytzinger-map
array/vec based map using eytzinger search algorithm
-
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
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
acap
As Close As Possible — nearest neighbor search in Rust
-
cplex-sys
Low level bindings to the Cplex C-API
-
czt
The package provides an algorithm to compute the chirp Z-transform
-
ai_kit
Collection of classic AI algorithms with convenient interfaces
-
supermemo2
A simple crate that implements the supermemo2 spaced repetition algorithm
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
optimization
Collection of optimization algorithms
-
mona
Transform nested container types
-
niceware
Generate or convert random bytes into passphrases. A Rust port of niceware.
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
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.
-
fxtypemap
A fast type map based on internal hasher used in Firefox and Rustc
-
phreak_facts
Rule matching algorithm focussed on speed
-
acacia
A spatial partitioning and tree library
-
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)…
-
dia-ip-range
Ranges for IP v4
-
cityhash-rs
Rust no_std implementation of Google Cityhash v1.0.2, v1.0.3, and v1.1.0
-
competitive-hpp
Competitive Programming Library for AtCoder with Rust
-
xoroshiro128
Fast psuedo-random number generators
-
mecs
An ecs library with a focus on iteration performance
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
smoothed_z_score
Smoothed z-score algo (very robust thresholding algorithm)
-
co_sort
Sort arrays given a permutation
-
spatium
Spatium. Calc distance between sequences.
-
baseperm
A tool for generating valid permutations of encoded inputs
-
traversal
Generic and lazy tree traversal algorithms
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
xrunits
A strong type unit library
-
aliasmethod
Implementation of Walker’s Alias method
-
highs
Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.
-
cdivsufsort
Rust bindings for Yuta Mori’s divsufsort
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
force_graph
Force-directed graph algorithm
-
tars
A Rust library providing useful technical indicators
-
persistent
A set of middleware for sharing server-global data in Iron
-
streemap
Set of tree map algorithms (binary, squarified, …)
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
blake
Implementation of the BLAKE hash function for Rust via FFI
-
floyd-warshall-alg
Floyd-Warshall algorithm supporting customization
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
highhash
High-speed hashing algorithms for Rust
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
rosalind
Crate contains solutions of problems published on Rosalind.info
-
checked_expr
a procedural macro for making writing checked_* chains more ergonomic
-
rust-algorithm
algorithm
-
vrp-scientific
An extension logic for solving scientific VRP
-
random-trait
Rust library for a random trait meant to produce random generic types
-
blurhash
A pure Rust implementation of blurhash
-
bufferpool
A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions
-
bidir-map
Bidirectional map implementation for Rust
-
parser-pda
Example of a simple parser pushdown automaton implementation
-
gpu-sw
GPU-SW, GPGPU-enabled SW algorithm
-
barnes
A multithreaded Barnes Hut Algorithm implementation
-
rustimization
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
trassel
Unique ID integers that scale
-
building_blocks_procgen
Algorithms for procedural generation of voxel data
-
wookong-solo
Wookong Solo driver crate
-
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
pso
Particle Swarm Optimizer
-
refset
A non-owning HashSet
-
collision
A collision extension to cgmath
-
kmpsearch
String/Byte pattern searching within byte slices or strings, using the Knuth Morris Pratt algorithm
-
sorted-insert
This crate provides traits to insert elements to a sorted collection and keep the order
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
sorting
The world’s best, finest and inefficient sorting algorithms
-
aont
All-Or-Nothing-Transform
-
inohashmap
fast and efficient insert only string hashmap
-
sra
A collection of spaced repetition algorithms
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
total-space
Explore the total space of states of communicating finite state machines
-
soundchange-english
Reimplementation of Mark Rosenfelder’s pronunciation algorithm for English
-
bernoulli
An exact Bernoulli distribution
-
num-cmp
Comparison between differently typed numbers
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
inin
It is a library written in Rust to parse and validate the Iranian national ID number
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
pcg-mwc
A fast non-cryptographic psudo random number generator
-
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.
-
symmetric-shadowcasting
Simple implementation of the shadow casting FOV algorithm
-
crfs
Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
microstate
Finite state machine, inspired by micromachine
-
smeagol
Conway’s Game of Life using HashLife and SIMD
-
stack
DSTs and arrays on the stack!
-
tdigest
T-Digest algorithm in Rust
-
plumtree
A Rust implementation of Plumtree algorithm
-
rand04_compat
Wrappers for compatibility with rand 0.4
-
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.
-
fractal
The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes
-
gitignored
A Rust implementation of the gitignore algorithm
-
t1ha
An implementation of the T1AH (Fast Positive Hash) hash function
-
octree
Octree algorithm for nearest neighbor search in 3D space
-
rusthotp
A simple, pure Rust implementation of the HMAC-based One-Time Password algorithm specified in RFC 4226
-
mur3
The rust language implementation of MurmurHash3
-
fxsm
A state machine procedural macro for enums
-
cloth_bumpmap
Creates a bump map used in the clothify algorithm in GIMP (GNU Image Manipulation Program)
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
cdt
Fast, robust constrained Delaunay triangulation
-
rustotp
A simple, pure Rust implementation of the Time-Based One Time Password (TOTP) algorithm specified in RFC 6238
-
bls-signatures-rs
Open source implementation of Bonneh-Lynn-Shacham (BLS) signatures written in Rust
-
astar
A generic implementation of the A* pathfinding algorithm
-
mushin_derive
Compile-time creation of neural networks
-
every-range
Iterator for interleaving included and excluded ranges
-
but-what-about
A permutation & combination calculation crate for rust
-
ntru
Implementation of the NTRUEncrypt algorithm. Interface to libntru.
-
raftlog
An implementation of distributed replicated log based on the Raft algorithm
-
aviary
Aviary bird combinators for Rust
-
hutton-rust
The Hutton cipher implemented as a Rust crate
-
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!
-
graph-neighbor-matching
Graph similarity score using neighbor matching
-
dekker
Implementation of Dekker’s algorithm for mutual exclusion
-
dusk-hades
Implementation of Hades252 permutation algorithm over the Bls12-381 Scalar field
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
gray-codes
Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection
-
revonet
Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
rand04
Re-export of rand 0.4, so it can be used together with a later version of rand
-
numcmp
Comparison between differently typed numbers
-
dubble
A generic implementation of double-buffering
-
two-lock-queue
A MPMC channel based on the michael-scott two lock queue algorithm
-
overlord
Overlord consensus procotol
-
fossil-delta
Provides functions for calculating differences between strings and applying calculated deltas
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
distributed-cards
Implements the mental poker shuffling algorithm
-
wyhash2
A simple wyhash2 implementation in rust
-
statest
Rust crate for statistical test
-
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…
-
broadword
Broadword algorithms
-
rijksdriehoek
Convert coordinates between rijksdriehoek and wgs84
-
rust-graph
A graph library for Rust
-
algo
Algorithms & Data Structure implementations
-
kddbscan
A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)
-
lax
LAPACK wrapper without ndarray
-
numlib
A simple numerical library implementing common numberical algorithms in rust
-
indented-blocks
parser for indented blocks
-
coloring
Convert values to color simply and securely
-
pack
Solver for packing puzzle
-
cogset
Generic implementations of clustering algorithms. Includes k-means, DBSCAN and OPTICS.
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
extsort-lily
An efficient external merge sort implementation
-
fsm-rust-jb
Simple FSM (with effects, like Mealy machine) implementation in Rust
-
rustbox
A rust implementation of the termbox library
-
addchain
Generate addition chains
-
polystem
Popular stemming algorithms for Information Retrieval
-
solve-leetcode
Solutions to leetcode in rust
-
dists
2d distribution generator
-
qrs_detector
Realtime ECG QRS detector algorithm
-
asdf-pixel-sort
ASDF pixel sorting
-
basic-hll
The basic HyperLogLog algorithm
-
fluent-comparisons-macros
Macros for the fluent-comparisons crate
-
td_rthreadpool
thread wrapper for Rust
-
checksum
Calculates crc32/crc64 file checksums written in Rust
-
machinebox
A client SDK for communicating with machinebox boxes
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
sfsm-base
Traits for the sfsm crate
-
randomkit
numpy.randomfor Rust -
rl-bandit
A simple multi-armed bandit implementation
-
fifo-set
FIFO queue with unique elements
-
phi-detector
An Implementation of Phi Accrual Failure Detector
-
wuf
A fast weighted implementation to the union-find problem with path compression
-
xxhash-c
Safe wrapper to xxhash
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
spiral
Iterate over a 2D structure in a spiral pattern
-
mcs
Synchronization primitives based on Mellor-Crummey and Scott’s (MCS) queueing spinlock. This library is usable without
std. -
aud
A minimal implementation of Sagas
-
nuban_rust
A validator and generator of Nigerian Uniform Bank Account Number(NUBAN)
-
bubble-sort
A quick and non-optimized, cloning version of the bubble sort algorithm. Created as a showcase for publishing crates in the Rust Cookbook 2018
-
zerobuf
A growable chunk of zeroed memory
-
cutter
A simple usefull functions for parsing text. Used for cutting between strings.
-
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
-
rust-spice-derive
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
gear
Collision avoidance path planning for robotics
-
kmeans
Small and fast library for k-means clustering calculations
-
rand_jitter
Random number generator based on timing jitter
-
hidden-median
Finds the median of two lists, when merged without breaking sorted state
-
simple_gaussian
Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse’s LDL algorithm
-
audiograph
An audio graph optimised for performance and limiting runtime allocations
-
hilbert_curve
A simple implementation of Hilbert curve mapping algorithms in Rust
-
fastblur
Linear-time gaussian blur
-
largest-remainder-method
The largest remainder method
-
bgjk
Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect
-
tiamat
a PRNG library
-
scarecrow
A neural network library
-
hyparview
A Rust implementation of HyParView algorithm
-
endian-hasher
Endianness wrapper for Hashers
-
length
A library to handle length/distances easyly. It can parse a string with several units (m, km, mi, ft, …) into the Length-struct and converting into other units.
-
zip-fill
Iterator library
-
dirty-fsm
A quick and dirty state machine library
-
blossom
Implementation of the Blossom algorithm to get a maximum matching in an undirected graph
-
superslice
Extensions for slices
-
rusty_state
A simple state machine for rust
-
hotsax
An implementation of the HOTSAX and HOTSAX based discord discovery algorithms
-
rure
A C API for Rust’s regular expression library
-
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.
-
wy
Rust implementation of wyhash algorithms
-
map_split
A library providing simultaneous mutable access to disjoint portions values stored in a hash map
-
geo-visibility
Compute visibility polygon
-
consistent-rs
Consistent hash package for Rust
-
statechart
statecharts: hierarchical, reactive state machines
-
alg_ds
Algorithms & data structures
-
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. -
rusty_grammar
A modified CYK algorithm to work for Language
-
external_set
A set with externally-owned items, designed for managing subscribers, clients, listeners, or observers across threads. Inserting an item returns an ItemOwner that removes the item when dropped.
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
invisible-snake
A building block for high-performant graph algorithms
-
noice
Fork of noise-rs, a procedural noise generation library
-
heapp
Some heap operations on slice
-
rast
A toy implementation of the raft consistency protocol focused on speed
-
triangulation
A collection of triangulation algorithms
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
symbolic_polynomials
A library for manipulation of polynomials over the integers
-
prng
pseudo random number generator
-
n18route
Searches 18xx maps for optimal route combinations
-
filter
Kalman filters and other optimal and non-optimal estimation filters in Rust
-
fuzzy-filter
A fast implementation (O(n)) of fuzzy-filtering
-
lindel
A crate for Hilbert and Morton encoding and decoding; in a word, linearising and delinearising
-
abc
An implementation of Karaboga’s Artificial Bee Colony algorithm
-
maze_generator
A library of different maze generation algorithms
-
numext-fixed-hash-hack
A internal crate used by numext-fixed-hash
-
rustmt
A MT19937 PRNG implementation for rust
-
sdbm
SDBM is a non-cryptographic hashing algorithm
-
phreak_rules
Rule matching algorithm focussed on speed
-
deepmesa-encoding
A collection of data structures and algorithms designed for performance
-
crc32c-hw
Hardware-accelerated (SSE 4.2) implementation of CRC32C with software fallback
-
iterative_methods
Iterative methods and associated utilities as StreamingIterators
-
non-dominated-sort
Fast Non-Dominated Sort Algorithm
-
sort-rs
A crate exposing sorting algorithms
-
polylabel-mini
[Fork of polylabel-rs] A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions
-
reingold-tilford
A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
redblackbst
Rust Algorithms
-
crc24
CRC-24 implementation (IETF RFC2440-compatible)
-
goertzel
An implementation of Goertzel’s Algoritm
-
fastcmp
A fast byte slice comparison library
-
raftmodel
A logic model for the raft consensus algorithm
-
aristeia
An evolutionary computation library
-
enso-shapely-macros
Automated typeclass derivation
-
tonemap
A collection of tonemapping algorithms
-
soundchange
Tool for implementing sound change algorithms in Rust
-
radixal
Digits iteration for unsigned integer types
-
cumsum
Cumulative sum
-
dia-range
Ranges for all integers
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
hyperbitbit
Implementation of HyperBitBit data structure
-
primitive_traits
Traits over primitive types. Particularly stuff not covered by num-*.
-
galil-seiferas
General string search in constant space, linear time, for nonorderable alphabets
-
msws
Middle Square Weyl Sequence pseudorandom number generator
-
dft
The package provides an algorithm to compute the discrete Fourier transform
-
building_blocks_core
The core data types for defining 2D and 3D integer lattices
-
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
-
rle-bitset
A no-std, no-alloc trait for querying and manipulating bits in a
[usize]and iterating their run lengths -
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
dusk-schnorr
A pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally
-
rs-graph-derive
Automatic implementation of graph types
-
moving-least-squares
Image deformation using moving least squares
-
dancing-links
Exact cover solver using dancing links technique
-
bstr_parse
Adds the ability to parse numbers out of
&[u8]s -
quadtree-f32
Simple, dependency-free ID-based quadtree
-
hamming-heap
Amortized constant time min heaps for binary features in nearest neighbor searches
-
nd_array
Crate for linear algebra that tries to have a similar api to numpy
-
sift4
This crate provides the sift4 string distance algorithm. It is very fast and returns results similar to levenshtein
-
idalloc
A library for different methods of allocating unique identifiers efficiently
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
gearhash
Fast, SIMD-accelerated hash function for content-defined chunking
-
editdistancewf
Compute the edit-distance between vectors using the Wagner-Fischer algorithm
-
tilecover
Generate the minimum number of tiles to cover a geometry
-
pattern-matching
Pattern matching and full-text index algorithms
-
generic-floyd-warshall
A generic implementation of the Floyd-Warshall algorithm for array-like types
-
crcxx
universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms
-
chalk-macros
Macros for Chalk
-
rstat
Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
eom
Configurable ODE/PDE solver
-
bit-vec
A vector of bits
-
bruteforce
This is a no_std-compatible brute force/string generation rust-nightly library
-
tinysort
The lowest memory footprint sorting algorithm
-
quadtree_rs
Point/region Quadtree with support for overlapping regions
-
state_machine
Simple state machine
-
bitwise
Portable high-level bitwise manipulation algorithms
-
gbps
Rust implementation of gossip-based peer sampling
-
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
-
streamlined-ntru-prime
Rust implementation of the Streamline NTRU Prime algorithm
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
gestalt_ratio
Calculate the gestalt pattern matching ratio between two strings
-
geo-offset
Add margin and padding to geometric shapes
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
linear_solver
A linear solver designed to be easy to use with Rust enum expressions
-
integrators
Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators
-
momba-explore
State space exploration engine for PTAs and MDPs augmented with variables
-
indexed_bitvec_core
Core operations on indexed bitvectors including (hopefully) fast rank and select operations
-
dary
This crate provides double-array construction and search functions
-
xoroshiro
Xoroshiro128+, xorshift1024*φ and splitmix64 random number generators
-
diffus
Finds the difference between two instances of any data structure. Supports: collections, Strings, Maps etc. Uses LCS where applicable. Also supports derive via
diffus-derive. -
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
kdvtree
K-dimensional tree space-partitioning data structure
-
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…
-
algosort
Implementation of sorting algorithms
-
sorting_explorer
An exploration of various sorting algorithms
-
bresenham
A fast, iterator-based integer-only implementation of Bresenham’s line algorithm
-
polytope
Data structures and methods for constructing polytopes
-
qht
Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc
-
safe-modular-arithmetic
Implementation of modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
onemax-oxigen
OneMax simple problem resolution using oxigen
-
digits_iterator
Iterate over the digits of numbers in an arbitrary radix
-
numext-fixed-uint-core
A internal crate used by numext-fixed-uint
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
crc8
A CRC8 implementation
-
byond-crc32
Fast CRC-32/BYOND checksum computation
-
rand_num_gen
random number generator trait
-
squares-rnd
Simple and fast counter based non-crypto random generator
-
rand_xorshift
Xorshift random number generator
-
rand_seeder
A universal random number seeder based on SipHash
-
max-subarray-sum
Finds the maximum subarray sum in a list
-
jeans
Genetic algorithms
-
sorted-rotated
Finds a number in a sorted and rotated list in O(logN) time
-
compressible-map
A hash map that allows compressing the least recently used values
-
n18map
Manages the state of 18xx maps
-
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