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