-
rand
Random number generators and other randomness functionality
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
twox-hash
XXHash and XXH3 algorithms
-
crc
support of various standards
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
fastrand
fast random number generator
-
crypto-bigint
Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…
-
xxhash-rust
xxhash
-
rustfft
High-performance FFT library written in pure Rust
-
stacker
A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack
-
noise
Procedural noise generation library
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
ulid
a Universally Unique Lexicographically Sortable Identifier implementation
-
fnv
Fowler–Noll–Vo hash function
-
rstar
An R*-tree spatial index
-
float_eq
Compare IEEE floating point primitives, structs and collections for equality
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
dissimilar
Diff library with semantic cleanup, based on Google's diff-match-patch
-
realfft
Real-to-complex forward FFT and complex-to-real inverse FFT for Rust
-
bitpacking
Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.
-
highway
Native Rust port of Google's HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
wildmatch
string matching with single- and multi-character wildcard operator
-
md5
The package provides the MD5 hash function
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
uint
Large fixed-size integer arithmetic
-
pathfinding
flow, and graph algorithms
-
passwords
useful tools to generate multiple readable passwords, as well as analyze and score them
-
ff
building and interfacing with finite fields
-
rand_hc
HC128 random number generator
-
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.
-
kiddo
A high-performance, flexible, ergonomic k-d tree library. Ideal for geo- and astro- nearest-neighbour and k-nearest-neighbor queries
-
oorandom
A tiny, robust PRNG implementation
-
streaming-iterator
Streaming iterators
-
gcd
Calculate the greatest common divisor
-
nucleo
plug and play high performance fuzzy matcher
-
slice-group-by
Iterators over groups in slices and strs
-
murmur3
hash
-
topological-sort
Performs topological sorting
-
strength_reduce
Faster integer division and modulus operations
-
rdrand
random number generator based on rdrand and rdseed instructions
-
buffer-redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
sgp4
A pure Rust implementation of the SGP4 algorithm for satellite propagation
-
easy-smt
Easily interact with an smt solver as a subprocess
-
medians
Median, Statistical Measures, Mathematics, Statistics
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
treediff
Find the difference between arbitrary data structures
-
edit-distance
Levenshtein edit distance between strings, a measure for similarity
-
foldhash
A fast, non-cryptographic, minimally DoS-resistant hashing algorithm
-
argminmax
(argmin & argmax in 1 function) with SIMD for floats and integers
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
special
The package provides special functions
-
differential-dataflow
An incremental data-parallel dataflow platform
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
earcutr
port of MapBox's earcut triangulation code to Rust language
-
textdistance
Lots of algorithms to compare how similar two sequences are
-
sketches-ddsketch
A direct port of the Golang DDSketch implementation
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
resolvo
Fast package resolver written in Rust (CDCL based SAT solving)
-
simd-adler32
A SIMD-accelerated Adler-32 hash algorithm implementation
-
rustfst-ffi
constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs). Rustfst-ffi provides C interfaces of the Rust library
-
memx
memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
k
kinematics
-
jubjub
elliptic curve group
-
reed-solomon-simd
Reed-Solomon coding with O(n log n) complexity. Leverages SIMD instructions on x86(-64) and AArch64.
-
daachorse
Double-Array Aho-Corasick
-
GSL
binding for the GSL (the GNU scientific library)
-
merkle_hash
Finds the hashes of all files and directories in a directory tree
-
fastcdc
(content defined chunking) in pure Rust
-
metrohash
high quality, high performance hash algorithm
-
hexf-parse
Parses hexadecimal floats (see also hexf)
-
hime_redist
Redistributable runtime library for parsers generated with Hime (LR, RNGLR)
-
halfbrown
Multi backend HashMap for higher performance on different key space sizes
-
adler
clean-room implementation of the Adler-32 checksum
-
annembed
dimension reduction à la Umap
-
levenshtein
algorithm
-
reed-solomon-novelpoly
reed solomon code / encoder / decoder with complexity
O(n lg(n)) -
ph
data structures based on perfect hashing
-
linfa-linalg
Pure-Rust implementation of linear algebra routines for ndarray
-
gix-negotiate
gitoxide project implementing negotiation algorithms
-
fractional_index
fractional indexing
-
raft
language implementation of Raft algorithm
-
reactive_graph
A fine-grained reactive graph for building user interfaces
-
crossterm_winapi
WinAPI wrapper that provides some basic simple abstractions around common WinAPI calls
-
boyer-moore-magiclen
fast string search algorithm implemented in Rust
-
task-local-extensions
Task-local container for arbitrary data
-
timely
A low-latency data-parallel dataflow system in Rust
-
transpose
transposing multi-dimensional data
-
bm25
BM25 embedder, scorer, and search engine
-
glass_pumpkin
A cryptographically secure prime number generator based on rust's own num-bigint and num-integer
-
iroh-blobs
blob and collection transfer support for iroh
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
muldiv
trait for numeric types to perform combined multiplication and division with overflow protection
-
partial_sort
provide a Rust version std::partial_sort
-
z3
High-level rust bindings for the Z3 SMT solver from Microsoft Research
-
simplerand
fast random number generator
-
robust
adaptive floating-point predicates for computational geometry
-
chalk-recursive
Recursive solver for the Chalk project
-
rust-stemmers
some popular snowball stemming algorithms
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
rand_simple
random number generator that is independent from the other libraries and based on XOR shift
-
keyword_extraction
Collection of algorithms for keyword extraction from text
-
nabla-ml
A numpy-like library for Rust
-
ndarray-slice
Fast and robust slice-based algorithms (e.g., sorting, selection, search) for non-contiguous (sub)views into n-dimensional arrays
-
scru128
Sortable, Clock and Random number-based Unique identifier
-
cam-geom
Geometric models of cameras for photogrammetry
-
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
blurhash
A pure Rust implementation of blurhash
-
faer-sparse
Basic linear algebra routines
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
levenberg-marquardt
algorithm built on top of nalgebra
-
quantiles
a collection of approximate quantile algorithms
-
naive_opt
The optimized naive string-search algorithm
-
cardinality-estimator
estimating the cardinality of distinct elements in a stream or dataset
-
varpro
A straightforward nonlinear least-squares fitting library which uses the Variable Projection algorithm
-
cmaes
CMA-ES optimization algorithm
-
rithm
Arbitrary precision arithmetic
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
pocket_prover
A fast, brute force, automatic theorem prover for first order logic
-
twofloat
Double-double arithmetic functionality
-
clone_dyn
Derive to clone dyn structures
-
russcip
Rust interface for SCIP
-
murmurhash32
murmurhash32_2
-
gxhash
non-cryptographic algorithm
-
rand_mt
Reference Mersenne Twister random number generators
-
nlopt
Wrapper for the nlopt library
-
timsort
modified MergeSort used in Python and Java
-
accurate
(more or less) accurate floating point algorithms
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
cubecl-linalg
CubeCL Linear Algebra Library
-
usearch
Smaller & Faster Single-File Vector Search Engine from Unum
-
dive-deco
A dive decompression models library (Buehlmann ZH-L 16C)
-
rand_regex
Generates random strings and byte strings matching a regex
-
mockd
Fake data generator library with 130+ functions
-
tailcall
Safe, zero-cost tail recursion
-
ipopt
Rust language bindings for the Ipopt non-linear constrained optimization library
-
kd-tree
k-dimensional tree
-
meos
Rust bindings for MEOS C API
-
chalk-engine
Core trait engine from Chalk project
-
genetic_algorithm
A genetic algorithm implementation
-
itermore
🤸♀️ More iterator adaptors
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
raddy-ad
An automatic differentiation system for geometry and simulation
-
rust-spice
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
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.
-
cdshealpix
HEALPix tesselation
-
ranges
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
-
num_convert
Type converting library, conversions integers by overflow addition, supports generics types
-
probminhash
Minhash algorithms for weighted Jaccard index
-
integer-sqrt
integer square root algorithm for primitive rust types
-
rsc_osrm
rust wrapper for osrm, folk from TehGoat/rs_osrm
-
byteyarn
hyper-compact strings
-
iter_tools
Collection of general purpose tools to iterate. Currently it simply reexports itertools.
-
dbsp
Continuous streaming analytics engine
-
ddo
generic and efficient framework for MDD-based optimization
-
diff-match-patch-rs
The fastest implementation of Myer's diff algorithm to perform the operations required for synchronizing plain text
-
rectangle-pack
A general purpose, deterministic bin packer designed to conform to any two or three dimensional use case
-
adskalman
Kalman filter and Rauch-Tung-Striebel smoothing implementation using nalgebra, no_std
-
fuzzy-muff
Fuzzy Matching Library
-
bit-matrix
bit matrices and vectors
-
geo-index
Fast, immutable, ABI-stable spatial indexes
-
cap-rand
Capability-based random number generators
-
rustfst
constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
rustsat
aims to provide implementations of elements commonly used in the development on software in the area of satisfiability solving. The focus of the library is to provide as much ease of use without giving up on performance.
-
incremental
computations, based on Jane Street's incremental
-
mergable
user-friendly and efficient CRDTs
-
union-find
Struct and methods for union-find operation
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
glissade
that provides various utilities for animations and transitions
-
rand_core
Core random number generator traits and tools for implementation
-
orx-v
Traits to unify all vectors!
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
algos
A collection of algorithms in Rust
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
quad-rand
Pseudo random implementation with core atomics
-
ids_service
that allows to generate unique Ids
-
rs-wordle-solver
solving Wordle-style puzzles. It provides multiple guessing algorithms, as well as building blocks for implementing your own Wordle solving algorithms.
-
tantivy-fst
tantivy-specific fork from the fst crate from Burntsushi. (Please use the fst crate instead.)
-
count-min-sketch
Count-min-sketch implementation
-
cubecl
Multi-platform high-performance compute language extension for Rust
-
t1ha
T1AH (Fast Positive Hash) hash function
-
alphanumeric-sort
can help you sort order for files and folders whose names contain numerals
-
xiangting
calculating the deficiency number (a.k.a. xiangting number, 向聴数).
-
easyfft
providing an easy FFT API for arrays and slices
-
version-ranges
Performance-optimized type for generic version ranges and operations on them
-
interp
Matlab's interp1 function
-
turborand
Fast random number generators
-
wyrand
A fast & portable non-cryptographic pseudorandom number generator and hashing algorithm
-
clingo
Rust idiomatic bindings to the clingo library
-
hime_sdk
Development kit for the generation of LR and RNGLR parsers programmatically or in command line. Full API for the manipulation of context-free grammars.
-
feruca
Unicode Collation Algorithm
-
random_word
Efficient functions for generating random words in many languages
-
cubecl-reduce
CubeCL Reduce Algorithms
-
smolprng
A Small and Extensible PRNG written in Rust
-
tenthash
A high-quality, non-cryptographic, 160-bit hash function
-
raftpico
Raft framework built on top of the raftbare crate
-
osqp
(Operator Splitting Quadratic Program) solver
-
kube_quantity
adding arithmetic operations to the Quantity type from the k8s-openapi crate
-
dilate
A compact, high performance integer dilation library for Rust
-
hi-doc-jumprope
fast rope (fancy string) library built on top of Skiplists - hi-doc fork
-
s2-tilejson
Backwards compatible JSON format for describing s2 map tilesets
-
fletcher
A dependency free implementation of the Fletcher's checksum algorithm
-
kmeans
Small and fast library for k-means clustering calculations
-
rapidhash
port of rapidhash: an extremely fast, high quality, platform-independent hashing algorithm
-
cryptocol
cryptographic library that includes big number arithmatic operation, hash algorithms, symmetric-key cryptographic encryption/decryption algorithms, asymmetric-key (public-key) cryptographic…
-
gcra
A basic implementation of GCRA algorithm for rate limiting
-
scnr
Scanner/Lexer with regex patterns and multiple modes
-
fast_polynomial
Faster polynomial evaluation using Estrin's Scheme to exploit instruction-level parallelism
-
pacmap
Pairwise Controlled Manifold Approximation (PaCMAP) for dimensionality reduction
-
tinymt
64/32 - a lightweight variant of Mersenne Twister PRNG
-
ra_ap_salsa
A generic framework for on-demand, incrementalized computation (experimental)
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
mpchash
Multi-probe consistent hashing algorithm implementation
-
pg_task
Resumable state machine based Postgres tasks
-
nozomi
Equivalent of the Linux shred command but in rust and library. Allows you to securely erase data from a hard drive.
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
highs
Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.
-
cobs
Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the "sentinel" value) is not used…
-
adler32
Minimal Adler32 implementation for Rust
-
dypdl
Libarary for Dynamic Programming Description Language (DyPDL)
-
stcalc
Stack calculator
-
syntree_layout
visualize trees from the 'syntree' crate
-
tribles
knowledge base implementation for rust
-
kdtree
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
optirustic
A multi-objective optimisation framework for Rust
-
rustradio
Software defined radio library
-
merkle-cbt
generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
rgeometry
High-Level Computational Geometry
-
kitoken
Fast and versatile tokenizer for language models, supporting BPE, Unigram and WordPiece tokenization
-
ipl3checksum
calculate the IPL3 checksum for N64 ROMs
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
evalexpr-jit
JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift
-
hyperloglogplus
HyperLogLog implementations
-
polylog
polylogarithms
-
contour-isobands
Compute isobands and contour polygons (using marching squares algorithm)
-
radiate
genetic algorithms and artificial evolution
-
geometry-predicates
port of robust geometric predicates
-
extendhash
Rust Hash Extender
-
rdst
A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes
-
relp-num
Number types for the relp crate
-
dogear
merging bookmark trees
-
wyhash
fast portable non-cryptographic hashing algorithm and random number generator
-
sonic-api
API for formally-verifiable distributed contracts
-
rand_aes
AES based pseudo-random number generator
-
logru
A small, embeddable and fast interpreter for a subset of Prolog
-
graaf
Work with directed graphs
-
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
-
trie_rcv
Ranked Choice Voting implementation using Tries in Rust
-
crc32-v2
A port of the CRC-32 algorithm to Rust
-
gix-revwalk
providing utilities for walking the revision graph
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
h3o-zip
A compression scheme tailored for H3 cell indexes
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
ckey
consistent hash key library
-
vecmath
type agnostic library for vector math designed for reexporting
-
rand_chacha
ChaCha random number generator
-
xxhrs
Safe XXHash and XXH3 bindings
-
wavefc
A home-grown implementation of the Wave Function Collapse algorithm
-
fakeit
Fake data generator library with 130+ functions
-
i_triangle
Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
lt-fm-index
Fm-index using k-mer lookup table for exact pattern matching
-
satkit
Satellite Toolkit
-
vector_quantizer
vector quantization utilities and functions
-
variadic_from
Variadic from
-
stringmetrics
approximate string matching
-
graphalgs
Graph algorithms based on the Rust 'petgraph' library
-
general-sam
A general suffix automaton implementation in Rust
-
timberio/file-source
A high-performance observability data pipeline
-
ran
fast random numbers generation
-
times
Timing Benchmark, Repeated Runs, with Statistics
-
ceres-solver
Safe Rust bindings for the Ceres Solver
-
metaheuristics-nature
A collection of nature-inspired metaheuristic algorithms
-
dlx-rs
dancing links in Rust
-
risc0-bigint2
RISC Zero's Big Integer Accelerator
-
startin
A Delaunay triangulator for terrains
-
single-svdlib
port of LAS2 from SVDLIBC
-
starlight
experimental HDL and optimizer for DAGs of lookup tables
-
runtime_units
A run-time Rust library for working with units of measurement and conversions between them
-
av-metrics
A collection of algorithms for measuring audio/video metrics
-
natord
Natural ordering for Rust
-
multimarkov
generic tool for training and using multi-order Markov chains for procedural generation applications such as generating randomized but authentic-sounding names for characters and locations
-
tolerance
Math representation of the physically needed permissible deviation of measures
-
simple_hll
HyperLogLog implementation in rust
-
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
-
tiny_sort
Binary-size optimized stable and unstable sorts
-
color_space
converting between color spaces and comparing colors
-
iban
IBAN parsing library
-
swift_vec
A convenient and comfortable vector maths crate that supports 2D, 3D, and 4D matrices and vectors - along with additional scalar math
-
kewb
manipulating and solving a 3x3 Rubik's cube with Kociemba's two phase algorithm
-
importunate
Methods for returning random elements from an iterator
-
pathfinding_astar
A-Star pathfinding algorithm that can process absract and grid-like paths
-
interval_adapter
Interval adapter for both open/closed implementations of intervals ( ranges )
-
arrow-string
String kernels for arrow arrays
-
mutcursor
Safely stores mutable references to parent nodes, for backtracking during traversal of tree & graph structures
-
many-unzip
multiunzipfrom itertools but with support for larger than 12-tuples -
kendalls
Kendall's tau rank correlation
-
adler2
clean-room implementation of the Adler-32 checksum
-
nekohash
A multifaceted hashing library for Rust
-
to_shmem
Trait to write to a contiguous chunk of shared memory
-
libsufr
Parallel Construction of Suffix Arrays in Rust
-
hypertwobits
cardinality estimation algorithm
-
volute
Boolean functions implementation, represented as lookup tables (LUT) or sum-of-products (SOP)
-
four-bar
Four🍀bar library provides simulation and synthesis function for four-bar linkages
-
sequence-generator-rust
Customizable 64-bit unique distributed IDs sequence generator based on Twitter's ID (snowflake). Build in Rust
-
oxidd-reorder
Reordering algorithms for OxiDD
-
opensimplex2
Port of OpenSimplex2
-
graph_process_manager_loggers
Generic loggers for graph_process_manager_core
-
fast-tlsh
generate / parse / compare TLSH locality sensitive hashes
-
simsearch
lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)
-
cassowary
linear constraint solving algorithm. The Cassowary algorithm is designed for naturally laying out user interfaces using linear constraints, like 'this button must line up with this text box'
-
sefar
evolutionary optimization algorithms
-
rand_jitter
Random number generator based on timing jitter
-
extsort
External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator
-
pcg_rand
PCG family of random number generators in pure Rust
-
raftbare
Minimal but feature-complete, I/O-free implementation of Raft distributed consensus algorithm
-
uutils_term_grid
formatting strings into a grid layout. Fork of term_grid.
-
sgrust
A sparse grid library written in Rust
-
jaime
j.a.i.m.e. is an ergonomic all purpose gradient descent engine
-
sobol_burley
A seedable Owen-scrambled Sobol sequence
-
jopemachine-raft
language implementation of Raft algorithm
-
counting_sort
Counting sort implementation for Iterators
-
cyclic-poly-23
A rolling, decomposable hash algorithm
-
tau-engine
A document tagging library
-
atomic-traits
The traits for generic atomic operations
-
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.
-
seastar
Dependency-free implementation of the A* pathfinding algorithm for uniform-cost, 2D grids in cardinal directions
-
easer
Tiny library imlementing Robert Penner's easing functions
-
permutation
Small utility for creating, manipulating, and applying permutations
-
flo_binding
Declarative binding library for Rust
-
bies
Helpers for dealing with BIES vectors with text segmentation applications
-
t-oc
Trie Occurrence Counter is frequency dictionary for any type implementing Iterator<Item = char>
-
algorithmica
Rust Algorithms
-
probability
The package provides a probability-theory toolbox
-
bpe-openai
Prebuilt fast byte-pair encoders for OpenAI
-
english-to-cron
converts natural language into cron expressions
-
rust_intervals
Intervals arithmetic with any combination of open, closed or infinite bounds, along with operations like intersection, convex hull, union, difference,
-
flat_spatial
Flat spatial partitionning algorithms and data structures
-
bit_gossip
Pathfinding library for calculating all node pairs' shortest paths in an unweighted undirected graph
-
mesh_to_sdf
Mesh to signed distance field (SDF) converter
-
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…
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phntnative Windows headers -
whittaker-eilers
A sparse matrix implementation of Whittaker-Eilers smoothing and interpolation
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
lookup-tables
High performance & compile-time customizable lookup tables
-
hmac-sha1
wrapper around the RustCrypto hmac and sha1 crates for simple HMAC-SHA1 generation
-
multistochgrad
Stochastic Gradient, Multithreaded
-
recursive
Easy recursion without stack overflows
-
oefpil
Optimum Estimate of Function Parameters by Iterated Linearization (OEFPIL): Algorithm for nonlinear function fitting to data with errors in both dependent and independent variables where correlation…
-
rollgrid
pseudo-infinite open worlds
-
autour_process
AUTOmata Utilities and Representation (AUTOUR) is a small toolbox to experiment with various kinds of automata and draw them
-
conhash
Consistent Hashing library in Rust
-
coord2d
rust lib for coordinate in 2d system
-
line-span
Find line ranges and jump between next and previous lines
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
lutz
"An Algorithm for the Real Time Analysis of Digitised Images" by R. K. Lutz
-
louvre
A Robust Triangulation Algorigthm
-
product-os-random
Product OS : Random provides a suite of random generator tools for different contexts. This includes random text, number and key generators including crypotgraphically secure random generation.
-
nu_plugin_hashes
A Nushell plugin that adds 61 cryptographic hash functions from Hashes project
-
graph-algorithms-rs
A collection of graph algorithms
-
rake
Rapid Automatic Keyword Extraction (RAKE) algorithm
-
solaris-rs
predict the position of the Sun
-
mittagleffler
High performance implementations of the Mittag-Leffler function
-
count-digits
A no-std trait to determine the lengths of integers in various number bases
-
spec_math
implementations of special mathematical functions. Includes re-implementation of the CEPHES math library for gamma functions, error functions, elliptic integrals, sine and cosine integrals…
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.
-
float_plus
Additional features for float values
-
drain_filter_polyfill
current nightly implementation of Vec::drain_filter, copypasted out for use on stable
-
bit_manipulation
lightweight Rust crate for seamless management and validation of up to 128 option states. Empower your applications with efficient, flexible, and intuitive option handling, ensuring…
-
density-rs
Superfast compression library
-
qptrie
A QP-Trie implementation for Rust
-
RustQuant_math
quantitative finance
-
fixed32
Fixed Point types
-
openraft-sledstore
A sled based implementation of the
openraft::RaftStoragetrait -
zeros
-
compute-it
define a lazy evaluated computation graph
-
compile_time_sort
Sort arrays and slices of primitives in const contexts
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
ruffer
overwriting ring buffer library written in Rust
-
is_sorted
Iterator sorted?
-
relp
Rust Exact Linear Programming
-
timelag
Creating time-lagged time series data
-
round_robin
Create a vector of rounds and their respective matches in a tournament, using the Round-robin algorithm
-
is-tree
Everything is a tree
-
float_next_after
A trait for native rust f64/f32 nextafter
-
controlled_astar
that provides an enhanced A* pathfinding algorithm with controllable node directions and block statuses, ideal for complex pathfinding scenarios
-
d3_geo_voronoi_rs
A port into rustlang of the javascript library d3-geo-voronoi
-
rex-sm
Hierarchical state machine
-
augurs-dtw
Dynamic Time Warping (DTW) algorithm for Rust
-
list_math
doing math on a list including average, smallest, largest, and standard deviation
-
libphext
A rust-native implementation of phext
-
dotlr
An LR(1) parser generator and visualizer created for educational purposes
-
noise-functions
Fast and lightweight noise functions
-
kalmanfilt
Kalman and other filters from Kalman-and-Bayesian-Filters-in-Python
-
random-pick
Pick an element from a slice randomly by given weights
-
ragged-buffer
Efficient RaggedBuffer datatype that implements 3D arrays with variable-length 2nd dimension
-
line-clipping
implementing line clipping algorithms
-
belnapian
Belnap's 4-valued logic basic building blocks in Rust
-
entropy-map
Ultra-low latency hash map using minimal perfect hash functions and compact encoding of values, minimizing memory footprint and storage size for efficient data retrieval
-
hud-slice-by-8
HUD Software's Rust improved implementation of the Intel Slice-By-8 algorithm
-
doxygen-bindgen
Converts Doxygen comments into Rustdoc markdown
-
pyin
pYIN pitch detection algorithm written in Rust
-
ratel_bandit
Muti-armed Bandit Simulator
-
spiral
Iterate over a 2D structure in a spiral pattern
-
linesweeper
Robust sweep-line algorithm and two-dimensional boolean ops
-
tifloats
Speedy, accurate emulation of TI-Floats
-
randevu
The official Rust implementation of the RANDEVU algorithm
-
to-display
A trait that is Display or can be converted to Display
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
edfsm
Event Driven Finite State Machine library
-
diffsl
A compiler for a domain-specific language for ordinary differential equations (ODE)
-
lilt
dependency free library for running interruptable, transition based animations as a function of time
-
rufl
A powerful util function library for rust
-
weighted_rand
A weighted random sampling crate using Walker's Alias Method
-
uint256
A light-weight implementation of 256-bit unsigned integers type with semantic API
-
tdigests
An efficient Rust implementation of the t-digest algorithm
-
bpe-tokenizer
A BPE Tokenizer library
-
rmqtt-raft
raft framework, for regular people
-
convolve2d
Easy and extensible pure rust image convolutions
-
dynalgo
A tiny library designed to produce animated SVG images that can illustrate graph algorithms in action
-
programinduction
program induction and learning representations
-
chibihash
hash function
-
random-nickname2
用于Rust的随机用户昵称生成器
-
fnir
Fast numerical integration rules, like tanh-sinh quadrature
-
dcc-lsystem
Lindenmayer system together with some rendering tools
-
geo-clipper
Boolean operations on polygons
-
hex2d
Helper library for working with 2d hex-grid maps
-
bitwuzla-sys
Low-level bindings for the Bitwuzla SMT solver
-
axgeom
that provides ability to extract 1d ranges out of 2d objects
-
fast-boolean-anf-transform
Fast implementation of the boolean Algebraic Normal Form (ANF) transform
-
intel-mkl-sys
Rust binding of unique functions in Intel(R) MKL
-
hrv-algos
A collection of algorithms for heart rate variability analysis
-
regexsolver
Manipulate regex and automaton as if they were sets
-
backyard-generator
Convert AST node back to PHP code
-
eta-algorithms
Low overhead data structures focused on performance
-
fastlem
generating procedural terrains based on simplified landscape evolution model (LEM)
-
liba
An algorithm library based on C/C++
-
lazy-bytes-cast
Lazy casts from & to byte arrays
-
opis
rational number and matrix arithmetic
-
faer_gmres
GMRES implementation using faer
-
probabilistic_bisector
bisection for one-dimensional functions in the presence of noise
-
tinyrand
Lightweight RNG specification and several ultrafast implementations in Rust
-
int_math
Integer math
-
arbi
Arbitrary Precision Integer
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
decmathlib-rs
Port of the Intel Decimal Floating-Point Math Library decimal128 type to Rust
-
twitter_snowflake
A lightweight, efficient library that implements Twitter's Snowflake algorithm
-
spc-rs
SPC (Statistical Process Control)
-
lace_cc
Core of the Lace cross-categorization engine library
-
astro
Advanced algorithms for astronomy
-
rustdct
Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust
-
anim8
Animation toolset
-
yafnv
Fowler-Noll-Vo (FNV-1, FNV-1a) hash implementation for
u32/u64/u128size, allno_stdandno_alloc -
umash
Idiomatic API for the umash hash/fingerprint function
-
cityhash-rs
Rust no_std implementation of Google Cityhash v1.0.2, v1.0.3, and v1.1.0
-
futf
Handling fragments of UTF-8
-
ognlib
Some code that is written to practice Rust
-
mocats
A fast, easy-to-use, generalized Monte Carlo Tree Search library. Works for any game, any number of players, and any tree policy (UCT Policy included as a default).
-
breakout
detection for Rust
-
perchance
Very simple random number generation optimized for ease of use
-
libbruteforce
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. PLEASE DO NOT use this…
-
ainconv
Converts Ainu words between different scripts (Katakana, Latin, Cyrillic)
-
sigmah
Create and scan binary signature in Rust efficiently
-
twistrs
An asynchronous domain name permutation and enumeration library
-
reveler
A cryptographic commitment scheme based on lattice and parallelized matrix-vector multiplication
-
kociemba
solving the 3x3 Rubik's cube with Kociemba's two phase algorithm
-
riichi-calc
calculate the score of a hand in riichi mahjong
-
atrocious_sort
Some of the most useless sorting algorithms implemented in Rust
-
crc-frame
functions for reading and writing crc32'd framed buffers
-
zorder
Fast Z-order curve conversions
-
noiselib
procedural 1D, 2D, 3D and 4D noise and fractal functions
-
kak-tabs
kakoune tabs
-
puan-rust
Puan package contain tools for defining logic relationships among linear inequalities and reduction algorithms
-
bsa3-hash
The hash function used in BSA files for *The Elder Scrolls III: Morrowind*
-
indexsort
sort crate, porting Golang sort package to Rust
-
hybridmap
Hybrid map using smallvec and the std hashmap
-
grid_pathfinding
Pathfinding using JPS and connected components on a grid
-
cdchunking
Content-defined chunking
-
strtod
A high precision floating point parser implementation for Rust
-
fixed32-math
Geometric types
-
bevy_lookup_curve
Editable lookup curve for Bevy
-
cint
A lean, minimal, and stable set of types for color interoperation between crates in Rust
-
rectutils
Common algorithms for rectangles (quadtree, rect packing, etc.)
-
linestring
line string toolbox
-
setsum
order-agnostic checksum
-
ccsort
clone of the Unix sort command, with multiple sorting algorithms
-
genetic-rs
A small crate for quickstarting genetic algorithm projects
-
undo_stack
A minimal undo stack for user defined types
-
random
The package provides sources of randomness
-
poi
A pragmatic point-free theorem prover assistant
-
multistream-batch
Implementations of batching algorithms
-
fuzzy_prefix_search
Fuzzy search for prefix matches
-
hostlist-parser
Parses hostlist expressions into a Vec of Strings
-
fnrs
some useful functions i like
-
mot-rs
Dead simple multi object tracking in Rust
-
rmpfit
Pure Rust implementation of the CMPFIT library
-
postcard-cobs
Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the "sentinel" value) is not used…
-
zmatrix
matrix calculation lib
-
faro_sharding
Non-shuffling sharding algorithm
-
blok
3D arrays that matter
-
mathml-core
MathML type definitions
-
rustiq-core
Quantum circuit synthesis library in rust
-
clipper2
A polygon Clipping and Offsetting library for Rust
-
hyperloglog-rs
HyperLogLog trying to be parsimonious with memory
-
extsort-iter
external sorting for all types for all iterators
-
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters's Pattern Defeating Quickselect
-
httlib-huffman
Canonical Huffman algorithm for handling HPACK format in HTTP/2
-
flexihash
Consistent hashing following the API and compatible with flexihash-php and flexihash-py
-
easy_salt
generating hashed strings with salt, currently based on easy-hasher crate
-
battleship_bot
The game of battleship and a few bot implementations
-
nonbox
NaN boxing without boxing
-
misfortunate
Perverse implementations of safe Rust traits
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
deki
A base for most of my rust projects (tailored to myself)!
-
rust_cascade
bloom filter cascade implementation in Rust
-
wcs
FITS World Coordinate System (WCS)
-
meval
math expression parser and evaluator
-
lp-solvers
.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK
-
dredd-rs
rules engine for Rust, adapted from the Dredd implementation for Android
-
ggstd
Partial implementation of Go standard library
-
u4
nibble (4-bit integer) library, with packed representations
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
romu
A pseudo random number generator using the Romu algorithm
-
del-ls
sparse solver library for research prototyping
-
glidesort
sorting algorithm
-
tiny-earley
Minimalistic implementation of Earley's algorithm
-
snowflaker
A Twitter snowflake algorithm simply implemented in Rust
-
evo_framework
Evo(lution) framework: A powerful framework designed for ai
-
clf
flush the cpu cache line by __builtin_clear_cache()
-
orx-funvec
Traits to unify access to elements of n-dimensional vectors which are particularly useful in algorithms requiring both flexibility through abstraction over inputs and performance through monomorphization
-
gridish
working with British and Irish national grid strings
-
funspace
N-dimensional function spaces and transforms
-
board-game
A board game abstraction and generic utilities around it
-
ufotofu_queues
Infallible queues that support bulk enqueueing and dequeueing
-
ibn_battuta
Solving the Travelling Salesman Problem (TSP)
-
ext-sort
rust external sort algorithm implementation
-
autodiff
An automatic differentiation library
-
tagged_ufs
A union-find-set implementation, in which sets can be associated with tags. When two sets are united, their tags are merged
-
ring-log
High-performance logger with lock-free ring buffer
-
markov_namegen
Random text generators based on Markov models
-
sorock
A Multi-Raft implementation in Rust
-
vrp-scientific
An extension logic for solving scientific VRP
-
fuzzyhash
Pure Rust fuzzy hash implementation
-
screwsat
condlict driven clause learning sat solver
-
libmf
Large-scale sparse matrix factorization for Rust
-
tetengo_lattice
Viterbi search and A* algorithm implementation
-
zung_mini
Mini rust projects that target specific features of rust
-
polyline-ffi
FFI bindings for the polyline crate
-
soukoban
some algorithms and data structures related to Sokoban
-
line-col
Convert string slice indices into line/column numbers
-
office-to-pdf
Convert office files to pdf files
-
lophat
Lockfree Persistent Homology Algorithm Toolbox
-
cnccoder
generating gcode operations targeted for GRBL controled cnc machines, and also generates camotics projects for simulation
-
rugraph
undirected, directed and multidirected graph library
-
abv
AV and BV convert functions for Bilibili videos
-
fsmentry
Finite State Machines with an entry API and data storage
-
suitesparse_sys
sys crate for suitesparse library
-
lotus-script
creating LOTUS-Simulator scripts
-
string-offsets
Converts string offsets between UTF-8 bytes, UTF-16 code units, Unicode code points, and lines
-
localsearch
Local Search based Metaheuristics
-
keyphrases
Rapid Automatic Keyword Extraction (RAKE) implementation in Rust
-
multibody_dynamics
Multibody dynamics algorithms in Rust
-
stable_matching
Gale-Shapley stable matching algorithm
-
elites
A fast and robust implementation of the Map-Elites algorithm in Rust
-
algebraics
algebraic numbers library
-
accumulator-plus
Accumulator based on Biguint
-
explicit-endian
Transparent traits to explicitely declare in-memory endianness for a virable or struct record
-
simplerandom
pseudo-random number generators
-
mylibrary_
my personal library
-
dmp
A high-performance library in that manipulates plain text
-
wave-function-collapse
Converts nodes and their restrictions into a collapsed node state based on the selected algorithm
-
revec
Convert a Vec<A> to a Vec<B> provided vec is empty
-
min2phase
An optimized implementation of two-phase algorithm for solving Rubik's cube
-
qrc
generating and manipulating QR code images in various formats
-
sets
Generic vectors as sets. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.
-
raftify
Experimental High level Raft framework
-
ratio-color
Ratio's color palette management in Rust, built on 'palette' and 'enterpolation'
-
dawg
Directed Acyclic Word Graph
-
screeps-game-utils
Additional utility functionality for Screeps: World not included in screeps-game-api
-
randm
Small, fast, and efficient random generation crate
-
global-static
Lazily evaluated non-constant static items
-
punkt
sentence tokenizer
-
ant-registers
Register logic for Autonomi
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
parol_runtime
Runtime library for parsers generated by the 'parol' parser generator
-
lds-rs
Low Discrepancy Sequence Generation in Rust
-
iceyee_random
Random
-
lazyrand
generating random numbers easily
-
integraal
Integral computation, done in Rust!
-
advanced-pid
An advanced PID control library implemented in Rust
-
iterextd
This trait provides additional methods for working with iterators, enhancing their functionality
-
pergola
abstract types for join-semilattices
-
ch_cityhash102
ClickHouse CityHash implementation
-
mctser
An incridiblely easy-to-use library for Monte Carlo Tree Search
-
metaheuristics
Find approximate solutions to your optimisation problem using metaheuristics algorithms
-
pumpkin-solver
The Pumpkin combinatorial optimisation solver library
-
sonyflake
A distributed unique ID generator inspired by Twitter's Snowflake
-
itermaps
Implement commonly used combinations of
Iterator::map -
autom
Automaton
-
egraph-serialize
serialize e-graphs
-
g2poly
Primitive implementation of polynomials over the field GF(2)
-
topo_sort
A 'cycle-safe' topological sort for a set of nodes with dependencies
-
velodyne-lidar
Velodyne lidar data processing algorithms and utilities
-
hyperloglog
in Rust
-
re_arrow2
Unofficial implementation of Apache Arrow spec in safe Rust
-
pingora-limits
rate limiting and event frequency estimation
-
aochelpers
A set of structs and associated methods that cover common use=cases when solving Advent Of Code problems
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
sample-std
Sampler definitions and implementations for st
-
space-search
providing basic generic depth-first, breadth-first, heuristic-guided, and A* search space exploration algorithms
-
windmouse-rs
windmouse
-
guid-create
Rust helper for creating GUIDs
-
timely_container
Container abstractions for Timely
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki's C library libLBFGS
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
rand_pcg
Selected PCG random number generators
-
rsbatch-maestro
flexible batch splitting and management with various strategies
-
diffmatchpatch
Rewrite of diff-match-patch in Rust
-
loop
The package allows for processing iterators in parallel
-
xentrace-parser
A XenTrace files parser with a study purpose
-
binary-merge
Minimum comparison merge of two sorted sequences with random access
-
screeps-pathfinding
Pathfinding algorithms for Screeps: World in native Rust
-
rindex
dynamic spatial index for efficiently maintaining *k* nearest neighbors graph of multi-dimensional clustered datasets
-
codeq
Codec trait
-
uuid-rs
Universally Unique IDentifier (UUID)
-
nphysics_testbed2d
Testbed for the 2-dimensional physics engine in Rust
-
cobyla
optimizer for Rust
-
diffs
A number of diff algorithms, also called longest common subsequence
-
tempoid
Generates URL-friendly, unique, and short IDs that are sortable by time. Inspired by nanoid and UUIDv7.
-
another-html-builder
html builder, focused on being a helper for creating elements, escaping attributes, escaping text, but not caring if the html structure is valid. It's up to the developer to test that.
-
ez-bencoding
bencoding library, which uses the bdecode algorithm from libtorrent 3rd edition
-
lerp
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
wpa-psk
Compute the WPA-PSK of a Wi-FI SSID and passphrase
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
monument
A fast and flexible composition generator
-
castep-param-io
read, operate on and write castep
.paramparameter file -
voxell_rng
Cheap and dirty thread-local RNGs
-
tuid
Sequential UUID generator
-
progress-encode
Progress ENCODE function
-
rand-unique
A no-std crate for generating random sequences of unique integers in O(1) time
-
bpcon
Byzantine Fault-Tolerant Consensus Protocol Implementation in Rust
-
algorithms_fourth
用rust实现算法4书中的算法，作为rust的学习实践
-
graphbench
A sparse graph analysis library
-
autd3-gain-holo
Holo (Multiple foci) Gain for autd3
-
liblrge
Genome size estimation from long read overlaps
-
sparta
software components specially designed for building high-performance static analyzers based on the theory of Abstract Interpretation
-
cube-rotations
Models the rotations that can happen on a cube without changing the set of planes to which its faces are parallel
-
dioxus-lazy
Async list components for Dioxus
-
derangements
Generate derangements of an iterable
-
light-tool
轻量级的Rust工具库
-
merged_range2
rangeset that can merge overlapping ranges (fork of merged_range)
-
ryley
Syntax unifies programmers
-
mcts-rs
Monte Carlo Tree Search (MCTS) using an arena allocator
-
i_key_sort
A fast sorting algorithm combining bin and counting sort. Optimized for scenarios where a primary key can be extracted to index elements into buckets.
-
hexdump
Easy hexdump to stdout or as an iterator
-
length
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.
-
f3l_search_tree
3D Point Cloud Library
-
extprim
Extra primitive types (u128, i128)
-
re_space_view_map
A space view that shows a map
-
hypersonic
Formally-verifiable distributed software
-
cuda_std
Standard library for CUDA with rustc_codegen_nvvm
-
memx-cdy
The fast memory functions like a libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
async_wrr_queue
[async & high performance] queued weighted round-robin load balance algorithm
-
kaede
adalah rust library untuk operasi matematika sederhana
-
uvgen
Triplanar texture coordinates generator and packer
-
unkocrypto_rs
unkocrypto (rust)
-
based16
BASE-16(HEX) implementation for chads
-
fr_alebref_libbrefdata
BrefData library
-
impls_index
Several of macros to put each function under a named macro to index every function in a class
-
penumbra-sdk-shielded-pool
Multi-asset shielded pool implementation for Penumbra
-
tick-queue
Tick ordered queue
-
biscuit-converter
A decimal ASCII parser
-
ordinal
Formatting of ordinals (1st, 2nd, 3rd etc)
-
mckernant1-tools
My random tools
-
singlevec
Vec-like container optimized for storing only a single item
-
superslice
Extensions for slices
-
peek-again
A performant iterator providing double peek functionality
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
checksum-tapestry
Collection of checksum algorithms and examples
-
data_storage_units
Unit converter for rust language
-
chksum-hash
hash algorithms for batch and stream computation
-
ntree-rs
A mutable n-tree with async support
-
median-accumulator
fast, space-efficient, generic accumulator for computing median
-
editdistancek
Fast algorithm for computing edit distance
-
linearsort
Sorting in linear time 🤔
-
kabsch_umeyama
Kabsch-Umeyama algorithm is a method for aligning and comparing the similarity between two sets of points. It finds the optimal translation, rotation and scaling by minimizing the root-mean-square deviation (RMSD)…
-
arithmetify
arithmetic coding
-
pinned-deque
A high-performance double-ended queue, inspired by BOOST deque. Every element in this deque is pinned until its popping
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
chrf
algorithm
-
rb-interval-map
rb-interval-mapis a map based on interval tree -
beetle_bits
A collection of bit-based types. Currently only u1 (1bit uint) and f3 (3bit float) are implemented
-
genevo
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
-
knossos
generating and rendering mazes
-
combination
A lib to do math jobs like permutate and combinate data from vec
-
dendritic-autodiff
Autodifferentation package for scalar and multi dimensional values
-
bnb
A generic template for Branch & Bound algorithms
-
ncollide3d-updated
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
double-ended-peekable
An adapter providing peeking features to double-ended iterators
-
seedling
hierarchical seeded pseudo-random number generators
-
random-picker
Generates random choices based on the weight table of probabilities. It can be used to calculate each item's probability of being picked up when picking a given amount of non-repetitive items…
-
logicng
Creating, Manipulating, and Solving Boolean Formulas
-
graph_builder
A building block for high-performant graph algorithms
-
math-ops
Mathematical and statistical operations on vectors
-
minifb_tile_base
A basic tile updater for minifb
-
rust_sensitive
Sensitive word filtering, support multiple data source loading, multiple filtering algorithms, multiple operation functions
-
jdt_activity_pub
ActivityPub is a set of structs and enums used to facilitate the operations of ActivityPub servers and clients
-
natural
Pure rust library for natural language processing
-
sa-is
algorithm for suffix array construction
-
vcg-auction
A Vickrey-Clarke-Groves auction library
-
blake2b-ref
A
no_stdBLAKE2B implementation -
lcg69069
/ MTH$RANDOM Pseudorandom linear congruential generator
-
svdlibrs
port of LAS2 from SVDLIBC
-
spectrex
AstroBWTv3 CPU mining algorithm in Rust
-
dual_threshold_optimization
Dual Threshold Optimization compares two ranked lists of features (e.g. genes) to determine the rank threshold for each list that minimizes the hypergeometric p-value of the overlap of features…
-
weighted-rs
A libray for weighted balancing algorithm
-
cvt
Expose the cvt function from Rust libstd
-
stochastic_universal_sampling
The stochastic universal sampling algorithm for the rand crate
-
aula_27
Aula de Library
-
range_rover
Function to pack integers into ranges
-
bandit
Algorithms in Rust
-
rs2
Reed-Solomon FEC for CCSDS downlink decoding
-
steepen
Create multiple iterators from a single iterator by separating elements
-
elipdotter
Embeddable full text search engine
-
downsample
keep downsampled history of data over long period of time
-
regex-filtered
Efficiently check an input against a large number of patterns
-
microns
float to fixed precision conversion
-
gcr
A fast, simple, and small Generic Cell Rate (GCR) algorithm implementation with zero dependencies
-
ckb-rust-std
A collection of
no_stdcompatible modules ported from Rust’s standard library, with an initial focus on theiomodule -
metaheurustics-rs
A comprehensive collection of metaheuristic optimization algorithms implemented in Rust
-
actionable
An enum-based async framework for building permission-driven APIs
-
burster
Lightweight stack allocated rate limiter implementations
-
ratio-genetic
Ratio's genetic algorithms library
-
extsort-lily
An efficient external merge sort implementation
-
b2c2-debugger
CASL2のコードを雑雑に実行テストするCOMET2シミュレーター(エミュレーター?)もどき
-
ssa-impls
common SSA algorithms
-
easing-fixed
easing iterators using fixed-point math
-
fenris-solid
Solid mechanics functionality for fenris
-
stack-cell-ref
Share a reference in thread inner
-
sort
sort algorithms
-
cryptominisat
Rust bindings for CryptoMiniSat, a boolean satisfiability solver
-
partition
slices in-place by a predicate
-
ar-reshaper
A no-std crate to reconstruct Arabic, turkish and persian sentences to be used in applications that don't support Arabic script
-
bitutils2
A package of tools for bit manipulations, including bit indexing, bitfields, and a variation of regular expressions for binary data
-
tectonic_engine_spx2html
The Tectonic engine that converts SPX output to HTML
-
doers
generating Design Of Experiments (DOE)
-
ms_toollib
Algorithms for Minesweeper
-
floaters
generate floating-point numbers in various ways
-
fenex
parsing and handling FEN and algebraic chess notations
-
cytogon
Mesh generation library based on cellular automata
-
zoc
Z-order curve based multidimensional range search
-
our-string
Customizable shared strings with inlining
-
maschen
A no-std compatible shunting yard implementation
-
numext-fixed-uint
Fixed-size uint types
-
asciidork-dr-html-backend
Asciidork Asciidoctor HTML backend
-
ropr
A blazing fast multithreaded ROP Gadget finder. ropper / ropgadget alternative
-
cvmcount
CVM algorithm to quickly estimate the number of distinct elements in a stream
-
specimen__multistringmap
An algorithm to compute cross products of multiple arrays
-
sudoku-solver
backtracking algorithm for solving sudoku
-
truck-polymesh
defines polygon data structure and some algorithms handling mesh, including meshing the shapes
-
general_stable_vec
A Vec implementation with stable indices
-
vec_clock
Vector clock implimentation
-
vec_to_array
Moves a heap allocated
Vec<T>to an stack allocated array of typeTand sizeN -
delatin
Fast TIN generation using Delaunay triangulation
-
phastft
A high-performance, quantum-inspired, implementation of FFT in pure Rust
-
treerder
Trie ordering for type implementing Orderable
-
sepax2d
A safe crate for finding and resolving collisions of 2D convex shapes using the Separating Axis Theorem
-
meshmeshmesh
Open-source mesh processing library
-
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
-
algorithmify
Create specifications for algorithms defined using Rust code
-
iterators_extended
Some useful extensions to Rust's iterators
-
here_be_dragons
Map generator for games
-
easing-function
easing functions for animation tweening
-
pi_orca
A* Path Finding Algorithm
-
polyeval
Evaluate polynomials
-
rusty_units
storing units of measurement in Rust
-
sapling-mincode
Bincode-like serialization with VLQ encoded integers
-
rcuber
rubiks cube and solver (LBL, CFOP, Roux, min2phase)
-
hampel
Sequential outlier detection and removal using Hampel identifiers
-
hash-roll
Rolling hashes & Content Defined Chunking (cdc)
-
substack
Stackbound iterable linked list for heap-free recursive algorithms
-
od_opencv
Object detection utilities in Rust programming language for YOLO-based neural networks in OpenCV ecosystem
-
dkg
Distributed key generation over ff/group
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
smtlib
A high-level API for interacting with SMT solvers
-
rustsat-ipasir
IPASIR bindings for RustSAT
-
nine_patch_drawable
core functionality to read nine patch bitmaps defined in Android NinePatch drawables and algorithms to scale them
-
bit-iter
Iterate forward or backwards over the positions of set bits in a word
-
quadtree-f32
dependency-free ID-based quadtree
-
xfeval
the Excel-like formula calculator
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
dzn-rs
dealing with DZN files used in the MiniZinc language
-
matrixcompare
Tools for convenient comparison of matrices
-
anyhash
Traits and utilities for making hashes of any type
-
constrained_int
Integers that are constrained within inclusive ranges
-
luhn_tools
A fast, minimal implementation of the Luhn algorithm
-
requests_rs
sending GET/POST requests and parsing jsons, included with an async file downloader. Intended for mostly small projects which need to make quick GET/POST requests or download files.
-
out
fast min and max functionality for collections
-
iter-set-ops
Fast set operations on an arbitrary number of sorted deduplicated iterators
-
glar-gemm-f16
high performance cpu kernels
-
redux-rs
Redux
-
gcollections
Generic traits over Rust collections library
-
pagat
that helps you split the bill
-
gad
Generic automatic differentiation for Rust
-
cubecl-opt
Compiler optimizations for CubeCL
-
median
efficient O(n) median filter
-
bit-cursor
A cursor that supports bit-level reads and writes
-
bananapeel
A darn-slippery obfuscator algorithm!
-
strprox
Top-k string autocompletion
-
lazysort
Lazy sorting for iterators
-
geo-core
Common tools for working with spatial data
-
ssr-algorithms
spaced repetition algorithms
-
rustronomy-watershed
a pure-rust implementation of the segmenting and merging watershed algorithms
-
bpe
Fast byte-pair encoding implementation
-
fft2d
Fourier transform for 2D data such as images
-
crcxx
computes CRC-8/16/32/64/128 using various methods. Included catalog of CRC parameters simplify usage.
-
geocraft
Geocraft
-
fast-math
Fast, approximate versions of mathematical functions
-
fusion-imu
Rust wrapper for the Fusion AHRS C library
-
furze
finite state transducers (fst) writen in rust
-
gix-filter
gitoxide project implementing git filters
-
sulid
unique ID generation algorithm that combines the benefits of ULID and Snowflake
-
catclustering
Agglomerative Clustering For Categorical Data
-
acap
As Close As Possible — nearest neighbor search in Rust
-
hilbert
curve transform and inverse for points having two to thousands of dimensions, using Skilling's algorithm
-
anaso_algorithm
The recommendation algorithm for Ana.so
-
toyai
A small collection of ai algorithms to perform some simple prediction on structured data
-
fugue
A binary analysis framework written in Rust
-
collision
extension to cgmath
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
cogitate
Algorithms made in Rust
-
lockjaw_common
lockjaw common lib. only to be used by https://crates.io/crates/lockjaw.
-
three-style
A CLI tool for searching 3x3 Rubiks'cube 3-style commutators
-
sapling-dag
DAG used for source control
-
gametime
Time handling library for games
-
raddy
An automatic differentiation system for geometry and simulation
-
trading-enhancers
some 'enhancers' as data pipelines for type-safe HFT trading based on trading-types defs
-
fqdn-trie
FQDN (Fully Qualified Domain Name) lookup structures (based on tries)
-
earclip
Triangle mesh designed to be fast, efficient, and sphere capable
-
big-int
arbitrary-precision, arbitrary-base arithmetic, supporting arbitrarily large integers of any base from 2 to u64::MAX
-
rev_bits
reverses bits in a specified range
-
augurs-clustering
Time series clustering
-
arcos-kdl
ARCOS-Lab Kinematics and Dynamics Library
-
mur3
language implementation of MurmurHash3
-
sobol
sequence generator for Rust
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
teliox
Transaction Event Log
-
snmptools
SNMP common tools
-
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
murmurhash
MurmurHash3 implementation in Rust
-
ac-library-rs
port of AtCoder Library (ACL)
-
iregex-automata
Finite automata definitions for the
iregexcrate -
fast-shard
High-performance configurable sharding library with SIMD optimizations
-
mersenne_twister_rs
porting Mersenne Twister to Rust
-
oxygraph
Algorithms and structures on ecological graphs
-
statig
Hierarchical state machines for designing event-driven systems
-
cps_st_machine
State machines driven by continuation passing style
-
fast_poisson
Bridson's algorithm for fast Poisson disk sampling
-
num-notation
Offers multiple numeric choices, allowing you to work with various number representations including StandardForm, fractions, and f64 floating-point decimals. This versatile crate empowers…
-
pso-rs
Particle Swarm Optimization implementation in Rust
-
map_range_int
map a value from one range to another
-
nblast
neurite similarity algorithm
-
beetle-collatz
A collection of functions relating to the Collatz conjecture
-
kmpm
KMP(Knuth-Morris-Pratt algorithm) method library
-
geqslib
Equation solving made easy in Rust and beyond!
-
limited-queue
a limited queue that overrides the oldest data if trying to push a data when the queue is full
-
uuid-by-string
Generating uuid-hash from string
-
movavg
Generic Moving Average calculation
-
fastbuf
single-thread-oriented very fast byte buffer
-
narr
Numeric Calc
-
rust-bigint
Common traits and methods for multiple BigInt implementations
-
derivative_pricer
providing pricers for various options in a Black-Scholes setting
-
esl01-dag
DAG used for source control
-
numint
ODE solvers and numerical integration in Rust
-
xyzvec
Statically allocated fixed-size vectors for working in 2 and 3 dimensions
-
ru_annoy
annoy(https://github.com/spotify/annoy) (Index serving only). Providing C api as well
-
ring_buffer
RingBuffer is a queue with added random access
-
sorting_lib
lib implementing sort algorithm?
-
miniball
Minimum enclosing ball
-
fnv0
FNV0/1/1a 32/64/128-bit hash functions
-
permute
Generate permutations of vectors and slices in a memory-efficient and deterministic manner, using Heap's algorithm
-
sort-it
various sorting algorithms
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
geo-aid-script
Geo-AID's subcrate for parsing GeoScript
-
lightmap
Light map generator
-
eddie
Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler
-
pubgrub
version solving algorithm
-
dach
A general delta encoded network difference algorithm
-
luhn
validation 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
-
hash-iter
Iterator producing sequence of hash values for a given input (using double hashing technique)
-
swimos_rtree
SwimOS R-Tree
-
cdc
performing Content-Defined Chunking (CDC) on data streams
-
satif-kissat
Rust wrapper for the kissat SAT solver
-
lazy_diamond_square
Lazy implementation of the diamond-square without randomness
-
dragoonfri
Fast Reed-solomon Interactive oracle proof of proximity
-
fibonacci-numbers
The 59th Fibonacci number
-
block-mesh
Fast algorithms for generating voxel block meshes from arrays
-
punkt_n
Punkt sentence tokenizer
-
eta-graph
Low overhead graph library focused on performance
-
swf-fixed
SWF fixed-point numbers for Rust
-
aoc-toolbox
An helping framework to Advent of Code
-
linear-map
A map implemented by searching linearly in a vector
-
net_promoter_score
calculating Net Promoter Score (NPS) from survey responses
-
entro-spin
Entro Spin is a 64-bit, true-random number generator algorithm
-
kl_one
KL-One algorithm
-
time-key-stream-set
A time-keyed stream set
-
guts
Traits for constructing/destructuring from/into a type's internal guts
-
kanaria
functions such as hiragana, katakana, half-width and full-width mutual conversion and discrimination
-
human-sort
Human sort (natural sort) implementation
-
jsonposition
Finds a path to a JSON element at a provided string index
-
density-mesh-core
Core module for density mesh generator
-
apodize
iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows
-
convert-base
convert the radix (base) of digits stored in a vector
-
big-rational-str
Format and parse BigRationals to/from decimal numbers
-
autour_core
AUTOmata Utilities and Representation (AUTOUR) is a small toolbox to experiment with various kinds of automata and draw them
-
rustint
working with RGB colors
-
iter-group
grouping (key,value) iterators into maps of collections
-
throttle_lock
Throttle can be used to monitor and limit user activity
-
vrp-pragmatic
An extension logic for solving rich VRP
-
chrono-probe
Compare and measure the time complexity of algorithms
-
nmm_lib
nine mens morris
-
graph-types
Shared types for graph theory
-
parity-map
For mapping integers based on their parity
-
kidy
kinematics and dynamics of multi-body
-
meiosis
An evolutionary algorithm library with as many compile time checks as possible
-
poisson-diskus
Poisson disk distribution sampling
-
subslice
Fast subslice search
-
multidimension
High-level manipulation of multi-dimensional arrays
-
const_ranged_int
Ranged constant integers. Useful for lookup tables with constrained values to avoid secondary bounds check.
-
arrsac
From the paper "A Comparative Analysis of RANSAC Techniques Leading to Adaptive Real-Time Random Sample Consensus"
-
fast_ode
Fast Runge-Kutta implementation for solving ordinary differential equations
-
boolector
Safe high-level bindings for the Boolector SMT solver
-
kratom
neural network library
-
hungarian
fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
timeharsh
implements the timehash algorithm, an algorithm for creating user configurable, variable-precision sliding windows of time. Useful for binning time values in large collections of data.
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
gchemol-geometry
gchemol: a Graph-based CHEMical Objects Library
-
winconsole
A wrapper for console-related functions in the Windows API
-
portmatching
Fast Graph Matching for Port Graphs
-
minecraft_downloader_core
A Minecraft downloader written in rust
-
freelist-rs
Free list for numeric values
-
worley-noise
Worley noise implementation
-
rip_shuffle
Fast sequential and parallel in-place shuffling algorithms
-
rusty_planner
Artificial intelligence planning & reasoning library for Rust
-
kzg-commitment
perform KZG polynomial commitment scheme
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
inter-val
Mathematical intervals, i.g., [a, b], (a, b), [a, b), and (a, b] on ℝ, and multi-dimensional axis-aligned boxes represented as Cartesian product of intervals
-
nsga
Multi-objective genetic optimization algorithm NSGA-II
-
euclidean_algo
euclidean algorithm to find the greatest common divisor
-
symspell
Spelling correction & Fuzzy search
-
imohash
Fast hashing for large files
-
nd-icp
Generic n dimensional implementation of the ICP algorithm based on SVD and the nalgebra linear algebra library
-
pagination-packing
efficiently solving bin-packing problems with overlap: so-called “pagination” problems
-
clustering
easy way to perform kmeans clustering on arbitrary data
-
komunikilo
A chaotic communications simulator
-
svi
a function to interpolate variables in a hashmap into a format string
-
fst-no-std
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
enso-prelude
An augmented standard library in the vein of Haskell's prelude
-
hexagonal_pathfinding_astar
A-Star pathfinding algorithm tailored for traversing a bespoke collection of weighted hexagons
-
varisat
A CDCL based SAT solver (library)
-
grb-sys2
Gurobi C API FFI declarations
-
causal-hub
A hub for Causal Data Science
-
rust-sugiyama
Sugiyama's algorithm to calculate coordinates of a directed graph
-
extended-isolation-forest
rust port of the anomaly detection algorithm
-
decompound
Decompose a compound word into its constituent parts. Works in any language, as you provide the rules around what constitutes a (*single*) word.
-
logicgate
logic gates with NAND gates as the underlying layer Turing Complete
-
lol-core
A Raft implementation in Rust language
-
vtmachine
State machine for VT100-like terminal data streams
-
buldak
that provides various sorting functions
-
abstract_integers
Defining specification-friendly bounded natural integer types
-
weak_true
Similar to the automatic implicit conversion to boolean values in weakly typed languages
-
pi_ext_heap
Extending the heap supports deleting and modifying the elements at the specified location. When the elements in the heap move, the callback function will be called
-
libtombala
Mugsoft Tombala Game
-
cplex-sys
Low level bindings to the Cplex C-API
-
round_float
Round
f64andf32to specified number of decimals -
sn-merkle-trie
Minimal starknet merkle patricia trie implementation
-
fmttools
Tools for modifying text without allocating any intermediate buffers or unsafe code
-
zzz
Fast progress bar with sane defaults
-
matrix-oxide
Lightweight Linear Algebra Library For Rust
-
interpolation_search
Interpolation search - binary search on steroids
-
colorbox
A low-level toolbox for working with color
-
iter-set
Set operations on sorted, deduplicated iterators
-
sss_moo
SSS Many-Objective Optimization Framework
-
buf-min
Minimal utf-8 safe buffer traits
-
UUID_extend
Extension of uuid generation based on snowflake algorithm and implementation of ID to string conversion
-
bs
bitset with small-set (single-word) optimization
-
voro_rs
binding for voro++ library
-
nydus-error
Error handling utilities for Nydus Image Service
-
lambdautils
random utlities I need from time to time but don't fit their own crates
-
randomize
Randomization routines
-
neophyte-ui-event
Parsing for Neovim UI events
-
appendlist
An append-only list that preserves references to its elements
-
simple-easing
Set of simple easing functions
-
number-based
attempt of mine to make working with number bases simple
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
binpack2d
A two-dimensional rectangle bin-packing algorithm
-
spatial
An N-Dimensional R-tree family spatial tree implementations
-
tea-dtype
provide datatype and useful traits for datatype
-
pcg32
No-frills PCG32 random number generator implementation
-
jellyfish
Approximate and phonetic matching of strings
-
shape-core
Definition of geometry shapes
-
cyclic_list
a doubly-linked list with owned nodes, implemented as a cyclic list
-
fast-float-to-integer
Convert floating point values to integer types faster than the standard
asoperator -
moga
A multi-objective genetic algorithm framework
-
bool-toggle
bool toggling for the bool toggle enjoyers
-
scm-bisect
Supporting library for git-branchless
-
materialized-view
incremental materialized views for the masses
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
hexagex
Match binary data with hexadecimal regexes
-
xmlwriter
streaming XML writer
-
algograph
A (both directed and undirected) graph and their algorithms implemented in Rust
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
rev_buf_reader
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.
-
rizzer
Fuzzy matching tool to find string similarity
-
euc_lib
Easy to use implementation of extended and normanl Euclidean algorithm
-
dfo
Differentiable Floating-point Operations in Rust
-
line_2d
Bresenham's line algorithm as a rust iterator
-
powerboxesrs
functions to manipulate and compute metrics on boxes
-
cuv
Compressed unit vectors that can be used to store things like normal vectors efficiently
-
mfem
A high-level Rust wrapper for MFEM
-
addchain
Generate addition chains
-
inator
Optimal zero-copy parsers with nondeterministic finite automata
-
node2vec
in rust
-
affinityprop
Vectorized and Parallelized Affinity Propagation
-
wiiu_swizzle
Wii U texture memory tiling
-
quasirandom
number generation
-
quickdiv
Faster repeated division and modulo operations by the same divisor
-
rselib
Misc algorithms implemented for embedded usage (i.e., wasm)
-
phi-accrual-detector
Pluggable phi-accrual-detection package for healthcheck of monitored processes
-
cubic_spline
Function that calculates curve points for cubic spline
-
dess
Differential Equation System Solver (DESS) is a Rust crate implementing fixed-step and adaptive-step solvers and designed especially for modeling physical systems. Seven explicit ordinary differential equation (ODE)…
-
avm1-emitter
AVM1 emitter
-
qdft
Constant-Q Sliding DFT
-
rand_seeder
A universal random number seeder based on SipHash
-
geos-sys
GEOS C API bindings
-
toffee
Get command to run to run specific test in a file
-
light-double-ratchet
implements the Double Ratchet algorithm in Rust
-
shadowcast
recursive shadowcast visible-area detection algorithm
-
cursorsort
A QuickSort implementation with a cursor based partitioner and pivot selector
-
tree_traversal
Find best leaf node in a tree
-
codes-check-digits
Common implementation of check digit algorithms
-
bisection
Python bisect module
-
bigbit
Implements the BigBit format, allowing for compact storage of arbitrarily large numbers
-
fqn-estimator
Fast online Qn scale estimator in Rust
-
gtin-validate
Validate GTIN barcodes including UPC-A and EAN-13. This module has built-in support for GTIN-8, GTIN-12 (UPC-A), GTIN-13 (EAN-13), and GTIN-14 codes
-
iterslide
A "sliding window" iterator
-
scale_std
datastructures and algorithms to be run on the SCALE engine
-
asap-rs
Automatic Smoothing for Attention Prioritization for Time Series
-
text-file-sort
Sort a text file similar to linux sort
-
lindenmayer
Memory Efficient Lindenmayer-Systems
-
prepona
A graph crate with simplicity in mind
-
travelling_salesman
Travelling Salesman Problem Solvers
-
lootr
RPG-like looting system
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
coinutils-src
Redistribution of Coin-OR CoinUtils as a crate
-
search_trees
binary search tree, red-black tree, and AVL tree
-
tokeneer
tokenizer crate
-
augrim
consensus algorithms implemented in Rust
-
murmurhash3
MurmurHash3 implementation
-
rasterization
Iterator and iterator adapters for rasterizing a circle and its parts
-
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
bex
working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
decimal-wad
Math for preserving precision floats up to 18 decimal places
-
cipher-crypt
A cryptographic tomb of ciphers forgotten by time
-
ffilter
dsp library
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
grafos-tools
Graph Theory Package. Create, manipulate and run algorithms on graphs.
-
isochronous_finite_fields
Isochronous implementation of GF(2^8) arithmetic
-
grambulate
grambulation for positive integers in Rust
-
ff-group-tests-mirror
collection of sanity tests for implementors of ff/group APIs. Mirrored by sneurlax from serai for downstream crate-publishing purposes until serai publishes their crates; use the versions from serai in production…
-
discoid
Different types of generic Circular Buffers
-
swap3
Swapping of three references, rotating the values left or right
-
ifc_rs
IFC standard
-
fltrs
Filter for querying lists
-
algorithms-rs
Introduction to Algorithms Thrid Edition By Rust programming Language
-
libreda-sta
Static timing analysis for netlists of the LibrEDA framework
-
sainte_lague
Sainte-Laguë method for seat distribution used in multiple parliamentary elections all over the world
-
codice_fiscale_rs
compute and validate Italian Tax code (codice fiscale)
-
wfc
Generate images using Wave Function Collapse
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
lightspeed_hash
Hash functions
-
grabbag
A random grab-bag of functionality
-
streamvbyte64
stream-vbyte codec supporting 64-bit wide values
-
drying_paint
observer pattern for Rust
-
qtruss
finite-element solver for trusses
-
numbers_rus
flexible library for working with numbers that aims to be useful, fast, and practical. Modular structure makes it easy to use only the parts you need, and the library is designed to be extensible…
-
ibmfloat
IBM floating point number types
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
libhumancode
A
no_stdcompatible library that provides a function to enode binary data up to 150 bits in a human friendly format -
onesies
Count the number of bits set to 1 in an integer
-
postman-api
Postman client, generated from the OpenAPI spec
-
tugger-wix
Interfaces to the WiX Toolset to produce Windows installers
-
mako_infinite_shuffle
Iterates over combinatorial spaces in a random order
-
qip-iterators
Iterators for tensor product matrix multiplication
-
flame-clustering
Fuzzy clustering by Local Approximation of MEmberships (FLAME)
-
idgenerator
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…
-
lazy-prime-sieve
Lazy Sieve of Eratosthenes for infinitely generating primes lazily in Rust
-
glicko2
rating system
-
crfmnes
CR-FM-NES (Cost-Reduction Fast Moving Natural Evolution Strategy Optimiser) implemented via nalgebra
-
data_units
Data unit converter
-
boolector-sys
Low-level bindings for the Boolector SMT solver
-
baiser
Curves manipulation library
-
scroll-buffer
Extra writable buffers for Scroll
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
spectre
A lightweight toolkit for analysing p2p network topologies
-
ranluxpp-rs
Ranlux++ FFI bindings for Rust
-
fx-hash
A speedy, non-cryptographic hashing algorithm used by rustc. Fork of rustc-hash.
-
oxydized-money
providing data types to manipulate amounts of money in specific currencies and convert amounts between then
-
private_poker
A poker library
-
modinverse
Small library for finding the modular multiplicative inverses
-
dendritic-knn
Package for algorithms related to K Nearest Neighbors
-
nd-triangulation
Arbitrary dimensional triangulations using CGAL
-
prime_bag
A bag datatype that used unsigned integers for storage
-
async_bagit
Create and load BagIt containers
-
meta_tools
Collection of general purpose meta tools
-
rucrf
Conditional Random Fields implemented in pure Rust
-
modular-decomposition
computing the modular decomposition of a graph
-
zvxryb-broadphase
A broadphase collision detection library
-
swimos_errors
SwimOS Error Utilties
-
gamma
Graph primitives and traversals for Rust
-
rust_wfa
wavefront sequence alignment algorithm
-
aporia
A flexible random number generation library
-
naturalneighbor
2D Natural Neighbor Interpolation (NNI) library for Rust
-
peepmatic-automata
Finite-state transducer automata
-
moco_abm
MOCO - Anytime Behavior Model (moco_abm)
-
wrappinghashset
HashSet that remembers the last key it returned with its iterator and subsequently will wrap around and only return all of the keys once per call. This is useful if you want to use a set both via hashing…
-
qframework
A experimental micor framework for clear design, based on queue model
-
hasher
Package hasher provides a Hasher trait
-
enso-optics
functional optics
-
argmap
parse command-line arguments into a hashmap and vec of positional args
-
nyar-number
Numeric types with GC optimization
-
yamcts
Monte Carlo Tree Search
-
favannat
Algorithms to evaluate the function encoded in ANN-like structures
-
cplit
Competitive Programming Library in Rust
-
isla-lib
Isla is a symbolic execution engine for Sail instruction set architecture specifications. This crate implements the core symbolic execution engine as a library.
-
marrow
Minimalist Arrow interop
-
locustdb-compression-utils
compressing and decompressing sequences used in LocustDB
-
ncollide2d-updated
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
morton-encoding
encoding and decoding Morton ("Z-order") keys
-
cfpyo3_rs_bindings
a collection of performant utilities
-
kasuari
layout solver for GUIs, based on the Cassowary algorithm. A fork of the unmaintained cassowary-rs crate with improvments and bug fixes. Kasuari is the indonesian name for the cassowary bird
-
from_bytes_or_zeroed
Reads integers from an arbitrary slice of bytes
-
sha3-asm
Raw bindings for SHA-3 algorithms written in assembly
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
nnf
Negation Normal Form manipulation library
-
topologic
Topological sorting of Acyclic Dependency Graphs
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
aviation-calculator
Useful calculations for aviators
-
markov-algorithms
Markov algorithms
-
scc-trait
Trait-based Strongly Connected Components Calculation
-
kette
Iterator tools
-
prexel
A math expression evaluator
-
tessellation
3d tessellation library
-
Cantor-Pair
A general algorithm to enable cantor pairing and unpairing between usizes. I'm not responsible for any damages if this code breaks GL GG
-
colourado-iter
A small and minimalistic library to generate a random color palette of infinite size
-
iron-shapes-booleanop
Boolean operations on polygons for iron-shapes
-
seadawg
that implements the online algorithm for Direct Acyclic Word Graph (DAWG) and Compact Direct Acyclic Word Graph (CDAWG)
-
portal-pc-tramp
Trampoline for recursive functions, with support for mutual recursion (portal version)
-
knn_classifier
classifier for the k-Nearest Neighbors (kNN/k-nn) algorithm
-
memmem
Substring searching
-
meowhash
Meow hash function
-
abow
Visual bag of words for fast image matching
-
symbolic_polynomials
manipulation of polynomials over the integers
-
container_image_dist_ref
parsing and validating container image references
-
rand_distr
Sampling from random number distributions
-
fuchsia-cprng
Fuchsia cryptographically secure pseudorandom number generator
-
gaoya
Locality Sensitive Hashing Data Structures
-
mahf-bmf
A collection of common continuous benchmark functions for MAHF
-
arima
time series modeling for Rust
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
stateflow
extensible state machine implementation in Rust
-
globe-rs
management of geographic coordinates
-
u7
dotnet's 7bit int in Rust
-
delaunator
A very fast 2D Delaunay triangulation library
-
crumsort
Parallel implementation of crumsort optmized for uniform distributions
-
fastcdc-alt
FastCDC (content defined chunking) implementation in pure Rust with an alternative API to the original crate
-
polars-algo
Algorithms built upon Polars primitives
-
shm_ring
A directional ring buffer for message passing between shared memory
-
vsr
Viewstamped Replication in Rust
-
powers
Power flow simulation and optimization
-
toolbelt_a
random tools for use
-
vec-drain-where
alternative
Vec::drain_filterimpl -
tlsh2
TLSH algorithm
-
automaton
Parse regular languages
-
minimax
Generic implementations of Minimax
-
coord_transforms
performing coordinate transformations
-
algx
Knuth's Algorithm X
-
sliding_windows
a non-copying implementation of a sliding windows iterator adaptor
-
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
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
-
name-engine
computing Markov chains to generate random names based on pronunciation
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
sbitty
defining bitwise operations on standard integers type
-
pmcore
building blocks needed to create new Non-Parametric algorithms and its integration with Pmetrics
-
soplex-rs
Safe Rust bindings for the SoPlex LP solver
-
shabottom
reimplementation in Rust
-
bit-list
A lazy list of bits
-
crc32fast-lib
Fast, SIMD-accelerated CRC-32/ISO-HDLC (aka 'crc32') checksum computation in Rust exposed as a C-compatible shared library
-
sparse_matrix
do linear algebra with sparse matrix
-
frand
Blazingly fast random number generation library
-
random-string
Allows to generate random strings based on a given charset and length
-
bytecmp
offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
shakemyleg
state machine definition language and interpreter
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
sykin
kinematic calculations using the syunit-unit-system
-
fossil-delta
functions for calculating differences between strings and applying calculated deltas
-
openmodel
Geometry library for structures
-
deranged
Ranged integers
-
rootfind
Root-finding algorithms
-
artcode
Converts dates into artcode coordinates
-
crczoo
CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms
-
coding_pk
pk for coding solution
-
mate_selection
A collection of mate selection methods for evolutionary algorithms
-
rtsam
Real Time Smoothing and Mapping (RTSAM) in Rust
-
demes-forward
rust API for iterating demes models forwards in time
-
oca-dag
OCA DAG
-
hash_ord
lib contains OrdMap(avl tree) and HashMap(use avl to resolve collision);
-
instant-distance
Fast minimal implementation of HNSW maps for approximate nearest neighbors searches
-
adapton-lab
Testing and performance evaluation suite for Adapton
-
const-arithmetic
Exploits Rust's type generic system to perform integer arithmetics at compile time
-
minecraft_launcher_core_msa
A Minecraft launcher library written in rust
-
gsv-culture-ships
Iain M. Banks's Culture ship names in a library.
-
contest-algorithms
Common algorithms and data structures for programming contests
-
blossom
algorithm to get a maximum matching in an undirected graph
-
fast_loaded_dice_roller
novel Fast Loaded Dice Roller algorithm (https://arxiv.org/pdf/2003.03830.pdf)
-
xynth
ASIC/GPU-resistant cryptographic hashing algorithm written in pure Rust for x64 CPUs with AVX2 support
-
galapagos
evolutionary solver
-
cygv
Compute GV and GW invariants of CY manifolds
-
rs_sha224
rs_sha224is a Rust implementation of the SHA-224 cryptographic hash algorithm, part of the largerrs_shieldproject. This package provides SHA-224 hashing functionality in a standalone manner… -
munkres
Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
atomex
Atomics extensions in Rust
-
distance_difference_triangulation
Position triangulation from differences of distances
-
bbqvec
Scalable, embeddable, vector storage for approximate K-nearest-neighbors (AKNN)
-
jomy-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
stb_rect_pack
Wrapper over stb_rect_pack_sys, offering a cleaner abstraction than the bindgen generated interface
-
npcore
building blocks needed to create new Non-Parametric algorithms and its integration with Pmetrics
-
flxy
Full-text searching and scoring of strings
-
rexl
Common Library for Rust
-
bip_util
Bittorrent Infrastructure Project
-
javarandom
Pure rust implementation of java.util.Random
-
hexx_more
Extensions to the
hexxcrate -
rand-sequence
A no-std crate for generating random sequences of unique integers in O(1) time
-
rcalc_lib
Mathematical expression calculation library
-
wheel
algebra library for Rust
-
bndm
that implements the BNDM algorithm for fast and efficient pattern matching, with support for wildcard searches
-
tdigest
T-Digest algorithm in Rust
-
chromosome
Genetic algorithm tools library
-
reed-solomon-16
Reed-Solomon GF(2^16) erasure coding with O(n log n) complexity
-
hmmm
Hidden Markov Models in Rust
-
field33_rdftk_core_temporary_fork
core RDF data model; concrete implementations for Statements and Literals, along with a Resource type that provides a builder-like experience for models
-
phi-detector
Phi Accrual Failure Detector
-
inexor-rgf-model-random
Inexor - Reactive Graph Flow - Model - Random
-
hammer-and-sample
Simplistic MCMC ensemble sampler based on emcee, the MCMC hammer
-
rust-algo
rust algorithms
-
mail-headers
[mail/headers] header parts for the mail crate (inkl. header map and standard header impl)
-
id_tree_layout
visualize trees from the 'id_tree' crate
-
vartyint
Read & Write varint encoded integers
-
simple_qp
Allows formulating Quadratic Programming problems in a symbolic way
-
shortestpath
Shortest Path is an experimental library finding the shortest path from A to B
-
ironstorm_lookup
Lightning fast lookup table for auto completion, type ahead, suggestion engines
-
dendritic-clustering
Package for algorithms related to clustering
-
stable-hash
A stable, structured hash with backward compatibility
-
toposort-scc
Kahn's algorithm for topological sorting and Kosaraju's algorithm for strongly connected components
-
kernel-density-estimation
Kernel density estimation in Rust
-
topk
TopK algorithm implementation in Rust
-
egml-io
IO operations for processing GML data
-
ramp64-srm-convert-lib
build RetroArch Mupen64 SRM Converter
-
watermill
Blazingly fast, generic, and serializable online statistics
-
aoc_utils_by_nifalu
A small collection of utilities for the advent of code challenges
-
crc16
A CRC16 implementation
-
n18game
assets and logic for 18xx games
-
rscompress-transformation
data transformation supporting rscompress
-
morton
space filling curve functions
-
iter_enumeration
Unifies Iterators over Same Type
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
graph_safe_compare
Equivalence predicate that can handle cyclic, shared, and very-deep graphs
-
hackflight
flight-control software for makers in Rust
-
museair
Fast portable hash algorithm with highest bulk throughput and lowest small key latency (1-32 bytes) among portable hashes listed in SMHasher3, and made improvements for quality and usability
-
rustmex
providing convenient Rust bindings to Matlab MEX API's
-
sniffer-rs
that simplifies fuzzy string matching in rust
-
soft-edge
efficient bithackery for making 3D collision meshes out of grids and stacked tile maps
-
ps-pint16
Packs integers into a u16 via variable precision
-
rs-graph
graph algorithms and combinatorial optimization
-
rabitq
vector search algorithm
-
paragraph-breaker
Knuth-Plass algorithm for breaking paragraphs into lines
-
squares
A Counter-RNG faster than Philox
-
chunk-diff
A fast and memory-efficient library for computing the difference between two frames of rect
-
gym-rs
OpenAI's Gym written in pure Rust
-
probably
various approximate computing algorithms
-
rmath
math library
-
mini-enigma
#[no-std] (and no alloc) zero dependency implementation of the M3 Enigma
-
noise-functions-config
Configurable noise generator for
noise-functions -
jaaptools
I really just wanted to try publishing a package, but this contains stuff I find useful in many circumstances
-
earley-omnitool
An Earley parser engine
-
bidivec
offering bidimensional arrays, vectors and slices, with batteries included (such as pathfinding, flood-filling and more)
-
slsqp
optimizer for Rust
-
gramschmidt
Classical, Modified, Reorthogonalized Gram Schmidt Orthogonalization and QR decompostion
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
cut-optimizer-2d
A cut optimizer for cutting rectangular pieces from sheet goods
-
cosyne
neuro evolution through cooperatively coevolved synapses
-
naive-cityhash
A naive native 64/128 bit cityhash implementation for databend
-
klotski
multifunctional engine with high performance
-
liblisa
automated discovery and analysis of the ISA of a CPU
-
redfa
Regular expression derivatives for creating DFAs
-
nistrs
his crate implements statistical tests according to the NIST standard
-
anchorhash
A consistent hashing algorithm that outperforms state-of-the-art algorithms
-
dbus-addr
D-Bus address parsing
-
filter
Kalman filters and other optimal and non-optimal estimation filters in Rust
-
kermit-kvs
Key-value stores used in Kermit
-
dryip
Short 🩸 Rust 🦀 code snippets for inspiration
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
cf_dist_utils
has risk and distribution utilities
-
chains_f2vect
chain complexes and dg algebra manipulations
-
simple-pagerank
calculate the PageRank of a graph
-
groestlcoin_hashes
Hash functions used by the rust-groestlcoin eccosystem
-
pack_it_up
that implements various bin packing algorithms
-
citi
Read and write CITI files
-
ldpc
A toolbox for classical and quantum LDPC codes
-
hierarchical_pathfinding
Quickly approximate Paths on a Grid
-
fitnesstools
Collection of tools related to fitness and weightlifting
-
miracl32
version of miracl/core for 32-bit no_std platforms
-
range-reader
Converts low-level APIs to read ranges of bytes to
Read + Seek -
qmc
Quantum Monte Carlo simulations in Rust
-
external_sort
ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
vec_extract_if_polyfill
Polyfill for Vec::extract_if
-
minstd
minimal standard random number generator
-
ju-tcs-tbop-24-bebidek-endpoints
providing head and tail functionality
-
dec-number-sys
Rust bindings for The decNumber C library by IBM Fellow Mike Cowlishaw
-
uwu_wasm
uwuifying the web
-
rustsat-batsat
Interface to the SAT solver BatSat for the RustSAT library. BatSat is fully implemented in Rust
-
molecules
working with molecules and molecular dynamics simulations
-
snaplog
easily recording changes to values
-
wtools
Collection of general purpose tools for solving problems. Fundamentally extend the language without spoiling, so may be used solely or in conjunction with another module of such kind.
-
pow2
Represents a non-negative power of 2, by storing its exponent
-
xor_rand
An arbitrary byte length, counter based PRNG crate
-
bisector
Flexible bisect implementatation which allows the use the bisection method on arbitrary data types
-
small-fsm
Finite State Machine for Rust
-
ms2
that replicates the ms package from TypeScript for Rust
-
omnipaxos
A distributed log library written in Rust
-
framp
Fork of James Miller's Ramp, a high-performance multiple-precision arithmetic library
-
entro-sort
Entro Sort is an in-place, linearithmic, unstable sorting algorithm
-
supply-chain-trust-example-crate-000069
A non-cryptographic hash function using AES-NI for high performance
-
statement
An event-driven state machine library for Rust
-
spalinalg
Sparse Linear Algebra Library
-
pyrand
Pure rust implementation of python's random module with compatible PRNG behaviour: seeding with equivalent values will yield identical PRNG output
-
bvh
A fast BVH using SAH
-
proc-opt
WIP: Process/Job scheduling optimization library
-
classify
A collection of algorithms for categorizing 1D data
-
micro_ndarray
Very small multi-dimensional-array implementation
-
hilbert-curve-rust
Basic Hilbert curve algorithm
-
ndspec
A package for ocean waves and energy spectra
-
cgl-src
Redistribution of Coin-OR Cgl as a crate
-
angled-random-walker
Angled Random Walker approach to Brownian tree generation
-
vsort
GNU Version Sort Rust implementation
-
qd
Extended precision floating point arithmetic
-
teeint
A teeworlds variable int packer/unpacker
-
classific
Classifications, comparator and equivalence class implementations
-
mle1
The MLE-1 encryption algorithm
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
rkr-gst
Running Karp-Rabin Greedy String Tiling algorithm
-
ripgen_lib
High-performance domain-name permutation generator
-
entromatica
constructing, simulating and analyzing markov chains
-
treap_non_random
A non-randomized Treap implementation. Not very useful as a balanced tree, but useful when implementing CVM or similar algorithms.
-
poorentropy
Low-quality entropy generator for
no_stdcrates -
entro-hash
Entro Hash is a 32-bit, non-cryptographic hashing algorithm
-
hora
Hora Search Everywhere
-
quickcheck_seedable
Automatic property based testing with shrinking
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
rustimization
optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
regex-lite
A lightweight regex engine that optimizes for binary size and compilation time
-
insides
A compact, high performance space filling curve library for Rust
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
c_math
这是一个用于基础数据转换操作的一个包
-
greek_number
Convert numbers to Greek number strings
-
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
-
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
display_buffered
A small library that provides convinience functions to write all the elements into a writer with buffering
-
oshash
https://pypi.org/project/oshash/ in Rust
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
libgdx-xs128
minimalist no_std clone of the Xorshift128+ algorithm used in the libgdx Java library
-
krakel
A lean 2d kd-tree ported from OpenCamLib
-
spaced-repetition
A spaced repetition algorithm based on anki and supermemo
-
rust-constraint
constraint satisfaction problem (CSPs)
-
genetic_algorithm_meta
A genetic algorithm implementation for optimizing genetic algorithm parameters
-
light-curve-common
Common tools for light-curve-* packages
-
weighted-selector
Select type from weighted index
-
numext-fixed-hash
Fixed-size hash types
-
game_pathfinding
一个寻路库，包含AStar和Recast，目前还在开发阶段
-
disk-based-bfs
Fast generic implementation of breadth-first search using disk storage, suitable for extremely large implicit graphs
-
rusty-perm
permutation with no-std
-
qsort-rs
A quick sort algorithm that accepts any type and non-recursive approach
-
clipper2-sys
Polygon Clipping and Offsetting (Clipper2 wrapper)
-
fp-growth
algorithm in pure Rust
-
ilattice
2 and 3-dimensional integer lattice math
-
supply-chain-trust-example-crate-000080
fast random number generator
-
cmaze
Core of tmaze game
-
random-branch
macro to select a random branch like match
-
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
sfparse
RFC 9651 Structured Field Values parser
-
pso_rust
famous PSO method
-
fmerk
Merkle key/value store
-
analytic
has been renamed to be the math crate https://crates.io/crates/math
-
ezing
Easing functions
-
sudoku-variants
A flexible Sudoku engine that supports common variations and custom rules
-
ucsi
SI-based unit typing system
-
webgestalt_lib
computing enrichment for different analytes using ORA or GSEA
-
easing
Leveraging Rust's powerful iterators for easing
-
radix
Convert any {u8, u16, u32, u64, u128, usize} to another radix
-
integer-partitions
Efficiently enumerate integer partitions
-
rand-functors
A zero-cost abstraction for sampling from and enumerating the outcomes of a random process using the same code
-
batsat
Extensible SAT solver in Rust
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
blackboxmc_java
BlackboxMC bindings for java.util
-
fnv_rs
Fowler–Noll–Vo hash function including 32, 64, 128, 256, 512, & 1024 bit variants
-
bidi
Unicode Bidirectional Algorithm (UBA)
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
krossbar-state-machine
Krossbar state machine
-
smth
math library
-
edfsm-kv-store
A KV Store based on Event Driven Finite State Machines
-
enso-shapely
Automated typeclass derivation
-
glar-gemm-s8u8s32
high performance cpu kernels
-
ribbon
Tape machine for peeking through windows of iterators
-
satsnet_hashes
Hash functions used by the rust-bitcoin eccosystem
-
bgjk
Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect
-
polystem
Popular stemming algorithms for Information Retrieval
-
vincenty-core
Calculate distances between two coordinates using vincenty formulae
-
kahan
types to perform Kahan summation
-
goorm_edu_rs_kit
A code test library for easy variable of integer or vector of integer from standard input
-
boostvoronoi_ext
Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)
-
mahf
A framework for modular construction and evaluation of metaheuristics
-
treelite
rust wrapper for treelite, only support predictor.predict_inst method now. Requires treelite:0.93
-
omango-wyhash
Wang Yi hash for Rust
-
npc-engine-core
The core of the NPC engine, providing a generic MCTS framework
-
assign1
Sorting code
-
oint
oint ('optional int') provides total operations on arithmetic
-
blake2b_simd
a pure Rust BLAKE2b implementation with dynamic SIMD
-
remedian
A Rust implementation of The Remedian
-
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
polyline-codec
Encode and decode polylines
-
lenia_ca
simulating the Lenia system of cellular automata
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
typed_shapefile
Read & Write .dbf in Rust
-
acacia
A spatial partitioning and tree library
-
hashids
HashIds Rust Implementation
-
num-cmp
Comparison between differently typed numbers
-
pennereq
Port of the Penner easing equations to rust
-
prksort
Merge Sort and Quick Sort algorithms in Rust
-
docchi_archiver2
A serializer which compresses integers
-
rabin_ida
Rabin's information dispersal algorithm, originally by Liam Perlaki
-
depper
basic dependency validation
-
chacha8rand
Reproducible, robust and (last but not least) fast pseudorandomness
-
b4s
Binary Search Single Sorted String: Perform binary search on a single, delimited string slice of sorted but unevenly sized substrings
-
fleetfs_raft
language implementation of Raft algorithm
-
smeagol
Conway's Game of Life using HashLife and SIMD
-
interiors
Primal-Dual Interior Point Method for Nonlinear Programming
-
eom
Configurable ODE/PDE solver
-
borrowned
Borrow-or-owned values
-
hot-ranking-algorithm
Algorithm that measures how relevant a given data set is, kinda like Reddit
-
coupe
mesh partitioning library. It implements composable geometric and topologic algorithms.
-
wasmium-random
Generate random numeric, alphabet, alphanumeric, BIP39 and EFF random bytes
-
rust-eratos
'Sieve of Eratosthenes' for rust language practice
-
endicon
Implementations of codicon traits for endianness encodings
-
fast-erasure-shake-rng
Fast erasure (forward secure) sponge/duplex based PRNG using the Keccak permutation
-
para-graph
"Para-Graph" delivers swift, parallel graph algorithms in Rust, optimized for CPU and GPU. Ideal for HPC workflows.
-
java_random
The java LCG and random module implementation in rust
-
my-bfgs
A pure Rust implementation of the BFGS optimization algorithm
-
anndists
some distances used in Ann related crates
-
sort_library
sorting algorithms in Rust
-
unicode-range
UnicodeRange is a Rust library for parsing and stringifying Unicode ranges. It provides functionality to convert a string representation of Unicode ranges into a vector of code points and vice versa.
-
quine-mccluskey
Boolean function minimizer based on Quine–McCluskey algorithm
-
savant_core
Savant Rust core functions library
-
madepro
A minimal Rust library crate for solving finite deterministic Markov decision processes (MDPs)
-
statistical
statistics library
-
graph-algorithms
5 graph algorithms - DIJKSTRA'S, BFS, DFS, KOSARAJU'S and BELLMAN FORD ALGORITHM
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
ish
Sometimes things are true-ish
-
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.
-
rust_poker
Rust poker library
-
sfsm
Static state machine generator for no_std and embedded environments
-
rlifesrc-lib
A Game of Life pattern searcher (library)
-
cp-rs
Competitive programming library, especially for AoC
-
semantics
mapping
-
wfc_tiled
Small library for Wave Function Collapse on Tile-based maps, using the
wfccrate. Provides Tiled integration. -
xorwowgen
Several implementations of the Xorwow algorithm
-
re_view_map
A view that shows a map
-
bubblesort
Bubblesorts stuff
-
badsort
Some basic sorting stuff I wrote as practice in Rust. Includes my favorite algorithm, BOGO Sort!
-
simplegraph
graph implementation
-
supermemo2
that implements the supermemo2 spaced repetition algorithm
-
speedytree
Canonical and RapidNJ implementations of Neighbor-joining in Rust
-
blurhash-ng
A pure Rust implementation of blurhash
-
local-or-heap
type with a pre-specified size, regardless of the size of the T type it contains, using heap allocation if necessary
-
supply-chain-trust-example-crate-000079
Fowler–Noll–Vo hash function
-
numeric-algs
implementing some numerical algorithms
-
caldera-bindings
Bindings for Caldera which includes bindings for libavcodec, libavformat, libavutil, pulseaudio and libsamplerate
-
weighted-rs-wasm
A libray for weighted balancing algorithm
-
rxqlite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
lfu
cache implementation
-
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
flowing
flow graph processing library
-
eviolite
Toolkit for working with evolutionary algorithms
-
umbra_slice
An owned slice type with German string optimizations
-
unit_types
A unit-aware type system for Rust
-
partition-point-veb-layout
partition_point van Emde Boas layout
-
rands
Random number generators and other randomness functionality
-
breadth-first-zip
Breadth-first
zipguaranteeing a monotonically increasing sum of indices -
metrics_evaluation
Small foot-print parser and solver for (nested) text-based comparisons
-
continent-code
Continent Code
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
heuristic-graph-coloring
Heuristic algorithms for graph vertex coloring
-
disco-quick
processing the Discogs XML data dumps
-
optimath
Linear Algebra using const generics for no_std and specialization to enable SIMD
-
xxh
XXHash algorithm implementation for Rust
-
cjp
converting strings to 怪レい日本语(Ayashī Nihongo)
-
wfc-rs
Binding to the krychu/wfc C library
-
traversal
Generic and lazy tree traversal algorithms
-
polyfit-rs
Polynomial fitting of data like in numpy.polyfit()
-
kmeans_smid
Small and fast library for k-means clustering calculations. Fixing smid from
kmeans-rs. -
pso
Particle Swarm Optimizer
-
rosomaxa
algorithm and other building blocks for creating a solver for optimization problems
-
minhash-rs
MinHash trying to be parsimonious with memory
-
ds-heightmap
Using diamond-square algorithm to generate heightmaps which stored in a 2D-array
-
descartes
Imprecision-tolerant computational geometry for Rust
-
task_partitioner
helper lib that allows partitioning named tasks by count or hash
-
swimos_multi_reader
SwimOS Stream Aggregator
-
meealgi
A selective implementation of Jean Meeus' astronomical algorithms
-
exact-cover
(WIP) Asynchronous exact cover solver library using Knuth's dancing links algorithm
-
trajectory
interpolation
-
bbt
A skill-rating system similar to Elo, Glicko or TrueSkill
-
library_of_babel
Babel in Rust
-
sorted-insert
traits to insert elements to a sorted collection and keep the order
-
qr2term
Stupidly simple Rust crate to render a QR code in the terminal
-
spsa
Simultaneous perturbation stochastic approximation
-
ringstack
A very simple circular buffered stack implementation
-
aws-tree-hash
Calculate the Amazon SHA256 tree hash as described on Checksum Calculation page of the AWS S3 Glacier developer guide
-
ksq
k-2 tree
-
ordq
Order keeping job processing queue
-
line_cardinality
High performance line cardinality counts and estimates
-
htmlprops-to-react
convert html properties to react
-
cityhash-sys
Rust binding of Google CityHash algorithm
-
denlibs
general-purpose libraries
-
sorts
A collection of sorting algorithms
-
three-style-lib
A 3x3 Rubik's Cube three style library
-
xxtea
encryption algorithm library
-
sea-canal
Identifies patterns in sequences of integers
-
fluent-comparisons-macros
Macros for the fluent-comparisons crate
-
rounded-div
Get rounded result of an integer division
-
index-utils
working with indices
-
password-worker
A wrapper for password hashing that can be used as shared state, and uses a rayon thread pool so it won't block the async runtime
-
safe-modular-arithmetic
modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
dahl-salso
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, including…
-
permutation_iterator
iterating over random permutations using O(1) (i.e. constant) space.
-
hashed-permutation
A fast, instant-access way to permute a range of numbers
-
simbiota-tlsh
A pure-rust implementation of Trendmicro's TLSH algorithm, featuring the same optimizations found in the reference implementation
-
or-tools
Unofficial Rust wrappers to the C++ library Google OR-Tools, open source software for combinatorial optimization
-
hv-fonseca-et-al-2006-sys
A wrapper for the hyper-volume algorithm by Fonseca et al. (2006)
-
heapz
Heap/Priority Queue implementations
-
gcd-bitwise
The binary Euclidean algorithm for computing gcd
-
memoires
Memoization for Rust
-
floyd-warshall-alg
Floyd-Warshall algorithm supporting customization
-
quriust
simulate a quantum computer. Only for quriust ones.
-
tacho
A prometheus-focused metrics library for Future-aware applications
-
robinson_mmodules
direct implementation of the algorithms presented in "MODULES IN ROBINSON SPACES" by MIKHAEL CARMONA, VICTOR CHEPOI, GUYSLAIN NAVES AND PASCAL PREA. It can determine if a given…
-
xorshift128plus-rs
XorShift128+ pseudorandom number generator in Rust
-
wookong-solo
Wookong Solo driver crate
-
opendp-ffi
Foreign function interfaces for the OpenDP library
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
forky_core
Rust Utilities
-
input_conv
A basic stdio extension to automatically translate basic inputs to a given type
-
dedup_signature
implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
rsbalancer
that implements load balancing algorithms
-
lcpc-brakedown-pc
polynomial commitment scheme from SDIG expander code
-
tiamat
a PRNG library
-
gray-codes
Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection
-
graph6-rs
parsing graph6/digraph6 strings and converting them into other text based formats
-
rbuf
A general purpose ring buffer implementation with some non-standard constraints
-
empty-fallback-chain
Iterator adaptor like chain, but conditional on empty first iterator
-
chandeliers-std
A standard library for the Chandeliers suite
-
nonn
Integer types that are known not to equal any single N
-
random_lfsr_256_galois
random generator imlplementation based on linear feedback shift register (LFSR, Galois variation) on 256-bit polynome
-
tlnat
type level non-negative integer constants for rust
-
rust-algorithm
algorithm
-
subproductdomain-pre-release
Implements subproduct domain algorithm
-
uniui_layout_linear_layout
Label widget for uniui_* crate family
-
jingle_sleigh
An FFI layer for Ghidra's SLEIGH
-
pollard-p-minus-one
Pollard's p-1 factoring algorithm
-
l
my personal library
-
metricator
Metrics
-
pi_path_finding
A* Path Finding Algorithm
-
randomwalk
Build glorious random walks
-
runiverse
A pure and safe Rust library to make astronomical calculations and solve astronomical algorithms
-
libtess2-rs
good quality polygon tesselator and triangulator
-
brace-expand
performs brace expansion of strings, as in shells like Bash etc
-
aabel-bloom-rs
implements the Bloom filter
-
sorted_intersection
Intersection Iterator Over Sorted Iterators
-
sssignals
🐍 Simple, Synchronous Reactive Signals for Rust
-
regalloc
Modular register allocation algorithms
-
mgraph
performance-oriented graph library for Rust
-
aob_common
String searching with wildcards
-
temex
Regex-like temporal expressions for evaluating systems that change over time
-
hybrid-clocks
Hybrid Logical Clocks
-
symbolic-sets-integers
Symbolic sets examples and test implementations
-
moore-hodgson
Moore Hodgson's Scheduling Algorithm in Rust
-
circularing
Circular buffer backed by in-stack storage
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
rustmt
A MT19937 PRNG implementation for rust
-
vqf-rs
A
no-std, dependency-free port of VQF sensor fusion algorithm for IMUs -
atlatl
Double-array tries
-
lcs_rs
longest common subsequence
-
hutton-rust
The Hutton cipher implemented as a Rust crate
-
arrow-cast-guess-precision
Arrow cast function alternative with timestamp integer guessing precision
-
satif
SAT solver interface
-
quotient-filter
A quotient filter implementation
-
label-propagation
Label Propagation Algorithm by Rust
-
zig-lexer
Zig lexer
-
unfold
in Rust
-
nummap
Defines a wrapper around a
HashMapof number values which behaves as if ALL keys are mapped but0values are not stored -
secwords
secure and safe password container
-
space_alloc
General purpose space allocators
-
codek
Codec trait
-
blurhash-fast
blurhash
-
rusty_genes
implementing and executing evolutionary algorithms with customizable models
-
sample-consensus
Abstractions for sample consensus algorithms such as RANSAC
-
randotron
Trivial little library that lets you randomly execute a closure with a sample rate
-
modicum
Modular arithemtic library in pure Rust
-
aviary
bird combinators for Rust
-
dagga
For scheduling directed acyclic graphs of nodes that create, read, write and consume resources
-
advanced-random-string
advanced string generation based on given charsets, lengths, and RNGs
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
integer_scaling
IntegerScaling wrapper for those who prefer snake_case
-
cityhash-102-rs
Faithful reimplementation of CityHash v1.0.2 64bit and 128bit hashes
-
chull
Convex hull approximation
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
jarl
Jarl (Just another Raft library)
-
srtree
SR-Tree: a high-dimensional nearest neighbor search index
-
gndr_rust
Uses advanced techniques and algorithms to determine the gender of a user by just fucking asking them
-
pef
Partioned Elias-Fano encoding for sorted integers
-
tradestats
Metrics
-
aces
Algebra of Cause-Effect Structures
-
poisson_reconstruction
Screened Poisson Reconstruction algorithm in Rust
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
random_lcg
lcg random number generator
-
griddy
general-purpose grid/matrix
-
tempergb
Convert a color temperature to RGB values
-
pregel-rs
A Graph library written in Rust for implementing your own algorithms in a Pregel fashion
-
cosiest_noisiest
allows generating 1d noise at arbitrary points
-
ogs
solving octal games
-
tallyweb-fuzzy-sort
A fuzzy sort library for use with the tallyweb site package
-
hex_to_rgb
convert hex color codes to RGB values
-
wordlea
A algorithm to check Wordle's word guess
-
traiter
Traits collection
-
advancedresearch/piston-math_notation
Bootstrapped meta rules for mathematical notation
-
poisson
Poisson-disk distribution generator
-
graphannis-core
supports graph representation and generic query-functionality
-
w_inter
❄️ Weighted INTERval scheduling problem
-
idhash
Calculate a Row-Invariant ID for Tabular Data
-
peak_finder
An algorithm for identifying peaks from line data, such as from accelerometer or spectral data
-
integer-cbrt
integer cube root algorithm for primitive rust types
-
varint-rs
A small, zero dependency varint implementation in Rust
-
primter
Prime number iterator based on sieve of Eratosthenes
-
blue-noise-sampler
version of the A Low-Discrepancy Sampler that Distributes Monte Carlo Errors as a Blue Noise in Screen Space sample code
-
ergothic
setting up and running distributed Monte-Carlo statistical simulations. Designed primarily for lattice QCD.
-
dandelion-random
A high performance non-cryptographic random number generator
-
broadword
algorithms
-
rhizomedb
RhizomeDB
-
zero-copy-pads
Padding/aligning values without heap allocation
-
summed-area-table
summed area table
-
whosly
便捷的工具库
-
lpn
Software to study attacks on the Learning Parity with Noise problem
-
spherical-cow
Spherical Cow: High volume fraction sphere packing in arbitrary geometries
-
is_even_odd
categorizing and operating on integers
-
powierza-coefficient
Powierża coefficient is a statistic for gauging if one string is an abbreviation of another
-
ndsort-rs
Sorting Algorithms implemented in Rust
-
meanshift-rs
Rust version of the MeanShift clustering algorithm that does not need a predefined number of clusters
-
cdragon-prop
Work with BIN files used by Riot
-
shuffle
various shuffling algorithms over slices
-
easylazy
Easy lazy initialization of variables
-
aob
String searching with wildcards
-
duval-rs
Duval algorithm in Rust
-
imei
number validator
-
predictive_shuffle
A vector shuffling library that allows for in-place shuffling, or predictive sub-item shuffling
-
kermit
Relational data structures, iterators and algorithms
-
stream-more
Stream utilities for Rust
-
tlsh-fixed
Rust port of Trend Micro Locality Sensitive Hashing
-
langis
A signal is a structure that can yield an infinite amount of data. The API is very similar to
std::iter::Iteratorbut with the assumption that it will never end. -
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
md2_digest
A 0 dependency, no_std library for generating md2 digests
-
tree-struct
A general-purpose Tree implementation in Rust
-
choosen
An easy program that choose some attending person, with equal properbility for each position
-
mvnc
Wrapper around the Movidius Neural Computing stick C API
-
biogarden
A collection of basic bioinformatics algorithms
-
skelly
Skeleton animation and IK
-
partopo
Functions to execute work described by a dependency graph
-
extrema
C++'s minmax_element implementation in rust
-
sparse
-
orca-rs
ORCA algorithm
-
libreda-pnr
Algorithm interface definitions of the LibrEDA place-and-route framework
-
rtriangulate
Delaunay triangulation on a set of points
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
kirkos
Lightweight no_std heap-allocated circular buffer implementation
-
rrt
Path finding using dual-RRT connect
-
rational_deduction
rational deduction algorithm
-
stochastic_optimizers
Generic implementations of gradient based stochastic optimizing algorithms
-
pokereval
evaluating poker hands with 5 or 7 cards
-
octree
algorithm for nearest neighbor search in 3D space
-
cell-map
Many-layered 2D cellular generic map
-
emas_rs
Rust-based EMAS optimization algorithm
-
fuzzerang
Efficient random number generators and distributions for fuzzing
-
partition-iterator
Iterator adaptors that enumerate all partitions or all k-partitions of an iterator's content
-
deep_core
deep prototype
-
oars
providing construction methods and utility functions for orthogonal arrays and strong orthogonal arrays
-
largest-remainder-method
The largest remainder method
-
microwfc
Small Wave-Function-Collapse implementation
-
algebloat
Rust linear algebra library
-
bit_combi_iter
An iterator to iterate all bit combinations less than given unsigned integer
-
maidenx_cuda_kernels
MaidenX CUDA Kernels
-
compensated-summation
Compensated summation algorithms for better precision
-
ang
Angular types and common helper methods
-
blake
hash function for Rust via FFI
-
sigalign-core
A core crate for sigalign
-
rehexed
Adjacency lists for hexasphere's icospheres
-
cubecl-spirv
SPIR-V compiler for CubeCL
-
onlinematching
Online bipartite matching is a type of matching problem where the goal is to match elements from two disjoint sets (also known as "bipartite graphs"), where one set represents the "left"…
-
similar-string
Find similar strings in Rust
-
kg-utils
Various collections and utilities
-
hopcroft-karp
A minimal implementation of the Hopcrof-Karp bipartite matching algorithm
-
tinysort
The lowest memory footprint sorting algorithm
-
siphash_c_d
A no-std, safe, generic implementation of the siphash_c_d algorithm
-
clone_dyn_types
Derive to clone dyn structures
-
hotdrink-rs
HotDrink in Rust
-
measurement-units
basic measurements units conversion such as length, mass, time, volume, percents
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
modulo
operation
-
rta-for-fps-lib
paper 'Response Time Analysis for Fixed Priority Servers' by Hamann et al
-
prefix-varint
PrefixVarint encoding for u64 integers
-
bitcursor
Keeps track of the bit position for an in wrapped memory buffer, and provides it with a read, seek implementation. Also applys a new trait called ReadBits which allows reading types that implement Unit from the cursor.
-
simple-std
extension to the Rust standard library for exercises
-
kaminpar
Rust wrapper around KaMinPar which is a shared-memory parallel tool to heuristically solve the graph partitioning problem
-
seqdiff
Diff between two sequences
-
sulfa
basic algorithm library implemented by rust
-
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
mathjax_svg
Convert mathematical expressions to SVG using Mathjax
-
quadtree_rs
Point/region Quadtree with support for overlapping regions
-
checkdigit
Check Digit Algorithms in Rust
-
meza
in-memory data table written in Rust
-
based64
BASE64 implementation for chads
-
juxt_adler32
just adler32, nothing else
-
normal-form
A trait to easily find the canonical/normal form of graph structures
-
swoop
lightweight optimisation algorithms in pure Rust
-
osi-src
Redistribution of Coin-OR Osi as a crate
-
matlab-sys
Rust bindings for the Matlab C API
-
distributed-cards
Implements the mental poker shuffling algorithm
-
rollercoaster
Extra iterators for grouping, sorting, arithmetic, and more
-
comtesse
graph utilities
-
numlib
numerical library implementing common numberical algorithms in rust
-
zaplib_vector
The vector library for Zaplib
-
normalize_country
Convert country names and codes to a standard
-
concorde
reconfigurable lattice agreement
-
first_order_logic
first-order logic
-
whr
Rémi Coulom's Whole-History Rating (WHR) algorithm for Rust
-
introsort
Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly
-
polymur-hash
Polymur hash function
-
kmers
k-mer manipulation
-
reciprocal
Baseline implementation of integer division by constants
-
rm
randomness
-
stringslice
A collection of methods to slice strings based on character indices rather than bytes
-
cmsis_dsp
Bindings to the CMSIS DSP library for ARM Cortex-M processors
-
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.
-
frechet
basic autodifferentiation
-
beediff
LCS algorithm in various applications
-
rand_xorshift
Xorshift random number generator
-
graphmst
allows you to generate minimum spanning tree from a graph using Prims, Kruskals, Boruvkas and Reverse Delete algorithms
-
weight_matchers
Efficiently find items by matching weight. You can build the lookup structure at compile time.
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
halton
A module for generating Halton sequences
-
etcd_dynamic_state
Etcd dynamic state library
-
code-fuzzy-match
Fuzzy string matching inspired by Visual Studio Code
-
pretty-hash
Output binary buffers as a nice, shortened hex string
-
afsort
American Flag sort implementation for faster sorting of Strings
-
win95-keygen
A lightweight library to generate valid Win95 product keys
-
utf-8
Incremental, zero-copy UTF-8 decoding with error handling
-
crc8-gsmb-fast
SIMD-powered implementation of CRC-8/GSM-B
-
unity-random
A reimplementation of Unity's pseudo-random number generator
-
math-concept
Common math concepts from Computer Science classes, implemented in Rust
-
phreak_engine
Rule matching algorithm focussed on speed
-
lttb
Largest Triangle Three Buckets algorithm
-
gpu_rand
GPU-friendly random number generators for the Rust CUDA Project
-
s_nor
A Very Simple To Use Encryption Algorithm * Not Ment For Professional Use
-
red_union_find
union find algorithm
-
zw-fast-quantile
Zhang-Wang fast quantile algorithm in Rust
-
infinity-sampler
Deterministic reservoir sampling for Rust
-
easyrand
Simpler to use random number library for the Rust language
-
psqr
The P-Square Algorithm for Dynamic Calculation of Percentiles and Histograms without Storing Observations
-
seedable_hash
calculating seedable hashes and fast reduction of their ranges
-
hex_grid
easily work with 2d hex grids of arbitrary shapes
-
rest_tensors
Provide efficient tensor operations for the Rust-based Electronic Structure Tool (REST)
-
gbps
gossip-based peer sampling
-
pagerank_rs
computing PageRank, optimized for performance and flexibility
-
xcsp3-rust
that help constraint programming solvers implemented by Rust to read XCSP3 files
-
awesome-trie
Awesome Trie is a fast Implementation of Trie algorithm
-
japanese_number_converter
A lib to convert numbers into japanese
-
fractal
The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes
-
cc4
Very simple implementation of the four_cc/fourcc algorithm as a const fn
-
byte_rb
byte ring buffer
-
ecgen-rs
Enumerative Combinatoric Generation in Rust
-
const-fnv1a-hash
A #![no_std] crate for performing FNV1A-16/32/64/128 hashing on Rust stable at compile time
-
digest-buffer
Fixed size buffer for use in cryptographic hash functions
-
perm
-
poseidon-permutation
An instantiation of the Poseidon permutation for decaf377
-
positivity
checking the non-negativity of values across various types
-
cmsis_dsp_sys_pregenerated
Low-level interfaces to the ARM CMSIS-DSP library
-
hmm
Hidden Markov Model
-
audiograph
An audio graph optimised for performance and limiting runtime allocations
-
dia-ip-range
-
hulahoop
An efficient consistent hash ring implementation supporting virtual nodes
-
geo-aid-latex
Support for LaTeX output from Geo-AID
-
eratosthenes
Mathematical operations library for Rust
-
is_42
blazingly fast way of checking if a variable is equal to 42
-
monotree
optimized Sparse Merkle Tree
-
xias
Explicit numeric type conversions
-
pseudo_encrypt
native-Rust generic implementation of Psql's pseudo_encrypt
-
staticstep
truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
phreak_rules
Rule matching algorithm focussed on speed
-
ritehash
A tiny, fast, zero-dep and no_std fxhash fork. More up to date.
-
bidir-map
Bidirectional map implementation for Rust
-
advancedresearch-hypo
Automatic hypothesis testing
-
bevy_cells
Bevy library for working with entities in grids
-
int_cmp
Small library for comparing unsigned integers with signed integers
-
fhash
Blazingly fast hash for HashMaps in Rust
-
vecfx
Extra batteries for a vec of floats
-
tension
Tensor library with OpenCL acceleration
-
biodiff-align
Sequence alignment bindings for biodiff
-
wotw_seedgen
Seed Generator for the Ori and the Will of the Wisps Randomizer
-
ff-group-tests
A collection of sanity tests for implementors of ff/group APIs
-
three-edge-connected
CLI tool for finding 3-edge-connected components of graphs, especially graphs in the GFA format
-
rutil
containing utilities for creating programs in rust
-
indiscriminant
A proc-macro for mapping between values and enum discriminants
-
dims
Unit-Aware Types Library
-
cfg-regex
Conversion from a regular expression to a context-free grammar
-
truth-values
Generate all possible combinations of N bools
-
generic_graph
implementing general purpose graphs. Including some default implementation (the latter are still WIP)
-
babygiant-alt-bn128
implementing a multi-threaded version of the baby-step giant-step algorithm on the Baby Jubjub curve (it is the curve whose base field is the scalar field of alt-bn-128 aka bn254) to decrypt u40 integers…
-
buter
Fluid buffer as place for iterators
-
smoothed_z_score
Smoothed z-score algo (very robust thresholding algorithm)
-
anim_curve
Curve Calculation function library with simple dependencies
-
babushka
bin packing and nesting library
-
genx
An easy to use and modular genetic algorithms library
-
buckets
O(n) integer sort
-
pkbuffer
Buffer objects made for arbitrary casting and addressing!
-
minecraft_launcher_core
A Minecraft launcher library written in rust
-
game-solver
Solve any combinatorial game
-
dists
2d distribution generator
-
broccoli-ext
broadphase collision detection algorithms
-
fstd
A fast standard library for Rust
-
suitesparse_camd_sys
Raw bindings to SuiteSparse's CAMD algorithm
-
aobscan
multi-threaded AOB memory scanning
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
resistor
calculating the resistance of a resistor based on the color bands
-
modular
arithmetic in rust
-
compound_factor_iter
Iterator types for output permutations from a function combining multiple discrete factors
-
nnapi-sys
FFI to the Android NNAPI
-
rdeck
choosing distinct random elements
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
thirtyseconds
Short Rust 🦀 code snippets for inspiration
-
nlsn-delaunay
Delaunay Triangulation and Refinement implementation through Bowyer Watson incremental insertion, conflict maps and ghost vertices
-
pqueue
Priority Queue for Rust
-
proportionate_selector
Selecting useful solutions for recombination via fitness proportionate selection
-
state_maschine
A State Machine Framework written in Rust
-
soundchange
implementing sound change algorithms in 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, ...
-
async-convert
Async TryFrom/TryInto traits
-
bravery_router
Radix Tree implementation
-
fixed-length-search
The fastest algorithm for finding a path with a specific length in a graph
-
ram
that helps to parse source code with finite state machines
-
id_graph_sccs
Find the strongly-connected components of a graph with nodes labeled by integer ids
-
fuss
Small, lightweight simplex noise generator for Rust
-
mecs
An ecs library with a focus on iteration performance
-
maglev
Google's consistent hashing algorithm
-
unit_converter
READ THE DESCRIPTION BEFORE USING THE LIBRARY. Add this in your main file {use unit_converter}. This is a binary converter library. all you have to do is call the function in the…
-
rustiny_fixed_point
tiny fixed point
-
vnd_siren
A SIREN DSL/serializer
-
window-sort-iterator
An iterator adapter that sorts items within a sliding window
-
sequencer
Dependency graph processing libarary
-
value-box-ffi
C-like api to family of value-box crates
-
stack
DSTs and arrays on the stack!
-
calculator_util
that helps you evaluating mathmatical expressions
-
rast
A toy implementation of the raft consistency protocol focused on speed
-
narcissistic
number searcher
-
sortnet
Sorting Networks for Rust
-
inexor-rgf-plugin-connector
Inexor - Reactive Graph Flow - Plugin - Connector
-
mccga
Implements the machine-coded compact genetic algorithm (MCCGA)
-
meos-sys
MEOS C API bindings
-
lehmer
Convert between permutation vectors, Lehmer codes and decimals
-
algo_sorting
implement all kind of sorting in the world of algorithms and more sorting methods will be implemented soon
-
tenhou-shuffle
Tenhou Deck/Wall-Shuffling Algorithm
-
clock-page-replacement
clock page replacement algorithm implementation
-
oefpil-sys
Rust FFI bindings to statically linked C/Fortran library OEFPIL
-
tokio_interval_buffer
Easy enum wrapper that implements all traits that the wrapped objects implement
-
mathlogic
made by Faizan Faisal, Email: f.f.programmer@gmail.com, f.f.programmer@hotmail.com
-
sorting
The world's best, finest and inefficient sorting algorithms
-
scales
converting values between scales
-
caldyn
Dynamic evaluation of mathematical expressions
-
powers-pf
Power flow algorithms
-
simple-soft-float
soft-float library that intends to be a straightforward reference implementation of IEEE 754
-
searchlib
Satisficing and optimal search algorithms
-
signalo_sources
A collection of filters used in 'signalo' umbrella crate
-
quine-mc_cluskey
Quine-McCluskey algorithm and Petrick's method
-
clamps
Wrapping, saturating, and other forms of number clamping
-
kv-par-merge-sort
External sorting algorithm for (key, value) data sets
-
guid-partition-types
A small crate designed to work with parition types and their GUIDs
-
rust-sort
common sorting algorithms, purely for learning
-
squares-rnd
fast counter based non-crypto random generator
-
divisors_fixed
A fixed & enhanced version of the divisors crate
-
bresenham_zip
Iterator to perform Bresenham over two lines of the same triangle simultaneusly for triangle rasterization
-
algo-rs
Set of data structures and algorithms
-
gearhash
Fast, SIMD-accelerated hash function for content-defined chunking
-
lis
Longest increasing subsequence algorithm
-
rustlearn
A machine learning package for Rust
-
linear-deque
A double-ended queue that can be sliced at any time without preparation
-
yaum
Units of Measurement
-
ddgg
A stable graph with undo/redo built in
-
weighted-median
Calculate the weighted median
-
pi_hash
Provide unified hasher, HashMap and HashSet, The hash algorithm used can be determined by compiling conditions
-
quantum_world_state
in-ram database with relationships between elements inspired by quantum superposition and entanglement
-
fixedbitset-utils
A bunch of utility stuffs that I use when working with bitsets in Rust
-
power-consistent-hash
Power consistent hash - constant expected time constant memory consistent hash
-
muscleman
A buffer utility
-
grb-sys
Low level bindings to Gurobi
-
degrees
Easily work with and compare temeratures in different units
-
ford-johnson
algorithm (aka merge-insertion sort)
-
scicrypt-bigint
A scicrypt crate implementing *mostly* constant-time bigints for modular integers
-
is-real
real?
-
enso-generics
supporting generic programming
-
dancing-links
Exact cover solver using dancing links technique
-
coaster-nn
coaster plugin providing Neural Network operations
-
kindness
Methods for returning random elements from an iterator
-
sharded-counter
A fast and concurrent counter
-
number-utils
A calculation crate
-
dahl-partition
An efficient representation of a set partition
-
balloon
Hash
-
ripped
A pure-Rust Interior-Point solver for linear programs
-
idalloc
different methods of allocating unique identifiers efficiently
-
bitpacking-plus
Wrappers of bitpacking with extra pack formats
-
markov_rs
fast Markov chain generator in Rust
-
fenris-sparse
Sparse matrix functionality for fenris
-
wgdiff
LCS-based diff algorithm
-
rscompress-coding
data coding supporting rscompress
-
ploc
Point location library
-
pth
Collection of algorithms and structures to handle paths properly
-
granular-id
ID numbers with arbitrary precision
-
kube_quantity_2
kube_quantity is a library adding arithmetic operations to the Quantity type from the k8s-openapi crate
-
fibonacci_codec
fibonacci coding for primitive integer types
-
gamemath
math library for game development, written in Rust
-
smallest-enclosing-circle
Iterative and recursive two-dimensional implementations of Welzl's algorithm for computing the smallest enclosing circle
-
graph_kit
graph algorithms
-
aleph-alpha-tokenizer
A fast implementation of a wordpiece-inspired tokenizer
-
glar-gemm-s16s16s32
high performance cpu kernels
-
cauchy
Trait for real and complex numbers
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
activation_functions
collection of activation functions
-
sosa
Stochastic simulation algorithm (SSA) with a Monte-Carlo generating method
-
hoeffding_integer_d
Hoeffding's Dependence coefficient presented as an integer between minimum and maximum integer values of the statistic. Hoeffding's D is like Pearsons correlation R, but accepts a wide range of nonlinear situations…
-
kodama
Agglomerative hierarchical clustering
-
tw-id-num
Check or generate Taiwan ID numbers
-
is-even-or-odd
Returns true if the given number is even or odd
-
location_based_sharding
Right sized sharding algorithm
-
minesweeprs
Probabalistic minesweeper solver, based on https://mrgris.com/projects/minesweepr/
-
triangulate
Subdivides polygons into equivalent triangles
-
lax
LAPACK wrapper without ndarray
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
when
'When' parses natural language date/time and produces computer friendly output structures
-
xelis_hash
A Xelihash optimize algo package
-
noice
Fork of noise-rs, a procedural noise generation library
-
crystallographic-group
Provide crystallographic group reference and useful information, e.g. lattice coordinates and symmetry operation matrices.
-
case_converter
Case Converter
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
honestintervals
Comprehensive, correctly rounding interval arithmetic library
-
or-iterator
Rust iterator which takes two iterators and returns non-empty one
-
rand_rgb
Generate a random rgba-formatted color
-
nd_vector
[WIP] Lengthen! Shrink! Iterate! Scale! Twist and turn to your imagination along any dimension on a vector!
-
gosh-fire
FIRE algorithm for geometry optimization
-
promerge
Parse, edit and merge Prometheus metrics exposition format
-
satif-minisat
Rust wrapper for the minisat SAT solver
-
rusty_algo
Implementations of algorithms from 'Introduction to Algorithms' by Cormen et al
-
dotzilla
Native Rust implementation of efficient basic linear algebra routines
-
lindel
Hilbert and Morton encoding and decoding; in a word, linearising and delinearising
-
parallel-factorial
fast, parallel factorial calculator
-
mumps-src
Build Mumps as a crate
-
graph-algo-ptas
PTAS on planars and other graph classes
-
argdata
binary serialization format
-
pi_adler32
adler32 crc check algorithm
-
zasa_core
internal core package for zasa
-
rustsat-kissat
Interface to the SAT solver kissat for the RustSAT library
-
rlp-iter
An iterator following a space-filling pattern over a given range
-
rost
sorting
-
gut
Geometry utilities: storing, manipulating and processing geometries
-
randu
MCG65539 is IBM System/360 random number generator
-
geo-buffer
methods to buffer (to inflate or deflate) certain primitive geometric types in the GeoRust ecosystem via a straight skeleton
-
anon-vec
An Anonymous Vector that emulates dynamic typing
-
cbc-src
Redistribution of Coin-OR Cbc as a crate
-
bresenham
A fast, iterator-based integer-only implementation of Bresenham's line algorithm
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
iris-lib
that creates color palettes from images using the median cut algorithm
-
double_sort
fast and simple sorting algorithm which groups numbers into pairs and orders them onwards as nodes
-
sprs_suitesparse_camd
sprs bindings to the suitesparse camd fill-in reducting ordering
-
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
-
sugiura-hiromichi_mylibrary
my personal library
-
cdt
Fast, robust constrained Delaunay triangulation
-
clipper2c-sys
Exposing unsafe FFI for Clipper2 library for Rust
-
xx-hash
xxHash implementation
-
topset
Top N selector
-
simple_delaunay_lib
2D and 3D Delaunay algorithms in Rust
-
fnntw
Fastest Nearest Neighbor (in the) West. A fast kdtree/kNN library.
-
fuzzy_dbscan
FuzzyDBSCAN algorithm
-
fastrand-contrib
Extension functionality for fastrand
-
lightningscanner
A lightning-fast memory pattern scanner, capable of scanning gigabytes of data per second
-
hv-wfg-sys
A wrapper for the hyper-volume algorithm by While et al. (2012)
-
cellular_lib
simulation of cellular automata
-
displayr-rustr
R integration
-
raft-proto
Protocol definitions for the rust language implementation of the Raft algorithm
-
pingora-ketama
Rust port of the nginx consistent hash function
-
astro-notation
transcoding between Astro Notation Format and Native Rust data types
-
indented-blocks
parser for indented blocks
-
supply-chain-trust-example-crate-000078
fast random number generator
-
fenv-bind
a safe wrapper around fenv.h
-
isnt-even-nor-odd
Returns true if the given number isn't even or odd
-
mutification
Convert immutable reference to mutable reference
-
osqp-rust
The OSQP (Operator Splitting Quadratic Program) solver
-
uncertain
Fast and correct computations with uncertain values
-
polymatheia
Mathematical types, traits, and algorithms in pure and safe Rust
-
smtlib-lowlevel
A low-level API for interacting with SMT solvers
-
matchertools
Implements the Gale-Shapley algorithm and exposes it as an API
-
lineargen
Bit sequence generators based on LFSRs
-
labirust
Naive rust crate for implementing and testing maze solving Algorithms
-
rxqlite-tests-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
ssdeep
wrapper for ssdeep
-
fmul-to-int
Float multiplication to integer part
-
flowmium
workflow orchestrator that use Kubernetes
-
easy_base64
The package provides the base64 encode/decode functions
-
gurobi
An unofficial Rust API for Gurobi optimizer
-
elm-solve-deps
A dependency solver for the elm ecosystem
-
n18tile
Defines 18xx tile elements and track networks
-
u160
Unsigned Integer 160 bits
-
sonic-url
URL-based request builders and parsers for SONIC distributed contracts
-
meshed
Graph creation and traversal tools
-
fxtypemap
A fast type map based on internal hasher used in Firefox and Rustc
-
phonics
Phonetic spelling algorithms in Rust
-
pcg-mwc
A fast non-cryptographic psudo random number generator
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
simple_permutator
create permutations of a list of values. Eg Permutator::new(&[1,2,3]) creates an iterator that yields [1,2,3], [2,1,3], [2,3,1], [1,3,2], [3,1,2], [3,2,1]
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
list
A singly-linked stack like list support peek
-
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
-
xcov
Knuth's Algorithm X (featuring dancing links) for solving exact cover problems
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
edfsm-machine
Tasks and Channels for Event Driven Finite State Machines
-
intersect2d
Line segment intersection detection
-
interp1d
lightweight interpolation library written in Rust
-
core_collections
copy of libstd::collections with all the parts that don't work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
chain_from_last
Iterator adaptor for chaining from last item
-
async_from
Async version of From, Into, TryFrom, TryInto
-
rand-bits
Random number generators with a fixed number of set bits (ones)
-
gsl_rust
A safe GSL wrapper
-
timely_sort
Sorting infrastructure for timely dataflow
-
curri-fsm
Functional Programming Finite State Machine With curri
-
ruzzy
A lightweight fuzzy matcher
-
potpack
Rust port of the potpack algorithm
-
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
easey
Easing functions for interpolation between 0.0 and 1.0
-
sat_toasty_helper
more-easily writing SAT constraints
-
norms
A collection of distance metrics on strings
-
hnsw_rs_thousand_birds
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin - Modified by the Thousand Birds Inc team to support building for windows
-
finite-state-automaton
A minimal DFSA implementation based on Jurafsky & Martin (2009)
-
algs
Solutions for various algorithms, made as generic as possible
-
bpci
Binomial proportion confidence intervals
-
optimus
ID hashing and Obfuscation using Knuth's Algorithm
-
non-dominated-sort
Fast Non-Dominated Sort Algorithm
-
img_hash_median
that provides perceptual hashing and difference calculation for images. Includes median PHash
-
unik
A Powerful Universally Unique Identifier (UUID)
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
closest-sum-pair
Finds a pair in a list that has the closest sum to a given number
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
permutation-generator
A direct permutation generator
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
refset
A non-owning HashSet
-
isolation_forest
Isolation Forest anomoly detection algorithm
-
divsufsort
Rust port of Yuta Mori's divsufsort
-
sdcons
geo-replicated distributed consensus algorithm: SDPaxos
-
satlog
A logger for SAT-like solvers
-
rdftk_memgraph
Graph traits from rdftk_core::graph for simple in-memory usage
-
ipopt-src
Redistribution of Coin-OR Ipopt as a crate
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
signal_processing
A signal processing library
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
tri_poly_moment
Calculate moments of random variables. The distributions of the random variables are normal, uniform, and exponential.
-
weighted-rs-1
A libray for weighted balancing algorithm
-
rs-uuid
Universally unique identifier generator
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
moving-least-squares
Image deformation using moving least squares
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
bogosort
implemented in Rust
-
tomt_async
Primarily a dumping ground for personal async snippets that may be used in other ToMT projects. If this crate is useful to others please let us know.
-
multivariate-optimization
Evolutionary optimization of multivariate functions
-
branchy
tools for generating strings and sequences using context-free grammars
-
dft
The package provides an algorithm to compute the discrete Fourier transform
-
pcoa
way to apply Principal Coordinate Analysis on a distance (dissimilarity) matrix
-
bloock-types
base types for our Sparse Merkle Tree
-
genetic-rs-common
Commonly-used parts of genetic-rs
-
custom-rust-stemmers
Experimental fork of: A rust implementation of some popular snowball stemming algorithms
-
dirty-fsm
A quick and dirty state machine library
-
npc-engine-utils
module of the NPC engine, providing re-usable support code
-
m4ri-sys
Bindings to m4ri
-
numcmp
Comparison between differently typed numbers
-
thinarray
A thin alternative to Box<[T]>
-
simple_optimization
Simpler optimizers for simple optimization
-
pushgen
Push-style design pattern for processing of ranges and data-streams
-
savage_core
A primitive computer algebra system (library)
-
bigs
A bipartite graph sampler
-
lazy_futuristic
Initialize variables lazily, futuristically
-
numa_maps
Parse the numa_maps file
-
zip_eq
Zip iterator that check that its inputs have the same length
-
glushkovizer
Manipulation, regular expression and automaton library. Allows conversion of regular expressions into automata and analysis of automata and their orbits
-
ordmap
A map ordered by value
-
spaced-repetition-rs
A spaced repetition algorithm based on anki and supermemo
-
ga-scheduler
A Genetic Algorithm optimizer designed for scheduling and similar tasks
-
rusted_list
A ever sorted list for rust that is operating on binary search
-
xxhash-c-sys
Bindings to xxhash
-
utm
Convert latitudes and longitudes to UTM coordinates and vice versa
-
intpack
collection of functions for packing/unpacking unsigned integers into other unsigned integers of different sizes. For example, packing 4 u8's into a u32.
-
robust-binary-search
Robust Binary Search provides a binary search implementation which is robust against errors during the search
-
allowance
Rust Datatype to representate the deviation of measures
-
automaters
Implémentation d'automate en Rust. (FSM, NFA, DFA, NDFAE)
-
dynstore
A container for arbitrary castable objects
-
kdbush
A very fast static spatial index for 2D points based on a flat KD-tree
-
k_nearest
K-nearest neighbors search for points with maximal search radius
-
ringhash
Consistent hashing implementation
-
octarine
Color manipulation library
-
sparse_linear_assignment
Solvers for sparse linear assignment problem based on the auction algorithm
-
markov_rope
used to generate random chain of words based on an example text
-
geo-visibility
Compute visibility polygon
-
pure_decimal
A decimal type with no NaN and Infinity
-
mesh-rand
methods of generating random points on the surface of 3d models
-
geomorph
conversion between different coordinate systems
-
is-even
Returns true if the given number is odd
-
co_sort
Sort arrays given a permutation
-
raftmodel
A logic model for the raft consensus algorithm
-
verhoeff
algorithm, for number checksums
-
rust-fuzzy-search
Fuzzy Search with trigrams implemented in Rust
-
heapify
Convenience functions to turn slices into max-heaps
-
randomizer
A random string/byte generator
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
env-convert
Conversion of environment variables with default values
-
automata-like-programming
that provides mechanisms for controlling the flow of execution in imitation of an automaton
-
libpermute
A
no_stdcompatible library that provides a function to permute the items of a slice -
neutils
Utitlity functions
-
del-fem-ls
sparse solver library for research prototyping
-
biodiff-wfa2-sys
Rust bindings for the WFA2 library
-
sortable-quick-unique-id
The Sort-able Quick Unique ID system
-
fastnoise-lite
FastNoise Lite is an extremely portable open source noise generation library with a large selection of noise algorithms
-
xoroshiro128
Fast psuedo-random number generators
-
bentobox
A fast, allocation-free Monte Carlo model of a top-N podium finish in racing events
-
c2-sys
c2.h library
-
srand
Random number generators and other randomness functionality with simple apis to use
-
radiate-rust
genetic algorithms and artificial evolution
-
optimization
Collection of optimization algorithms
-
big_num
A big number implement in rust
-
hora-new
Hora Search Everywhere
-
tique
drive a tantivy search index
-
fenris-optimize
Optimization functionality used by fenris
-
keyde
Fast, Dependency-free Spacial Queries
-
normalize-case
A small Rust library for normalizing string cases (snake_case, camelCase, PascalCase, etc.)
-
ed2k
hash function
-
wildescape
string matching with questionmark, star wildcard operator and an escaped character
-
kahuna
A basic implementation of wave-function collapse for procedural generation
-
choose-rand
A small crate for choosing random items from a set of weighted items
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
number_easing
number easing functions
-
cbsrs
A Circular Binary Segmentation algorithm
-
randperm-crt
Small library for generating random permutations
-
four-bar-ui
Four🍀bar GUI is a simulator, a synthesizing tool for four-bar linkages
-
clock-zones
handling clock zones
-
debris
the data structure
-
ceetle
A Computional Tree Logic (CTL) Verifier
-
jps
Jump Point Search Implementation for Path Finding
-
crc8-hitag-fast
SIMD-powered implementation of CRC-8/HITAG
-
IntegerScaling
Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction
-
shr3
3-shift register random number generator
-
clp-src
Redistribution of Coin-OR Clp as a crate
-
cpp_map
C++ std::map emulator
-
algorithm_playground
Algorithms Playground: To learn and understand the working of different algorithms in Computer Science
-
srmfpa-berkeley-softfloat-3
Wrapper of berkeley-softfloat-3 for srmfpa
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
varisat-checker
Proof checker for proofs generate by the Varisat SAT solver
-
moon_stats
A set of statistical functions
-
svg-diff
Find the diff between 2 SVGs in the form of a list of operations to get transform from one SVG to the other
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
brzozowski-regex
Brzozowski regular expressions
-
gevlib
containing distributional quantities (CDF, PDF, Quantile, random generation) of the Extreme Value Distributions
-
rand_krull
Krull64/65 random number generators
-
varint-compression
variable length integer compression
-
watchmaker_vm
virtual machine for use with genetic algorithms
-
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. -
tilecover
Generate the minimum number of tiles to cover a geometry
-
radix-ecmascript
Convert floating-point types to string representation as defined in ECMAScript Language Specification Section 9.8.1
-
pagefind_stem
Snowball stemming algorithms repackaged for Rust, with languages behind feature flags
-
floatconv
Floating point conversion functions
-
acorn_prng
A no_std, 0 dependency, pseudo-random number generator based on the ACORN algorithm
-
multi_iter
Iterator for acting on multiple elements at a time
-
lolraft
A Multi-Raft implementation in Rust language
-
griditer
Contains a couple of iterators for implementing 2D grid based algoritms
-
dochy_archiver2
A serializer which compresses integers
-
entro-shift
Entro Shift is a 32-bit, pseudo-random number generator algorithm
-
grid_shapes
A general purpose 2d grid shape library
-
wav2json
that decodes wav audio files into json waveform data
-
near_enough
finding the difference between two values, and for getting the closest match from a set
-
octarr
dynamic cubic octree capable of storing class data, accessed via indexers
-
const_lookup_map
Rust map that can be defined in a const context
-
chargrid_event_routine
Pseudo-synchronous composable event-based state machines for chargrid apps
-
mephisto-raft
language implementation of Raft algorithm
-
biodiff
Compare binary files using sequence alignment
-
toolbox-rs
A toolbox of basic data structures and algorithms
-
neato
package of useful tools
-
word_sensitive
sensitive string matching, the implementation language is rust, and the algorithm used is ac
-
caso
Category Theory Solver for Commutative Diagrams
-
path-finding
variety of path finding and graph operations. Work in progress.
-
compact_bitset
A type for storing fixed-size arrays of booleans densely to optimize space
-
is_i32
A blazingly fast algorithm to compute whether or not a value is an i32
-
dep_crusher
Starting at a root node, traverse the dependency graph and flatten it
-
topcodes
A scanner for detecting TopCodes in an image buffer
-
dfp-number-sys
Rust bindings for Intel® Decimal Floating-Point Math Library
-
fixit
Converts infix (human-readable) expression tokens into postfix (Reverse Polish Notation) order
-
lufact
Sparse LU factorization with partial pivoting
-
radiant-utils
Radiant example code support library
-
float_math
Does math on floating point values
-
hirschberg
Generic implementation of Hirschberg's algorithm in Rust
-
radixal
Digits iteration for unsigned integer types
-
graph_csr
that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms
-
str_sim
Calculate the similarity between strings
-
tempconvert
package to convert temperature into different units, and their types
-
bruteforce
no_std-compatible brute force/string generation rust-nightly library
-
iterwindows
An iterator adapter to iterate over all contiguous windows of length N
-
tipping-rs
Token Interdependency Parsing (Tipping) algorithm
-
domtree
dominance relation calculation
-
moving-least-squares-image
Image deformation using moving least squares
-
musemap
Fast DoS-resistant hashmap based on MuseAir hash algorithm
-
geometrize-sys
geometrize bindings
-
cubecl-core
CubeCL core create
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
vertical-multiplication
Vertical multiplication step by step
-
kmers-rs
k-mer manipulation
-
minisat
interface. Solves a boolean satisfiability problem given in conjunctive normal form.
-
inexor-rgf-plugin-random
Inexor - Reactive Graph Flow - Plugin - Random
-
vconvert
vulnus to soundspace converter (or vice versa)
-
pincol
PINned COLlections: data structures utilizing
Pinpointer -
process_tools
Collection of algorithms and structures to handle processes properly
-
deepmesa-encoding
A collection of data structures and algorithms designed for performance
-
path-finding-lib
variety of path finding and graph operations. Work in progress.
-
numeric
N-dimensional matrix class for Rust
-
string_calc
Perform calculations based on String to avoid floating point errors
-
gossip
A generic gossip library that uses gossip-based peer sampling
-
easings-rs
easings crate without any bells and whistles
-
probabilities
Compact library for sampling and calculations related to various statistical distributions
-
crypto_api_blake2
Implements Blake2b for
crypto_api -
knn
compute KNN
-
gaps
Functionality for working with gaps/holes in ordered sequences of values
-
knaptime
Solve the knapsack problem and its variants
-
packed-vec
Sorted, deduped, compressed vector of integers
-
gcm-lcm
Greatest convex minorant, least concave majorant
-
grapher
Simulate and visualize a force directed graph
-
benford
test the Benford-ness of a given set of numbers
-
sortby
adds convenient sort functions for Iterators
-
streemap
Set of tree map algorithms (binary, squarified, ...)
-
porco
Composable probability distributions
-
simple_graph_algorithms
goal of making running graph algorithms as easy as possible
-
seximal
(base6) equivalent of Rust's type system
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse's LDL algorithm
-
async_to_iter
Convert async functions to generators on stable Rust
-
osqp-sys
FFI bindings to the OSQP (Operator Splitting Quadratic Program) solver
-
hotsax
based discord discovery algorithms
-
detect-lang
Language detection given paths and extensions
-
stackbt_behavior_tree
Behavior Trees for StackBT
-
f8
It's a float! It's a unorm! It's only one byte!
-
czt
The package provides an algorithm to compute the chirp Z-transform
-
snake_case_converter_slom_test
convert strings to snake case
-
generic-str
Annoyed that Rust has two string types? Well it doesn't any more
-
lev_distance
A copy of Levenshtein distance implementation from Rust Compiler
-
ackr
Storm acking algorithm in Rust
-
scip-sys
Bindings for the C SCIP solver
-
gworld
evolve genetic algorithms (beginner friendly to advanced) and reduce boilerplate setup
-
rand_isaac
ISAAC random number generator
-
malwaredb-murmurhash3
MurmurHash3 implementation
-
mapwords
HashMap based keyword extraction
-
generic-matrix
Manipulations and data types that represent 2d matrix
-
shufflr
Shuffle a lists using Fisher-Yates algorithm
-
fibonacci-like
A small crate to help you interact with second order sequences, such as the Fibonacci sequence, with no_std support
-
szyk
generic topological sort
-
rodar
a command line tool that brings together all the functions Roy would use for analysis and decision-making
-
rblas
BLAS bindings and wrappers
-
permut_lib
function to generate permutations on a dictionry of a u8 chars set. I used it for generate unic Items into my proc macros.
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
cogset
Generic implementations of clustering algorithms. Includes k-means, DBSCAN and OPTICS.
-
scialg
A collection of scientific algorithms
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
strseq
A string sequence library for Rust
-
equation_generator
Generate random equations ! WIP
-
closest
nearest neighbor implementation
-
full
Matrix and array types for numeric values
-
threed-ice
The package provides an interface to 3D-ICE
-
yavomrs
Variation of Myers for generic containers
-
boostvoronoi_core
Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)
-
map-gen-2d
2D map generation algorithms implementaion
-
icp_2d
A 2D Iterative Closest Point implementation in Rust
-
read-byte-slice
An iterator over chunks of bytes as slices from an underlying reader
-
rendezvous_hash
Rendezvous hashing algorithm
-
fluent_state_machine
A domain-specific language (DSL) for creating state machines in Rust
-
fpopt
a wrapper around manipulating floating point flags
-
mersenne-twister-m
mersenne twister pseudorandom number generator
-
rs-category
Categorical traits
-
boomphf-patched
Scalable and Efficient Minimal Perfect Hash Functions (version modified by Piotr Beling)
-
squirrel3-rs
reliable random number generator
-
nohash-hasher
std::hash::Hasherwhich does not hash at all -
wy
wyhash algorithms
-
permutation-rs
Do calculations with groups
-
but-what-about
A permutation & combination calculation crate for rust
-
state_machine
state machine
-
fibonacii-heap
Priority queue implemeted using a Fibonacii Heap
-
bitap
in rust
-
csparse21
Sparse Matrix Solver
-
ffuzzy
generate / parse / compare ssdeep Context Triggered Piecewise Hashes (CTPH)
-
fsm-rust-jb
FSM (with effects, like Mealy machine) implementation in Rust
-
kurobako_problems
A collection of black-box optimization problems
-
suffix
arrays
-
byte_arithmetic
arithmetic on byte-like objects
-
reverse-lines
Rust Iterator for reading files line by line with a buffer in reverse
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
dynforest
dynamic forest management
-
mincost
A collection of modern heuristic optimization toolkit
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
more-iter
More iterator utilities
-
packr2
a few packing algorithms for your needs
-
index-sort
Sort containers by index using user-specified swap and compare functions
-
sorting_explorer
An exploration of various sorting algorithms
-
sprs-rand
Random sparse matrix generation
-
gmatlib
linear algebra in Rust and beyond!
-
pareto_front
Builds a Pareto front incrementaly
-
various_data_file
Store a dainary datas in a file. Use mmap, optimize fragments on delete, and reference identical strings.
-
yabe
Integer bitcasts through the use of Mul and autoref specialization
-
math_lib_test
test Library for rust
-
graph_solver
An undirected graph constraint solver for node and edge colors
-
distance
A collection of approximate string matching algorithms
-
divider
low level 2D path linearize and trapezoidator.fork from makepad
-
darwin-rs
Evolutionary algorithms library written in Rust
-
inttable
Specialized HashMap for randomly-distributed u64 keys
-
rbtree-defrag-buffer
Red-black tree based defragmentation buffer that maintains inserted and free intervals
-
math-interpolate
Linear interpolation between two points to calculate the 3rd point
-
voxel_chunk
A voxel object module which allows you to have private Chunk objects with methods to modify their data
-
int_ranges
ranges tools for integer
-
algorithms-edu
Algorithms for pedagogical demonstration
-
simple-rnd
Tiny random number generation library
-
spelling
A spellchecker using the Levenshtein distance as the heuristic for distance
-
dda-voxelize
3D mesh voxelization with the DDA algorithm
-
rummikub_solver
Solves a board of Rummikub game by attempting to fit every piece given into a valid game set
-
river-ring-buffer
ring buffer implementation
-
rustsat-glucose
Interface to the SAT solver Glucose for the RustSAT library
-
mime-detective
The
MimeDetectivespies for the magic number of a file or buffer and spits out strongly typed Mimes -
mersenne_twister
Mersenne Twister pseudorandom number generator
-
log_buffer
A zero-allocation ring buffer for storing text logs
-
hash-match
Optimized pattern matching alternative
-
isl-rs
Rust bindings for Integer Set Library
-
slur
A fast, iterative, correct approach to Stackblur, resulting in a very smooth and high-quality output, with no edge bleeding
-
hidden-median
Finds the median of two lists, when merged without breaking sorted state
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
easings
Robert Penner's easing functions
-
grid_search_cardinal_point_to_point
Search algorithm for finding the shortest path between two points in a uniform-cost cardinal grid
-
num-to-words
Number to words converter
-
static_str_ops
A package allows using static strings with non-trivial operations, e.g.,
concat!,format!,call_once, and more -
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
-
yass-2
string similarity library
-
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
binary-helper
binary conversion crate
-
revonet
real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
statest
statistical test
-
german-str
small-string optimized string type with fast comparisons
-
solve-leetcode
Solutions to leetcode in rust
-
drain_at_sorted_unchecked
Terribly unsafe but highly efficient function that allows removing items from a vector with few moves
-
n18catalogue
Defines common 18xx tiles
-
map_to_range
map numbers from on range to another
-
rdx
A collection of traits and algorithms to ease using radix sorts
-
quickbacktrack
back tracking with customizable search for moves
-
iffi
Make assertions about values used over FFI
-
turk
A generic minimax algorithm that may be used as an AI player for 2-player games
-
peekable-buffer
Buffer with a cursor
-
macro_machine
State machine generator using macros
-
candle-gemm-f32
Playground for matrix multiplication algorithms
-
backtrack
Solve hard constraints easily
-
ordered-map
A HashMap, with the capability of accessing the keys and values in order
-
dyn_array
easy to use N-dimensional dynamic array
-
flo_sparse_array
Sparse array data type: a fast map between usize values and data
-
str-distance
Distance metrics to evaluate distances between strings
-
best-path
Shortest/longest path algorithms, where edge weight accumulation via either a sum or a product
-
numb_rs
An experimental numeric package
-
broccoli-rayon
broadphase collision detection algorithms
-
affine_transforms
(Pre Release Package) Does linear transformations in R3
-
bsutils
Binary search utilities with efficiency
-
lesspass
An efficient implementation of the LessPass password generator
-
index_key
lexicographic sort order encoding
-
uno
Encode floats in the range [0.0, 1.0] as unsigned integers!
-
blitz-path
Implementations of the A* and JPS pathfinding algorithms
-
advancedresearch-error_predictive_learning
Black-box learning algorithm using error prediction levels
-
polysplit
Algorithm that allows to split polylines into segments by the defined list of points not necessary belonging to the polyline
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
bitset-fixed-utils
A bunch of utility stuffs that I use when working with bitsets in Rust
-
generalized_suffix_tree
Generalized Suffix Tree using Ukkonen's algorithm in Rust
-
tdigest-rs
T-Digest algorithm in Rust
-
constfft
providing an FFT API for arrays
-
number_traits
number traits
-
pia
that adds packed integer arrays for mass storage of oddly sized variables
-
hyperid
Superfast id generator
-
watchmaker
A genetic algorithm implementation in Rust
-
metromc
Markov chain Monte Carlo sampling using the Independence Metropolis-Hastings algorithm
-
minutae
Cellular Automata-esque simulation engine involving a 2D universe populated by cells and entities
-
scicrypt-numbertheory
A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation
-
itertree
Hobby project to experiment with tree traversal using iterators
-
sra
A collection of spaced repetition algorithms
-
hangeul-id
Shorter unique id using Hangeul
-
jandom
Port of java.util.Random
-
lgeo
2D Geometry library, focusing on collision computation
-
fhex
providing the ToHex trait for converting floating-point numbers to hexadecimal
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
m4ri-rust
M4RI-based boolean linear algebra
-
tiny_tco
A tiny dirt simple no_std tail call optimization library
-
bloock-merge
merge for our Sparse Merkle Tree
-
shash
An arbitrary-length-input hash function for competitive programming and experimental purposes
-
zkp-mmap-vec
Replacement for
Vecthat uses file-backed storage -
quickmaths
A collection of algorithims for generic mathematics
-
spatium
Spatium. Calc distance between sequences.
-
crc8-gsma-fast
SIMD-powered implementation of CRC-8/GSM-A
-
hashvec
A HashMap/Vector hybrid: efficient, ordered key-value data storage
-
perlin2d
Lightning fast 2D Perlin Noise generator
-
automafish
state machine builder for creating deterministic state machines out of nondeterministic state machine definitions
-
isogeometric_analysis
Create implementing algorithms related to Isogeometric Analysis. Bezier, B-spline, NURBS, numerical integration and isogeometric approach to PDE approximation.
-
genesys-dice-roller
dice rolling library for genesys dice strings
-
take-some
that provides a way to obtain *some* value from various collections
-
rust-numerals
converting
i64integers into their cardinal string format -
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
librsb-sys
FFI interface for librsb
-
num_string
perform conversion between string and number
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
star_rng
opinionated PRNG for easier fuzz testing
-
order-maintenance
Totally-ordered priorities for the order maintainence problem
-
funny_crystal_hasher
Reimplementation of the funny_hash algorithm
-
identity-hash
std::hash::Hasherwhich does not hash at all -
klownie_matrice
My personnel project on matrices
-
cut-optimizer-1d
A cut optimizer for cutting linear pieces
-
yn
Natural language processing library for yes or no values
-
compute-float
Computes floating point numbers using Eisel-Lemire algolithm
-
bft-core
An efficient and stable Rust library of BFT core for distributed system
-
numerilib
Mathematics Library
-
snowgen
generating unique, time-based IDs using the Snowflake algorithm
-
ss-graph-rs
A graph algorithm library written in Rust, primarily featuring a function for finding all paths
-
savant_rs
Savant rust optimization library
-
randge
Generate unique random numbers
-
varisat-internal-proof
Internal proof format for the Varisat SAT solver
-
alg_ds
Algorithms & data structures
-
heterogeneous_graphlets
computation of heterogeneous graphlets
-
eziter
Wrapper around Iterator
-
maze_generator
different maze generation algorithms
-
a-star_traitbased
Implemetaion of A* useful for stuct, based on train implementation
-
to_precision
Write out a float rounded to the given position
-
rand-wyrand
The extremely fast WyRand PRNG for the rand ecosystem of crates
-
py-fossil-delta
functions for calculating differences between strings and applying calculated deltas
-
blu
LU factorization with dynamic Markowitz search and columnwise threshold pivoting
-
xtoken
Iterator based no_std XML Tokenizer using memchr
-
rusty_grammar
A modified CYK algorithm to work for Language
-
const-linear
linear algebra library based on const generics
-
membuf
A safe-ish wrapper for allocating and reallocating heap buffers
-
writebuf-core
A writable buffer that implements fmt::Write or ufmt::uWrite
-
pascal_case_converter_slom_test
convert strings to snake case
-
pi_guid64
An GUID Generator
-
z3-sys
Low-level bindings for the Z3 SMT solver from Microsoft Research
-
radiate_web
Train Radiate remotely
-
rure
A C API for Rust's regular expression library
-
stalin-binary-search
alike binary search but any checking element which is not target one is eliminated
-
gacha-traits
traits for making gacha emulators
-
monster
Collection of random utilities
-
rs_state_machine
A business-oriented state machine library
-
quickfib
A no_std compatible Fibonacci calculation algorithm implemented in Rust
-
Algod
Many types of rust algorithms and data-structures
-
prototty_event_routine
Pseudo-synchronous composable event-based state machines for prototty apps
-
uncertainty
allow the creation and arithmetic operations on numbers with uncertain values
-
ndarray-rblas
rblasbindings forndarray -
aid
Rust port of the id generation algorithm use in Misskey
-
geometric_algebra
Generate(d) custom libraries for geometric algebras
-
round_mult
A tiny library to round a number up or down to a multiplier
-
deviz
access to a VS Code extension for displaying structured program output
-
eprng
Extremely Pseudo RNG
-
rollsum
Rolling checksum implementation
-
isize-vec
isize sorted vector
-
alea
randomness
-
pcg
A port of the PCG random number generation library
-
delsum-lib
most functionality for the delsum crate
-
usize_conversions
Conversion traits for conversions between
usizeand fixed sized integers -
mx3
algorithm providing a bit mixer, pseudo-random number generator, and hash function
-
count_sort
O(n) sorting library for large datasets with small range of possible values
-
do_util
Discrete Optimization utilitary library (data-structures)
-
las-kml-to-stl
A short description of my package
-
salsa
A generic framework for on-demand, incrementalized computation (experimental)
-
diamond-square
Generate heightmap using diamond-square algorithm
-
hnsw
Fast approximate nearest neighbors
-
vlfeat-sys
FFI bindings to vlfeat library
-
oblivious_state_machine
defines an abstraction level to conveniently describe state machines
-
piston-history_tree
A persistent history tree for undo/redo
-
quicksort_gen
Generic implementation of quicksort algorithm
-
biterate
API for Gurobi optimizer
-
heapp
Some heap operations on slice
-
grid_search_cardinal_distance_map
Grid where each cell stores the distance from a set of interesting points to each cell in a uniform-cost cardinal grid
-
deterministic-finite-automaton
generic implementation of a deterministic finite automaton
-
grid_search_cardinal_common
Reusable components for use implementing uniform-cost cardinal grid-searching algorithms
-
ordered-vector
Keep ordered vector of mutable elements
-
froggy-rand
Random number generation without state for games
-
bound-stl
attempts to implement lower_bound and upper_bound in C++ STL
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
exxact
drop-in float replacement for exact arithmetic
-
step-machine
Run your CLI program as state machines with persistence and recovery abilities
-
fastcmp
A fast byte slice comparison library
-
pdqsort
Pattern-defeating quicksort
-
bogo-plus-plus
Blazingly fast 🚀 AI 🤖 Powered Sorting algorithm
-
poker
speedy poker hand evaluation
-
geo-rand
Generate random geometric shapes
-
rustlex_fsa
manipulating (deterministic) finite automata
-
squares-rng
Squares RNG for game development
-
rxqlite-notification
A distributed sqlite database built upon
openraft,sqlxandsqlite -
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
integer-hasher
std::hash::Hasherwhich does not hash at all -
str-similarity
A string similarity library
-
aabel-hashmap-rs
implements extensions for HashMap
-
func-iter
Functional programming utitilies for iterators and collections
-
hexagon-map
Coordinate transformation and pathfinding for hexagonal maps
-
geohash-tools
A collection of functions to manipulate GeoHashes
-
robin_merge
merging vectors round-robin style
-
tlsh
Rust port of Trend Micro Locality Sensitive Hashing
-
evolutionary
A fully extensible Rust framework for using paralyzed genetic algorithms to solve problems
-
rustsat-cadical
Interface to the SAT solver CaDiCaL for the RustSAT library
-
wfc_voxel
A Wave Function Collapse solver using preliminary voxel files
-
algen
A parallelized genetic algorithm runner
-
rustsat-minisat
Interface to the SAT solver Minisat for the RustSAT library
-
igs
solving impartial games
-
ciclo
Exhaustive cycle enumeration
-
prandom
Some PNRG algorithms implemented in Rust
-
byte-num
converting numbers to bytes, and bytes to numbers in base 10!
-
algorithm_rust
some common rust_algorithms, Everyone can participate, and the project will continue to be updated, all the algorithms comes from <Introduction to Algorithms III>
-
small-sorted-map
Heap-stored map based on a sorted list
-
triangulation
A collection of triangulation algorithms
-
elements-frequency
Finds the frequency of elements in a list
-
n_best
Convenient collection to gather the N highest elements, and discard the others
-
exotic-iter
My personal collection of special-case iterator methods
-
rscompress-approximation
data approximations supporting rscompress
-
reachability_solver
A linear reachability solver for directional edges
-
pack
Solver for packing puzzle
-
winsfs-core
Site frequency spectrum estimation based on window expectation-maximisation algorithm
-
primitive_traits
Traits over primitive types. Particularly stuff not covered by num-*.
-
web-glitz-buffer-vec
Implements growing WebGlitz memory buffers for slices of data
-
cellular_maps
generate 2D procedural bitmaps using the cellular automata technique
-
iter_vec
vector of iterator but specialized for std::slice::Iter
-
ruststft
computes the short-time fourier transform on streaming data
-
rustgym-util
handy macros, data types and traits for rustgym
-
lsap
Solving linear sum assignment problem using JV algorithm as in Scipy
-
closed01
checked floating point operations within the range [0,1]
-
myopic-brain
Search and evaluation for determining best move available in a chess game
-
iterchunks
An iterator adapter to adapter that yields N elements of the iterator at a time
-
plumtree
algorithm
-
lsh-rs
LSH: Approximate Nearest Neighbor Search with Locality Sensitive Hashing
-
masker
Mask patterns in data
-
xxhash-c
Safe wrapper to xxhash
-
clingo-sys
Raw FFI bindings to the C API of the clingo library
-
dynamic-weighted-index
Data structure to sample elements with weights that can be efficiently updated
-
wyhash2
in rust
-
wordfeud-solver
evaluate all possible moves given a wordfeud board and rack
-
limited_direction
Find path to any direction and distance but with limited directions
-
bufferpool
A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions
-
random_tester
similar to https://www.fourmilab.ch/random/
-
aristeia
An evolutionary computation library
-
graph-neighbor-matching
Graph similarity score using neighbor matching
-
copper
A constraint programming solver
-
attorand
A small random number generator hacked on top of Rust's standard library
-
xxh3
XXH3 hash function
-
batbox-color
Working with colors
-
former_types
A flexible implementation of the Builder pattern supporting nested builders and collection-specific subformers. Its compile-time structures and traits that are not generated but reused.
-
ivy-random
random utility functions to the ivy framework
-
tousize
A helper trait to convert values into usize
-
genomic
A small crate for implementing genetical algorithms
-
rusted_pipe
Real time processing library for developing multithreaded ML pipelines, written in Rust
-
string-ring
A circular string buffer with character- and line-level granularity
-
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
-
generic-matrix-impl
generic matrices and their associated operations
-
valistr
Creating immutable string wrapper types with values validated with regexes
-
moore-hilbert
A safe Rust binding to Doug Moore's Fast Hilbert Curve Generation, Sorting, and Range Queries
-
regex_macros
statically compiled regular expressions for Rust. Unless you specifically need compile time regular expressions or a matching engine that is guaranteed not to allocate, you should temporarily prefer using…
-
etsm
Efficient Tiny State Machine using object callbacks
-
n18map
Manages the state of 18xx maps
-
msws
Middle Square Weyl Sequence pseudorandom number generator
-
flo_curves
manipulating Bezier curves
-
sqnc
Traits and adaptors for sequences
-
stringr
random string functions
-
miraland-nohash-hasher
std::hash::Hasherwhich does not hash at all -
ord_by
Conveniently attach a custom compare function to any type
-
kitty_pool
A safe buffer pool
-
permoot
General-purpose no_std permutation library
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
eytzinger-map
array/vec based map using eytzinger search algorithm
-
varisat-dimacs
DIMCAS CNF parser and writer for the Varisat SAT solver
-
crc8-cdma2000-fast
SIMD-powered implementation of CRC-8/CDMA2000
-
nostbeep
A no_std implementation of a binary heap. Binary Heap is implemented as a max heap.
-
sol_prng
functional pseudo random number generator. No mutability. Relies on shadowing as of now.
-
rbi
A FIFO index queue that can be used for implementing a ring buffer
-
blake3-std
the BLAKE3 hash function implementation with std::simd
-
md6
hash function for Rust via FFI
-
java-rand
java.util.Random
-
mattr
transposing multi-dimensional data
-
funfsm
An FSM library where the states are functions
-
str_stack
string allocator for allocating many write-once strings. This library is primarily useful for parsing where you need to repeatedly build many strings, use them, and then throw them away…
-
sfmt
SIMD-oriented Fast Mersenne Twister (SFMT)
-
assessment
that allows different types of assessments, to convert between them and to perform basic operations
-
quad3
quadtree implementation in Rust
-
total-space
Explore the total space of states of communicating finite state machines
-
rs_sha512_256
rs_sha512_256is a Rust implementation of the SHA-512/256 cryptographic hash algorithm, part of the largerrs_shieldproject. This package provides SHA-512/256 hashing functionality in a standalone manner… -
rs_sha512
rs_sha512is a Rust implementation of the SHA-512 cryptographic hash algorithm, part of the largerrs_shieldproject. This package provides SHA-512 hashing functionality in a standalone manner… -
small_str
A String-like but using SmallVec internally
-
generations
running generation-based simulations in Rust
-
beehave
defining and evaluating a hierarchical state machine (behaviour tree)
-
random-trait
random trait meant to produce random generic types
-
slicetools
Add extra iterators to slices
-
rs-kdbush
A very fast static spatial index for 2D points based on a flat KD-tree
-
floating-distance
Measure distance between floating-point vectors in Rust
-
f3l_surface
3D Point Cloud Library
-
max-subarray-sum
Finds the maximum subarray sum in a list
-
rbf
Super simple const generics based ring buffer implementation for no_std
-
double-buffer
double buffer generic implementation
-
iso_iec_7064
Support for check digit operations conforming to ISO/IEC 7064
-
pqgrams
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…
-
graph-tools
Graph tools and algorithms written in Rust
-
spare_buffer
A wrapper around Vec that provides access to the “spare” capacity of the vector as a mutable slice
-
fastnoise-simd
A safe wrapper around the fastnoise-simd-bindings crate
-
ncollide_testbed3d
3D testbed for ncollide
-
bitap-reference
Reference functions for the bitap crate
-
luhn3
A Luhn validation library
-
c3-linearization
C3 linearization
-
epilog
A collection of Prolog-like tools for inference logic
-
bareiss
Calculates the determinant of an integer square matrix
-
ordered_vec
A trait that ensures that elements in a vector are pushed in a sorted order (both ascending and descending)
-
onemax-oxigen
OneMax simple problem resolution using oxigen
-
octopus_query
query engine for arrays of integers (scoring only idf at the moment), supports AND/OR/DisMax/Constant queries
-
generic-octree
generic implementation of a linear Octree
-
byteloaf
heap-allocated byte buffer (a 'loaf') via independently owned, accessed, and moved slices
-
libreda-interp
Interpolation of one and two dimensional arrays
-
vec_rand
Vec generator to hold random contents
-
plot_interface
Plot interface
-
elara-math
Rust-native tensor and math library
-
sonare
Runtime environment for formally-verifiable distributed software
-
building_blocks_search
Search algorithms for voxel data
-
smart_buffer
A hybrid stack/heap buffer
-
genetic_algorithms
solving genetic algorithm problems
-
enchainte-merge
merge for our Sparse Merkle Tree
-
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
-
istos
graphs
-
kdvtree
K-dimensional tree space-partitioning data structure
-
qunit
Experimental uom-like library which enables compile-time verification of dimensional analysis, with support for statically-sized vectors and matrices
-
intern-str
Efficient, compile-time string interning for Rust
-
bernoulli
An exact Bernoulli distribution
-
sparse_graph
Sparse graph algorithms
-
microstate
Finite state machine, inspired by micromachine
-
koek-redact
Allows for redaction of values when outputting them to places where sensitive data is not permitted
-
mycrc
Create your own cyclic redundancy check (CRC)
-
meta_tools_min
Collection of general purpose meta tools. Minimal Set.
-
pushy
A pushable stack-allocated buffer
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
schindel
rust min-shingle hashing
-
fastfloat
Fast-math wrapper and convenient numeric functions for approximate floating point operations in Rust
-
mesh-sweeper
Mesh sweeping algorithms!
-
crc32-aixm-fast
SIMD-powered implementation of CRC-32/AIXM (CRC-32Q)
-
sparsemat
sparse matrix library
-
candle-gemm-f64
Playground for matrix multiplication algorithms
-
alyx
Alyx
-
genetic-algorithm-fn
Using genetic algorithms to maximize functions
-
tree-edit-distance
Find the lowest cost sequence of edits between two trees
-
fasthash
A suite of non-cryptographic hash functions for Rust
-
debug_sat
A debuggable automatic theorem prover for boolean satisfiability problems (SAT)
-
xfind
Fast forward and backward stream search routines
-
xcc
Exact Cover solver with color extensions
-
generic-state-machine
that allows to create generic or Moore or Mealy state machines that allows the use of custom transition functions
-
rule30
Pseudo random number generator with cellular automaton rule 30
-
fst-bin
command line tool for using finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible). The command line tool exposes functionality to search FSTs using regular expressions…
-
norm
A collection of distance metrics on strings
-
ordslice
Extensions for ordered slices
-
csinsertion_sort
Insertion sort implementation for indexable collections
-
simple_nn
nueral network library
-
autobahn-hash
HighwayHash, a fast and strong SIMD hash function
-
shufflebag
A shuffle bag implementation on rust
-
randlib
Dependency-less random value generator using pointer addresses and time
-
murmur2
hash functions - see docs.rs
-
rl-bandit
multi-armed bandit implementation
-
generic-floyd-warshall
A generic implementation of the Floyd-Warshall algorithm for array-like types
-
find-simdoc
Time- and memory-efficient all pairs similarity searches in documents
-
miura
Math library written for learning Rust
-
spatial-neighbors
certain Spatial-Partitioning Algorithms | DataStructures
-
smolmask
A small library for storing small binary masks in just a single integer
-
logicng-open-wbo-sys
LogicNG Bindings for OpenWBO
-
slice_search
A collection of algorithms for searching within slices
-
stackbt_automata_impl
Automata implementations for StackBT
-
finite-state-machine
A type and trait based finite state machine macro
-
bqrs
apply boolean query to text
-
rent_vec
vector with a unique owner for every item
-
candle-gemm-c32
Playground for matrix multiplication algorithms
-
mop-blocks
Foundation blocks for MOP
-
alcs
All Longest Common Subsequences and String Fuzzy Search
-
smbus-pec
Minimal portable implementation of SMBus Packet Error Code calculation algorithm
-
hash-algorithms
Hash, generally translated as hash, hash, or transliterated as hash, is to transform any length of input (also known as pre image) into fixed length output through hash algorithm, and the output is the hash value…
-
checksum
Calculates crc32/crc64 file checksums written in Rust
-
deki_core
A collection of crates, functions and renames tailored to myself!
-
fliphash
A constant-time consistent range-hashing algorithm
-
curveipo
2D curve interpolation
-
letterboxed
A solver for the New York Times Letter Boxed puzzle - https://www.nytimes.com/puzzles/letter-boxed
-
cuckoo
search algorithm
-
yet-another-md5
compute md5 hashes from Read objects
-
cutter
usefull functions for parsing text. Used for cutting between strings.
-
block-pseudorand
Generator of random Vec<T>'s for types that can be transmuted from arbitrary bytes
-
animgraph
Animation data flow library using hierarchical state machines
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
grid_search_cardinal_best
Search algorithm for finding the shortest path to the best cell in a uniform-cost cardinal grid
-
nucleic-acid
Implementations of Suffix Array, Burrows-Wheeler Transform and FM-index
-
tile-buffer
Tiling Buffer useful when dealing with range requests
-
simdutf8
SIMD-accelerated UTF-8 validation
-
lisa
longest increasing subsequence algorithm [ O( nlogn ) ]
-
lazy-transform-str
Lazy-copying lazy-allocated scanning
strtransformations. This is good e.g. for (un)escaping text, especially if individual strings are short. -
array-matrix
Treats two-dimensional arrays as matrices and introduces matrix operations
-
jenkins_hash
Native rust implementation of the hash algorithms from Bob Jenkins
-
ig_tools
Misc tools for list hashing, sorting and io
-
priority_container
Datastructure to find n biggest/smallest items within a large set
-
prefix-range
Compute bounds for prefix string queries for BTreeSet/BTreeMap::range
-
suraft
extended Raft algorithm
-
n18io
Manages the (de)serialisation of 18xx tiles and maps
-
sacabase
Base types and functions for suffix arrays and longest substring search
-
highhash
High-speed hashing algorithms for Rust
-
waifu
solver
-
base62num
A convertor between numbers and strings in Base62
-
kmp
Various functions using the Knuth–Morris–Pratt algorithm to efficiently find patterns
-
fxsm
A state machine procedural macro for enums
-
coloring
Convert values to color simply and securely
-
concorde_rs
binding to Concorde TSP Solver
-
pmsa
Parallel Mergeing of two Sorted Arrays
-
coinipopt-sys
The low-level bindings to the COIN-OR Clp library
-
selfsimilar
A fast generator of discrete self similar random numbers
-
vqsort-rs
Rust bindings for the Google Highway's vectorized quicksort
-
kagemeka
Kagemeka's Rust Package
-
const-crc32
A
const fnimplementation of crc32 checksum algorithm -
ccl-fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc. This is a fork designed for use with ccl. Rights go to the original creator.
-
pocket_prover-set
A base logical system for PocketProver to reason about set properties
-
scorpius
data structures and algorithms library
-
search-autocompletion
Search Auto Completion
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
morel
A string searching library
-
varisat-formula
Basic formula data types used by the Varisat SAT solver
-
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
-
npy-writer
Export numpy arrays in the npy or npz format
-
crc-32c
Comput CRC-32C using accelerated SIMD and fusion algorithm
-
pvpgn-hash-rs
Battle.net v1.0 hash algorithm implementations on rust
-
stacked-sandwich
Find all occurances of a number in a row/column sorted matrix; in square root of linear time!
-
smolmap
A hashmap on the stack
-
twentyfour
A solver for the 24 card game
-
csselection_sort
Selection sort implementation for indexable collections
-
random-fast-rng
Blazing fast non cryptographic random number generator
-
multistr
Store multiple strings in the same heap buffer
-
sorted-rotated
Finds a number in a sorted and rotated list in O(logN) time
-
itemops
some operations on items of slices
-
fsmentry-core
Finite State Machines with an entry API and data storage
-
rs_sha3_256
rs_sha3_256is a Rust implementation of the SHA3-256 cryptographic hash algorithm, part of the largerrs_shieldproject. This package provides SHA3-256 hashing functionality in a standalone manner… -
buf-trait
abstract over [u8], str, and friends
-
hashdozen
A novel 48 bit hashing algorithm producing human-readables hashes
-
rsfsm
Rust Finite State Machine Library
-
semistr
Immutable string stored inline or on heap
-
lcg-rand
Lightweight open source random number generator using the Linear Congruential Generator algorithm
-
diagonal
Extract diagonals from a matrix in various directions
-
rolling-dual-crc
Rolling CRC with 32-bit CRC32C and 64-bit CRC64/XZ
-
snappy_framed
Read and Write implementations for streaming, framed Snappy compression format
-
scalar
A trait for scalars (integers and floats)
-
gen-combinations
A general combination generator
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
smart_ape
A genetic algorithms library
-
rs_shake256
rs_shake256is a Rust implementation of the SHAKE256 cryptographic hash algorithm, part of the largerrs_shieldproject. This package provides SHAKE256 hashing functionality in a standalone manner… -
crc16-ibm3740-fast
SIMD-powered implementation of CRC-16/IBM-3740 (CRC-16/AUTOSAR CRC-16/CCITT-FALSE)
-
curuam
lot of useful functions and structs like Ipv4, Ipv6, Mac, random_in_range, memcpy, checksum, EthHeader, IpHeader, and etc
-
searchsort
trait implementing Binary Search and Quick Sort algorithms
-
fingles
hash-based text similarity analysis