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