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

rand_core

Core random number generator traits and tools for implementation

crc

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

num-bigint

Big integer implementation for Rust

rand_jitter

Random number generator based on timing jitter

pathfinding

Pathfinding, flow, and graph algorithms

md5

The package provides the MD5 hash function

geos

Rust bindings for GEOS C API

bytecount

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

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

extprim

Extra primitive types (u128, i128)

twox-hash

A Rust implementation of the XXHash algorithm

fst

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

number_prefix

Library for formatting numeric prefixes: kilo, giga, kibi

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

geo

Geospatial primitives and algorithms

rand_pcg

Selected PCG random number generators

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

whatlang

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

rustfft

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

rand_os

OS backed Random Number Generator

triple_buffer

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

lazysort

Lazy sorting for iterators

raft

The rust language implementation of Raft algorithm

rsgenetic

A library providing genetic algorithm execution

decorum

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

ncollide3d

2 and 3-dimensional collision detection library in Rust

quantiles

a collection of approximate quantile algorithms

ratelimit_meter

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

ncollide2d

2 and 3-dimensional collision detection library in Rust

primal-sieve

A high performance prime sieve

rand_xorshift

Xorshift random number generator

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

bigdecimal

Arbitrary percision decimal numbers

metrohash

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

rdrand

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

numext-fixed-uint

Fixed-size uint types

twoway

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

probability

The package provides a probability-theory toolbox

out

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

permutator

Get a lexicographic cartesian product and lexicographic permutation at any specific index from data. Generate complete lexicographic cartesian product from single or multiple set of data. Generate complete lexicographic combination from data. Generate non-lexicographic permutation and k-permutation.

numext-fixed-hash

Fixed-size hash types

adler32

Minimal Adler32 implementation for Rust

numext-constructor

Fixed-size uint and hash constructor

rand_chacha

ChaCha random number generator

punkt

An implementation of a Punkt sentence tokenizer

rand_isaac

ISAAC random number generator

argonautica

Idiomatic Argon2 password hashing for Rust

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

geo-types

Geospatial primitive data types

flo_binding

Declarative binding library for Rust

elasticlunr-rs

A partial port of elasticlunr.js to Rust

afsort

American Flag sort implementation for faster sorting of Strings

criterion-stats

Criterion’s statistics library

is_sorted

Is an Iterator sorted?

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

streaming-stats

Experimental crate for computing basic statistics on streams

hashmap_core

Implementation of HashMap and HashSet for no_std environments

ipopt

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

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

noise

Procedural noise generation library

vpsearch

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

meval

A simple math expression parser and evaluator

programinduction

A library for program induction and learning representations

roots

Library of well known algorithms for numerical root finding

crc16

A CRC16 implementation

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

basic_dsp

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

sdset

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

staccato

Statistics from the command line

zipf

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

k

k is for kinematics

special

The package provides special functions

basic_dsp_interop

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

num-bigint-dig

Big integer implementation for Rust

basic_dsp_matrix

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

crc-any

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

highway

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

worley-noise

Worley noise implementation

collider

A library for continuous 2D collision detection for game developement

linear_solver

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

cdshealpix

Rust implementation of the HEALPix tesselation

optimization_engine

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

num

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

usher

Parameterized routing for generic resources in Rust

alphanumeric-sort

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

polylabel

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

passwords

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

specialized-div-rem

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

levenshtein

Levenshtein algorithm

slice-group-by

Iterators over groups in a slice

sublime_fuzzy

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

pikkr

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

random-pick

Pick an element from a slice randomly by given weights

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

randomize

A dead simple to use randomization library for rust

geohash

Geohash implementation for Rust

rustdct

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

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

bibicode

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

convert-base

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

automata

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

pihex

Arbitrary place hexadecimal digits viewer of pi written in Rust

hashers

A collection of non-cryptographic hashing algorithms for Rust

permutohedron

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

rs-graph

A library for graph algorithms and combinatorial optimization

faiss

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

mathru

Simple mathematics library written in Rust

fxhash

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

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein 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) is not used. This value can then be used to mark frame boundaries in a serial communication channel.

maths-traits

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

zhang_hilbert

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

qptrie

A QP-Trie implementation for Rust

astro

Advanced algorithms for astronomy

bitintr

Portable Bit Manipulation Intrinsics

hime_redist

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

aristeia

An evolutionary computation library

gear

Collision avoidance path planning for robotics

rs_algo

Common sorting algorithms and other common computer science algorithms

cellular_maps

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

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

rustfst

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

chfft

Fastest Fourier Transform library implemented with pure Rust

statistical

A simple statistics library

coord_transforms

A Rust crate use for performing coordinate transformations

graphene

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

vecshard

Split Vecs in constant time

superslice

Extensions for slices

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.

boyer-moore-magiclen

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

easy_reader

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

munkres

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

raftlog

An implementation of distributed replicated log based on the Raft algorithm

normalize-line-endings

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

axgeom

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

spmc_buffer

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

ipopt-sys

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

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.

subslice

Fast subslice search

symbolic_polynomials

A library for manipulation of polynomials over the integers

simsearch

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

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

strength_reduce

Faster integer division and modulus operations

smeagol

Conway’s Game of Life using HashLife and SIMD

test-data-generation

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

streamlined-ntru-prime

Rust implementation of the Streamline NTRU Prime algorithm

bidir-map

Bidirectional map implementation for Rust

bft-core

An efficient and stable Rust library of BFT core for distributed system

timely_sort

Sorting infrastructure for timely dataflow

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

indexed_bitvec_core

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

xbar

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

indexed_bitvec

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

random_color

Rust crate for generating random attractive colors

random-integer

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

escape_string

Very efficiently parse backslash-escaped strings

genevo

genevo provides building blocks to run simulations of optimization and search problems using genetic algorithms (GA). Execute genetic algorithm (GA) simulations in a customizable and extensible way

geometry-predicates

vrf

An implementation of Verifiable Random Functions (VRFs)

eudex

A blazingly fast phonetic reduction/hashing algorithm

galois_2p8

Basic Arithmetic over all GF(2^8) fields

darwin-rs

Evolutionary algorithms library written in Rust

treediff

Find the difference between arbitrary data structures

plumcast

A message broadcasting library based on the Plumtree/HyParView algorithms

graph-neighbor-matching

Graph similarity score using neighbor matching

fuss

Small, lightweight simplex noise generator for Rust

rtriangulate

Delaunay triangulation on a set of points

cassowary

A Rust implementation of the Cassowary linear constraint solving algorithm. The Cassowary algorithm is designed for naturally laying out user interfaces using linear constraints, like ‘this button must line up with this text box’

quadtree_rs

Point/region Quadtree with support for overlapping regions

flo_curves

Library for manipulating Bezier curves

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

mop

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

solvent

Dependency Resolver library

fuzzyhash

Pure Rust fuzzy hash implementation

graphplan

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

dummy

Type oriented fake data generation

flag-algebra

An implementation of Razborov’s flag algebras

rustlex_fsa

Library for manipulating (deterministic) finite automata

howto

instant coding answers via the command line

natural

Pure rust library for natural language processing

beehave

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

tilecover

Generate the minimum number of tiles to cover a geometry

rdp

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

rvs

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

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

count_sort

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

natord

Natural ordering for Rust

monotonic_solver

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

dedup_signature

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

gcd

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

labelgraph

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

line_drawing

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

pdqsort

Pattern-defeating quicksort

contrail

Simple state restoration for backtracking search algorithms using a trail

vek

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

fasthash-sys

A suite of non-cryptographic hash functions for Rust

osqp

The OSQP (Operator Splitting Quadratic Program) solver

cubic_spline

Function that calculates curve points for cubic spline

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

external_sort

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

quasirandom

Quasirandom number generation

spiral

Iterate over a 2D structure in a spiral pattern

tic

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

reingold-tilford

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

specs_scene_graph

scene graph for specs

human-sort

Human sort (natural sort) implementation

dft

The package provides an algorithm to compute the discrete Fourier transform

wyhash

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

startin

A Delaunay triangulator for terrain data

extfsm

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

livesplit-title-abbreviations

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

sortrs

An introspective sort implementation

acacia

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

co_sort

Sort arrays given a permutation

rand_hc

HC128 random number generator

raftlog_protobuf

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

zpatial

Algorithms for Spatial Acceleration and Geometries

transpose

Utility for transposing multi-dimensional data

xorshift128plus-rs

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

cplex-sys

Low level bindings to the Cplex C-API

hyparview

A Rust implementation of HyParView algorithm

algos

A collection of algorithms in rust

qht

Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc

extsort

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

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

point_process

A crate for simulating random point processes

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

collenchyma-nn

collenchyma plugin providing Neural Network operations

common_macros

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

rootfind

Root-finding algorithms

count-min-sketch

Count-min-sketch implementation

bloodhound

Fuzzy file finder

kademlia-dht

A simple implementation of the Kademlia DHT

quickbacktrack

Library for back tracking with customizable search for moves

algoliasearch

Algolia client

spanish-numbers

Convert integers to written Spanish number format

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

crcdir

A thin wrapper around crc32fast to checksum an entire directory

bitreader

BitReader helps reading individual bits from a slice of bytes. You can read “unusual” numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer.

cang-jie

A Chinese tokenizer for tantivy

triangulation

A collection of triangulation algorithms

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

accurate

(more or less) accurate floating point algorithms

geos-sys

GEOS C API bindings

shine-graph

SHINE. Graph and sparse matrix module for the shine engine.

crc32c-hw

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

non-dominated-sort

Fast Non-Dominated Sort Algorithm

mix-distribution

Mixture distributions

block-array-cow

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

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

lzjd

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

cycle-sort

Simple generic Cycle sort implementation

t1ha

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

float-ord

A total ordering for floating-point numbers

exprtk_rs

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

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

ffts-sys

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

pack

Solver for packing puzzle

rand_regex

Generates random strings and byte strings matching a regex

bex

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

rendezvous_hash

An implementation of Rendezvous hashing algorithm

twox-hash-cli

A cli for the twox-hash crate

sift4

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

ssdeep

A Rust wrapper for ssdeep

zeros

Extensions for hashing crates

fera

An aggregation of algorithms, data structures and supporting crates

mersenne_twister

Mersenne Twister pseudorandom number generator

vec_arith

Powerful vector/matrix arithmetic library written in Rust

ffts

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

sorts

A collection of sorting algorithms

kmpsearch

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

cagra

Calculation Graph Library

nanoid

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

graphsearch

A simple graph search and representation library

flot

Generate HTML documents with embedded charts using Flot

r-fairdist

Fair Resource Distribution Algorithm

bip_dht

Implementation of the bittorrent mainline DHT

sdbm

SDBM is a non-cryptographic hashing algorithm

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

muldiv

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

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

algorithmica

Rust Algorithms

suffix_array

Suffix array construction and searching algorithms for in-memory binary data, focusing on space efficiency

sfmt

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

partitions

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

dia-range

Ranges for all integers

abstractgraph

Abstract Graph Algorithms

galil-seiferas

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

revonet

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

order-stat

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

rs-graph-derive

Automatic implementation of graph types

llrb-index

Left Leaning Red Black index

hyperbolic_graph_generator

Create different types of hyperbolic graphs

index-fixed

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

plumtree

A Rust implementation of Plumtree algorithm

rsalgo

A collection of some algorithms and data-structures

perlin

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

xxcalc

Embeddable or standalone robust floating-point polynomial calculator

largest-remainder-method

The largest remainder method

collect_slice

Collect an iterator into a slice

pruefung

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

xorshift

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

hwt

Hamming Weight Tree for finding neighbors in Hamming space

rstat

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

lcs-diff

Compute differences between two slices using LCS algorithm

pcg

A port of the PCG random number generation library

sfcgal

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

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. Take the boolean maze, a list of allowed directional moves, and entrance and exit and get Some(Vec<shortest_usized_index_of_direction_choices>).

checksum

Calculates crc32/crc64 file checksums written in Rust

conshash

A library to do consistent hashing in Rust

teia

A crate which implements persistent homology algorithm

integrators

Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators

scottish_names

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

glicko2

Implementation of the glicko2 rating system

merging-iterator

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

thin-slice

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

batsat

Extensible SAT solver in Rust

permutation

Small utility for creating, manipulating, and applying permutations

cuckoocache

High performance concurrent cache

delaunay2d

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

number_traits

number traits

highwayhash

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

yyid

YYID generator (random tokens like UUIDv4)

english-numbers

Convert integers to written English number format

faiss-sys

Native bindings for Faiss

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

haikunator

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

int_traits

Provides a trait for extended functions on integers

random_choice

Chooses samples randomly by their weights/probabilities

delaunator

A very fast 2D Delaunay triangulation library

sub-strs

For finding sub strings

sorty

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

fast_inv_sqrt

Fast inverse square root algorithm implementation

kurobako_solvers

A collection of black-box optimization solvers

bigint-base10

Experimental API for dealing with big integers in base-ten

algs4

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

rosalind

Crate contains solutions of problems published on Rosalind.info

lz_eytzinger_tree

An Eytzinger tree implementation, this is an N-tree implemented using array storage

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!

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

rjq

Redis job queue

fiz-math

Game & graphics math in two and three dimensions

names

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

djb33

DJB33 hash algorithm write in Rust

mcts

This is a library for Monte Carlo tree search

needle

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

dgraph-rs

Provides a client for the DGraph graph database