Lib.rs

rand

Random number generators and other randomness functionality

strsim

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

crc

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

md5

The package provides the MD5 hash function

rand_pcg

Selected PCG random number generators

rand_jitter

Random number generator based on timing jitter

twox-hash

A Rust implementation of the XXHash algorithm

rand_chacha

ChaCha random number generator

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

bytecount

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

rand_xorshift

Xorshift random number generator

fst

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

pathfinding

Pathfinding, flow, and graph algorithms

rand_os

OS backed Random Number Generator

rand_isaac

ISAAC random number generator

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

adler32

Minimal Adler32 implementation for Rust

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…

fake

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

rand_hc

HC128 random number generator

extprim

Extra primitive types (u128, i128)

ratelimit_meter

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

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

geos

Rust bindings for GEOS C API

elasticlunr-rs

A partial port of elasticlunr.js to Rust

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.

metrohash

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

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

proj

Rust bindings for PROJ

ncollide3d

2 and 3-dimensional collision detection library in Rust

raft

The rust language implementation of Raft algorithm

whatlang

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

textnonce

Text based random nonce generator

probability

The package provides a probability-theory toolbox

ncollide2d

2 and 3-dimensional collision detection library in Rust

triple_buffer

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

decorum

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

rdrand

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

fallible-iterator

Fallible iterator traits

rustfft

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

alphanumeric-sort

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

passwords

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

out

Provides functionality to get the n largest items from slices and iterators

numext-fixed-uint

Fixed-size uint types

polylabel

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

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

numext-fixed-hash

Fixed-size hash types

line_drawing

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

hashmap_core

Implementation of HashMap and HashSet for no_std environments

nqueens-oxigen

N Queens problem resolution using oxigen

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

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

rand_distr

Sampling from random number distributions

special

The package provides special functions

quantiles

a collection of approximate quantile algorithms

highway

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

fxhash

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

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

random-pick

Pick an element from a slice randomly by given weights

programinduction

A library for program induction and learning representations

onemax-oxigen

OneMax simple problem resolution using oxigen

sdset

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

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

cdshealpix

Rust implementation of the HEALPix tesselation

crc16

A CRC16 implementation

flo_binding

Declarative binding library for Rust

vek

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

noise

Procedural noise generation library

ipopt

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

zipf

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

k

k is for kinematics

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…

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

afsort

American Flag sort implementation for faster sorting of Strings

rsgenetic

A library providing genetic algorithm execution

geohash

Geohash implementation for Rust

worley-noise

Worley noise implementation

basic_dsp

Digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations…

linear_solver

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

bitintr

Portable Bit Manipulation Intrinsics

vpsearch

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

permutohedron

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

punkt

An implementation of a Punkt sentence tokenizer

hnsw

Fast approximate nearest neighbors

rust-lapper

A fast and easy interval overlap library

streaming-stats

Experimental crate for computing basic statistics on streams

numext-constructor

Fixed-size uint and hash constructor

spaces

Set/space primitives for defining machine learning problems

boyer-moore-magiclen

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

knapsack-oxigen

Knapsack problem resolution using oxigen

is_sorted

Is an Iterator sorted?

radiate

Parallel and customizable genetic programming library

vrf

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

strength_reduce

Faster integer division and modulus operations

rendezvous_hash

An implementation of Rendezvous hashing algorithm

cubic_spline

Function that calculates curve points for cubic spline

slice-group-by

Iterators over groups in a slice

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…

levenshtein

Levenshtein algorithm

xoroshiro128

Fast psuedo-random number generators

fsm_gen

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

pikkr

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

qframework

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

random-integer

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

basic_dsp_interop

This lib offers a C compatible interface for basic_dsp_vector, so that it can be used from programs written in languages other than Rust. basic_dsp_vector provides digital signal…

basic_dsp_matrix

This lib offers the same operations defined in basic_dsp_vector for matrices. It doesn’t offer complete matrix algebra by itself and instead is meant to be used in combination with other matrix libs…

float-ord

A total ordering for floating-point numbers

oorandom

A tiny, robust PRNG implementation

zkp-stark

Implementation of the STARK ZK-proof system

easy_reader

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

faiss

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

test-data-generation

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

rs-graph

A library for graph algorithms and combinatorial optimization

advancedresearch-tree_mem_sort

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

sublime_fuzzy

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

gear

Collision avoidance path planning for robotics

convert-base

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

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

external_sort

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

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

graphplan

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

ahrs

A Rust port of Madgwick’s AHRS algorithm

axgeom

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

vec-drain-where

alternative Vec::drain_filter impl

rand_regex

Generates random strings and byte strings matching a regex

bibicode

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

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

natord

Natural ordering for Rust

qptrie

A QP-Trie implementation for Rust

timely_sort

Sorting infrastructure for timely dataflow

canonical-form

Reduce graphs and other combinatorial structures modulo isomorphism

bidir-map

Bidirectional map implementation for Rust

usher

Parameterized routing for generic resources in Rust

collider

A library for continuous 2D collision detection for game developement

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

automata

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

vecshard

Split Vecs in constant time

astro

Advanced algorithms for astronomy

apodize

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

superslice

Extensions for slices

nhl-stats

NHL Stats API client for Rust created using openapi-generator

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

raftlog

An implementation of distributed replicated log based on the Raft algorithm

simsearch

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

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein automata

tile-grid

Library for map tile grid calculations

treediff

Find the difference between arbitrary data structures

rustdct

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

governor

A rate-limiting implementation in Rust

startin

A Delaunay triangulator for terrains

eliza

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

multistream-batch

Different types and implementations of batching algorithms

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

hime_redist

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

sfmt

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

diffr-lib

An implementation of Myers diff algorithm

simplers_optimization

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

eudex

A blazingly fast phonetic reduction/hashing algorithm

bravery_router

Radix Tree implementation

rs_algo

Common sorting algorithms and other common computer science algorithms

zeros

Extensions for hashing crates

count_sort

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

hashers

A collection of non-cryptographic hashing algorithms for Rust

nanoid

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

natural

Pure rust library for natural language processing

objid

Generate a random object identifier

lis

Longest increasing subsequence algorithm

fast_paths

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

streaming_algorithms

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

hilbert

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

nats-types

Enumerations and types for representing NATS protocol messages

ffts

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

bsa3-hash

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

darwin-rs

Evolutionary algorithms library written in Rust

aliasmethod

Implementation of Walker’s Alias method

mop

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

random_color

Rust crate for generating random attractive colors

coord_transforms

A Rust crate use for performing coordinate transformations

munkres

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

pocket_prover-set

A base logical system for PocketProver to reason about set properties

subslice

Fast subslice search

fractal

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

hypernonsense

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

indexed_bitvec

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

friedrich

Gaussian Process Regression

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.

muldiv

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

merging-iterator

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

beehave

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

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

just-argon2

Bindings to the argon2 C library

pdqsort

Pattern-defeating quicksort

spmc_buffer

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

kademlia-dht

A simple implementation of the Kademlia DHT

zhang_hilbert

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

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.

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

sub-strs

For finding sub strings

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

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.

graphene

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

lonlat_bng

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

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

contrail

Simple state restoration for backtracking search algorithms using a trail

aristeia

An evolutionary computation library

cang-jie

A Chinese tokenizer for tantivy

rustlex_fsa

Library for manipulating (deterministic) finite automata

howto

instant coding answers via the command line

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

wu-diff

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

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

ordslice

Extensions for ordered slices

human-sort

Human sort (natural sort) implementation

rvs-parser

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

tilecover

Generate the minimum number of tiles to cover a geometry

osmgraphing

Playing around with graphs created via parsing OpenStreetMap data

gut

Geometry utilities: storing, manipulating and processing geometries

tdigest

T-Digest algorithm in Rust

actix-raft

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

srand

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

order-stat

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

xbar

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

sfcgal

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

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

labelgraph

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

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

acacia

A spatial partitioning and tree library

fuzzyhash

Pure Rust fuzzy hash implementation

rvs-repl

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

rand_seeder

A universal random number seeder based on SipHash

bitap

Bitap implementation in rust

kahan

Provides types to perform Kahan summation

thin-slice

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

ipopt-sys

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

rvs-c-api

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

cplex-sys

Low level bindings to the Cplex C-API

mix-distribution

Mixture distributions

sortrs

An introspective sort implementation

weighted-rs

A libray for weighted balancing algorithm

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.

random-trait

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

dia-range

Ranges for all integers

geos-sys

GEOS C API bindings

kendalls

Kendall’s tau rank correlation

forge_hasher

The rust language implementation of forge_hasher

rootfind

Root-finding algorithms

xx-bloomfilter

Bloom filter implementation using xx hash

algebraics

algebraic numbers library

ostn02_phf

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

galois_2p8

Basic Arithmetic over all GF(2^8) fields

raftlog_protobuf

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

rtriangulate

Delaunay triangulation on a set of points

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

geometry-predicates

scottish_names

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

quickbacktrack

Library for back tracking with customizable search for moves

block-array-cow

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

visit_diff

Efficiently finding differences between data structures

algorithmica

Rust Algorithms

common_macros

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

sorting

The world’s best, finest and inefficient sorting algorithms

sprs-ldl

Sparse cholesky factorization

rvs

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

dft

The package provides an algorithm to compute the discrete Fourier transform

int_traits

Provides a trait for extended functions on integers

permu-rs

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

non-dominated-sort

Fast Non-Dominated Sort Algorithm

pack

Solver for packing puzzle

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

gcd

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

accurate

(more or less) accurate floating point algorithms

ed_join

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

hamming

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

fuss

Small, lightweight simplex noise generator for Rust

spiral

Iterate over a 2D structure in a spiral pattern

suffix_array

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

zpatial

Algorithms for Spatial Acceleration and Geometries

flo_curves

Library for manipulating Bezier curves

ssdeep

A Rust wrapper for ssdeep

names

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

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.

xorshift

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

geo-visibility

Compute visibility polygon

wookong-solo

Wookong Solo driver crate

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

rdp

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

geo-rand

Generate random geometric shapes

sift4

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

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.

index-fixed

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

graphsearch

A simple graph search and representation library

msws

Middle Square Weyl Sequence pseudorandom number generator

radixal

Digits iteration for unsigned integer types

quadtree_rs

Point/region Quadtree with support for overlapping regions

consistent_hash_ring

A flexible and efficient consistent hash ring

quasirandom

Quasirandom number generation

bip_dht

Implementation of the bittorrent mainline DHT

lzjd

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

const-random-macro

Provides the procedural macro used by const-random

livesplit-title-abbreviations

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

raft-proto

Protocol definitions for the rust language implementation of the Raft algorithm

ffts-sys

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

wyhash

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

mersenne_twister

Mersenne Twister pseudorandom number generator

scailist

A fast and easy interval overlap library

xorshift128plus-rs

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

rkm

A generic k-means implementation

smeagol

Conway’s Game of Life using HashLife and SIMD

revonet

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

perlin

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

internet-checksum

RFC 1071 checksum computation (the “internet checksum”)

pruefung

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

spanish-numbers

Convert integers to written Spanish number format

sharpen

A rust library for iterator element condensing and sharpening

geo-raycasting

Ray Casting algorithm for the geo crate

yyid

YYID generator (random tokens like UUIDv4)

modulo

Simple modulo operation

indexed_bitvec_core

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

geomorph

Simple conversion between different coordinate systems

partitions

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

hashed-permutation

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

checksum

Calculates crc32/crc64 file checksums written in Rust

reingold-tilford

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

bloodhound

Fuzzy file finder

bft-core

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

crc32c-hw

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

conshash

A library to do consistent hashing in Rust

sdbm

SDBM is a non-cryptographic hashing algorithm

glicko2

Implementation of the glicko2 rating system

count-min-sketch

Count-min-sketch implementation

extfsm

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

rusted_list

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

abstractgraph

Abstract Graph Algorithms

rosalind-cli

CLI for rosalind crate

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…

lcs-diff

Compute differences between two slices using LCS algorithm

delaunay2d

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

number_traits

number traits

hyparview

A Rust implementation of HyParView algorithm

highwayhash

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

english-numbers

Convert integers to written English number format

co_sort

Sort arrays given a permutation

triangulation

A collection of triangulation algorithms

hamming-heap

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

djb33

DJB33 hash algorithm write in Rust

extsort

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

ndarray-rblas

rblas bindings for ndarray