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_jitter

Random number generator based on timing jitter

bytecount

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

rand_pcg

Selected PCG random number generators

rand_os

OS backed Random Number Generator

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

twox-hash

A Rust implementation of the XXHash algorithm

adler32

Minimal Adler32 implementation for Rust

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

crc

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

md5

The package provides the MD5 hash function

pathfinding

Pathfinding, flow, and graph algorithms

geos

Rust bindings for GEOS C API

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

rand_xorshift

Xorshift random number generator

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

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.

fst

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

fake

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

rand_chacha

ChaCha random number generator

raft

The rust language implementation of Raft algorithm

elasticlunr-rs

A partial port of elasticlunr.js to Rust

probability

The package provides a probability-theory toolbox

rand_isaac

ISAAC random number generator

decorum

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

triple_buffer

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

proj

Rust bindings for PROJ

rustfft

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

extprim

Extra primitive types (u128, i128)

textnonce

Text based random nonce generator

alphanumeric-sort

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

rand_hc

HC128 random number generator

passwords

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

ratelimit_meter

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

metrohash

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

out

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

ncollide3d

2 and 3-dimensional collision detection library in Rust

whatlang

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

hbbft

The Honey Badger of Byzantine Fault Tolerant Consensus Protocols

ncollide2d

2 and 3-dimensional collision detection library in Rust

quantiles

a collection of approximate quantile algorithms

polylabel

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

numext-fixed-uint

Fixed-size uint types

highway

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

programinduction

A library for program induction and learning representations

numext-fixed-hash

Fixed-size hash types

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

hashmap_core

Implementation of HashMap and HashSet for no_std environments

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

random-pick

Pick an element from a slice randomly by given weights

rsgenetic

A library providing genetic algorithm execution

rand_distr

Sampling from random number distributions

fallible-iterator

Fallible iterator traits

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…

streaming-stats

Experimental crate for computing basic statistics on streams

permutohedron

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

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…

punkt

An implementation of a Punkt sentence tokenizer

special

The package provides special functions

k

k is for kinematics

flo_binding

Declarative binding library for Rust

ipopt

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

rdrand

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

afsort

American Flag sort implementation for faster sorting of Strings

worley-noise

Worley noise implementation

vek

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

zipf

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

is_sorted

Is an Iterator sorted?

vpsearch

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

bitintr

Portable Bit Manipulation Intrinsics

linear_solver

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

cdshealpix

Rust implementation of the HEALPix tesselation

vrf

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

line_drawing

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

numext-constructor

Fixed-size uint and hash constructor

hnsw

Fast approximate nearest neighbors

noise

Procedural noise generation library

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…

boyer-moore-magiclen

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

sdset

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

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…

geohash

Geohash implementation for Rust

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…

cubic_spline

Function that calculates curve points for cubic spline

slice-group-by

Iterators over groups in a slice

crates-io-cli

Interact with crates.io from the command-line

pikkr

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

numext-fixed-uint-core

A internal crate used by numext-fixed-uint

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)

bibicode

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

sublime_fuzzy

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

spaces

Set/space primitives for defining machine learning problems

levenshtein

Levenshtein algorithm

usher

Parameterized routing for generic resources in Rust

graphplan

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

strength_reduce

Faster integer division and modulus operations

faiss

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

numext-fixed-uint-hack

A internal crate used by numext-fixed-uint

fxhash

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

float-ord

A total ordering for floating-point numbers

gear

Collision avoidance path planning for robotics

crc16

A CRC16 implementation

axgeom

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

collider

A library for continuous 2D collision detection for game developement

oxigen

Fast, parallel, extensible and adaptable genetic algorithm library

external_sort

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

rust-lapper

A fast and easy interval overlap library

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

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

oorandom

A tiny, robust PRNG implementation

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

qptrie

A QP-Trie implementation for Rust

numext-fixed-hash-core

A internal crate used by numext-fixed-hash

rustdct

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

vecshard

Split Vecs in constant time

astro

Advanced algorithms for astronomy

hime_redist

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

cuckoofilter

Cuckoo Filter: Practically Better Than Bloom

munkres

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

rs_algo

Common sorting algorithms and other common computer science algorithms

multistream-batch

Different types and implementations of batching algorithms

jumphash

A Fast, Minimal Memory, Consistent Hash Algorithm

nhl-stats

NHL Stats API client for Rust created using openapi-generator

numext-fixed-hash-hack

A internal crate used by numext-fixed-hash

simsearch

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

startin

A Delaunay triangulator for terrains

fast_paths

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

fst-levenshtein

Search finite state transducers with fuzzy queries using Levenshtein automata

zhang_hilbert

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

raftlog

An implementation of distributed replicated log based on the Raft algorithm

bidir-map

Bidirectional map implementation for Rust

tile-grid

Library for map tile grid calculations

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…

crc_all

A Pure Rust Implementation of Generic CRC Algorithm

diffr-lib

An implementation of Myers diff algorithm

subslice

Fast subslice search

eudex

A blazingly fast phonetic reduction/hashing algorithm

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.

coord_transforms

A Rust crate use for performing coordinate transformations

timely_sort

Sorting infrastructure for timely dataflow

zeros

Extensions for hashing crates

specs_scene_graph

scene graph for specs

hashers

A collection of non-cryptographic hashing algorithms for Rust

superslice

Extensions for slices

graphene

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

ffts

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

random_color

Rust crate for generating random attractive colors

indexed_bitvec

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

lis

Longest increasing subsequence algorithm

integer-sqrt

An implementation of integer square root algorithm for primitive rust types

xbar

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

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.

simplers_optimization

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

osqp

The OSQP (Operator Splitting Quadratic Program) solver

pocket_prover-set

A base logical system for PocketProver to reason about set properties

darwin-rs

Evolutionary algorithms library written in Rust

count_sort

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

spmc_buffer

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

aliasmethod

Implementation of Walker’s Alias method

advancedresearch-tree_mem_sort

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

rustfst

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

nats-types

Enumerations and types for representing NATS protocol messages

mop

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

osmgraphing

Playing around with graphs created via parsing OpenStreetMap data

rvs-repl

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

sfmt

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

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

natural

Pure rust library for natural language processing

quadtree_rs

Point/region Quadtree with support for overlapping regions

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.

sfcgal

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

solvent

Dependency Resolver library

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)

aristeia

An evolutionary computation library

treediff

Find the difference between arbitrary data structures

easy_reader

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

natord

Natural ordering for Rust

just-argon2

Bindings to the argon2 C library

pdqsort

Pattern-defeating quicksort

bravery_router

Radix Tree implementation

bsa3-hash

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

streaming_algorithms

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

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

contrail

Simple state restoration for backtracking search algorithms using a trail

rvs-parser

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

bitap

Bitap implementation in rust

hypernonsense

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

rustlex_fsa

Library for manipulating (deterministic) finite automata

cang-jie

A Chinese tokenizer for tantivy

nqueens-oxigen

N Queens problem resolution using oxigen

sub-strs

For finding sub strings

raftlog_protobuf

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

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

geometry-predicates

ordslice

Extensions for ordered slices

human-sort

Human sort (natural sort) implementation

labelgraph

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

tilecover

Generate the minimum number of tiles to cover a geometry

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

galois_2p8

Basic Arithmetic over all GF(2^8) fields

fossil-delta

Provides functions for calculating differences between strings and applying calculated deltas

common_macros

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

srand

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

mix-distribution

Mixture distributions

fuss

Small, lightweight simplex noise generator for Rust

gcd

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

onemax-oxigen

OneMax simple problem resolution using oxigen

flo_curves

Library for manipulating Bezier curves

lzjd

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

howto

instant coding answers via the command line

test-data-generation

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

acacia

A spatial partitioning and tree library

rtriangulate

Delaunay triangulation on a set of points

rake

Rust implementation of Rapid Automatic Keyword Extraction (RAKE) algorithm

fuzzyhash

Pure Rust fuzzy hash implementation

visit_diff

Efficiently finding differences between data structures

kendalls

Kendall’s tau rank correlation

rendezvous_hash

An implementation of Rendezvous hashing algorithm

actix-raft

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

indexed_bitvec_core

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

sortrs

An introspective sort implementation

kahan

Provides types to perform Kahan summation

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

wyhash

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

random-trait

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

dia-range

Ranges for all integers

dft

The package provides an algorithm to compute the discrete Fourier transform

sbitty

library defining bitwise operations on standard integers type

crc32c

Wrapper for SSE 4.2 CRC32C instructions, with software fallback

xx-bloomfilter

Bloom filter implementation using xx hash

rootfind

Root-finding algorithms

rdp

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

quasirandom

Quasirandom number generation

bft-core

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

spiral

Iterate over a 2D structure in a spiral pattern

quickbacktrack

Library for back tracking with customizable search for moves

geos-sys

GEOS C API bindings

block-array-cow

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

hierarchical_pathfinding

A crate to quickly approximate Paths on a Grid

algorithmica

Rust Algorithms

ostn02_phf

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

non-dominated-sort

Fast Non-Dominated Sort Algorithm

rvs

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

doryen-fov

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

xorshift128plus-rs

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

int_traits

Provides a trait for extended functions on integers

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

accurate

(more or less) accurate floating point algorithms

pack

Solver for packing puzzle

spanish-numbers

Convert integers to written Spanish number format

weighted-rs

A libray for weighted balancing algorithm

sift4

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

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

co_sort

Sort arrays given a permutation

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

nanoid

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

sprs-ldl

Sparse cholesky factorization

extfsm

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

smeagol

Conway’s Game of Life using HashLife and SIMD

rstat

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

zpatial

Algorithms for Spatial Acceleration and Geometries

reingold-tilford

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

geo-rand

Generate random geometric shapes

extsort

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

rkm

A generic k-means implementation

kademlia-dht

A simple implementation of the Kademlia DHT

algoliasearch

Algolia client

shine-graph

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

msws

Middle Square Weyl Sequence pseudorandom number generator

muldiv

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

cycle-sort

Simple generic Cycle sort implementation

partitions

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

consistent_hash_ring

A flexible and efficient consistent hash ring

bip_dht

Implementation of the bittorrent mainline DHT

sdbm

SDBM is a non-cryptographic hashing algorithm

crc32c-hw

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

suffix_array

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

ffts-sys

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

bloodhound

Fuzzy file finder

triangulation

A collection of triangulation algorithms

streamlined-ntru-prime

Rust implementation of the Streamline NTRU Prime algorithm

batsat

Extensible SAT solver in Rust

raft-proto

Protocol definitions for the rust language implementation of the Raft algorithm

const-random-macro

Provides the procedural macro used by const-random

fuzzy_dbscan

An implementation of the FuzzyDBSCAN algorithm

tdigest

T-Digest algorithm in Rust

hyparview

A Rust implementation of HyParView algorithm

scailist

A fast and easy interval overlap library

order-stat

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

index-fixed

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

geo-visibility

Compute visibility polygon

revonet

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

xorshift

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

internet-checksum

RFC 1071 checksum computation (the “internet checksum”)

floyd-warshall-alg

Floyd-Warshall algorithm supporting customization

pruefung

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

t1ha

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

hwt

Hamming Weight Tree for finding neighbors in Hamming space

yyid

YYID generator (random tokens like UUIDv4)

crcdir

A thin wrapper around crc32fast to checksum an entire directory

garbo

Global reference-counted, thread-sharable, immutable heap

count-min-sketch

Count-min-sketch implementation

hashed-permutation

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

hyperbolic_graph_generator

Create different types of hyperbolic graphs

abstractgraph

Abstract Graph Algorithms

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…

kmpsearch

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

mersenne_twister

Mersenne Twister pseudorandom number generator

checksum

Calculates crc32/crc64 file checksums written in Rust

twox-hash-cli

A cli for the twox-hash crate

conshash

A library to do consistent hashing in Rust

fera

An aggregation of algorithms, data structures and supporting crates

cuckoocache

High performance concurrent cache

glicko2

Implementation of the glicko2 rating system

sorts

A collection of sorting algorithms

sharpen

A rust library for iterator element condensing and sharpening

rusted_list

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

grue

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

rosalind-cli

CLI for rosalind crate

thin-slice

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

delaunay2d

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

number_traits

number traits

highwayhash

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

atomic-traits

The traits for generic atomic operations

hamming-heap

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

djb33

DJB33 hash algorithm write in Rust

kmeans

Small and fast library for k-means clustering calculations

longest-increasing-subsequence

Find a longest increasing subsequence of some input sequence

bex

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

rust-sort

Implementation of common sorting algorithms, purely for learning

plumtree

A Rust implementation of Plumtree algorithm

sorty

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

lcs-diff

Compute differences between two slices using LCS algorithm

haikunator

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

fast_inv_sqrt

Fast inverse square root algorithm implementation

rosalind

Crate contains solutions of problems published on Rosalind.info

algs4

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

galil-seiferas

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

quadtree-cd

A quadtree-based data structure for placing shapes such as rotated rectangles in bounded 2D space, checking for collision with already placed items

polystem

Popular stemming algorithms for Information Retrieval

fsm

A simple Finite State Machine library, provide State and Event types, then create a machine with an initial state, give it some transition behaviours and you have your state machine!

random_choice

Chooses samples randomly by their weights/probabilities