-
rand
Random number generators and other randomness functionality
-
memchr
Safe interface to memchr
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
twox-hash
A Rust implementation of the XXHash and XXH3 algorithms
-
crc
Rust implementation of CRC(16, 32, 64) with support of various standards
-
rand_isaac
ISAAC random number generator
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
crc32fast
Fast, SIMD-accelerated CRC32 (IEEE) checksum computation
-
crc-any
To compute CRC values by providing the length of bits, expression, reflection, an initial value and a final xor value. It has many built-in CRC functions.
-
adler32
Minimal Adler32 implementation for Rust
-
k
k is for kinematics
-
fake
An easy to use library for generating fake data like name, number, address, lorem, dates, etc
-
pathfinding
Pathfinding, flow, and graph algorithms
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
fastrand
A simple and fast random number generator
-
ultraviolet
A crate to do linear algebra, fast
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
oorandom
A tiny, robust PRNG implementation
-
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
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
ncollide3d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
rustc-hash
speed, non-cryptographic hash used in rustc
-
integer-sqrt
An implementation of integer square root algorithm for primitive rust types
-
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
jubjub
Implementation of the Jubjub elliptic curve group
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
numext-constructor
Fixed-size uint and hash constructor
-
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.
-
numext-fixed-uint
Fixed-size uint types
-
whatlang
Natural language detection library. Identifies language of a given text.
-
levenshtein
Levenshtein algorithm
-
passwords
This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them
-
bitpacking
Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.
-
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, …
-
rdrand
An implementation of random number generator based on rdrand and rdseed instructions
-
highway
Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
governor
A rate-limiting implementation in Rust
-
noise
Procedural noise generation library
-
radiate
Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems
-
md5
The package provides the MD5 hash function
-
screwsat
A simple condlict driven clause learning sat solver
-
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
-
rsgenetic
A library providing genetic algorithm execution
-
rust-lapper
A fast and easy interval overlap library
-
regex-syntax
A regular expression parser
-
ff
Library for building and interfacing with finite fields
-
roots
Library of well known algorithms for numerical root finding
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
fastcdc
FastCDC (content defined chunking) in pure Rust
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
counting_sort
Counting sort implementation for Iterators
-
robust
Robust adaptive floating-point predicates for computational geometry
-
rand_regex
Generates random strings and byte strings matching a regex
-
rand_core
Core random number generator traits and tools for implementation
-
multihash
Implementation of the multihash format
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
adler
A simple clean-room implementation of the Adler-32 checksum
-
slice-group-by
Iterators over groups in a slice
-
twoway
Fast substring search for strings and byte strings. Optional SSE4.2 acceleration (if detected at runtime) using pcmpestri. Memchr is the only mandatory dependency. The two way algorithm…
-
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
wyhash
Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
quantiles
a collection of approximate quantile algorithms
-
poi
A pragmatic point-free theorem prover assistant
-
leaky-bucket
Futures-aware rate limiter implementation
-
fsm_gen
FSM (finite state machine) DSL for code generation (c++ at the moment)
-
wildmatch
Simple string matching with questionmark and star wildcard operator
-
is_sorted
Is an Iterator sorted?
-
lfest
A leveraged perpetual futures exchange for simulated trading is a high performance backtesting exchange
-
median
An implementation of an efficient O(n) median filter
-
rust-stemmers
A rust implementation of some popular snowball stemming algorithms
-
probability
The package provides a probability-theory toolbox
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
nonogrid
Efficient nonogram solver
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
simsearch
A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)
-
extindex
Persisted immutable index
-
dissimilar
Diff library with semantic cleanup, based on Google’s diff-match-patch
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
bitintr
Portable Bit Manipulation Intrinsics
-
unicode-bidi
Implementation of the Unicode Bidirectional Algorithm
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
muldiv
Provides a trait for numeric types to perform combined multiplication and division with overflow protection
-
rand_mt
Reference Mersenne Twister random number generators
-
strength_reduce
Faster integer division and modulus operations
-
contest-algorithms
Common algorithms and data structures for programming contests
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
streamline
Reversible futures::Stream-based state machines
-
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
-
graphplan
Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
out
Provides fast min and max functionality for collections
-
permutator
Get a lexicographic cartesian product and lexicographic permutation at any specific index from data. Generate complete lexicographic cartesian product from single or multiple set of data…
-
cdchunking
Content-defined chunking
-
metrohash
Rust implementation of MetroHash, a high quality, high performance hash algorithm
-
geometry-predicates
A Rust port of robust geometric predicates
-
worley-noise
Worley noise implementation
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
yada
Yada is a yet another double-array trie library aiming for fast search and compact data representation
-
random-pick
Pick an element from a slice randomly by given weights
-
flo_curves
Library for manipulating Bezier curves
-
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
-
linked_hash_set
HashSet with insertion ordering
-
bishop
Library for visualizing keys and hashes using OpenSSH’s Drunken Bishop algorithm
-
cdshealpix
Rust implementation of the HEALPix tesselation
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
intersect2d
Line segment intersection detection
-
dusk-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
broccoli
broadphase collision detection algorithms
-
vsprintf
Rust bindings to the libc vsprintf function
-
extendhash
Rust Hash Extender
-
bao
a general-purpose cryptographic tree hash
-
hnsw
Fast approximate nearest neighbors
-
microfft
Embedded-friendly Fast Fourier Transforms
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
gcd
Small Rust library (with no dependencies) for calculating greatest common divisor
-
rrt
Path finding using dual-RRT connect
-
linregress
ordinary least squared linear regression with some basic statistics
-
treediff
Find the difference between arbitrary data structures
-
rs-graph
A library for graph algorithms and combinatorial optimization
-
boyer-moore-magiclen
Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust
-
sobol
A Sobol sequence generator for Rust
-
md6
Implementation of the MD6 hash function for Rust via FFI
-
test-data-generation
A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data
-
id_tree_layout
A library to visualize trees from the ‘id_tree’ crate
-
simplers_optimization
A Rust implementation of the Simple(x) black-box optimization algorithm
-
pikkr-annika
JSON Parser which picks up values directly without performing tokenization in Rust. Reuploaded by Annika due to her compile problems.
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
frank_jwt
Implementation of JSON JWT
-
nlopt
Wrapper for the nlopt library
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
vrp-pragmatic
An extension logic for solving rich VRP
-
rake
Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm
-
faiss
High-level bindings for Faiss, the vector similarity search engine
-
flo_binding
Declarative binding library for Rust
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
munkres
Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)
-
accurate
(more or less) accurate floating point algorithms
-
cap-rand
Capability-oriented random number generators
-
hybrid-clocks
Hybrid Logical Clocks
-
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…
-
fakeit
Fake data generator library with 130+ functions
-
convert-base
convert the radix (base) of digits stored in a vector
-
ahrs
A Rust port of Madgwick’s AHRS algorithm
-
magpie
Reasonably efficient Othello library built with bitboards
-
hungarian
A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
color_space
library for converting between color spaces and comparing colors
-
matchit
A high performance URL path (route) matcher based on a radix tree
-
fallible-iterator
Fallible iterator traits
-
tokenizations
Tokenizations alignments library
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
hierarchical_pathfinding
A crate to quickly approximate Paths on a Grid
-
crc16
A CRC16 implementation
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
rexl
A simple algorithm library for Rust
-
consistent_hash_ring
A flexible and efficient consistent hash ring
-
astro
Advanced algorithms for astronomy
-
nohash-hasher
An implementation of
std::hash::Hasherwhich does not hash at all -
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
partition
partition slices in-place by a predicate
-
osqp
The OSQP (Operator Splitting Quadratic Program) solver
-
superslice
Extensions for slices
-
hyperloglogplus
HyperLogLog implementations
-
punkt
An implementation of a Punkt sentence tokenizer
-
rust-3d
2D/3D library written in rust
-
flat_spatial
Flat spatial partitionning algorithms and data structures
-
levenberg-marquardt
Levenberg-Marquardt algorithm built on top of nalgebra
-
pubgrub
PubGrub version solving algorithm
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
xxhash-rust
Implementation of xxhash
-
varint-rs
A small, zero dependency varint implementation in Rust
-
maglev
Maglev - Google’s consistent hashing algorithm
-
bromberg_sl2
Cayley hashing as in ‘Navigating in the Cayley Graph of SL₂(𝔽ₚ)’
-
rendezvous_hash
An implementation of Rendezvous hashing algorithm
-
coord_transforms
A Rust crate use for performing coordinate transformations
-
safe-mix
Implementation of the Collective Coin Flip algorithm
-
lol-core
A Raft implementation in Rust language
-
glass_pumpkin
A cryptographically secure prime number generator based on rust’s own num-bigint and num-integer
-
gut
Geometry utilities: storing, manipulating and processing geometries
-
eddie
Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler
-
pcg_rand
An implementation of the PCG family of random number generators in pure Rust
-
rtbvh
BVH library with various build algorithms and support for packet traversal
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
poker
A crate for speedy poker hand evaluation
-
color-thief
Grabs the dominant color or a representative color palette from an image
-
detect-lang
Language detection given paths and extensions
-
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
building_blocks_procgen
Algorithms for procedural generation of voxel data
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
rulinalg
A linear algebra library
-
multistream-batch
Implementations of batching algorithms
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
enso-prelude
An augmented standard library in the vein of Haskell’s prelude
-
glicko2
Implementation of the glicko2 rating system
-
colors-transform
Module for convert and transform colors
-
programinduction
A library for program induction and learning representations
-
twofloat
Double-double arithmetic functionality
-
seqdiff
Diff between two sequences
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
xorf
Library implementing xor filters - faster and smaller than bloom and cuckoo filters
-
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
-
dasp_interpolate
An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc
-
pagino
Handle pagination’s logic
-
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.
-
iter-set
Set operations on sorted, deduplicated iterators
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
enso-shapely
Automated typeclass derivation
-
circbuf
A growable circular buffer for working with bytes
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
kendalls
Kendall’s tau rank correlation
-
nqueens-oxigen
N Queens problem resolution using oxigen
-
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…
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.
-
pikkr
JSON Parser which picks up values directly without performing tokenization in Rust
-
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
endicon
Implementations of codicon traits for endianness encodings
-
symspell
Spelling correction & Fuzzy search
-
stack
DSTs and arrays on the stack!
-
extprim
Extra primitive types (u128, i128)
-
xoroshiro128
Fast psuedo-random number generators
-
sorts
A collection of sorting algorithms
-
friedrich
Gaussian Process Regression
-
arc-interner
An interner that deallocates unused values
-
rusty_planner
Artificial intelligence planning & reasoning library for Rust
-
leaky-bucket-lite
Slimmed down, lazy futures-aware rate limiter implementation
-
vrf
Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves
-
bibicode
A crate to convert any integer from one numeral system to another
-
special
The package provides special functions
-
toposort-scc
An implementation of Kahn’s algorithm for topological sorting and Kosaraju’s algorithm for strongly connected components
-
xxhrs
Safe XXHash and XXH3 bindings
-
nanoid
A tiny, secure, URL-friendly, unique string ID generator for Rust
-
beehave
A simple library for defining and evaluating a hierarchical state machine (behaviour tree)
-
grb
A Rust API for Gurobi optimizer
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
mikktspace
Mikkelsen tangent space algorithm
-
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…
-
zeros
Keccak implementation
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
hyperbitbit
Implementation of HyperBitBit data structure
-
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.
-
gurobi
An unofficial Rust API for Gurobi optimizer
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
sub-strs
For finding sub strings
-
cauchy
Trait for real and complex numbers
-
historian
a high performance zero-config histogram implementation
-
codebreaker
Decrypt & encrypt any cheat code for CodeBreaker PS2
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
avalog
An experimental implementation of Avatar Logic with a Prolog-like syntax
-
qframework
A experimental micor framework for clear design, based on queue model
-
diffr-lib
An implementation of Myers diff algorithm
-
murmur3
A rust implementation of Murmur3 hash
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
iterslide
A “sliding window” iterator
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
meowhash
Meow hash function
-
probminhash
Minhash algorithms for weighted Jaccard index
-
line-col
Convert string slice indices into line/column numbers
-
raft
The rust language implementation of Raft algorithm
-
names
A library to generate random name strings suitable for use in container instances, project names, application instances, etc
-
uaparser
A Rust implementation of the UA Parser
-
lv03
Conversion between the Swiss coordinate system (LV03/CH1903 or LV95/CH1903+) and WGS84 coordinates
-
nuid
A highly performant unique identifier generator
-
acacia
A spatial partitioning and tree library
-
paginator
This crate is used for generating pagination bar
-
textnonce
Text based random nonce generator
-
lfu
An LFU cache implementation
-
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)…
-
batsat
Extensible SAT solver in Rust
-
poisson-diskus
Poisson disk distribution sampling
-
rustlex_fsa
Library for manipulating (deterministic) finite automata
-
geos-sys
GEOS C API bindings
-
count-min-sketch
Count-min-sketch implementation
-
faiss-sys
Native bindings for Faiss
-
utm
Convert latitudes and longitudes to UTM coordinates
-
tailcall
Safe, zero-cost tail recursion
-
dusk-poseidon
Implementation of Poseidon hash algorithm over the Bls12-381 Scalar field
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
clock-zones
A library for handling clock zones
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
darwin-rs
Evolutionary algorithms library written in Rust
-
toolbox
Simple tools for daily use
-
vec-drain-where
alternative
Vec::drain_filterimpl -
gossip
A generic gossip library that uses gossip-based peer sampling
-
graph-neighbor-matching
Graph similarity score using neighbor matching
-
refset
A non-owning HashSet
-
rand_chacha
ChaCha random number generator
-
java_random
The java LCG and random module implementation in rust
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
external_sort
Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS
-
baseperm
A tool for generating valid permutations of encoded inputs
-
qptrie
A QP-Trie implementation for Rust
-
bufferpool
A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions
-
benchfun
Benchmarking functions to use for optimization algorithms
-
geo-clipper
Boolean operations on polygons
-
appr_dbscan_rust
Rust implementation of the approximated DBSCAN algorithm introduced by Gan and Tao
-
macro_machine
State machine generator using macros
-
IntegerScaling
Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
debouncr
A simple no-std input debouncer to detect rising and falling edges with minimal RAM requirements
-
fxtypemap
A fast type map based on internal hasher used in Firefox and Rustc
-
trade_aggregation
Aggregate raw trades into candles using different methods
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
symmetric-shadowcasting
Simple implementation of the shadow casting FOV algorithm
-
zerobuf
A growable chunk of zeroed memory
-
distance
A collection of approximate string matching algorithms
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
conshash
A library to do consistent hashing in Rust
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
sort-it
Various sorting algorithms
-
rdx
A collection of traits and algorithms to ease using radix sorts
-
svg2polylines
Convert SVG data to a list of polylines (aka polygonal chains or polygonal paths)
-
rootfind
Root-finding algorithms
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
censor
A simple text profanity filter
-
tiny_tco
A tiny dirt simple no_std tail call optimization library
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters’s pdqsort
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
inohashmap
fast and efficient insert only string hashmap
-
permutation
Small utility for creating, manipulating, and applying permutations
-
imgthin
A fast parallel algorithm for thinning digital patterns
-
rtriangulate
Delaunay triangulation on a set of points
-
ostn02_phf
A PHF map of the OSTN02 grid shifts for use in transforming ETRS89 grid coordinates to OSGB36
-
vecshard
Split Vecs in constant time
-
visionmagic
Collection of vision & graphics algorithms
-
numext-fixed-uint-hack
A internal crate used by numext-fixed-uint
-
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
probably
A library with various approximate computing algorithms
-
library_of_babel
Implementation of Library of Babel in Rust
-
mersenne_twister
Mersenne Twister pseudorandom number generator
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
algos
A collection of algorithms in Rust
-
backtrack
Solve hard constraints easily
-
halton
A module for generating Halton sequences
-
fossil-delta
Provides functions for calculating differences between strings and applying calculated deltas
-
ca-formats
Parsing pattern files for Conway’s Game of Life
-
addchain
Generate addition chains
-
indented-blocks
parser for indented blocks
-
human-sort
Human sort (natural sort) implementation
-
zvxryb-broadphase
A broadphase collision detection library
-
overlord
Overlord consensus procotol
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
quasirandom
Quasirandom number generation
-
moodyblues-sdk
A tracer SDK for Overlord like consensus algorithm
-
bravery_router
Radix Tree implementation
-
uncertain
Fast and correct computations with uncertain values
-
rl-bandit
A simple multi-armed bandit implementation
-
phreak_rules
Rule matching algorithm focussed on speed
-
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
-
collision
A collision extension to cgmath
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
filter
Kalman filters and other optimal and non-optimal estimation filters in Rust
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
acap
As Close As Possible — nearest neighbor search in Rust
-
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. -
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
gear
Collision avoidance path planning for robotics
-
buldak
It is a library that provides various sorting functions
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
rand_distr
Sampling from random number distributions
-
rust-algorithm
algorithm
-
concorde
reconfigurable lattice agreement
-
sprs-ldl
Sparse cholesky factorization
-
bsa3-hash
The hash function used in BSA files for The Elder Scrolls III: Morrowind
-
hilbert
Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
wy
Rust implementation of wyhash algorithms
-
buf-min
Minimal buffer traits
-
dedup_signature
This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
sample_planning
Sample Based Planner
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
subslice
Fast subslice search
-
lttb
An implementation of the Largest Triangle Three Buckets algorithm
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
blake
Implementation of the BLAKE hash function for Rust via FFI
-
supermemo2
A simple crate that implements the supermemo2 spaced repetition algorithm
-
traversal
Generic and lazy tree traversal algorithms
-
fastvlq
A fast variant of Variable-Length Quantity with a focus on speed and no_std support
-
phi-detector
An Implementation of Phi Accrual Failure Detector
-
gitignored
A Rust implementation of the gitignore algorithm
-
fang_oost
A library implementing Fang and Oosterlee’s algorithm for inverting characteristic functions
-
noisy
A procedural noise generation library written for Rust
-
hutton-rust
The Hutton cipher implemented as a Rust crate
-
summed-area-table
Implementation of a summed area table
-
statistical
A simple statistics library
-
fuss
Small, lightweight simplex noise generator for Rust
-
delaunay2d
A library to compute Delaunay triangulations and Voronoi diagrams in 2D space
-
genevo
genevo provides building blocks to run simulations of optimization and search problems using genetic algorithms (GA). Execute genetic algorithm (GA) simulations in a customizable and extensible way
-
numcmp
Comparison between differently typed numbers
-
competitive-hpp
Competitive Programming Library for AtCoder with Rust
-
atomic-traits
The traits for generic atomic operations
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
english-numbers
Convert integers to written English number format
-
permutation_iterator
A Rust library for iterating over random permutations using O(1) (i.e. constant) space.
-
fsm-rust-jb
Simple FSM (with effects, like Mealy machine) implementation in Rust
-
statest
Rust crate for statistical test
-
search-autocompletion
A Rust implementation of Search Auto Completion
-
html2pango
Library to convert html to pango
-
coloring
Convert values to color simply and securely
-
trassel
Unique ID integers that scale
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
nats-types
Enumerations and types for representing NATS protocol messages
-
fast_inv_sqrt
Fast inverse square root algorithm implementation
-
xorshift128plus-rs
A simple implementation of the XorShift128+ pseudorandom number generator in Rust
-
xorshift
Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators
-
fuzzy_dbscan
An implementation of the FuzzyDBSCAN algorithm
-
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
pso
Particle Swarm Optimizer
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
eight-point
Eight-point algorithm for essential matrix estimation
-
lis
Longest increasing subsequence algorithm
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
uhttp_body_bytes
Iterator for HTTP request body bytes
-
livesplit-title-abbreviations
livesplit-title-abbreviations encapsulates the algorithm that LiveSplit uses to abbreviate game titles
-
krator
A Kubernetes operator implementation in Rust
-
cutter
A simple usefull functions for parsing text. Used for cutting between strings.
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
phpass
PHPass, the WordPress password hasher, re-implemented in rust
-
hamt-rs
A Hash Array Mapped Trie implementation based on the Ideal Hash Trees paper by Phil Bagwell
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
lambert
lamber-rust is a crate helping to convert Lambert coordinates to WGS84
-
tonemap
A collection of tonemapping algorithms
-
noice
Fork of noise-rs, a procedural noise generation library
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
raftlog
An implementation of distributed replicated log based on the Raft algorithm
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
hashring
A minimal implementation of consistent hashing
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
pdqsort
Pattern-defeating quicksort
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
spherical_blue_noise
Blue noise generator on a sphere
-
count_sort
O(n) sorting library for large datasets with small range of possible values
-
modulo
Simple modulo operation
-
algebraics
algebraic numbers library
-
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
-
rational_deduction
Rust implementation of the rational deduction algorithm
-
just-argon2
Bindings to the argon2 C library
-
rosalind-cli
CLI for
rosalindcrate -
rand04_compat
Wrappers for compatibility with rand 0.4
-
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
-
srand
Random number generators and other randomness functionality with simple apis to use
-
etagere
Dynamic 2D texture atlas allocation using the shelf packing algorithm
-
ai_kit
Collection of classic AI algorithms with convenient interfaces
-
rustfft
High-performance FFT library written in pure Rust
-
kahan
Provides types to perform Kahan summation
-
sep-sys
Low-level bindings to SEP - C library for Source Extraction and Photometry
-
rjq
Redis job queue
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
spiral
Iterate over a 2D structure in a spiral pattern
-
checksum
Calculates crc32/crc64 file checksums written in Rust
-
robust-binary-search
Robust Binary Search provides a binary search implementation which is robust against errors during the search
-
cdivsufsort
Rust bindings for Yuta Mori’s divsufsort
-
bidir-map
Bidirectional map implementation for Rust
-
czt
The package provides an algorithm to compute the chirp Z-transform
-
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)…
-
needle
Fast search functions for finding things in Strings, Arrays and iterators
-
nohash
An implementation of
std::hash::Hasherwhich does not hash at all -
dia-range
Ranges for all integers
-
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.
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
djb33
DJB33 hash algorithm write in Rust
-
bls-signatures-rs
Open source implementation of Bonneh-Lynn-Shacham (BLS) signatures written in Rust
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
optimization
Collection of optimization algorithms
-
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
-
fera
An aggregation of algorithms, data structures and supporting crates
-
maze_generator
A library of different maze generation algorithms
-
midas_rs
Rust lib port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
libblockchain
A Blockchain implementation
-
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.
-
starts-ends-with-caseless
This crate provides the
StartsWithCaselesstrait and theEndsWithCaselesstrait to extend types which implementAsRef<str>in order to dostarts_withandends_withcase-insensitively -
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
rusty_state
A simple state machine for rust
-
mecs
An ecs library with a focus on iteration performance
-
aliasmethod
Implementation of Walker’s Alias method
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
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!
-
persistent
A set of middleware for sharing server-global data in Iron
-
wkb
Convert geo-types from georust to/from Well Known Binary
-
blurhash
A pure Rust implementation of blurhash
-
reingold-tilford
A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
dekker
Implementation of Dekker’s algorithm for mutual exclusion
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
qrs_detector
Realtime ECG QRS detector algorithm
-
tars
A Rust library providing useful technical indicators
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
floyd-warshall-alg
Floyd-Warshall algorithm supporting customization
-
delaunator
A very fast 2D Delaunay triangulation library
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
dinotree_alg
Dinotree algorithms
-
pattern-matching
Pattern matching and full-text index algorithms
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
fractal
The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes
-
bstr_parse
Adds the ability to parse numbers out of
&[u8]s -
sorting_explorer
An exploration of various sorting algorithms
-
hotsax
An implementation of the HOTSAX and HOTSAX based discord discovery algorithms
-
fabrik
Implementation of FABRIK (Forward And Backward Reaching Inverse Kinematics) IK algorithm
-
randge
Generate unique random numbers
-
dubble
A generic implementation of double-buffering
-
spmc_buffer
An extension of triple buffering for multiple-consumer scenarios, useful for sharing frequently updated data between threads
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse’s LDL algorithm
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
barnes
A multithreaded Barnes Hut Algorithm implementation
-
newton_rootfinder
Newton based methods for root finding
-
fxsm
A state machine procedural macro for enums
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
rustimization
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
wookong-solo
Wookong Solo driver crate
-
sorting
The world’s best, finest and inefficient sorting algorithms
-
rustmt
A MT19937 PRNG implementation for rust
-
kmpsearch
String/Byte pattern searching within byte slices or strings, using the Knuth Morris Pratt algorithm
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
poisson2d
Poisson disk sampling generator
-
co_sort
Sort arrays given a permutation
-
every-range
Iterator for interleaving included and excluded ranges
-
quadtree-f32
Simple, dependency-free ID-based quadtree
-
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.
-
rustomaton
A small Rust library for automaton (DFA, NFA, Regex) manipulation
-
hostlist-parser
Parses hostlist expressions into a Vec of Strings
-
tdigest
T-Digest algorithm in Rust
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
smeagol
Conway’s Game of Life using HashLife and SIMD
-
microstate
Finite state machine, inspired by micromachine
-
streamhist
Implementation of streaming histogram
-
tilecover
Generate the minimum number of tiles to cover a geometry
-
plumtree
A Rust implementation of Plumtree algorithm
-
cloth_bumpmap
Creates a bump map used in the clothify algorithm in GIMP (GNU Image Manipulation Program)
-
smbus-pec
Minimal portable implementation of SMBus Packet Error Code calculation algorithm
-
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
crfs
Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)
-
rusty_grammar
A modified CYK algorithm to work for Language
-
rusthotp
A simple, pure Rust implementation of the HMAC-based One-Time Password algorithm specified in RFC 4226
-
gpu-sw
GPU-SW, GPGPU-enabled SW algorithm
-
kddbscan
A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)
-
num-cmp
Comparison between differently typed numbers
-
raft-proto
Protocol definitions for the rust language implementation of the Raft algorithm
-
dubins_path
Dubins Path pathfinding algorithm
-
primitive_traits
Traits over primitive types. Particularly stuff not covered by num-*.
-
pollard-p-minus-one
An implementation of Pollard’s p-1 factoring algorithm
-
rustotp
A simple, pure Rust implementation of the Time-Based One Time Password (TOTP) algorithm specified in RFC 6238
-
astar
A generic implementation of the A* pathfinding algorithm
-
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
rast
A toy implementation of the raft consistency protocol focused on speed
-
soundchange-english
Reimplementation of Mark Rosenfelder’s pronunciation algorithm for English
-
cplex-sys
Low level bindings to the Cplex C-API
-
fastcmp
A fast byte slice comparison library
-
multistochgrad
Stochastic Gradient, Multithreaded
-
rle-bitset
A no-std, no-alloc trait for querying and manipulating bits in a
[usize]and iterating their run lengths -
ntru
Implementation of the NTRUEncrypt algorithm. Interface to libntru.
-
rustbox
A rust implementation of the termbox library
-
aviary
Aviary bird combinators for Rust
-
gestalt_ratio
Calculate the gestalt pattern matching ratio between two strings
-
two-lock-queue
A MPMC channel based on the michael-scott two lock queue algorithm
-
arborist
A surgical tool for interacting with binary trees
-
vrp-scientific
An extension logic for solving scientific VRP
-
ordist
Order distance package
-
revonet
Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
gray-codes
Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection
-
indexed_bitvec_core
Core operations on indexed bitvectors including (hopefully) fast rank and select operations
-
phreak_facts
Rule matching algorithm focussed on speed
-
librualg
Collection of basic algorithms for everyday development
-
random-trait
Rust library for a random trait meant to produce random generic types
-
labelgraph
A simple to use graph implementation, allowing random access to nodes via labels
-
kmeans
Small and fast library for k-means clustering calculations
-
weighted-rs
A libray for weighted balancing algorithm
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
dancing-links
Exact cover solver using dancing links technique
-
abc
An implementation of Karaboga’s Artificial Bee Colony algorithm
-
broadword
Broadword algorithms
-
vose-alias
An implementation of the Vose Alias method to sample an element out of a list, given a discrete probablity distribution
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
fuzzy-filter
A fast implementation (O(n)) of fuzzy-filtering
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
rijksdriehoek
Convert coordinates between rijksdriehoek and wgs84
-
quicksort
A quicksort implementation for in-place sorting
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
squares-rnd
Simple and fast counter based non-crypto random generator
-
algo
Algorithms & Data Structure implementations
-
t1ha
An implementation of the T1AH (Fast Positive Hash) hash function
-
quadtree_rs
Point/region Quadtree with support for overlapping regions
-
simple_gaussian
Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.
-
human_bytes
Crate to convert bytes into human-readable values
-
numlib
A simple numerical library implementing common numberical algorithms in rust
-
ttlhashmap
Optionally bounded HashMap-like container with decaying nodes
-
pack
Solver for packing puzzle
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
lz_eytzinger_tree
An Eytzinger tree implementation, this is an N-tree implemented using array storage
-
algorithmica
Rust Algorithms
-
omnitigs
Omnitig-related algorithms
-
polystem
Popular stemming algorithms for Information Retrieval
-
fastblur
Linear-time gaussian blur
-
scarecrow
A neural network library
-
gen-combinations
A general combination generator
-
handletree-rs
Helps you implement handle-based APIs
-
cogset
Generic implementations of clustering algorithms. Includes k-means, DBSCAN and OPTICS.
-
alg_ds
Algorithms & data structures
-
consistent-rs
Consistent hash package for Rust
-
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…
-
machinebox
A client SDK for communicating with machinebox boxes
-
criterion-stats
Criterion’s statistics library
-
nblast
Implementation of NBLAST neurite similarity algorithm
-
td_rthreadpool
thread wrapper for Rust
-
xoroshiro
Xoroshiro128+, xorshift1024*φ and splitmix64 random number generators
-
rure
A C API for Rust’s regular expression library
-
dists
2d distribution generator
-
hilbert_curve
A simple implementation of Hilbert curve mapping algorithms in Rust
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
tiamat
a PRNG library
-
building_blocks_search
Search algorithms for voxel data
-
enso-optics
An implementation of functional optics
-
nlsn-delaunay
Delaunay Triangulation and Refinement implementation through Bowyer Watson incremental insertion, conflict maps and ghost vertices
-
octree
Octree algorithm for nearest neighbor search in 3D space
-
xxh
XXHash algorithm implementation for Rust
-
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.
-
wuf
A fast weighted implementation to the union-find problem with path compression
-
debtsolver
Track and settle debts between parties with the fewest transactions
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
convute
Conversion between types with overlapping valid bit patterns and arrays, vecs and slices of those values
-
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
-
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.
-
nuban_rust
A validator and generator of Nigerian Uniform Bank Account Number(NUBAN)
-
basic-hll
The basic HyperLogLog algorithm
-
radixal
Digits iteration for unsigned integer types
-
ordslice
Extensions for ordered slices
-
gbps
Rust implementation of gossip-based peer sampling
-
gearhash
Fast, SIMD-accelerated hash function for content-defined chunking
-
fletcher
An implementation of Fletcher’s Checksum algorithm in rust
-
endian-hasher
Endianness wrapper for Hashers
-
bsdiff
Rust port of the bsdiff binary diffing algorithm
-
numext-fixed-uint-core
A internal crate used by numext-fixed-uint
-
crc32c-hw
Hardware-accelerated (SSE 4.2) implementation of CRC32C with software fallback
-
perm
Permutation iterator
-
sfmt
Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)
-
statechart
statecharts: hierarchical, reactive state machines
-
largest-remainder-method
The largest remainder method
-
bgjk
Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect
-
hyparview
A Rust implementation of HyParView algorithm
-
momba-explore
State space exploration engine for PTAs and MDPs augmented with variables
-
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
-
prng
pseudo random number generator
-
triangulation
A collection of triangulation algorithms
-
shaman
A pure-Rust, cross-platform implementation of various common hashing algorithms
-
cuckoo
Cuckoo search algorithm
-
stream_histogram
a rust library for efficient histogram approximations
-
polylabel-mini
[Fork of polylabel-rs] A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions
-
numext-fixed-hash
Fixed-size hash types
-
audiograph
An audio graph optimised for performance and limiting runtime allocations
-
map_split
A library providing simultaneous mutable access to disjoint portions values stored in a hash map
-
iobuffer
A simple memory-based buffer for IO reading and writing
-
symbolic_polynomials
A library for manipulation of polynomials over the integers
-
bruteforce
This is a no_std-compatible brute force/string generation rust-nightly library
-
truck-polymesh
defines polygon data structure and some algorithms handling mesh, including meshing the shapes
-
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
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
crcxx
universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms
-
dary
This crate provides double-array construction and search functions
-
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
-
seal
Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
rstat
Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures
-
sdbm
SDBM is a non-cryptographic hashing algorithm
-
aristeia
An evolutionary computation library
-
goertzel
An implementation of Goertzel’s Algoritm
-
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
streamlined-ntru-prime
Rust implementation of the Streamline NTRU Prime algorithm
-
non-dominated-sort
Fast Non-Dominated Sort Algorithm
-
rand_xorshift
Xorshift random number generator
-
blossom
Implementation of the Blossom algorithm to get a maximum matching in an undirected graph
-
crc8
A CRC8 implementation
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
lax
LAPACK wrapper without ndarray
-
dusk-hades
Implementation of Hades252 permutation algorithm over the Bls12-381 Scalar field
-
redblackbst
Rust Algorithms
-
soundchange
Tool for implementing sound change algorithms in Rust
-
triangular
A Delauney triangulation library
-
bit-vec
A vector of bits
-
editdistancewf
Compute the edit-distance between vectors using the Wagner-Fischer algorithm
-
highs
Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
state_machine
Simple state machine
-
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
-
sorted-insert
This crate provides traits to insert elements to a sorted collection and keep the order
-
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…
-
rosalind
Crate contains solutions of problems published on Rosalind.info
-
crc24
CRC-24 implementation (IETF RFC2440-compatible)
-
ppom
Left Leaning Red Black index in Rust-lang
-
rand-array-iid
Create arrays whose elements are independently identically distributed
-
rand04
Re-export of rand 0.4, so it can be used together with a later version of rand
-
tailcall-impl
The procedural macro implementation for the tailcall crate
-
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.
-
tinysort
The lowest memory footprint sorting algorithm
-
idalloc
A library for different methods of allocating unique identifiers efficiently
-
maglev_rs
Maglev hashing algo implmentation
-
sharpen
A rust library for iterator element condensing and sharpening
-
voronoi
A library to compute Voronoi diagrams, using Fortune’s sweepline algorithm
-
integrators
Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators
-
rustdct
Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust
-
lyon_algorithms
2D Path manipulation/transformation algorithms
-
rotor
The mio-based framework for doing I/O in simple and composable way
-
jeans
Genetic algorithms
-
qht
Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc
-
crc64
CRC64 checksum implementation
-
eom
Configurable ODE/PDE solver
-
msws
Middle Square Weyl Sequence pseudorandom number generator
-
xxhash-c-sys
Bindings to xxhash
-
async-jobs
Asynchronous job orchestration for Rust
-
pocket_prover-set
A base logical system for PocketProver to reason about set properties
-
hamming-heap
Amortized constant time min heaps for binary features in nearest neighbor searches
-
force_graph
Force-directed graph algorithm
-
generic-floyd-warshall
A generic implementation of the Floyd-Warshall algorithm for array-like types
-
bitwise
Portable high-level bitwise manipulation algorithms
-
marx
a high performance zero-config metric implementation
-
fast-fibonacci
Quickly find nth fibonacci number with modulo. Supports u64 and BigUint.
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
phreak_engine
Rule matching algorithm focussed on speed
-
building_blocks_core
The core data types for defining 2D and 3D integer lattices
-
polytope
Data structures and methods for constructing polytopes
-
textspan
Text span utility