Lib.rs

rand

Random number generators and other randomness functionality

itertools

Extra iterator adaptors, iterator methods, free functions, and macros

twox-hash

XXHash and XXH3 algorithms

strsim

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

fastrand

fast random number generator

crc

support of various standards

crypto-bigint

Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…

xxhash-rust

xxhash

rustfft

High-performance FFT library written in pure Rust

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

ff

building and interfacing with finite fields

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

realfft

Real-to-complex forward FFT and complex-to-real inverse FFT for Rust

rstar

An R*-tree spatial index

litemap

A key-value Map implementation based on a flat, sorted Vec

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

noise

Procedural noise generation library

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

dissimilar

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

fnv

Fowler–Noll–Vo hash function

highway

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

rand_distr

Sampling from random number distributions

pathfinding

flow, and graph algorithms

kiddo

A high-performance, flexible, ergonomic k-d tree library. Ideal for geo- and astro- nearest-neighbour and k-nearest-neighbor queries

passwords

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

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

wildmatch

string matching with single- and multi-character wildcard operator

foldhash

A fast, non-cryptographic, minimally DoS-resistant hashing algorithm

ena

Union-find, congruence closure, and other unification code. Based on code from rustc.

nonmax

Numeric types that cannot hold maximum values

gcd

Calculate the greatest common divisor

murmur3

hash

rs_merkle

The most advanced Merkle Tree library for Rust. Supports creating and verifying proofs, multi-proofs, as well as advanced features, such as tree diffs, transactional changes, and rollbacks

topological-sort

Performs topological sorting

diff

An LCS based slice and string diffing implementation

differential-dataflow

An incremental data-parallel dataflow platform

argminmax

(argmin & argmax in 1 function) with SIMD for floats and integers

easy-smt

Easily interact with an smt solver as a subprocess

buffer-redux

Drop-in replacements for buffered I/O in std::io with extra features

gix-revwalk

providing utilities for walking the revision graph

phf_codegen

Codegen library for PHF types

edit-distance

Levenshtein edit distance between strings, a measure for similarity

resolvo

Fast package resolver written in Rust (CDCL based SAT solving)

treediff

Find the difference between arbitrary data structures

rand_mt

Reference Mersenne Twister random number generators

seahash

A blazingly fast, portable hash function with proven statistical guarantees

rapidhash

port of rapidhash: an extremely fast, high quality, platform-independent hashing algorithm

special

The package provides special functions

slice-group-by

Iterators over groups in slices and strs

bao

BLAKE3 verified streaming

strength_reduce

Faster integer division and modulus operations

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

rand_regex

Generates random strings and byte strings matching a regex

textdistance

Lots of algorithms to compare how similar two sequences are

rustfst

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

hostname

Cross-platform system's host name functions

gxhash

non-cryptographic algorithm

vek

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

rand_hc

HC128 random number generator

earcutr

port of MapBox's earcut triangulation code to Rust language

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

timely

A low-latency data-parallel dataflow system in Rust

memx

memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()

alphanumeric-sort

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

ffuzzy

generate / parse / compare ssdeep Context Triggered Piecewise Hashes (CTPH)

ph

data structures based on perfect hashing

yada

double-array trie library aiming for fast search and compact data representation

arrow-buffer

Buffer abstractions for Apache Arrow

metrohash

high quality, high performance hash algorithm

adler

clean-room implementation of the Adler-32 checksum

reed-solomon-simd

Reed-Solomon coding with O(n log n) complexity. Leverages SIMD instructions on x86(-64) and AArch64.

fastcdc

(content defined chunking) in pure Rust

k

kinematics

rand_simple

random number generator that is independent from the other libraries and based on XOR shift

hexf-parse

Parses hexadecimal floats (see also hexf)

jubjub

elliptic curve group

sketches-ddsketch

A direct port of the Golang DDSketch implementation

rphonetic

Rust port of phonetic Apache commons-codec algorithms

reed-solomon-novelpoly

reed solomon code / encoder / decoder with complexity O(n lg(n))

bm25

BM25 embedder, scorer, and search engine

fractional_index

fractional indexing

rust-stemmers

some popular snowball stemming algorithms

genetic_algorithms

solving genetic algorithm problems

kdtree

K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup

levenshtein

algorithm

daachorse

Double-Array Aho-Corasick

merkle_hash

Finds the hashes of all files and directories in a directory tree

geo-clipper

Boolean operations on polygons

interp

Matlab's interp1 function

partial_sort

provide a Rust version std::partial_sort

flo_curves

manipulating Bezier curves

hnsw_rs

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

hime_redist

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

dusk-poseidon

Poseidon hash algorithm over the Bls12-381 Scalar field

urandom

Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms

grb

API for Gurobi optimizer

ndarray-slice

Fast and robust slice-based algorithms (e.g., sorting, selection, search) for non-contiguous (sub)views into n-dimensional arrays

optirustic

A multi-objective optimisation framework for Rust

raft

language implementation of Raft algorithm

cubecl-linalg

CubeCL Linear Algebra Library

tenthash

A high-quality, non-cryptographic, 160-bit hash function

integer-sqrt

integer square root algorithm for primitive rust types

keyword_extraction

Collection of algorithms for keyword extraction from text

robust

adaptive floating-point predicates for computational geometry

boyer-moore-magiclen

fast string search algorithm implemented in Rust

blake2_bin

a command line implementation of BLAKE2b/s/bp/sp and all their parameters

levenberg-marquardt

algorithm built on top of nalgebra

blstrs_plus

High performance implementation of BLS12 381

mod_interface

Protocol of modularity unifying interface of a module and introducing layers

pubgrub

version solving algorithm

gix-merge

gitoxide project implementing merge algorithms

bitm

bit and bitmap (bit vector) manipulation

knossos

generating and rendering mazes

transpose

transposing multi-dimensional data

naive_opt

The optimized naive string-search algorithm

nanorand

A tiny, fast, zero-dep library for random number generation

rand_jitter

Random number generator based on timing jitter

radsort

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

rustsat

aims to provide implementations of elements commonly used in the development on software in the area of satisfiability solving. The focus of the library is to provide as much ease of use without giving up on performance.

cam-geom

Geometric models of cameras for photogrammetry

wyrand

A fast & portable non-cryptographic pseudorandom number generator and hashing algorithm

russcip

Rust interface for SCIP

setsum

order-agnostic checksum

varpro

A straightforward nonlinear least-squares fitting library which uses the Variable Projection algorithm

twofloat

Double-double arithmetic functionality

fast_paths

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

murmurhash32

murmurhash32_2

smawk

Functions for finding row-minima in a totally monotone matrix

accurate

(more or less) accurate floating point algorithms

cggmp21

TSS ECDSA implementation based on CGGMP21 paper

scru128

Sortable, Clock and Random number-based Unique identifier

graph

high-performant graph algorithms

muldiv

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

dive-deco

A dive decompression models library (Buehlmann ZH-L 16C)

highs

Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

tailcall

Safe, zero-cost tail recursion

tau-engine

A document tagging library

osqp

(Operator Splitting Quadratic Program) solver

ipopt

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

kube_quantity

adding arithmetic operations to the Quantity type from the k8s-openapi crate

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

glissade

that provides various utilities for animations and transitions

bevy_knossos

generating and rendering mazes

orx-v

Traits to unify all vectors!

keccak-asm

wrappers for SHA-3 algorithms written in assembly

oxirush-nas

5G NAS Message encoder/decoder library

petal-neighbors

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

union-find

Struct and methods for union-find operation

hierarchical_hash_wheel_timer

A low-level timer implementantion using a hierarchical four-level hash wheel with overflow

lilt

running interruptable, transition based animations as a function of time

fuzzy-muff

Fuzzy Matching Library

simplerand

fast random number generator

incremental

computations, based on Jane Street's incremental

trackball

Virtual Trackball Orbiting via the Exponential Map

scnr

Scanner/Lexer with regex patterns and multiple modes

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

diffusionx

random number/stochastic process simulation with high performance

toodee

A lightweight 2D wrapper around a Vec

mergable

user-friendly and efficient CRDTs

cdshealpix

HEALPix tesselation

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

bellperson

zk-SNARK library

rectangle-pack

A general purpose, deterministic bin packer designed to conform to any two or three dimensional use case

arpfloat

Arbitrary-precision floating point library

avalog

An experimental implementation of Avatar Logic with a Prolog-like syntax

num_convert

Type converting library, conversions integers by overflow addition, supports generics types

dbsp

Continuous streaming analytics engine

conv2

number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'

udigest

Unambiguously digest structured data

probminhash

Minhash algorithms for weighted Jaccard index

ta

Technical analysis library. Implements number of indicators: EMA, SMA, RSI, MACD, Stochastic, etc.

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

fuse-rust

Fuse is a super lightweight library which provides a simple way to do fuzzy searching. Fuse-Rust is a port of Fuse-Swift, written purely in rust

vrp-scientific

An extension logic for solving scientific VRP

satkit

Satellite Toolkit

ra_ap_salsa

A generic framework for on-demand, incrementalized computation (experimental)

timsort

modified MergeSort used in Python and Java

itermore

🤸‍♀️ More iterator adaptors

rucrf

Conditional Random Fields implemented in pure Rust

toktrie

LLM Token Trie library

dup-indexer

Create a non-duplicated index from Strings, static str, Vec, or Box values

quad-rand

Pseudo random implementation with core atomics

bridgetree

A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration

rust-spice

WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust

feos-campd

Computer-aided molecular and process design using the FeOs framework

cmaes

CMA-ES optimization algorithm

piper

Async pipes, channels, mutexes, and more

random_color

generating random attractive colors

feruca

Unicode Collation Algorithm

meos

Rust bindings for MEOS C API

ran

fast random numbers generation

ids_service

that allows to generate unique Ids

scru64

Sortable, Clock-based, Realm-specifically Unique identifier

graaf

Work with directed graphs

rollgrid

pseudo-infinite open worlds

prio-graph

A lazily populated directed acyclic graph with top-level priority ordering

lt-fm-index

Fm-index using k-mer lookup table for exact pattern matching

random_word

Efficient functions for generating random words in many languages

rhai-sci

Scientific computing in the Rhai scripting language

color_space

converting between color spaces and comparing colors

mhgl

Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.

rithm

Arbitrary precision arithmetic

geometry-predicates

port of robust geometric predicates

dogear

merging bookmark trees

extendhash

Rust Hash Extender

annembed

dimension reduction à la Umap

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.

panfix

parsing: linear time parsing of multifix operators

dilate

A compact, high performance integer dilation library for Rust

clingo

Rust idiomatic bindings to the clingo library

haru_cmaes

CMA-ES optimization algorithm implementation based on Hansen's purecma Python implementation

radiate

genetic algorithms and artificial evolution

here_be_dragons

Map generator for games

wcs

FITS World Coordinate System (WCS)

smolprng

A Small and Extensible PRNG written in Rust

broccoli

broadphase collision detection algorithms

brique-rs

A MLP library made from scratch, using the rust standard lib

four-bar

Four🍀bar library provides simulation and synthesis function for four-bar linkages

algos

A collection of algorithms in Rust

syntree_layout

visualize trees from the 'syntree' crate

hud-slice-by-8

HUD Software's Rust improved implementation of the Intel Slice-By-8 algorithm

fastatomstruct

A Python package for the analysis of atomic structures and dynamics

fast_poisson

Bridson's algorithm for fast Poisson disk sampling

par-iter

Fork of rayon, with chili support

mpchash

Multi-probe consistent hashing algorithm implementation

treerder

Trie ordering for type implementing Orderable

ranges

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

rs-wordle-solver

solving Wordle-style puzzles. It provides multiple guessing algorithms, as well as building blocks for implementing your own Wordle solving algorithms.

ltpp-output

An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.

od_opencv

Object detection utilities in Rust programming language for YOLO-based neural networks in OpenCV ecosystem

rdst

A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes

xxhrs

Safe XXHash and XXH3 bindings

xiangting

calculating the deficiency number (a.k.a. xiangting number, 向聴数).

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

bit-iter

Iterate forward or backwards over the positions of set bits in a word

vecmath

type agnostic library for vector math designed for reexporting

zspell

Native Rust library for spellchecking

polygons

Fast points-in-polygon test and distances to polygons

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

count-min-sketch

Count-min-sketch implementation

nabla-ml

A numpy-like library for Rust

libsufr

Parallel Construction of Suffix Arrays in Rust

english-to-cron

converts natural language into cron expressions

sequence-generator-rust

Customizable 64-bit unique distributed IDs sequence generator based on Twitter's ID (snowflake). Build in Rust

piecewise_polynomial

Fitting and interpolation with piecewise polynomials

autour_core

AUTOmata Utilities and Representation (AUTOUR) is a small toolbox to experiment with various kinds of automata and draw them

stringmetrics

approximate string matching

acap

As Close As Possible — nearest neighbor search in Rust

crc32-v2

A port of the CRC-32 algorithm to Rust

pyinrs

type library that is as easy to use as Python built-in types

numerical-multiset

An ordered multiset of machine numbers

ijzer

Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..

lazypoline-rs

A framework for building syscall interposers for user-space Linux applications

simsearch

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

bit_gossip

Pathfinding library for calculating all node pairs' shortest paths in an unweighted undirected graph

randevu

The official Rust implementation of the RANDEVU algorithm

varint-rs

A small, zero dependency varint implementation in Rust

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

i_shape

iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint

importunate

Methods for returning random elements from an iterator

fast-erasure-shake-rng

Fast erasure (forward secure) sponge/duplex based PRNG using the Keccak permutation

clipper2

A polygon Clipping and Offsetting library for Rust

sefar

evolutionary optimization algorithms

single-svdlib

port of LAS2 from SVDLIBC

pm-remez

Parks-McClellan Remez FIR design algorithm

hyper_byte

An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

oxidd-reorder

Reordering algorithms for OxiDD

permutation

Small utility for creating, manipulating, and applying permutations

ddo

generic and efficient framework for MDD-based optimization

zeros

const-random

compile time random number generation

timberio/file-source

A high-performance observability data pipeline

adskalman

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

compile_time_sort

Sort arrays and slices of primitives in const contexts

jopemachine-raft

language implementation of Raft algorithm

uniset

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

probability

The package provides a probability-theory toolbox

numext-fixed-uint

Fixed-size uint types

sonic-api

API for formally-verifiable distributed contracts

liba

An algorithm library based on C/C++

cap-rand

Capability-based random number generators

gemm-f32

Playground for matrix multiplication algorithms

noise-functions

A collection of fast and lightweight noise functions

density-rs

Superfast compression library

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

simplehash

fast Rust library implementing common non-cryptographic hash functions

kendalls

Kendall's tau rank correlation

lutz

"An Algorithm for the Real Time Analysis of Digitised Images" by R. K. Lutz

sfcgal

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

basic_dsp

Digital signal processing based on real or complex vectors in time or frequency domain

error_tools

Basic exceptions handling mechanism

collate

Traits and a data structure to support collation and bisection

localsearch

Local Search based Metaheuristics

merkle-cbt

generating efficient Merkle tree and combined Merkle proof based on complete binary tree

algorithmica

Rust Algorithms

easer

Tiny library imlementing Robert Penner's easing functions

hax-bounded-integers

Newtypes for working with bounded integers with hax

ya-rand

fast random number generation

abd-clam

Clustering, Learning and Approximation with Manifolds

tetengo_lattice

Viterbi search and A* algorithm implementation

quine-mccluskey

Boolean function minimizer based on Quine–McCluskey algorithm

spectrex

AstroBWTv3 CPU mining algorithm in Rust

movavg

Generic Moving Average calculation

kitoken

Fast and versatile tokenizer for language models, supporting BPE, Unigram and WordPiece tokenization

sif-embedding

Smooth inverse frequency (SIF), a simple but powerful embedding technique for sentences

bpe-openai

Prebuilt fast byte-pair encoders for OpenAI

sobol_burley

A seedable Owen-scrambled Sobol sequence

libecvrf

A ECVRF that's friendly with EVM, based on curve secp256k1 and keccak256

natord

Natural ordering for Rust

drbg

Crypographic random number generator CTR_DRBG defined by NIST SP 800-90A R1

t1ha

T1AH (Fast Positive Hash) hash function

pingora-limits

rate limiting and event frequency estimation

random

The package provides sources of randomness

seastar

Dependency-free implementation of the A* pathfinding algorithm for uniform-cost, 2D grids in cardinal directions

randomize

Randomization routines

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

graph-algorithms-rs

A collection of graph algorithms

is_sorted

Iterator sorted?

markov_namegen

Random text generators based on Markov models

rand_aes

AES based pseudo-random number generator

openraft-sledstore

A sled based implementation of the openraft::RaftStorage trait

line-col

Convert string slice indices into line/column numbers

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…

hamming-bitwise-fast

A fast, zero-dependency implementation of bitwise Hamming Distance using a method amenable to auto-vectorization

crunch

A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind

flat_spatial

Flat spatial partitionning algorithms and data structures

out

fast min and max functionality for collections

pasture-algorithms

Point cloud algorithms for pasture

kewb

manipulating and solving a 3x3 Rubik's cube with Kociemba's two phase algorithm

graphina

A graph data science library for Rust

h3o-zip

A compression scheme tailored for H3 cell indexes

slice-diff-patch

providing utility functions for diff and patch of slices

convi

Convenient (but safe) conversion (From-like) traits

elipdotter

Embeddable full text search engine

fast_polynomial

Faster polynomial evaluation using Estrin's Scheme to exploit instruction-level parallelism

rocm-rs

Rust bindings for AMD ROCm libraries

maybe-owned

MaybeOwned (and MaybeOwnedMut) type similar to std’s Cow but it implements From<T> and From<&'a T> and does not require ToOwned

ruut-functions

parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian

trie_rcv

Ranked Choice Voting implementation using Tries in Rust

batsat

Extensible SAT solver in Rust

seedling

hierarchical seeded pseudo-random number generators

keyforge95

product key generation / validation for Windows 95 and other Microsoft products

rand_xorshift

Xorshift random number generator

muchin

Support for composing large, interacting, complicated state machines

f3l_search_tree

3D Point Cloud Library

uuid-by-string

Generating uuid-hash from string

lazyrand

generating random numbers easily

ruffer

overwriting ring buffer library written in Rust

timelag

Creating time-lagged time series data

tiny_sort

Binary-size optimized stable and unstable sorts

chksum-sha2

SHA-2 hash functions with a straightforward interface for computing digests of bytes, files, directories, and more

b2c2-parser

b2c2におけるBASICコードのパーサー?

impact-rs

Collision query library for 2D games

decmathlib-rs

Port of the Intel Decimal Floating-Point Math Library decimal128 type to Rust

bye_nanoflann_rs

KD-Tree, implemented based on nanoflann, primarily optimized for 2D or 3D point clouds

round_robin

Create a vector of rounds and their respective matches in a tournament, using the Round-robin algorithm

codeq

Codec trait

generic_levenshtein

Generic and fast implementation of the Levenshtein distance

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

topopt

Topology optimization in pure Rust, based on 99 lines of MATLAB

xldenis/creusot

prove your code is correct in an automated fashion

from-pest

Convert from a pest grammar to a typed AST

multimarkov

generic tool for training and using multi-order Markov chains for procedural generation applications such as generating randomized but authentic-sounding names for characters and locations

voracious_radix_sort

State of the art radix sort algorithms. Single thread and multi thread versions.

oefpil

Optimum Estimate of Function Parameters by Iterated Linearization (OEFPIL): Algorithm for nonlinear function fitting to data with errors in both dependent and independent variables where correlation…

ext-sort

rust external sort algorithm implementation

spc-rs

SPC (Statistical Process Control)

downstream

efficient, constant-space implementations of stream curation algorithms

float_plus

Additional features for float values

lp-solvers

.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK

pumpkin-solver

The Pumpkin combinatorial optimisation solver library

what3words-api

Official what3words API wrapper for rust

light_ranged_integers

Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code

generic_a_star

A generic implementation of the A* algorithm

hypertwobits

cardinality estimation algorithm

bit_manipulation

lightweight Rust crate for seamless management and validation of up to 128 option states. Empower your applications with efficient, flexible, and intuitive option handling, ensuring…

froggy-rand

Random number generation without state for games

random-nickname2

用于Rust的随机用户昵称生成器

vrp-cli

A command line interface for VRP solver

violin

decentralized network coordinate system using the vivaldi algorithm

himmelblau_red_asn1

A little library to encode/decode ASN1 DER

pathfinding_astar

A-Star pathfinding algorithm that can process absract and grid-like paths

polylog

polylogarithms

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

time_series_generator

Generate various timeseries of given length, some randomly sampled

recursive_matching

Formulating unique assignments recursively

pacmap

Pairwise Controlled Manifold Approximation (PaCMAP) for dimensionality reduction

rustdct

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

pack_it_up

that implements various bin packing algorithms

ringstack

A very simple circular buffered stack implementation

pcg_rand

PCG family of random number generators in pure Rust

shardtree

A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration

libphext

A rust-native implementation of phext

rapid_solve

metaheuristic framework for solving combinatorial optimization problems

gbwt

Partial reimplementation of the GBWT. Exposure for the GBZ struct.

subset_sum

Solves subset sum problem and returns a set of decomposed integers. It also can match corresponding numbers from two vectors and be used for Account reconciliation.

length

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.

augurs-clustering

Time series clustering