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

twox-hash

A Rust implementation of the XXHash algorithm

md5

The package provides the MD5 hash function

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

bytecount

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

geos

Rust bindings for GEOS C API

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

rand_xorshift

Xorshift random number generator

fake

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

extprim

Extra primitive types (u128, i128)

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

rand_pcg

Selected PCG random number generators

geo

Geospatial primitives and algorithms

elasticlunr-rs

A partial port of elasticlunr.js to Rust

rand_chacha

ChaCha random number generator

rand_isaac

ISAAC random number generator

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

rand_os

OS backed Random Number Generator

rustfft

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

raft

The rust language implementation of Raft algorithm

lazysort

Lazy sorting for iterators

triple_buffer

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

probability

The package provides a probability-theory toolbox

rsgenetic

A library providing genetic algorithm execution

rand_hc

HC128 random number generator

decorum

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

ncollide3d

2 and 3-dimensional collision detection library in Rust

ratelimit_meter

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

quantiles

a collection of approximate quantile algorithms

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.

ncollide2d

2 and 3-dimensional collision detection library in Rust

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

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

out

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

primal-sieve

A high performance prime sieve

programinduction

A library for program induction and learning representations

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.

whatlang

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

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.

highway

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

geo-types

Geospatial primitive data types

numext-constructor

Fixed-size uint and hash constructor

numext-fixed-hash

Fixed-size hash types

adler32

Minimal Adler32 implementation for Rust

punkt

An implementation of a Punkt sentence tokenizer

argonautica

Idiomatic Argon2 password hashing for Rust

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

flo_binding

Declarative binding library for Rust

k

k is for kinematics

afsort

American Flag sort implementation for faster sorting of Strings

is_sorted

Is an Iterator sorted?

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

bitintr

Portable Bit Manipulation Intrinsics

vpsearch

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

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

noise

Procedural noise generation library

meval

A simple math expression parser and evaluator

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.

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

sdset

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

crc16

A CRC16 implementation

staccato

Statistics from the command line

cdshealpix

Rust implementation of the HEALPix tesselation

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.

rdrand

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

num

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

worley-noise

Worley noise implementation

slice-group-by

Iterators over groups in a slice

linear_solver

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

collider

A library for continuous 2D collision detection for game developement

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

vrf

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

zipf

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

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

bibicode

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

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

levenshtein

Levenshtein algorithm

lumberjack

Read and modify constituency trees

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

geohash

Geohash implementation for Rust

sublime_fuzzy

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

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

strength_reduce

Faster integer division and modulus operations

external_sort

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

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

rs-graph

A library for graph algorithms and combinatorial optimization

rustdct

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

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

fxhash

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

mathru

Simple mathematics library written in Rust

gear

Collision avoidance path planning for robotics

permutohedron

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

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.

hashers

A collection of non-cryptographic hashing algorithms for Rust

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

faiss

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

qptrie

A QP-Trie implementation for Rust

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein automata

boyer-moore-magiclen

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

astro

Advanced algorithms for astronomy

hime_redist

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

aristeia

An evolutionary computation library

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

cellular_maps

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

rs_algo

Common sorting algorithms and other common computer science algorithms

rustfst

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

simsearch

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

trek-router

A flexible router for RESTful APIs

statistical

A simple statistics library

coord_transforms

A Rust crate use for performing coordinate transformations

chfft

Fastest Fourier Transform library implemented with pure Rust

vecshard

Split Vecs in constant time

graphene

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

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.

munkres

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

superslice

Extensions for slices

raftlog

An implementation of distributed replicated log based on the Raft algorithm

easy_reader

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

axgeom

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

ipopt-sys

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

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

vek

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

spmc_buffer

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

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

bidir-map

Bidirectional map implementation for Rust

specs_scene_graph

scene graph for specs

timely_sort

Sorting infrastructure for timely dataflow

modtype

Macros that implement modular arithmetic integer types

bft-core

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

cubic_spline

Function that calculates curve points for cubic spline

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

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)

darwin-rs

Evolutionary algorithms library written in Rust

eudex

A blazingly fast phonetic reduction/hashing algorithm

treediff

Find the difference between arbitrary data structures

plumcast

A message broadcasting library based on the Plumtree/HyParView algorithms

count_sort

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

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’

startin

A Delaunay triangulator for terrain data

quadtree_rs

Point/region Quadtree with support for overlapping regions

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

graph-neighbor-matching

Graph similarity score using neighbor matching

geometry-predicates

cang-jie

A Chinese tokenizer for tantivy

rand_distr

Sampling from random number distributions

galois_2p8

Basic Arithmetic over all GF(2^8) fields

mop

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

fuss

Small, lightweight simplex noise generator for Rust

flag-algebra

An implementation of Razborov’s flag algebras

rng-cli

A random data generator CLI tool. Prints an infinite stream of data generated from a selected PRNG algorithm to stdout. Basically a CLI frontend for the rand crate.

solvent

Dependency Resolver library

rustlex_fsa

Library for manipulating (deterministic) finite automata

natural

Pure rust library for natural language processing

beehave

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

sfcgal

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

tilecover

Generate the minimum number of tiles to cover a geometry

fuzzyhash

Pure Rust fuzzy hash implementation

howto

instant coding answers via the command line

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

escape_string

Very efficiently parse backslash-escaped strings

graphplan

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

gcd

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

rtriangulate

Delaunay triangulation on a set of points

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

rvs

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

zeros

Extensions for hashing crates

wyhash

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

smeagol

Conway’s Game of Life using HashLife and SIMD

flo_curves

Library for manipulating Bezier curves

fasthash-sys

A suite of non-cryptographic hash functions for 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

grue

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

labelgraph

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

rdp

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

human-sort

Human sort (natural sort) implementation

spiral

Iterate over a 2D structure in a spiral pattern

quasirandom

Quasirandom number generation

common_macros

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

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)

lzjd

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

acacia

A spatial partitioning and tree library

sortrs

An introspective sort implementation

livesplit-title-abbreviations

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

dft

The package provides an algorithm to compute the discrete Fourier transform

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.

kendalls

Kendall’s tau rank correlation

raftlog_protobuf

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

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

transpose

Utility for transposing multi-dimensional data

zpatial

Algorithms for Spatial Acceleration and Geometries

cplex-sys

Low level bindings to the Cplex C-API

hyparview

A Rust implementation of HyParView algorithm

algos

A collection of algorithms in rust

co_sort

Sort arrays given a permutation

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

qht

Implementation of Quotient Hash Tables variants QHTc, QQHTc, QQHTDc

collenchyma-nn

collenchyma plugin providing Neural Network operations

multistream-batch

Different types and implementations of batching algorithms

rootfind

Root-finding algorithms

point_process

A crate for simulating random point processes

count-min-sketch

Count-min-sketch implementation

sub-strs

For finding sub strings

algoliasearch

Algolia client

geo-booleanop

Rust implementation of the Martinez-Rueda Polygon Clipping Algorithm

dummy

Type oriented fake data generation

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.

bloodhound

Fuzzy file finder

sfmt

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

xorshift128plus-rs

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

kademlia-dht

A simple implementation of the Kademlia DHT

quickbacktrack

Library for back tracking with customizable search for moves

spanish-numbers

Convert integers to written Spanish number format

geos-sys

GEOS C API bindings

ostn02_phf

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

t1ha

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

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

accurate

(more or less) accurate floating point algorithms

extfsm

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

block-array-cow

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

doryen-fov

A pure rust library containing 2D field of view algorithms for roguelikes

cycle-sort

Simple generic Cycle sort implementation

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

dia-range

Ranges for all integers

pcg

A port of the PCG random number generation library

float-ord

A total ordering for floating-point numbers

exprtk_rs

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

modtype_derive

Macros that implement modular arithmetic integer types

extsort

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

pack

Solver for packing puzzle

rendezvous_hash

An implementation of Rendezvous hashing algorithm

sift4

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

bsa3-hash

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

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

ssdeep

A Rust wrapper for ssdeep

triangulation

A collection of triangulation algorithms

rand_regex

Generates random strings and byte strings matching a regex

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

twox-hash-cli

A cli for the twox-hash crate

terr

Procedural terrain techniques

llrb-index

Left Leaning Red Black index

geo-rand

Generate random geometric shapes

bex

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

kmpsearch

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

nanoid

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

graphsearch

A simple graph search and representation library

rs-graph-derive

Automatic implementation of graph types

flot

Generate HTML documents with embedded charts using Flot

suffix_array

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

mersenne_twister

Mersenne Twister pseudorandom number generator

consistent_hash_ring

A flexible and efficient consistent hash ring

sorts

A collection of sorting algorithms

bip_dht

Implementation of the bittorrent mainline DHT

sdbm

SDBM is a non-cryptographic hashing algorithm

muldiv

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

cagra

Calculation Graph Library

algorithmica

Rust Algorithms

ffts

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

partitions

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

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

r-fairdist

Fair Resource Distribution Algorithm

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

rustr

Rust and R integration

rcmerkle

Efficient Merkle tree calculation function and state machine

rkm

A generic k-means implementation

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

hyperbolic_graph_generator

Create different types of hyperbolic graphs

index-fixed

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

geo-visibility

Compute visibility polygon

fera

An aggregation of algorithms, data structures and supporting crates

perlin

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

xxcalc

Embeddable or standalone robust floating-point polynomial calculator

collect_slice

Collect an iterator into a slice

pruefung

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

hwt

Hamming Weight Tree for finding neighbors in Hamming space

abstractgraph

Abstract Graph Algorithms

plumtree

A Rust implementation of Plumtree algorithm

xorshift

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

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

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

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

kurobako_solvers

A collection of black-box optimization solvers

conshash

A library to do consistent hashing in Rust

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

geohash-16

Geohash-16 implementation for Rust

batsat

Extensible SAT solver in Rust

atomic-traits

The traits for generic atomic operations

rusted_list

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

teia

A crate which implements persistent homology algorithm

cuckoocache

High performance concurrent cache

delaunay2d

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

number_traits

number traits

crcdir

A thin wrapper around crc32fast to checksum an entire directory

ffts-sys

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

highwayhash

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

integrators

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

yyid

YYID generator (random tokens like UUIDv4)

english-numbers

Convert integers to written English number format

permutation

Small utility for creating, manipulating, and applying permutations

thin-slice

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

clamped

Simple clamping of numbers in Rust

faiss-sys

Native bindings for Faiss

merging-iterator

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

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

djb33

DJB33 hash algorithm write in Rust