Lib.rs

rand

Random number generators and other randomness functionality

crc

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

twox-hash

A Rust implementation of the XXHash algorithm

bytecount

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

pathfinding

Pathfinding, flow, and graph algorithms

fake

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

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.

rand_jitter

Random number generator based on timing jitter

md5

The package provides the MD5 hash function

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…

ratelimit_meter

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

fst

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

adler32

Minimal Adler32 implementation for Rust

ncollide3d

2 and 3-dimensional collision detection library in Rust

nanoid

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

whatlang

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

passwords

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

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…

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

triple_buffer

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

bio

A bioinformatics library for Rust. This library provides implementations of many algorithms and data structures that are useful for bioinformatics, but also in other fields.

probability

The package provides a probability-theory toolbox

radiate

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

numext-fixed-uint

Fixed-size uint types

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

rdrand

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

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

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

out

Provides fast min and max functionality for collections

bao

a general-purpose cryptographic tree hash

alphanumeric-sort

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

metrohash

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

fallible-iterator

Fallible iterator traits

noise

Procedural noise generation library

rand_os

OS backed Random Number Generator

raft

The rust language implementation of Raft algorithm

extprim

Extra primitive types (u128, i128)

decorum

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

oorandom

A tiny, robust PRNG implementation

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

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

ff

Library for building and interfacing with finite fields

quantiles

a collection of approximate quantile algorithms

zipf

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

cdshealpix

Rust implementation of the HEALPix tesselation

streaming-stats

Experimental crate for computing basic statistics on streams

sdset

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

vek

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

rust-3d

2D/3D library written in rust

graphplan

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

ipopt

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

hnsw

Fast approximate nearest neighbors

cam-geom

Geometric models of cameras for photogrammetry

ddo

DDO a generic and efficient framework for MDD-based optimization

fuzzyhash

Pure Rust fuzzy hash implementation

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…

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

jubjub

Implementation of the Jubjub elliptic curve group

mop

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

fxhash

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

highway

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

rust-lapper

A fast and easy interval overlap library

linear_solver

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

worley-noise

Worley noise implementation

strength_reduce

Faster integer division and modulus operations

polylabel

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

convert-base

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

flo_curves

Library for manipulating Bezier curves

rsgenetic

A library providing genetic algorithm execution

k

k is for kinematics

timely_sort

Sorting infrastructure for timely dataflow

random-pick

Pick an element from a slice randomly by given weights

special

The package provides special functions

bitintr

Portable Bit Manipulation Intrinsics

afsort

American Flag sort implementation for faster sorting of Strings

flo_binding

Declarative binding library for Rust

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

nonogrid

Efficient nonogram solver

safe-mix

Implementation of the Collective Coin Flip algorithm

vpsearch

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

is_sorted

Is an Iterator sorted?

simsearch

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

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…

treediff

Find the difference between arbitrary data structures

programinduction

A library for program induction and learning representations

easy_reader

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

rand_regex

Generates random strings and byte strings matching a regex

eddie

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

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

rs-graph

A library for graph algorithms and combinatorial optimization

hilbert

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

algos

A collection of algorithms in Rust

ncollide2d

2 and 3-dimensional collision detection library in Rust

extendhash

Rust Hash Extender

crc16

A CRC16 implementation

test-data-generation

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

diffr-lib

An implementation of Myers diff algorithm

microfft

Embedded-friendly Fast Fourier Transforms

external_sort

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

natord

Natural ordering for Rust

muldiv

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

flatk

Flat layout abstraction toolkit

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

xoroshiro128

Fast psuedo-random number generators

rendezvous_hash

An implementation of Rendezvous hashing algorithm

nqueens-oxigen

N Queens problem resolution using oxigen

leaky-bucket

Futures-aware rate limiter implementation

levenshtein

Levenshtein algorithm

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.

slice-group-by

Iterators over groups in a slice

faiss

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

extsort

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

glicko2

Implementation of the glicko2 rating system

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

permutation_iterator

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

numext-fixed-hash

Fixed-size hash types

hybrid-clocks

Hybrid Logical Clocks

boyer-moore-magiclen

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

punkt

An implementation of a Punkt sentence tokenizer

detect-lang

Language detection given paths and extensions

qptrie

A QP-Trie implementation for Rust

advancedresearch-tree_mem_sort

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

qframework

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

meowhash

Meow hash function

zeros

Extensions for hashing crates

astro

Advanced algorithms for astronomy

raftlog

An implementation of distributed replicated log based on the Raft algorithm

hypernonsense

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

halton

A module for generating Halton sequences

vec-drain-where

alternative Vec::drain_filter impl

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

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

dissimilar

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

divisors

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

bidir-map

Bidirectional map implementation for Rust

rand_mt

Reference Mersenne Twister random number generators

superslice

Extensions for slices

gcd

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

sample_planning

Sample Based Planner

vecshard

Split Vecs in constant time

hashers

A collection of non-cryptographic hashing algorithms for Rust

bravery_router

Radix Tree implementation

overlord

Overlord consensus procotol

traversal

Generic and lazy tree traversal algorithms

sobol

A Sobol sequence generator for Rust

median

An implementation of an efficient O(n) median filter

hotsax

An implementation of the HOTSAX discord discovery algorithm

xorf

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

simple_gaussian

Some quick and easy functions for generating gaussian noise, mappable to specific bounds. Useful for artistic purposes.

tailcall

Safe, zero-cost tail recursion

permutohedron

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

sub-strs

For finding sub strings

osqp

The OSQP (Operator Splitting Quadratic Program) solver

lis

Longest increasing subsequence algorithm

conshash

A library to do consistent hashing in Rust

count_sort

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

governor

A rate-limiting implementation in Rust

beehave

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

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

eudex

A blazingly fast phonetic reduction/hashing algorithm

simplers_optimization

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

apodize

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

nats-types

Enumerations and types for representing NATS protocol messages

sfmt

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

bibicode

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

str-distance

Distance metrics to evaluate distances between strings

nhl-stats

NHL Stats API client for Rust created using openapi-generator

const-random-macro

Provides the procedural macro used by const-random

bufferpool

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

darwin-rs

Evolutionary algorithms library written in Rust

iter-set

Set operations on sorted, deduplicated iterators

bsa3-hash

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

algebraics

algebraic numbers library

lonlat_bng

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

rs_algo

Common sorting algorithms and other common computer science algorithms

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

alass-core

Automatic Language-Agnostic Subtitle Synchronization (Library)

merging-iterator

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

tdigest

T-Digest algorithm in Rust

introsort

Fast sorting compatible with #[no_std]. Also has (optional) support for efficient and robust sorting of floating point numbers. Currently, introsort only builds on nightly

friedrich

Gaussian Process Regression

pdqsort

Pattern-defeating quicksort

twofloat

Double-double arithmetic functionality

aliasmethod

Implementation of Walker’s Alias method

gear

Collision avoidance path planning for robotics

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…

matfile-ndarray

Utility library to convert between matfile and ndarray array formats

multistream-batch

Different types and implementations of batching algorithms

rustlex_fsa

Library for manipulating (deterministic) finite automata

human-sort

Human sort (natural sort) implementation

moving_min_max

Tracking minimum or maximum of sliding windows

rusted_list

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

indexed_bitvec

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

rvs-parser

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

rdp

An FFI wrapper for the Ramer–Douglas–Peucker and Visvalingam-Whyatt algorithms

dia-range

Ranges for all integers

graphene

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

voracious_radix_sort

Very fast radix sort for all Rust primitive types and struct (except Array and tuple)

midas_rs

Rust lib port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)

names

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

srand

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

spatium

Spatium. Calc distance between sequences.

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

order-stat

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

kahan

Provides types to perform Kahan summation

baseperm

A tool for generating valid permutations of encoded inputs

ffts

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

coord_transforms

A Rust crate use for performing coordinate transformations

robust

Robust predicates for computational geometry

levenberg-marquardt

Levenberg-Marquardt algorithm built on top of nalgebra

scottish_names

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

geo-visibility

Compute visibility polygon

weighted-rs

A libray for weighted balancing algorithm

zhang_hilbert

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

sortrs

An introspective sort implementation

rootfind

Root-finding algorithms

algorithmica

Rust Algorithms

galois_2p8

Basic Arithmetic over all GF(2^8) fields

rdx

A collection of traits and algorithms to ease using radix sorts

macro_machine

State machine generator using macros

mecs

An ecs library with a focus on iteration performance

thin-slice

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

subslice

Fast subslice search

just-argon2

Bindings to the argon2 C 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

uniset

A hierarchical, growable bit set with support for in-place atomic operations

dary

This crate provides double-array construction and search functions

block-array-cow

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

acacia

A spatial partitioning and tree library

sorting

The world’s best, finest and inefficient sorting algorithms

fractal

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

streaming_algorithms

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

labelgraph

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

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.

rust-algorithm

algorithm

permu-rs

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

count-min-sketch

Count-min-sketch implementation

clusterphobia

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

every-range

Iterator for interleaving included and excluded ranges

rtriangulate

Delaunay triangulation on a set of points

munkres

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

ingrid

Dynamic two-dimensional arrays with algorithms

wookong-solo

Wookong Solo driver crate

IntegerScaling

Calculates integer ratios for pixel-perfect image upscaling with optional aspect-ratio correction

random_color

Rust crate for generating random attractive colors

aristeia

An evolutionary computation library

xorshift

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

accurate

(more or less) accurate floating point algorithms

bigbit

Implements the BigBig format, allowing for compact storage of arbitrarily large numbers

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.

cv-core

Contains core primitives used in computer vision applications

quasirandom

Quasirandom number generation

phreak_engine

Rule matching algorithm focussed on speed

razor-chase

razor-chase implements a variation of The Chase algorithm to find models for theories in geometric form

xbar

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

cdivsufsort

Rust bindings for Yuta Mori’s divsufsort

random-trait

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

kendalls

Kendall’s tau rank correlation

random-integer

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

ranges

TODO

addchain

Generate addition chains

hnsw_rs

Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin

hashed-permutation

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

mersenne_twister

Mersenne Twister pseudorandom number generator

opencv-ros-camera

Geometric models of OpenCV/ROS cameras for photogrammetry

rand_chacha

ChaCha random number generator

mix-distribution

Mixture distributions

fuss

Small, lightweight simplex noise generator for Rust

generic_levenshtein

Generic and fast implementation of the Levenshtein distance

suffix_array

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

debtsolver

Track and settle debts between parties with the fewest transactions

radixal

Digits iteration for unsigned integer types

py_pathfinding

A* and Jump-Point-Search algorithms using ndarray which makes them easy to use via pyo3 in Python

geos-sys

GEOS C API bindings

quicksort

A quicksort implementation for in-place sorting

dedup_signature

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

isochronous_finite_fields

Isochronous implementation of GF(2^8) arithmetic

revonet

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

numlib

A simple numerical library implementing common numberical algorithms in rust

fxtypemap

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

geo-raycasting

Ray Casting algorithm for the geo crate

sortnet

Sorting Networks for Rust

number_traits

number traits

delaunay2d

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

highwayhash

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

partitions

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

wyhash

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

sorty

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

forge_hasher

The rust language implementation of forge_hasher

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

fera

An aggregation of algorithms, data structures and supporting crates

xorshift128plus-rs

A simple implementation of the XorShift128+ pseudorandom number generator 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!

bcmp

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

blackbox

Optimize blackbox functions, suitable for hyperparameter optimization

rtt

Rapidly-Exploring random trees path planning algorithm

noisy

A procedural noise generation library written for Rust

livesplit-title-abbreviations

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

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

tilecover

Generate the minimum number of tiles to cover a geometry

haikunator

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

random_choice

Chooses samples randomly by their weights/probabilities

maglev

Maglev - Google’s consistent hashing algorithm

git-release-name

A simple library for turning git shas into release names

lcs-diff

Compute differences between two slices using LCS algorithm

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…

dynalock

A lease based distributed locking algorithm with support for DynamoDB

rosalind

Crate contains solutions of problems published on Rosalind.info

randomkit

numpy.random for Rust

rjq

Redis job queue

arrsac

From the paper “A Comparative Analysis of RANSAC Techniques Leading to Adaptive Real-Time Random Sample Consensus”

extfsm

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

pack

Solver for packing puzzle

yyid

YYID generator (random tokens like UUIDv4)

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.

permutation

Small utility for creating, manipulating, and applying permutations

cplex-sys

Low level bindings to the Cplex C-API

modulo

Simple modulo operation

kmp

Various functions using the Knuth–Morris–Pratt algorithm to efficiently find patterns

partition

partition slices in-place by a predicate

audiograph

An audio graph optimised for performance and limiting runtime allocations

reachability_solver

A linear reachability solver for directional edges

gut

Geometry utilities: storing, manipulating and processing geometries

needle

Fast search functions for finding things in Strings, Arrays and iterators

libblockchain

A Blockchain implementation

sdbm

SDBM is a non-cryptographic hashing algorithm

oqs

Bindings for Open Quantum Safe, a library for quantum-resistant cryptographic algorithms

adversarial_search

Rust adversarial search library

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

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

t1ha

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

scs-rs

Bindings to the SCS convex optimization solver

honestintervals

Comprehensive, correctly rounding interval arithmetic library

smoothed_z_score

Smoothed z-score algo (very robust thresholding algorithm)

pruefung

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

spmc_buffer

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

rustgraphblas

Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector

lz_fnv

Fowler-Noll-Vo hash functions for various integer types

smeagol

Conway’s Game of Life using HashLife and SIMD

hyparview

A Rust implementation of HyParView algorithm

const-linear

A Rust linear algebra library based on const generics

hungarian

A simple, fast implementation of the Hungarian (Kuhn-Munkres) algorithm

icub3d_combinatorics

A collection of combinatorics utilities

numext-constructor

Fixed-size uint and hash constructor

geo-clipper

Boolean operations on polygons

onemax-oxigen

OneMax simple problem resolution using oxigen

delaunator

A very fast 2D Delaunay triangulation library

md6

Implementation of the MD6 hash function for Rust via FFI

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

cycle-sort

Simple generic Cycle sort implementation

arborist

A surgical tool for interacting with binary trees

itemops

Provides some operations on items of slices

non-dominated-sort

Fast Non-Dominated Sort Algorithm

censor

A simple text profanity filter

tars

A Rust library providing useful technical indicators

msws

Middle Square Weyl Sequence pseudorandom number generator

crc64fast

SIMD accelerated CRC64 calculation

endicon

Implementations of codicon traits for endianness encodings

rand04_compat

Wrappers for compatibility with rand 0.4

raft-proto

Protocol definitions for the rust language implementation of the Raft algorithm

checksum

Calculates crc32/crc64 file checksums written in Rust

slot_generator

Efficiently generate and reclaim slot IDs from a numerical range

sorted-collections

A library providing useful extension traits and convenience methods for ordered collections in Rust. NOTE: This library is not currently in active development, and much of the functionality…

checked_int_cast

Conversions between primitive integers with overflow and underflow checking

sorts

A collection of sorting algorithms

park-miller-carta-prng

An efficient Pseudo-Random Number Generator

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

streamlined-ntru-prime

Rust implementation of the Streamline NTRU Prime algorithm

r-fairdist

Fair Resource Distribution Algorithm

trassel

Unique ID integers that scale

geojson-antimeridian-cut

Cuts GeoJSON Objects according to RFC 7946 § 3.1.9

kmpsearch

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

tiamat

a PRNG library

ntru

Implementation of the NTRUEncrypt algorithm. Interface to libntru.

sift4

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

differential-evolution

Simple and powerful global optimization using a self-adapting differential evolution

sfcgal

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

cpu-freq

Get CPU frequency information

cauchy

Trait for real and complex numbers

dft

The package provides an algorithm to compute the discrete Fourier transform

faiss-sys

Native bindings for Faiss

astar

A generic implementation of the A* pathfinding algorithm

sharpen

A rust library for iterator element condensing and sharpening

gray-codes

Iterators over binary Gray codes; utilities for efficiently visiting all subsets of a collection

index-fixed

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

humanesort

A crate for sorting the way humans would

fastcmp

A fast byte slice comparison library

rvs-c-api

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

bgjk

Boolean Gilbert-Johnson-Keerthi algorithm for determining if convex hull volumes intersect

aviary

Aviary bird combinators for Rust

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

crc24

CRC-24 implementation (IETF RFC2440-compatible)

abstractgraph

Abstract Graph Algorithms

co_sort

Sort arrays given a permutation

spiral

Iterate over a 2D structure in a spiral pattern

polystem

Popular stemming algorithms for Information Retrieval

small-ord-set

A set data-structure represented by a sorted SmallVec

plumtree

A Rust implementation of Plumtree algorithm

consistent-rs

Consistent hash package for Rust

broadword

Broadword algorithms

icub3d_sudoku_solver

A sudoku solver

geometry-predicates

rdxsort

Fast Radix Sort

lttb

An implementation of the Largest Triangle Three Buckets algorithm

quadtree_rs

Point/region Quadtree with support for overlapping regions

optimization

Collection of optimization algorithms

qht

Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc

scarecrow

A neural network library

estahr

A string distance and hashing library

rustfft

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

prefix_sum

An implementation of the prefix sum data structure

machinebox

A client SDK for communicating with machinebox boxes

adjective_adjective_animal

A library to generate suitably random and reasonably unique human readable (and fairly adorable) ids, ala GiphyCat

endian-hasher

Endianness wrapper for Hashers

rijksdriehoek

Convert coordinates between rijksdriehoek and wgs84

bigwise

Bitwise operations on fixed-size, arbitrary big buffer of bytes

batsat

Extensible SAT solver in Rust

quick_sort

In place quick sort

dsar

Data Structures & Algorithms in Rust

redblackbst

Rust Algorithms

exrng

RNG crate with lan features but using external RNG source

textnonce

Text based random nonce generator

prng

pseudo random number generator

xoroshiro

Xoroshiro128+, xorshift1024*φ and splitmix64 random number generators

idalloc

A library for different methods of allocating unique identifiers efficiently

collect_slice

Collect an iterator into a slice

unordered-hash

Hashes a set of items independent of their ordering

num-cmp

Comparison between differently typed numbers

atomic-traits

The traits for generic atomic operations

where39

rust implementation of the where39 geo location encoding standard

phreak_facts

Rule matching algorithm focussed on speed

rand_isaac

ISAAC random number generator

wuf

A fast weighted implementation to the union-find problem with path compression

aud

A minimal implementation of Sagas

grue

Various tools and algorithms for building role-playing and adventure games

bubble-sort

A quick and non-optimized, cloning version of the bubble sort algorithm. Created as a showcase for publishing crates in the Rust Cookbook 2018

succinct_vec

A Vec-like datastructure with less memory overhead

nuban_rust

A validator and generator of Nigerian Uniform Bank Account Number(NUBAN)

llrb-index

Left Leaning Red Black index

ordslice

Extensions for ordered slices

crc32c-hw

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

seal

Implementation of Needleman-Wunsch & Smith-Waterman sequence alignment

ipopt-sys

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

handletree-rs

Helps you implement handle-based APIs

advancedresearch-hypo

Automatic hypothesis testing

triangulation

A collection of triangulation algorithms

dlx

An implementation of Knuth’s ‘Dancing Links’ algorithm for solving exact cover problems

fuzzy-filter

A fast implementation (O(n)) of fuzzy-filtering

largest-remainder-method