Lib.rs

rand

Random number generators and other randomness functionality

strsim

Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, and Jaro-Winkler

crc

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

md5

The package provides the MD5 hash function

rand_pcg

Selected PCG random number generators

twox-hash

A Rust implementation of the XXHash algorithm

rand_chacha

ChaCha random number generator

bytecount

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

rand_jitter

Random number generator based on timing jitter

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

pathfinding

Pathfinding, flow, and graph algorithms

rand_xorshift

Xorshift random number generator

fst

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

rand_os

OS backed Random Number Generator

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

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…

adler32

Minimal Adler32 implementation for Rust

fake

An easy to use library for generating fake data like name, number, address, lorem, dates, etc

rand_isaac

ISAAC random number generator

ratelimit_meter

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

rand_hc

HC128 random number generator

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

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.

geos

Rust bindings for GEOS C API

extprim

Extra primitive types (u128, i128)

metrohash

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

elasticlunr-rs

A partial port of elasticlunr.js to Rust

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

rustfft

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

probability

The package provides a probability-theory toolbox

whatlang

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

rdrand

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

textnonce

Text based random nonce 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…

ncollide3d

2 and 3-dimensional collision detection library in Rust

triple_buffer

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

rand_distr

Sampling from random number distributions

decorum

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

passwords

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

fxhash

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

alphanumeric-sort

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

numext-fixed-uint

Fixed-size uint types

fallible-iterator

Fallible iterator traits

line_drawing

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

lp-modeler

A linear programming modeller written in Rust. This api helps to write LP model and use solver such as CBC, Gurobi, lp_solve, …

ncollide2d

2 and 3-dimensional collision detection library in Rust

streaming-stats

Experimental crate for computing basic statistics on streams

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

nqueens-oxigen

N Queens problem resolution using oxigen

quantiles

a collection of approximate quantile algorithms

out

Provides partial sorting for slices and iterators

raft

The rust language implementation of Raft algorithm

special

The package provides special functions

radiate

Parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and general reinforcement learning problems

zipf

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

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

crc16

A CRC16 implementation

vek

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

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

highway

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

flo_binding

Declarative binding library for Rust

sdset

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

random-pick

Pick an element from a slice randomly by given weights

polylabel

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

strength_reduce

Faster integer division and modulus operations

k

k is for kinematics

onemax-oxigen

OneMax simple problem resolution using oxigen

noise

Procedural noise generation library

cdshealpix

Rust implementation of the HEALPix tesselation

numext-fixed-hash

Fixed-size hash types

bitintr

Portable Bit Manipulation Intrinsics

timely_sort

Sorting infrastructure for timely dataflow

ipopt

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

muldiv

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

hnsw

Fast approximate nearest neighbors

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

programinduction

A library for program induction and learning representations

flo_curves

Library for manipulating Bezier curves

axgeom

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

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…

geohash

Geohash implementation for Rust

eliza

A rust implementation of ELIZA - a natural language processing program developed by Joseph Weizenbaum in 1966

rsgenetic

A library providing genetic algorithm execution

afsort

American Flag sort implementation for faster sorting of Strings

permutohedron

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

rust-lapper

A fast and easy interval overlap library

worley-noise

Worley noise implementation

linear_solver

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

numext-constructor

Fixed-size uint and hash constructor

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…

natural

Pure rust library for natural language processing

nonogrid

Efficient nonogram solver

vpsearch

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

slice-group-by

Iterators over groups in a slice

is_sorted

Is an Iterator sorted?

boyer-moore-magiclen

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

fd-oxigen

Fast Downward planner parameters optimization using oxigen

spaces

Set/space primitives for defining machine learning problems

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

xoroshiro128

Fast psuedo-random number generators

oorandom

A tiny, robust PRNG implementation

levenshtein

Levenshtein algorithm

easy_reader

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

cubic_spline

Function that calculates curve points for cubic spline

vrf

Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves

pikkr

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

hilbert

Hilbert curve transform and inverse for points having two to thousands of dimensions, using Skilling’s algorithm

rust-3d

2D/3D library written in rust

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

rendezvous_hash

An implementation of Rendezvous hashing algorithm

const-random-macro

Provides the procedural macro used by const-random

eddie

Fast and well-tested implementations of edit distance/string similarity metrics: Levenshtein, Damerau-Levenshtein, Hamming, Jaro, and Jaro-Winkler

float-ord

A total ordering for floating-point numbers

graphplan

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

diffr-lib

An implementation of Myers diff algorithm

sublime_fuzzy

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

punkt

An implementation of a Punkt sentence tokenizer

faiss

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

rand_regex

Generates random strings and byte strings matching a regex

zkp-stark

Implementation of the STARK ZK-proof system

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)…

test-data-generation

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

advancedresearch-tree_mem_sort

An in-memory topological sort algorithm for trees based on Group Theory

knapsack-oxigen

Knapsack problem resolution using oxigen

natord

Natural ordering for Rust

random-integer

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

qframework

A experimental micor framework for clear design, based on queue model

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.

external_sort

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

ahrs

A Rust port of Madgwick’s AHRS algorithm

rs-graph

A library for graph algorithms and combinatorial optimization

raftlog

An implementation of distributed replicated log based on the Raft algorithm

collider

A library for continuous 2D collision detection for game developement

nanoid

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

gear

Collision avoidance path planning for robotics

vec-drain-where

alternative Vec::drain_filter impl

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…

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…

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

qptrie

A QP-Trie implementation for Rust

canonical-form

Reduce graphs and other combinatorial structures modulo isomorphism

permutation_iterator

A Rust library for iterating over random permutations using O(1) (i.e. constant) space.

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

bidir-map

Bidirectional map implementation for Rust

hashmap_core

Implementation of HashMap and HashSet for no_std environments

startin

A Delaunay triangulator for terrains

treediff

Find the difference between arbitrary data structures

astro

Advanced algorithms for astronomy

superslice

Extensions for slices

friedrich

Gaussian Process Regression

fsm_gen

FSM (finite state machine) DSL for code generation (c++ at the moment)

convert-base

convert the radix (base) of digits stored in a vector

vecshard

Split Vecs in constant time

objid

Generate a random object identifier

simsearch

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

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein automata

tile-grid

Library for map tile grid calculations

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

geomorph

Simple conversion between different coordinate systems

gut

Geometry utilities: storing, manipulating and processing geometries

usher

Parameterized routing for generic resources in Rust

rustdct

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

halton

A module for generating Halton sequences

bibicode

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

trigram

Trigram-based string similarity for fuzzy matching

count_sort

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

divisors

A blazing fast library to find all divisors of a natural number

nhl-stats

NHL Stats API client for Rust created using openapi-generator

nats-types

Enumerations and types for representing NATS protocol messages

governor

A rate-limiting implementation in Rust

solvent

Dependency Resolver library

automata

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

apodize

simple iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows

bravery_router

Radix Tree implementation

zeros

Extensions for hashing crates

leaky-bucket

Futures-aware rate limiter implementation

hashers

A collection of non-cryptographic hashing algorithms for Rust

lis

Longest increasing subsequence algorithm

hime_redist

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

sfmt

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

eudex

A blazingly fast phonetic reduction/hashing algorithm

clusterphobia

Algorithms and data structures for unassisted clustering that employ the Hilbert Curve

darwin-rs

Evolutionary algorithms library written in Rust

beehave

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

rs_algo

Common sorting algorithms and other common computer science algorithms

lonlat_bng

Convert longitude and latitude coordinates to BNG coordinates, and vice versa

dissimilar

Diff library with semantic cleanup, based on Google’s diff-match-patch

bsa3-hash

The hash function used in BSA files for The Elder Scrolls III: Morrowind

multistream-batch

Different types and implementations of batching algorithms

spmc_buffer

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

sub-strs

For finding sub strings

conshash

A library to do consistent hashing in Rust

howto

instant coding answers via the command line

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

simplers_optimization

A Rust implementation of the Simple(x) black-box optimization algorithm

ffts

Rust binding for ffts (The Fastest Fourier Transform in the South)

mop

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

raftlog_protobuf

Encoders and decoders of the Protocol-Buffers messages for the constituents defined in raftlog crate

aliasmethod

Implementation of Walker’s Alias method

hypernonsense

Using Locality Sensitive hashing to find the nearest points to a query point in extremely high dimensional space

cang-jie

A Chinese tokenizer for tantivy

fractal

The package provides a multiscale modeling framework for the analysis and synthesis of positive-valued, long-range-dependent processes

merging-iterator

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

pdqsort

Pattern-defeating quicksort

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

kademlia-dht

A simple implementation of the Kademlia DHT

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

wu-diff

Compute differences between two slices using wu(the O(NP)) algorithm

monotonic_solver

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

bufferpool

A vector of vectors backed by one contiguous vector - allows mutable borrows of non-overlapping regions

munkres

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

dedup_signature

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

cplex-sys

Low level bindings to the Cplex C-API

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

human-sort

Human sort (natural sort) implementation

indexed_bitvec

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

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.

coord_transforms

A Rust crate use for performing coordinate transformations

xorf

Library implementing xor filters - faster and smaller than bloom and cuckoo filters

thin-slice

An owned slice that packs the slice storage into a single word when possible

dia-range

Ranges for all integers

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

rustlex_fsa

Library for manipulating (deterministic) finite automata

iter-set

Set operations on sorted, deduplicated iterators

osmgraphing

Playing around with graphs created via parsing OpenStreetMap data

moodyblues-sdk

A tracer SDK for Overlord like consensus algorithm

tilecover

Generate the minimum number of tiles to cover a geometry

tailcall

Safe, zero-cost tail recursion

contrail

Simple state restoration for backtracking search algorithms using a trail

fast_paths

Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies

consistent_hash_ring

A flexible and efficient consistent hash ring

rand_seeder

A universal random number seeder based on SipHash

dary

This crate provides double-array construction and search functions

ipopt-sys

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

subslice

Fast subslice search

rvs-parser

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

pocket_prover-set

A base logical system for PocketProver to reason about set properties

srand

Random number generators and other randomness functionality with simple apis to use

tdigest

T-Digest algorithm in Rust

just-argon2

Bindings to the argon2 C library

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…

geos-sys

GEOS C API bindings

algebraics

algebraic numbers library

order-stat

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

acacia

A spatial partitioning and tree library

graphene

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

geo-booleanop

Rust implementation of the Martinez-Rueda Polygon Clipping Algorithm

fuzzyhash

Pure Rust fuzzy hash implementation

rvs-repl

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

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.

kahan

Provides types to perform Kahan summation

zhang_hilbert

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

forge_hasher

The rust language implementation of forge_hasher

random_color

Rust crate for generating random attractive colors

mecs

An ecs library with a focus on iteration performance

rvs-c-api

C-API for Rvs - A library for defining and evaluating random variables using a simple DSL

rusted_list

A ever sorted list for rust that is operating on binary search

actix-raft

An implementation of the Raft distributed consensus protocol using the Actix actor framework

sortrs

An introspective sort implementation

weighted-rs

A libray for weighted balancing algorithm

labelgraph

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

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

count-min-sketch

Count-min-sketch implementation

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

names

A library to generate random name strings suitable for use in container instances, project names, application instances, etc

ordslice

Extensions for ordered slices

aristeia

An evolutionary computation library

spatium

Spatium. Calc distance between sequences.

rootfind

Root-finding algorithms

galois_2p8

Basic Arithmetic over all GF(2^8) fields

ostn02_phf

A PHF map of the OSTN02 grid shifts for use in transforming ETRS89 grid coordinates to OSGB36

geometry-predicates

streaming_algorithms

SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling

robust

Robust predicates for computational geometry

scottish_names

Library for generating random names of people based on frequency of occurrence of birth-names in Scotland

quickbacktrack

Library for back tracking with customizable search for moves

block-array-cow

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

xx-bloomfilter

Bloom filter implementation using xx hash

algorithmica

Rust Algorithms

overlord

Overlord consensus procotol

xbar

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

sorting

The world’s best, finest and inefficient sorting algorithms

random-trait

Rust library for a random trait meant to produce random generic types

sprs-ldl

Sparse cholesky factorization

rvs

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

length

A library to handle length/distances easyly. It can parse a string with several units (m, km, mi, ft, …) into the Length-struct and converting into other units.

index-fixed

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

hamming

Count ones, fast (aka popcount, hamming weight). This provides a performant popcount and bitwise hamming distance for a slice of bytes.

permu-rs

A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.

ingrid

Dynamic two-dimensional arrays with algorithms

int_traits

Provides a trait for extended functions on integers

xorshift

Implementation of the high performance xoroshiro128+, xorshift128+, xorshift1024*, and splitmix64 pseudo random number generators

bitap

Bitap implementation in rust

rtriangulate

Delaunay triangulation on a set of points

suffix_array

Suffix array construction and searching algorithms for in-memory binary data

pack

Solver for packing puzzle

mix-distribution

Mixture distributions

accurate

(more or less) accurate floating point algorithms

generic_levenshtein

Generic and fast implementation of the Levenshtein distance

ssdeep

A Rust wrapper for ssdeep

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

kendalls

Kendall’s tau rank correlation

crc64fast

SIMD accelerated CRC64 calculation

geo-visibility

Compute visibility polygon

debtsolver

Track and settle debts between parties with the fewest transactions

specs_scene_graph

scene graph for specs

wookong-solo

Wookong Solo driver crate

zpatial

Algorithms for Spatial Acceleration and Geometries

geo-rand

Generate random geometric shapes

grb-sys

Low level bindings to Gurobi

dft

The package provides an algorithm to compute the discrete Fourier transform

radixal

Digits iteration for unsigned integer types

sfcgal

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

quasirandom

Quasirandom number generation

bip_dht

Implementation of the bittorrent mainline DHT

cdivsufsort

Rust bindings for Yuta Mori’s divsufsort

ffts-sys

Rust binding for ffts (The Fastest Fourier Transform in the South)

visit_diff

Efficiently finding differences between data structures

common_macros

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

rdx

A collection of traits and algorithms to ease using radix sorts

mersenne_twister

Mersenne Twister pseudorandom number generator

rand04_compat

Wrappers for compatibility with rand 0.4

ranges

TODO

spiral

Iterate over a 2D structure in a spiral pattern

non-dominated-sort

Fast Non-Dominated Sort Algorithm

advancedresearch-hypo

Automatic hypothesis testing

wyhash

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

fuss

Small, lightweight simplex noise generator for Rust

distance

A collection of approximate string matching algorithms

ed_join

A Rust Implemtation of Ed-Join Algorithm for string similarity join

gcd

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

rand04

Re-export of rand 0.4, so it can be used together with a later version of rand

revonet

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

addchain

Generate addition chains

sift4

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

pruefung

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

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

geo-raycasting

Ray Casting algorithm for the geo crate

audiograph

An audio graph optimised for performance and limiting runtime allocations

rkm

A generic k-means implementation

rdp

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

msws

Middle Square Weyl Sequence pseudorandom number generator

hashed-permutation

A fast, instant-access way to permute a range of numbers

geo

Geospatial primitives and algorithms

sharpen

A rust library for iterator element condensing and sharpening

checksum

Calculates crc32/crc64 file checksums written in Rust

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

scailist

A fast and easy interval overlap library

xorshift128plus-rs

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

crc24

CRC-24 implementation (IETF RFC2440-compatible)

abstractgraph

Abstract Graph Algorithms

delaunator

A very fast 2D Delaunay triangulation library

extsort

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

lcs-diff

Compute differences between two slices using LCS algorithm

delaunay2d

A library to compute Delaunay triangulations and Voronoi diagrams in 2D space

number_traits

number traits

english-numbers

Convert integers to written English number format

highwayhash

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

quadtree_rs

Point/region Quadtree with support for overlapping regions

hamming-heap

Amortized constant time min heaps for binary features in nearest neighbor searches

djb33

DJB33 hash algorithm write in Rust

livesplit-title-abbreviations

livesplit-title-abbreviations encapsulates the algorithm that LiveSplit uses to abbreviate game titles

glicko2

Implementation of the glicko2 rating system

rosalind-cli

CLI for rosalind crate

ndarray-rblas

rblas bindings for ndarray

spanish-numbers

Convert integers to written Spanish number format

fxtypemap

A fast type map based on internal hasher used in Firefox and Rustc

lzjd

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

sorty

A plugin to check whether the ‘extern crate’, ‘mod’ and ‘use’ declarations are in their sorted format

raft-proto

Protocol definitions for the rust language implementation of the Raft algorithm

indexed_bitvec_core

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

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

fast_inv_sqrt

Fast inverse square root algorithm implementation

estahr

A string distance and hashing library

smeagol

Conway’s Game of Life using HashLife and SIMD

haikunator

Generate Heroku-like random names to use in your Rust applications

fera

An aggregation of algorithms, data structures and supporting crates

partitions

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

algs4

Algorithms, 4ed. MOOC in Coursera. in 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!

random_choice

Chooses samples randomly by their weights/probabilities

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

faiss-sys

Native bindings for Faiss

internet-checksum

RFC 1071 checksum computation (the “internet checksum”)

bloodhound

Fuzzy file finder

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 rand crate.

cauchy

Trait for real and complex numbers

permutation

Small utility for creating, manipulating, and applying permutations

checked_int_cast

Conversions between primitive integers with overflow and underflow checking

small-ord-set

A set data-structure represented by a sorted SmallVec

hwt

Hamming Weight Tree for finding neighbors in Hamming space

md6

Implementation of the MD6 hash function for Rust via FFI

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)…

rjq

Redis job queue

extfsm

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

bcmp

bcmp offers fast binary data comparison algorithms to enumerate common substrings, unique substrings or determine a patch set

noisy

A procedural noise generation library written for Rust

rosalind

Crate contains solutions of problems published on Rosalind.info