Lib.rs

rand

Random number generators and other randomness functionality

rand_core

Core random number generator traits and tools for implementation

crc

Rust implementation of CRC(16, 32, 64) with support of various standards

num-bigint

Big integer implementation for Rust

pathfinding

Pathfinding, flow, and graph algorithms

rand_jitter

Random number generator based on timing jitter

md5

The package provides the MD5 hash function

bytecount

count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast

extprim

Extra primitive types (u128, i128)

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

fst

Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible)

twox-hash

A Rust implementation of the XXHash algorithm

number_prefix

Library for formatting numeric prefixes: kilo, giga, kibi

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

geo

Geospatial primitives and algorithms

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

rand_xorshift

Xorshift random number generator

rand_pcg

Selected PCG random number generators

rsgenetic

A library providing genetic algorithm execution

rustfft

Compute FFTs of any size in O(nlogn) time, in pure Rust

triple_buffer

An implementation of triple buffering, useful for sharing frequently updated data between threads

rand_os

OS backed Random Number Generator

lazysort

Lazy sorting for iterators

quantiles

a collection of approximate quantile algorithms

ratelimit_meter

A leaky-bucket-as-a-meter rate-limiting implementation in Rust

rand_chacha

ChaCha random number generator

ncollide3d

2 and 3-dimensional collision detection library in Rust

dmsort

Fast adaptive sorting for when most of your data is already in order. dmsort can be 2-5 times faster than Rust’s default sort when more than 80% of the elements are already in order

ncollide2d

2 and 3-dimensional collision detection library in Rust

decorum

Ordering, equality, hashing, and constraints for floating-point types

whatlang

Natural language detection library. Identifies language of a given text.

raft

The rust language implementation of Raft algorithm

primal-sieve

A high performance prime sieve

twoway

Fast substring search for strings and byte strings. Optional SSE4.2 acceleration (if detected at runtime) using pcmpestri. Memchr is the only mandatory dependency. The two way algorithm is also used by rust’s libstd itself, but here it is exposed both for byte strings, using memchr, and optionally using a SSE4.2 accelerated version.

bigdecimal

Arbitrary percision decimal numbers

geos

Rust bindings for GEOS C API

metrohash

Rust implementation of MetroHash, a high quality, high performance hash algorithm

rdrand

An implementation of random number generator based on rdrand and rdseed instructions

numext-fixed-uint

Fixed-size uint types

out

Provides functionality to get the n largest items from a &mut [T]

rand_isaac

ISAAC random number generator

float-cmp

Floating point approximate comparison traits

adler32

Minimal Adler32 implementation for Rust

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. Generate complete lexicographic combination from data. Generate non-lexicographic permutation and k-permutation.

probability

The package provides a probability-theory toolbox

numext-fixed-hash

Fixed-size hash types

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

numext-constructor

Fixed-size uint and hash constructor

punkt

An implementation of a Punkt sentence tokenizer

argonautica

Idiomatic Argon2 password hashing for Rust

criterion-stats

Criterion’s statistics library

geo-types

Geospatial primitive data types

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

elasticlunr-rs

A partial port of elasticlunr.js to Rust

is_sorted

Is an Iterator sorted?

meval

A simple math expression parser and evaluator

afsort

American Flag sort implementation for faster sorting of Strings

noise

Procedural noise generation library

streaming-stats

Experimental crate for computing basic statistics on streams

crc16

A CRC16 implementation

ipopt

Rust language bindings for the Ipopt non-linear constrained optimization library

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

vpsearch

Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces

hashmap_core

Implementation of HashMap and HashSet for no_std environments

special

The package provides special functions

num-bigint-dig

Big integer implementation for Rust

programinduction

A library for program induction and learning representations

roots

Library of well known algorithms for numerical root finding

cdshealpix

Rust implementation of the HEALPix tesselation

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

basic_dsp

Digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations. The vectors are optimized for sizes of a couple of thousand elements or more. The same operations are provdided for matrices. For complete matrix algebra this lib is intended to be used in combination with other matrix libs. Please refer to the documentation for more information about this.

num

A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!

k

k is for kinematics

staccato

Statistics from the command line

collider

A library for continuous 2D collision detection for game developement

zipf

A fast generator of discrete, bounded Zipf-distributed random numbers

basic_dsp_interop

This lib offers a C compatible interface for basic_dsp_vector, so that it can be used from programs written in languages other than Rust. basic_dsp_vector provides digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations. The vectors are optimized for sizes of a couple of thousand elements or more.

basic_dsp_matrix

This lib offers the same operations defined in basic_dsp_vector for matrices. It doesn’t offer complete matrix algebra by itself and instead is meant to be used in combination with other matrix libs. basic_dsp_vector provides digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations. The vectors are optimized for sizes of a couple of thousand elements or more.

highway

Native Rust port of Google’s HighwayHash, which makes use of SIMD instructions for a fast and strong hash function

worley-noise

Worley noise implementation

sdset

Set operations for sorted and deduplicated slices. Much performances! Such Wow!

crc-any

To compute CRC values by providing the length of bits, expression, reflection, an initial value and a final xor value. It has built-in CRC-8-ATM, CRC-8-CDMA, CRC-16-IBM, CRC16-CCITT, CRC-32-IEEE, CRC-32-C, CRC-64-ISO and CRC-64-ECMA functions.

polylabel

A Rust implementation of the Polylabel algorithm for finding optimum polygon label positions

alphanumeric-sort

This crate can help you sort order for files and folders whose names contain numerals

passwords

This crate provides useful tools to generate multiple readable passwords, as well as analyze and score them

specialized-div-rem

Specialized long division algorithms that are faster than binary long division (used by Rust) on some CPUs, especially 128 bit division on CPUs with hardwired 64 bit division

levenshtein

Levenshtein algorithm

slice-group-by

Iterators over groups in a slice

pikkr

JSON Parser which picks up values directly without performing tokenization in Rust

random-pick

Pick an element from a slice randomly by given weights

sublime_fuzzy

Fuzzy matching algorithm based on Sublime Text’s string search. Check out the repository’s releases for a summarized changelog.

randomize

A dead simple to use randomization library for rust

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

chinese-number

Convert primitive numbers to Chinese numbers, or parse Chinese numbers to primitive numbers

hashers

A collection of non-cryptographic hashing algorithms for Rust

rustdct

Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein automata

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

permutohedron

Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap’s algorithm.

faiss

High-level bindings for Faiss, the vector similarity search engine

bibicode

A crate to convert any integer from one numeral system to another

automata

An implementation of standard finite state automata such as DFA, NFA, Regex

pihex

Arbitrary place hexadecimal digits viewer of pi written in Rust

rs-graph

A library for graph algorithms and combinatorial optimization

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) is not used. This value can then be used to mark frame boundaries in a serial communication channel.

fxhash

A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc

zhang_hilbert

Produces an arbitrary-sized pseudo-Hilbert scan based on “A Pseudo-Hilbert Scan for Arbitrarily-Sized Arrays” by Zhang, et al

qptrie

A QP-Trie implementation for Rust

usher

Parameterized routing for generic resources in Rust

mathru

Simple mathematics library written in Rust

astro

Advanced algorithms for astronomy

cryptominisat

Rust bindings for Cryptominisat, a boolean satisfiability solver

bitintr

Portable Bit Manipulation Intrinsics

graphene

A general purpose, extensible Graph Theory data type and algorithm library for Rust

maths-traits

A simple to use yet abstract system of mathematical traits for the Rust language

hime_redist

Redistributable runtime library for parsers generated with Hime (LR, RNGLR)

aristeia

An evolutionary computation library

gear

Collision avoidance path planning for robotics

rs_algo

Common sorting algorithms and other common computer science algorithms

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

chfft

Fastest Fourier Transform library implemented with pure Rust

cellular_maps

A simple library to generate 2D procedural bitmaps using the cellular automata technique

normalize-line-endings

Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n

linear_solver

A linear solver designed to be easy to use with Rust enum expressions

rustfst

Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)

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.

coord_transforms

A Rust crate use for performing coordinate transformations

spmc_buffer

An extension of triple buffering for multiple-consumer scenarios, useful for sharing frequently updated data between threads

superslice

Extensions for slices

test-data-generation

A simple to use, light-weight library that analyzes sample data to build algorithms and generates realistic test data

smeagol

Conway’s Game of Life using HashLife and SIMD

boyer-moore-magiclen

Boyer-Moore-MagicLen, a fast string search algorithm implemented in Rust

statistical

A simple statistics library

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

ncollide

2 and 3-dimensional collision detection library in Rust

streamlined-ntru-prime

Rust implementation of the Streamline NTRU Prime algorithm

vecshard

Split Vecs in constant time

munkres

Kuhn-Munkres (aka Hungarian) algorithm for solving the Assignment Problem in O(n^3)

axgeom

Library that provides ability to extract 1d ranges out of 2d objects

ipopt-sys

Raw unsafe Rust bindings to the Ipopt non-linear optimization library

subslice

Fast subslice search

escape_string

Very efficiently parse backslash-escaped strings

symbolic_polynomials

A library for manipulation of polynomials over the integers

strength_reduce

Faster integer division and modulus operations

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

geometry-predicates

galois_2p8

Basic Arithmetic over all GF(2^8) fields

fuss

Small, lightweight simplex noise generator for Rust

raftlog

An implementation of distributed replicated log based on the Raft algorithm

graphplan

Implementation of the Graphplan planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust

treediff

Find the difference between arbitrary data structures

timely_sort

Sorting infrastructure for timely dataflow

rtriangulate

Delaunay triangulation on a set of points

rand_hc

HC128 random number generator

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

simsearch

A simple and lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)

random_color

Rust crate for generating random attractive colors

indexed_bitvec_core

Core operations on indexed bitvectors including (hopefully) fast rank and select operations

xbar

An iterator-based implementation of the locality-preserving one-sided binary tree - crossbar switch wiring design algorithm

indexed_bitvec

An indexed bitvector with (hopefully) fast rank and select operations

random-integer

Generate a random integer between two integer numbers (including the two integer numbers)

rustlex_fsa

Library for manipulating (deterministic) finite automata

flo_curves

Library for manipulating Bezier curves

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

solvent

Dependency Resolver library

bidir-map

Bidirectional map implementation for Rust

fuzzyhash

Pure Rust fuzzy hash implementation

darwin-rs

Evolutionary algorithms library written in Rust

eudex

A blazingly fast phonetic reduction/hashing algorithm

plumcast

A message broadcasting library based on the Plumtree/HyParView algorithms

rvs

A library for defining and evaluating random variables using a simple DSL

quadtree_rs

Point/region Quadtree with support for overlapping regions

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL 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 ‘this button must line up with this text box’

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

howto

instant coding answers via the command line

dummy

Type oriented fake data generation

flag-algebra

An implementation of Razborov’s flag algebras

natural

Pure rust library for natural language processing

beehave

A simple library for defining and evaluating a hierarchical state machine (behaviour tree)

quasirandom

Quasirandom number generation

tilecover

Generate the minimum number of tiles to cover a geometry

rdp

A Rust implementation of the Ramer–Douglas–Peucker and Visvalingam-Whyatt algorithms

reingold-tilford

A Rust library for laying out aesthetically pleasing trees (the data structure, not the plant)

fasthash-sys

A suite of non-cryptographic hash functions for Rust

natord

Natural ordering for Rust

external_sort

Provides the ability to perform external sorts on structs, which allows for rapid sorting of large data streams

count_sort

O(n) sorting library for large datasets with small range of possible values

tic

a high-performance stats library focused on rates and latencies from timestamped events

monotonic_solver

A monotonic solver designed to be easy to use with Rust enum expressions

dedup_signature

This library implements TextProfileSignature and Lookup3 algorithms to generates a hash/signature/footprint in order to be used for detecting duplicate documents

spiral

Iterate over a 2D structure in a spiral pattern

gcd

Small Rust library (with no dependencies) for calculating greatest common divisor

ncollide_geometry

2 and 3-dimensional collision detection library in Rust: module describing the geometric entities and their mathematical definitions

pdqsort

Pattern-defeating quicksort

osqp

The OSQP (Operator Splitting Quadratic Program) solver

contrail

Simple state restoration for backtracking search algorithms using a trail

line_drawing

A collection of line-drawing algorithms for use in graphics and video games

extfsm

Extended Finite State Machine with internal event queue and entry/exit transitions

dft

The package provides an algorithm to compute the discrete Fourier transform

specs_scene_graph

scene graph for specs

mop

Flexible and modular single or multi-objective solver for contiguous and discrete problems

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

vek

Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience

labelgraph

A simple to use graph implementation, allowing random access to nodes via labels

optimization_engine

A pure Rust framework for embedded nonconvex optimization. Ideal for robotics!

transpose

Utility for transposing multi-dimensional data

human-sort

Human sort (natural sort) implementation

extsort

External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator

wyhash

Rust implementation of the WyHash fast portable non-cryptographic hashing algorithm and random number generator

xorshift128plus-rs

A simple implementation of the XorShift128+ pseudorandom number generator in Rust

sortrs

An introspective sort implementation

acacia

A spatial partitioning and tree library

cang-jie

A Chinese tokenizer for tantivy

co_sort

Sort arrays given a permutation

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) is not used. This value can then be used to mark frame boundaries in a serial communication channel.

quickbacktrack

Library for back tracking with customizable search for moves

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

sfmt

Rust implementation of SIMD-oriented Fast Mersenne Twister (SFMT)

crc32c-hw

Hardware-accelerated (SSE 4.2) implementation of CRC32C with software fallback

point_process

A crate for simulating random point processes

bloodhound

Fuzzy file finder

ncollide_pipeline

2 and 3-dimensional collision detection library in Rust: module describing the collision detection pipeline (broad phase/narrow phase) of ncollide

cplex-sys

Low level bindings to the Cplex C-API

algos

A collection of algorithms in rust

hyparview

A Rust implementation of HyParView algorithm

qht

Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc

zpatial

Algorithms for Spatial Acceleration and Geometries

partitions

A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set

collenchyma-nn

collenchyma plugin providing Neural Network operations

common_macros

Provides common macros like hash_map! or hash_set! (WIP)

rootfind

Root-finding algorithms

count-min-sketch

Count-min-sketch implementation

kademlia-dht

A simple implementation of the Kademlia DHT

t1ha

An implementation of the T1AH (Fast Positive Hash) hash function

algoliasearch

Algolia client

bex

A rust library for working with boolean expressions (expression trees, decision diagrams, etc.)

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.

spanish-numbers

Convert integers to written Spanish number format

rand_regex

Generates random strings and byte strings matching a regex

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

ncollide_utils

2 and 3-dimensional collision detection library in Rust: module for various common and simple geometric and mathematical operations

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

accurate

(more or less) accurate floating point algorithms

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

fera

An aggregation of algorithms, data structures and supporting crates

easy_reader

Move forward, backward or randomly through the lines of huge files. Easily and fastly.

triangulation

A collection of triangulation algorithms

non-dominated-sort

Fast Non-Dominated Sort Algorithm

mix-distribution

Mixture distributions

block-array-cow

In memory array de-duplication, useful for efficient storing of a history of data versions

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

lzjd

Rust implementation of the LZJD algorithm (https://github.com/EdwardRaff/jLZJD)

cycle-sort

Simple generic Cycle sort implementation

mersenne_twister

Mersenne Twister pseudorandom number generator

cagra

Calculation Graph Library

pcg

A port of the PCG random number generation library

twox-hash-cli

A cli for the twox-hash crate

exprtk_rs

Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)

pack

Solver for packing puzzle

float-ord

A total ordering for floating-point numbers

hwt

Hamming Weight Tree for finding neighbors in Hamming space

rendezvous_hash

An implementation of Rendezvous hashing algorithm

batsat

Extensible SAT solver in Rust

sift4

This crate provides the sift4 string distance algorithm. It is very fast and returns results similar to levenshtein

ssdeep

A Rust wrapper for ssdeep

sorts

A collection of sorting algorithms

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

sfcgal

High-level bindings to SFCGAL and conversion from/to other geometry libraries

r-fairdist

Fair Resource Distribution Algorithm

kmpsearch

String/Byte pattern searching within byte slices or strings, using the Knuth Morris Pratt algorithm

nanoid

A tiny, secure, URL-friendly, unique string ID generator for Rust

graphsearch

A simple graph search and representation library

galil-seiferas

General string search in constant space, linear time, for nonorderable alphabets

flot

Generate HTML documents with embedded charts using Flot

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

largest-remainder-method

The largest remainder method

bip_dht

Implementation of the bittorrent mainline DHT

sdbm

SDBM is a non-cryptographic hashing algorithm

plumtree

A Rust implementation of Plumtree algorithm

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

muldiv

Provides a trait for numeric types to perform combined multiplication and division with overflow protection

algorithmica

Rust Algorithms

revonet

Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.

dia-range

Ranges for all integers

order-stat

Compute order statistics efficiently via the Floyd-Rivest algorithm and estimate a median via the median-of-medians algorithm

rs-graph-derive

Automatic implementation of graph types

ncollide_procedural

2 and 3-dimensional collision detection library in Rust: module for procedural generation of discrete geometric objects

highwayhash

Bindings to AVX-2-optimized SIP-like hash functions

llrb-index

Left Leaning Red Black index

abstractgraph

Abstract Graph Algorithms

hyperbolic_graph_generator

Create different types of hyperbolic graphs

index-fixed

convert slices into arrays using indexes ([T] -> [T;N])

teia

A crate which implements persistent homology algorithm

rsalgo

A collection of some algorithms and data-structures

merging-iterator

An iterator to return the elements of two independently ordered iterators in order

perlin

A lazy, zero-allocation and data-agnostic Information Retrieval library

xxcalc

Embeddable or standalone robust floating-point polynomial calculator

zeros

Extensions for hashing crates

pruefung

Checksums in pure Rust, with no_std available, implementing the Hasher trait