Lib.rs

rand

Random number generators and other randomness functionality

fastrand

fast random number generator

crc

support of various standards

rustfft

High-performance FFT library written in pure Rust

priority-queue

Priority Queue implemented as a heap with a function to efficiently change the priority of an item

fnv

Fowler–Noll–Vo hash function

bytecount

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

xxhash-rust

xxhash

ahash

non-cryptographic hash function using AES-NI for high performance

rand_chacha

ChaCha random number generator

sprs

sparse matrix library

stacker

stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack

nanorand

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

pathfinding

flow, and graph algorithms

highway

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

ulid

Universally Unique Lexicographically Sortable Identifier implementation

rstar

R*-tree library for the Rust ecosystem

strsim

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

twox-hash

XXHash and XXH3 algorithms

rustc-hash

speed, non-cryptographic hash used in rustc

crc-any

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.

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

bellperson

zk-SNARK library

blstrs

High performance implementation of BLS12 381

passwords

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

ena

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

fastcdc

(content defined chunking) in pure Rust

GSL

binding for the GSL (the GNU scientific library)

extendr-api

Safe and user friendly bindings to the R programming language

wildmatch

string matching with questionmark and star wildcard operator

nu-command

Nushell's built-in commands

md5

package provides the MD5 hash function

gtk4-sys

FFI bindings of GTK 4

kiddo

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

levenshtein

algorithm

group

Elliptic curve group traits and utilities

slice-group-by

Iterators over groups in slices and strs

arrow-data

Array data abstractions for Apache Arrow

streaming-iterator

Streaming iterators

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

fallible-iterator

Fallible iterator traits

robust

adaptive floating-point predicates for computational geometry

realfft

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

arrow-ord

Ordering kernels for arrow arrays

rand_pcg

Selected PCG random number generators

dissimilar

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

oorandom

tiny, robust PRNG implementation

ff

building and interfacing with finite fields

xorf

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

strength_reduce

Faster integer division and modulus operations

fallible_collections

adds fallible allocation api to std collections

z3

High-level rust bindings for the Z3 SMT solver from Microsoft Research

topological-sort

Performs topological sorting

rand_distr

Sampling from random number distributions

icu_pattern

ICU pattern utilities

alphanumeric-sort

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

broccoli

broadphase collision detection algorithms

sgp4

pure Rust implementation of the SGP4 algorithm for satellite propagation

type_constructor

Fundamental data types and type constructors, like Single, Pair, Many

wkt

read/write support for well-known text (WKT)

tantivy-fst

tantivy-specific fork from the fst crate from Burntsushi. (Please use the fst crate instead.)

adler32

Minimal Adler32 implementation for Rust

byte-slice-cast

Safely cast bytes slices from/to slices of built-in fundamental numeric types

medians

Median, Statistical Measures, Mathematics, Statistics

arrow-buffer

Buffer abstractions for Apache Arrow

k

kinematics

special

package provides special functions

r3bl_rs_utils

Async Redux library, TUI framework, and useful types

gcd

Calculate the greatest common divisor

ddo

generic and efficient framework for MDD-based optimization

murmur3

hash

cap-rand

Capability-based random number generators

oci-distribution

OCI implementation in Rust

simd-adler32

SIMD-accelerated Adler-32 hash algorithm implementation

binary-heap-plus

Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps

bevy_rapier2d

2-dimensional physics engine in Rust, official Bevy plugin

graph

high-performant graph algorithms

hnsw_rs

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

vek

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

integer-sqrt

integer square root algorithm for primitive rust types

rand_regex

Generates random strings and byte strings matching a regex

pv_rhino

bindings for Picovoice's Rhino library

zipf

fast generator of discrete, bounded Zipf-distributed random numbers

flo_curves

manipulating Bezier curves

genetic_algorithms

solving genetic algorithm problems

opis

rational number and matrix arithmetic

cdshealpix

HEALPix tesselation

rustfst-ffi

constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs). Rustfst-ffi provides C interfaces of the Rust library

image_hasher

that provides perceptual hashing and difference calculation for images

transpose

transposing multi-dimensional data

differ

finding the differences between two sequences

ph

data structures based on perfect hashing

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

advent-of-code

Solutions to Advent of Code

hexf-parse

Parses hexadecimal floats (see also hexf)

skillratings

Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more

clingo

idiomatic bindings to the clingo library

probability

package provides a probability-theory toolbox

arrayfire

high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…

gix-negotiate

gitoxide project implementing negotiation algorithms

rust-spice

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

reed-solomon-novelpoly

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

timely

low-latency data-parallel dataflow system in Rust

hime_redist

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

crunch

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

radius2

fast symbolic execution framework using r2

counting_sort

Counting sort implementation for Iterators

distances

Fast and generic distance functions for high-dimensional data

seahash

blazingly fast, portable hash function with proven statistical guarantees

smawk

Functions for finding row-minima in a totally monotone matrix

extendhash

Hash Extender

resiter

Helper crate for handling iterators over result

kdtree

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

bao

BLAKE3 verified streaming

sliding_features

Modular sliding window with various signal processing functions and technical indicators

differential-dataflow

incremental data-parallel dataflow platform

argminmax

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

ids_service

that allows to generate unique Ids

lerp

Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types

poi

pragmatic point-free theorem prover assistant

linfa-datasets

Collection of small datasets for Linfa

naive_opt

optimized naive string-search algorithm

unit-conversions

Various units of measurement conversions

sets

Generic vectors as sets. Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc.

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.

spa

Solar Position Algorithm module (SPA) for Rust calculates the sunrise-sunset and azimuth and zenith-angle for specific geo-position and time (UTC); for example for solar-panel-alignment or automotive

earcutr

port of MapBox's earcut triangulation code to Rust language

line-span

Find line ranges and jump between next and previous lines

rattler_solve

solve conda environments

fuzzyhash

Pure Rust fuzzy hash implementation

ssri

Various utilities for handling Subresource Integrity

smallmap

Small byte-sized generic key-value map type

memx

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

linestring

line string toolbox

rithm

Arbitrary precision arithmetic

sophia_inmem

toolkit for RDF and Linked Data - In-memory Graph and Dataset implementations

instant-distance

Fast minimal implementation of HNSW maps for approximate nearest neighbors searches

knossos

generating and rendering mazes

svd-rs

CMSIS-SVD base structures

noodles-cram

CRAM format reader and writer

nucleo

plug and play high performance fuzzy matcher

rand_mt

Reference Mersenne Twister random number generators

openblas-build

package provides a build helper for OpenBLAS

levenberg-marquardt

algorithm built on top of nalgebra

backon

Retry with backoff without effort

probminhash

Minhash algorithms for weighted Jaccard index

kd-tree

k-dimensional tree

triple_accel

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

scru128

SCRU128: Sortable, Clock and Random number-based Unique identifier

toodee

lightweight 2D wrapper around a Vec

dfp-number-sys

bindings for Intel® Decimal Floating-Point Math Library

treediff

Find the difference between arbitrary data structures

partial_sort

version of std::partial_sort

fractional_index

fractional indexing

reed-solomon-simd

Reed-Solomon coding with O(n log n) complexity. Leverages AVX2 or SSSE3 on x86(-64).

yada

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

ra-ap-rustc_index

Automatically published version of the package rustc_index in the rust-lang/rust repository from commit 390e3c8b6615afb4f0b9bb2c3db3ad033ac75d78 The publishing script for this crate lives at:…

cam-geom

Geometric models of cameras for photogrammetry

app_units

Servo app units type (Au)

boostvoronoi

Boost voronoi ported to 100% rust

halfbrown

Multi backend HashMap for higher performance on different key space sizes

surgeshaper-digi

surge synthesizer -- digital waveshaper

merkle_hash

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

gdsl

graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected smart pointers

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

mergable

user-friendly and efficient CRDTs

boyer-moore-magiclen

fast string search algorithm implemented in Rust

geo-clipper

Boolean operations on polygons

avltriee

Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…

simsearch

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

biodiff

Compare binary files using sequence alignment

qr2term

Stupidly simple Rust crate to render a QR code in the terminal

rs-wordle-solver

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

bit-iter

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

svdlibrs

port of LAS2 from SVDLIBC

ragged-buffer

Efficient RaggedBuffer datatype that implements 3D arrays with variable-length 2nd dimension

weighted_rand

weighted random sampling crate using Walker's Alias Method

murmurhash32

murmurhash32_2

static_aabb2d_index

Fast static spatial index data structure for 2D axis aligned bounding boxes

randomize

Randomization routines

muldiv

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

delaunator

very fast 2D Delaunay triangulation library

graph-algorithms

5 graph algorithms - DIJKSTRA'S, BFS, DFS, KOSARAJU'S and BELLMAN FORD ALGORITHM

numext-fixed-uint

Fixed-size uint types

stringmetrics

approximate string matching

metaheuristics-nature

collection of nature-inspired meta-heuristic algorithms

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

mpchash

Multi-probe consistent hashing algorithm implementation

jubjub

elliptic curve group

is_prime

Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm

svd-encoder

CMSIS-SVD file encoder

hypernonsense

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

starlark_map

Map implementation with starlark-rust specific optimizations

annembed

dimension reduction à la Umap

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

highs

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

pi_atom

global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys

at-commands

AT Commands builder and parser for Rust #![no_std]

typed-sled

Sled with types instead of bytes

hyperloglog-rs

HyperLogLog trying to be parsimonious with memory

blitzar

High-Level Rust wrapper for the blitzar-sys crate

random-access-memory

Continuously read and write to memory using random offsets and lengths

list-fn

generic lazy list

ndarray-slice

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

polylog

polylogarithms

edit-distance

Levenshtein edit distance between strings, a measure for similarity

easyfft

providing an easy FFT API for arrays and slices

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…

random_word

Efficient functions for generating random words in many languages

fastcdc-alt

FastCDC (content defined chunking) implementation in pure Rust with an alternative API to the original crate

crczoo

CRC Zoo: A collection of Cyclic Redundancy Check (CRC) algorithms

graph_builder

building block for high-performant graph algorithms

zeros

polynomial

manipulating polynomials

itermore

🤸‍♀️ More iterator adaptors

voracious_radix_sort

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

cbor-data

using CBOR as in-memory representation for working with dynamically shaped data

stack-graphs

Name binding for arbitrary programming languages

slice-by-8

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

easy_color

very simple and easy-to-use color conversion tool

dwrote

Lightweight binding to DirectWrite

canadensis_dsdl_frontend

Compiler front-end for the Cyphal Data Structure Description Language

hashring

minimal implementation of consistent hashing

is_sorted

Iterator sorted?

arpfloat

Arbitrary-precision floating point library

tiny_sort

Binary-size optimized stable and unstable sorts

dogear

merging bookmark trees

id_tree_layout

visualize trees from the 'id_tree' crate

rust_cascade

bloom filter cascade implementation in Rust

math_adapter

Collection of math adapters to decouple your application from math libraries' implementations and to provide both inter-libraries compatibility and affordable exchangeability

memory-db

In-memory implementation of hash-db, useful for tests

json-proof-token

based on the new JOSE Working Group draft specifications: JSON Web Proof (JWP), JSON Proof Token (JPT) and JSON Proof Algorithm (JPA)

dbsp

Continuous streaming analytics engine

dagga

scheduling directed acyclic graphs of nodes that create, read, write and consume resources

zarray

Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…

board-game

board game abstraction and generic utilities around it

buffer-redux

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

vrp-pragmatic

extension logic for solving rich VRP

adler

clean-room implementation of the Adler-32 checksum

iban

parsing library

linregress

ordinary least squared linear regression with some basic statistics

opensimplex2

Port of OpenSimplex2

autodiff

automatic differentiation library

rust_dynamic

Support for dynamically-typed values in run-time

rdst

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

natord

Natural ordering for Rust

random-pick

Pick an element from a slice randomly by given weights

hora-new

Hora Search Everywhere

metrohash

high quality, high performance hash algorithm

fluent-comparisons

Boost readability by writing multicomparison expressions like if any_of!({a,b,c}>=5) {...} while keeping the benefits of hand-written code

logicng

Creating, Manipulating, and Solving Boolean Formulas

rustronomy-watershed

pure-rust implementation of the segmenting and merging watershed algorithms

poker

speedy poker hand evaluation

lib-sokoban

Sokoban: compact, efficient data structures packed into contiguous byte arrays

rattler_libsolv_c

Bindings for libsolv

rand-unique

no-std crate for generating random sequences of unique integers in O(1) time

toffee

Get command to run to run specific test in a file

diffmatchpatch

Rewrite of diff-match-patch in Rust

rev_lines

Iterator for reading files line by line with a buffer in reverse

fitsrs

FITS image parser

radiate

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

cnccoder

generating gcode operations targeted for GRBL controled cnc machines, and also generates camotics projects for simulation

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

kube_quantity

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

cheap-ruler

port of cheap-ruler, a collection of very fast approximations to common geodesic measurements

voronator

Implements the Voronoi diagram construction as a dual of the Delaunay triangulation for a set of points and the construction of a centroidal tesselation of a Delaunay triangulation

fst

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

travelling_salesman

Travelling Salesman Problem Solvers

rs-graph

graph algorithms and combinatorial optimization

sequence-generator-rust

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

timsort

modified MergeSort used in Python and Java

guid-create

helper for creating GUIDs

liba

algorithm library based on C/C++ language

pso-rs

Particle Swarm Optimization implementation in Rust

ms_toollib

Algorithms for Minesweeper

extsort-iter

external sorting for all types for all iterators

regex-lite

lightweight regex engine that optimizes for binary size and compilation time

dynalgo

tiny library designed to produce animated SVG images that can illustrate graph algorithms in action

rlifesrc-lib

Game of Life pattern searcher (library)

cobyla

optimizer for Rust

crcxx

computes CRC-8/16/32/64/128 using various methods. Included catalog of CRC parameters simplify usage.

kewb

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

genevo

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

shardtree

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

thincollections

Alternative implementations for vector, map and set that are faster/smaller for some use cases

lctree

Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees

pcg_rand

PCG family of random number generators in pure Rust

g2poly

Primitive implementation of polynomials over the field GF(2)

genetic_algorithm

genetic algorithm implementation

test-data-generation

light-weight library that analyzes sample data to build algorithms and generates realistic test data

ramp

high-performance multiple-precision arithmetic library

chronologic

Time constraint reasoning (scheduling...)

fixed2float

Fixed point to floating point conversion utility

chalk-engine

Core trait engine from Chalk project

stream-more

Stream utilities for Rust

jellyfish

Approximate and phonetic matching of strings

rln

APIs to manage, compute and verify zkSNARK proofs and RLN primitives

collate

Traits and a data structure to support collation and bisection

editdistancek

Fast algorithm for computing edit distance

bash-builtins

implement loadable builtins for bash

petal-neighbors

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

what3words

client for What3Words v3 API, allowing you to convert coordinates to three-word addresses and vice versa

sepax2d

safe crate for finding and resolving collisions of 2D convex shapes using the Separating Axis Theorem

num_convert

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

nuts-rs

Sample from unnormalized densities using Hamiltonian MCMC

overlord

consensus procotol

path-finding-lib

variety of path finding and graph operations. Work in progress.

hpke-rs-crypto

Traits and types for HPKE crypto backends

dmp

high-performance library in that manipulates plain text

rustmex

Rustmex: providing convenient Rust bindings to Matlab MEX API's

pasture-algorithms

Point cloud algorithms for pasture

qip-iterators

Iterators for tensor product matrix multiplication

portmatching

Fast Graph Matching for Port Graphs

random

package provides sources of randomness

sortby

adds convenient sort functions for Iterators

wavefc

home-grown implementation of the Wave Function Collapse algorithm

time_series_generator

Generate various timeseries of given length, some randomly sampled

cuid

ipmlementation of CUID protocol in rust

geos-sys

GEOS C API bindings

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.

fast_paths

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

movavg

Generic Moving Average calculation

cast

Ergonomic, checked cast functions for primitive types

flowmium

workflow orchestrator that use Kubernetes

deranged

Ranged integers

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

times

Timing Benchmark, Repeated Runs, with Statistics

bitm

bit and bitmap (bit vector) manipulation

human-sort

Human sort (natural sort) implementation

rsgenetic

providing genetic algorithm execution

mhgl

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

graus-db

high-performance, thread-safe key-value embedded data store

out

fast min and max functionality for collections

mozilla/sync-guid

Firefox Application Services

pi_spatial

sparial octtree quadtree

levenshtein-diff

Generic implementation of Levenshtein's algorithm that also allows you to generate the edits required to convert a source sequence to a target, and apply them to the source sequence to regenerate the target

elipdotter

Embeddable full text search engine

rip_shuffle

Fast sequential and parallel in-place shuffling algorithms

requests_rs

sending GET/POST requests and parsing jsons, included with an async file downloader. Intended for mostly small projects which need to make quick GET/POST requests or download files.

norms

collection of distance metrics on strings

four-char-code

string of 4 ascii chars represented by an u32

native-pkcs11-traits

Traits for implementing and interactive with native-pkcs11 module backends

changeforest

Random Forests for Change Point Detection

flat_spatial

Flat spatial partitionning algorithms and data structures

screwsat

condlict driven clause learning sat solver

b4s

Binary Search Single Sorted String: Perform binary search on a single, delimited string slice of sorted but unevenly sized substrings

multiexp

Multiexponentation algorithms for ff/group

sudoku-solver

backtracking algorithm for solving sudoku

raphy

graph data structure library

buf-min

Minimal utf-8 safe buffer traits

turborand

Fast random number generators

localsearch

Local Search based Metaheuristics

uniset

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

UUID_extend

Extension of uuid generation based on snowflake algorithm and implementation of ID to string conversion

relog

Strong String Normalization

rmqtt-raft

- A raft framework, for regular people

od_opencv

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

rusty_planner

Artificial intelligence planning & reasoning library for Rust

fmttools

Tools for modifying text without allocating any intermediate buffers or unsafe code

fastapprox

Fast approximate versions of certain functions that arise in machine learning

sub-strs

finding sub strings

permutation

Small utility for creating, manipulating, and applying permutations

convert-base

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

rtforth

Forth implemented in Rust for realtime application

lazy-prime-sieve

Lazy Sieve of Eratosthenes for infinitely generating primes lazily in Rust

gix-hashtable

that provides hashtable based data structures optimized to utilize ObjectId keys

fenris-geometry

Geometry functionality for fenris

route_verification_irr

Parse RPSL in the IRR to verify observed BGP routes

bies

Helpers for dealing with BIES vectors with text segmentation applications

fast_poisson

Bridson's algorithm for fast Poisson disk sampling

colourado-iter

small and minimalistic library to generate a random color palette of infinite size

ferment-interfaces

Traits for FFI conversions and some helper methods

rand_hc

HC128 random number generator

graphalgs

Graph algorithms based on the Rust 'petgraph' library

autour_core

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

easer

Tiny library imlementing Robert Penner's easing functions

lutz

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

text-file-sort

Sort a text file similar to linux sort

indexical

indexed collections

twofloat

Double-double arithmetic functionality

eqlog

Datalog with equality

hyperloglog

in Rust

matlab-sys

bindings for the Matlab C API

four-bar

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

arrayfire_fork

ArrayFire is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…

lazy_diamond_square

Lazy and fast implementation of the diamond-square without randomness

whittaker-eilers

sparse matrix implementation of Whittaker-Eilers smoothing and interpolation

hkalbasi-rustc-ap-rustc_index

Automatically published version of the package rustc_index in the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github…

acvm

virtual machine that processes ACIR given a backend/proof system

powierza-coefficient

Powierża coefficient is a statistic for gauging if one string is an abbreviation of another

spectre

lightweight toolkit for analysing p2p network topologies

simplerand

fast random number generator

tailcall

Safe, zero-cost tail recursion

hash40

working with Hash40 types in Smash Ultimate

mzpeaks

representing peaks in mass spectrometry data

multidimension

High-level manipulation of multi-dimensional arrays

favannat

Algorithms to evaluate the function encoded in ANN-like structures

cellumina

configure and run cellular automata

equation

mathematical expression evaluation and simplification

competitive-programming-rs

Competitive Programming Library in Rust

mahf

framework for modular construction and evaluation of metaheuristics

pagat

that helps you split the bill

random_color

generating random attractive colors

libbruteforce

brute force hashes (e.g. passwords). It includes a set of pre-configured hashing functions, like md5 or sha256. You can also provide your own hashing function. PLEASE DO NOT use this…

vpsearch

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

intel-mkl-sys

binding of unique functions in Intel(R) MKL

decompound

Decompose a compound word into its constituent parts. Works in any language, as you provide the rules around what constitutes a (*single*) word.

minecraft_downloader_core

Minecraft downloader written in rust

cdchunking

Content-defined chunking

hilbert

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

sif-embedding

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

const-crc32

const fn implementation of crc32 checksum algorithm

rand_simple

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

llm-bloom

BLOOM (BigScience Large Open-science Open-access Multilingual Language Model) for the llm ecosystem

gf256

containing Galois-field types and utilities

pdqselect

Selects the kth smallest element of a slice, based on Orson Peters's Pattern Defeating Quickselect

clf

flush the cpu cache line by __builtin_clear_cache()

eviolite