-
rand
Random number generators and other randomness functionality
-
twox-hash
A Rust implementation of the XXHash and XXH3 algorithms
-
fastrand
A simple and fast random number generator
-
crc
Rust implementation of CRC(16, 32, 64) with support of various standards
-
rustfft
High-performance FFT library written in pure Rust
-
xxhash-rust
Implementation of xxhash
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
rand_chacha
ChaCha random number generator
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
rand_distr
Sampling from random number distributions
-
rustc-hash
speed, non-cryptographic hash used in rustc
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
ff
Library for building and interfacing with finite fields
-
fnv
Fowler–Noll–Vo hash function
-
wildmatch
Simple string matching with questionmark and star wildcard operator
-
realfft
Real-to-complex FFT and complex-to-real iFFT for Rust
-
md5
The package provides the MD5 hash function
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
ulid
a Universally Unique Lexicographically Sortable Identifier implementation
-
noise
Procedural noise generation library
-
crc-any
To compute CRC values by providing the length of bits, expression, reflection, an initial value and a final xor value. It has many built-in CRC functions.
-
pathfinding
Pathfinding, flow, and graph algorithms
-
highway
Native Rust port of Google's HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
alphanumeric-sort
This crate can help you sort order for files and folders whose names contain numerals
-
simdutf8
SIMD-accelerated UTF-8 validation
-
rust-lapper
A fast and easy interval overlap library
-
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
type_constructor
Fundamental data types and type constructors, like Single, Pair, Many
-
topological-sort
Performs topological sorting
-
earcutr
port of MapBox's earcut triangulation code to Rust language
-
fastcdc
FastCDC (content defined chunking) in pure Rust
-
pqc_kyber
A rust implementation of the post-quantum Kyber KEM algorithm
-
dusk-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
av-metrics
A collection of algorithms for measuring audio/video metrics
-
gcd
Calculate the greatest common divisor
-
passwords
This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them
-
xorf
Library implementing xor filters - faster and smaller than bloom and cuckoo filters
-
probability
The package provides a probability-theory toolbox
-
naive_opt
The optimized naive string-search algorithm
-
strength_reduce
Faster integer division and modulus operations
-
k
k is for kinematics
-
rand_pcg
Selected PCG random number generators
-
broccoli
broadphase collision detection algorithms
-
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…
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
permutation
Small utility for creating, manipulating, and applying permutations
-
rand_mt
Reference Mersenne Twister random number generators
-
graph
A library of high-performant graph algorithms
-
sgp4
A pure Rust implementation of the SGP4 algorithm for satellite propagation
-
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
-
chalk-engine
Core trait engine from Chalk project
-
openrr-planner
Collision avoidance path planning for robotics
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
thin-vec
A vec that takes up less space on the stack
-
cap-rand
Capability-based random number generators
-
rdrand
An implementation of random number generator based on rdrand and rdseed instructions
-
roots
Library of well known algorithms for numerical root finding
-
timely
A low-latency data-parallel dataflow system in Rust
-
geo-types
Geospatial primitive data types
-
pact_models
Pact-Rust support library that provides the core models for dealing with Pact files
-
special
The package provides special functions
-
stacker
A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack
-
cdshealpix
Rust implementation of the HEALPix tesselation
-
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
-
medians
Median, Statistical Measures, Mathematics, Statistics
-
arrow-array
Array abstractions for Apache Arrow
-
extendhash
Rust Hash Extender
-
arrow-data
Array data abstractions for Apache Arrow
-
test-data-generation
A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data
-
chalk-recursive
Recursive solver for the Chalk project
-
ordered-stream
Streams that are ordered relative to external events
-
sets
Generic vectors as sets. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
transpose
Utility for transposing multi-dimensional data
-
cam-geom
Geometric models of cameras for photogrammetry
-
hexf-parse
Parses hexadecimal floats (see also hexf)
-
linked_hash_set
HashSet with insertion ordering
-
quantiles
a collection of approximate quantile algorithms
-
slice-group-by
Iterators over groups in a slice
-
screwsat
A simple condlict driven clause learning sat solver
-
counting_sort
Counting sort implementation for Iterators
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
linfa-datasets
Collection of small datasets for Linfa
-
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)…
-
rustdct
Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust
-
differ
Differ is a library for finding the differences between two sequences
-
etagere
Dynamic 2D texture atlas allocation using the shelf packing algorithm
-
id_tree_layout
A library to visualize trees from the 'id_tree' crate
-
dogear
A library for merging bookmark trees
-
ids_service
Library that allows to generate unique Ids
-
jubjub
Implementation of the Jubjub elliptic curve group
-
memx
memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
muldiv
Provides a trait for numeric types to perform combined multiplication and division with overflow protection
-
numext-fixed-uint
Fixed-size uint types
-
fallible-iterator
Fallible iterator traits
-
radiate
Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
skillratings
Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more
-
friedrich
Gaussian Process Regression
-
metrohash
Rust implementation of MetroHash, a high quality, high performance hash algorithm
-
color-thief
Grabs the dominant color or a representative color palette from an image
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
powierza-coefficient
Powierża coefficient is a statistic for gauging if one string is an abbreviation of another
-
linregress
ordinary least squared linear regression with some basic statistics
-
geo-clipper
Boolean operations on polygons
-
autodiff
An automatic differentiation library
-
unm_selector
The algorithm for UnblockNeteaseMusic, determining what Song to return
-
rust-stemmers
A rust implementation of some popular snowball stemming algorithms
-
fractional_index
An implementation of fractional indexing
-
toffee
Get command to run to run specific test in a file
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
math_adapter
Collection of math adapters to decouple your application from math libraries' implementations and to provide both inter-libraries compatibility and affordable exchangeability
-
regex-syntax
A regular expression parser
-
rdst
A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
turborand
Fast random number generators
-
oorandom
A tiny, robust PRNG implementation
-
inplace_it
Place small arrays on the stack with a low-cost!
-
subset_sum
Solves subset sum problem and returns a set of decomposed integers. It also can match corresponding numbers from two vectors and be used for Account reconciliation.
-
metaheuristics-nature
A collection of nature-inspired meta-heuristic algorithms
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
sequence-generator-rust
Customizable 64-bit unique distributed IDs sequence generator based on Twitter's ID (snowflake). Build in Rust
-
hexagonal_pathfinding_astar
A-Star pathfinding algorithm tailored for traversing a bespoke collection of weighted hexagons
-
historian
a high performance zero-config histogram implementation
-
mergable
A library for user-friendly and efficient CRDTs
-
seal
Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
rust-spice
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
yada
Yada is a yet another double-array trie library aiming for fast search and compact data representation
-
opis
Opis is a library for rational number and matrix arithmetic
-
probminhash
Minhash algorithms for weighted Jaccard index
-
bandit
Bandit Algorithms in Rust
-
lfest
A leveraged perpetual futures exchange for simulated trading is a high performance backtesting exchange
-
edit-distance
Levenshtein edit distance between strings, a measure for similarity
-
term_grid
Library for formatting strings into a grid layout
-
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…
-
avalog
An experimental implementation of Avatar Logic with a Prolog-like syntax
-
natord
Natural ordering for Rust
-
zeros
Some cryptographic implementations
-
lyon_algorithms
2D Path manipulation/transformation algorithms
-
glass_pumpkin
A cryptographically secure prime number generator based on rust's own num-bigint and num-integer
-
bit-iter
Iterate forward or backwards over the positions of set bits in a word
-
rphonetic
Rust port of phonetic Apache commons-codec algorithms
-
poker
A crate for speedy poker hand evaluation
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
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…
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
pso-rs
An easy-to-use, simple Particle Swarm Optimization implementation in Rust
-
random-pick
Pick an element from a slice randomly by given weights
-
usher
Parameterized routing for generic resources in Rust
-
twofloat
Double-double arithmetic functionality
-
is_sorted
Is an Iterator sorted?
-
easer
Tiny library imlementing Robert Penner's easing functions
-
cosmian_kyber
A rust implementation of the post-quantum Kyber KEM algorithm. This is a fork of the
pqc_kybercrate -
rand_core
Core random number generator traits and tools for implementation
-
boostvoronoi
Boost voronoi ported to 100% rust
-
polylog
Rust implementation of polylogarithms
-
caches
This is a Rust implementation for popular caches (support no_std)
-
wfc
Generate images using Wave Function Collapse
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
levenshtein
Levenshtein algorithm
-
raft
The rust language implementation of Raft algorithm
-
rsc_osrm
rust wrapper for osrm, folk from TehGoat/rs_osrm
-
scru128
SCRU128: Sortable, Clock and Random number-based Unique identifier
-
ms_toollib
Algorithms for Minesweeper
-
perchance
Very simple random number generation optimized for ease of use
-
html2pango
Library to convert html to pango
-
hyperloglog
Hyperloglog implementation in Rust
-
board-game
A board game abstraction and generic utilities around it
-
random_color
Rust crate for generating random attractive colors
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
icu_casemapping
Unicode case mapping algorithms
-
delaunator
A very fast 2D Delaunay triangulation library
-
stringprep
An implementation of the stringprep algorithm
-
relp
Rust Exact Linear Programming
-
integer-sqrt
An implementation of integer square root algorithm for primitive rust types
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
simd-adler32
A SIMD-accelerated Adler-32 rolling hash algorithm implementation
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
ragged-buffer
Efficient RaggedBuffer datatype that implements 3D arrays with variable-length 2nd dimension
-
treediff
Find the difference between arbitrary data structures
-
mapproj
Implementation of (a part of) map projections defined in the FITS World Coordinate System (WCS)
-
rgeometry
High-Level Computational Geometry
-
magpie
Reasonably efficient Othello library built with bitboards
-
chalk-solve
Combines the chalk-engine with chalk-ir
-
differential-dataflow
An incremental data-parallel dataflow platform
-
tinyrand
Lightweight RNG specification and several ultrafast implementations in Rust
-
jps
Jump Point Search Implementation for Path Finding
-
biodiff
Compare binary files using sequence alignment
-
vrp-pragmatic
An extension logic for solving rich VRP
-
svdlibrs
A Rust port of LAS2 from SVDLIBC
-
symspell
Spelling correction & Fuzzy search
-
mockd
Fake data generator library with 130+ functions
-
competitive-programming-rs
Competitive Programming Library in Rust
-
travelling_salesman
Travelling Salesman Problem Solvers
-
gdsl
GDSL is a graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected…
-
numext-constructor
Fixed-size uint and hash constructor
-
overlord
Overlord consensus procotol
-
num_convert
Type converting library, conversions integers by overflow addition, supports generics types
-
rustronomy-watershed
a pure-rust implementation of the segmenting and merging watershed algorithms
-
sort
sort algorithms
-
sepax2d
A safe crate for finding and resolving collisions of 2D convex shapes using the Separating Axis Theorem
-
opendp
A library of differential privacy algorithms for the statistical analysis of sensitive private data
-
zero-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
adskalman
Kalman filter and Rauch-Tung-Striebel smoothing implementation using nalgebra, no_std
-
wezterm-bidi
The Unicode Bidi Algorithm (UBA)
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
dilate
A compact, high performance integer dilation library for Rust
-
argmap
parse command-line arguments into a hashmap and vec of positional args
-
qsv-stats
Computing summary statistics on streams
-
buf-min
Minimal utf-8 safe buffer traits
-
g2poly
Primitive implementation of polynomials over the field GF(2)
-
wavefc
A home-grown implementation of the Wave Function Collapse algorithm
-
geos-sys
GEOS C API bindings
-
iter-set
Set operations on sorted, deduplicated iterators
-
clingo
Rust idiomatic bindings to the clingo library
-
coord_transforms
A Rust crate use for performing coordinate transformations
-
hex2d
Helper library for working with 2d hex-grid maps
-
genetic_algorithm
A genetic algorithm implementation
-
bisector
Flexible bisect implementatation which allows the use the bisection method on arbitrary data types
-
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-polymesh
defines polygon data structure and some algorithms handling mesh, including meshing the shapes
-
seqalign
Sequence alignment using edit operations
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
blake
Implementation of the BLAKE hash function for Rust via FFI
-
spiral
Iterate over a 2D structure in a spiral pattern
-
convert-base
convert the radix (base) of digits stored in a vector
-
winsfs-core
Site frequency spectrum estimation based on window expectation-maximisation algorithm
-
zsplit
Split text into multiple files by line
-
meshed
Graph creation and traversal tools
-
rucrf
Conditional Random Fields implemented in pure Rust
-
graph_safe_compare
Equivalence predicate that can handle cyclic, shared, and very-deep graphs
-
pubgrub
PubGrub version solving algorithm
-
hilbert
Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling's algorithm
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
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
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki's C library libLBFGS
-
double-ratchet-rs
A pure Rust implementation of the Double Ratchet Algorithm as specified by Signal
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
oxygraphis
Algorithms and structures on ecological graphs command line interface
-
rsgenetic
A library providing genetic algorithm execution
-
halfbrown
Multi backend HashMap for higher performance on different key space sizes
-
vectora
A vector computation library
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
spectre
A lightweight toolkit for analysing p2p network topologies
-
poisson_reconstruction
Screened Poisson Reconstruction algorithm in Rust
-
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
webp
WebP conversion library
-
iter-read
A Read implementation for iterators over u8 and related types
-
maglev
Maglev - Google's consistent hashing algorithm
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
wave-function-collapse
Converts nodes and their restrictions into a collapsed node state based on the selected algorithm
-
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.
-
argminmax
ArgMinMax (argmin & argmax in 1 function) with SIMD for floats and integers
-
metaheuristics
Find approximate solutions to your optimisation problem using metaheuristics algorithms
-
murmur3
A rust implementation of Murmur3 hash
-
extended-isolation-forest
rust port of the anomaly detection algorithm
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
robust
Robust adaptive floating-point predicates for computational geometry
-
varint-rs
A small, zero dependency varint implementation in Rust
-
fossil-delta
Provides functions for calculating differences between strings and applying calculated deltas
-
boyer-moore-magiclen
Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust
-
sobol_burley
A seedable Owen-scrambled Sobol sequence
-
movavg
Generic Moving Average calculation
-
opencv-ros-camera
Geometric models of OpenCV/ROS cameras for photogrammetry
-
annembed
a Rust implementation of a dimension reduction à la Umap
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
graphalgs
Graph algorithms based on the Rust 'petgraph' library
-
pcg_rand
An implementation of the PCG family of random number generators in pure Rust
-
graph_builder
A building block for high-performant graph algorithms
-
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)…
-
ahrs
A Rust port of Madgwick's AHRS algorithm
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
out
Provides fast min and max functionality for collections
-
rtbvh
BVH library with various build algorithms and high performance using packet traversal
-
simple_accumulator
A simple accumulator
-
cint
A lean, minimal, and stable set of types for color interoperation between crates in Rust
-
levenberg-marquardt
Levenberg-Marquardt algorithm built on top of nalgebra
-
hilbert-curve-rust
Basic Hilbert curve algorithm
-
astro-format
Astro Format is a library for transcoding between multiple arrays and a single buffer
-
streaming-decompression
Fallible streaming iterator specialized for decompression
-
liba
An algorithm library based on C/C++ language
-
fast-erasure-shake-rng
Fast erasure (forward secure) sponge/duplex based PRNG using the Keccak permutation
-
dusk-hades
Implementation of Hades252 permutation algorithm over the Bls12-381 Scalar field
-
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
-
worley-noise
Worley noise implementation
-
sub-strs
For finding sub strings
-
simplerand
Simple and fast random number generator
-
linear-map
A map implemented by searching linearly in a vector
-
sort-it
Provides various sorting algorithms
-
superslice
Extensions for slices
-
async_chanx
Implement
Sinkfor some channel implementations -
response-time-analysis
Definitions and algorithms for response-time analysis of real-time systems
-
tailcall
Safe, zero-cost tail recursion
-
geometry-predicates
A Rust port of robust geometric predicates
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
fixed2float
Fixed point to floating point conversion utility
-
cobyla
COBYLA optimizer for Rust
-
punkt
An implementation of a Punkt sentence tokenizer
-
newton_rootfinder
Newton based methods for root finding
-
anchorhash
A consistent hashing algorithm that outperforms state-of-the-art algorithms
-
cmaes
An implementation of the CMA-ES optimization algorithm
-
fast_poisson
An implementation of Bridson's algorithm for fast Poisson disk sampling
-
wcs
Implementation of the FITS World Coordinate System (WCS)
-
prepona
A graph crate with simplicity in mind
-
quotient-filter
A quotient filter implementation
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
edt
An implementation of 2D EDT (Euclidian distance transform) with Saito's algorithm in pure Rust
-
adler
A simple clean-room implementation of the Adler-32 checksum
-
slice-by-8
HUD Software's Rust improved implementation of the Intel Slice-By-8 algorithm
-
fast-math
Fast, approximate versions of mathematical functions
-
data_type
Collection of primal data types
-
lazysort
Lazy sorting for iterators
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
human-sort
Human sort (natural sort) implementation
-
dahl-salso
The SALSO algorithm is an efficient greedy search procedure to obtain a clustering estimate based on a partition loss function. The algorithm is implemented for many loss functions…
-
abow
Visual bag of words for fast image matching
-
sha
Rust Secure Hash Algorithm (SHA) Library
-
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, ...
-
redux-rs
A Rust implementation of Redux
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
relp-num
Number types for the relp crate
-
codes-check-digits
Common implementation of check digit algorithms
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
requests_rs
A simple library for sending GET/POST requests, included with an async file downloader. Intended for mostly small projects which need to make quick GET/POST requests or download files.
-
graphplan
Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
rust-formal-verification
A rust library that makes it easier to develop, prototype and test new algorithms for formal verification like IC3, PDR, AVY and others
-
omnitigs
Omnitig-related algorithms
-
ring_buffer
RingBuffer is a queue with added random access
-
watchmaker_vm
A Rust implementation of a virtual machine for use with genetic algorithms
-
sudoku-solver
Simple backtracking algorithm for solving sudoku
-
minecraft_downloader_core
A Minecraft downloader written in rust
-
kendalls
Kendall's tau rank correlation
-
multistream-batch
Implementations of batching algorithms
-
domtree
dominance relation calculation
-
feruca
An implementation of the Unicode Collation Algorithm
-
buter
Fluid buffer as place for iterators
-
fuzzyhash
Pure Rust fuzzy hash implementation
-
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters's Pattern Defeating Quickselect
-
subslice
Fast subslice search
-
octarine
Color manipulation library
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
rlifesrc-lib
A Game of Life pattern searcher (library)
-
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
-
dryip
Short 🩸 Rust 🦀 code snippets for inspiration
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
spa
The Solar Position Algorithm module (SPA) for Rust calculates the sunrise-sunset and azimuth and zenith-angle for specific geo-position and time (UTC); for example for solar-panel-alignment or automotive
-
simple-simplex
Generates 2d simplex noise values and applies Fractal Brownian Motion
-
quantum_world_state
in-ram database with relationships between elements inspired by quantum superposition and entanglement
-
poi
A pragmatic point-free theorem prover assistant
-
random-manager
Rust random manager
-
times
Timing Benchmark, Repeated Runs, with Statistics
-
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
gemm
Playground for matrix multiplication algorithms
-
cozo
A general-purpose, transactional, relational database that uses Datalog and focuses on graph data and algorithms
-
gad
Generic automatic differentiation for Rust
-
algorithms-rs
Implementation of The Introduction to Algorithms Thrid Edition By Rust programming Language
-
shogi-kifu-converter
Shogi kifu parsers and converters
-
median
An implementation of an efficient O(n) median filter
-
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.
-
minimax-alpha-beta
An implementation of Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
idgenerator
A powerful unique id generator. Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity…
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
elipdotter
Embeddable full text search engine
-
tabu
Provides local search functionality in general, plus derived applications such as local search based clustering
-
clf
flush the cpu cache line by __builtin_clear_cache()
-
tlsh2
A rust implementation of the TLSH algorithm
-
cdchunking
Content-defined chunking
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
bsa3-hash
The hash function used in BSA files for *The Elder Scrolls III: Morrowind*
-
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
-
lol-core
A Raft implementation in Rust language
-
svg2polylines
Convert SVG data to a list of polylines (aka polygonal chains or polygonal paths)
-
hierarchical_pathfinding
Quickly approximate Paths on a Grid
-
hostlist-parser
Parses hostlist expressions into a Vec of Strings
-
lazy-bytes-cast
Lazy casts from & to byte arrays
-
gcp-vertex-ai-vizier
An async client library for GCP Vertex AI Vizier
-
arrow-arith
Arrow arithmetic kernels
-
bit-list
A lazy list of bits
-
guid-create
Rust helper for creating GUIDs
-
bloomy
A simple Bloom filter using only two hash functions
-
modular-frost
Modular implementation of FROST over ff/group
-
memx-cdy
The fast memory functions like a libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
wfc_image
Create patterns for wfc using image files
-
decluster
Iteratively declusters and replaces a randomised set of 2D points until a set is discovered where each point is separated by at least the specified minimum distance
-
algebraics
algebraic numbers library
-
sobol
A Sobol sequence generator for Rust
-
simplers_optimization
A Rust implementation of the Simple(x) black-box optimization algorithm
-
knossos
Rust library for generating and rendering mazes
-
scicrypt-numbertheory
A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation
-
four-bar
Four🍀bar library provides simulation and synthesis function for four-bar linkages
-
permutate
Generic permutator that permutates singular and multiple lists
-
tokenizations
Tokenizations alignments library
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
learnwell
Framework for reinforcement learning
-
emas_rs
Rust-based EMAS optimization algorithm
-
rev_buf_reader
Crate that provides a buffered reader capable of reading chunks of bytes of a data stream in reverse order. Its implementation is an adapted copy of BufReader from the nightly std::io.
-
etsm
Efficient Tiny State Machine using object callbacks
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
classify
A collection of algorithms for categorizing 1D data
-
tree_traversal
Find best leaf node in a tree
-
rmqtt-raft
rmqtt-raft - A raft framework, for regular people
-
idgenerator-thin
Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity (50W/0…
-
programinduction
A library for program induction and learning representations
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
comtesse
graph utilities
-
cityhash-rs
Rust no_std implementation of Google Cityhash v1.0.2, v1.0.3, and v1.1.0
-
jandom
Port of java.util.Random
-
avm1-emitter
AVM1 emitter
-
motion_list_rs
Library for working with motion_list.bin files in Smash Ultimate
-
faiss-sys
Native bindings for Faiss
-
stackful
Bridge between sync and async
-
textnonce
Text based random nonce generator
-
hora
Hora Search Everywhere
-
rust_wfa
Rust implementation of the wavefront sequence alignment algorithm
-
rs-graph
A library for graph algorithms and combinatorial optimization
-
xxh
XXHash algorithm implementation for Rust
-
ru_annoy
A rust implementation of annoy(https://github.com/spotify/annoy) (Index serving only). Providing C api as well
-
vrp-scientific
An extension logic for solving scientific VRP
-
astro
Advanced algorithms for astronomy
-
vsprintf
Rust bindings to the libc vsprintf function
-
permute
Generate permutations of vectors and slices in a memory-efficient and deterministic manner, using Heap's algorithm
-
line-col
Convert string slice indices into line/column numbers
-
lutz
Rust implementation of "An Algorithm for the Real Time Analysis of Digitised Images" by R. K. Lutz
-
const-fnv1a-hash
A #![no_std] crate for performing FNV1A-16/32/64/128 hashing on Rust stable at compile time
-
cp-rs
Competitive programming library, especially for AoC
-
hulahoop
An efficient consistent hash ring implementation supporting virtual nodes
-
scale_std
datastructures and algorithms to be run on the SCALE engine
-
throbber-widgets-tui
This is a tui-rs widget that displays throbber
-
wyhash
Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator
-
ringstack
A very simple circular buffered stack implementation
-
rendezvous_hash
An implementation of Rendezvous hashing algorithm
-
density-mesh-core
Core module for density mesh generator
-
multiexp
Multiexponentation algorithms for ff/group
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
rexl
Common Library for Rust
-
peak_finder
An algorithm for identifying peaks from line data, such as from accelerometer or spectral data
-
smbus-pec
Minimal portable implementation of SMBus Packet Error Code calculation algorithm
-
advent-of-code-ocr
Small crate to help convert AoC text screens to strings
-
rand_krull
Krull64/65 random number generators
-
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
numext-fixed-hash
Fixed-size hash types
-
flowing
Rusty flow graph processing library
-
spaced-rs
A small library implementing a sm2 inspired SR algorithm
-
prexel
A math expression evaluator
-
forceatlas2
fast force-directed generic n-dimension graph layout
-
sprs-ldl
Sparse cholesky factorization
-
pack_it_up
pack_it_up is a simple Rust library that implements various bin packing algorithms
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
qframework
A experimental micor framework for clear design, based on queue model
-
dia-ip-range
Ranges for IP v4
-
avltriee
Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…
-
shr3
SHR3 - 3-shift register random number generator
-
wgdiff
Implementation of LCS-based diff algorithm
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
zw-fast-quantile
Zhang-Wang fast quantile algorithm in Rust
-
meanshift-rs
Rust version of the MeanShift clustering algorithm that does not need a predefined number of clusters
-
quasirandom
Quasirandom number generation
-
tocket
A implemetation of 'Token Bucket' algorithm
-
cauchy
Trait for real and complex numbers
-
automata
An implementation of standard finite state automata such as DFA, NFA, Regex
-
weighted-rs
A libray for weighted balancing algorithm
-
packr2
a few packing algorithms for your needs
-
best-path
Shortest/longest path algorithms, where edge weight accumulation via either a sum or a product
-
rs_state_machine
A business-oriented state machine library
-
color_space
library for converting between color spaces and comparing colors
-
compound_factor_iter
Iterator types for output permutations from a function combining multiple discrete factors
-
ds-heightmap
Using diamond-square algorithm to generate heightmaps which stored in a 2D-array
-
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
codice_fiscale_rs
Crate to compute and validate Italian Tax code (codice fiscale)
-
normalize_country
Convert country names and codes to a standard
-
quine-mc_cluskey
Rust implementation of the Quine-McCluskey algorithm and Petrick's method
-
aws-tree-hash
Calculate the Amazon SHA256 tree hash as described on Checksum Calculation page of the AWS S3 Glacier developer guide
-
epoch-converter
epoch-converter enables conversion between seconds and units of time as well as between an epoch timestamp and units of time
-
isosurface
Isosurface extraction algorithms
-
libreda-pnr
Algorithm interface definitions of the LibrEDA place-and-route framework
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
crc16
A CRC16 implementation
-
iterslide
A "sliding window" iterator
-
random
The package provides sources of randomness
-
meminterval
A simple interval-tree in Rust made to store memory mappings
-
demes-forward
rust API for iterating demes models forwards in time
-
fakeit
Fake data generator library with 130+ functions
-
wfc-rs
Binding to the krychu/wfc C library
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
sea-canal
Identifies patterns in sequences of integers
-
pikkr
JSON Parser which picks up values directly without performing tokenization in Rust
-
map-gen-2d
2D map generation algorithms implementaion
-
murmurhash3
MurmurHash3 implementation
-
poisson-diskus
Poisson disk distribution sampling
-
aobscan
AOBscan is a library for multi-threaded AOB memory scanning
-
rustworkx-core
Rust APIs used for rustworkx algorithms
-
weighted_rand
A weighted random sampling crate using Walker's Alias Method
-
algorithmica
Rust Algorithms
-
task_partitioner
helper lib that allows partitioning named tasks by count or hash
-
building_blocks_search
Search algorithms for voxel data
-
clustr
Multithreaded string clustering
-
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
fang_oost_option
A library implementing Fang and Oosterlee's algorithm for option pricing
-
distance
A collection of approximate string matching algorithms
-
acap
As Close As Possible — nearest neighbor search in Rust
-
nostbeep
A no_std implementation of a binary heap. Binary Heap is implemented as a max heap.
-
npy-writer
Export numpy arrays in the npy or npz format
-
abv
AV and BV convert functions for Bilibili videos
-
rolling-stats
Rolling statistics calculations (min/max/mean/std_dev) over arbitrary floating point numbers based on Welford's Online Algorithm
-
openrr-teleop
openrr teleoperation library
-
rs-x11-hash
Rust bindings for x11 hashing algorithm
-
range_rover
Function to pack integers into ranges
-
vec-drain-where
alternative
Vec::drain_filterimpl -
rust-eratos
An implementation of 'Sieve of Eratosthenes' for rust language practice
-
fenris-optimize
Optimization functionality used by fenris
-
mx3
Implementation of the mx3 algorithm providing a bit mixer, pseudo-random number generator, and hash function
-
rust-3d
2D/3D library written in rust
-
checksum-tapestry
Collection of checksum algorithms and examples
-
ryu-ecmascript
Fast floating point to string conversion, suitable for ECMAScript NumberToString
-
algen
A parallelized genetic algorithm runner
-
bresenham_zip
Iterator to perform Bresenham over two lines of the same triangle simultaneusly for triangle rasterization
-
osqp
The OSQP (Operator Splitting Quadratic Program) solver
-
distributed-cards
Implements the mental poker shuffling algorithm
-
paragraph-breaker
An implementation of the Knuth-Plass algorithm for breaking paragraphs into lines
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
polyfit-rs
Polynomial fitting of data like in numpy.polyfit()
-
nsga
Multi-objective genetic optimization algorithm NSGA-II
-
glicko2
Implementation of the glicko2 rating system
-
rure
A C API for Rust's regular expression library
-
morphorm
A UI layout engine
-
sliding_windows
a non-copying implementation of a sliding windows iterator adaptor
-
rustlex_fsa
Library for manipulating (deterministic) finite automata
-
learn-rust-with-bubble-sort
A quick and non-optimized, cloning version of the bubble sort algorithm. Created as a showcase for publishing crates in the Rust Cookbook 2018
-
location_based_sharding
Right sized sharding algorithm
-
reed-solomon-16
Reed-Solomon GF(2^16) erasure coding with O(n log n) complexity
-
idhash
Calculate a Row-Invariant ID for Tabular Data
-
arrsac
From the paper "A Comparative Analysis of RANSAC Techniques Leading to Adaptive Real-Time Random Sample Consensus"
-
actionable
An enum-based async framework for building permission-driven APIs
-
romu
A pseudo random number generator using the Romu algorithm
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
a-star_traitbased
Implemetaion of A* useful for stuct, based on train implementation
-
fleetfs_raft
The rust language implementation of Raft algorithm
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
list_comprehension_macro
A macro for making Python like Vector and HashMap comprehensions
-
fallible-streaming-iterator
Fallible streaming iteration
-
accurate
(more or less) accurate floating point algorithms
-
fibonacii-heap
Priority queue implemeted using a Fibonacii Heap
-
circbuf
A growable circular buffer for working with bytes
-
rosomaxa
A rosomaxa algorithm and other building blocks for creating a solver for optimization problems
-
n18route
Searches 18xx maps for optimal route combinations
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
flat_spatial
Flat spatial partitionning algorithms and data structures
-
secret_integers
Wrapping around Rust's integers to allow only constant-time operations
-
logru
A small, embeddable and fast interpreter for a subset of Prolog
-
fixed-sqrt
Square root for fixed-point numbers
-
external_sort
Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
xor_rand
An arbitrary byte length, counter based PRNG crate
-
digraph-rs
a handful of algorithms for digraphs
-
lax
LAPACK wrapper without ndarray
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
extprim
Extra primitive types (u128, i128)
-
atomic-traits
The traits for generic atomic operations
-
orca-rs
Implementation of the ORCA algorithm
-
hopcroft-karp
A minimal implementation of the Hopcrof-Karp bipartite matching algorithm
-
cozad-union-find
An implementation of the union-find disjoint set graph algorithm
-
monitor-common
Basic data structure and algorithm of linux-monitor tool
-
maze_generator
A library of different maze generation algorithms
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
rootfind
Root-finding algorithms
-
shadowcast
Implementation of the recursive shadowcast visible-area detection algorithm
-
casuarius
Another implementation of the Cassowary linear constraint solving algorithm
-
morton-encoding
A crate for encoding and decoding Morton ("Z-order") keys
-
ziku-algorithms
Implementation for some common algorithms
-
rtriangulate
Delaunay triangulation on a set of points
-
fletcher
A dependency free implementation of the Fletcher's checksum algorithm
-
diffs
A number of diff algorithms, also called longest common subsequence
-
macro_machine
State machine generator using macros
-
blake3-std
the BLAKE3 hash function implementation with std::simd
-
tenhou-shuffle
Tenhou Deck/Wall-Shuffling Algorithm
-
keyde
Fast, Dependency-free Spacial Queries
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
g2gen
A macro to create types that implement fast finite field arithmetic
-
insides
A compact, high performance space filling curve library for Rust
-
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
treemap
Implementation of the Squarified Treemap algorithm
-
crfs
Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)
-
extsort
External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator
-
blurhash
A pure Rust implementation of blurhash
-
whosly
便捷的工具库
-
trajectory
Trajectory interpolation
-
numeric-algs
Crate implementing some numerical algorithms
-
dfp-number-sys
Rust bindings for Intel(R) Decimal Floating-Point Math Library
-
consistent_hash_ring
A flexible and efficient consistent hash ring
-
euc_lib
Easy to use implementation of extended and normanl Euclidean algorithm
-
const-crc32
A
const fnimplementation of crc32 checksum algorithm -
searchy
Search index (in-memory), that can be constructed and searched using a bag of words model, with cosine similarity scoring based on tf-idf. Supports multiple search terms, permissions…
-
wz-publish-test
Test publish crate, don't use
-
rs-wordle-solver
A library for solving Wordle-style puzzles. It provides multiple guessing algorithms, as well as building blocks for implementing your own Wordle solving algorithms.
-
tempergb
Convert a color temperature to RGB values
-
scidec
Scientific to decimal number converter
-
minisat
MiniSat Rust interface. Solves a boolean satisfiability problem given in conjunctive normal form.
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
tdigest
T-Digest algorithm in Rust
-
algos
A collection of algorithms in Rust
-
stable_matching
Implementation of the Gale-Shapley stable matching algorithm
-
tnt-lib
A Rust implementation of many certificates about Integers
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
rab-core
Rusty Armor Builds - Algorithms, Armors and skill management
-
cfg-regex
Conversion from a regular expression to a context-free grammar
-
rustimization
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
reed-solomon-novelpoly
An implementation of a reed solomon code / encoder / decoder with complexity
O(n lg(n)) -
zvxryb-broadphase
A broadphase collision detection library
-
velodyne-lidar
Velodyne lidar data processing algorithms and utilities
-
ordered_vec
A trait that ensures that elements in a vector are pushed in a sorted order (both ascending and descending)
-
pagino
Handle pagination's logic
-
lehmer
Convert between permutation vectors, Lehmer codes and decimals
-
ssdeep
A Rust wrapper for ssdeep
-
ga-scheduler
A Genetic Algorithm optimizer designed for scheduling and similar tasks
-
kernel-density-estimation
Kernel Density Estimation in Rust
-
random_lfsr_256_galois
Simple random generator imlplementation based on linear feedback shift register (LFSR, Galois variation) on 256-bit polynome
-
pocket_prover-set
A base logical system for PocketProver to reason about set properties
-
triadic-memory
Basic triadic memory implementation
-
quad-rand
Pseudo random implementation with std atomics
-
oxygraph
Algorithms and structures on ecological graphs
-
intersect2d
Line segment intersection detection
-
perm
Permutation iterator
-
xxh3
XXH3 hash function
-
cyclic-poly-23
A rolling, decomposable hash algorithm
-
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.
-
topo_sort
A 'cycle-safe' topological sort for a set of nodes with dependencies
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
beehave
A simple library for defining and evaluating a hierarchical state machine (behaviour tree)
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
java_random
The java LCG and random module implementation in rust
-
rand_xorshift
Xorshift random number generator
-
pg_rnd_numeric
PostgresQL extension for random numerics and bytes
-
vecshard
Split Vecs in constant time
-
xias
Explicit numeric type conversions
-
shash
An arbitrary-length-input hash function for competitive programming and experimental purposes
-
randotron
Trivial little library that lets you randomly execute a closure with a sample rate
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
petgraph-gen
Graph generators for petgraph
-
fakemap
Map with Vec implementation, without ordering or hashing (for Serde deserialization)
-
staticstep
Provides truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
shuffle
Implementation of various shuffling algorithms over slices
-
glicko_2
Glicko2 is an iterative algorithm for ranking opponents or teams in 1v1 games
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
detect-lang
Language detection given paths and extensions
-
ciclo
Exhaustive cycle enumeration
-
grabbag
A random grab-bag of functionality
-
graph-tools
Graph tools and algorithms written in Rust
-
modulo
Simple modulo operation
-
hungarian
A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
differential-growth
A Rust implementation of the differential growth algorithm
-
fuzzy_rocks
A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm
-
dynamic-weighted-index
Data structure to sample elements with weights that can be efficiently updated
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
alea
A crate for randomness
-
endicon
Implementations of codicon traits for endianness encodings
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
meowhash
Meow hash function
-
halton
A module for generating Halton sequences
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
hash-roll
Rolling hashes & Content Defined Chunking (cdc)
-
naive-cityhash
A naive native 64/128 bit cityhash implementation for databend
-
utm
Convert latitudes and longitudes to UTM coordinates and vice versa
-
arthroprod
Clifford Algebra based computation for the theory of Absolute Relativity
-
toposort-scc
An implementation of Kahn's algorithm for topological sorting and Kosaraju's algorithm for strongly connected components
-
gaps
Functionality for working with gaps/holes in ordered sequences of values
-
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
-
genx
An easy to use and modular genetic algorithms library
-
lfu
An LFU cache implementation
-
space_alloc
General purpose space allocators
-
oshash
An implementation of https://pypi.org/project/oshash/ in Rust
-
xorshift128plus-rs
A simple implementation of the XorShift128+ pseudorandom number generator in Rust
-
binary-merge
Minimum comparison merge of two sorted sequences with random access
-
cdivsufsort
Rust bindings for Yuta Mori's divsufsort
-
favannat
Algorithms to evaluate the function encoded in ANN-like structures
-
rabin_ida
Rabin's information dispersal algorithm, originally by Liam Perlaki
-
geomorph
Simple conversion between different coordinate systems
-
murmurhash32
A simple implementation of murmurhash32_2
-
microstate
Finite state machine, inspired by micromachine
-
fuss
Small, lightweight simplex noise generator for Rust
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
census-proteomics
Rust library for working with proteomics data quantified by the Census algorithm
-
dedup_signature
This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
rustgym
rustgym solutions
-
algo
Algorithms & Data Structure implementations
-
pluum
Rust is very sweet
-
to-mut
Convert immutable reference to mutable reference
-
depper
Library for basic dependency validation
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
lambert
lamber-rust is a crate helping to convert Lambert coordinates to WGS84
-
elm-solve-deps
A dependency solver for the elm ecosystem
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
srand
Random number generators and other randomness functionality with simple apis to use
-
bit_combi_iter
An iterator to iterate all bit combinations less than given unsigned integer
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
libhumancode
A
no_stdcompatible library that provides a function to enode binary data up to 150 bits in a human friendly format -
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
tylar
Type-Level Arithmetic in Rust
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
md6
Implementation of the MD6 hash function for Rust via FFI
-
moodyblues-sdk
A tracer SDK for Overlord like consensus algorithm
-
sfmt
Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)
-
squirrel3-rs
Simple and reliable random number generator
-
MFEKmath
A library which supplies mathematics and algorithms for manipulating beziers
-
kahan
Provides types to perform Kahan summation
-
seqdiff
Diff between two sequences
-
image-match
Derives an image signature to be used in quick image comparisons
-
snakecase
Snakecase is a general purpose snakecase implementation supporting both ascii and unicode
-
fair
CLI tool and library for verifying provably fair games (baccarat, etc.)
-
hyperid
Superfast id generator
-
addchain
Generate addition chains
-
buf_stream_reader
provides a buffered access to a Read object with a limited Seek implementation
-
clock-zones
A library for handling clock zones
-
median-accumulator
Simple, fast, space-efficient accumulator for computing median
-
elias-fano
An implementation of Elias-Fano encoding in Rust
-
index-sort
Sort containers by index using user-specified swap and compare functions
-
sparse-interp
Basic univariate polynomial arithmetic and sparse polynomial interpolation
-
traversal
Generic and lazy tree traversal algorithms
-
runiverse
A pure and safe Rust library to make astronomical calculations and solve astronomical algorithms
-
f8
It's a float! It's a unorm! It's only one byte!
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
blossom
Implementation of the Blossom algorithm to get a maximum matching in an undirected graph
-
sorted-insert
This crate provides traits to insert elements to a sorted collection and keep the order
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
markov_rs
A simple and fast Markov chain generator in Rust
-
fp-growth
An implementation of the FP-Growth algorithm in pure Rust
-
wasmium-random
Generate random numeric, alphabet, alphanumeric, BIP39 and EFF random bytes
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse's LDL algorithm
-
chull
Convex hull approximation
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
stalin-binary-search
alike binary search but any checking element which is not target one is eliminated
-
batsat
Extensible SAT solver in Rust
-
optimum
Future Framework to solve optimization problems
-
m4ri-sys
Bindings to m4ri
-
partition
partition slices in-place by a predicate
-
algorithms-edu
Algorithms for pedagogical demonstration
-
heuristic-graph-coloring
Heuristic algorithms for graph vertex coloring
-
const-murmur3
A const fn implementation of the murmur3 hashing algorithm
-
mecs
An ecs library with a focus on iteration performance
-
wpa-psk
Compute the WPA-PSK of a Wi-FI SSID and passphrase
-
fast_inv_sqrt
Fast inverse square root algorithm implementation
-
skelly
Skeleton animation and IK
-
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
-
library_of_babel
Implementation of Library of Babel in Rust
-
lazy-pbar
An extremely lazy interface for indicatif, simplifying my one use case (Wrapping an iterator)
-
rodar
a command line tool that brings together all the functions Roy would use for analysis and decision-making
-
lp-solvers
.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK
-
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
divisors
A blazing fast library to find all divisors of a natural number
-
squirrel-noise
A rust implementation of noise based rng from Squirrel Eiserloh's talk at GDC 2017
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
crc24
CRC-24 implementation (IETF RFC2440-compatible)
-
xxhash-c
Safe wrapper to xxhash
-
rust-algorithms
A rust-algorithms library
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
spain-vat-id
Spanish VAT ID numbers validation/verification
-
pennereq
Port of the Penner easing equations to rust
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
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.
-
spatium
Spatium. Calc distance between sequences.
-
easey
Easing functions for interpolation between 0.0 and 1.0
-
intpackit
library that allows to manage unsigned values packed in a single integer
-
microwfc
Small Wave-Function-Collapse implementation
-
billow
Simple Wave Function Collapse implementation in Rust
-
seadawg
SeaDawg is a library that implements the online algorithm for Direct Acyclic Word Graph (DAWG) and Compact Direct Acyclic Word Graph (CDAWG)
-
weighted-rs-wasm
A libray for weighted balancing algorithm
-
librualg
Collection of basic algorithms for everyday development
-
affine_transforms
(Pre Release Package) Does linear transformations in R3
-
crczoo
CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms
-
fuzzy_dbscan
An implementation of the FuzzyDBSCAN algorithm
-
flinn_engdahl
Flinn-Engdahl Seismic And Geographic Regionalization - Rust Implementation
-
honestintervals
Comprehensive, correctly rounding interval arithmetic library
-
supermemo2
A simple crate that implements the supermemo2 spaced repetition algorithm
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
graco
Generalized Rust Ant Colony Optimization
-
heapify
Convenience functions to turn slices into max-heaps
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
max-subarray-sum
Finds the maximum subarray sum in a list
-
iterchunks
An iterator adapter to adapter that yields N elements of the iterator at a time
-
xxhrs
Safe XXHash and XXH3 bindings
-
hybrid-clocks
Hybrid Logical Clocks
-
visionmagic
Collection of vision & graphics algorithms
-
mini-kanren
miniKANREN in Rust
-
hot-ranking-algorithm
Algorithm that measures how relevant a given data set is, kinda like Reddit
-
performant_encryption
This is a Rust library providing external facing functions to performant and trusted encryption in Rust
-
easy_complex
Complex numbers crate
-
fang_oost
A library implementing Fang and Oosterlee's algorithm for inverting characteristic functions
-
lttb
An implementation of the Largest Triangle Three Buckets algorithm
-
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
orc-format
Unofficial implementation of Apache ORC spec in safe Rust
-
double_sort
This is a fast and simple sorting algorithm which groups numbers into pairs and orders them onwards as nodes
-
rusty-perm
Rusty permutation with no-std
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
elements-frequency
Finds the frequency of elements in a list
-
optimization
Collection of optimization algorithms
-
watchmaker
A genetic algorithm implementation in Rust
-
vecfx
Extra batteries for a vec of floats
-
spatial-neighbors
Simple to use implementation of certain Spatial-Partitioning Algorithms | DataStructures
-
mersenne-twister-m
mersenne twister pseudorandom number generator
-
darwin-rs
Evolutionary algorithms library written in Rust
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
morton
Morton space filling curve functions
-
range-reader
Converts low-level APIs to read ranges of bytes to
Read + Seek -
minecraft_launcher_core
A Minecraft launcher library written in rust
-
pi_hash
Provide unified hasher, HashMap and HashSet, The hash algorithm used can be determined by compiling conditions
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
array_windows
finding the minimum or maximum n values from an iterable
-
verhoeff
The Verhoeff algorithm, for number checksums
-
bufstream
Buffered I/O for streams where each read/write half is separately buffered
-
rand-wyrand
The extremely fast WyRand PRNG for the rand ecosystem of crates
-
bresenham
A fast, iterator-based integer-only implementation of Bresenham's line algorithm
-
conshash
A library to do consistent hashing in Rust
-
tenthash
A robust 160-bit non-cryptographic hash function
-
gevlib
A Rust library containing distributional quantities (CDF, PDF, Quantile, random generation) of the Extreme Value Distributions
-
backtrack
Solve hard constraints easily
-
editdistancek
Fast algorithm for computing edit distance
-
gbps
Rust implementation of gossip-based peer sampling
-
pagefind_stem
Snowball stemming algorithms repackaged for Rust, with languages behind feature flags
-
parser-pda
Example of a simple parser pushdown automaton implementation
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
fixed-array
Fixed-size array
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
oss-vizier
An (unofficial) async client library for OSS Vizier
-
is_42
Simple, blazingly fast way of checking if a variable is equal to 42
-
lis
Longest increasing subsequence algorithm
-
dft
The package provides an algorithm to compute the discrete Fourier transform
-
various_data_file
Store a dainary datas in a file. Use mmap, optimize fragments on delete, and reference identical strings.
-
acorn_prng
A no_std, 0 dependency, pseudo-random number generator based on the ACORN algorithm
-
byond-crc32
Fast CRC-32/BYOND checksum computation
-
neptune-triton
GPU implementation of neptune-compatible Poseidon hashing
-
number_traits
number traits
-
hashed-permutation
A fast, instant-access way to permute a range of numbers
-
winstructs
Common structures used in parsing various windows protocols
-
sample-consensus
Abstractions for sample consensus algorithms such as RANSAC
-
cplex-sys
Low level bindings to the Cplex C-API
-
froggy-rand
Random number generation without state for games
-
octree
Octree algorithm for nearest neighbor search in 3D space
-
quickmaths
A collection of algorithims for generic mathematics
-
integer-hasher
An implementation of
std::hash::Hasherwhich does not hash at all -
tokio_interval_buffer
Easy enum wrapper that implements all traits that the wrapped objects implement
-
hotsax
An implementation of the HOTSAX and HOTSAX based discord discovery algorithms
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
randlib
Dependency-less random value generator using pointer addresses and time
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
convolve2d
Easy and extensible pure rust image convolutions
-
random-string
Allows to generate random strings based on a given charset and length
-
num-cmp
Comparison between differently typed numbers
-
unik
A Powerful Universally Unique Identifier (UUID)
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
toolbox
Simple tools for daily use
-
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!
-
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
-
math_lib_test
This is a test Library for rust
-
iso_iec_7064
Support for check digit operations conforming to ISO/IEC 7064
-
state_machine
Simple state machine
-
downsample
keep downsampled history of data over long period of time
-
count-min-sketch
Count-min-sketch implementation
-
levenshtein-rs
Levenshtein distance algorithm
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
nqueens-oxigen
N Queens problem resolution using oxigen
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
gosh-lbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki's C library libLBFGS
-
tw-id-num
Check or generate Taiwan ID numbers
-
doga-multilingual-greetings
A multilingual greetings package written for educational purposes
-
rbuf
A general purpose ring buffer implementation with some non-standard constraints
-
iobuf
A contiguous region of bytes, useful for I/O operations
-
cityhash-sys
Rust binding of Google CityHash algorithm
-
implements
Macro to answer the question: does it implement a trait?
-
gurobi
An unofficial Rust API for Gurobi optimizer
-
block-mesh
Fast algorithms for generating voxel block meshes from arrays
-
distance-pairs
A package to find the longest distance-pair points in a point cloud
-
co_sort
Sort arrays given a permutation
-
grid_search_cardinal_common
Reusable components for use implementing uniform-cost cardinal grid-searching algorithms
-
automafish
Automafish is a state machine builder for creating deterministic state machines out of nondeterministic state machine definitions
-
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
den
A general delta encoded network difference algorithm
-
n18game
Provides assets and logic for 18xx games
-
indexsort
Yet another sort crate, porting Golang sort package to Rust
-
truncate
Possibly truncating conversions between types
-
palette_extract
A Rust port of Leptonica's modified media cut quantization algorithm
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
meiosis
An evolutionary algorithm library with as many compile time checks as possible
-
closest-sum-pair
Finds a pair in a list that has the closest sum to a given number
-
rust-freqdist
An implementation of a Frequency Distribution in Rust
-
permutation_iterator
A Rust library for iterating over random permutations using O(1) (i.e. constant) space.
-
permoot
General-purpose no_std permutation library
-
rand_seeder
A universal random number seeder based on SipHash
-
seamcarving
Content-aware image resizing using the seam carving algorithm. Allows changing the aspect ratio of an image without distorting its contents.
-
line_2d
Bresenham's line algorithm as a rust iterator
-
opendp-ffi
Foreign function interfaces for the OpenDP library
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
nd_array
Crate for linear algebra that tries to have a similar api to numpy
-
fastblur
Linear-time gaussian blur
-
loli_lib_dev
Fun project to get used to cargo and rust programming
-
pack
Solver for packing puzzle
-
statistical
A simple statistics library
-
broccoli-ext
broadphase collision detection algorithms
-
wyhash2
A simple wyhash2 implementation in rust
-
luhn3
A Luhn validation library
-
pathfinding_astar
An implementation of the A-Star pathfinding algorithm that can process absract and grid-like paths
-
search_trees
Utilities for binary search tree, red-black tree, and AVL tree
-
pushy
A pushable stack-allocated buffer
-
streemap
Set of tree map algorithms (binary, squarified, ...)
-
tree-edit-distance
Find the lowest cost sequence of edits between two trees
-
simple-rnd
Tiny random number generation library
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
gcd-bitwise
The binary Euclidean algorithm for computing gcd
-
sort_algos
Sorting alghoritms
-
gworld
A library to evolve genetic algorithms (beginner friendly to advanced) and reduce boilerplate setup
-
fxsm
A state machine procedural macro for enums
-
pcg
A port of the PCG random number generation library
-
float_to_int
Conversions of integer-value floats into integers
-
ritehash
A tiny, fast, zero-dep and no_std fxhash fork. More up to date.
-
moving-least-squares-image
Image deformation using moving least squares
-
fst_stringstring
String-to-String Map built from fst
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
multistochgrad
Stochastic Gradient, Multithreaded
-
sorts
A collection of sorting algorithms
-
organism
A struct used for a genetic programing algorithm
-
word_sensitive
A library for sensitive string matching, the implementation language is rust, and the algorithm used is ac
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
interp
A Rust implementation of Matlab's interp1 function
-
hash_map_diff
Comparing changes between two HashMaps
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
squares-rnd
Simple and fast counter based non-crypto random generator
-
block-pseudorand
Generator of random Vec<T>'s for types that can be transmuted from arbitrary bytes
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
curveipo
2D curve interpolation
-
ncollide3d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
diffr-lib
An implementation of Myers diff algorithm
-
rrt
Path finding using dual-RRT connect
-
sust
A 2d rust rendering engine powered by sfml & egui that mainly renders shapes. This can be used to visualize algorithms on a grid based surface
-
simple-pagerank
Simple library to calculate the PageRank of a graph
-
tailcall-impl
The procedural macro implementation for the tailcall crate
-
revonet
Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
rand_jitter
Random number generator based on timing jitter
-
stack
DSTs and arrays on the stack!
-
oars
A library providing construction methods and utility functions for orthogonal arrays and strong orthogonal arrays
-
pretree
Pretree is a package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
gut
Geometry utilities: storing, manipulating and processing geometries
-
hnsw
Fast approximate nearest neighbors
-
plonkup
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
uncertain
Fast and correct computations with uncertain values
-
xxhash-c-sys
Bindings to xxhash
-
adler32fast
Fast, SIMD-accelerated Adler-32 checksum computation
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
iter_columns
Iterate over columns easily
-
quadrature
This provides several fast numerical integration methods. This library is pure safe rust, and cross-platform. The double exponential algorithm is naturally adaptive, and does not allocate.
-
bsutils
Binary search utilities with efficiency
-
numext-fixed-uint-hack
A internal crate used by numext-fixed-uint
-
bruteforce
This is a no_std-compatible brute force/string generation rust-nightly library
-
rost
A library for sorting
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
building_blocks_procgen
Algorithms for procedural generation of voxel data
-
sark_pathfinding
A simple implementation of the astar pathfinding algorthim from red blob games https://www.redblobgames.com/pathfinding/a-star/implementation.html
-
rustyard
A Shunting Yard implementation and calculator. This crate is able to calculate basic math expressions passed to it as strings and return a 64-bit floating point return value.
-
deus-nqueens
NQueens Problem Solver
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
pruefung
Checksums in pure Rust, with no_std available, implementing the Hasher trait
-
density-mesh-image
Image module for density mesh generator
-
Algod
Many types of rust algorithms and data-structures
-
rudoku-core
A Sudoku library for generating and solving Suokus
-
str-distance
Distance metrics to evaluate distances between strings
-
mersenne_twister
Mersenne Twister pseudorandom number generator
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
cinnabar
Rust library of graph algorithms and data strctures
-
rolling-dual-crc
Rolling CRC with 32-bit CRC32C and 64-bit CRC64/XZ
-
otp-simple
A simple implementation of the TOTP and HOTP algorithms
-
quadtree-f32
Simple, dependency-free ID-based quadtree
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
zerobuf
A growable chunk of zeroed memory
-
dubble
A generic implementation of double-buffering
-
crcxx
universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms
-
fundamental_data_type
Fundamental data types and type constructors, like Single, Pair, Many
-
ordslice
Extensions for ordered slices
-
acacia
A spatial partitioning and tree library
-
boostvoronoi_ext
Boost voronoi private workspace
-
aristeia
An evolutionary computation library
-
triangulation
A collection of triangulation algorithms
-
scalar
A trait for scalars (integers and floats)
-
infinitable
Infinity for types without infinite values