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

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.

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

fst

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

adler32

Minimal Adler32 implementation for Rust

rand_chacha

ChaCha random number generator

fake

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

ratelimit_meter

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

alphanumeric-sort

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

md5

The package provides the MD5 hash function

rdrand

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

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…

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

oorandom

A tiny, robust PRNG implementation

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

noise

Procedural noise generation library

highway

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

passwords

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

radiate

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

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.

triple_buffer

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

ncollide2d

2 and 3-dimensional collision detection library in Rust

nanoid

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

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

whatlang

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

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

out

Provides fast min and max functionality for collections

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…

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

vek

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

k

k is for kinematics

vpsearch

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

probability

The package provides a probability-theory toolbox

rand_jitter

Random number generator based on timing jitter

fastrand

A simple random number generator

rand_regex

Generates random strings and byte strings matching a regex

crc32c

Safe implementation for SSE 4.2 CRC32C instructions, with software fallback

metrohash

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

counting_sort

Counting sort implementation for Iterators

quantiles

a collection of approximate quantile algorithms

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

wyhash

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

strength_reduce

Faster integer division and modulus operations

streaming-stats

Experimental crate for computing basic statistics on streams

zipf

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

sdset

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

rust-lapper

A fast and easy interval overlap library

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

worley-noise

Worley noise implementation

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

acacia

A spatial partitioning and tree library

hnsw

Fast approximate nearest neighbors

vrf

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

cam-geom

Geometric models of cameras for photogrammetry

treediff

Find the difference between arbitrary data structures

bao

a general-purpose cryptographic tree 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…

poi

A pragmatic point-free theorem prover assistant

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

convert-base

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

rsgenetic

A library providing genetic algorithm execution

boyer-moore-magiclen

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

dissimilar

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

nonogrid

Efficient nonogram solver

is_sorted

Is an Iterator sorted?

fuzzyhash

Pure Rust fuzzy hash implementation

jubjub

Implementation of the Jubjub elliptic curve group

dasp_interpolate

An abstraction for audio PCM DSP rate interpolation, including floor, linear and sinc

cauchy

Trait for real and complex numbers

flo_curves

Library for manipulating Bezier curves

test-data-generation

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

rust-3d

2D/3D library written in rust

safe-mix

Implementation of the Collective Coin Flip algorithm

cdshealpix

Rust implementation of the HEALPix tesselation

ddo

DDO a generic and efficient framework for MDD-based optimization

numext-fixed-uint

Fixed-size uint types

bitintr

Portable Bit Manipulation Intrinsics

triple_accel

Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.

hungarian

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

mop

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

extendhash

Rust Hash Extender

xoroshiro128

Fast psuedo-random number generators

rs-graph

A library for graph algorithms and combinatorial optimization

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

eddie

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

zvxryb-broadphase

A broadphase collision detection library

simsearch

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

baseperm

A tool for generating valid permutations of encoded inputs

filter

Kalman filters and other optimal and non-optimal estimation filters in Rust

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

algos

A collection of algorithms in Rust

muldiv

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

random-pick

Pick an element from a slice randomly by given weights

streaming_algorithms

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

levenberg-marquardt

Levenberg-Marquardt algorithm built on top of nalgebra

leaky-bucket

Futures-aware rate limiter implementation

timely_sort

Sorting infrastructure for timely dataflow

pikkr

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

hybrid-clocks

Hybrid Logical Clocks

pos_pso

Particle Swarm Optimizer

afsort

American Flag sort implementation for faster sorting of Strings

natord

Natural ordering for Rust

nqueens-oxigen

N Queens problem resolution using oxigen

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

diffr-lib

An implementation of Myers diff algorithm

multistream-batch

Implementations of batching algorithms

programinduction

A library for program induction and learning representations

fallible-iterator

Fallible iterator traits

easy_reader

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

glicko2

Implementation of the glicko2 rating system

sublime_fuzzy

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

gut

Geometry utilities: storing, manipulating and processing geometries

slice-group-by

Iterators over groups in a slice

optimization

Collection of optimization algorithms

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…

wildmatch

Simple string matching with questionmark and star wildcard operator

xorf

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

akaze

AKAZE feature extraction algorithm for computer vision

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

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.

superslice

Extensions for slices

punkt

An implementation of a Punkt sentence tokenizer

detect-lang

Language detection given paths and extensions

fakeit

Fake data generator library with 130+ functions

crc16

A CRC16 implementation

special

The package provides special functions

external_sort

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

meowhash

Meow hash function

diffus-derive

Finds the difference between two instances of any data structure. Supports derive on structs and enums.

microfft

Embedded-friendly Fast Fourier Transforms

astro

Advanced algorithms for astronomy

gear

Collision avoidance path planning for robotics

extsort

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

zeros

Extensions for hashing crates

startin

A Delaunay triangulator for terrains

levenshtein

Levenshtein algorithm

permutation_iterator

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

crc64fast

SIMD accelerated CRC64 calculation

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

suffix_array

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

hypernonsense

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

codebreaker

Decrypt & encrypt any cheat code for CodeBreaker PS2

gcd

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

rand_mt

Reference Mersenne Twister random number generators

hashers

A collection of non-cryptographic hashing algorithms for Rust

median

An implementation of an efficient O(n) median filter

vrp-pragmatic

An extension logic for solving rich VRP

governor

A rate-limiting implementation in Rust

ncollide3d

2 and 3-dimensional collision detection library in Rust

qptrie

A QP-Trie implementation for Rust

linear_solver

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

adler

A simple clean-room implementation of the Adler-32 checksum

traversal

Generic and lazy tree traversal algorithms

halton

A module for generating Halton sequences

sorts

A collection of sorting algorithms

moving_min_max

Tracking minimum or maximum of sliding windows

twofloat

Double-double arithmetic functionality

faiss

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

petal-neighbors

Nearest neighbor search algorithms including a ball tree and a vantage point tree

flat_spatial

Flat spatial partitionning algorithms and data structures

raftlog

An implementation of distributed replicated log based on the Raft algorithm

simple_gaussian

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

pso

Particle Swarm Optimizer

bigbit

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

qframework

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

tailcall

Safe, zero-cost tail recursion

unbounded-interval-tree

An interval tree working with inclusive/exclusive bounds, as well as unbounded intervals. Provides helpers to fetch overlapping intervals, and difference of intervals.

color-thief

Grabs the dominant color or a representative color palette from an image

newton_rootfinder

Newton based methods for root finding

sobol

A Sobol sequence generator for Rust

conshash

A library to do consistent hashing in Rust

vsprintf

Rust bindings to the libc vsprintf function

toolbox

Simple tools for daily use

const-random-macro

Provides the procedural macro used by const-random

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

eudex

A blazingly fast phonetic reduction/hashing algorithm

darwin-rs

Evolutionary algorithms library written in Rust

float_next_after

A trait for native rust f64/f32 nextafter

gurobi

An unofficial Rust API for Gurobi optimizer

rendezvous_hash

An implementation of Rendezvous hashing algorithm

hilbert

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

vec-drain-where

alternative Vec::drain_filter impl

bidir-map

Bidirectional map implementation for Rust

radsort

Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)

spaces

Set/space primitives for defining machine learning problems

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

simplers_optimization

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

iter-set

Set operations on sorted, deduplicated iterators

vecshard

Split Vecs in constant time

beehave

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

permutohedron

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

bravery_router

Radix Tree implementation

sample_planning

Sample Based Planner

dia-range

Ranges for all integers

lonlat_bng

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

bls-signatures-rs

Open source implementation of Bonneh-Lynn-Shacham (BLS) signatures written in Rust

hotsax

An implementation of the HOTSAX and HOTSAX based discord discovery algorithms

bibicode

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

nats-types

Enumerations and types for representing NATS protocol messages

moodyblues-sdk

A tracer SDK for Overlord like consensus algorithm

lttb

An implementation of the Largest Triangle Three Buckets algorithm

md6

Implementation of the MD6 hash function for Rust via FFI

flo_binding

Declarative binding library for Rust

marching-squares

Parallelized marching squares algorithm for constructing closed isolines / contour lines

dusk-plonk

A pure-Rust implementation of the PLONK ZK-Proof algorithm

robust

Robust predicates for computational geometry

divisors

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

tdigest

T-Digest algorithm in Rust

friedrich

Gaussian Process Regression

loaded_dice

A simple sampler for loaded dices, implementing the alias method

apodize

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

rdp

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

algebraics

algebraic numbers library

names

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

rustlex_fsa

Library for manipulating (deterministic) finite automata

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

sample-consensus

Abstractions for sample consensus algorithms such as RANSAC

rusted_list

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

alass-core

Automatic Language-Agnostic Subtitle Synchronization (Library)

hashed-permutation

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

order-stat

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

phreak_engine

Rule matching algorithm focussed on speed

graphene

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

midas_rs

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

rstat

Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures

str-distance

Distance metrics to evaluate distances between strings

sub-strs

For finding sub strings

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

rvs-c-api

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

rs_algo

Common sorting algorithms and other common computer science algorithms

numext-fixed-hash

Fixed-size hash types

overlord

Overlord consensus procotol

extprim

Extra primitive types (u128, i128)

bufferpool

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

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

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…

tilecover

Generate the minimum number of tiles to cover a geometry

rootfind

Root-finding algorithms

batsat

Extensible SAT solver in Rust

lis

Longest increasing subsequence algorithm

IntegerScaling

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

hyperloglogplus

HyperLogLog implementations

raft

The rust language implementation of Raft 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…

human-sort

Human sort (natural sort) implementation

zhang_hilbert

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

galois_2p8

Basic Arithmetic over all GF(2^8) fields

rdx

A collection of traits and algorithms to ease using radix sorts

fletcher

An implementation of Fletcher’s Checksum algorithm in rust

sorted_intersection

Intersection Iterator Over Sorted Iterators

bsa3-hash

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

uniset

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

thin-slice

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

merging-iterator

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

uncertainty

A crate to allow the creation and arithmetic operations on numbers with uncertain values

block-array-cow

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

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

ff

Library for building and interfacing with finite fields

primecount

Rust wrapper for https://github.com/kimwalisch/primecount

rust-algorithm

algorithm

fractal

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

acap

As Close As Possible — nearest neighbor search in Rust

kddbscan

A k -Deviation Density Based Clustering Algorithm (kDDBSCAN)

count-min-sketch

Count-min-sketch implementation

aliasmethod

Implementation of Walker’s Alias method

permu-rs

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

rtriangulate

Delaunay triangulation on a set of points

algorithmica

Rust Algorithms

matfile-ndarray

Utility library to convert between matfile and ndarray array formats

hnsw_rs

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

voracious_radix_sort

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

spatium

Spatium. Calc distance between sequences.

coord_transforms

A Rust crate use for performing coordinate transformations

competitive-hpp

Competitive Programming Library for AtCoder with Rust

advancedresearch-tree_mem_sort

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

petal-decomposition

Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)

subslice

Fast subslice search

accurate

(more or less) accurate floating point algorithms

srand

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

indexed_bitvec

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

quadtree-f32

Simple, dependency-free ID-based quadtree

rast

A toy implementation of the raft consistency protocol focused on speed

geo-clipper

Boolean operations on polygons

kahan

Provides types to perform Kahan summation

count_sort

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

quasirandom

Quasirandom number generation

xorshift

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

crcxx

universal slice-by-4/8/16/32 implementation of CRC-8/16/32/64 algorithms

just-argon2

Bindings to the argon2 C library

cv-core

Contains core primitives used in computer vision applications

random_color

Rust crate for generating random attractive colors

qrs_detector

Realtime ECG QRS detector algorithm

yz-nomstr

A simple escaped string literal parser using nom

bip_dht

Implementation of the bittorrent mainline DHT

ingrid

Dynamic two-dimensional arrays with algorithms

every-range

Iterator for interleaving included and excluded ranges

weighted-rs

A libray for weighted balancing algorithm

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.

triangular

A Delauney triangulation library

cdivsufsort

Rust bindings for Yuta Mori’s divsufsort

concorde

reconfigurable lattice agreement

sorting

The world’s best, finest and inefficient sorting algorithms

ffts

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

fuss

Small, lightweight simplex noise generator for Rust

py_pathfinding

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

opencv-ros-camera

Geometric models of OpenCV/ROS cameras for photogrammetry

dedup_signature

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

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

mersenne_twister

Mersenne Twister pseudorandom number generator

revonet

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

blake

Implementation of the BLAKE hash function for Rust via FFI

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

xbar

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

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.

aristeia

An evolutionary computation library

rustmt

A MT19937 PRNG implementation for rust

wookong-solo

Wookong Solo driver crate

clusterphobia

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

xorshift128plus-rs

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

delaunay2d

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

highwayhash

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

sfmt

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

sortrs

An introspective sort implementation

rand_pcg

Selected PCG random number generators

rust-string-random

easy to use random string generator

pack

Solver for packing puzzle

geo-normalized

A trait for producing a normalized Polygon/Multipolygon according to OCG winding rules

sorty

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

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

fast_inv_sqrt

Fast inverse square root algorithm implementation

seqdiff

Diff between two sequences

sainte_lague

Sainte-Laguë method for seat distribution used in multiple parliamentary elections all over the world

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!

labelgraph

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

raftlog_protobuf

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

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.

razor-chase

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

munkres

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

vrp-scientific

An extension logic for solving scientific VRP

grp_api

API for crate grp 0.1.0

bcmp

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

rtt

Rapidly-Exploring random trees path planning algorithm

noisy

A procedural noise generation library written for Rust

addchain

Generate addition chains

livesplit-title-abbreviations

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

permutation

Small utility for creating, manipulating, and applying permutations

mix-distribution

Mixture distributions

haikunator

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

algs4

Algorithms, 4ed. MOOC in Coursera. in Rust.

random-trait

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

arborist

A surgical tool for interacting with binary trees

dary

This crate provides double-array construction and search functions

dynalock

A lease based distributed locking algorithm with support for DynamoDB

xxh

XXHash algorithm implementation for Rust

adskalman

Kalman filter and Rauch-Tung-Striebel smoothing implementation using nalgebra, no_std

forge_hasher

The rust language implementation of forge_hasher

extfsm

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

rjq

Redis job queue

rosalind

Crate contains solutions of problems published on Rosalind.info

ai_kit

Collection of classic AI algorithms with convenient interfaces

multistochgrad

Stochastic Gradient, Multithreaded

pdqsort

Pattern-defeating quicksort

fxtypemap

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

reingold-tilford

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

partition

partition slices in-place by a predicate

git-release-name

A simple library for turning git shas into release names

phpass

PHPass, the WordPress password hasher, re-implemented in rust

nlsn-delaunay

Delaunay Triangulation and Refinement implementation through Bowyer Watson incremental insertion, conflict maps and ghost vertices

needle

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

rand04_compat

Wrappers for compatibility with rand 0.4

mecs

An ecs library with a focus on iteration performance

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

libblockchain

A Blockchain implementation

modulo

Simple modulo operation

radixal

Digits iteration for unsigned integer types

oqs

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

cplex-sys

Low level bindings to the Cplex C-API

t1ha

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

quickbacktrack

Library for back tracking with customizable search for moves

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

fera

An aggregation of algorithms, data structures and supporting crates

honestintervals

Comprehensive, correctly rounding interval arithmetic library

smoothed_z_score

Smoothed z-score algo (very robust thresholding algorithm)

geos-sys

GEOS C API bindings

numlib

A simple numerical library implementing common numberical algorithms in rust

kendalls

Kendall’s tau rank correlation

lz_fnv

Fowler-Noll-Vo hash functions for various integer types

maglev

Maglev - Google’s consistent hashing algorithm

geo-raycasting

Ray Casting algorithm for the geo crate

nblast

Implementation of NBLAST neurite similarity algorithm

randomkit

numpy.random for Rust

random_choice

Chooses samples randomly by their weights/probabilities

rs_lockfree

a lock-Free lib based on practical Hazard Pointers algorithm

rustgraphblas

Wrapper for GraphBLAS.h exposing SparseMatrix and SparseVector

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

debtsolver

Track and settle debts between parties with the fewest transactions

cycle-sort

Simple generic Cycle sort implementation

checked_int_cast

Conversions between primitive integers with overflow and underflow checking

spmc_buffer

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

generic_levenshtein

Generic and fast implementation of the Levenshtein distance

crc24

CRC-24 implementation (IETF RFC2440-compatible)

tars

A Rust library providing useful technical indicators

raft4rs

Rust impl for raft

blackbox

Optimize blackbox functions, suitable for hyperparameter optimization

streamlined-ntru-prime

Rust implementation of the Streamline NTRU Prime algorithm

lcs-diff

Compute differences between two slices using LCS algorithm

geometry-predicates

fastcmp

A fast byte slice comparison library

smeagol

Conway’s Game of Life using HashLife and SIMD

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

xxhrs

Safe XXHash and XXH3 bindings

enso-shapely

Automated typeclass derivation

faiss-sys

Native bindings for Faiss

audiograph

An audio graph optimised for performance and limiting runtime allocations

koper

The koper project

trassel

Unique ID integers that scale

humanesort

A crate for sorting the way humans would

kmpsearch

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

slippy_map_tilenames

Converts lon/lat coordinates to slippy map tile format (OpenStreetMap/Google Map format)

tiamat

a PRNG library

plumtree

A Rust implementation of Plumtree algorithm

itemops

Provides some operations on items of slices

park-miller-carta-prng

An efficient Pseudo-Random Number Generator

differential-evolution

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

sdbm

SDBM is a non-cryptographic hashing algorithm

ntru

Implementation of the NTRUEncrypt algorithm. Interface to libntru.

spiral

Iterate over a 2D structure in a spiral pattern

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.

ecos-rs

Bindings to the ECOS convex second-order cone program solver

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…

delaunator

A very fast 2D Delaunay triangulation library

partitions

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

quadtree_rs

Point/region Quadtree with support for overlapping regions

adversarial_search

Rust adversarial search library

rustfft

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

prng

pseudo random number generator

psacak

The pSACAK suffix sorting algorithm for huge in-memory data on multicore machines

gray-codes

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

abc

An implementation of Karaboga’s Artificial Bee Colony algorithm

tinysort

The lowest memory footprint sorting algorithm

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…

astar

A generic implementation of the A* pathfinding algorithm

aviary

Aviary bird combinators for Rust

endicon

Implementations of codicon traits for endianness encodings