-
rand
Random number generators and other randomness functionality
-
twox-hash
A Rust implementation of the XXHash and XXH3 algorithms
-
crc
Rust implementation of CRC(16, 32, 64) with support of various standards
-
ndarray-linalg
Linear algebra package for rust-ndarray using LAPACK
-
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
pathfinding
Pathfinding, flow, and graph algorithms
-
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.
-
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…
-
float_eq
Compare IEEE floating point primitives, structs and collections for equality
-
fastrand
A simple and fast random number generator
-
whatlang
Fast and lightweight language identification library for Rust
-
rustfft
High-performance FFT library written in pure Rust
-
highway
Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
-
nanorand
A tiny, fast, zero-dep library for random number generation
-
alphanumeric-sort
This crate can help you sort order for files and folders whose names contain numerals
-
bitpacking
Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.
-
xxhash-rust
Implementation of xxhash
-
probability
The package provides a probability-theory toolbox
-
passwords
This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them
-
rand_distr
Sampling from random number distributions
-
rustc-hash
speed, non-cryptographic hash used in rustc
-
md5
The package provides the MD5 hash function
-
ff
Library for building and interfacing with finite fields
-
rand_core
Core random number generator traits and tools for implementation
-
daachorse
Daachorse: Double-Array Aho-Corasick
-
rust-lapper
A fast and easy interval overlap library
-
simdutf8
SIMD-accelerated UTF-8 validation
-
dusk-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
naive_opt
The optimized naive string-search algorithm
-
roots
Library of well known algorithms for numerical root finding
-
triple_buffer
An implementation of triple buffering, useful for sharing frequently updated data between threads
-
k
k is for kinematics
-
dissimilar
Diff library with semantic cleanup, based on Google’s diff-match-patch
-
fst
Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)
-
crc32c
Safe implementation for hardware accelerated CRC32C instructions with software fallback
-
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
-
rdrand
An implementation of random number generator based on rdrand and rdseed instructions
-
genevo
genevo provides building blocks to run simulations of optimization and search problems using genetic algorithms (GA). Execute genetic algorithm (GA) simulations in a customizable and extensible way
-
fastcdc
FastCDC (content defined chunking) in pure Rust
-
ulid
a Universally Unique Lexicographically Sortable Identifier implementation
-
math_adapter
Collection of math adapters to decouple your application from math libraries’ implementations and to provide both inter-libraries compatibility and affordable exchangeability
-
broccoli
broadphase collision detection algorithms
-
differential-dataflow
An incremental data-parallel dataflow platform
-
cam-geom
Geometric models of cameras for photogrammetry
-
wildmatch
Simple string matching with questionmark and star wildcard operator
-
slice-group-by
Iterators over groups in a slice
-
counting_sort
Counting sort implementation for Iterators
-
oorandom
A tiny, robust PRNG implementation
-
screwsat
A simple condlict driven clause learning sat solver
-
nlopt
Wrapper for the nlopt library
-
vek
Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience
-
out
Provides fast min and max functionality for collections
-
xorf
Library implementing xor filters - faster and smaller than bloom and cuckoo filters
-
chalk-solve
Combines the chalk-engine with chalk-ir
-
transvoxel
Implementation of Eric Lengyel’s Transvoxel Algorithm
-
rand_chacha
ChaCha random number generator
-
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…
-
yada
Yada is a yet another double-array trie library aiming for fast search and compact data representation
-
sets
Generic vectors as sets. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.
-
rdst
A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes
-
hexagonal_pathfinding_astar
A-Star pathfinding algorithm tailored for traversing a bespoke collection of weighted hexagons
-
memx
memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
ros-nalgebra
ROS message converter for rosrust and nalgebra
-
clingo
Rust idiomatic bindings to the clingo library
-
gcd
Calculate the greatest common divisor
-
svg2polylines
Convert SVG data to a list of polylines (aka polygonal chains or polygonal paths)
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
chalk-recursive
Recursive solver for the Chalk project
-
rand_mt
Reference Mersenne Twister random number generators
-
cap-rand
Capability-based random number generators
-
rustdct
Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust
-
fake
An easy to use library for generating fake data like name, number, address, lorem, dates, etc
-
vrf
Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves
-
iter-read
A Read implementation for iterators over u8 and related types
-
powierza-coefficient
Powierża coefficient is a statistic for gauging if one string is an abbreviation of another
-
delaunator
A very fast 2D Delaunay triangulation library
-
boostvoronoi
Boost voronoi ported to 100% rust
-
crc_all
A Pure Rust Implementation of Generic CRC Algorithm
-
timely
A low-latency data-parallel dataflow system in Rust
-
quantiles
a collection of approximate quantile algorithms
-
pso-rs
An easy-to-use, simple Particle Swarm Optimization implementation in Rust
-
chalk-engine
Core trait engine from Chalk project
-
avalog
An experimental implementation of Avatar Logic with a Prolog-like syntax
-
radiate
Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems
-
linregress
ordinary least squared linear regression with some basic statistics
-
permutation
Small utility for creating, manipulating, and applying permutations
-
ranges
This crate provides a generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible
-
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.
-
id_tree_layout
A library to visualize trees from the ‘id_tree’ crate
-
convert-base
convert the radix (base) of digits stored in a vector
-
numext-fixed-uint
Fixed-size uint types
-
random_color
Rust crate for generating random attractive colors
-
polylog
Rust implementation of polylogarithms
-
iset
Map and set with interval keys (x..y)
-
adler32
Minimal Adler32 implementation for Rust
-
autodiff
An automatic differentiation library
-
hilbert
Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm
-
trade_aggregation
Aggregate raw trades into candles using different methods
-
flo_binding
Declarative binding library for Rust
-
probminhash
Minhash algorithms for weighted Jaccard index
-
rand_regex
Generates random strings and byte strings matching a regex
-
libbruteforce
This library helps you to brute force hashes (e.g. passwords). It includes a set of pre-configured hashing functions, like md5 or sha256. You can also provide your own hashing function…
-
regex-syntax
A regular expression parser
-
color-thief
Grabs the dominant color or a representative color palette from an image
-
graph
A library of high-performant graph algorithms
-
accrete
Rust port of Accrete, planetary system generation algorithm. Based on ‘Formation of Planetary Systems by Aggregation: A Computer Simulation’ by Stephen H. Dole. Improved and extended…
-
seahash
A blazingly fast, portable hash function with proven statistical guarantees
-
cobs
This is an implementation of the Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the “sentinel” value)…
-
earcutr
port of MapBox’s earcut triangulation code to Rust language
-
levenberg-marquardt
Levenberg-Marquardt algorithm built on top of nalgebra
-
bit-iter
Iterate forward or backwards over the positions of set bits in a word
-
treediff
Find the difference between arbitrary data structures
-
cdshealpix
Rust implementation of the HEALPix tesselation
-
usher
Parameterized routing for generic resources in Rust
-
tinymt
Rust implementation of TinyMT 64/32 - a lightweight variant of Mersenne Twister PRNG
-
maglev
Maglev - Google’s consistent hashing algorithm
-
cassowary
A Rust implementation of the Cassowary linear constraint solving algorithm. The Cassowary algorithm is designed for naturally laying out user interfaces using linear constraints, like…
-
nohash-hasher
An implementation of
std::hash::Hasherwhich does not hash at all -
mergable
A library for user-friendly and efficient CRDTs
-
hypernonsense
Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space
-
faiss
High-level bindings for Faiss, the vector similarity search engine
-
seal
Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment
-
npc-engine-core
The core of the NPC engine, providing a generic MCTS framework
-
caches
This is a Rust implementation for popular caches (support no_std)
-
integer-sqrt
An implementation of integer square root algorithm for primitive rust types
-
galois_2p8
Basic Arithmetic over all GF(2^8) fields
-
nonogrid
Efficient nonogram solver
-
numext-constructor
Fixed-size uint and hash constructor
-
hnsw_rs
Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
hex2d
Helper library for working with 2d hex-grid maps
-
random-pick
Pick an element from a slice randomly by given weights
-
poker
A crate for speedy poker hand evaluation
-
perchance
Very simple random number generation optimized for ease of use
-
worley-noise
Worley noise implementation
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
fxhash
A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc
-
hyperloglogplus
HyperLogLog implementations
-
coord2d
rust lib for coordinate in 2d system
-
geo-clipper
Boolean operations on polygons
-
magpie
Reasonably efficient Othello library built with bitboards
-
algebraics
algebraic numbers library
-
strsim
Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.
-
edit-distance
Levenshtein edit distance between strings, a measure for similarity
-
ids_service
Library that allows to generate unique Ids
-
vectora
A vector computation library
-
rust-stemmers
A rust implementation of some popular snowball stemming algorithms
-
vrp-pragmatic
An extension logic for solving rich VRP
-
fallible-iterator
Fallible iterator traits
-
extendhash
Rust Hash Extender
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
robust
Robust adaptive floating-point predicates for computational geometry
-
contour
Compute isorings and contour polygons (using marching squares algorithm)
-
scru128
SCRU128: Sortable, Clock and Random number-based Unique identifier
-
fractional_index
An implementation of fractional indexing
-
metaheuristics-nature
A collection of nature-inspired meta-heuristic algorithms
-
hashers
A collection of non-cryptographic hashing algorithms for Rust
-
historian
a high performance zero-config histogram implementation
-
ahrs
A Rust port of Madgwick’s AHRS algorithm
-
minimax-alpha-beta
An implementation of Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
is_sorted
Is an Iterator sorted?
-
simple_optimization
Simpler optimizers for simple optimization
-
sprs-ldl
Sparse cholesky factorization
-
graph_safe_compare
Equivalence predicate that can handle cyclic, shared, and very-deep graphs
-
strength_reduce
Faster integer division and modulus operations
-
genetic_algorithm
A genetic algorithm implementation
-
adler
A simple clean-room implementation of the Adler-32 checksum
-
boyer-moore-magiclen
Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust
-
uaparser
A Rust implementation of the UA Parser
-
multistream-batch
Implementations of batching algorithms
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
rgeometry
High-Level Computational Geometry
-
overlord
Overlord consensus procotol
-
tdigest
T-Digest algorithm in Rust
-
rust-spice
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
binary-merge
Minimum comparison merge of two sorted sequences with random access
-
bsa3-hash
The hash function used in BSA files for The Elder Scrolls III: Morrowind
-
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
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
ring_buffer
RingBuffer is a queue with added random access
-
highs
Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.
-
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
-
incrementalmerkletree
Implementation of an Incremental Merkle Tree
-
board-game
A board game abstraction and generic utilities around it
-
dilate
A compact, high performance integer dilation library for Rust
-
geos-sys
GEOS C API bindings
-
omnitigs
Omnitig-related algorithms
-
tailcall
Safe, zero-cost tail recursion
-
simd-adler32
A SIMD-accelerated Adler-32 rolling hash algorithm implementation
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
watchmaker_vm
A Rust implementation of a virtual machine for use with genetic algorithms
-
twofloat
Double-double arithmetic functionality
-
hashring
A minimal implementation of consistent hashing
-
idgenerator
A powerful unique id generator. Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity…
-
rs-graph
A library for graph algorithms and combinatorial optimization
-
oxigen
Fast, parallel, extensible and adaptable genetic algorithm library
-
rrt
Path finding using dual-RRT connect
-
vpsearch
Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces
-
noise
Procedural noise generation library
-
canonical-form
Reduce graphs and other combinatorial structures modulo isomorphism
-
glass_pumpkin
A cryptographically secure prime number generator based on rust’s own num-bigint and num-integer
-
subslice
Fast subslice search
-
metrohash
Rust implementation of MetroHash, a high quality, high performance hash algorithm
-
fuzzyhash
Pure Rust fuzzy hash implementation
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
movavg
Generic Moving Average calculation
-
romu
A pseudo random number generator using the Romu algorithm
-
hostlist-parser
Parses hostlist expressions into a Vec of Strings
-
hierarchical_pathfinding
Quickly approximate Paths on a Grid
-
kendalls
Kendall’s tau rank correlation
-
edt
An implementation of 2D EDT (Euclidian distance transform) with Saito’s algorithm in pure Rust
-
sorting_rs
Collection of sorting algorithms implemented in Rust
-
topo_sort
A ‘cycle-safe’ topological sort for a set of nodes with dependencies
-
triple_accel
Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.
-
simple-simplex
Generates 2d simplex noise values and applies Fractal Brownian Motion
-
iter-set
Set operations on sorted, deduplicated iterators
-
bindet
Fast file type detection
-
graphplan
Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
rs-wordle-solver
A library for solving Wordle-style puzzles. It provides multiple guessing algorithms, as well as building blocks for implementing your own Wordle solving algorithms.
-
tokenizations
Tokenizations alignments library
-
compound_factor_iter
Iterator types for output permutations from a function combining multiple discrete factors
-
simsearch
A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)
-
faiss-sys
Native bindings for Faiss
-
knossos
Rust library for generating and rendering mazes
-
weighted-rs
A libray for weighted balancing algorithm
-
actionable
An enum-based async framework for building permission-driven APIs
-
simplers_optimization
A Rust implementation of the Simple(x) black-box optimization algorithm
-
lfest
A leveraged perpetual futures exchange for simulated trading is a high performance backtesting exchange
-
blake
Implementation of the BLAKE hash function for Rust via FFI
-
poi
A pragmatic point-free theorem prover assistant
-
median
An implementation of an efficient O(n) median filter
-
pubgrub
PubGrub version solving algorithm
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
peak_finder
An algorithm for identifying peaks from line data, such as from accelerometer or spectral data
-
genx
An easy to use and modular genetic algorithms library
-
edge-detection
The canny edge detection algorithm
-
nsga
Multi-objective genetic optimization algorithm NSGA-II
-
sm
💋 SM – a static State Machine library
-
rexl
Common Library for Rust
-
osqp
The OSQP (Operator Splitting Quadratic Program) solver
-
svdlibrs
A Rust port of LAS2 from SVDLIBC
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
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
-
simplerand
Simple and fast random number generator
-
crunch
A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind
-
rand_pcg
Selected PCG random number generators
-
slice-by-8
Rust improved implementation of the Intel Slice-By-8 algorithm
-
etsm
Efficient Tiny State Machine using object callbacks
-
sort-it
Provides various sorting algorithms
-
ndarray-rand
Constructors for randomized arrays.
randintegration forndarray. -
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
petal-neighbors
Nearest neighbor search algorithms including a ball tree and a vantage point tree
-
weighted_rand
A weighted random sampling crate using Walker’s Alias Method
-
quasirandom
Quasirandom number generation
-
fnv
Fowler–Noll–Vo hash function
-
dsalgo
A package for Datastructures and Algorithms
-
newton_rootfinder
Newton based methods for root finding
-
extfsm
Extended Finite State Machine with internal event queue and entry/exit transitions
-
lv03
Conversion between the Swiss coordinate system (LV03/CH1903 or LV95/CH1903+) and WGS84 coordinates
-
contest-algorithms
Common algorithms and data structures for programming contests
-
pikkr
JSON Parser which picks up values directly without performing tokenization in Rust
-
afsort
American Flag sort implementation for faster sorting of Strings
-
special
The package provides special functions
-
permute
Generate permutations of vectors and slices in a memory-efficient and deterministic manner, using Heap’s algorithm
-
merkle_hash
Finds the blake3 hash of files or entire directories using a multithreaded merkle tree algorithm
-
color_space
library for converting between color spaces and comparing colors
-
luhn3
A Luhn validation library
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
hyperid
Superfast id generator
-
smbus-pec
Minimal portable implementation of SMBus Packet Error Code calculation algorithm
-
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters’s Pattern Defeating Quickselect
-
elipdotter
Embeddable full text search engine
-
fastvlq
A fast variant of Variable-Length Quantity with a focus on speed and no_std support
-
bytestream
Provides a convenient way of writing binary data to a buffer
-
pqc_kyber
A rust implementation of the post-quantum Kyber KEM algorithm
-
punkt
An implementation of a Punkt sentence tokenizer
-
sample-consensus
Abstractions for sample consensus algorithms such as RANSAC
-
bresenham_zip
Iterator to perform Bresenham over two lines of the same triangle simultaneusly for triangle rasterization
-
fi-night
Statically typed Finite State Machine and Pushdown Automaton implementation
-
rs_algo
Common sorting algorithms and other common computer science algorithms
-
dasp_interpolate
An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc
-
astro
Advanced algorithms for astronomy
-
poisson-diskus
Poisson disk distribution sampling
-
qsv-stats
Experimental crate for computing basic statistics on streams
-
floydrivest
A lightweight crate that brings the Floyd-Rivest implementation of nth_element
-
cdchunking
Content-defined chunking
-
bitreader
BitReader helps reading individual bits from a slice of bytes. You can read “unusual” numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer.
-
geometry-predicates
A Rust port of robust geometric predicates
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
rake
Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm
-
rand_krull
Krull64/65 random number generators
-
algorithmica
Rust Algorithms
-
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
-
linfa-datasets
Collection of small datasets for Linfa
-
sobol
A Sobol sequence generator for Rust
-
markov_rs
A simple and fast Markov chain generator in Rust
-
ru_annoy
A rust implementation of annoy(https://github.com/spotify/annoy) (Index serving only). Providing C api as well
-
fast-math
Fast, approximate versions of mathematical functions
-
hora
Hora Search Everywhere
-
chalk-ir
Chalk’s internal representation of types, goals, and clauses
-
ms_toollib
Algorithms for Minesweeper
-
annembed
a Rust implementation of a dimension reduction à la Umap
-
four-bar
Four🍀bar library provides simulation and synthesis function for four-bar linkage mechanism
-
cyclic-poly-23
A rolling, decomposable hash algorithm
-
array-bin-ops
Efficient array binary operations
-
glicko_2
Glicko2 is an iterative algorithm for ranking opponents or teams in 1v1 games
-
cauchy
Trait for real and complex numbers
-
programinduction
A library for program induction and learning representations
-
iso_iec_7064
Support for check digit operations conforming to ISO/IEC 7064
-
eudex
A blazingly fast phonetic reduction/hashing algorithm
-
rust-3d
2D/3D library written in rust
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
secwords
secure and safe password container
-
forceatlas2
fast force-directed generic n-dimension graph layout
-
relp-num
Number types for the relp crate
-
dlt
DLT (direct linear transform) algorithm for camera calibration
-
lol-core
A Raft implementation in Rust language
-
rendezvous_hash
An implementation of Rendezvous hashing algorithm
-
numext-fixed-uint-hack
A internal crate used by numext-fixed-uint
-
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
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
memx-cdy
The fast memory functions like a libc memcmp(), memchr(), memmem(), memcpy(), memset()
-
here_be_dragons
Map generator for games
-
vrp-scientific
An extension logic for solving scientific VRP
-
reed-solomon-16
Reed-Solomon GF(2^16) erasure coding with O(n log n) complexity
-
elm-solve-deps
A dependency solver for the elm ecosystem
-
reservoir-sampling
Implementations of a variety of algorithms for reservoir sampling in Rust
-
redux-rs
A Rust implementation of Redux
-
eddie
Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler
-
spectre
A lightweight toolkit for analysing p2p network topologies
-
sub-strs
For finding sub strings
-
tocket
A implemetation of ‘Token Bucket’ algorithm
-
accurate
(more or less) accurate floating point algorithms
-
rurel
Flexible, reusable reinforcement learning (Q learning) implementation
-
lev_distance
A copy of Levenshtein distance implementation from Rust Compiler
-
turborand
A simple and fast random number generator
-
palette_extract
A Rust port of Leptonica’s modified media cut quantization algorithm
-
nuid
A highly performant unique identifier generator
-
pyin
pYIN pitch detection algorithm written in Rust
-
qframework
A experimental micor framework for clear design, based on queue model
-
zipf
A fast generator of discrete, bounded Zipf-distributed random numbers
-
competitive-programming-rs
Competitive Programming Library in Rust
-
human-sort
Human sort (natural sort) implementation
-
extsort
External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator
-
permutate
Generic permutator that permutates singular and multiple lists
-
intersect2d
Line segment intersection detection
-
graph_builder
A building block for high-performant graph algorithms
-
pagino
Handle pagination’s logic
-
clf
flush the cpu cache line by __builtin_clear_cache()
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
diffr-lib
An implementation of Myers diff algorithm
-
maze_generator
A library of different maze generation algorithms
-
symspell
Spelling correction & Fuzzy search
-
wasmium-random
Generate random numeric, alphabet, alphanumeric, BIP39 and EFF random bytes
-
zw-fast-quantile
Zhang-Wang fast quantile algorithm in Rust
-
linked_hash_set
HashSet with insertion ordering
-
lutz
Rust implementation of “An Algorithm for the Real Time Analysis of Digitised Images” by R. K. Lutz
-
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.
-
gcra
A basic implementation of GCRA algorithm for rate limiting
-
insides
A compact, high performance space filling curve library for Rust
-
dusk-hades
Implementation of Hades252 permutation algorithm over the Bls12-381 Scalar field
-
sfmt
Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)
-
comtesse
graph utilities
-
acap
As Close As Possible — nearest neighbor search in Rust
-
reed-solomon-novelpoly
An implementation of a reed solomon code / encoder / decoder with complexity
O(n lg(n)) -
varint-rs
A small, zero dependency varint implementation in Rust
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
id_graph_sccs
Find the strongly-connected components of a graph with nodes labeled by integer ids
-
consistent_hash_ring
A flexible and efficient consistent hash ring
-
fast-erasure-shake-rng
Fast erasure (forward secure) sponge/duplex based PRNG using the Keccak permutation
-
alea
A crate for randomness
-
smawk
Functions for finding row-minima in a totally monotone matrix
-
fuzzy_rocks
A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm
-
libhumancode
A
no_stdcompatible library that provides a function to enode binary data up to 150 bits in a human friendly format -
sudoku-solver
Simple backtracking algorithm for solving sudoku
-
verhoeff
The Verhoeff algorithm, for number checksums
-
chksum-hash
Cryptography primitives for chksum library
-
iterslide
A “sliding window” iterator
-
bit_combi_iter
An iterator to iterate all bit combinations less than given unsigned integer
-
search-sort
Implementation of few searching and sorting algorithms
-
mx3
Implementation of the mx3 algorithm providing a bit mixer, pseudo-random number generator, and hash function
-
crawdad
Crawdad: ChaRActer-Wise Double-Array Dictionary
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
aleph-bft-rmc
Reliable MultiCast - a primitive for Reliable Broadcast protocol
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
library_of_babel
Implementation of Library of Babel in Rust
-
gcp-vertex-ai-vizier
An async client library for GCP Vertex AI Vizier
-
bcmp
bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set
-
mockd
Fake data generator library with 130+ functions
-
atomic-traits
The traits for generic atomic operations
-
circbuf
A growable circular buffer for working with bytes
-
hybrid-clocks
Hybrid Logical Clocks
-
gaps
Functionality for working with gaps/holes in ordered sequences of values
-
rootfind
Root-finding algorithms
-
superslice
Extensions for slices
-
squirrel3-rs
Simple and reliable random number generator
-
muldiv
Provides a trait for numeric types to perform combined multiplication and division with overflow protection
-
basic_dsp_matrix
Digital signal processing based on real or complex vectors in time or frequency domain
-
sortedvec
a sorted vector that enables quick lookups
-
travelling_salesman
Travelling Salesman Problem Solvers
-
bloom_filter_plush
rust_bloom_filter
-
weighted-rs-wasm
A libray for weighted balancing algorithm
-
chull
Convex hull approximation
-
wpa-psk
Compute the WPA-PSK of a Wi-FI SSID and passphrase
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
spain-vat-id
Spanish VAT ID numbers validation/verification
-
sark_pathfinding
A simple implementation of the astar pathfinding algorthim from red blob games https://www.redblobgames.com/pathfinding/a-star/implementation.html
-
vec-drain-where
alternative
Vec::drain_filterimpl -
quadtree-f32
Simple, dependency-free ID-based quadtree
-
fp-growth
An implementation of the FP-Growth algorithm in pure Rust
-
wfc-rs
Binding to the krychu/wfc C library
-
w_inter
❄️ Weighted INTERval scheduling problem
-
glicko2
Implementation of the glicko2 rating system
-
schindel
rust min-shingle hashing
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
external_sort
Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams
-
fleetfs_raft
The rust language implementation of Raft algorithm
-
md6
Implementation of the MD6 hash function for Rust via FFI
-
vecshard
Split Vecs in constant time
-
line-col
Convert string slice indices into line/column numbers
-
count-min-sketch
Count-min-sketch implementation
-
merging-iterator
An iterator to return the elements of two independently ordered iterators in order
-
cumath
Cuda-based matrix/vector computations
-
suffix_array
Suffix array construction and searching algorithms for in-memory binary data
-
pikkr-annika
JSON Parser which picks up values directly without performing tokenization in Rust. Reuploaded by Annika due to her compile problems.
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
byond-crc32
Fast CRC-32/BYOND checksum computation
-
scicrypt-numbertheory
A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation
-
rev_lines
Rust Iterator for reading files line by line with a buffer in reverse
-
transpose
Utility for transposing multi-dimensional data
-
wyhash
Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator
-
normalize_country
Convert country names and codes to a standard
-
clipper-sys
Boolean operations on polygons (Clipper wrapper)
-
ds-heightmap
Using diamond-square algorithm to generate heightmaps which stored in a 2D-array
-
spaced-rs
A small library implementing a sm2 inspired SR algorithm
-
dmp
A high-performance library in that manipulates plain text
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
rtriangulate
Delaunay triangulation on a set of points
-
shr3
SHR3 - 3-shift register random number generator
-
lfu
An LFU cache implementation
-
mersenne_twister
Mersenne Twister pseudorandom number generator
-
distance
A collection of approximate string matching algorithms
-
toposort-scc
An implementation of Kahn’s algorithm for topological sorting and Kosaraju’s algorithm for strongly connected components
-
bin_packer_3d
Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
-
sbitty
library defining bitwise operations on standard integers type
-
numext-fixed-hash
Fixed-size hash types
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
tempergb
Convert a color temperature to RGB values
-
prexel
A math expression evaluator
-
meowhash
Meow hash function
-
easey
Easing functions for interpolation between 0.0 and 1.0
-
probables
This crate is the replicate of BTree. It contains some functions that are nesscary for BTree. Currently this version support wrapper method called traits, implemention, structs and module testing…
-
dia-ip-range
Ranges for IP v4
-
rand_hc
HC128 random number generator
-
ext-sort
rust external sort algorithm implementation
-
trajectory
Trajectory interpolation
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
longest-increasing-subsequence
Find a longest increasing subsequence of some input sequence
-
wmath
Math library aggregating several math modules
-
convolve2d
Easy and extensible pure rust image convolutions
-
elements-frequency
Finds the frequency of elements in a list
-
narcissistic
Narcissistic number searcher
-
postcard-cobs
This is an implementation of the Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the “sentinel” value)…
-
ssb-multiformats
Key, feed id, and message hash types used by Secure Scuttlebutt
-
liba
An algorithm library based on C language
-
hashed-permutation
A fast, instant-access way to permute a range of numbers
-
clock-zones
A library for handling clock zones
-
detect-lang
Language detection given paths and extensions
-
fletcher
A dependency free implementation of the Fletcher’s checksum algorithm
-
seqdiff
Diff between two sequences
-
rsgenetic
A library providing genetic algorithm execution
-
moving-least-squares-image
Image deformation using moving least squares
-
searchy
Search index (in-memory), that can be constructed and searched using a bag of words model, with cosine similarity scoring based on tf-idf. Supports multiple search terms, permissions…
-
vsprintf
Rust bindings to the libc vsprintf function
-
cmaes
An implementation of the CMA-ES optimization algorithm
-
thirtyseconds
Short Rust 🦀 code snippets for inspiration
-
fullcodec-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
sparse_linear_assignment
Solvers for sparse linear assignment problem based on the auction algorithm
-
spaced-repetition
A spaced repetition algorithm based on anki and supermemo
-
halton
A module for generating Halton sequences
-
dogs
Discrete Optimization Global Search framework. Implements various search algorithms that can be found in combinatorial optimization or heuristic search.
-
gemm
Playground for matrix multiplication algorithms
-
hamming
Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.
-
gosh-lbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS
-
wkb
Convert geo-types from georust to/from Well Known Binary
-
js-resolve
A node.js module resolver
-
rodar
a command line tool that brings together all the functions Roy would use for analysis and decision-making
-
pasture-algorithms
Point cloud algorithms for pasture
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
modulo
Simple modulo operation
-
signrel
Trait expressing relationship between integers of different signedness
-
funutd
Procedural texture library
-
squares-rnd
Simple and fast counter based non-crypto random generator
-
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
rustgraphblas
Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector
-
closest-sum-pair
Finds a pair in a list that has the closest sum to a given number
-
hash-roll
Rolling hashes & Content Defined Chunking (cdc)
-
algos
A collection of algorithms in Rust
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
coupe
Coupe is a mesh partitioning library. It implements composable geometric and topologic 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
-
xbar
An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm
-
alass-core
Automatic Language-Agnostic Subtitle Synchronization (Library)
-
window-sort-iterator
An iterator adapter that sorts items within a sliding window
-
ritehash
A tiny, fast, zero-dep and no_std fxhash fork. More up to date.
-
sorted-insert
This crate provides traits to insert elements to a sorted collection and keep the order
-
buf-min
Minimal utf-8 safe buffer traits
-
rustlex_fsa
Library for manipulating (deterministic) finite automata
-
rlp-iter
An iterator following a space-filling pattern over a given range
-
partition
partition slices in-place by a predicate
-
mt19937
A translation of the MT19937 Mersenne Twister rng algorithm to Rust
-
lz_fnv
Fowler-Noll-Vo hash functions for various integer types
-
bidivec
A crate offering bidimensional arrays, vectors and slices, with batteries included (such as pathfinding, flood-filling and more)
-
asura
ASURA implementation in Rust
-
moore-hodgson
An implementation of the Moore Hodgson’s Scheduling Algorithm in Rust
-
murmur3
A rust implementation of Murmur3 hash
-
drain-rs
Automatically cluster semi-formatted text with the drain algorithm
-
pi_adler32
adler32 crc check algorithm
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
roaring-bloom-filter
bloom filter implementation in rust with roaring-bitmap
-
hungarian
A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
staticstep
Provides truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
pi_hash
Provide unified hasher, HashMap and HashSet, The hash algorithm used can be determined by compiling conditions
-
microstate
Finite state machine, inspired by micromachine
-
macro_machine
State machine generator using macros
-
rusty_planner
Artificial intelligence planning & reasoning library for Rust
-
fst_stringstring
String-to-String Map built from fst
-
crczoo
CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms
-
raft
The rust language implementation of Raft algorithm
-
simple_accumulator
A simple accumulator
-
delaunay2d
A library to compute Delaunay triangulations and Voronoi diagrams in 2D space
-
fang_oost
A library implementing Fang and Oosterlee’s algorithm for inverting characteristic functions
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
mikktspace
Mikkelsen tangent space algorithm
-
rectcut-rs
Rust implementation of the rectcut concept from https://halt.software/dead-simple-layouts/
-
sparse-interp
Basic univariate polynomial arithmetic and sparse polynomial interpolation
-
compute-float
Computes floating point numbers using Eisel-Lemire algolithm
-
watchmaker
A genetic algorithm implementation in Rust
-
fakeit
Fake data generator library with 130+ functions
-
lis
Longest increasing subsequence algorithm
-
xxhrs
Safe XXHash and XXH3 bindings
-
english-numbers
Convert integers to written English number format
-
varid
convert ident string to hash value, and check conflict
-
endicon
Implementations of codicon traits for endianness encodings
-
porco
Composable probability distributions
-
partition-point-veb-layout
partition_point van Emde Boas layout
-
divisors
A blazing fast library to find all divisors of a natural number
-
optimum
Future Framework to solve optimization problems
-
lazysort
Lazy sorting for iterators
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.
-
jumpch
Jump Consistent Hashing is a fast, minimal memory, consistent hash algorithm
-
gfxmath-vec3
A simple 3D math library
-
n18io
Manages the (de)serialisation of 18xx tiles and maps
-
dedup_signature
This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents
-
favannat
Algorithms to evaluate the function encoded in ANN-like structures
-
xorshift128plus-rs
A simple implementation of the XorShift128+ pseudorandom number generator in Rust
-
labelgraph
A simple to use graph implementation, allowing random access to nodes via labels
-
modular-frost
Modular implementation of FROST over ff/group
-
order-stat
Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm
-
toolbox
Simple tools for daily use
-
iobuf
A contiguous region of bytes, useful for I/O operations
-
traversal
Generic and lazy tree traversal algorithms
-
conshash
A library to do consistent hashing in Rust
-
bishop
Library for visualizing keys and hashes using OpenSSH’s Drunken Bishop algorithm
-
fera
An aggregation of algorithms, data structures and supporting crates
-
lfa
Native rust implementations of linear function approximators
-
geomorph
Simple conversion between different coordinate systems
-
beehave
A simple library for defining and evaluating a hierarchical state machine (behaviour tree)
-
highwayhash
Bindings to AVX-2-optimized SIP-like hash functions
-
java_random
The java LCG and random module implementation in rust
-
librsb-sys
FFI interface for librsb
-
skelly
Skeleton animation and IK
-
yield-iter
Safe implementation of the
Iteratortrait forGenerator -
zhang_hilbert
Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al
-
block-mesh
Fast algorithms for generating voxel block meshes from arrays
-
blurhash
A pure Rust implementation of blurhash
-
kahan
Provides types to perform Kahan summation
-
just-argon2
Bindings to the argon2 C library
-
geo-raycasting
Ray Casting algorithm for the geo crate
-
morton-encoding
A crate for encoding and decoding Morton (“Z-order”) keys
-
gut
Geometry utilities: storing, manipulating and processing geometries
-
hash_avatar
rust生成随机头像的库
-
srand
Random number generators and other randomness functionality with simple apis to use
-
mincost
A collection of modern heuristic optimization toolkit
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse’s LDL algorithm
-
cueball-static-resolver
This is an implementation of the cueball Resolver trait that provides a static list of backends for use by the connection pool
-
m4ri-sys
Bindings to m4ri
-
zvxryb-broadphase
A broadphase collision detection library
-
iter_columns
Iterate over columns easily
-
froggy-rand
Random number generation without state for games
-
omg_serde
Adds serde support to omg_core
-
lambert
lamber-rust is a crate helping to convert Lambert coordinates to WGS84
-
goertzel-nostd
An nostd implementation of Goertzel’s Algoritm
-
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
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
fast_inv_sqrt
Fast inverse square root algorithm implementation
-
layered-bitset
Bit set implementation using layered structure
-
soft-edge
efficient bithackery for making 3D collision meshes out of grids and stacked tile maps
-
laizy
A simple, stable and thread-safe implementation of a lazy value
-
big_num
A big number implement in rust
-
fuzzy_dbscan
An implementation of the FuzzyDBSCAN algorithm
-
arc-interner
An interner that deallocates unused values
-
multiexp
Multiexponentation algorithms for ff/group
-
rounded-div
Get rounded result of an integer division
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
honestintervals
Comprehensive, correctly rounding interval arithmetic library
-
mini-kanren
miniKANREN in Rust
-
rtt
Rapidly-Exploring random trees path planning algorithm
-
g2poly
Primitive implementation of polynomials over the field GF(2)
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
unik
A Powerful Universally Unique Identifier (UUID)
-
permutation_iterator
A Rust library for iterating over random permutations using O(1) (i.e. constant) space.
-
parallel-factorial
Simple, fast, parallel factorial calculator
-
mushin_derive
Compile-time creation of neural networks
-
monotonic_solver
A monotonic solver designed to be easy to use with Rust enum expressions
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
extprim
Extra primitive types (u128, i128)
-
fuss
Small, lightweight simplex noise generator for Rust
-
mecs
An ecs library with a focus on iteration performance
-
clusterphobia
Algorithms and data structures for unassisted clustering that employ the Hilbert Curve
-
rta-for-fps-lib
An Implementation of the paper ‘Response Time Analysis for Fixed Priority Servers’ by Hamann et al
-
pathfinding_astar
An implementation of the A-Star pathfinding algorithm that can process absract and grid-like paths
-
algs4
Algorithms, 4ed. MOOC in Coursera. in Rust.
-
crfs
Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)
-
wu-diff
Compute differences between two slices using wu(the O(NP)) algorithm
-
marching-squares
Parallelized marching squares algorithm for constructing closed isolines / contour lines
-
lttb
An implementation of the Largest Triangle Three Buckets algorithm
-
rs_state_machine
A business-oriented state machine library
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
dft
The package provides an algorithm to compute the discrete Fourier transform
-
kahuna
A basic implementation of wave-function collapse for procedural generation
-
collectables
Collectables: Rust crate of collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
ingrid
Dynamic two-dimensional arrays with algorithms
-
zwohash
A fast, deterministic, non-cryptographic hash for use in hash tables
-
memo-map
A crate implementing a synchronized map for memoization
-
libdivsufsort-rs
A rust wrapper of libdivsufsort
-
morton
Morton space filling curve functions
-
rdx
A collection of traits and algorithms to ease using radix sorts
-
needle
Fast search functions for finding things in Strings, Arrays and iterators
-
hnsw
Fast approximate nearest neighbors
-
dedup_iter
Deduplicating iterator adapters
-
gabble
Library crate for generating random pseudo-words
-
supermemo2
A simple crate that implements the supermemo2 spaced repetition algorithm
-
xoroshiro128
Fast psuedo-random number generators
-
raft-proto
Protocol definitions for the rust language implementation of the Raft algorithm
-
batsat
Extensible SAT solver in Rust
-
rand_xoshiro
Xoshiro, xoroshiro and splitmix64 random number generators
-
dryip
Short 🩸 Rust 🦀 code snippets for inspiration
-
fast_hilbert
Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)
-
distributed-cards
Implements the mental poker shuffling algorithm
-
delay_map
HashMap collections whose entries expire after a given time
-
basic-hll
The basic HyperLogLog algorithm
-
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.
-
phpass
PHPass, the WordPress password hasher, re-implemented in rust
-
spatium
Spatium. Calc distance between sequences.
-
vrp-core
A core algorithms to solve a Vehicle Routing Problem
-
xxhash-c-sys
Bindings to xxhash
-
noisy
A procedural noise generation library written for Rust
-
leef2hashmap
A Simple LEEF Parser to a HashMap
-
filter
Kalman filters and other optimal and non-optimal estimation filters in Rust
-
darwin-rs
Evolutionary algorithms library written in Rust
-
probably
A library with various approximate computing algorithms
-
num-cmp
Comparison between differently typed numbers
-
sparse_graph
Sparse graph algorithms
-
rand04_compat
Wrappers for compatibility with rand 0.4
-
IntegerScaling
Calculates integer ratios and scaled-image sizes for pixel-perfect image upscaling with optional aspect-ratio correction
-
enso-prelude
An augmented standard library in the vein of Haskell’s prelude
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
svd-expander
Expands arrays and resolves inheritance chains in CMSIS-SVD specifications
-
async-hsm
The lightweight asynchronous hierarchical state machine (HSM)
-
fast_poisson
An implementation of Bridson’s algorithm for fast Poisson disk sampling
-
backtrack
Solve hard constraints easily
-
xorshift
Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators
-
buldak
It is a library that provides various sorting functions
-
rast
A toy implementation of the raft consistency protocol focused on speed
-
seadawg
SeaDawg is a library that implements the online algorithm for Direct Acyclic Word Graph (DAWG) and Compact Direct Acyclic Word Graph (CDAWG)
-
biterate
A Rust API for Gurobi optimizer
-
cdivsufsort
Rust bindings for Yuta Mori’s divsufsort
-
non-dominated-sort
Fast Non-Dominated Sort Algorithm
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
uniset
A hierarchical, growable bit set with support for in-place atomic operations
-
tars
A Rust library providing useful technical indicators
-
is_42
Simple, blazingly fast way of checking if a variable is equal to 42
-
rure
A C API for Rust’s regular expression library
-
hamming_rs
Computes Hamming distance and weight – if available, uses a highly optimized avx2 implementation
-
relp
Rust Exact Linear Programming
-
adqselect
A lightweight crate that brings an implementation of nth_element by using the adaptive quickselect algorithm by Andrei Alexandrescu
-
floyd-warshall-alg
Floyd-Warshall algorithm supporting customization
-
visionmagic
Collection of vision & graphics algorithms
-
smoothed_z_score
Smoothed z-score algo (very robust thresholding algorithm)
-
pso
Particle Swarm Optimizer
-
chksum
A simple to use library which allows to make checksum of single file or whole directory
-
aliasmethod
Implementation of Walker’s Alias method
-
randomkit
numpy.randomfor Rust -
rustneat
Implementation of NeuroEvolution of Augmenting Topologies NEAT http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf with a Continuous-Time Recurrent Neural Networks
-
split_by
Split anything implementing Read trait by multiple sequences of bytes
-
kmpsearch
String/Byte pattern searching within byte slices or strings, using the Knuth Morris Pratt algorithm
-
gpu-sw
GPU-SW, GPGPU-enabled SW algorithm
-
den
A general delta encoded network difference algorithm
-
random-branch
Provides a macro to select a random branch like match
-
astro-format
Astro Format is a library for efficiently transcoding arrays into a single buffer and native rust types into hexadecimal strings
-
uncertain
Fast and correct computations with uncertain values
-
nqueens-oxigen
N Queens problem resolution using oxigen
-
mcmf
This crate is for solving instances of the minimum cost maximum flow problem. It uses the network simplex algorithm from the LEMON graph optimization library.
-
rust-algorithm
algorithm
-
eytzinger-map
array/vec based map using eytzinger search algorithm
-
symbolic_polynomials
A library for manipulation of polynomials over the integers
-
blurhash-ng
A pure Rust implementation of blurhash
-
pretree
Pretree is a package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
rolling-dual-crc
Rolling CRC with 32-bit CRC32C and 64-bit CRC64/XZ
-
stalin-binary-search
alike binary search but any checking element which is not target one is eliminated
-
plumtree
A Rust implementation of Plumtree algorithm
-
competitive-hpp
Competitive Programming Library for AtCoder with Rust
-
location_based_sharding
Right sized sharding algorithm
-
total-space
Explore the total space of states of communicating finite state machines
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
str-distance
Distance metrics to evaluate distances between strings
-
winapi-hash
Windows API hashing implementation
-
rustimization
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
-
feruca
An implementation of the Unicode Collation Algorithm
-
textnonce
Text based random nonce generator
-
persist-es
A backing logic for an RDBMS implementation of an event store for cqrs-es
-
perm
Permutation iterator
-
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…
-
cityhash-sys
Rust binding of Google CityHash algorithm
-
fastcmp
A fast byte slice comparison library
-
hyperbitbit
Implementation of HyperBitBit data structure
-
mur3
The rust language implementation of MurmurHash3
-
opensimplex_noise_rs
OpenSimplex noise algorithm implementation in Rust
-
pcg_rand
An implementation of the PCG family of random number generators in pure Rust
-
tokio_interval_buffer
Easy enum wrapper that implements all traits that the wrapped objects implement
-
aviary
Aviary bird combinators for Rust
-
gbps
Rust implementation of gossip-based peer sampling
-
reciprocal
Baseline implementation of integer division by constants
-
every-range
Iterator for interleaving included and excluded ranges
-
soundchange-english
Reimplementation of Mark Rosenfelder’s pronunciation algorithm for English
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
rosalind
Crate contains solutions of problems published on Rosalind.info
-
kmp
Various functions using the Knuth–Morris–Pratt algorithm to efficiently find patterns
-
time_series_generator
Generate various timeseries of given length, some randomly sampled
-
leemaze
A generalized Lee Algorithm - Fastest Flood Fill Path type - solver for 2d, 3d, 4d or even 5d binary block mazes (5d Vec<Vec<Vec<Vec<Vec>>>>). # Convert your data into a vector maze of wall trues and open falses…
-
stal
Set algebra solver for Redis
-
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.
-
ntru
Implementation of the NTRUEncrypt algorithm. Interface to libntru.
-
deranged
Ranged integers
-
time_wheel
An implementation of timer uses time-wheel algorithm
-
extra_waiters
Wait for notifications without a Mutex
-
search_trees
Utilities for binary search tree, red-black tree, and AVL tree
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
phreak_rules
Rule matching algorithm focussed on speed
-
hutton-rust
The Hutton cipher implemented as a Rust crate
-
optimization
Collection of optimization algorithms
-
hotsax
An implementation of the HOTSAX and HOTSAX based discord discovery algorithms
-
sorting
The world’s best, finest and inefficient sorting algorithms
-
polystem
Popular stemming algorithms for Information Retrieval
-
co_sort
Sort arrays given a permutation
-
barnes
A multithreaded Barnes Hut Algorithm implementation
-
rand04
Re-export of rand 0.4, so it can be used together with a later version of rand
-
force_graph
Force-directed graph algorithm
-
haikunator
Generate Heroku-like random names to use in your Rust applications
-
gray-codes
Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection
-
cityhash-rs
Rust no_std implementation of Google Cityhash v1.0.2, v1.0.3, and v1.1.0
-
indented-blocks
parser for indented blocks
-
rabin_ida
Rabin’s information dispersal algorithm, originally by Liam Perlaki
-
rijksdriehoek
Convert coordinates between rijksdriehoek and wgs84
-
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…
-
randish_rs
Generate predictably random like numbers using LCG
-
tlsh
Rust port of Trend Micro Locality Sensitive Hashing
-
selfsimilar
A fast generator of discrete self similar random numbers
-
zip-fill
Iterator library
-
symmetric-shadowcasting
Simple implementation of the shadow casting FOV algorithm
-
search-autocompletion
A Rust implementation of Search Auto Completion
-
t1ha
An implementation of the T1AH (Fast Positive Hash) hash function
-
actionable-macros
Macros for
actionable -
html2pango
Library to convert html to pango
-
raftlog
An implementation of distributed replicated log based on the Raft algorithm
-
stringslice
A collection of methods to slice strings based on character indices rather than bytes
-
midpoint_circle
Rust implementation of the midpoint circle algorithm
-
gitignored
A Rust implementation of the gitignore algorithm
-
refset
A non-owning HashSet
-
kmeans
Small and fast library for k-means clustering calculations
-
checked_int_cast
Conversions between primitive integers with overflow and underflow checking
-
hash_by_ref
A simple NewType that wraps Rc and allows to use the reference identity/pointer value of Rc as keys in hashmap
-
extrema
C++’s minmax_element implementation in rust
-
ncollide3d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
numlib
A simple numerical library implementing common numberical algorithms in rust
-
multistochgrad
Stochastic Gradient, Multithreaded
-
brace-expand
Rust crate which performs brace expansion of strings, as in shells like Bash etc
-
fractal
The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes
-
jandom
Port of Java’s Random
-
guid-partition-types
A small crate designed to work with parition types and their GUIDs
-
interpolate_idents_gnzlbg_fork
Useable macro identifier concatenation plugin
-
xrunits
A strong type unit library
-
kddbscan
A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)
-
tiamat
a PRNG library
-
patmatch
A configurable pattern matching / wildcard matching library
-
gearhash
Fast, SIMD-accelerated hash function for content-defined chunking
-
rosomaxa
A rosomaxa algorithm and other building blocks for creating a solver for optimization problems
-
parser-pda
Example of a simple parser pushdown automaton implementation
-
numext-fixed-uint-core
A internal crate used by numext-fixed-uint
-
plonkup
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
transducers
A transducer library for Rust
-
simplex
A Linear Programming solver
-
rand_seeder
A universal random number seeder based on SipHash
-
qrs_detector
Realtime ECG QRS detector algorithm
-
algo
Algorithms & Data Structure implementations
-
aleph-alpha-tokenizer
A fast implementation of a wordpiece-inspired tokenizer
-
cogset
Generic implementations of clustering algorithms. Includes k-means, DBSCAN and OPTICS.
-
gurobi
An unofficial Rust API for Gurobi optimizer
-
libpermute
A
no_stdcompatible library that provides a function to permute the items of a slice -
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
fxsm
A state machine procedural macro for enums
-
addchain
Generate addition chains
-
fullcodec_rand_xorshift
Xorshift random number generator
-
librualg
Collection of basic algorithms for everyday development
-
safe-shuffle
Perform unbiased shuffles using a CSPRNG and Fisher-Yates
-
rust-graph
A graph library for Rust
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
machinebox
A client SDK for communicating with machinebox boxes
-
koper
The koper project
-
measurement-units
Rust library for basic measurements units conversion such as length, mass, time, volume, percents
-
wuf
A fast weighted implementation to the union-find problem with path compression
-
realfft
Real-to-complex FFT and complex-to-real iFFT for Rust
-
sorts
A collection of sorting algorithms
-
ordslice
Extensions for ordered slices
-
streemap
Set of tree map algorithms (binary, squarified, …)
-
gfxmath-vec2
A simple 2D math library
-
random-trait
Rust library for a random trait meant to produce random generic types
-
stack
DSTs and arrays on the stack!
-
gbm-sys
Bindgen generated unsafe libgbm wrapper
-
nuts-rs
Sample from unnormalized densities using Hamiltonian MCMC
-
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki’s C library libLBFGS
-
pack
Solver for packing puzzle
-
lapjv
Linear Assignmment Problem solve using Jonker-Volgenant algorithm
-
lmaths
A short 2D Maths library
-
bfes
Brute force embedding (vector) search library
-
anchorhash
A consistent hashing algorithm that outperforms state-of-the-art algorithms
-
spiral
Iterate over a 2D structure in a spiral pattern
-
fossil-delta
Provides functions for calculating differences between strings and applying calculated deltas
-
bresenham
A fast, iterator-based integer-only implementation of Bresenham’s line algorithm
-
revonet
Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
-
cinnabar
Rust library of graph algorithms and data strctures
-
largest-remainder-method
The largest remainder method
-
munkres
Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)
-
sdbm
SDBM is a non-cryptographic hashing algorithm
-
tailcall-impl
The procedural macro implementation for the tailcall crate
-
fxtypemap
A fast type map based on internal hasher used in Firefox and Rustc
-
mmseg
Chinese word segmenation algorithm MMSEG in Rust
-
stacked-sandwich
Find all occurances of a number in a row/column sorted matrix; in square root of linear time!
-
zeros
Keccak implementation
-
zerobuf
A growable chunk of zeroed memory
-
bufferpool
A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions
-
alg_ds
Algorithms & data structures
-
statistical
A simple statistics library
-
fuzzy-filter
A fast implementation (O(n)) of fuzzy-filtering
-
swoop
Simple, lightweight optimisation algorithms in pure Rust
-
fast-surface-nets
A fast, chunk-friendly implementation of Naive Surface Nets on regular grids
-
weighted-rs-1
A libray for weighted balancing algorithm
-
sfcgal
High-level bindings to SFCGAL and conversion from/to other geometry libraries
-
astar
A generic implementation of the A* pathfinding algorithm
-
weighted_levenshtein
Generic implementation of Levenshtein distance allowing arbitrary weighting of operations
-
polylabel-mini
[Fork of polylabel-rs] A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions
-
rust-spice-derive
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust
-
pdqsort
Pattern-defeating quicksort
-
boostvoronoi_core
Boost voronoi private workspace
-
probs
Statistics toolkit
-
tiny_tco
A tiny dirt simple no_std tail call optimization library
-
concorde
reconfigurable lattice agreement
-
dia-range
Ranges for all integers
-
sungod
0-Dependency random numbers to brighten your day
-
raft-consensus
Raft consensus algorithm implementation
-
blossom
Implementation of the Blossom algorithm to get a maximum matching in an undirected graph
-
fft2d
Fourier transform for 2D data such as images
-
mona
Transform nested container types
-
asearch
Approximate pattern matching on Rust
-
mycrc
Create your own cyclic redundancy check (CRC)
-
hash-match
Optimized pattern matching alternative
-
zero-copy-pads
Padding/aligning values without heap allocation
-
hilbert_curve
A simple implementation of Hilbert curve mapping algorithms in Rust
-
deus-nqueens
NQueens Problem Solver
-
mpmc-map
Mpmc async map implementation for highly concurrent low-write access
-
lcs-diff
Compute differences between two slices using LCS algorithm
-
endian-hasher
Endianness wrapper for Hashers
-
crc24
CRC-24 implementation (IETF RFC2440-compatible)
-
navig18xx
Construct 18xx tiles and maps, and find optimal route combinations
-
revec
Convert a Vec to a Vec provided vec is empty
-
bgjk
Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect
-
lax
LAPACK wrapper without ndarray
-
interp
A Rust implementation of Matlab’s interp1 function
-
fsm-rust-jb
Simple FSM (with effects, like Mealy machine) implementation in Rust
-
fluent-comparisons-macros
Macros for the fluent-comparisons crate
-
scarecrow
A neural network library
-
four-bar-ui
Four🍀bar GUI is a simulator, a synthesizing tool for four-bar linkage mechanism
-
raftmodel
A logic model for the raft consensus algorithm
-
simplearrayhash
-
primenumbe-rs
Generate the nth prime number
-
adler32fast
Fast, SIMD-accelerated Adler-32 checksum computation
-
integer-cbrt
An implementation of integer cube root algorithm for primitive rust types
-
collision
A collision extension to cgmath
-
digits_iterator
Iterate over the digits of numbers in an arbitrary radix
-
rl-bandit
A simple multi-armed bandit implementation
-
numcmp
Comparison between differently typed numbers
-
wyhash2
A simple wyhash2 implementation in rust
-
memega
genetic algorithm library
-
idalloc
A library for different methods of allocating unique identifiers efficiently
-
siphash
A fast implementation of the SipHash hashing algorithm with no dependency on libstd
-
radiate_web
Train Radiate remotely
-
randlib
Dependency-less random value generator using pointer addresses and time
-
pruefung
Checksums in pure Rust, with no_std available, implementing the Hasher trait
-
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
-
rs-graph-derive
Automatic implementation of graph types
-
redblackbst
Rust Algorithms
-
rustmt
A MT19937 PRNG implementation for rust
-
minterpolate
Data set interpolation for mint primitives and raw arrays
-
rost
A library for sorting
-
bidir-map
Bidirectional map implementation for Rust
-
cutter
A simple usefull functions for parsing text. Used for cutting between strings.
-
octree
Octree algorithm for nearest neighbor search in 3D space
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
sorting-vec
Sorts a vector using a btreemap
-
eom
Configurable ODE/PDE solver
-
abc
An implementation of Karaboga’s Artificial Bee Colony algorithm
-
inohashmap
fast and efficient insert only string hashmap
-
triangulation
A collection of triangulation algorithms
-
acacia
A spatial partitioning and tree library
-
digit-invariant
Narcissistic number searcher
-
basichll
The basic HyperLogLog algorithm
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
audiograph
An audio graph optimised for performance and limiting runtime allocations
-
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
-
soundchange
Tool for implementing sound change algorithms in Rust
-
generic-floyd-warshall
A generic implementation of the Floyd-Warshall algorithm for array-like types
-
lisa
lisa - longest increasing subsequence algorithm [ O( nlogn ) ]
-
highhash
High-speed hashing algorithms for Rust
-
fsm
A simple Finite State Machine library, provide State and Event types, then create a machine with an initial state, give it some transition behaviours and you have your state machine!
-
dubble
A generic implementation of double-buffering
-
permut_lib
Simple function to generate permutations on a dictionry of a u8 chars set. I used it for generate unic Items into my proc macros.
-
checksum
Calculates crc32/crc64 file checksums written in Rust
-
prng
pseudo random number generator
-
baseperm
A tool for generating valid permutations of encoded inputs
-
perlin2d
Lightning fast 2D Perlin Noise generator
-
sort-rs
A crate exposing sorting algorithms
-
numext-fixed-hash-hack
A internal crate used by numext-fixed-hash
-
Algod
Many types of rust algorithms and data-structures
-
lp-solvers
.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK
-
radixal
Digits iteration for unsigned integer types
-
dary
This crate provides double-array construction and search functions
-
graph-neighbor-matching
Graph similarity score using neighbor matching
-
iobuffer
A simple memory-based buffer for IO reading and writing
-
const-murmur3
A const fn implementation of the murmur3 hashing algorithm
-
dpc-simplemap
Simple map with default value and compacting
-
lindel
A crate for Hilbert and Morton encoding and decoding; in a word, linearising and delinearising
-
czt
The package provides an algorithm to compute the chirp Z-transform
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
cloth_bumpmap
Creates a bump map used in the clothify algorithm in GIMP (GNU Image Manipulation Program)
-
dancing-links
Exact cover solver using dancing links technique
-
building_blocks_search
Search algorithms for voxel data
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
chalk-macros
Macros for Chalk
-
phreak_engine
Rule matching algorithm focussed on speed
-
editdistancewf
Compute the edit-distance between vectors using the Wagner-Fischer algorithm
-
rstat
Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures
-
count_sort
O(n) sorting library for large datasets with small range of possible values
-
phi-detector
An Implementation of Phi Accrual Failure Detector
-
coloring
Convert values to color simply and securely
-
indexed_bitvec_core
Core operations on indexed bitvectors including (hopefully) fast rank and select operations
-
crcxx
universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms
-
aristeia
An evolutionary computation library
-
word_sensitive
A library for sensitive string matching, the implementation language is rust, and the algorithm used is ac
-
chksum-sync
Synchronous higher-level functions for chksum library
-
gosh-fire
FIRE algorithm for geometry optimization
-
int_cmp
Small library for comparing unsigned integers with signed integers
-
quadtree_rs
Point/region Quadtree with support for overlapping regions
-
streamlined-ntru-prime
Rust implementation of the Streamline NTRU Prime algorithm
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
hamming-heap
Amortized constant time min heaps for binary features in nearest neighbor searches
-
simple_gaussian
Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.
-
gpp-solver
A small hybrid push-pull solver/planner that has the best of both worlds
-
spaced-repetition-rs
A spaced repetition algorithm based on anki and supermemo
-
sift4
This crate provides the sift4 string distance algorithm. It is very fast and returns results similar to levenshtein
-
tree-edit-distance
Find the lowest cost sequence of edits between two trees
-
primecount
Rust wrapper for https://github.com/kimwalisch/primecount
-
primitive_traits
Traits over primitive types. Particularly stuff not covered by num-*.
-
streamhist
Implementation of streaming histogram
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
pqgrams
This package implements a basic version of the PQ-Grams tree-edit-distance approximation algorithm, as generically as possible. It defines traits that you can define for your label-types and tree-types…
-
geo-rand
Generate random geometric shapes
-
utm
Convert latitudes and longitudes to UTM coordinates
-
rust-sort
Implementation of common sorting algorithms, purely for learning
-
nd_array
Crate for linear algebra that tries to have a similar api to numpy
-
envelope
An interpolatable Envelope trait along with a generic 2D Point trait. Useful for controlling parameters over time.
-
wy
Rust implementation of wyhash algorithms
-
noice
Fork of noise-rs, a procedural noise generation library
-
gossip
A generic gossip library that uses gossip-based peer sampling
-
urandom
Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms
-
rust-selfsimilar
A fast generator of discrete self similar random numbers
-
is-odd
Returns true if the given number is odd
-
rand_jitter
Random number generator based on timing jitter
-
random_access_unicode
Provide random access to the unicode characters in a file
-
fixed_trigonometry
Fixed point numerical approimations to trigonometric functions
-
polytope
Data structures and methods for constructing polytopes
-
triangulate
Subdivides polygons into equivalent triangles
-
linear_solver
A linear solver designed to be easy to use with Rust enum expressions
-
itertree
Hobby project to experiment with tree traversal using iterators
-
crcany
Compute any CRC
-
pcg-mwc
A fast non-cryptographic psudo random number generator
-
bsutils
Binary search utilities with efficiency
-
badsort
Some basic sorting stuff I wrote as practice in Rust. Includes my favorite algorithm, BOGO Sort!
-
tinysort
The lowest memory footprint sorting algorithm
-
bruteforce
This is a no_std-compatible brute force/string generation rust-nightly library
-
bft-core
An efficient and stable Rust library of BFT core for distributed system
-
bisection
Rust implementation of the Python bisect module
-
kdvtree
K-dimensional tree space-partitioning data structure
-
onemax-oxigen
OneMax simple problem resolution using oxigen
-
rusty-train
A graphical user interface for constructing 18xx maps and identifying optimal train routes
-
asdf-pixel-sort
ASDF pixel sorting
-
map_split
A library providing simultaneous mutable access to disjoint portions values stored in a hash map
-
tilecover
Generate the minimum number of tiles to cover a geometry
-
reingold-tilford
A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)
-
crc32c-hw
Hardware-accelerated (SSE 4.2) implementation of CRC32C with software fallback
-
quadtree-cd
A quadtree-based data structure for placing shapes such as rotated rectangles in bounded 2D space, checking for collision with already placed items
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
arenavec
An arena backed implementation of vectors and related types
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
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. -
kv-par-merge-sort
External sorting algorithm for (key, value) data sets
-
dense_mats
A strided dense tensor implementation
-
icub3d_sudoku_solver
A sudoku solver
-
faker_rand
Fake data generators for lorem ipsum, names, emails, and more
-
multiarray
Small Rust library for handling multi-dimensional data
-
dwt
The package provides an algorithm to compute the discrete wavelet transform
-
slicetools
Add extra iterators to slices
-
modinverse
Small library for finding the modular multiplicative inverses
-
integrators
Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators
-
fletcher-simd
A SIMD implementation of the Fletcher’s checksum algorithm
-
is-even
Returns true if the given number is odd
-
lz_eytzinger_tree
An Eytzinger tree implementation, this is an N-tree implemented using array storage
-
gfxmath-vec4
A simple 3D math library
-
phreak_facts
Rule matching algorithm focussed on speed
-
kagemeka
Kagemeka’s Rust Package
-
geo-offset
Add margin and padding to geometric shapes