Algorithm catalogue

2250 catalog entries from docs/algos.md: each id is an anchor, and a mapped entry links to its module in the standard library catalogue.

1. Sorting, Searching & Selection Algorithms (1–60)

#1Quick Sort

Partitioning array around a pivot recursively. — e.algo.sort.quick

#2Merge Sort

Divide-and-conquer stable sorting algorithm. — e.algo.sort.merge

#3Heap Sort

Binary heap-based comparison sort. — e.algo.sort.heap

#4Bubble Sort

Repeatedly swapping adjacent out-of-order elements. — skip: pedagogical only

#5Insertion Sort

Building sorted array one element at a time. — e.algo.sort.insertion

#6Selection Sort

In-place comparison search for minimum value. — skip: pedagogical only

#7Counting Sort

Non-comparison integer sorting by frequency keys. — e.algo.sort.counting

#8Radix Sort

Digit-by-digit positional integer sorting. — e.algo.sort.radix_u32_in_place

#9Bucket Sort

Distribution sort partitioning elements into buckets. — e.algo.sort.bucket

#10Shell Sort

In-place gap-based generalization of insertion sort. — e.algo.sort.shell

#11Tim Sort

Hybrid stable sort combining merge and insertion sort. — e.algo.sort.stable_in_place

#12Comb Sort

Improvement on bubble sort using variable gap sizes. — skip: pedagogical only

#13Pigeonhole Sort

Sorting where key count roughly equals element count. — see #7 (e.algo.sort.counting)

#14Cycle Sort

In-place unstable sort minimizing memory writes. — e.algo.sort.cycle

#15Smoothsort

Variation of heapsort using Leonardo numbers. — skip: implementable, but too specialised for the standard library

#16Tournament Sort

Tree-based selection sort using tournament trees. — skip: implementable, but too specialised for the standard library

#17Cocktail Shaker Sort

Bidirectional bubble sort. — skip: pedagogical only

#18Gnome Sort

Sorting by moving backward and forward like garden gnomes. — skip: pedagogical only

#19Bitonic Sort

Parallel sorting algorithm constructing bitonic sequences. — e.gpu.sort_bitonic

#20Pancake Sort

Sorting array using only prefix reversal operations. — skip: pedagogical only

#21Bogo Sort

Permuting array randomly until sorted (stochastic). — skip: pedagogical only

#22Binary Search

Divide-and-conquer search in sorted arrays. — e.algo.search.binary

#23Linear Search

Sequential element scan through collections. — e.algo.search.linear

#24Interpolation Search

Estimation-based search for uniformly distributed values. — e.algo.search.interpolation

#25Exponential Search

Bounded binary search for unbounded/infinite lists. — e.algo.search.exponential

#26Fibonacci Search

Search using Fibonacci numbers to divide ranges. — skip: implementable, but too specialised for the standard library

#27Ternary Search

Divide-and-conquer search dividing range into three parts. — e.algo.search.ternary

#28Jump Search

Block-based stepping search on sorted arrays. — skip: implementable, but too specialised for the standard library

#29Sublist Search

Checking if a linked list exists inside another list. — e.data.linked.contains_sublist

#30Ubiquitous Binary Search

Boundary-finding variant of binary search. — see #51 (e.algo.search.lower_bound)

#31Fractional Cascading

Speeding up consecutive binary searches across structures. — skip: implementable, but too specialised for the standard library

#32Quickselect

Selection algorithm to find k-th smallest element. — e.algo.search.kth

#33Median of Medians

Deterministic linear-time selection algorithm. — e.algo.search.kth_deterministic

#34IntroSort

Hybrid sort combining quicksort, heapsort, and insertion sort. — e.algo.sort.in_place

#35Block Sort

In-place merge sort running in O(1) extra memory. — skip: implementable, but too specialised for the standard library

#36Library Sort

Insertion sort with gaps to accelerate insertions. — skip: implementable, but too specialised for the standard library

#37Strand Sort

Sorting by repeatedly extracting sorted sub-lists. — skip: implementable, but too specialised for the standard library

#38Patience Sorting

Card-game inspired sort calculating longest increasing subsequences. — e.algo.sort.patience

#39Tree Sort

Inserting elements into a BST and reading in-order. — skip: pedagogical only

#40Cascade Merge Sort

External sorting algorithm for magnetic tape drives. — skip: implementable, but too specialised for the standard library

#41Oscillating Merge Sort

External sort using backward/forward tape reading. — skip: implementable, but too specialised for the standard library

#42Polyphase Merge Sort

Multi-way external merge sort minimizing tape runs. — e.algo.sort.external_merge

#43American Flag Sort

In-place radix sort for strings or integers. — e.algo.sort.radix_bytes

#44Bead Sort (Gravity Sort)

Natural sorting model simulating sliding beads. — skip: pedagogical only

#45Flashsort

Distribution sort estimating density distributions. — skip: implementable, but too specialised for the standard library

#46Burstsort

Fast string sorting using trie-based bucket structures. — e.algo.sort.strings

#47Postman's Sort

Hierarchical key sorting algorithm. — skip: implementable, but too specialised for the standard library

#48Spreadsort

Hybrid algorithm combining radix, bucket, and quicksort. — skip: implementable, but too specialised for the standard library

#49Stooge Sort

Recursive sorting algorithm with O(n2.71) complexity. — skip: pedagogical only

#50Slowsort

Multiply and surrender paradigm sorting. — skip: pedagogical only

#51Binary Search Lower Bound

Finding first element not less than target. — e.algo.search.lower_bound

#52Binary Search Upper Bound

Finding first element strictly greater than target. — e.algo.search.upper_bound

#53Binary Search Equal Range

Finding subrange matching given key. — e.algo.search.equal_range

#54Saddleback Search

Searching target in 2D sorted matrix. — e.algo.search.matrix_sorted

#55Meta Binary Search

One-pass binary search operating on binary bits. — skip: implementable, but too specialised for the standard library

#56Galloping Search

Searching sorted arrays with unknown lengths. — see #25 (e.algo.search.exponential)

#57Shuffling (Fisher-Yates / Durstenfeld)

Unbiased random array permutation. — e.algo.rand.shuffle

#58Sattolo's Algorithm

Generating cyclic permutations of array. — e.algo.rand.cycle_permutation

#59Reservoir Sampling

Randomly sampling k items from continuous stream. — e.algo.rand.reservoir

#60Alias Method (Walker's)

O(1) sampling from discrete probability distributions. — e.algo.rand.alias_table

2. Graph Algorithms & Network Analysis (61–180)

#61Breadth-First Search (BFS)

Layer-by-layer graph traversal. — e.algo.graph.bfs

#62Depth-First Search (DFS)

Deepest-path-first graph traversal. — e.algo.graph.dfs

#63Dijkstra's Algorithm

Single-source shortest path with non-negative weights. — e.algo.graph.dijkstra

#64Bellman-Ford Algorithm

Single-source shortest path handling negative weights. — e.algo.graph.bellman_ford

#65A* Search Algorithm

Heuristic-guided shortest path search. — e.algo.graph.path.astar

#66Floyd-Warshall Algorithm

All-pairs shortest paths via dynamic programming. — e.algo.graph.floyd_warshall

#67Kruskal's Algorithm

Minimum spanning tree using disjoint set union. — e.algo.graph.mst_kruskal

#68Prim's Algorithm

Minimum spanning tree via greedy vertex addition. — e.algo.graph.mst_prim

#69Borůvka's Algorithm

Parallel minimum spanning tree construction. — e.algo.graph.mst_boruvka

#70Tarjan's SCC Algorithm

Finding strongly connected components in O(V + E). — e.algo.graph.strong_components

#71Kosaraju's Algorithm

Two-pass DFS strongly connected components search. — see #70 (e.algo.graph.strong_components)

#72Johnson's Algorithm

All-pairs shortest path reweighting with Bellman-Ford. — e.algo.graph.johnson

#73Kahn's Algorithm

Topological sorting using vertex in-degrees. — e.algo.graph.topological

#74Ford-Fulkerson Algorithm

Augmenting-path method for maximum network flow. — see #75 (e.algo.graph.flow.edmonds_karp)

#75Edmonds-Karp Algorithm

BFS implementation of Ford-Fulkerson in O(V E²). — e.algo.graph.flow.edmonds_karp

#76Dinic's Algorithm

Level-graph blocking flow algorithm for max flow. — e.algo.graph.flow.dinic

#77Push-Relabel Algorithm

Preflow-push max flow algorithm with height labels. — e.algo.graph.flow.push_relabel

#78Hopcroft-Karp Algorithm

Maximum bipartite matching in O(E √V). — e.algo.graph.match.hopcroft_karp

#79Hungarian Algorithm (Kuhn-Munkres)

Solving the linear assignment problem. — e.algo.graph.match.hungarian

#80Hierholzer's Algorithm

Constructing Eulerian paths and circuits in O(E). — e.algo.graph.euler_path

#81Fleury's Algorithm

Finding Eulerian circuits by avoiding bridges. — skip: pedagogical only

#82Bridge Finding Algorithm

Finding critical edges whose removal disconnects graph. — e.algo.graph.bridges

#83Articulation Points Algorithm

Finding vertices whose removal disconnects graph. — e.algo.graph.articulation_points

#84Lowest Common Ancestor (Binary Lifting)

O(log N) tree LCA query. — e.algo.graph.tree.lca_binary_lifting

#85Lowest Common Ancestor (Farach-Colton & Bender)

O(1) query LCA via RMQ reduction. — e.algo.graph.tree.lca_rmq

#86Heavy-Light Decomposition

Decomposing trees into paths for segment tree queries. — e.algo.graph.tree.heavy_light

#87Centroid Decomposition

Divide-and-conquer tree decomposition around centroids. — e.algo.graph.tree.centroid_decompose

#88Prüfer Sequence Encoding

Converting labeled tree to unique sequence. — e.algo.graph.tree.prufer_encode

#89Prüfer Sequence Decoding

Reconstructing tree from Prüfer sequence. — e.algo.graph.tree.prufer_decode

#90PageRank Algorithm

Stationary distribution random-walk node importance. — e.algo.graph.centrality.pagerank

#91HITS Algorithm

Calculating Hub and Authority scores for network nodes. — e.algo.graph.centrality.hits

#92D* Search Algorithm

Incremental heuristic search for dynamic environments. — e.robot.plan.dstar_lite

#93Lifelong Planning A* (LPA*)

Incremental version of A* for changing graphs. — e.robot.plan.lpa_star

#94Bidirectional Search

Searching simultaneously from start and goal nodes. — e.algo.graph.path.bidirectional

#95Iterative Deepening DFS (IDDFS)

Depth-first search with bounded increasing depth. — e.algo.graph.path.iddfs

#96Iterative Deepening A (IDA)

Heuristic search combining IDDFS and A*. — e.algo.graph.path.ida_star

#97Uniform Cost Search

Dijkstra's variant finding optimal paths by path cost. — see #63 (e.algo.graph.dijkstra)

#98Best-First Search

Priority queue traversal using pure heuristic evaluations. — e.algo.graph.path.best_first

#99Shortest Path Faster Algorithm (SPFA)

Queue-optimized Bellman-Ford variant. — skip: implementable, but too specialised for the standard library

#100Suurballe's Algorithm

Finding pair of edge-disjoint paths with minimum total length. — e.algo.graph.path.suurballe

#101Yen's Algorithm

Finding K-shortest loopless paths in weighted graphs. — e.algo.graph.path.yen_k_shortest

#102Gale-Shapley Algorithm

Stable matching/marriage problem solution. — e.algo.graph.match.stable_marriage

#103Blossom Algorithm (Edmonds')

Maximum matching in general (non-bipartite) graphs. — e.algo.graph.match.blossom

#104Bron-Kerbosch Algorithm

Finding maximal cliques in undirected graphs. — e.algo.graph.max_cliques

#105Girvan-Newman Algorithm

Community detection removing high-betweenness edges. — e.algo.graph.community.girvan_newman

#106Louvain Community Detection

Modularity-maximization community extraction. — e.algo.graph.community.louvain

#107Label Propagation Algorithm

Community detection using network neighbor consensus. — e.algo.graph.community.label_propagation

#108Karger's Algorithm

Randomized min-cut algorithm via edge contractions. — e.algo.graph.cut.karger

#109Karger-Stein Algorithm

Fast recursive contraction min-cut algorithm. — skip: implementable, but too specialised for the standard library

#110Stoer-Wagner Algorithm

Deterministic global min-cut in undirected graphs. — e.algo.graph.cut.stoer_wagner

#111Chandy-Misra-Haas Algorithm

Distributed deadlock detection in resource networks. — e.dist.deadlock.chandy_misra_haas

#112Maximum Cost Bipartite Matching

Weighted assignment via min-cost max-flow. — see #79 (e.algo.graph.match.hungarian)

#113Gabow's Matching Algorithm

Degree-constrained maximum matching. — see #103 (e.algo.graph.match.blossom)

#114Christofides Algorithm

3/2-approximation algorithm for Metric TSP. — e.algo.combopt.tsp_christofides

#115Held-Karp Algorithm

Dynamic programming exact solution for TSP. — e.algo.combopt.tsp_held_karp

#1162-Opt Algorithm

Local search heuristic untangling crossing edges in paths. — e.algo.combopt.tsp_two_opt

#1173-Opt Algorithm

Local search heuristic recombining 3 path segments. — e.algo.combopt.tsp_three_opt

#118Lin-Kernighan Heuristic

Variable k-opt edge swapping for TSP. — e.algo.combopt.tsp_lin_kernighan

#119Boyer-Myrvold Planarity Test

Linear-time check if graph is planar. — e.algo.graph.iso.is_planar

#120VF2 Algorithm

Subgraph isomorphism detection algorithm. — e.algo.graph.iso.subgraph_vf2

#121Ullmann's Algorithm

Backtracking search for subgraph isomorphism. — skip: implementable, but too specialised for the standard library

#122Trémaux's Algorithm

Maze routing using wall marking and backtracking. — skip: pedagogical only

#123Pledge Algorithm

Obstacle bypass navigation in unknown planar environments. — skip: implementable, but too specialised for the standard library

#124Bug 1 / Bug 2 Algorithms

Sensor-based robotic path planning around obstacles. — skip: implementable, but too specialised for the standard library

#125Flood Fill Algorithm

Multi-directional connected area labeling. — e.gfx.filter.flood_fill

#126Lee's Algorithm

Grid maze pathfinding using breadth-first search wave propagation. — e.game.grid.path_bfs

#127Soukup's Algorithm

Fast line-search pathfinding variant combining BFS and DFS. — skip: implementable, but too specialised for the standard library

#128High-Low Watermark Algorithm

Flow control queue threshold management. — e.data.queue.watermarks

#129Dominator Tree Construction (Lengauer-Tarjan)

Computing flow graph dominance. — skip: belongs in the Neper compiler, not the library

#130Chord Protocol Lookup

Distributed Hash Table (DHT) key routing. — e.dist.dht.chord_lookup

#131Kademlia Routing Lookup

XOR-metric based DHT lookup algorithm. — e.dist.dht.kademlia_lookup

#132Pastry Routing Algorithm

Prefix-based overlay network routing. — skip: implementable, but too specialised for the standard library

#133Tapestry Routing Algorithm

Mesh overlay network routing using Matched Prefixes. — skip: implementable, but too specialised for the standard library

#134Raft Leader Election Algorithm

Consensus-based leader selection in clusters. — e.dist.consensus.raft_election

#135Paxos Consensus Algorithm

Distributed agreement under unreliable networks. — e.dist.consensus.paxos

#136Zab (ZooKeeper Atomic Broadcast)

Crash-recovery atomic broadcast protocol algorithm. — skip: implementable, but too specialised for the standard library

#137Byzantine Fault Tolerance (PBFT)

Consensus reaching agreement with malicious nodes. — skip: implementable, but too specialised for the standard library

#138Spanning Tree Protocol (STP / 802.1D)

Loop prevention in Ethernet networks. — skip: network protocol beyond the library scope

#139Distance Vector Routing (Bellman-Ford variant)

Distributed router table calculation. — skip: network protocol beyond the library scope

#140Link State Routing (Dijkstra variant)

Router topology flooding and local shortest path. — skip: network protocol beyond the library scope

#141BGP Path Vector Routing

Inter-domain Internet routing path selection algorithm. — skip: network protocol beyond the library scope

#142Gossip Protocol

Epidemic peer-to-peer state dissemination. — e.dist.gossip.disseminate

#143Bully Algorithm

Distributed process leader election by rank. — e.dist.election.bully

#144Ring Leader Election Algorithm

Token-passing ring network election. — e.dist.election.ring

#145Ricart-Agrawala Algorithm

Distributed mutual exclusion via timestamped requests. — e.dist.mutex.ricart_agrawala

#146Maekawa's Algorithm

Quorum-based distributed mutual exclusion. — skip: implementable, but too specialised for the standard library

#147Lamport's Logical Clocks

Ordering events in distributed systems without physical clocks. — e.dist.clock.lamport

#148Vector Clocks Algorithm

Causality tracking across distributed nodes. — e.dist.clock.vector

#149Marzullo's Algorithm

Time synchronization combining overlapping noisy intervals. — e.time.sync.marzullo

#150Berkeley Algorithm

Internal physical clock synchronization for connected nodes. — e.time.sync.berkeley

#151Cristian's Algorithm

Time sync over client-server networks with unknown latency. — e.time.sync.cristian

#152Chandy-Lamport Algorithm

Distributed global snapshot recording without pausing. — e.dist.snapshot.chandy_lamport

#153Raynal's Distributed Mutual Exclusion

Request-based token pass mutual exclusion. — skip: implementable, but too specialised for the standard library

#154Raymond's Tree-Based Algorithm

Distributed mutual exclusion on token trees. — e.dist.mutex.raymond_tree

#155Suzuki-Kasami Algorithm

Token-based distributed mutual exclusion. — skip: implementable, but too specialised for the standard library

#156Agrawal-El Abbadi Quorum Protocol

Tree-structured quorum algorithm for fault tolerance. — skip: implementable, but too specialised for the standard library

#157Gaffke's Minimum Spanning Tree

Directed minimum spanning tree (Arborescence). — see #158 (e.algo.graph.arborescence)

#158Edmonds' Branching Algorithm (Chu-Liu/Edmonds)

Directed graph optimum arborescence. — e.algo.graph.arborescence

#159Transitive Closure (Warshall's Algorithm)

Reachability matrix computation. — e.algo.graph.transitive_closure

#160Graph Coloring (Welsh-Powell)

Greedy vertex coloring sorted by node degree. — e.algo.graph.color.greedy

#161DSATUR Graph Coloring

Vertex selection based on degree of saturation. — e.algo.graph.color.dsatur

#162RLF (Recursive Largest First) Coloring

Independent set construction graph coloring. — skip: implementable, but too specialised for the standard library

#163Kempe Chains Algorithm

Edge-swapping method used in planar graph coloring. — skip: implementable, but too specialised for the standard library

#164Min-Max Flow Optimization

Fair network bandwidth allocation. — e.algo.graph.flow.max_min_fair

#165Max-Weight Bipartite Matching (Auction Algorithm)

Distributed auction assignment. — e.algo.graph.match.auction

#166Suurballe-Tarjan Shortest Path

Fast two-disjoint-path routing. — see #100 (e.algo.graph.path.suurballe)

#167Thorup's Algorithm

O(V + E) single-source shortest paths on undirected graphs. — skip: research-grade, no settled practical implementation

#168Dial's Algorithm

Bucket-optimized Dijkstra for small integer weights. — e.algo.graph.dial

#169Radix Heap Dijkstra

Monotonic priority queue optimization for pathfinding. — e.algo.graph.dijkstra_radix_heap

#170Shortest Path Tree Reconstruction

Reconstructing actual path vectors from parents. — e.algo.graph.path_to

#171Graph Center Finding Algorithm

Vertex minimizing maximum distance to all nodes. — e.algo.graph.center

#172Graph Periphery / Diameter Calculation

Finding two most distant nodes in graph. — e.algo.graph.diameter

#173Closeness Centrality Algorithm

Reciprocal sum of shortest path distances to nodes. — e.algo.graph.centrality.closeness

#174Betweenness Centrality (Brandes' Algorithm)

Shortest-path vertex load calculation. — e.algo.graph.centrality.betweenness

#175Eigenvector Centrality Algorithm

Power-iteration node influence scoring. — e.algo.graph.centrality.eigenvector

#176K-Core Decomposition Algorithm

Subgraph extraction where all nodes have degree ≥ k. — e.algo.graph.k_core

#177Truss Decomposition Algorithm

Edge triangle-containment subnetwork extraction. — e.algo.graph.k_truss

#178Triangle Counting (Forward Algorithm)

Exact graph triangle enumeration. — e.algo.graph.count_triangles

#179Min-Hash Graph Sparsification

Preserving spectral properties while dropping edges. — skip: implementable, but too specialised for the standard library

#180Stoer Min-Cut Phase Algorithm

Repeated target-less min-cut contraction. — see #110 (e.algo.graph.cut.stoer_wagner)

3. Tree & Data Structure Operations (181–290)

#181Binary Search Tree Insertion

Placing items preserving left-smaller right-larger invariant. — e.data.tree.put

#182Binary Search Tree Deletion

Node removal handling 0, 1, or 2 children (inorder successor). — e.data.tree.remove

#183AVL Tree Rotation (Left / Right)

Single rotations rebalancing tree height. — skip: an implementation detail of an existing module, not an API

#184AVL Tree Double Rotation (Left-Right / Right-Left)

Dual rotation balancing skewed subtrees. — skip: an implementation detail of an existing module, not an API

#185Red-Black Tree Insert Rebalancing

Color flips and rotations preserving black-height. — skip: an implementation detail of an existing module, not an API

#186Red-Black Tree Delete Rebalancing

Handling double-black nodes using sibling transformations. — skip: an implementation detail of an existing module, not an API

#187Splay Tree Splay Operation

Zig, Zag, Zig-Zig, and Zig-Zag operations bringing node to root. — e.data.splay.splay

#188Treap Split

Splitting Treap into two trees based on key threshold. — e.data.treap.split

#189Treap Merge

Combining two Treaps matching priority invariants. — e.data.treap.merge

#190Scapegoat Tree Rebuilding

Rebalancing subtrees when balance alpha factor triggers. — skip: implementable, but too specialised for the standard library

#191B-Tree Node Splitting

Promoting median key upward when node exceeds capacity. — e.data.btree.split_node

#192B-Tree Node Merging

Combining underflow nodes during key deletion. — e.data.btree.merge_node

#193B+ Tree Leaf Insertion

Appending leaf items while updating parent range pointers. — e.data.btree.insert

#194Fenwick Tree Point Update

Adding value and propagating using LSB increment ( i += i & -i ). — e.data.fenwick.add

#195Fenwick Tree Prefix Sum Query

Accumulating range values using LSB decrement ( i -= i & -i ). — e.data.fenwick.prefix_sum

#196Segment Tree Construction

Building array-backed range-query tree in O(N). — e.data.segment_tree.build

#197Segment Tree Range Query

Aggregating sub-segments matching target interval. — e.data.segment_tree.query

#198Segment Tree Lazy Propagation

Deferred sub-tree updates for efficient range mutations. — e.data.segment_tree.update_range

#199Persistent Segment Tree Modification

Creating path-copy version history of tree states. — e.data.segment_tree.persistent_update

#200Disjoint Set Union (DSU) Find

Element root discovery using path compression. — e.algo.disjoint_set.find

#201DSU Union by Rank / Size

Merging smaller set root into larger set root. — e.algo.disjoint_set.join

#202DSU Rollback

Undoing tree unions using state history stacks. — e.algo.disjoint_set.rollback

#203Trie Insertion

Character-by-character child node path traversal. — e.data.trie.insert

#204Trie Search

Prefix or full-word node path validation. — e.data.trie.get

#205Trie Deletion

Unwinding unused child branches recursively. — e.data.trie.remove

#206Compressed Trie (Radix/Patricia) Compact

Merging single-child nodes to reduce depth. — e.data.trie.compact

#207Suffix Tree Ukkonen's Algorithm

Online linear-time suffix tree construction. — e.text.suffix.tree_build

#208Suffix Array SA-IS Algorithm

Linear-time induced sorting of suffix strings. — e.text.suffix.array_build

#209Kasai's LCP Array Construction

O(N) Longest Common Prefix calculation from suffix array. — e.text.suffix.lcp_array

#210Cartesian Tree Construction

Building heap-ordered tree from array in O(N). — e.data.cartesian_tree.build

#211Link-Cut Tree Access Operation

Preferred path updating in dynamic forest trees. — e.data.link_cut.access

#212Link-Cut Tree Link / Cut

Dynamic tree joining and detachment algorithms. — e.data.link_cut.link

#213Euler Tour Technique

Flattening tree into 1D array via entry/exit timestamps. — e.algo.graph.tree.euler_tour

#214Tree Rebuilding from Traversal

Reconstructing tree given Preorder and Inorder inputs. — e.data.tree.from_traversals

#215AHU Tree Isomorphism Test

Canonical string generation for unlabeled trees. — e.algo.graph.tree.is_isomorphic

#216Van Emde Boas Tree Operations

O(log log U) predecessor/successor searches. — skip: implementable, but too specialised for the standard library

#217Dancing Links (Knuth's Algorithm X)

Exact cover problem solver using sparse matrix links. — e.algo.exact_cover.solve

#218BK-Tree Metric Distance Search

String spell-checking via Levenshtein-distance tree traversal. — e.data.bk_tree.search

#219Quadtree Insertion & Subdivision

Splitting spatial node into 4 quadrants upon threshold. — e.data.spatial.quadtree_insert

#220Octree Insertion & Subdivision

Splitting 3D spatial node into 8 octants. — e.data.spatial.octree_insert

#221KD-Tree Construction

Splitting multidimensional points along alternating median axes. — e.data.spatial.kd_build

#222KD-Tree Nearest Neighbor

Hypersphere branch pruning range traversal. — e.data.spatial.kd_nearest

#223R-Tree Spatial Insertion

Bounding box expansion and minimal area node splitting. — e.data.spatial.rtree_insert

#224Interval Tree Overlap Query

Finding all intervals intersecting given range. — e.data.spatial.interval_overlap

#225Wavelet Tree Quantile Query

Finding k-th smallest value in subsegment in O(log Σ). — e.data.succinct.wavelet_quantile

#226Skip List Insertion

Probabilistic height assignment and multi-level forward linkage. — e.data.skip_list.insert

#227Skip List Deletion

Splice removal across indexed list layers. — e.data.skip_list.remove

#228Binary Heap Sift-Up

Moving parent element upward until min/max heap condition holds. — e.data.heap.push

#229Binary Heap Sift-Down

Moving node downward replacing smaller/larger child. — e.data.heap.pop

#230Heapify (Floyd's Algorithm)

Constructing array heap in linear O(N) time. — e.data.heap.heapify

#231Fibonacci Heap Consolidate

Linking equal-degree trees during minimum extraction. — skip: implementable, but too specialised for the standard library

#232Binomial Heap Union

Merging binomial trees of equal order. — e.data.heap.binomial_merge

#233Pairing Heap Decrease-Key

Two-pass tree merging priority queue operations. — e.data.heap.pairing_decrease_key

#234Leftist Heap Merge

Recursive structural combination maintaining null path length. — e.data.heap.leftist_merge

#235Skew Heap Merge

Self-adjusting heap merging unconditionally swapping subtrees. — e.data.heap.skew_merge

#236Min-Max Heap Operations

Single array structure supporting O(1) Min and Max extraction. — e.data.heap.min_max

#237Bloom Filter Insertion

Setting bits across k independent hash functions. — e.algo.sketch.bloom_insert

#238Bloom Filter Membership Test

Bitwise AND evaluation checking bit locations. — e.algo.sketch.bloom_contains

#239Counting Bloom Filter Deletion

Decrementing location counters instead of single bits. — e.algo.sketch.counting_bloom_remove

#240Cuckoo Filter Insertion

Kicking out existing keys to alternate hash locations. — e.algo.sketch.cuckoo_insert

#241Quotient Filter Operations

In-cache compact hashtable using fingerprint quotients. — e.algo.sketch.quotient_filter

#242HyperLogLog Cardinality Estimation

Estimating unique items using leading zero counts. — e.algo.sketch.hll_estimate

#243Count-Min Sketch Update

Adding item count across parallel frequency arrays. — e.algo.sketch.count_min_add

#244Count-Min Sketch Query

Extracting minimum value among hashed bucket locations. — e.algo.sketch.count_min_estimate

#245Heavy Hitters Algorithm (Misra-Gries)

Tracking top-k frequent stream items. — e.algo.sketch.misra_gries

#246Space-Saving Algorithm

Stream frequency estimation with bounded error. — e.algo.sketch.space_saving

#247Hash Table Open Addressing (Linear Probing)

Resolving collisions via step sequential scans. — skip: an implementation detail of an existing module, not an API

#248Hash Table Quadratic Probing

Collision resolution using quadratic step function. — skip: an implementation detail of an existing module, not an API

#249Hash Table Double Hashing

Using second hash output as secondary probe step size. — skip: an implementation detail of an existing module, not an API

#250Robin Hood Hashing

Stealing from rich keys to equalize probe sequence length. — skip: an implementation detail of an existing module, not an API

#251Hopscotch Hashing

Moving items within bounded neighborhood windows. — skip: an implementation detail of an existing module, not an API

#2522-Choice Hashing

Inserting item into shorter of two alternate hash buckets. — skip: an implementation detail of an existing module, not an API

#253Cuckoo Hashing Lookup

O(1) guaranteed lookup across dual hash tables. — skip: an implementation detail of an existing module, not an API

#254Dynamic Resizing / Rehashing

Allocating doubled array size and redistributing entries. — skip: an implementation detail of an existing module, not an API

#255Consistent Hashing (Ring Topology)

Distributing keys across nodes using hash ring slots. — e.algo.consistent_hash.ring_lookup

#256Rendezvous Hashing (Highest Random Weight)

Independent node selection for key replication. — e.algo.consistent_hash.rendezvous

#257Locality-Sensitive Hashing (LSH)

Hashing items so similar vectors map to same buckets. — e.algo.sketch.lsh_bucket

#258MinHash Calculation

Estimating Jaccard similarity between set items. — e.algo.sketch.minhash

#259SimHash Algorithm

Dimensionality reduction mapping text features to bitwise distance. — e.algo.sketch.simhash

#260Doubly Linked List Node Splice

Modifying 4 pointer links to insert/extract sequence. — e.data.linked.splice

#261XOR Linked List Traversal

Using pointer XOR combinations to traverse bidirectionally. — skip: pedagogical only

#262Unrolled Linked List Search

Array-node hybrid traversal for cache optimization. — skip: implementable, but too specialised for the standard library

#263Self-Organizing List (Move-To-Front)

Relocating accessed node directly to head. — e.data.linked.move_to_front

#264Self-Organizing List (Transpose)

Swapping accessed node with its immediate predecessor. — skip: implementable, but too specialised for the standard library

#265Ring Buffer Enqueue/Dequeue

Circular array head/tail pointer increment modulo size. — e.data.ring.push

#266Monotonic Stack Construction

Maintaining strictly increasing/decreasing element stack. — e.algo.dp.monotonic_stack

#267Monotonic Queue Slide Window

Maintaining min/max elements in sliding temporal window. — e.data.window.monotonic_queue

#268LRU Cache Eviction

Moving accessed keys in Doubly Linked List while popping tail. — e.data.cache.lru

#269LFU Cache Eviction

Frequency-bucketed doubly linked lists for access count removal. — e.data.cache.lfu

#270ARC (Adaptive Replacement Cache)

Balancing LRU and LFU dynamically based on hits. — e.data.cache.arc

#271Clock (Second Chance) Eviction

Array loop checking usage bits prior to page selection. — e.data.cache.clock

#272FIFO Cache Eviction

Queue-based first-in first-out element replacement. — e.data.cache.fifo

#2732Q Cache Eviction

Multi-queue caching separating single access from frequent items. — e.data.cache.two_queue

#274SLRU (Segmented LRU)

Protected and probationary cache buffer management. — e.data.cache.slru

#275Tree Centroid Finding

Single pass DFS counting subtree sizes to find balance point. — see #87 (e.algo.graph.tree.centroid_decompose)

#276Heavy-Light Path Query

Combining segment tree queries over light and heavy paths. — see #86 (e.algo.graph.tree.heavy_light)

#277Treap Implicit Key Split

Splitting random search tree by sub-tree node count. — e.data.treap.split_at

#278Splay Tree Range Reverse

Tagging Lazy propagation lazy flag to invert tree children. — e.data.splay.reverse_range

#279Sparse Table Construction

Precomputing static Range Minimum Queries in O(N log N). — e.data.sparse_table.build

#280Sparse Table RMQ Lookup

O(1) query combining overlapping power-of-two blocks. — e.data.sparse_table.query

#281Disjoint Sparse Table

Range queries on non-idempotent operations in O(1). — e.data.sparse_table.disjoint_query

#282Block Decomposition (Sqrt Decomposition)

Partitioning N items into N blocks. — skip: a technique applied per problem, not a reusable function

#283Mo's Algorithm

Offline query ordering by block boundaries to reduce pointer moves. — e.algo.query.mo_order

#284Mo's Algorithm with Updates

3D query sorting incorporating time dimension. — skip: implementable, but too specialised for the standard library

#285Mo's Algorithm on Trees

Flattening tree via Euler Tour to process path queries offline. — skip: implementable, but too specialised for the standard library

#286Suffix Automaton Construction

Directed acyclic word graph minimal string acceptor. — e.text.suffix.automaton_build

#287Directed Acyclic Word Graph (DAWG)

Memory-efficient deterministic finite state automaton. — see #286 (e.text.suffix.automaton_build)

#288Rope Insert / Concatenate

Binary tree-backed long string editing and splicing. — e.data.rope.insert

#289Zipper Data Structure Movement

Functional cursor movement over nested structures. — skip: a technique applied per problem, not a reusable function

#290Finger Tree Operations

Deque structure supporting O(1) access at boundaries. — skip: implementable, but too specialised for the standard library

4. String Processing, Parsing & Text Formatting (291–380)

#291Knuth-Morris-Pratt (KMP)

String pattern matching using prefix function failure tables. — e.text.search.kmp

#292Boyer-Moore Search

Text search skipping alignments via bad character and good suffix rules. — e.text.search.boyer_moore

#293Boyer-Moore-Horspool

Simplified Boyer-Moore variant using bad-character rules. — e.text.search.horspool

#294Rabin-Karp Algorithm

Rolling hash string pattern search across text windows. — e.text.search.rabin_karp

#295Aho-Corasick Algorithm

Trie-based automaton for fast multi-pattern dictionary search. — e.text.search.aho_corasick

#296Z-Algorithm

Linear time computation of longest prefix-matching substrings. — e.text.search.z_array

#297Manacher's Algorithm

Linear time discovery of longest palindromic substrings. — e.text.search.longest_palindrome

#298Commentz-Walter Algorithm

Hybrid combining Boyer-Moore and Aho-Corasick multi-string search. — skip: implementable, but too specialised for the standard library

#299Baeza-Yates-Gonnet (Bitap / Shift-Or)

Bitwise string matching algorithm handling fuzzy searches. — e.text.search.bitap

#300Suffix Array Binary Search

Searching text patterns in O(M log N) via sorted suffix indices. — e.text.suffix.array_search

#301Levenshtein Distance

Dynamic programming metric for minimum single-character edits. — e.text.distance.levenshtein

#302Damerau-Levenshtein Distance

Edit distance accounting for insertions, deletions, substitutions, and transpositions. — e.text.distance.damerau_levenshtein

#303Jaro-Winkler Distance

String similarity metric weighting prefix matches higher. — e.text.distance.jaro_winkler

#304Hamming Distance

Bitwise or character positional difference count between equal-length strings. — e.text.distance.hamming

#305Needleman-Wunsch Algorithm

Global alignment dynamic programming for biological or text sequences. — e.algo.align.global

#306Smith-Waterman Algorithm

Local sequence alignment optimization for string sequence matching. — e.algo.align.local

#307Hirschberg's Algorithm

Space-efficient linear memory sequence alignment using divide-and-conquer. — e.algo.align.global_linear_space

#308Longest Common Subsequence (LCS)

Finding the maximum length order-preserving shared sub-sequence. — e.algo.dp.lcs

#309Longest Common Substring

Extracting the maximum length contiguous shared character sequence. — e.text.distance.longest_common_substring

#310Longest Palindromic Subsequence

Dynamic programming identification of internal palindromic sub-sequences. — e.algo.dp.longest_palindromic_subsequence

#311Shortest Common Supersequence

Finding the smallest string containing all input sequences as subsequences. — e.algo.dp.shortest_common_supersequence

#312Soundex Algorithm

Phonetic indexing algorithm encoding words by sound as pronounced in English. — e.text.phonetic.soundex

#313Metaphone / Double Metaphone

Phonetic algorithms encoding words into sound keys for fuzzy matching. — e.text.phonetic.metaphone

#314NYSIIS Algorithm

Phonetic coding system improving on Soundex for surname matching. — e.text.phonetic.nysiis

#315Caesar Cipher Shift

Simple substitution mapping by rotating characters by fixed distances. — e.crypto.classic.caesar

#316Vigenère Cipher

Polyalphabetic substitution using repeating keyword shift offsets. — e.crypto.classic.vigenere

#317Atbash Cipher

Substitution cipher mapping alphabet characters to their exact reversed position (A — Z). → e.crypto.classic.atbash

#318ROT13 Substitution

Alphabetical substitution rotating characters by 13 positions. — e.crypto.classic.rot13

#319Run-Length Encoding (RLE)

Lossless compression mapping adjacent duplicate characters to counts. — e.algo.coding.rle_encode

#320Base64 Encoding

Translating binary streams into 64 ASCII printable characters. — e.bytes.base64_encode

#321Base85 / Ascii85 Encoding

High-density string encoding mapping 4-byte sequences into 5 characters. — e.bytes.base85_encode

#322URL Percent Encoding

Converting non-ASCII and reserved symbols into %XX hex codes. — e.fmt.uri.percent_encode

#323UTF-8 Byte Encoder/Decoder

Variable-length multi-byte character mapping for Unicode codepoints. — e.text.utf8.encode

#324UTF-16 Surrogate Pair Resolver

Converting extended Unicode codepoint values into 16-bit code units. — e.text.utf8.decode_utf16

#325Unicode Normalization (NFD/NFC/NFKD/NFKC)

Canonical and compatibility character decomposition/composition. — e.text.normalize.normalize

#326TR31 Identifier Validation

Unicode standard rules verifying valid language variable names. — e.text.unicode.is_identifier

#327Byte Order Mark (BOM) Detector

Inspecting stream lead bytes to identify text file encoding format. — e.text.encoding.detect_bom

#328Recursive Descent Parsing

Top-down LL parser execution using mutually recursive functions. — e.parse.recursive_descent

#329LL(1) Parser Table Generator

Calculating FIRST and FOLLOW sets for context-free grammar rules. — e.parse.ll.table

#330LR(0) Item Set Generation

Building shift-reduce parser state graphs via item closure. — e.parse.lr.items

#331SLR(1) Parsing Table Builder

Simple LR parser generator using FOLLOW sets for conflict resolution. — e.parse.lr.slr_table

#332LALR(1) Parsing Table Construction

Look-ahead LR parser state merging to reduce table size. — e.parse.lr.lalr_table

#333Canonical LR(1) Parser Construction

Full look-ahead context-free grammar parsing table builder. — e.parse.lr.canonical_table

#334CYK Algorithm (Cocke-Younger-Kasami)

O(N3) parsing for grammars in Chomsky Normal Form. — e.parse.cyk

#335Earley Parser

Chart parsing algorithm handling arbitrary context-free grammars. — e.parse.earley

#336Shunting-Yard Algorithm

Converting infix expressions into Reverse Polish Notation (RPN). — e.parse.shunting_yard

#337Abstract Syntax Tree (AST) Builder

Constructing hierarchical tree nodes from parser token streams. — e.parse.ast

#338Lexical Tokenizer Scan

Regular expression scanner yielding typed atomic grammar tokens. — e.parse.lex

#339Packrat Parsing (PEG)

Linear-time parsing of Parsing Expression Grammars via memoization. — e.parse.peg

#340Pratt Parser (Top-Down Operator Precedence)

Parsing expressions using operator binding powers. — e.parse.pratt

#341Pretty Printing Layout Algorithm

Formatting AST structures into neatly indented text representations. — e.fmt.pretty.layout

#342Indentation Level Tracking

Off-side rule parser managing block scoping via indentation stacks. — e.parse.lex_indent

#343JSON Parser State Machine

Streaming character validation and parsing for key-value structures. — e.fmt.json.parse

#344XML SAX Event Streaming

Memory-efficient push parsing emitting element start/end callbacks. — e.fmt.xml.stream

#345XML DOM Tree Construction

Building complete in-memory hierarchical document trees. — e.fmt.xml.parse

#346Markdown Block Parsing

Line-oriented structural scanner classifying blocks, headers, and lists. — e.fmt.markdown.parse_blocks

#347Markdown Inline Parsing

Delimiter-matching engine for inline emphasis, code, and links. — e.fmt.markdown.parse_inlines

#348Thompson's NFA Construction

Building non-deterministic finite automata from regular expressions. — e.text.regex.nfa_compile

#349Powerset Construction (NFA to DFA)

Converting non-deterministic state machines to deterministic ones. — e.text.regex.dfa_from_nfa

#350Hopcroft's DFA Minimization

Merging equivalent state sets to construct minimal DFAs. — e.text.regex.dfa_minimize

#351DFA Execution

Fast single-pass text validation using state transition matrices. — e.text.regex.dfa_run

#352Backtracking Regex Engine

Recursive matching strategy supporting captures and backreferences. — e.text.regex.compile_backtracking

#353Pike Vectorized NFA Regex

Parallel state set tracking preventing catastrophic backtracking. — e.text.regex.pike_vm

#354Wildcard Pattern Matching

Evaluating wildcard strings containing ? and * symbols. — e.path.glob_match

#355String Trimming (LTRIM/RTRIM)

Stripping leading and trailing whitespace characters. — e.str.trim

#356String Padding

Prepending or appending fill characters to meet target field widths. — e.str.pad

#357String Splitting

Tokenizing strings using multi-character delimiter bounds. — e.str.split

#358String Joining / Interpolation

Concatenating array elements with central glue strings. — e.str.join

#359Naming Convention Converter

Transforming strings between camelCase, snake_case, and PascalCase. — e.text.casing.convert

#360Knuth's Word Wrap Algorithm

Dynamic programming line-breaking minimizing line raggedness. — e.text.wrap.optimal

#361Greedy Line Wrapping

Breaking text lines immediately upon exceeding maximum column width. — e.text.wrap.greedy

#362Justified Text Alignment

Distributing inter-word whitespace evenly to align both margins. — e.text.wrap.justify

#363Slugification

Normalizing raw text into lowercase, clean, hyphenated URL-safe strings. — e.text.casing.slug

#364Title Case Normalization

Capitalizing principal words following linguistic style guides. — e.text.casing.title

#365Truncation with Ellipsis

Shortening text to fixed length while appending ellipsis cleanly. — e.text.layout.ellipsis

#366K-Shingle Tokenization

Breaking text documents into sets of k adjacent character/word slices. — e.text.tokenize.shingles

#367TF-IDF Calculation

Scoring term frequency against inverse document frequency in information retrieval. — e.text.rank.tf_idf

#368BM25 Ranking Algorithm

Probabilistic relevance framework for document searching. — e.text.rank.bm25

#369Porter Stemming Algorithm

Rule-based suffix stripping engine reducing English words to roots. — e.text.stem.porter

#370Lancaster Stemmer

Aggressive rule-driven word stemmer stripping suffixes iteratively. — e.text.stem.lancaster

#371Snowball Framework

Language-neutral domain language for specifying stemming algorithms. — e.text.stem.snowball

#372Lemmatization (WordNet Lookup)

Mapping inflected words to true dictionary canonical lemmas. — skip: a trained ML model or training recipe

#373Byte-Pair Encoding (BPE)

Subword tokenization merging frequent character pairs. — e.text.tokenize.bpe

#374WordPiece Tokenizer

Subword segmentation maximizing vocabulary likelihood. — e.text.tokenize.wordpiece

#375Unigram Subword Tokenization

Probabilistic subword extraction using vocabulary pruning. — e.text.tokenize.unigram

#376Myers Diff Algorithm

Finding minimal edit scripts and differences between two files. — e.text.diff.myers

#377Patience Diff

Human-readable line diffing focusing on unique matching lines. — e.text.diff.patience

#3783-Way Text Merge

Merging two divergent text revisions using their common base ancestor. — e.text.diff.merge3

#379Trigram Fuzzy Matching

Substring similarity calculation using character 3-gram overlapping sets. — e.text.distance.trigram

#380Affix Stripping Parsing

Analyzing complex compound words down to structural roots. — e.text.stem.strip_affixes

5. Dynamic Programming, Greedy & Backtracking Algorithms (381–460)

#3810/1 Knapsack Problem

DP selection of item subsets maximizing value under weight limits. — e.algo.dp.knapsack

#382Fractional Knapsack Problem

Greedy selection prioritizing value-to-weight ratios. — e.algo.dp.knapsack_fractional

#383Unbounded Knapsack Problem

DP allocation allowing infinite copies of each available item. — e.algo.dp.knapsack_unbounded

#384Fibonacci Top-Down DP

Memoized recursive computation of Fibonacci numbers. — skip: pedagogical only

#385Fibonacci Bottom-Up DP

Tabulated iterative array calculation for O(N) Fibonacci output. — skip: pedagogical only

#386Longest Increasing Subsequence (LIS)

O(N log N) patience-sorting approach for increasing subsequences. — e.algo.dp.lis

#387Coin Change (Min Coins)

DP calculation determining fewest coins needed for target values. — e.algo.dp.coin_change_min

#388Coin Change (Total Ways)

Counting all combinations of coins that sum to target amounts. — e.algo.dp.coin_change_ways

#389Rod Cutting Problem

Optimizing rod cuts to maximize cumulative piece selling values. — see #383 (e.algo.dp.knapsack_unbounded)

#390Matrix Chain Multiplication

DP finding optimal parenthesization minimizing matrix product ops. — e.algo.dp.matrix_chain

#391Partition Equal Subset Sum

Subproblem check verifying if array splits into equal-sum halves. — see #392 (e.algo.dp.subset_sum)

#392Subset Sum Problem

Determining if any combination of numbers sums exactly to target S. — e.algo.dp.subset_sum

#393Kadane's Algorithm

Linear time scan discovering maximum contiguous sum subarrays. — e.algo.dp.max_subarray

#394Maximum Product Subarray

Dual DP tracking minimum and maximum contiguous products. — e.algo.dp.max_product_subarray

#395Box Stacking Problem

Dynamic programming stacking 3D boxes to achieve maximum height. — skip: pedagogical only

#396Egg Dropping Puzzle

Minimizing worst-case test drops needed to identify breaking floors. — skip: pedagogical only

#397Optimal Binary Search Tree

Constructing search trees minimizing average search costs based on access frequencies. — e.algo.dp.optimal_bst

#398Word Break Problem

DP verification determining if strings can be segmented into valid dictionary words. — e.text.tokenize.word_break

#399Palindromic Partitioning

Computing minimal cuts needed to divide strings into palindromes. — skip: pedagogical only

#400House Robber Problem

Maximizing non-adjacent element selection along arrays or trees. — skip: pedagogical only

#401Decode Ways

Counting possible character decodings for continuous numeric strings. — skip: pedagogical only

#402Interleaving String Verification

DP check confirming if two strings weave together into a third string. — skip: pedagogical only

#403Trapping Rain Water

Calculating trapped surface liquid volumes between elevation bars. — skip: pedagogical only

#404Largest Rectangle in Histogram

Stack-driven linear time computation of maximum bar area. — e.algo.dp.largest_rectangle_histogram

#405Maximal Rectangle in Binary Matrix

Row-by-row reduction translating 2D grids to histogram max areas. — e.gfx.filter.max_rectangle

#406Activity Selection Problem

Greedy task scheduling maximizing non-overlapping time intervals. — e.algo.schedule.activity_selection

#407Job Sequencing with Deadlines

Greedy assignment using disjoint sets to maximize scheduling profit. — e.algo.schedule.jobs_with_deadlines

#408Interval Scheduling Maximization

Sorting interval finish times to maximize processed tasks. — see #406 (e.algo.schedule.activity_selection)

#409Interval Covering Problem

Finding the smallest set of points required to touch all intervals. — e.algo.schedule.interval_cover

#410Minimum Refueling Stops

Max-heap tracking reachable gas station fuel capacities. — skip: pedagogical only

#411Gas Station Circuit (Petroleum Route)

Greedy starting index validation for complete circular routes. — skip: pedagogical only

#412Candy Distribution Problem

Two-pass array sweep satisfying local rating constraints with minimal costs. — skip: pedagogical only

#413Task Scheduler

Arranging task queues around cooldown intervals to minimize CPU idle slots. — e.algo.schedule.cooldown

#414Huffman Coding Tree Generation

Priority-queue greedy merging for optimal prefix coding trees. — e.algo.coding.huffman_build

#415Greedy Set Cover (Chvátal's)

Logarithmic approximation choosing sets with maximum unvisited elements. — e.algo.combopt.set_cover_greedy

#416N-Queens Problem

Backtracking search placing N non-attacking queens on an N × N chessboard. — skip: pedagogical only

#417Sudoku Solver

Backtracking grid search integrated with constraint propagation. — e.algo.exact_cover.sudoku

#418Knight's Tour Problem

Warnsdorff's heuristic guiding knights to visit every board square once. — skip: pedagogical only

#419Hamiltonian Path Backtracking

Depth-first search looking for paths visiting all graph vertices once. — skip: pedagogical only

#420Subset Generation (Power Set)

Iterative or recursive bitmask expansion building all sub-combinations. — e.algo.combin.subsets

#421Heap's Algorithm

Generating all N! permutations of an array using single element swaps. — e.algo.combin.permutations

#422Lexicographic Permutations

Finding next permutations via pivot discovery and suffix inversion. — e.algo.combin.next_permutation

#423Gosper's Hack

Bitwise loop generating all k-element subset bitmasks efficiently. — e.algo.combin.next_subset_same_popcount

#424Crossword Puzzle Solver

Backtracking word placement across intersecting grid slots. — skip: pedagogical only

#425Rat in a Maze

Multi-directional recursive grid pathfinding with backtracking. — skip: pedagogical only

#426Word Search in Grid (DFS + Trie)

Grid character search guided by Trie prefix lookups. — skip: pedagogical only

#427K-Equal Sum Subsets Partition

Recursive subset construction with state memoization. — skip: pedagogical only

#428Target Sum Expression Solver

Evaluating binary sign variations over sequence values. — skip: pedagogical only

#429Graham Scan (Convex Hull)

O(N log N) polar angle sorting identifying 2D convex boundary points. — e.algo.geom.hull_graham

#430Jarvis March / Gift Wrapping

Convex hull generation wrapping around outer perimeter points. — e.algo.geom.hull_jarvis

#431Monotone Chain Hull Algorithm

Sorting 2D points to construct upper and lower convex hulls. — e.algo.geom.hull

#432Quickhull

Divide-and-conquer convex hull determination using furthest points from lines. — e.algo.geom.hull_quick

#433Convex Hull Trick (CHT)

DP optimization technique evaluating envelope lines in O(1) or O(log N). — e.algo.dp.convex_hull_trick

#434Li Chao Tree

Segment tree structure maintaining set of linear functions over ranges. — e.algo.dp.li_chao_tree

#435Divide and Conquer DP Optimization

Accelerating dynamic programming when cost functions meet Quadrangle Inequality. — skip: a technique applied per problem, not a reusable function

#436Knuth's DP Optimization

Speeding up range DP when split indices are monotonic. — skip: a technique applied per problem, not a reusable function

#437Digit DP

Dynamic programming counting numbers under bounds satisfying specific digit rules. — skip: a technique applied per problem, not a reusable function

#438Bitmask DP

Memoizing subproblems by encoding state flags into binary integers. — skip: a technique applied per problem, not a reusable function

#439Sum Over Subsets (SOS DP)

Efficiently computing aggregate functions across all subset bitmasks in O(N2N). — e.algo.combin.subset_sums

#440Rerooting Tree DP

Two-pass DFS collecting results for every node treated as tree root. — skip: a technique applied per problem, not a reusable function

#441Broken Profile DP (Plug DP)

Grid DP maintaining boundaries across cell-by-cell state contours. — skip: a technique applied per problem, not a reusable function

#442Automata-Based DP

Counting string states by modeling transitions with matrix exponentiation. — skip: a technique applied per problem, not a reusable function

#443Minimax Algorithm

Decision tree evaluation minimizing maximum potential losses in zero-sum games. — e.game.ai.minimax

#444Alpha-Beta Pruning

Optimizing minimax search by discarding non-viable decision branches. — e.game.ai.alpha_beta

#445Monte Carlo Tree Search (MCTS)

Heuristic game tree exploration using Selection, Expansion, Simulation, and Backpropagation. — e.game.ai.mcts

#446Expectimax Search

Game tree traversal accounting for chance probabilistic nodes. — e.game.ai.expectimax

#447Negamax Variant

Compact implementation of minimax relying on zero-sum property symmetries. — see #444 (e.game.ai.alpha_beta)

#448Principal Variation Search (PVS)

NegaScout variant evaluating primary move paths with narrow search bounds. — e.game.ai.pvs

#449Proof-Number Search

Game tree search targeting proving or disproving tree connectivity goals. — skip: implementable, but too specialised for the standard library

#450Retrograde Analysis

Solving endgame positions by working backward from known terminal states. — skip: implementable, but too specialised for the standard library

#451SSS Algorithm*

Game tree search using state-space search with best-first heuristic evaluation. — skip: implementable, but too specialised for the standard library

#452B Tree Search*

Best-first search evaluating intervals of optimistic and pessimistic leaf bounds. — skip: implementable, but too specialised for the standard library

#453Iterative Deepening Negamax

Progressive search depth expansion combining transposition tables. — e.game.ai.iterative_deepening

#454Transposition Table Lookup

Hash-based caching of analyzed game tree positions and evaluations. — e.game.ai.transposition_table

#455Zobrist Hashing

Fast XOR-based hash computation for board game positions. — e.algo.hash.zobrist

#456Null-Move Pruning

Passing turns in game trees to verify positional advantage safety. — skip: an implementation detail of an existing module, not an API

#457Late Move Reductions (LMR)

Reducing search depth for moves ordered later in candidate lists. — skip: an implementation detail of an existing module, not an API

#458Quiescence Search

Extending search depth at tactical positions until board states stabilize. — e.game.ai.quiescence

#459Killer Heuristic

Prioritizing non-capturing moves that previously caused beta cutoffs. — skip: an implementation detail of an existing module, not an API

#460History Heuristic

Scoring move success frequency across the entire game tree to guide move ordering. — skip: an implementation detail of an existing module, not an API

6. Numerical, Mathematical & Number Theory Algorithms (461–500)

#461Euclidean Algorithm

Computing Greatest Common Divisor (GCD) via repeated modulo ops. — e.math.ntheory.gcd

#462Extended Euclidean Algorithm

Finding GCD alongside Bézout coefficients x and y (ax + by = gcd(a,b)). — e.math.ntheory.extended_gcd

#463Binary GCD (Stein's Algorithm)

Computing GCD using bitwise shifts, subtractions, and parity operations. — e.math.ntheory.gcd

#464Sieve of Eratosthenes

Generating all prime numbers up to N by marking multiples. — e.math.ntheory.sieve

#465Sieve of Sundaram

Prime generation algorithm sifting out odd composite numbers. — skip: pedagogical only

#466Sieve of Atkin

Fast algorithm for finding primes using quadratic forms. — skip: implementable, but too specialised for the standard library

#467Segmented Sieve

Generating primes in contiguous blocks to optimize memory cache usage. — e.math.ntheory.sieve_segmented

#468Linear Sieve

Generating primes up to N in O(N) time while calculating multiplicative functions. — e.math.ntheory.sieve_linear

#469Trial Division

Basic primality test dividing N by integers up to N. — e.math.ntheory.factor_trial

#470Fermat Primality Test

Probabilistic test checking if ap−1 ≡ 1 (mod p). — skip: pedagogical only

#471Miller-Rabin Primality Test

Fast probabilistic primality test used widely in cryptography. — e.math.ntheory.is_prime

#472Solovay-Strassen Test

Probabilistic primality test based on Euler's criterion and Jacobi symbols. — skip: pedagogical only

#473AKS Primality Test

Unconditional, deterministic polynomial-time primality test. — skip: research-grade, no settled practical implementation

#474Pollard's Rho Algorithm

Integer factorization algorithm optimized for composite numbers with small factors. — e.math.ntheory.factor_rho

#475Pollard's p − 1 Factorization

Number-theoretic factorization effective when p − 1 has small prime factors. — e.math.ntheory.factor_p_minus_1

#476Lenstra Elliptic-Curve Factorization (ECM)

Factorization technique using arithmetic on elliptic curves. — e.algo.bignum.factor_ecm

#477Quadratic Sieve

General-purpose integer factorization algorithm for 50–100 digit numbers. — skip: research-grade, no settled practical implementation

#478General Number Field Sieve (GNFS)

Fastest known algorithm for factorizing integers larger than 10100. — skip: research-grade, no settled practical implementation

#479Modular Exponentiation

O(log E) computation of (BE ) (mod M) using repeated squaring. — e.math.ntheory.pow_mod

#480Modular Multiplicative Inverse (Fermat's Little Theorem)

Finding A−1 (mod P) when P is prime (AP−2 (mod P)). — e.math.ntheory.inverse_mod

#481Chinese Remainder Theorem (CRT) Solver

Solving systems of simultaneous modular congruences. — e.math.ntheory.crt

#482Garner's Algorithm

CRT implementation avoiding big-integer overhead by computing mixed-radix digits. — e.math.ntheory.crt_garner

#483Euler's Totient Function (ϕ(n))

Counting positive integers up to n that are coprime to n. — e.math.ntheory.totient

#484Baby-Step Giant-Step

O( N) algorithm for solving discrete logarithm problems ( ax ≡ b (mod m)). — e.math.ntheory.discrete_log_bsgs

#485Pohlig-Hellman Algorithm

Solving discrete logarithms when group order factors into small primes. — e.math.ntheory.discrete_log_pohlig_hellman

#486Pollard's Kangaroo Algorithm

Discrete logarithm algorithm searching within bounded ranges. — e.math.ntheory.discrete_log_kangaroo

#487Tonelli-Shanks Algorithm

Finding modular square roots (x2 ≡ n (mod p)). — e.math.ntheory.sqrt_mod

#488Shanks-Mestre Point Counting

Counting points on elliptic curves over finite fields. — skip: implementable, but too specialised for the standard library

#489Fast Fourier Transform (FFT / Cooley-Tukey)

O(N log N) transformation converting signals between time and frequency domains. — e.math.fft.fft

#490Number Theoretic Transform (NTT)

FFT equivalent operating over finite fields using primitive roots. — e.math.fft.ntt

#491Karatsuba Multiplication

Fast polynomial/integer multiplication running in O(N^log2(3)) ≈ O(N^1.58). — e.algo.bignum.int_mul

#492Toom-Cook Multiplication

Generalization of Karatsuba dividing numbers into k equal parts. — skip: an implementation detail of an existing module, not an API

#493Schönhage-Strassen Algorithm

Fast multiplication for large integers using FFT over 2^(2^n) + 1. — skip: an implementation detail of an existing module, not an API

#494Harvey-Hoeven Multiplication

O(N log N) ultra-large integer multiplication algorithm. — skip: research-grade, no settled practical implementation

#495Fast Walsh-Hadamard Transform (FWHT)

O(N log N) algorithm for bitwise XOR/AND/OR convolutions. — e.math.fft.fwht

#496Newton-Raphson Method

Root-finding algorithm using function derivatives (x(n+1) = x(n) − f(x(n)) / f′(x(n))). — e.math.root.newton

#497Halley's Method

Second-order root-finding method using first and second derivatives. — e.math.root.halley

#498Secant Method

Root-finding algorithm approximating derivatives using finite differences. — e.math.root.secant

#499Bisection Method

Deterministic root-finding repeatedly halving bracketed sign-change intervals. — e.math.root.bisect

#500Brent's Method

Hybrid root-finding combining bisection, secant, and inverse quadratic interpolation.  Yes do it — e.math.root.brent

7. Linear Algebra, Geometry & Spatial Algorithms (501–560)

#501Gaussian Elimination

Solving systems of linear equations via row-reduction to upper triangular form. — e.algo.linalg.matrix.solve

#502Gauss-Jordan Elimination

Reducing linear systems further to reduced row echelon form (RREF). — e.algo.linalg.matrix.rref

#503LU Decomposition

Factoring matrix A into lower (L) and upper (U) triangular matrices (A = LU). — e.algo.linalg.matrix.lu

#504QR Decomposition

Factoring matrix into orthogonal (Q) and upper triangular (R) matrices. — e.algo.linalg.matrix.qr

#505Cholesky Decomposition

Efficient factorization of symmetric positive-definite matrices (A = LLT). — e.algo.linalg.matrix.cholesky

#506Singular Value Decomposition (SVD)

Decomposing real matrix into singular vectors and singular values (A = UΣV T). — e.algo.linalg.matrix.svd

#507Power Iteration

Eigenvalue algorithm finding the dominant eigenvalue and eigenvector. — e.algo.linalg.matrix.power_iteration

#508QR Algorithm for Eigenvalues

Iterative matrix decomposition yielding all eigenvalues and eigenvectors. — e.algo.linalg.matrix.eigen

#509Inverse Matrix Computation (Adjugate/Elimination)

Finding matrix A−1 such that AA−1 = I. — e.algo.linalg.matrix.inverse

#510Matrix Exponentiation

O(log N) exponentiation for solving linear recurrences and graph path counts. — e.algo.linalg.matrix.pow

#511Strassen's Matrix Multiplication

Divide-and-conquer matrix multiplication running in O(N2.807). — skip: an implementation detail of an existing module, not an API

#512Coppersmith-Winograd Algorithm

Theoretical matrix multiplication algorithm running in O(N2.375). — skip: research-grade, no settled practical implementation

#513Gram-Schmidt Process

Orthonormalizing a set of vectors in an inner product space. — e.algo.linalg.matrix.orthonormalize

#514Householder Reflection

Constructing orthogonal matrices that reflect vectors across hyperplanes. — e.algo.linalg.matrix.householder

#515Givens Rotation

Applying planar rotations to zero out specific off-diagonal matrix elements. — e.algo.linalg.matrix.givens

#516Simplex Algorithm

Linear programming solver navigating vertices of a feasible polytope region. — e.math.opt.simplex

#517Interior Point Method (Karmarkar's)

Polynomial-time linear programming solver traversing polytope interiors. — e.math.opt.convex.interior_point

#518Extended Kalman Filter (EKF)

Non-linear state estimation using local first-order Taylor expansions. — e.math.filter.ekf

#519Unscented Kalman Filter (UKF)

Non-linear state estimation using deterministic sigma-point sampling. — e.math.filter.ukf

#520Particle Filter (Sequential Monte Carlo)

Non-parametric state estimation using weighted random particles. — e.math.filter.particle

#521Ray-Casting Algorithm

Determining point inclusion in 2D polygons by counting edge intersections. — e.algo.geom.point_in_polygon

#522Ray-Box Intersection (Slab Method)

Fast ray axis-aligned bounding box (AABB) intersection testing. — e.algo.geom3.ray_box

#523Ray-Triangle Intersection (Möller-Trumbore)

O(1) ray-triangle intersection without computing plane equations. — e.algo.geom3.ray_triangle

#524Separating Axis Theorem (SAT)

Collision detection checking projection overlaps on candidate axes. — e.algo.geom3.separating_axis

#525Gilbert-Johnson-Keerthi (GJK)

Collision detection and distance queries using Minkowski differences. — e.algo.geom3.gjk

#526Expanding Polytope Algorithm (EPA)

Finding penetration depth and contact vectors following GJK collisions. — e.algo.geom3.epa

#527Bounding Volume Hierarchy (BVH)

Tree structure organizing geometric primitives for spatial queries. — e.data.spatial.bvh_build

#528Sweep-Line Algorithm (Bentley-Ottmann)

O((N + K)log N) algorithm discovering K segment intersections. — e.algo.geom.segment_intersections

#529Fortune's Algorithm

O(N log N) sweep-line algorithm generating Voronoi diagrams. — e.algo.geom.voronoi

#530Bowyer-Watson Algorithm

Incremental generation of Delaunay triangulations in arbitrary dimensions. — e.algo.geom.delaunay

#531Flip Algorithm

Converting arbitrary triangulations to Delaunay triangulations via edge flipping. — e.algo.geom.delaunay_flip

#532Winding Number Algorithm

Exact point-in-polygon test calculating total signed rotation angle. — e.algo.geom.winding_number

#533Ear Clipping Algorithm

O(N2) polygon triangulation repeatedly cutting off non-overlapping ears. — e.algo.geom.clip.triangulate_ear_clip

#534Sutherland-Hodgman Algorithm

Clipping arbitrary polygons against convex clipping boundaries. — e.algo.geom.clip.clip_convex

#535Weiler-Atherton Algorithm

Polygon clipping algorithm supporting non-convex polygons with holes. — e.algo.geom.clip_polygon

#536Cohen-Sutherland Line Clipping

2D line segment clipping using 4-bit outcodes. — e.algo.geom.clip.clip_line

#537Liang-Barsky Line Clipping

Parametric line segment clipping against rectangular viewports. — e.algo.geom.clip.clip_line_liang_barsky

#538Line Segment Intersection Check

Orientation-based cross-product test checking if two 2D segments cross. — e.algo.geom.segments_intersect

#539Welzl's Algorithm

Randomized linear-time O(N) algorithm finding minimum enclosing circle. — e.algo.geom.enclosing_circle

#540Rotating Calipers

Computing bounding boxes, maximum distance, or antipodal pairs in convex polygons. — e.algo.geom.rotating_calipers

#541Closest Pair of Points

O(N log N) divide-and-conquer search for closest 2D point pair. — e.algo.geom.closest_pair

#542Furthest Pair of Points

O(N log N) rotating calipers search over convex hull vertices. — e.algo.geom.farthest_pair

#543Bresenham's Line Algorithm

Integer-only incremental grid rasterization of line segments. — e.gfx.raster.line

#544Midpoint Circle Algorithm

Integer-based incremental circle drawing using 8-way symmetry. — e.gfx.raster.circle

#545Xiaolin Wu's Line Algorithm

Anti-aliased line drawing using coverage percentage weighting. — e.gfx.raster.line_aa

#546Scanline Flood Fill

Optimized flood filling operating on horizontal line segments instead of pixels. — e.gfx.filter.flood_fill_scanline

#547Polygon Convexity Check

Verifying polygon convexity via consistent cross-product sign evaluation. — e.algo.geom.is_convex

#548Shoelace Formula (Gauss's Area Formula)

Calculating area of non-self-intersecting polygons from coordinates. — e.algo.geom.polygon_area

#549Pick's Theorem Computation

Area calculation for lattice polygons using interior and boundary lattice points (A = I + B/2 − 1). — e.algo.geom.lattice_points

#550Spatial Hash Grid Search

Bucketing 2D/3D entities into fixed grid cells for O(1) neighbor queries. — e.data.spatial.hash_grid

#551Marching Cubes

Extracting 3D polygonal isosurface meshes from volumetric scalar fields. — e.gfx.mesh.marching_cubes

#552Marching Squares

Generating 2D contour lines from discrete 2D scalar fields. — e.gfx.mesh.marching_squares

#553Catmull-Rom Spline Interpolation

Constructing smooth space curves passing directly through control points. — e.gfx.curve.catmull_rom

#554De Boor's Algorithm

Fast evaluation of B-spline curves at parametric position t. — e.gfx.curve.bspline

#555De Casteljau's Algorithm

Recursive linear interpolation evaluating Bézier curves. — e.gfx.curve.bezier

#556NURBS Surface Evaluation

Calculating surface coordinates for Non-Uniform Rational B-Splines. — e.gfx.curve.nurbs_surface

#557Douglas-Peucker Algorithm

Polyline simplification reducing vertex count while maintaining topology tolerance. — e.algo.geom.clip.simplify_douglas_peucker

#558Visvalingam-Whyatt Algorithm

Line simplification incrementally removing vertices contributing least triangular area. — e.algo.geom.clip.simplify_visvalingam

#559Rapidly-Exploring Random Tree (RRT)

Sampling-based path planning searching high-dimensional spaces. — e.robot.plan.rrt

#560RRT*

Asymptotically optimal RRT rewiring tree branches to find shortest paths. — e.robot.plan.rrt_star

8. Cryptography, Security, Hashing & Compression (561–650)

#561SHA-256

Cryptographic hash function producing 256-bit message digests via Merkle-Damgård. — e.crypto.hash.sha256

#562SHA-3 (Keccak)

Cryptographic hash built on permutation-based sponge construction. — e.crypto.hash.sha3_256

#563MD5 Algorithm

Legacy 128-bit message digest function (now cryptographically broken). — e.crypto.hash.legacy_md5

#564BLAKE3

High-performance cryptographic hash using tree hashing and internal parallelism. — e.crypto.hash.blake3

#565MurmurHash

Fast non-cryptographic hash function optimized for general hash table lookups. — e.algo.hash.murmur3

#566CityHash / FarmHash

Non-cryptographic hash functions optimized for short string performance on CPUs. — skip: implementable, but too specialised for the standard library

#567xxHash

Extremely fast non-cryptographic hash operating at RAM speed limits. — e.algo.hash.xxhash64

#568FNV-1a Hash

Compact non-cryptographic hash using iterative multiplication and XOR operations. — e.algo.hash.fnv1a64

#569Adler-32

Fast 32-bit checksum combining two 16-bit modular sums. — e.algo.hash.adler32

#570CRC32 Checksum

Cyclic redundancy check detecting accidental data corruption via polynomial division. — e.algo.hash.crc32

#571Fletcher's Checksum

Error-detection algorithm providing comparable reliability to CRC32 at lower CPU cost. — e.algo.hash.fletcher

#572HMAC

Hash-based Message Authentication Code combining secret keys with cryptographic hashes. — e.crypto.mac.hmac_sha256

#573HKDF

Key derivation function extracting pseudo-random keys and expanding them to target lengths. — e.crypto.kdf.hkdf_sha256_expand

#574PBKDF2

Password-based key derivation applying repeated HMAC iterations with salt. — e.crypto.kdf.pbkdf2

#575bcrypt

Adaptive password hashing based on the Blowfish cipher incorporating a work factor. — e.crypto.kdf.bcrypt

#576scrypt

Memory-hard key derivation function designed to deter hardware ASIC attacks. — e.crypto.kdf.scrypt

#577Argon2

Password Hashing Competition winner optimizing memory-hardness (Argon2id/Argon2i/Argon2d). — e.crypto.kdf.argon2id

#578AES (Rijndael)

Symmetric block cipher operating on 128-bit blocks using substitution-permutation networks. — e.crypto.cipher.aes_block

#579Triple DES (3DES)

Legacy symmetric cipher applying DES encryption three times per block. — skip: obsolete cryptography

#580ChaCha20

High-speed symmetric stream cipher operating on 512-bit state matrices. — e.crypto.cipher.chacha20

#581Salsa20

Stream cipher precursor to ChaCha20 using quarter-round ARX operations. — skip: obsolete cryptography

#582RSA Encryption & Signing

Public-key cryptography reliant on the difficulty of prime factorization. — e.crypto.sign.rsa_pss

#583Diffie-Hellman Key Exchange

Method allowing two parties to establish a shared secret over an insecure channel. — e.crypto.kx.dh

#584ECDH (Elliptic Curve Diffie-Hellman)

Key agreement protocol using elliptic curve arithmetic. — e.crypto.kx.x25519_exchange

#585ECDSA

Elliptic Curve Digital Signature Algorithm providing digital authentication with shorter keys. — e.crypto.sign.p256_sign

#586Ed25519 (EdDSA)

High-speed, misuse-resistant digital signature scheme using Curve25519. — e.crypto.sign.ed25519_sign

#587Schnorr Signature

Efficient digital signature scheme supporting key and signature aggregation. — e.crypto.sign.schnorr

#588Shamir's Secret Sharing

Threshold scheme splitting secrets into N shares where any K can reconstruct it. — e.crypto.secret.split

#589Paillier Cryptosystem

Additively homomorphic public-key encryption scheme. — skip: implementable, but too specialised for the standard library

#590Learning With Errors (LWE)

Post-quantum cryptographic foundation based on high-dimensional lattice hardness. — skip: research-grade, no settled practical implementation

#591NTRU Encryption

Lattice-based public-key cryptosystem resilient to quantum attacks. — skip: implementable, but too specialised for the standard library

#592Kyber (ML-KEM)

Lattice-based key encapsulation mechanism standardized for post-quantum security. — e.crypto.kx.ml_kem

#593Dilithium (ML-DSA)

Lattice-based digital signature scheme standardized for post-quantum security. — e.crypto.sign.ml_dsa

#594Groth16 (zk-SNARK)

Zero-knowledge succinct non-interactive argument of knowledge with small proof size. — skip: research-grade, no settled practical implementation

#595zk-STARK

Zero-knowledge proof system requiring no trusted setup and offering post-quantum security. — skip: research-grade, no settled practical implementation

#596Bulletproofs

Short zero-knowledge range proofs requiring no trusted setup. — skip: research-grade, no settled practical implementation

#597Ring Signatures

Group digital signature obscuring the specific signer among a pool of public keys. — skip: implementable, but too specialised for the standard library

#598Pedersen Commitments

Cryptographic commitments hiding values while preserving additive homomorphic properties. — skip: implementable, but too specialised for the standard library

#599Merkle Tree Construction

Binary hash tree providing O(log N) data verification proofs. — e.crypto.merkle.build

#600Merkle-Patricia Trie

Modified radix trie providing cryptographically verifiable key- value state storage. — skip: implementable, but too specialised for the standard library

#601Verkle Tree

Tree structure using vector commitments to produce small state proofs. — skip: research-grade, no settled practical implementation

#602BLS Signature Aggregation

Aggregating multiple signatures across different keys into a single signature. — skip: implementable, but too specialised for the standard library

#603AES-GCM

Authenticated symmetric encryption mode providing both confidentiality and data integrity. — e.crypto.aead.aes_gcm_seal

#604AES-CBC

Cipher Block Chaining mode chaining plaintext blocks with previous ciphertext blocks. — e.crypto.cipher.cbc

#605AES-CTR

Counter mode converting block ciphers into stream ciphers using incrementing counters. — e.crypto.cipher.ctr

#606Poly1305

Fast, one-time authenticator creating 128-bit message authentication tags. — e.crypto.mac.poly1305

#607One-Time Pad

Information-theoretically unbreakable encryption using random keys matching message length. — skip: pedagogical only

#608Feistel Cipher Structure

Symmetric network splitting block states into left and right halves iteratively. — skip: a technique applied per problem, not a reusable function

#609Substitution-Permutation Network (SPN)

Cipher architecture alternating substitution boxes and permutation layers. — skip: a technique applied per problem, not a reusable function

#610Chaum's Blind Signature

Protocol allowing message signing without revealing message content to the signer. — skip: implementable, but too specialised for the standard library

#611Huffman Coding

Entropy encoding assigning variable-length bit codes based on character frequency. — e.algo.coding.huffman_encode

#612Canonical Huffman Coding

Huffman variant generating standardized bit patterns for compact tree storage. — e.algo.coding.huffman_canonical

#613Adaptive Huffman Coding

Dynamic entropy coding updating frequency trees on the fly during transmission. — skip: implementable, but too specialised for the standard library

#614LZW Compression

Dictionary-based lossless compression building code tables dynamically. — e.fmt.lzw.encode

#615LZ77 (Sliding Window)

Lossless compression replacing duplicate data with (distance, length) pointers. — skip: an implementation detail of an existing module, not an API

#616LZ78

Lossless compression constructing an explicit dictionary of phrases from input streams. — skip: implementable, but too specialised for the standard library

#617LZMA

High-ratio lossless compression using dictionary encoding and range coder backends. — e.fmt.lzma.decode

#618LZ4

Extremely fast byte-aligned compression optimized for high decompression throughput. — e.fmt.lz4.encode

#619Zstandard (zstd)

Lossless compression combining LZ77 with Finite State Entropy (FSE) backends. — e.fmt.zstd.encode

#620DEFLATE

Lossless data compression combining LZ77 and Huffman coding (used in Gzip/Zip). — e.algo.deflate.encode

#621Brotli

Lossless compression combining LZ77, Huffman coding, and static dictionary context modeling. — e.fmt.brotli.decode

#622Snappy

Fast byte-oriented compression designed for high-throughput string processing. — e.fmt.snappy.encode

#623Burrows-Wheeler Transform (BWT)

Block-sorting transform grouping identical characters together for compression. — e.algo.coding.bwt

#624Move-To-Front (MTF) Transform

Data transformation replacing recent symbols with index positions in a dynamic list. — e.algo.coding.move_to_front

#625Arithmetic Coding

Lossless entropy encoding mapping entire streams into a single floating-point interval. — e.algo.coding.arithmetic_encode

#626Asymmetric Numeral Systems (ANS)

Fast entropy coding offering arithmetic coding ratios at Huffman speeds. — e.algo.coding.ans_encode

#627Delta Encoding

Storing data streams as differences (deltas) between sequential values. — e.algo.coding.delta_encode

#628Frame of Reference (FoR) Compression

Storing integer arrays as small offsets relative to a minimum reference value. — e.algo.coding.for_encode

#629Elias Gamma / Delta / Omega Coding

Universal bit-level variable-length integer encoding schemes. — e.algo.coding.elias_gamma

#630Golomb / Rice Coding

Lossless variable-length encoding optimized for geometric distributions. — e.algo.coding.rice_encode

#631Varint (Variable Byte) Encoding

Encoding arbitrary integers into variable numbers of bytes using 7-bit chunks. — e.algo.coding.varint_encode

#632ZigZag Encoding

Mapping signed integers to unsigned integers so small negative values use fewer bits. — e.algo.coding.zigzag_encode

#633Roaring Bitmaps

Compressed bitmap data structure using arrays, run-length encodings, or raw bitsets. — e.data.bitmap.roaring

#634Word-Aligned Hybrid (WAH)

Compressed bit-vector structure optimizing logical AND/OR set operations. — e.data.bitmap.wah

#635Discrete Cosine Transform (DCT)

Lossy image compression algorithm packing energy into low frequencies (JPEG). — e.math.fft.dct

#636Discrete Wavelet Transform (DWT)

Multi-resolution image compression transform preserving spatial localization (JPEG 2000). — e.math.fft.dwt

#637Quantization Matrix Application

Lossy step dividing frequency coefficients to discard perceptually insignificant data. — skip: an implementation detail of an existing module, not an API

#638Chroma Subsampling

Color compression reducing chrominance resolution relative to luminance (4 : 2 : 2, 4 : 2 : 0). — skip: an implementation detail of an existing module, not an API

#639Vector Quantization (LBG)

Lossy vector clustering mapping continuous features to discrete codebook vectors. — e.ml.cluster.vector_quantize

#640pHash (Perceptual Hash)

Fingerprinting media files based on visual features rather than exact binary representations. — e.gfx.image.phash

#641Average Hash (aHash)

Fast perceptual image hash comparing pixels against average luminance. — e.gfx.image.ahash

#642Difference Hash (dHash)

Perceptual image hash tracking directional pixel brightness gradients. — e.gfx.image.dhash

#643Block Truncation Coding (BTC)

Lossy image compression preserving local sample mean and standard deviation. — skip: implementable, but too specialised for the standard library

#644ASTC Texture Compression

Fixed-rate GPU texture compression supporting arbitrary block sizes. — e.gfx.texture.astc_decode

#645BC1–BC7 (DXTC / S3TC)

Hardware-accelerated GPU texture block compression formats. — e.gfx.texture.bc_decode

#646FLAC Linear Predictive Coding

Lossless audio compression modeling audio samples via autoregressive linear prediction. — e.fmt.flac.decode

#647Opus Audio Compression Engine

Low-latency audio codec combining SILK (speech) and CELT (music) engines. — e.fmt.opus.decode

#648Block-Matching Motion Estimation

Video compression tracking spatial movement vectors between frames. — skip: implementable, but too specialised for the standard library

#649HEVC Quad-Tree Intra Prediction

Hierarchical video frame partitioning into coding tree units (CTUs). — skip: implementable, but too specialised for the standard library

#650AV1 Film Grain Synthesis

Video encoding stripping camera noise and re-synthesizing it parametrically at display time. — skip: implementable, but too specialised for the standard library

9. Operating Systems, Concurrency, Memory & Distributed Systems (651–720)

#651Context Switching

Saving and restoring CPU registers, program counters, and address spaces. — skip: OS kernel internals

#652Round-Robin Scheduling

Preemptive process scheduling assigning fixed CPU time slices sequentially. — skip: OS kernel internals

#653Shortest Remaining Time First (SRTF)

Preemptive scheduler prioritizing tasks with least remaining execution time. — skip: OS kernel internals

#654Priority Scheduling with Aging

Dynamic process scheduling increasing priority over time to prevent starvation. — skip: OS kernel internals

#655Multilevel Feedback Queue (MLFQ)

Adaptive scheduling adjusting process queues based on CPU vs I/O behavior. — skip: OS kernel internals

#656Completely Fair Scheduler (CFS)

Linux red-black tree scheduler balancing virtual runtime among processes. — skip: OS kernel internals

#657Earliest Deadline First (EDF)

Dynamic real-time task scheduling prioritizing upcoming execution deadlines. — e.thread.pool.edf

#658Rate Monotonic Scheduling (RMS)

Static-priority real-time scheduling assigning higher priority to frequent tasks. — skip: OS kernel internals

#659Work-Stealing Scheduler

Task scheduling where idle worker threads pull tasks from busy threads' deques. — e.thread.pool.work_stealing

#660Fork-Join Framework

Parallel execution model recursively splitting tasks and joining results. — e.thread.pool.fork_join

#661Peterson's Algorithm

Concurrent software lock guaranteeing mutual exclusion between two processes. — skip: pedagogical only

#662Dekker's Algorithm

First correct software solution for two-process mutual exclusion. — skip: pedagogical only

#663Lamport's Bakery Algorithm

N-process mutual exclusion algorithm assigning ordering tickets. — skip: pedagogical only

#664Test-And-Set

Hardware atomic instruction setting memory flags and returning previous values. — e.atomic.xchg

#665Compare-And-Swap (CAS)

Atomic instruction updating memory locations only if current values match expectations. — e.atomic.cas

#666Fetch-And-Add (FAA)

Hardware atomic primitive incrementing memory values in place. — e.atomic.add

#667Read-Copy-Update (RCU)

Synchronization mechanism allowing readers lock-free access while updates publish pointer swaps. — e.sync.rcu

#668Reader-Writer Lock

Synchronization primitive allowing concurrent reads or exclusive writes. — e.sync.rwlock

#669Semaphore (P and V Operations)

Signaling counter managing resource access units. — e.sync.semaphore

#670Priority Inheritance Protocol

Priority inversion solution boosting lower-priority task priorities holding required locks. — skip: OS kernel internals

#671Priority Ceiling Protocol

Real-time lock ceiling assignment preventing priority inversions and deadlocks. — skip: OS kernel internals

#672Dissemination Barrier

O(log N) thread synchronization barrier exchanging completion flags in rounds. — e.sync.barrier

#673Spinlock with Exponential Backoff

Busy-waiting lock delaying retry intervals exponentially to reduce memory bus pressure. — e.sync.spin_lock

#674Michael-Scott Queue

Concurrent lock-free FIFO queue using atomic CAS operations on linked lists. — e.concurrent.queue.push

#675Treiber Stack

Lock-free concurrent stack using Compare-And-Swap on head pointers. — e.concurrent.stack.push

#676Split-Ordered Lists

Lock-free hash table supporting dynamic resizing using bit-reversed key orders. — skip: an implementation detail of an existing module, not an API

#677Hazard Pointers

Memory reclamation technique preventing lock-free memory deallocation races. — e.concurrent.reclaim.hazard

#678Epoch-Based Reclamation (EBR)

Deferred lock-free memory freeing tied to global epoch state progression. — e.concurrent.reclaim.epoch

#679Buddy Memory Allocation

Memory management subdividing blocks into power-of-two halves ("buddies"). — e.mem.buddy

#680Slab Allocation

Kernel object caching eliminating memory fragmentation for fixed-size structures. — e.mem.slab

#681Arena Allocator

Region-based memory allocation releasing contiguous blocks all at once. — e.mem.arena_from

#682Pool Allocator

Fast fixed-size block memory allocation managed via free lists. — e.mem.pool

#683Stack-Based Arena Allocator

Sequential linear memory allocation supporting LIFO rewinds. — e.mem.mark

#684First-Fit / Best-Fit Memory Search

Free-list search strategies locating memory blocks for allocation requests. — skip: an implementation detail of an existing module, not an API

#685Mark-and-Sweep GC

Two-phase garbage collection marking reachable roots and sweeping unreferenced memory. — skip: Neper has ownership, not a garbage collector

#686Cheney's Copying Collector

Two-space GC copying reachable objects into a single contiguous destination space. — skip: Neper has ownership, not a garbage collector

#687Generational Garbage Collection

Memory reclamation prioritizing short-lived young generation objects. — skip: Neper has ownership, not a garbage collector

#688Reference Counting with Trial Deletion

Reference-counted memory management resolving cyclic references. — skip: Neper has ownership, not a garbage collector

#689Tri-Color Marking

Concurrent GC classifying objects into white (unvisited), grey (frontier), and black (visited). — skip: Neper has ownership, not a garbage collector

#690ZGC Concurrent Marking

Garbage collection using colored pointers and load barriers for sub-millisecond pauses. — skip: Neper has ownership, not a garbage collector

#691Page Table Walk

Hardware MMU multi-level tree traversal resolving virtual memory addresses to physical addresses. — skip: OS kernel internals

#692TLB Miss Handling

Virtual memory address translation falling back to page table walks upon TLB cache misses. — skip: OS kernel internals

#693Inverted Page Table Lookup

Hash-based page table mapping physical memory frames back to virtual pages. — skip: OS kernel internals

#694LRU Page Replacement

Evicting physical memory pages that have gone longest without access. — see #268 (e.data.cache.lru)

#695Clock (Second-Chance) Page Eviction

Circular page array loop checking usage bit flags prior to page eviction. — see #271 (e.data.cache.clock)

#696Not Recently Used (NRU) Eviction

Page selection categorizing pages by read/written status bits. — skip: OS kernel internals

#697Working Set Page Model

Thrashing prevention monitoring process page access frequencies within time windows. — skip: OS kernel internals

#698Elevator Algorithm (SCAN)

Disk I/O scheduling moving arm in one direction serving requests until reaching end bounds. — skip: OS kernel internals

#699C-SCAN (Circular SCAN)

Disk I/O scheduling serving requests in one direction only, jumping back to start immediately. — skip: OS kernel internals

#700LOOK / C-LOOK Scheduling

Elevator algorithm variant reversing direction upon servicing final request in current direction. — skip: OS kernel internals

#701I/O Multiplexing (epoll / kqueue / io_uring)

OS event notification mechanisms monitoring multiple file descriptors efficiently. — e.async.poll

#702Reactor Pattern

Event handling pattern dispatching incoming I/O requests synchronously to handlers. — skip: a technique applied per problem, not a reusable function

#703Proactor Pattern

Event handling pattern executing I/O operations asynchronously and notifying completion handlers. — skip: a technique applied per problem, not a reusable function

#704Thread Pool Worker Loop

Reusing fixed worker thread sets pulling tasks off synchronized queues. — e.thread.pool.run

#705Token Bucket Algorithm

Traffic shaping rate limiting allowing burst capacity within token refresh rates. — e.ratelimit.token_bucket

#706Leaky Bucket Algorithm

Traffic limiting enforcing smooth constant outbound request rates. — e.ratelimit.leaky_bucket

#707Fixed Window Counter

Rate limiting counting requests within fixed calendar time windows. — e.ratelimit.fixed_window

#708Sliding Window Log

Rate limiting logging exact timestamps per request to prevent boundary bursts. — e.ratelimit.sliding_log

#709Sliding Window Counter

Rate limiting combining current and previous window counts using weighted averages. — e.ratelimit.sliding_window

#710Circuit Breaker Pattern

Fault-tolerance state machine (Closed, Open, Half-Open) failing fast when downstream services error. — e.resilience.circuit_breaker

#711Exponential Backoff with Jitter

Retrying failed operations with exponentially increasing random delay intervals. — e.resilience.backoff

#712Weighted Round-Robin Load Balancing

Distributing incoming requests across servers proportional to assigned weights. — e.net.balance.weighted_round_robin

#713Power of Two Choices (Maglev)

Load balancing selecting the shorter queue between two randomly chosen nodes. — e.net.balance.power_of_two

#714DNS Round-Robin

Distributing network traffic by returning alternating IP addresses for domain queries. — e.net.resolve

#715Heartbeat Monitoring

Periodic ping messages tracking live status of remote cluster nodes. — e.resilience.heartbeat

#716Distributed Tracing Context Propagation

Injecting trace and span IDs across HTTP/RPC service headers. — e.trace.propagate

#717LSM-Tree Compaction

Merging and sorting immutable SSTables (Size-Tiered or Leveled) to reclaim disk space. — e.db.storage.lsm_compact

#718Write-Ahead Logging (WAL)

Ensuring ACID durability by logging mutations to append-only files before applying to state. — e.db.storage.wal_append

#719ARIES Recovery Protocol

Transaction recovery logging protocol executing Analysis, Redo, and Undo passes. — e.db.storage.recover

#720Two-Phase Commit (2PC)

Distributed consensus protocol coordinating distributed transaction commit or rollback steps. — e.dist.commit.two_phase

10. Machine Learning, Artificial Intelligence & Optimization (721–780)

#721Ordinary Least Squares (OLS) Linear Regression

Minimizing sum of squared residuals to fit linear relationships (y = Xβ + ϵ). — e.ml.linear.ols

#722Ridge Regression

Linear regression regularized with an L2 penalty term (λ∥β∥₂²) to prevent overfitting. — e.ml.linear.ridge

#723Lasso Regression

Linear regression regularized with an L1 penalty term (λ∥β∥₁) driving sparse coefficients. — e.ml.linear.lasso

#724Logistic Regression (L-BFGS / Newton)

Binary classification modeling log-odds of outcomes using sigmoid functions. — e.ml.linear.logistic

#725K-Means Clustering

Partitioning N observations into K clusters by minimizing squared distances to centroids. — e.ml.cluster.kmeans

#726K-Means++ Initialization

Seeding initial centroids proportional to squared distance from existing centroids. — e.ml.cluster.kmeans_pp_init

#727K-Medoids (PAM Algorithm)

Clustering using actual dataset objects (medoids) instead of mean centroids. — e.ml.cluster.kmedoids

#728DBSCAN

Density-based spatial clustering identifying core points, border points, and noise. — e.ml.cluster.dbscan

#729OPTICS

Density-based clustering ordering points to extract variable-density cluster hierarchies. — e.ml.cluster.optics

#730Agglomerative Hierarchical Clustering

Bottom-up clustering merging clusters based on linkage criteria (Single/Complete/Average). — e.ml.cluster.agglomerative

#731Expectation-Maximization (EM) for GMM

Iterative fitting of Gaussian Mixture Models optimizing data log-likelihood. — e.ml.cluster.gmm_em

#732Principal Component Analysis (PCA)

Dimensionality reduction projecting data onto orthogonal variance-maximizing eigenvectors. — e.ml.reduce.pca

#733t-SNE

Non-linear dimensionality reduction preserving local neighbor similarities via t-distributions. — e.ml.reduce.tsne

#734UMAP

Dimensionality reduction based on manifold learning and Riemannian geometry. — skip: implementable, but too specialised for the standard library

#735K-Nearest Neighbors (KNN)

Non-parametric classification/regression assigning labels based on K closest training instances. — e.ml.knn.classify

#736Decision Tree Induction (CART / C4.5)

Recursive dataset partitioning maximizing Information Gain or Gini Impurity reduction. — e.ml.tree.cart

#737Random Forest Ensembling

Combining decision trees trained on bootstrap samples with random feature subsets. — e.ml.tree.random_forest

#738Gradient Boosting Decision Trees (GBDT)

Sequential ensemble fitting new decision trees to negative gradients of loss functions. — e.ml.tree.gradient_boost

#739XGBoost Algorithm

Second-order gradient tree boosting with regularized objective functions and parallel building. — see #738 (e.ml.tree.gradient_boost)

#740LightGBM Histogram Optimization

Tree boosting bucketing continuous features into discrete bins to accelerate splits. — see #738 (e.ml.tree.gradient_boost)

#741Naive Bayes Classification

Probabilistic classifier applying Bayes' Theorem assuming feature independence. — e.ml.bayes.naive

#742Sequential Minimal Optimization (SMO)

Solving the quadratic programming problem in Support Vector Machine training. — e.ml.svm.smo

#743SVM Kernel Trick

Implicitly mapping inputs to high-dimensional feature spaces using inner product functions (RBF, Polynomial). — e.ml.svm.kernel

#744Perceptron Learning Algorithm

Single-layer binary classifier updating weights upon misclassification errors. — e.ml.nn.perceptron

#745Backpropagation (Automatic Differentiation)

Computing loss gradients across neural network weights via the chain rule. — e.ml.nn.autodiff

#746Stochastic Gradient Descent (SGD)

Iterative optimization updating parameters using single-sample loss gradients. — e.ml.optim.sgd

#747SGD with Momentum

Accelerating gradient descent updates by accumulating past directional velocity vectors. — e.ml.optim.momentum

#748RMSprop Optimization

Adaptive learning rate method dividing gradients by running root mean square averages. — e.ml.optim.rmsprop

#749Adam Optimizer

Optimization combining first-moment (mean) and second-moment (uncentered variance) gradient tracking. — e.ml.optim.adam

#750AdamW Optimizer

Adam optimization variant decoupling weight decay from gradient updates.  Yes do it — e.ml.optim.adamw

#751Scaled Dot-Product Attention

Calculating query-key similarity matrices with scaling factor √d_k. — e.ml.nn.attention

#752Multi-Head Attention

Parallel attention projections over subspace representations in Transformers. — e.ml.nn.multi_head_attention

#753Rotary Position Embedding (RoPE)

Injecting relative positional information using rotation matrices. — e.ml.nn.rope

#754FlashAttention

Tile-based memory-efficient exact attention computing blockwise updates. — e.gpu.attention_flash

#755Beam Search

Heuristic search maintaining top-k most probable sequence hypotheses. — e.ml.sample.beam_search

#756Temperature Sampling

Scaling logit distributions to control randomness during sequence generation. — e.ml.sample.temperature

#757Top-K Sampling

Filtering next-token candidate pools to the K highest-probability tokens. — e.ml.sample.top_k

#758Top-P (Nucleus) Sampling

Dynamic next-token candidate selection targeting cumulative probability P. — e.ml.sample.top_p

#759Contrastive Loss (InfoNCE)

Maximizing agreement between positive pairs while minimizing negative pairs. — e.ml.loss.info_nce

#760Triplet Loss

Minimizing anchor-positive distance while maximizing anchor-negative distance. — e.ml.loss.triplet

#761GAN Minimax Optimization

Adversarial training balancing generator and discriminator objectives. — skip: a trained ML model or training recipe

#762DDPM Noise Estimation

Denoising Diffusion Probabilistic Models predicting Gaussian noise steps. — skip: a trained ML model or training recipe

#763VAE ELBO Maximization

Optimizing Evidence Lower Bound combining reconstruction loss and KL divergence. — skip: a trained ML model or training recipe

#764Q-Learning

Off-policy temporal-difference reinforcement learning updating state-action values. — e.ml.rl.q_learning

#765SARSA

On-policy temporal-difference reinforcement learning updating value functions via executed actions. — e.ml.rl.sarsa

#766Deep Q-Networks (DQN)

Reinforcement learning combining Q-learning with neural networks and replay buffers. — skip: a trained ML model or training recipe

#767Proximal Policy Optimization (PPO)

Policy gradient RL optimizing clipped surrogate objectives. — skip: a trained ML model or training recipe

#768Trust Region Policy Optimization (TRPO)

Policy gradient method enforcing KL-divergence constraints on updates. — skip: a trained ML model or training recipe

#769Asynchronous Advantage Actor-Critic (A3C)

Parallel asynchronous worker threads updating global policy networks. — skip: a trained ML model or training recipe

#770Simulated Annealing

Probabilistic optimization accepting worse states controlled by a cooling temperature parameter. — e.math.opt.meta.simulated_annealing

#771Genetic Algorithm

Population-based optimization employing selection, crossover, and mutation operations. — e.math.opt.meta.genetic

#772Particle Swarm Optimization (PSO)

Population optimization navigating search spaces using velocity vectors. — e.math.opt.meta.particle_swarm

#773Ant Colony Optimization (ACO)

Probabilistic graph search guided by simulated pheromone decay and deposition. — e.math.opt.meta.ant_colony

#774Differential Evolution

Vector-based stochastic optimization mutating population candidates via differences. — e.math.opt.meta.differential_evolution

#775Nelder-Mead Simplex Method

Direct search optimization using geometric simplex transformations without derivatives. — e.math.opt.nelder_mead

#776Conjugate Gradient Method

Iterative solver for linear systems and non-linear optimization along orthogonal directions. — e.math.opt.conjugate_gradient

#777BFGS Algorithm

Quasi-Newton optimization method approximating the inverse Hessian matrix. — e.math.opt.bfgs

#778L-BFGS Algorithm

Limited-memory quasi-Newton optimization storing recent position/gradient updates. — e.math.opt.lbfgs

#779Hill Climbing

Local search algorithm continuously moving in the direction of increasing value. — e.math.opt.meta.hill_climb

#780Tabu Search

Metaheuristic search employing short-term memory lists to avoid previously visited local optima. — e.math.opt.meta.tabu

11. Image Processing, Computer Vision & Signal Processing (781–820)

#781Sobel Filter Convolution

Calculating image intensity spatial gradients using 3 × 3 derivative masks. — e.gfx.filter.sobel

#782Canny Edge Detector

Multi-stage edge detection combining Gaussian smoothing, gradients, non-maximum suppression, and hysteresis thresholding. — e.gfx.filter.canny

#783Harris Corner Detector

Identifying visual corner features based on local intensity gradient changes. — e.gfx.vision.harris_corners

#784SIFT (Scale-Invariant Feature Transform)

Detecting scale, rotation, and illumination invariant interest points. — e.gfx.vision.sift

#785ORB (Oriented FAST and Rotated BRIEF)

Fast binary feature detector combining FAST keypoints and oriented BRIEF descriptors. — e.gfx.vision.orb

#786Hough Transform

Feature extraction technique identifying geometric shapes (lines, circles) in binary images. — e.gfx.vision.hough_lines

#787Gaussian Blur Filtering

Low-pass image filtering using 2D Gaussian convolution kernels. — e.gfx.filter.gaussian_blur

#788Bilateral Filter

Edge-preserving image smoothing weighting pixels by spatial distance and color similarity. — e.gfx.filter.bilateral

#789Otsu's Thresholding

Automatic image binarization maximizing inter-class variance between foreground and background. — e.gfx.filter.threshold_otsu

#790Watershed Algorithm

Topographic region-growing segmentation treating image intensities as elevation relief maps. — e.gfx.filter.watershed

#791Lucas-Kanade Optical Flow

Local optical flow estimation assuming constant velocity within local neighborhood windows. — e.gfx.vision.optical_flow_lk

#792Farneback Optical Flow

Dense optical flow calculation approximating neighborhoods with quadratic polynomials. — e.gfx.vision.optical_flow_farneback

#793Median Filter

Non-linear spatial filter replacing pixel values with neighborhood medians to eliminate noise. — e.gfx.filter.median

#794Moving Average Filter

Smoothing discrete time-series data by averaging sliding window segments. — e.dsp.moving_average

#795Exponential Moving Average (EMA)

Time-series smoothing applying exponentially decreasing weights to older data points. — e.dsp.ema

#796Savitzky-Golay Filter

Smoothing signal data by fitting low-degree local polynomials via least squares. — e.dsp.savitzky_golay

#797Finite Impulse Response (FIR) Filter

Digital signal filter whose impulse response settles to zero in finite time. — e.dsp.fir

#798Infinite Impulse Response (IIR) Filter

Digital signal filter utilizing feedback loops for recursive impulse responses. — e.dsp.iir

#799Butterworth Filter Design

Signal processing filter maximizing frequency response passband flatness. — e.dsp.design_butterworth

#800Chebyshev Filter Design

Signal processing filter sacrificing passband/stopband ripple for steeper roll-off curves. — e.dsp.design_chebyshev

#801Mel-Frequency Cepstral Coefficients (MFCC)

Extracting spectral acoustic features mapped to human auditory perception scales. — e.dsp.mfcc

#802Short-Time Fourier Transform (STFT)

Computing frequency spectra over sliding windowed signal segments. — e.dsp.stft

#803Constant-Q Transform

Time-frequency transform using logarithmically spaced center frequencies. — e.dsp.cqt

#804YIN Pitch Detection

Monophonic pitch tracking based on modified autocorrelation functions. — e.audio.analysis.pitch_yin

#805Dynamic Time Warping (DTW)

Measuring similarity between temporal sequences with variable timing speeds. — e.dsp.dtw

#806Peak Signal-to-Noise Ratio (PSNR)

Objective quality metric evaluating pixel-level error between compressed and original images. — e.gfx.image.psnr

#807Structural Similarity Index (SSIM)

Perceptual quality metric comparing image luminance, contrast, and structural features. — e.gfx.image.ssim

#808Connected Component Labeling

Identifying contiguous pixel regions in binary images using two-pass sweeps. — e.gfx.filter.label_components

#809Integral Image (Summed-Area Table)

O(1) sub-rectangle pixel intensity summation precomputed in single passes. — e.gfx.filter.integral_image

#810Guided Image Filter

Edge-preserving smoothing filter using a guidance image to compute linear transformations. — e.gfx.filter.guided

#811Laplacian Pyramid Construction

Multi-scale bandpass image decomposition subtracting upsampled Gaussian levels. — e.gfx.filter.laplacian_pyramid

#812Distance Transform

Computing minimum distance from every grid pixel to nearest obstacle or boundary. — e.gfx.filter.distance_transform

#813Morphological Erosion & Dilation

Fundamental binary image shape operations expanding or shrinking boundaries. — e.gfx.filter.morph_erode

#814Morphological Opening & Closing

Compound operations removing background noise or filling foreground holes. — e.gfx.filter.morph_open

#815Harris-Laplace Detector

Scale-adapted corner detection combining Harris response with Laplacian scale selection. — skip: implementable, but too specialised for the standard library

#816Haar Cascade Classifier

Fast object detection using boosted decision trees over Haar-like visual features. — skip: a trained ML model or training recipe

#817Mean Shift Segmentation

Non-parametric feature-space clustering shifting points to local mode density peaks. — e.gfx.filter.mean_shift

#818GrabCut Segmentation

Interactive foreground extraction using iterative Graph Cuts and Gaussian Mixture Models. — skip: implementable, but too specialised for the standard library

#819Phase Correlation

Estimating relative translation offsets between two images using 2D Fourier transforms. — e.gfx.vision.phase_correlate

#820Zero-Crossing Detector

Identifying edge locations in signals or images where second derivatives flip signs. — e.dsp.zero_crossings

12. Bit Manipulation, Low-Level Arithmetic & Systems (821–860)

#821Brian Kernighan's Algorithm

Counting set bits in an integer by repeatedly clearing the lowest set bit ( x &= x - 1 ). — e.bytes.count_ones

#822Population Count (Popcount)

Parallel bitwise accumulation calculating total set bits in a word. — e.bytes.count_ones

#823Count Leading Zeros (CLZ)

Determining the number of consecutive zero bits preceding the most significant set bit. — e.bytes.leading_zeros

#824Count Trailing Zeros (CTZ)

Counting consecutive zero bits following the least significant set bit. — e.bytes.trailing_zeros

#825Reverse Bits

Inverting bit order across an integer using hierarchical parallel swaps. — e.bytes.reverse_bits

#826Next Power of Two

Rounding unsigned integers up to the nearest power of two using bitwise OR shifts. — e.bytes.next_power_of_two

#827XOR Swap Algorithm

Swapping two variables in place without auxiliary storage using XOR operations. — skip: pedagogical only

#828Fast Inverse Square Root

Computing 1/ x using IEEE 754 floating-point magic constant bit manipulation and Newton iterations. — e.math.rsqrt

#829Gray Code Conversion

Encoding binary values into Gray code (G = B ⊕ (B ≫ 1)) and decoding back. — e.bytes.gray_encode

#830Parity Check

Determining if the total count of set bits in a binary word is even or odd. — e.bytes.parity

#831Bitwise Circular Shift (Rotate Left/Right)

Rotating bits beyond word boundaries without bit loss. — e.bytes.rotate_left

#832Bitmask Overlap Check

Verifying set intersection between bit flags using bitwise AND operations ( (A & B) != 0 ). — skip: pedagogical only

#833Carryless Multiplication

Multiplying binary polynomials over Galois Field GF(2). — e.math.gf.clmul

#834IEEE 754 Floating-Point Unpacking

Extracting sign, exponent, and mantissa fields from 32-bit/64-bit float representations. — e.math.float.unpack

#835Half-Precision (FP16) Conversion

Packing/unpacking standard 32-bit floats to 16-bit floating point representations. — e.math.float.to_f16

#836Bfloat16 Conversion

Truncating 32-bit floats to 16-bit brain floating-point format preserving 8-bit exponent ranges. — e.math.float.to_bf16

#837Saturated Arithmetic Operations

Clamping arithmetic results to minimum or maximum byte/word bounds on overflow. — e.math.saturating_add

#838Byte Swapping (Endianness Flip)

Reversing byte order within multi-byte integers for network packet conversion. — e.bytes.byte_swap

#839Variable-Length Quantity (VLQ)

Encoding arbitrary-length integers using continuation bits per byte. — e.algo.coding.vlq_encode

#840Delta-Delta Encoding

Storing differences between consecutive differences in time-series data streams. — e.algo.coding.delta_delta_encode

#841Bit-Packing Array

Compacting K-bit integers into contiguous memory byte arrays. — e.algo.coding.bit_pack

#842Bitset Intersection / Union

Computing set operations over bit arrays using SIMD bitwise AND/OR instructions. — e.algo.bitset.intersect

#843Longitudinal Redundancy Check (LRC)

Error detection checksum calculating XOR sums across byte sequences. — e.algo.hash.lrc

#844Cyclic Shift Hash

Fast string hashing combining bitwise rotation and XOR operations. — skip: implementable, but too specialised for the standard library

#845Interleaved Bit Multiplication (Morton Coding)

Interleaving bits of multidimensional coordinates to generate Z-order curve keys. — e.algo.geom.morton_encode

#846De Bruijn Bitscan

Locating least significant set bit indices using precomputed De Bruijn lookup tables. — skip: an implementation detail of an existing module, not an API

#847Bitwise Subset Traversal

Iterating through all valid bitmask sub-combinations using sub = (sub - 1) & mask . — e.algo.combin.subsets_of_mask

#848Sign Extension

Expanding signed integer width while preserving sign bit values across bit boundaries. — e.bytes.sign_extend

#849Log2 of Integer (Bitwise)

Finding integer binary logarithm via leading zero counts or bitwise shifts. — e.bytes.ilog2

#850Symmetric Bit Swap

Swapping non-overlapping bit ranges within integers using bitmasks. — e.bytes.swap_bits

#851Masked Bit Clear

Unsetting specific bit ranges using inverted bitmasks ( x & ~mask ). — skip: pedagogical only

#852Non-Zero Byte Detection (SWAR)

Detecting zero bytes within 32/64-bit integer words without byte-by-byte loops. — e.bytes.has_zero_byte

#853Galois Field Addition / Multiplication

Arithmetic operations over GF(28) used in AES and Reed-Solomon coding. — e.math.gf.mul

#854Reed-Solomon Error Correction

Non-binary error-correcting code constructing polynomials over finite fields. — e.algo.ecc.reed_solomon_decode

#855BCH Code Decoding (Berlekamp-Massey)

Decoding binary error-correcting codes to fix multi-bit corruption. — e.algo.ecc.bch_decode

#856Viterbi Algorithm

Dynamic programming decoding optimal state sequences in Hidden Markov Models and convolutional codes. — e.algo.ecc.viterbi_decode

#857Fano Algorithm

Sequential decoding heuristic for convolutional error-correcting codes. — skip: implementable, but too specialised for the standard library

#858Turbo Codes Iterative Decoding

Soft-decision parallel concatenated convolutional decoding. — skip: implementable, but too specialised for the standard library

#859LDPC Belief Propagation

Message-passing algorithm over Tanner graphs decoding Low-Density Parity-Check codes. — e.algo.ecc.ldpc_decode

#860Hamming (7,4) Error Correction

Linear error-correcting code detecting and correcting single-bit errors. — e.algo.ecc.hamming_decode

13. Databases, Indexing & Storage Engine Operations (861–900)

#861B-Tree Range Search

Traversing node page bounds to extract entries within key intervals. — e.db.storage.btree_range

#862B+ Tree Leaf Splitting

Dividing full leaf nodes and inserting median keys into parent nodes. — see #191 (e.data.btree.split_node)

#863LSM-Tree MemTable Flush

Writing in-memory skiplists/trees to disk as immutable SSTables. — e.db.storage.memtable_flush

#864SSTable Block Binary Search

Searching block offset indexes to locate key positions on disk. — e.db.storage.sstable_find

#865Write-Ahead Log Appending

Sequential append-only logging of transaction operations prior to page updates. — see #718 (e.db.storage.wal_append)

#866Buffer Pool Clock Eviction

LRU-approximation page eviction managing cached disk blocks in memory. — e.db.storage.buffer_pool_evict

#867Checkpoint Recovery Sweep

Flushed dirty page logging enabling fast database crash recovery. — see #719 (e.db.storage.recover)

#868Strict Two-Phase Locking (SS2PL)

Concurrency control holding all exclusive locks until transaction commit. — e.db.storage.txn_lock_2pl

#869Optimistic Concurrency Control (OCC)

Validating read/write sets prior to commit to avoid locking overhead. — e.db.storage.txn_occ

#870Multi-Version Concurrency Control (MVCC)

Maintaining versioned tuples allowing non-blocking reads. — e.db.storage.txn_mvcc

#871Snapshot Isolation Sweep

Reading tuple states matching specific transaction start timestamps. — skip: an implementation detail of an existing module, not an API

#872Extendible Hash Indexing

Dynamic hash tables expanding directory depth without rehashing entire datasets. — e.db.storage.hash_index_extendible

#873Linear Hashing

Dynamic hash table growing incrementally page by page. — e.db.storage.hash_index_linear

#874R-Tree Spatial Bounding Box Search

Finding spatial objects intersecting target query bounding boxes. — e.data.spatial.rtree_search

#875Inverted Index Construction

Mapping tokenized terms to sorted posting lists of document IDs. — e.text.index.build

#876Posting List Compression (Elias-Fano)

Quasi-succinct encoding storing sorted integer lists in minimal space. — e.text.index.postings_elias_fano

#877Nested Loop Join

Simple relational join evaluating matching conditions for every outer/inner row pair. — e.db.query.join_nested_loop

#878Hash Join

Building in-memory hash tables on smaller relations and scanning larger relations to join. — e.db.query.join_hash

#879Sort-Merge Join

Sorting both join inputs on key columns and merging matching streams concurrently. — e.db.query.join_sort_merge

#880Semi-Join Optimization

Returning rows from outer table that have at least one match in inner table. — e.db.query.join_semi

#881Anti-Join Execution

Returning rows from outer table that have zero matches in inner table. — e.db.query.join_anti

#882Predicate Pushdown

Query optimizer rule moving filter conditions down logical plans closer to data sources. — e.db.query.push_predicates

#883Projection Pushdown

Discarding unused relation attributes early in physical query execution plans. — e.db.query.push_projections

#884Common Table Expression (CTE) Materialization

Executing temporary query sub-expressions once and caching outputs. — e.db.query.materialize_cte

#885Volcano Iterator Model

Volcano-style query processing calling open() , next() , and close() on plan operators. — e.db.query.iterator

#886Vectorized Query Execution

Processing database tuples in columnar batches using SIMD execution loops. — e.db.query.vectorized

#887JIT Query Compilation (LLVM)

Compiling query plans into native machine code to eliminate virtual dispatch overhead. — skip: implementable, but too specialised for the standard library

#888Spatial Range Query (Quadtree)

Querying bounding boxes in 2D quadtree structures recursively. — e.data.spatial.quadtree_range

#889B-Tree Right-Sibling Pointer Traversal

Scanning contiguous leaf pages sequentially in B+ trees. — e.db.storage.btree_next_leaf

#890Write-Ahead Log Truncation

Safely dropping log segments older than the active checkpoint. — e.db.storage.wal_truncate

#891Dynamic Predicate Pushdown

Injecting dynamic runtime Bloom filters into join build phases. — see #882 (e.db.query.push_predicates)

#892Star Join Optimization

Multi-table join plan optimization targeting data warehouse star schemas. — skip: implementable, but too specialised for the standard library

#893Partition Pruning

Query engine rule skipping table partitions outside filter ranges. — e.db.query.prune_partitions

#894Parallel Hash Join Split

Partitioning build and probe tables across parallel worker threads. — e.db.query.join_hash_parallel

#895Page Compaction (Vacuuming)

Reclaiming dead tuple slots within database storage pages. — e.db.storage.vacuum

#896Sparse Index Lookup

Locating key blocks in sorted data files using subset offset indices. — e.db.storage.index_sparse

#897Dense Index Lookup

Locating exact tuple record pointers using full key index records. — e.db.storage.index_dense

#898Covering Index Scan

Fulfilling query attribute requests entirely from index pages without table lookups. — e.db.query.index_only_scan

#899Bitmap Index Scan

Performing bitwise AND/OR operations over attribute bitmasks before tuple retrieval. — e.db.storage.index_bitmap

#900Trie-Based Prefix Index Traversal

Matching variable-length string keys using character edge transitions. — e.data.trie.prefix_iter

14. Distributed Protocols, Networking & Infrastructure (901–940)

#901Token Bucket Traffic Shaping

Controlling request rates by releasing tokens into queues at fixed speeds. — see #705 (e.ratelimit.token_bucket)

#902Leaky Bucket Rate Limiting

Smoothly discharging bursts of incoming network packets at constant rates. — see #706 (e.ratelimit.leaky_bucket)

#903Sliding Window Protocol

Reliable network packet transmission managing unacknowledged sender/receiver frames. — e.net.reliable.sliding_window

#904Selective Repeat ARQ

Automatic Repeat Request protocol retransmitting only corrupted or lost packets. — e.net.reliable.selective_repeat

#905Nagle's Algorithm

TCP optimization combining small outgoing messages into single TCP segments. — skip: OS kernel internals

#906Jacobson's RTT Estimation

Computing TCP round-trip times and retransmission timeouts using smooth variance tracking. — e.net.reliable.rtt_estimate

#907Karn's Algorithm

Preventing ambiguous TCP retransmission measurements when updating RTT estimates. — e.net.reliable.rtt_karn

#908Consistent Hashing Ring Lookup

Mapping keys to closest node tokens on virtual hash rings. — see #255 (e.algo.consistent_hash.ring_lookup)

#909Rendezvous Hashing (HRW)

Selecting target nodes maximizing pseudo-random weight functions per key. — see #256 (e.algo.consistent_hash.rendezvous)

#910Chord Distributed Lookup

Routing DHT queries across O(log N) finger table node shortcuts. — see #130 (e.dist.dht.chord_lookup)

#911Kademlia Node Lookup

DHT node discovery calculating target distance using bitwise XOR metrics. — see #131 (e.dist.dht.kademlia_lookup)

#912Raft Consensus Replication

Leader-driven log entry appending and commit index advancement. — e.dist.consensus.raft_replicate

#913Paxos Multi-Prepare

Two-phase consensus achieving agreement on sequence series of values. — see #135 (e.dist.consensus.paxos)

#914Gossip State Dissemination

Epidemic peer-to-peer state propagation sharing node rumors randomly. — see #142 (e.dist.gossip.disseminate)

#915Vector Clock Causality Tracking

Updating vector clock arrays to detect concurrent updates vs causal ordering. — see #148 (e.dist.clock.vector)

#916Lamport Logical Clock Sync

Ordering distributed events using monotonically increasing scalar counters. — see #147 (e.dist.clock.lamport)

#917Bully Election Algorithm

Highest-rank node asserting cluster leadership upon detecting leader failure. — see #143 (e.dist.election.bully)

#918Ring Election Algorithm

Token-passing ring network election gathering active node IDs. — see #144 (e.dist.election.ring)

#919Chandy-Lamport Global Snapshot

Recording distributed global states without freezing system execution. — see #152 (e.dist.snapshot.chandy_lamport)

#920Two-Phase Commit (2PC)

Coordinating distributed database transactions via Prepare and Commit phases. — see #720 (e.dist.commit.two_phase)

#921Three-Phase Commit (3PC)

Non-blocking distributed transaction commit protocol introducing Pre-Commit states. — e.dist.commit.three_phase

#922Saga Pattern Choreography

Distributed event-driven transaction execution using local compensations. — e.dist.commit.saga_choreography

#923Saga Pattern Orchestration

Central coordinator directing service steps and triggering rollback compensations. — e.dist.commit.saga_orchestrate

#924Circuit Breaker State Transition

Tripping service calls upon fault threshold breaches to allow recovery. — see #710 (e.resilience.circuit_breaker)

#925Health Check Heartbeat Sweep

Pinging cluster nodes periodically to detect offline instances. — see #715 (e.resilience.heartbeat)

#926Distributed Tracing Span Propagation

Injecting trace/span contexts into HTTP/RPC request headers. — see #716 (e.trace.propagate)

#927Gossip-Based Failure Detector (Phi Accrual)

Continuous probabilistic evaluation of node availability. — e.dist.failure_detector.phi_accrual

#928Jump Consistent Hash

Fast O(1) memory consistent hash algorithm mapping keys to buckets. — e.algo.consistent_hash.jump

#929Load Shedding Drop Protocol

Discarding low-priority traffic when service CPU/memory saturation triggers. — e.resilience.load_shed

#930Slow Start (TCP Congestion Control)

Exponentially expanding TCP congestion windows until loss or thresholds occur. — skip: OS kernel internals

#931Congestion Avoidance (TCP AIMD)

Additive Increase Multiplicative Decrease adjustment of TCP window sizes. — skip: OS kernel internals

#932Fast Retransmit / Fast Recovery

Retransmitting lost TCP packets upon receiving three duplicate ACKs. — skip: OS kernel internals

#933Distributed Lock Renewal (Redlock)

Acquiring time-bounded distributed locks across majority independent instances. — e.dist.lock.redlock

#934Merkle Tree Anti-Entropy Sync

Comparing hash tree branches between nodes to identify out-of-sync key ranges. — e.dist.anti_entropy.merkle_sync

#935Read Repair Mechanism

Background sync updating stale replica nodes when read operations detect inconsistency. — e.dist.replica.read_repair

#936Hinted Handoff Execution

Storing write operations locally for offline target nodes and replaying upon reconnect. — e.dist.replica.hinted_handoff

#937Quorum Read/Write Evaluation

Validating distributed consistency where R + W > N. — e.dist.replica.quorum

#938Consistent Hash Virtual Node Placement

Mapping physical hardware onto multiple virtual hash ring tokens to equalize load. — e.algo.consistent_hash.virtual_nodes

#939Gossip Membership List Exchange

Periodic pairwise state swaps updating cluster membership tables. — e.dist.gossip.membership

#940Distributed Deadlock Detection (Wait-For Graph)

Detecting cycles in distributed resource allocation dependency graphs. — e.dist.deadlock.wait_for_graph

15. General Utilities, Validation, Randomness & Core Functions (941–1000)

#941Fisher-Yates (Durstenfeld) Shuffle

Generating unbiased random permutations of arrays in O(N) time. — see #57 (e.algo.rand.shuffle)

#942Reservoir Sampling

Uniformly sampling k items from continuous data streams of unknown length. — see #59 (e.algo.rand.reservoir)

#943Alias Method (Walker's)

Generating random variates from discrete probability distributions in O(1) time. — see #60 (e.algo.rand.alias_table)

#944Linear Congruential Generator (LCG)

Pseudorandom number generator using modular linear equations (X = (aX + c) (mod m)). n+1 n — e.algo.rand.lcg

#945Mersenne Twister (MT19937)

High-period (219937 − 1) pseudorandom number generator based on linear recurrences. — e.algo.rand.mt19937

#946Xorshift PRNG

Fast pseudorandom number generation using repeated bitwise shifts and XOR operations. — e.algo.rand.xorshift

#947PCG Random Number Generator

Permuted Congruential Generator applying output permutation functions to LCG states. — e.algo.rand.pcg64

#948Luhn Algorithm

Modulo 10 checksum formula validating identification numbers (credit cards, IMEI). — e.valid.luhn

#949ISBN-13 Checksum Validation

Validating 13-digit book identifiers using alternating 1 and 3 weight multipliers. — e.valid.isbn13

#950IBAN Validation Algorithm

Validating International Bank Account Numbers using modulo 97 arithmetic. — e.valid.iban

#951EAN-13 Barcode Verification

Checking parity weighted checksums for global commercial barcodes. — e.valid.ean13

#952CIDR Subnet Masking

Calculating network/broadcast IP addresses and valid host ranges from bitmask lengths. — e.net.cidr_contains

#953IPv6 Address Compression / Expansion

Normalizing IPv6 address strings handling zero-block contractions ( :: ). — e.net.format_ip

#954UUID v4 Generation

Constructing 128-bit cryptographically secure random Universally Unique Identifiers. — e.algo.uuid.v4

#955UUID v5 Namespace Hashing

Generating deterministic UUIDs using SHA-1 hashing over namespace and name strings. — e.algo.uuid.v5

#956Snowflake ID Generation

Generating 64-bit unique IDs composed of timestamp, worker ID, and sequence counters. — e.algo.uuid.snowflake

#957ULID Generation

Universally Unique Lexicographically Sortable Identifiers combining millisecond timestamps and randomness. — e.algo.uuid.ulid

#958Nanoid Generation

Compact, URL-friendly unique string generation using secure random bytes. — e.algo.uuid.nanoid

#959Semantic Versioning (SemVer) Parser

Parsing and comparing MAJOR.MINOR.PATCH version string rules. — e.fmt.semver.parse

#960Cron Expression Parser

Parsing 5/6-field schedule expressions to compute next runtime execution timestamps. — e.time.cron.parse

#961Interval Overlap Detection

Checking intersection conditions between two time intervals (Start_A < End_B ∧ Start_B < End_A). — e.time.intervals_overlap

#962Zeller's Congruence

Calculating day of the week for any Julian or Gregorian calendar date. — e.time.calendar.weekday

#963Julian Day Number Calculation

Mapping calendar dates into continuous count of days since epoch start. — e.time.calendar.julian_day

#964ISO 8601 Date Parser

Parsing standardized date-time strings into unix epoch timestamps. — e.time.parse_iso8601

#965HTML Entity Encoder / Decoder

Translating special reserved characters to/from HTML named or numeric entities. — e.fmt.html.escape

#966CSV Tokenizer

Parsing comma-separated values respecting quoted fields, escaped quotes, and newlines. — e.fmt.csv.reader

#967Levenshtein Matrix Alignment

Constructing edit distance tables to extract actual insertion/deletion/substitution steps. — see #301 (e.text.distance.levenshtein)

#968Soundex Phonetic Encoder

Mapping English words to 4-character codes based on phonetic consonant categories. — see #312 (e.text.phonetic.soundex)

#969Base64 Stream Encoder

Converting binary byte buffers into printable 64-character ASCII strings. — e.bytes.base64_encoder

#970Base64 Stream Decoder

Unpacking Base64 ASCII text back into raw binary buffers. — e.bytes.base64_decoder

#971Hexadecimal String Encoder

Converting raw bytes to lowercase/uppercase two-character hex strings. — e.bytes.hex_encode

#972URL Query String Builder

Serializing key-value dictionary objects into URL-encoded parameter strings. — e.fmt.uri.query_build

#973URL Query String Parser

Deconstructing query parameter strings into key-value map structures. — e.fmt.uri.query_parse

#974Diff Match Patch

Computing line/character text differences and applying patch operations cleanly. — e.text.diff.patch

#975CRC32 Table-Driven Calculation

Accelerating 32-bit cyclic redundancy check calculations using 256-entry lookup tables. — see #570 (e.algo.hash.crc32)

#976Adler-32 Checksum Engine

Fast 32-bit checksum computation updating s1 and s2 rolling sums. — see #569 (e.algo.hash.adler32)

#977MD5 Digest Computation

Computing legacy 128-bit hashes over 512-bit message blocks. — see #563 (e.crypto.hash.legacy_md5)

#978Floyd's Cycle Finding (Tortoise and Hare)

O(1) memory pointers detecting cycles in linked lists or state sequences. — e.algo.search.cycle_floyd

#979Brent's Cycle Finding

Cycle detection using moving power-of-two teleporters running faster than Floyd's algorithm. — e.algo.search.cycle_brent

#980Misra-Gries Heavy Hitters

Finding items appearing more than N/k times in streaming data. — see #245 (e.algo.sketch.misra_gries)

#981Flajolet-Martin Count

Estimating number of distinct elements using trailing zero bit counts of hashed values. — e.algo.sketch.flajolet_martin

#982Reservoir Sampling with Weights (A-Res)

Weighted random sampling from streams using priority keys (U1/w). — e.algo.rand.reservoir_weighted

#983Linear Counting Algorithm

Cardinality estimation algorithm for datasets with low to medium distinct counts. — e.algo.sketch.linear_counting

#984Exponential Decay Moving Average

Time-weighted running average giving higher precedence to recent observations. — see #795 (e.dsp.ema)

#985Topological Sort (Kahn's)

In-degree tracking algorithm ordering directed acyclic graphs linearly. — see #73 (e.algo.graph.topological)

#986Tarjan's Off-Line LCA Algorithm

Finding lowest common ancestors for offline node pairs using disjoint sets during DFS. — e.algo.graph.tree.lca_offline

#987Prüfer Code Generation

Converting labeled trees into compact sequence representations. — see #88 (e.algo.graph.tree.prufer_encode)

#988Stern-Brocot Tree Binary Search

Representing all positive irreducible rational numbers using binary tree traversals. — e.math.ntheory.stern_brocot_search

#989Farey Sequence Generation

Generating ordered sequences of completely reduced fractions between 0 and 1. — e.math.ntheory.farey

#990Fast Matrix Exponentiation

Computing AN in O(M3 log N) time to solve linear recurrence relations. — see #510 (e.algo.linalg.matrix.pow)

#991Strassen's Submatrix Multiplication

Divide-and-conquer algorithm multiplying 2 × 2 submatrices using 7 multiplications instead of 8. — skip: an implementation detail of an existing module, not an API

#992Coppersmith-Winograd Algorithm

Theoretical fast matrix multiplication algorithm running in O(N2.3754). — skip: research-grade, no settled practical implementation

#993Probing Sequence Generation

Calculating secondary probe offsets in hash tables (Linear, Quadratic, Double Hashing). — skip: an implementation detail of an existing module, not an API

#994Hopcroft-Karp Bipartite Matching

O(E √V) maximum cardinality matching algorithm in bipartite graphs. — see #78 (e.algo.graph.match.hopcroft_karp)

#995Hierholzer's Eulerian Circuit Finding

Constructing Eulerian paths in O(E) time by splicing sub-tours. — see #80 (e.algo.graph.euler_path)

#996Bron-Kerbosch Maximal Clique Search

Recursive algorithm finding maximal cliques in undirected graphs. — see #104 (e.algo.graph.max_cliques)

#997Johnson's All-Pairs Shortest Path

Reweighting edge costs via Bellman-Ford to run Dijkstra from all vertices safely. — see #72 (e.algo.graph.johnson)

#998A Pathfinding Heuristic Evaluation*

Combining path costs (g(n)) and estimated distance (h(n)) to navigate weighted graphs. — see #65 (e.algo.graph.path.astar)

#999Floyd-Warshall Shortest Path

Dynamic programming algorithm computing all-pairs shortest paths in O(V 3). — see #66 (e.algo.graph.floyd_warshall)

#1000Quickselect Selection Algorithm

Partition-based selection finding k-th smallest elements in unsorted arrays in expected O(N) time. do another 250 — see #32 (e.algo.search.kth)

16. Quantum Computing, Physics & Scientific Simulation (1001–1050)

#1001Quantum Fourier Transform (QFT)

Quantum analogue of the discrete Fourier transform mapping state vectors into frequency bases in O((log N)2) gates. — skip: needs quantum hardware or a simulator

#1002Shor's Algorithm

Polynomial-time quantum algorithm for integer factorization using quantum period-finding. — skip: needs quantum hardware or a simulator

#1003Grover's Search Algorithm

Quadratic quantum speedup searching unstructured databases in O(√N) iterations. — skip: needs quantum hardware or a simulator

#1004Variational Quantum Eigensolver (VQE)

Hybrid quantum-classical algorithm estimating ground state energies of quantum system Hamiltonians. — skip: needs quantum hardware or a simulator

#1005Quantum Approximate Optimization Algorithm (QAOA)

Variational quantum algorithm solving combinatorial optimization problems on NISQ devices. — skip: needs quantum hardware or a simulator

#1006Deutsch-Jozsa Algorithm

Deterministic quantum algorithm evaluating whether black-box functions are constant or balanced in a single query. — skip: needs quantum hardware or a simulator

#1007Bernstein-Vazirani Algorithm

Quantum algorithm determining hidden binary bitstrings in a single oracle query. — skip: needs quantum hardware or a simulator

#1008Simon's Algorithm

Exponentially faster quantum algorithm discovering hidden periodic XOR masks. — skip: needs quantum hardware or a simulator

#1009Quantum Phase Estimation (QPE)

Estimating the eigenphase of a unitary operator given its eigenvector state. — skip: needs quantum hardware or a simulator

#1010BB84 Protocol

Quantum key distribution protocol detecting eavesdropping via quantum state collapse. — skip: needs quantum hardware or a simulator

#1011E91 Protocol (Ekert91)

Quantum key distribution relying on entangled photon pairs and Bell inequality testing. — skip: needs quantum hardware or a simulator

#1012Quantum Teleportation Protocol

Transmitting quantum states across arbitrary distances using shared entanglement and classical communication. — skip: needs quantum hardware or a simulator

#1013Superdense Coding

Transmitting two classical bits of information using a single transmitted qubit and shared entanglement. — skip: needs quantum hardware or a simulator

#1014Shor's 9-Qubit Code

Quantum error correction encoding one logical qubit into nine physical qubits to protect against arbitrary single-qubit errors. — skip: needs quantum hardware or a simulator

#1015Surface Code Error Correction

Topological quantum error correction topology executing 2D nearest-neighbor stabilizer measurements. — skip: needs quantum hardware or a simulator

#1016Harrow-Hassidim-Lloyd (HHL) Algorithm

Solving linear systems of equations Ax = b on quantum computers in logarithmic time relative to matrix size. — skip: needs quantum hardware or a simulator

#1017Quantum Walk

Quantum mechanics analogue of classical random walks exhibiting quadratic space-time propagation spread. — skip: needs quantum hardware or a simulator

#1018Velocity Verlet Integration

Second-order symplectic numerical integrator calculating position and velocity vectors in molecular dynamics. — e.math.ode.verlet

#1019Leapfrog Integration

Symplectic integrator stepping positions and velocities at interleaved half-time steps. — e.math.ode.leapfrog

#1020Runge-Kutta 4th Order (RK4)

Fourth-order numerical integration method solving ordinary differential equations using slope weighted averages. — e.math.ode.rk4

#1021Euler-Maruyama Method

Stochastic numerical method approximating solutions to stochastic differential equations (SDEs). — e.math.ode.euler_maruyama

#1022Metropolis-Hastings MCMC

Markov Chain Monte Carlo sampling drawing samples from probability distributions using proposal acceptance ratios. — e.math.mcmc.metropolis_hastings

#1023Gibbs Sampling

MCMC algorithm sampling multivariate distributions by updating one parameter conditioned on all others sequentially. — e.math.mcmc.gibbs

#1024Hamiltonian Monte Carlo (HMC)

MCMC algorithm using gradient-based molecular dynamics trajectories to propose distant state moves efficiently. — e.math.mcmc.hmc

#1025No-U-Turn Sampler (NUTS)

Automated extension of HMC eliminating manual path length tuning by building recursive binary trees. — e.math.mcmc.nuts

#1026Particle-in-Cell (PIC) Method

Simulating plasma and fluid dynamics by tracking discrete particles on Eulerian spatial grids. — skip: domain simulation outside a general library

#1027Lattice Boltzmann Method (LBM)

Fluid dynamics simulation modeling particle density distributions on discrete lattice grids. — skip: domain simulation outside a general library

#1028Finite Element Method (FEM) Assembly

Discretizing continuous physical fields into mesh element matrices to solve partial differential equations. — skip: domain simulation outside a general library

#1029Finite-Difference Time-Domain (FDTD)

Maxwell's equation solver grid-discretizing electric and magnetic fields in time and space. — skip: domain simulation outside a general library

#1030Smoothed Particle Hydrodynamics (SPH)

Meshfree Lagrangian method simulating fluid movement using smoothed particle kernel sums. — e.game.physics.sph

#1031Fast Multipole Method (FMM)

Accelerating N-body potential interactions from O(N2) to O(N) via multipole expansion tree structures. — skip: domain simulation outside a general library

#1032Barnes-Hut Algorithm

O(N log N) approximation for N-body simulation grouping distant particles using octrees. — e.algo.geom3.barnes_hut

#1033Direct Simulation Monte Carlo (DSMC)

Probabilistic gas dynamics method modeling rarefied gas flows using collisions among representative particles. — skip: domain simulation outside a general library

#1034Kohn-Sham Density Functional Theory

Quantum mechanical modeling method solving non-interacting electronic orbital equations. — skip: domain simulation outside a general library

#1035Hartree-Fock Method

Approximation method calculating molecular electronic structures via Slater determinant wavefunctions. — skip: domain simulation outside a general library

#1036Diffusion Quantum Monte Carlo (DMC)

Projecting ground state wavefunctions using imaginary-time Schrödinger equation propagation. — skip: domain simulation outside a general library

#1037Continuous-Time Quantum Monte Carlo (CT-QMC)

Exact quantum impurity solver evaluating Feynman diagram expansions. — skip: domain simulation outside a general library

#1038Tensor Network Contraction (MPS / PEPS)

Compressing quantum multi-body states into low-rank tensor chains and grids. — skip: domain simulation outside a general library

#1039Density Matrix Renormalization Group (DMRG)

Variational tensor network method calculating low-energy states of 1D quantum lattice systems. — skip: domain simulation outside a general library

#1040Quantum Amplitude Estimation

Estimating quantum state probability amplitudes with quadratic speedup over Monte Carlo sampling. — skip: needs quantum hardware or a simulator

#1041Quantum Counting Algorithm

Combining Grover search and Quantum Phase Estimation to count solutions in unstructured search spaces. — skip: needs quantum hardware or a simulator

#1042Quantum Singular Value Transformation (QSVT)

Unified framework applying polynomial transformations to singular values of block-encoded matrices. — skip: needs quantum hardware or a simulator

#1043Variational Quantum Classifier (VQC)

Supervised quantum machine learning model encoding data into quantum states and optimizing parameter gates. — skip: needs quantum hardware or a simulator

#1044Quantum State Tomography

Reconstructing unknown quantum state density matrices from sets of quantum measurements. — skip: needs quantum hardware or a simulator

#1045Quantum Process Tomography

Complete experimental characterization of unknown quantum channels and gate operations. — skip: needs quantum hardware or a simulator

#1046Parameter Shift Rule

Computing exact analytical gradients of parameterized quantum circuits on physical hardware. — skip: needs quantum hardware or a simulator

#1047Symplectic Integrator (Yoshida Integration)

High-order geometric integrator conserving total energy phase-space invariants in classical mechanics. — e.math.ode.yoshida

#1048Multigrid Method (V-Cycle / W-Cycle)

Solving PDE linear systems across hierarchical grid resolutions to accelerate convergence. — e.algo.linalg.matrix.multigrid

#1049Fast Marching Method

O(N log N) numerical algorithm solving Eikonal boundary value wave arrival time equations. — e.gfx.filter.fast_marching

#1050Fast Sweeping Method

Iterative grid algorithm solving Eikonal equations using alternating Gauss-Seidel spatial sweeps. — e.gfx.filter.fast_sweeping

17. Advanced Data Structures & Succinct Structures (1051–1100)

#1051Succinct Rank / Select Operations

Supporting O(1) count queries for k-th set bits in compressed bitvectors using auxiliary block structures. — e.data.succinct.rank

#1052LOUDS Tree Encoding

Level-Order Unary Degree Sequence representing arbitrary N-node tree topologies in 2N + O(1) bits. — e.data.succinct.louds

#1053BP (Balanced Parentheses) Succinct Tree

Representing tree hierarchies using balanced bracket sequences with O(1) navigation operations. — e.data.succinct.balanced_parens

#1054Wavelet Tree

Compact data structure supporting range quantile, rank, and select queries over arbitrary alphabets in O(log Σ) time. — e.data.succinct.wavelet_tree

#1055Compressed Suffix Array (CSA)

Text indexing structure reducing suffix array memory usage down to empirical text entropy bounds. — e.data.succinct.compressed_suffix_array

#1056FM-Index Search

Combining Burrows-Wheeler Transform and rank operations for fast string pattern matching in compressed text space. — e.data.succinct.fm_index

#1057Compressed Suffix Tree (CST)

Succinct data structure supporting full suffix tree operations using O(N log Σ) bits. — skip: implementable, but too specialised for the standard library

#1058Dynamic Wavelet Matrix

Variant of wavelet trees optimizing rank/select queries over large dynamically changing alphabets. — skip: implementable, but too specialised for the standard library

#1059X-Fast Trie

Bitwise trie combined with hash tables providing O(log w) successor queries for w-bit keys. — skip: implementable, but too specialised for the standard library

#1060Y-Fast Trie

Indirection structure combining x-fast tries with balanced BSTs to achieve O(log w) queries in O(N) space. — skip: implementable, but too specialised for the standard library

#1061Fusion Tree

w-wide tree structure achieving O(log N) searching time using w parallel bit comparison operations. — skip: research-grade, no settled practical implementation

#1062Exponential Tree

Search tree structure converting static search algorithms into dynamic implementations. — skip: research-grade, no settled practical implementation

#1063Tango Tree

Self-adjusting BST providing O(log log N) competitive ratio against optimal offline access sequences. — skip: research-grade, no settled practical implementation

#1064Splay-Tree Multisplay Engine

Multi-dimensional splay tree variant maintaining dynamic structural bounds. — skip: research-grade, no settled practical implementation

#1065Link-Cut Tree

Dynamic tree structure maintaining collections of rooted trees supporting path updates and link/cut operations in O(log N) time. — e.data.link_cut.link

#1066Euler Tour Tree

Dynamic graph structure tracking tree connectivity via Euler tour sequences over dynamic edge changes. — e.data.link_cut.euler_tour_tree

#1067Top Tree

Abstract data structure maintaining dynamic tree properties using recursive path and tree decompositions. — skip: implementable, but too specialised for the standard library

#1068Kinetic Heap

Priority queue structure maintaining dynamic priorities governed by continuous time functions. — skip: implementable, but too specialised for the standard library

#1069Persistent Segment Tree

Fully persistent segment tree maintaining all historical versions after updates in O(log N) time per change. — see #199 (e.data.segment_tree.persistent_update)

#1070Fully Persistent Treap

Search tree preserving functional immutability and complete revision history via node copying. — e.data.treap.persistent_insert

#1071Retroactive Priority Queue

Data structure allowing inserting, deleting, or Modifying historical queue operations at past time steps. — skip: implementable, but too specialised for the standard library

#1072Priority R-Tree

Worst-case optimal spatial index tree maintaining bounding boxes with O( N + K) query performance. — skip: implementable, but too specialised for the standard library

#1073Hilbert R-Tree

Spatial R-tree variant sorting bounding box centroids along space-filling Hilbert curves. — e.data.spatial.rtree_hilbert

#1074Range Tree with Fractional Cascading

Multi-dimensional search structure reducing range search query times to O(log N + K). — e.data.spatial.range_tree

#1075Interval Tree with Fractional Cascading

Accelerating 2D range overlap queries by maintaining pointers between adjacent coordinate lists. — see #224 (e.data.spatial.interval_overlap)

#1076Disjoint Set Union with Path Halving

Optimization of DSU skipping every other parent node during path traversal. — e.algo.disjoint_set.find

#1077Randomized Meldable Heap

Priority queue allowing O(log N) expected heap merging via random node swaps. — e.data.heap.meldable

#1078Brodal Queue

Heap structure offering O(1) worst-case push/meld and O(log N) delete-min bounds. — skip: research-grade, no settled practical implementation

#1079Soft Heap

Priority queue achieving O(1) amortized bounds by corrupting values of a small fraction of keys. — skip: research-grade, no settled practical implementation

#1080Strict Fibonacci Heap

Heap variant achieving worst-case O(1) insertion/decrease-key and O(log N) deletion bounds. — skip: research-grade, no settled practical implementation

#1081Pairing Heap (Lazy Variant)

Self-adjusting heap variant postponing tree restructuring until explicit deletion calls. — e.data.heap.pairing_merge

#1082Hollow Heap

Simple heap structure matching Fibonacci heap bounds using DAG-based hollow node tags. — skip: research-grade, no settled practical implementation

#1083Van Emde Boas Tree

Bit-vector search tree supporting predecessor/successor queries in O(log log U) time. — skip: implementable, but too specialised for the standard library

#1084Hash Array Mapped Trie (HAMT)

Immutable array-mapped trie balancing key paths using bit-popcount branching. — e.data.hamt.put

#1085Patricia Trie (Compressed Radix)

Compact prefix tree merging single-child nodes to reduce memory footprints. — e.data.trie.compact

#1086Cuckoo Filter

Probabilistic set membership structure supporting item deletion using Cuckoo hashing tables. — see #240 (e.algo.sketch.cuckoo_insert)

#1087XOR Filter

Space-efficient probabilistic filter evaluating membership using three-way XOR lookup arrays. — e.algo.sketch.xor_filter

#1088Binary Fuse Filter

Fast probabilistic filter outperforming XOR filters in space efficiency and construction speed. — e.algo.sketch.binary_fuse_filter

#1089Quotient Filter

Probabilistic filter storing fingerprints in contiguous slotted hash tables to optimize cache locality. — see #241 (e.algo.sketch.quotient_filter)

#1090Count-Min Sketch with Conservative Update

Frequency estimation sketch ignoring updates when current cell estimates exceed minimum readings. — e.algo.sketch.count_min_add_conservative

#1091Heavy-Keeper Algorithm

Streaming algorithm using decay-based count tracking to locate top-k frequent items. — skip: implementable, but too specialised for the standard library

#1092Space-Saving Algorithm

Streaming algorithm maintaining fixed-size stream tables for stream frequency estimation. — see #246 (e.algo.sketch.space_saving)

#1093t-Digest Quantile Sketch

Data structure approximating online order-statistics and quantiles over streaming numeric data. — e.algo.sketch.tdigest

#1094KLL Quantile Sketch

Streaming algorithm providing provable rank-error guarantees for quantile estimation. — e.algo.sketch.kll

#1095DDSketch

Fully mergeable relative-error quantile sketch maintaining relative error bounds across extreme values. — e.algo.sketch.ddsketch

#1096MinHash LSH Indexing

Locality-Sensitive Hashing indexing Jaccard similarity between document set signatures. — e.ml.ann.minhash_lsh

#1097SimHash Near-Duplicate Detection

Cosine-distance LSH hashing multi-dimensional feature vectors into bit masks. — see #259 (e.algo.sketch.simhash)

#1098Weight-Balanced Tree (BB[α])

Self-balancing binary search tree maintaining balance ratios based on subtree node counts. — skip: an implementation detail of an existing module, not an API

#1099Compressed Matrix Trie

Succinct multi-dimensional array mapping multi-index structures into linear memory spaces. — skip: implementable, but too specialised for the standard library

#1100R-S-Tree (Succinct B-Tree)

Compressed internal node layout combining succinct bitvectors with standard B-tree branch structures. — skip: implementable, but too specialised for the standard library

18. Game Development, Physics Engines & Computer Graphics (1101–1150)

#1101Percentage-Closer Filtering (PCF)

Soft shadow anti-aliasing technique averaging depth comparison results across pixel grid samples. — e.gfx.scene.shadow_pcf

#1102Cascaded Shadow Maps (CSM)

Rendering multi-resolution shadow maps split across camera view frustum depth slices. — e.gfx.scene.shadow_cascades

#1103Variance Shadow Maps (VSM)

Fast shadow mapping technique storing depth and squared-depth moments to permit filtering. — skip: implementable, but too specialised for the standard library

#1104Screen Space Ambient Occlusion (SSAO)

Screen-space image effect approximating local ambient contact shadowing using depth buffer sampling. — e.gfx.scene.ssao

#1105Horizon-Based Ambient Occlusion (HBAO)

Raymarching depth buffers along horizon angle directions to generate realistic contact shadows. — see #1104 (e.gfx.scene.ssao)

#1106Ground Truth Ambient Occlusion (GTAO)

Physically-based ambient occlusion calculating closed-form visibility integrals over view horizons. — see #1104 (e.gfx.scene.ssao)

#1107Screen Space Reflections (SSR)

Tracing ray trajectories in screen-space depth buffers to evaluate specular surface reflections. — e.gfx.scene.ssr

#1108Fast Approximate Anti-Aliasing (FXAA)

Single-pass post-processing anti-aliasing algorithm smoothing high-contrast color edges. — e.gfx.scene.fxaa

#1109Subpixel Morphological Anti-Aliasing (SMAA)

Post-processing anti-aliasing detecting subpixel pattern shapes and blending weights. — skip: implementable, but too specialised for the standard library

#1110Temporal Anti-Aliasing (TAA)

Anti-aliasing technique combining jittered subpixel samples accumulated over consecutive rendered frames. — e.gfx.scene.taa

#1111Deep Learning Super Sampling (DLSS)

AI-driven temporal upscaling evaluating low-resolution frames and motion vectors. — skip: a trained ML model or training recipe

#1112Clustered Forward Rendering

Partitioning view frustums into 3D grid clusters to assign light lists for forward shading. — e.gfx.scene.clustered_lights

#1113Deferred Shading G-Buffer Pass

Decoupling geometry processing from lighting calculation by storing material properties in intermediate buffers. — e.gfx.scene.deferred

#1114Ray Tracing Hardware BVH Traversal

Stackless acceleration tree traversal evaluating ray-primitive intersections on GPU ray cores. — skip: hardware or circuit design

#1115Path Tracing Next Event Estimation (NEE)

Explicitly sampling light sources at path bounces to reduce Monte Carlo image noise. — e.gfx.trace.next_event_estimation

#1116Multiple Importance Sampling (MIS)

Combining surface BRDF sampling and light source sampling to minimize variance in path tracing. — e.gfx.trace.multiple_importance

#1117Bidirectional Path Tracing (BDPT)

Tracing eye paths from camera and light paths from sources, connecting path vertices in pairs. — skip: implementable, but too specialised for the standard library

#1118ReSTIR (Reservoir-based Resampling)

Spatiotemporal importance resampling tracking dynamic light contributions across light samples. — skip: implementable, but too specialised for the standard library

#1119Position-Based Dynamics (PBD)

Simulating physical systems (cloth, soft bodies) by modifying positions directly to satisfy geometric constraints. — e.game.physics.pbd_step

#1120Extended Position-Based Dynamics (XPBD)

PBD extension incorporating physical compliance constants independent of frame rates and iterations. — e.game.physics.xpbd_step

#1121Material Point Method (MPM)

Continuum mechanics solver combining Eulerian grids and particle representations for snow, mud, and sand. — skip: domain simulation outside a general library

#1122Projected Gauss-Seidel Constraint Solver

Iteratively computing impulse vectors to solve rigid body contact constraints. — e.game.physics.solve_gauss_seidel

#1123Conservative Advancement CCD

Continuous Collision Detection stepping time forward safely without penetrating fast-moving geometries. — e.game.physics.ccd_conservative

#1124Sweep and Prune

Broadphase collision detection algorithm sorting axis-aligned bounding box endpoints along principal axes. — e.game.physics.sweep_and_prune

#1125Spatial Grid Broadphase

Hashing object bounding boxes into fixed 3D grid buckets to isolate candidate collision pairs. — e.game.collide2d.grid_insert

#1126FABRIK (Forward And Backward Reaching IK)

Iterative inverse kinematics algorithm adjusting joint positions forwards and backwards along bone chains. — e.game.anim.ik_fabrik

#1127Cyclic Coordinate Descent (CCD IK)

Inverse kinematics optimization adjusting one joint angle at a time to align end effectors with target positions. — e.game.anim.ik_ccd

#1128Dual Quaternion Skinning

Character mesh animation solver eliminating artifact volume loss at bending joints ("candy wrapper" effect). — e.game.anim.skin_dual_quaternion

#1129Linear Blend Skinning (LBS)

Animating vertices by blending transformations across weighted joint hierarchies. — e.game.anim.skin_linear_blend

#1130Recast Navigation Mesh Generation

Voxelizing 3D geometry and extracting walkable polygon surface meshes for pathfinding. — e.game.nav.build_navmesh

#1131Funnel Algorithm (String Pulling)

Finding shortest straight paths across sequences of convex navigation mesh polygons. — e.game.nav.funnel

#1132Flow Field Pathfinding

Generating vector direction fields across spatial grids to navigate large crowds of agents toward goals. — e.game.nav.flow_field

#1133Hierarchical Pathfinding (HPA)*

Abstracting large grid maps into macro-node graphs to accelerate path searches. — e.game.nav.hierarchical_astar

#1134Behavior Tree Traversal Engine

Evaluating hierarchical Selector, Sequence, and Decorator nodes to manage game AI states. — e.game.ai.behavior_tick

#1135Goal-Oriented Action Planning (GOAP)

Searching action graphs using A* to generate optimal sequences fulfilling AI goal states. — e.game.ai.goap_plan

#1136Utility AI Evaluator

Scoring available behaviors using continuous utility curves to select high-value AI choices. — e.game.ai.utility_select

#1137Boids Flocking Model (Reynolds)

Simulating crowd movement using Separation, Alignment, and Cohesion steering vectors. — e.game.ai.boids

#1138Wave Function Collapse (WFC)

Procedural generation algorithm generating grid layouts satisfying adjacent edge compatibility constraints. — e.game.procgen.wave_function_collapse

#1139Perlin Noise Generation

Gradient noise function creating continuous procedural textures, terrain, and natural forms. — e.game.procgen.perlin

#1140Simplex Noise Generation

Higher-dimensional procedural noise function using simplex grid layouts to improve computational complexity. — e.game.procgen.simplex

#1141Worley (Cellular) Noise

Distance-based noise function generating cell patterns for stone, water, and biological textures. — e.game.procgen.worley

#1142Tessendorf FFT Ocean Waves

Simulating realistic ocean surface waves using statistical wind spectrum Fast Fourier Transforms. — skip: implementable, but too specialised for the standard library

#1143Volumetric Fog Raymarching

Raymarching light-scattering participation media using 3D volume noise textures. — e.gfx.scene.volumetric_fog

#1144Bruneton Atmosphere Scattering

Precomputing multiple atmospheric light scattering integrals for real-time sky rendering. — skip: implementable, but too specialised for the standard library

#1145SDF Raymarching (Sphere Tracing)

Marching camera rays along dynamic distances defined by Signed Distance Fields. — e.gfx.scene.sdf_raymarch

#1146Meshlet Cone Culling

GPU geometry pipeline culling mesh clusters (meshlets) based on backface normal cones and bounding spheres. — skip: hardware or circuit design

#1147Virtual Shadow Maps (VSM)

High-resolution clipmap shadow mapping dividing shadow projections into dynamically allocated physical pages. — skip: implementable, but too specialised for the standard library

#1148Dynamic Mesh LOD Simplification

Simplifying dense geometries dynamically by collapsing edge pairs while maintaining topology metrics. — e.gfx.mesh.decimate

#1149Screen-Space Horizon Traversal (SSHT)

Raymarching screen space height fields to compute detailed contact ambient shadows. — skip: implementable, but too specialised for the standard library

#1150Distance Field Ambient Occlusion (DFAO)

Approximating ambient occlusion using mesh-generated signed distance field representations. — skip: implementable, but too specialised for the standard library

19. Bioinformatics, Computational Biology & Genomics Algorithms (1151–1200)

#1151Needleman-Wunsch Algorithm

O(MN) dynamic programming algorithm computing global sequence alignment between nucleotide/protein sequences. — see #305 (e.algo.align.global)

#1152Smith-Waterman Algorithm

Dynamic programming algorithm finding optimal local sequence alignment regions between two sequences. — see #306 (e.algo.align.local)

#1153Hirschberg's Algorithm

Dynamic programming variant reducing sequence alignment space complexity to O(min(M,N)). — see #307 (e.algo.align.global_linear_space)

#1154Gotoh's Algorithm

Optimized sequence alignment incorporating affine gap penalties in O(MN) time. — e.algo.align.affine_gap

#1155BLAST Seed-and-Extend

Heuristic sequence alignment discovering short exact word matches and extending them into High-Scoring Segment Pairs. — skip: bioinformatics domain tool

#1156Burrows-Wheeler Aligner (BWA)

Mapping short sequencing reads against reference genomes using Burrows-Wheeler Transform indexing. — skip: bioinformatics domain tool

#1157Bowtie Seeded Alignment

Fast short-read alignment engine building compact FM-Indexes of human reference genomes. — skip: bioinformatics domain tool

#1158De Bruijn Graph Genome Assembly

Constructing directed graphs over overlapping k-mer substrings to assemble raw DNA reads into contigs. — skip: bioinformatics domain tool

#1159Overlap-Layout-Consensus (OLC) Assembly

Genome assembly paradigm computing pairwise read overlaps to construct string graphs. — skip: bioinformatics domain tool

#1160Neighbor-Joining Algorithm

Bottom-up clustering method constructing phylogenetic trees based on evolutionary distance matrices. — e.ml.cluster.neighbor_joining

#1161UPGMA Clustering

Agglomerative hierarchical clustering method generating ultrametric phylogenetic trees. — see #730 (e.ml.cluster.agglomerative)

#1162Felsenstein's Pruning Algorithm

Dynamic programming algorithm computing maximum likelihood scores across phylogenetic tree nodes. — skip: bioinformatics domain tool

#1163Profile HMM Search (HMMER)

Modeling domain protein families using Hidden Markov Models to detect distant sequence homologs. — skip: bioinformatics domain tool

#1164Viterbi Decoding for Gene Prediction

Identifying exon-intron gene structures across DNA sequences using HMM state decoding. — e.ml.hmm.viterbi

#1165Baum-Welch Algorithm

Expectation-Maximization algorithm estimating unknown transition and emission probabilities of Hidden Markov Models. — e.ml.hmm.baum_welch

#1166Nussinov RNA Folding Algorithm

Dynamic programming algorithm predicting RNA secondary structures by maximizing base pair counts. — skip: bioinformatics domain tool

#1167Zuker RNA Folding Algorithm

Predicting minimum free energy RNA secondary structures using thermodynamic base-pair energy parameters. — skip: bioinformatics domain tool

#1168Kabsch Algorithm

Calculating optimal rotation matrix minimizing Root Mean Square Deviation (RMSD) between aligned protein coordinate sets. — e.algo.geom3.kabsch

#1169TM-align Algorithm

Structural alignment algorithm scoring protein pair similarities independently of sequence length differences. — skip: bioinformatics domain tool

#1170DALI Protein Alignment

Aligning 3D protein structures by comparing internal distance matrices of contact patterns. — skip: bioinformatics domain tool

#1171Linear Mixed Model (GWAS)

Controlling for population structure and family relatedness when testing genetic variants in GWAS datasets. — skip: bioinformatics domain tool

#1172GATK HaplotypeCaller Graph Assembly

Re-assembling local sequence reads using de Bruijn graphs to call single-nucleotide variants and indels. — skip: bioinformatics domain tool

#1173Salmon Pseudoalignment

Ultra-fast RNA-seq transcript quantification skipping full alignment using k-mer equivalence classes. — skip: bioinformatics domain tool

#1174Kallisto Pseudoalignment

Mapping RNA-seq reads directly to transcript target de Bruijn graphs without computing base-level alignments. — skip: bioinformatics domain tool

#1175DESeq2 Negative Binomial Regression

Modeling count variance across biological replicates in RNA-seq differential expression analysis. — skip: bioinformatics domain tool

#1176Louvain Community Detection for Single-Cell

Graph-based clustering partitioning single-cell expression profiles using modularity optimization. — see #106 (e.algo.graph.community.louvain)

#1177Leiden Community Detection

Improved single-cell graph clustering algorithm resolving disconnected community artifacts found in Louvain. — e.algo.graph.community.leiden

#1178Monocle Pseudotime Inference

Ordering single-cell gene expression profiles along developmental trajectories using minimum spanning trees. — skip: bioinformatics domain tool

#1179Kraken K-mer Taxonomic Classification

Classifying metagenomic reads by matching k-mer strings to lowest common ancestor database trees. — skip: bioinformatics domain tool

#1180Minimap2 Alignment

Pairwise alignment engine mapping long reads (PacBio/Nanopore) using minimizer seed chains. — skip: bioinformatics domain tool

#1181Flye Assembly Algorithm

Long-read genome assembler constructing repeat graphs from error-prone reads. — skip: bioinformatics domain tool

#1182AutoDock Vina Scoring

Molecular docking software calculating empirical affinity binding scores between protein targets and drug ligands. — skip: bioinformatics domain tool

#1183Pharmacophore Matching Grid Search

Mapping 3D spatial arrangements of essential molecular interaction features onto small molecules. — skip: bioinformatics domain tool

#1184BLAT (BLAST-Like Alignment Tool)

Fast DNA/protein sequence alignment using index tables of non-overlapping k-mer keywords. — skip: bioinformatics domain tool

#1185Plink Identity-by-State (IBS)

Evaluating genetic similarity metrics across individual genotypes to identify pairwise sample relationships. — skip: bioinformatics domain tool

#1186Linkage Disequilibrium Calculation

Measuring non-random association of alleles at different genetic loci within populations. — skip: bioinformatics domain tool

#1187Sankoff Algorithm

Parsimony-based dynamic programming scoring character state changes on phylogenetic tree structures. — skip: bioinformatics domain tool

#1188Cufflinks Assembly Engine

Assembling RNA-seq alignments into minimal sets of transcript isoforms using overlap graphs. — skip: bioinformatics domain tool

#1189MetaBAT2 Binning

Grouping metagenomic contigs into draft genomes using sequence co-abundance and tetranucleotide frequencies. — skip: bioinformatics domain tool

#1190Centrifuge Taxonomic Profiler

Compressed FM-index classification engine matching sequencing reads against large microbial reference sets. — skip: bioinformatics domain tool

#1191CellPhoneDB Interaction Mapping

Estimating cell-cell communication networks by analyzing single-cell ligand-receptor pair expression. — skip: bioinformatics domain tool

#1192CRISPR Off-Target Scoring (CFD)

Predicting CRISPR-Cas9 guide RNA cleavage efficiency across potential genomic off-target sites. — skip: bioinformatics domain tool

#1193Distance Geometry Protein Reconstruction

Calculating 3D atomic coordinates from lower and upper bounds of nuclear magnetic resonance (NMR) distances. — skip: bioinformatics domain tool

#1194EdgeR Empirical Bayes Analysis

Testing differential expression in digital gene expression data using empirical Bayes moderated dispersion estimates. — skip: bioinformatics domain tool

#1195CANU Long-Read Pipeline

Assembling noisy long reads through overlapping, error correction, and string graph construction steps. — skip: bioinformatics domain tool

#1196StringGraph Assembler (SGA)

Memory-efficient genome assembly using the FM-Index to build string graphs directly. — skip: bioinformatics domain tool

#1197Variant Call Format (VCF) Likelihood Engine

Calculating posterior genotype probabilities across genomic loci given read quality scores. — skip: bioinformatics domain tool

#1198AlphaFold Frame Aligner

Translating transformer sequence representations into 3D Euclidean frame coordinates for protein structure prediction. — skip: bioinformatics domain tool

#1199Cell Ranger Demultiplexing

Mapping single-cell GEM barcodes and UMIs to quantify cellular transcript abundances. — skip: bioinformatics domain tool

#1200N-Gram Genomic Profiling

Evaluating species similarity profiles by computing distance metrics over genomic k-mer frequency vectors. — skip: bioinformatics domain tool

20. Natural Language Processing, Speech & Information Retrieval (1201–1250)

#1201Byte-Pair Encoding (BPE)

Subword tokenization iteratively merging the most frequent character/token byte pairs. — see #373 (e.text.tokenize.bpe)

#1202WordPiece Tokenization

Subword tokenization picking subword merges that maximize language model likelihood scores. — see #374 (e.text.tokenize.wordpiece)

#1203Unigram Language Model Tokenization

SentencePiece subword tokenization optimizing vocabulary sets by iteratively dropping low-probability subwords. — see #375 (e.text.tokenize.unigram)

#1204Word2Vec Skip-Gram (SGNS)

Learning word vector representations by predicting surrounding context words using negative sampling. — skip: a trained ML model or training recipe

#1205Word2Vec Continuous Bag-of-Words (CBOW)

Learning word embeddings by predicting center words given averaged surrounding context vectors. — skip: a trained ML model or training recipe

#1206GloVe Embedding Factorization

Matrix factorization learning word embeddings by modeling global log co-occurrence count matrices. — skip: a trained ML model or training recipe

#1207FastText Subword Embeddings

Enhancing word embeddings by representing words as character n-gram bag sums to handle out-of-vocabulary terms. — skip: a trained ML model or training recipe

#1208BERT Masked Language Modeling (MLM)

Training bidirectional text representations by predicting randomly masked tokens within context sequences. — skip: a trained ML model or training recipe

#1209RoBERTa Optimization

Enhancing BERT performance by removing Next Sentence Prediction tasks and dynamically shifting token mask patterns. — skip: a trained ML model or training recipe

#1210ELECTRA Replaced Token Detection

Pre-training transformer models using discriminators that identify tokens replaced by generator models. — skip: a trained ML model or training recipe

#1211DeBERTa Disentangled Attention

Disentangling transformer self-attention calculations into distinct word content and relative position vectors. — skip: a trained ML model or training recipe

#1212T5 Text-to-Text Framework

Framing all NLP tasks (summarization, translation, classification) into a unified text input to text output sequence model. — skip: a trained ML model or training recipe

#1213GPT Autoregressive Language Modeling

Pre-training generative transformers using causal next-token prediction loss over left-to-right context. — skip: a trained ML model or training recipe

#1214LLaMA Architecture Adjustments

Enhancing autoregressive LLMs using pre-normalization (RMSNorm), SwiGLU activation functions, and Rotary Embeddings (RoPE). — skip: a trained ML model or training recipe

#1215Grouped-Query Attention (GQA)

Transformer attention architecture sharing key/value head projections across query head groups to accelerate generation. — skip: a trained ML model or training recipe

#1216Low-Rank Adaptation (LoRA)

Parameter-efficient LLM fine-tuning injecting trainable low-rank decomposition matrices into frozen attention layers. — skip: a trained ML model or training recipe

#1217QLoRA (Quantized LoRA)

Fine-tuning LLMs by combining 4-bit NormalFloat (NF4) quantization with low-rank adapter weights. — skip: a trained ML model or training recipe

#1218Direct Preference Optimization (DPO)

Aligning language models with human preferences using direct log-ratio classification loss without external reward models. — skip: a trained ML model or training recipe

#1219RLHF (PPO Alignment)

Fine-tuning LLM generation policies using Proximal Policy Optimization updates guided by human preference reward models. — skip: a trained ML model or training recipe

#1220BM25 Lexical Retrieval

Probabilistic Document Retrieval scoring keyword relevance using term frequency and inverse document frequency with length normalization parameters. — see #368 (e.text.rank.bm25)

#1221TF-IDF Weighting

Scoring term importance in document collections combining Term Frequency and Inverse Document Frequency logarithms. — see #367 (e.text.rank.tf_idf)

#1222Dense Passage Retrieval (DPR)

Retrieving text passages by computing cosine similarities between dense dual-encoder vector embeddings. — skip: a trained ML model or training recipe

#1223ColBERT Late Interaction

Information retrieval model computing token-level fine-grained similarity matrix max-sim sums across query and document terms. — skip: a trained ML model or training recipe

#1224Reciprocal Rank Fusion (RRF)

Combining rank positions from multiple distinct retrieval systems into unified document score rankings. — e.text.rank.reciprocal_rank_fusion

#1225Maximal Marginal Relevance (MMR)

Re-ranking document search results to maximize relevance while penalizing similarity to already selected items. — e.text.rank.maximal_marginal_relevance

#1226HNSW Vector Search

Approximate nearest neighbor vector search building multi-layer small-world graphs supporting O(log N) searches. — e.ml.ann.hnsw

#1227Inverted File with Product Quantization (IVF-PQ)

Vector search index dividing high-dimensional spaces into Voronoi cells and compressing sub-vectors. — e.ml.ann.ivf_pq

#1228ScaNN Anisotropic Quantization

Quantizing high-dimensional vectors by optimizing inner product preservation rather than Euclidean distance errors. — skip: a vendor product's architecture

#1229DiskANN Vector Index

Graph-based approximate nearest neighbor index serving multi-billion scale vector sets directly from SSD storage. — skip: a vendor product's architecture

#1230Double Metaphone Algorithm

Phonetic encoding algorithm generating primary and secondary codes for words based on English pronunciation edge cases. — see #313 (e.text.phonetic.metaphone)

#1231Porter Stemmer Algorithm

Rule-based suffix stripping algorithm mapping English words to their canonical morphological stems. — see #369 (e.text.stem.porter)

#1232Viterbi POS Tagging

Assigning optimal Part-of-Speech tag sequences to sentences using Hidden Markov Model dynamic programming. — e.ml.hmm.viterbi

#1233Conditional Random Fields (CRF)

Discriminative sequence modeling algorithm calculating global normalizations for named entity recognition (NER). — skip: a trained ML model or training recipe

#1234Transition-Based Arc-Eager Dependency Parsing

Constructing dependency parse trees using shift-reduce stack transition operations. — skip: a trained ML model or training recipe

#1235BLEU Score Evaluation

Automated evaluation metric comparing n-gram precision matching between machine translation outputs and reference texts. — e.text.metric.bleu

#1236ROUGE Metric Evaluation

Recall-oriented metric suite evaluating text summarization quality using n-gram and longest common subsequence counts. — e.text.metric.rouge

#1237BERTScore Semantic Metric

Evaluating text generation quality by computing contextual embedding token cosine similarities. — skip: a trained ML model or training recipe

#1238Connectionist Temporal Classification (CTC)

Loss function training sequence models (ASR, OCR) without explicit time-alignment labels. — e.ml.loss.ctc

#1239WFST Speech Decoding

Decoding speech audio frames into text using Weighted Finite-State Transducers combining Grammar, Lexicon, and Acoustic models. — skip: implementable, but too specialised for the standard library

#1240Whisper Speech Encoder-Decoder

Multitask speech recognition processing log- Mel spectrograms through audio encoders and autoregressive text decoders. — skip: a trained ML model or training recipe

#1241SentencePiece Unigram Sampler

Regularizing NLP model training by probabilistically sampling alternative subword tokenizations. — e.text.tokenize.unigram_sample

#1242Kahneman-Tversky Optimization (KTO)

Model alignment strategy directly maximizing utility functions derived from human loss-aversion behavioral principles. — skip: a trained ML model or training recipe

#1243Prefix Tuning

Parameter-efficient fine-tuning prepending continuous trainable task-specific prefix vectors to transformer key/value layers. — skip: a trained ML model or training recipe

#1244Sliding Window Attention

Reducing self-attention memory overhead by limiting attention fields to local fixed-size contextual windows. — skip: a trained ML model or training recipe

#1245Eisner's Dependency Parsing

O(N3) dynamic programming algorithm finding maximum spanning dependency trees over parsed sentences. — skip: implementable, but too specialised for the standard library

#1246Inside-Outside Algorithm

Calculating production rule expectations for Probabilistic Context-Free Grammars (PCFGs). — skip: implementable, but too specialised for the standard library

#1247METEOR Evaluation Metric

Translation assessment metric incorporating exact matches, stem matches, synonymy, and word order penalties. — e.text.metric.meteor

#1248Snowball Stemmer

Framework and algorithm generating customizable stemmers across multiple European languages. — see #371 (e.text.stem.snowball)

#1249FastSpeech Feed-Forward TTS

Non-autoregressive text-to-speech generation generating mel-spectrograms in parallel using duration predictors. — skip: a trained ML model or training recipe

#1250Soundex Indexing

Classifying English words by phonetic sound to index names despite minor spelling variations.  Yes yes — see #312 (e.text.phonetic.soundex)

21. Parallel, Distributed & Cloud Computing Systems (1251–1300)

#1251MapReduce Paradigm

Distributed data processing framework partitioning computations into parallel Map and Reduce phases. — skip: a technique applied per problem, not a reusable function

#1252Apache Spark RDD Lineage Engine

Fault-tolerant dynamic memory computation tracking operation graphs to rebuild lost partitions. — skip: a vendor product's architecture

#1253Parameter Server Architecture

Distributed machine learning framework separating worker node computations from parameter state synchronization. — skip: a whole service or system, not a function

#1254Bulk Synchronous Parallel (BSP) Model

Parallel execution abstraction operating in iterative supersteps bounded by global barriers. — skip: a technique applied per problem, not a reusable function

#1255Ring-AllReduce Algorithm

Bandwidth-optimal collective communication algorithm transferring array gradients across ring-connected worker nodes. — e.dist.collective.all_reduce_ring

#1256MPI Scatter-Gather & Broadcast

High-performance computing primitives distributing single arrays to multiple nodes and gathering responses. — e.dist.collective.broadcast

#1257Multi-Paxos Consensus

Optimized Paxos variant streamlining consensus rounds by electing long-term leaders for stream logging. — e.dist.consensus.multi_paxos

#1258Egalitarian Paxos (EPaxos)

Leaderless distributed consensus protocol allowing nodes to commit command instances without centralized bottlenecks. — skip: implementable, but too specialised for the standard library

#1259Viewstamped Replication (VR)

Primary-backup state machine replication protocol handling network reconfigurations via view changes. — e.dist.consensus.viewstamped

#1260Raft Log Compaction & Snapshotting

Compacting state machine logs by persisting state snapshots and discarding applied entries. — e.dist.consensus.raft_snapshot

#1261Google Spanner TrueTime API Sync

Distributed consistency primitive utilizing atomic clocks and GPS receivers to bound clock uncertainty (ϵ). — skip: a vendor product's architecture

#1262Two-Phase Commit with Paxos (2PC-Paxos)

Combining 2PC with Paxos-replicated transaction cohorts to eliminate coordinator single-point-of-failure blocks. — see #720 (e.dist.commit.two_phase)

#1263Try-Confirm-Cancel (TCC) Pattern

Application-level distributed transaction pattern reserving, committing, or releasing resources explicitly across services. — e.dist.commit.tcc

#1264Maglev Consistent Hash Load Balancer

Network load balancer mapping service flows into lookup tables to ensure uniform traffic distribution during backend churn. — e.net.balance.maglev

#1265Power of Two Random Choices (P2C)

Load balancing heuristic selecting the least loaded backend among two randomly chosen candidates. — see #713 (e.net.balance.power_of_two)

#1266Directory-Based Cache Coherence

Maintaining distributed shared memory consistency across hardware nodes via centralized state directories. — skip: hardware or circuit design

#1267Active-Active Database Replication

Replicating transactions concurrently across multiple geographically distributed write-capable nodes. — skip: a whole service or system, not a function

#1268Conflict-Free Replicated Data Types (CRDTs)

Data structures converging concurrently edited states without coordination (State-based / Operation-based). — e.dist.crdt.merge

#1269Operational Transformation (OT)

Concurrent text editing engine transforming local editing operations relative to concurrent remote updates. — e.text.collab.transform

#1270Distributed Weighted Lease Renewal

Time-bounded resource allocation protocol using heartbeat renewals to manage lease ownership. — e.dist.lock.lease_renew

#1271Distributed Snapshot (Chandy-Lamport)

Recording global system states in distributed systems by propagating state markers across channel queues. — see #152 (e.dist.snapshot.chandy_lamport)

#1272Epidemic Gossip Push-Pull State Sync

Exchanging missing cluster state vectors pairwise to achieve exponential network-wide convergence. — see #142 (e.dist.gossip.disseminate)

#1273Chase-Lev Work-Stealing Deque

Lock-free single-producer multi-consumer deque enabling worker threads to steal tasks efficiently. — e.concurrent.deque.steal

#1274MapReduce Combiner Optimization

Executing localized sub-aggregations on mapper outputs to minimize network serialization volume. — skip: a technique applied per problem, not a reusable function

#1275Distributed Lock Manager (DLM) Escalation

Managing clustered resource locks via lock escalation and distributed deadlock detection graphs. — skip: a whole service or system, not a function

#1276Redis Cluster Key Hash Slot Sharding

Partitioning keyspace into 16,384 deterministic hash slots assigned across cluster nodes. — skip: a vendor product's architecture

#1277Memcached Slab Allocation Engine

Memory manager pre-allocating fixed-size slab classes to eliminate heap memory fragmentation. — see #680 (e.mem.slab)

#1278W3C Trace Context Propagation

Injecting standardized traceparent and tracestate headers across HTTP/RPC boundaries for distributed tracing. — e.trace.propagate

#1279Cloud Autoscaling Reactive Control Loops

Monitoring real-time system metrics (CPU, memory, queue depth) to scale infrastructure capacity via PID controllers. — skip: a whole service or system, not a function

#1280Proactive Predictive Autoscaling

Forecasting traffic spikes using time-series models (Holt-Winters, ARIMA) to provision capacity prior to load arrival. — skip: a whole service or system, not a function

#1281Kubernetes Horizontal Pod Autoscaler (HPA)

Controller loop calculating target metric ratios to adjust replica counts dynamically. — skip: a vendor product's architecture

#1282Envoy Outlier Detection

Service mesh circuit breaking pattern isolating backends that exhibit elevated HTTP 5xx error rates. — skip: a vendor product's architecture

#1283eBPF Sidecar Proxy Interception

Bypassing standard TCP/IP stack overhead by redirecting socket traffic at the Linux kernel level. — skip: a vendor product's architecture

#1284DFS Chunk Metadata Management (GFS / HDFS)

Dividing massive files into 64MB/128MB chunks and managing locations via centralized master nodes. — skip: a whole service or system, not a function

#1285Erasure Coding (Reed-Solomon) in Distributed Storage

Splitting storage objects into K data chunks and M parity chunks to recover from M simultaneous node failures. — see #854 (e.algo.ecc.reed_solomon_decode)

#1286Ceph CRUSH Map Placement Algorithm

Algorithmic pseudo-random data object placement mapping objects directly to storage devices without lookup tables. — skip: a vendor product's architecture

#1287Amazon Dynamo Eventual Consistency Read-Repair

Reconciling stale replica data asynchronously during read operations using vector clock comparisons. — see #935 (e.dist.replica.read_repair)

#1288Distributed Outbox Pattern

Writing domain events to local database tables within transactions before publishing to asynchronous message brokers. — skip: a technique applied per problem, not a reusable function

#1289Apache Kafka Log Segment Rolling

Appending messages to immutable commit logs on disk and rolling segments based on age or byte bounds. — skip: a vendor product's architecture

#1290Zero-Copy Socket Transfer ( sendfile )

Transferring data directly from OS page caches to network sockets without copying memory to user space. — e.os.send_file

#1291Asynchronous Event-Driven I/O ( io_uring )

Offloading kernel system calls via shared submission and completion ring buffers. — skip: an implementation detail of an existing module, not an API

#1292Consensus-Driven Dynamic Membership Change

Transitioning cluster membership configurations safely using joint consensus states in Raft/Paxos. — e.dist.consensus.membership_change

#1293Redis Sliding Window Rate Limiter

Atomic Lua script enforcing precise rolling-window rate limits using sorted set scores ( ZADD / ZREMRANGEBYSCORE ). — see #709 (e.ratelimit.sliding_window)

#1294Pregel BSP Graph Compute Engine

Iterative graph processing framework executing user-defined compute functions at vertices during BSP supersteps. — skip: a technique applied per problem, not a reusable function

#1295Distributed Vector Index Sharding

Partitioning high-dimensional vector collections across nodes using multi-index or k-means space partitioning. — skip: a whole service or system, not a function

#1296Flink Chandy-Lamport Checkpointing

Injecting barrier markers into stream processing pipelines to record consistent state snapshots without stopping execution. — see #152 (e.dist.snapshot.chandy_lamport)

#1297Stream Processing Watermarking

Emitting monotonically increasing timestamp bounds to track event-time progress in out-of-order data streams. — e.data.stream.watermark

#1298DAG Task Scheduler Execution Engine

Resolving inter-task dependency graphs to schedule parallel processing stages (e.g., Apache Spark, Airflow). — e.thread.pool.run_dag

#1299Multi-Cluster Ingress Global Traffic Routing

Routing user requests across geographically distributed clusters using latency-based DNS or BGP Anycast. — skip: a whole service or system, not a function

#1300Chandy-Misra-Haas Deadlock Detection

Edge-chasing algorithm detecting deadlocks in distributed resource allocation systems. — see #111 (e.dist.deadlock.chandy_misra_haas)

22. Advanced Software Architecture, Compilers & Runtimes (1301–1350)

#1301Cytron's SSA Form Construction

Placing ϕ-functions at iterated dominance frontiers to construct Static Single Assignment representations. — skip: belongs in the Neper compiler, not the library

#1302Lengauer-Tarjan Dominator Tree Algorithm

Computing dominator trees in control-flow graphs using depth-first search and semi-dominators in O(E ⋅ α(V ,E)) time. — skip: belongs in the Neper compiler, not the library

#1303Global Value Numbering (GVN)

Compiler pass identifying redundant expressions across control-flow paths by assigning value numbers to SSA variables. — skip: belongs in the Neper compiler, not the library

#1304Sparse Conditional Constant Propagation (SCCP)

Propagating constants and evaluating branches simultaneously to eliminate dead code and simplify expressions. — skip: belongs in the Neper compiler, not the library

#1305Loop-Invariant Code Motion (LICM)

Hoisting computations that produce identical values across iterations out of loop bodies. — skip: belongs in the Neper compiler, not the library

#1306Chaitin-Briggs Graph Coloring Register Allocation

Modeling register allocation as a graph coloring problem over register interference graphs. — skip: belongs in the Neper compiler, not the library

#1307Linear Scan Register Allocation

Fast single-pass register allocator assigning registers by processing variable live ranges sequentially. — skip: belongs in the Neper compiler, not the library

#1308Escape Analysis

Compiler optimization determining if object allocations outlive execution frames to allocate memory on stacks instead of heaps. — skip: belongs in the Neper compiler, not the library

#1309Aggressive Dead Code Elimination (ADCE)

Removing instructions lacking observable side effects by operating control-dependence graphs in reverse. — skip: belongs in the Neper compiler, not the library

#1310Trace JIT Compilation

Hotpath runtime optimization recording executed basic-block traces and compiling them into native machine code. — skip: belongs in the Neper compiler, not the library

#1311Method JIT Compilation

Compiling frequently invoked functions or methods into optimized native code based on execution counters. — skip: belongs in the Neper compiler, not the library

#1312On-Stack Replacement (OSR)

Replacing unoptimized running frame stacks with optimized native frames during active loop execution. — skip: belongs in the Neper compiler, not the library

#1313Pratt Parser (Top-Down Operator Precedence)

Extensible parsing algorithm associating precedence levels and binding power with tokens. — see #340 (e.parse.pratt)

#1314Packrat Parsing (PEG)

Linear-time parsing algorithm executing Parsing Expression Grammars via memoization. — see #339 (e.parse.peg)

#1315LALR(1) Parser Construction

Merging LR(1) items with identical core items to build compact parsing tables for context-free grammars. — see #332 (e.parse.lr.lalr_table)

#1316Algorithm W (Hindley-Milner Type Inference)

Recursively unifying type equations to infer principal types without explicit type annotations. — skip: belongs in the Neper compiler, not the library

#1317Continuation-Passing Style (CPS) Transformation

Transforming functional code such that control is passed explicitly via continuation functions. — skip: belongs in the Neper compiler, not the library

#1318Defunctionalization

Replacing first-class functions or closures with data structures and dispatch functions. — skip: belongs in the Neper compiler, not the library

#1319Tail-Call Optimization (TCO)

Reusing current stack frames for tail-recursive calls to enable infinite recursion within O(1) space. — skip: belongs in the Neper compiler, not the library

#1320G1 GC Card Table Marking

Tracking cross-region object references using card tables and write barriers during concurrent garbage collection. — skip: Neper has ownership, not a garbage collector

#1321Shenandoah Brooks Pointers

Supporting concurrent compaction by routing object accesses through forwarding pointers updated during GC phases. — skip: Neper has ownership, not a garbage collector

#1322Immix Region-Based Garbage Collection

Managing memory using blocks and lines to balance contiguous allocation speed with low fragmentation. — skip: Neper has ownership, not a garbage collector

#1323ZGC Colored Pointers & Load Barriers

Encoding reference metadata directly inside 64-bit pointer bits to run concurrent marking and relocation phases. — skip: Neper has ownership, not a garbage collector

#1324AST Pattern Lowering

Transforming high-level Abstract Syntax Tree constructs into lower-level intermediate representations (IR). — skip: belongs in the Neper compiler, not the library

#1325Monadic Bind & Composable Effect System

Structuring side-effects sequentially using algebraic effect handlers or monadic compositions. — skip: a technique applied per problem, not a reusable function

#1326Software Transactional Memory (STM) TLog Validation

Executing memory updates inside thread-local logs and committing changes via atomic validation passes. — skip: implementable, but too specialised for the standard library

#1327Acquire-Release Memory Ordering

Enforcing hardware memory fence rules to guarantee cross-thread operation visibility without full barriers. — e.atomic.load

#1328AddressSanitizer (ASan) Shadow Memory Mapping

Intercepting memory allocations and mapping 8-byte application regions to 1-byte shadow memory flags to detect out-of-bound accesses. — skip: belongs in the toolchain (build, test runner, pacman)

#1329ThreadSanitizer (TSan) Shadow State Algorithm

Tracking memory access vector clocks per thread to detect data races. — skip: belongs in the toolchain (build, test runner, pacman)

#1330MemorySanitizer (MSan) Shadow Bits

Tracking initialization state for every memory bit to catch uninitialized memory reads. — skip: belongs in the toolchain (build, test runner, pacman)

#1331LLVM Intermediate Representation (IR) Pass Management

Scheduling transform, analysis, and optimization passes over SSA-based IR. — skip: belongs in the Neper compiler, not the library

#1332Superword-Level Parallelism (SLP) Vectorization

Combining independent scalar instructions within basic blocks into single-instruction multi-data (SIMD) operations. — skip: belongs in the Neper compiler, not the library

#1333Profile-Guided Optimization (PGO)

Utilizing execution profile feedback to optimize branch prediction layouts, function inlining, and code coldness. — skip: belongs in the Neper compiler, not the library

#1334Link-Time Optimization (LTO)

Merging compiler IR across compilation units at link time to execute global optimizations. — skip: belongs in the Neper compiler, not the library

#1335Foreign Function Interface (FFI) Trampolines

Generating dynamic assembly trampolines to translate calling conventions between programming languages. — skip: belongs in the Neper compiler, not the library

#1336Green Thread Fiber Scheduling

Cooperatively or preemptively scheduling lightweight user-space threads onto OS worker threads. — e.thread.fiber

#1337DWARF Stack Unwinding

Reading call frame information (.eh_frame) sections to unwind execution stack frames during exception handling. — e.debug.backtrace

#1338Structural Subtyping Type Checker

Validating type compatibility based on structural shape and signature parity rather than explicit inheritance declarations. — skip: belongs in the Neper compiler, not the library

#1339Software Fault Isolation (SFI)

Restricting untrusted modules by rewriting memory access instructions to keep reads/writes inside isolated memory ranges. — skip: implementable, but too specialised for the standard library

#1340WebAssembly Bytecode Validation Engine

Validating type-safety, stack balance, and structured control flow in Wasm modules prior to compilation. — skip: implementable, but too specialised for the standard library

#1341Direct Threaded Virtual Machine Interpreter

Accelerating bytecode execution by replacing switch-based dispatch loops with arrays of instruction handler addresses. — skip: a technique applied per problem, not a reusable function

#1342Copy-on-Write (CoW) Memory Page Mapping

Sharing physical memory pages between processes until write operations trigger page-fault duplication. — skip: OS kernel internals

#1343PLT/GOT Dynamic Linking Resolution

Deferring dynamic library symbol resolution until runtime using Procedure Linkage Tables and Global Offset Tables. — skip: belongs in the Neper compiler, not the library

#1344Automatic Reference Counting (ARC) Insertion

Inserting retain and release calls statically during compilation to manage object lifecycles. — skip: belongs in the Neper compiler, not the library

#1345Non-Blocking CAS Loop Construction

Constructing lock-free operations using Atomic Compare-And-Swap loops with exponential backoff handling. — skip: a technique applied per problem, not a reusable function

#1346Stack Canary Protection

Inserting guard values onto stack frames before return addresses to detect buffer overflow attacks. — skip: belongs in the Neper compiler, not the library

#1347Symbol Demangling Engine

Decoding compiler-mangled name strings back into human-readable class, method, and type signatures. — e.debug.demangle

#1348Control Flow Guard (CFG) Indirect Call Validation

Checking target addresses of indirect function calls against valid target bitmasks prior to execution. — skip: belongs in the Neper compiler, not the library

#1349Whole Program Reflection Metadata Generation

Emitting compile-time type descriptor tables to allow runtime inspection and dynamic invocation. — skip: belongs in the Neper compiler, not the library

#1350Escape Analysis Stack-to-Register Promotion

Promoting non-escaping scalar fields of allocated objects directly into virtual registers. — skip: belongs in the Neper compiler, not the library

23. Hardware, Computer Architecture & VLSI Algorithms (1351–1400)

#1351TAGE (TAgged GEometric) Branch Predictor

High-accuracy branch predictor tracking history across geometrically increasing history lengths using tagged tables. — skip: hardware or circuit design

#1352Two-Level Adaptive Branch Prediction

Predicting conditional branches using global shift registers and pattern history tables. — skip: hardware or circuit design

#1353Tournament Branch Predictor

Dynamic predictor selecting between local and global branch predictors using meta-predictor state machines. — skip: hardware or circuit design

#1354MESI Cache Coherence Protocol

Protocol managing multi-core L1/L2 cache line states (Modified, Exclusive, Shared, Invalid). — skip: hardware or circuit design

#1355MOESI Cache Coherence Protocol

Coherence protocol adding an "Owner" state to enable sharing dirty cache lines without writing back to main memory. — skip: hardware or circuit design

#1356Tomasulo's Algorithm

Out-of-order instruction execution pipeline dynamic scheduling scheme using reservation stations and register renaming. — skip: hardware or circuit design

#1357Reorder Buffer (ROB) In-Order Commit

Reordering speculatively executed out-of-order instructions to ensure in-order state updates and precise exceptions. — skip: hardware or circuit design

#1358Register Renaming Map Tables

Mapping architectural registers to physical register files to eliminate WAR and WAW hazards. — skip: hardware or circuit design

#1359Adaptive Replacement Cache (ARC)

Self-tuning cache replacement policy balancing Recency (LRU) and Frequency (LFU) sub-lists. — see #270 (e.data.cache.arc)

#1360Segmented LRU (SLRU) Cache Engine

Partitioning cache lines into probationary and protected segments to prevent cache pollution from single-use scans. — see #274 (e.data.cache.slru)

#1361Stride Hardware Prefetcher

Detecting constant memory access strides to speculatively load data blocks into L1/L2 caches. — skip: hardware or circuit design

#1362Stream Buffer Prefetching

Prefetching sequential memory blocks into dedicated FIFO buffers ahead of execution demands. — skip: hardware or circuit design

#1363Wallace Tree Multiplier

Hardware reduction tree structure reducing partial products using 3:2 full adders in O(log N) stages. — skip: hardware or circuit design

#1364Booth's Multiplication Algorithm

Recoding binary multipliers into signed digit representations to reduce partial product additions. — skip: an implementation detail of an existing module, not an API

#1365Systolic Array Acceleration Engine

Grid of tightly coupled processing elements streaming data through local registers to execute matrix multiplications (e.g., Google TPU). — skip: hardware or circuit design

#1366Wormhole Routing Network-on-Chip (NoC)

Splitting packet structures into tiny flow control units (flits) to route data through NoCs with minimal router buffer overhead. — skip: hardware or circuit design

#1367Virtual Channel NoC Allocation

Multiplexing physical NoC link bandwidth across multiple virtual flit queues to avoid head-of-line blocking. — skip: hardware or circuit design

#1368XY Dimension-Order Routing

Minimal non-adaptive routing algorithm directing packets along X coordinates before Y coordinates in 2D mesh topologies. — skip: hardware or circuit design

#1369Clock Tree Synthesis (CTS) H-Tree

Constructing symmetric clock distribution networks to minimize clock skew across physical silicon dies. — skip: hardware or circuit design

#1370Static Timing Analysis (STA)

Computing maximum signal propagation delays across combinational logic paths to verify setup and hold time constraints. — skip: hardware or circuit design

#1371Quine-McCluskey Boolean Minimization

Exact method for minimizing boolean functions by grouping prime implicants. — e.algo.logic.quine_mccluskey

#1372Espresso Heuristic Logic Minimizer

Fast heuristic algorithm reducing boolean function expressions for programmable logic arrays (PLAs). — skip: implementable, but too specialised for the standard library

#1373Floorplanning via Simulated Annealing

Optimizing module placement, die area, and wire interconnect length using stochastic thermal cooling models. — skip: hardware or circuit design

#1374Scan Chain Insertion (DFT)

Connecting internal flip-flops into shift registers during Design-for-Testability modes to enable post-fabrication fault testing. — skip: hardware or circuit design

#1375Built-In Self-Test (BIST) LFSR Engine

Utilizing Linear Feedback Shift Registers to generate pseudo-random test patterns on-chip. — e.algo.rand.lfsr

#1376Content-Addressable Memory (CAM) Search Circuitry

Parallel hardware architecture comparing input data terms against stored bit arrays in O(1) clock cycles. — skip: hardware or circuit design

#1377TLB Shootdown IPI Handler

Inter-Processor Interrupt mechanism forcing core CPUs to invalidate stale translation lookaside buffer entries. — skip: OS kernel internals

#1378Rank-Level Memory Controller Scheduling

Scheduling DDR DRAM read/write commands to maximize bank-level parallelism and minimize bus turnaround penalties. — skip: hardware or circuit design

#1379Target Row Refresh (TRR)

Memory controller mechanism tracking activation counts to mitigate Rowhammer electromagnetic leakage faults in DRAM. — skip: hardware or circuit design

#1380High Bandwidth Memory (HBM) Silicon Interposer

Stacking DRAM dies vertically over logic dies using Through-Silicon Vias (TSVs) to maximize bus width. — skip: hardware or circuit design

#1381NUMA First-Touch Allocation Policy

Allocating physical memory pages on the local NUMA node associated with the thread initiating the allocation. — skip: OS kernel internals

#1382Branch Target Buffer (BTB)

High-speed hardware cache storing destination addresses of direct/indirect branch instructions. — skip: hardware or circuit design

#1383Hardware Transactional Memory (HTM) Conflict Detection

Tracking read-sets and write-sets via L1 cache line tags to detect transactional memory collisions. — skip: hardware or circuit design

#1384Vector Register Lane Masking

Executing conditional vector operations by applying predicate register bitmasks across execution lanes. — e.simd.select

#1385Floating-Point Alignment Shifter

Aligning significand fractions during floating-point addition/subtraction operations by shifting smaller exponents. — skip: hardware or circuit design

#1386Asynchronous FIFO Gray Code Synchronization

Dual-clock domain FIFO synchronization passing read/write pointers across clock boundaries using Gray codes. — see #829 (e.bytes.gray_encode)

#1387Dynamic Voltage and Frequency Scaling (DVFS)

Adjusting processor operating clock frequencies and supply voltages dynamically based on workload profiles. — skip: hardware or circuit design

#1388Retiming Logic Optimization

Relocating flip-flops across combinational logic blocks to minimize critical path delays without changing circuit functionality. — skip: hardware or circuit design

#1389High-Level Synthesis (HLS) C-to-RTL Scheduling

Transforming high-level algorithmic C/C++ representations into cycle-accurate Verilog/VHDL RTL hardware implementations. — skip: hardware or circuit design

#1390Reduced Ordered Binary Decision Diagrams (ROBDD)

Canonical graph representation of boolean functions supporting canonical equality checks. — e.algo.bdd.build

#1391SAT-Based Formal Equivalence Checking

Proving equivalence between gate-level netlists and high-level RTL specifications using Boolean SAT solvers. — e.algo.sat.equivalent

#1392IEEE 1149.1 JTAG Boundary Scan

Standardized shift-register architecture inspecting chip pin states and executing device testing. — skip: hardware or circuit design

#1393DMA Scatter-Gather Controller Engine

Processing memory descriptor chains to execute non-contiguous memory transfers without host CPU interventions. — skip: hardware or circuit design

#1394Write-Combining Buffer Execution

Coalescing sequential memory writes into temporary store buffers to issue single burst memory bus requests. — skip: hardware or circuit design

#1395Store Buffer & Invalidation Queue Memory Pipeline

Decoupling CPU core writes from cache interconnect delays using speculation queues and memory barriers. — skip: hardware or circuit design

#1396Hardware-Assisted Virtualization (Nested Page Tables / EPT)

Hardware MMU translation mapping guest virtual addresses through guest physical addresses directly to host physical addresses. — skip: hardware or circuit design

#1397Advanced Programmable Interrupt Controller (APIC) Routing

Priority-based routing engine directing hardware and software interrupts to specific CPU cores. — skip: hardware or circuit design

#1398Round-Robin Bus Arbitration Logic

Fair arbitration logic allocating shared hardware bus access sequentially among competing masters. — skip: hardware or circuit design

#1399Delay-Locked Loop (DLL) Clock Alignment

Aligning clock signal phases across high-speed DDR memory interfaces using controllable delay lines. — skip: hardware or circuit design

#1400SECDED Error-Correcting Code Logic

Single Error Correction, Double Error Detection Hamming code logic protecting SRAM/DRAM lines against soft errors. — see #860 (e.algo.ecc.hamming_decode)

24. Cybersecurity, Network Defense & Cryptographic Protocols (1401–1450)

#1401TLS 1.3 1-RTT & 0-RTT Handshake Protocols

Establishing encrypted session keys using Diffie-Hellman key exchanges while eliminating legacy round-trips. — e.net.tls.handshake

#1402IPsec ESP (Encapsulating Security Payload)

Encrypting and authenticating IP packet payloads in Tunnel or Transport modes. — skip: OS kernel internals

#1403Kerberos V5 Authentication

Ticket-granting authentication system using symmetric key cryptography and trusted KDCs. — e.net.auth.client

#1404OAuth 2.0 PKCE (Proof Key for Code Exchange)

Authorization code protocol utilizing dynamic code verifiers and code challenges to prevent authorization code interception. — e.net.http.auth.pkce

#1405OpenID Connect (OIDC) ID Token Validation

Validating JWT identity tokens by verifying cryptographically signed JSON Web Keys (JWKS). — e.fmt.jwt.verify

#1406Aho-Corasick Multi-Pattern Inspection Engine

Constructing finite-state pattern matching automata to inspect network payloads against signature dictionaries in single passes. — see #295 (e.text.search.aho_corasick)

#1407WAF ModSecurity Rules Engine

Evaluating incoming HTTP requests against regular expression rule sets to filter out XSS and SQL Injection payloads. — skip: a vendor product's architecture

#1408DNSSEC Chain of Trust Validation

Authenticating DNS record responses by recursively validating RRSIG , DNSKEY , and DS record signatures back to the root zone key. — e.net.dns.dnssec_validate

#1409RPKI Route Origin Validation (ROV)

Validating BGP route announcements against cryptographically signed Route Origin Authorizations (ROAs). — skip: network protocol beyond the library scope

#1410TCP SYN Cookie Generation

Mitigating SYN flood attacks by encoding connection parameters into TCP initial sequence numbers (ISN) without allocating connection state. — skip: OS kernel internals

#1411BGP Anycast Traffic Scrubbing

Announcing identical IP prefixes via Anycast to distribute volumetric DDoS traffic to scrubbing centers. — skip: a whole service or system, not a function

#1412Time-Based Blind SQL Injection Exfiltration

Extracting schema data character by character using conditional database delay commands ( SLEEP() , pg_sleep() ). — skip: attack technique

#1413Address Space Layout Randomization (ASLR)

Randomizing address space positions of program stacks, heaps, and libraries in memory to block exploitation. — skip: OS kernel internals

#1414Data Execution Prevention (DEP / NX Bit)

Marking stack and memory pages as non-executable to prevent execution of injected shellcode. — skip: OS kernel internals

#1415Stack Canary Protection Verification

Checking stack frame integrity using randomized canary values prior to function return instructions. — skip: belongs in the Neper compiler, not the library

#1416Control Flow Integrity (CFI)

Restricting runtime execution transfers to valid target call graphs to eliminate Return-Oriented Programming (ROP) exploits. — skip: belongs in the Neper compiler, not the library

#1417CKKS Fully Homomorphic Encryption

Homomorphic encryption scheme supporting fixed-point arithmetic vector operations over encrypted data. — skip: research-grade, no settled practical implementation

#1418BFV / BGV Fully Homomorphic Encryption

Homomorphic encryption schemes supporting exact integer polynomial ring arithmetic operations over encrypted data. — skip: research-grade, no settled practical implementation

#1419Differential Privacy Laplace Mechanism

Preserving privacy in statistical data queries by adding noise drawn from Laplace distributions proportional to query sensitivity (Δf/ϵ). — e.algo.privacy.laplace

#1420Differential Privacy Gaussian Mechanism

Adding Gaussian-distributed noise to numeric query outputs to satisfy (ϵ,δ)-differential privacy bounds. — e.algo.privacy.gaussian

#1421Differential Privacy Exponential Mechanism

Selecting non-numeric query outputs from candidate sets while preserving differential privacy. — e.algo.privacy.exponential

#1422Yao's Garbled Circuits

Two-party secure computation protocol evaluating boolean circuit functions over private inputs without revealing raw data. — skip: research-grade, no settled practical implementation

#1423Goldreich-Micali-Wigderson (GMW) MPC Protocol

Multi-party computation framework evaluating circuits using secret-shared input values and Oblivious Transfer. — skip: research-grade, no settled practical implementation

#1424PLONK Zero-Knowledge Proof System

Universal zero-knowledge proof scheme using polynomial commitments (KZG) over custom constraint systems. — skip: research-grade, no settled practical implementation

#1425Nova Recursive ZK-Proof Folding

Folding two instances of relaxed Rank-1 Constraint Systems (R1CS) recursively to generate incremental zero-knowledge proofs. — skip: research-grade, no settled practical implementation

#1426Ransomware I/O Entropy Analysis Heuristic

Detecting active file encryption attacks by monitoring file write operations for sudden entropy shifts toward 8.0 bits per byte. — e.algo.stat.entropy

#1427Dynamic Sandbox Hooking & Anti-Evasion

Intercepting OS API calls inside isolated virtual machines while obfuscating sandbox artifacts (hypervisor flags, timing delays). — skip: a whole service or system, not a function

#1428Software Bill of Materials (SBOM) Dependency Resolution

Constructing dependency graphs to trace vulnerability propagation across software supply chains. — pacman.resolve

#1429WebAuthn / FIDO2 Passkey Signature Verification

Authenticating users via asymmetric public-key cryptography stored on hardware authenticators or Secure Enclaves. — e.net.http.auth.webauthn_verify

#1430HMAC-SHA256 Token Authentication

Verifying message integrity and authenticity using shared secret keys combined with iterated cryptographic hashing. — see #572 (e.crypto.mac.hmac_sha256)

#1431Certificate Transparency (CT) Merkle Audit

Verifying TLS certificate issuance by querying append-only, publicly verifiable Merkle tree logs. — e.crypto.x509.ct_verify

#1432Content Security Policy (CSP) Nonce Validation

Blocking cross-site scripting by requiring script tags to include matching single-use cryptographic nonces. — e.net.http.csp_nonce

#1433SameSite Cookie Enforcement Engine

Enforcing browser cookie policies ( Strict , Lax , None ) to prevent Cross-Site Request Forgery (CSRF) vulnerabilities. — e.net.http.cookie_same_site

#1434CORS Preflight Evaluation

Handling browser OPTIONS requests to validate cross-origin resource access rights prior to processing state-changing calls. — e.net.http.cors_preflight

#1435XML External Entity (XXE) Safe Parsing

Disabling inline DTD loading and external entity expansion within XML parsers. — e.fmt.xml.parse

#1436SSRF IP Whitelist / Blacklist Validation

Validating URLs to block internal IP ranges ( 10.0.0.0/8, 127.0.0.1, link-local 169.254.169.254) prior to initiating HTTP requests. — e.net.is_private

#1437Format String Vulnerability Exploitation Mitigation

Enforcing compile-time checks requiring static literal strings as format arguments in print functions. — skip: belongs in the Neper compiler, not the library

#1438Return-Oriented Programming (ROP) Gadget Chain Construction

Chaining short assembly sequences ending in ret instructions to bypass executable space protections. — skip: attack technique

#1439Jump-Oriented Programming (JOP) Mitigation

Restricting indirect jump table branches using branch target instructions (e.g., ARM BTI, Intel CET). — skip: belongs in the Neper compiler, not the library

#1440ML-KEM (Kyber) Post-Quantum Key Encapsulation

Standardized lattice-based key encapsulation mechanism built on Module Learning-With-Errors (M-LWE). — see #592 (e.crypto.kx.ml_kem)

#1441ML-DSA (Dilithium) Post-Quantum Signature

Standardized lattice-based digital signature scheme relying on Module Learning-With-Errors hardness. — see #593 (e.crypto.sign.ml_dsa)

#1442Stateful Hash-Based Signatures (LMS / XMSS)

Quantum-resistant digital signatures utilizing Merkle trees built over One-Time Signature schemes (WOTS+). — e.crypto.sign.xmss

#1443STRIDE Threat Modeling Surface Analysis

Evaluating system security boundaries against Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege. — skip: a technique applied per problem, not a reusable function

#1444Coverage-Guided Fuzzing (AFL / libFuzzer)

Mutating program inputs guided by code coverage edge feedback to discover crash-inducing states. — e.test.fuzz.run

#1445Symbolic Execution Pathfinder (KLEE)

Executing programs with symbolic inputs to generate path constraints and auto-solve input payloads for uncovered code paths. — skip: belongs in the toolchain (build, test runner, pacman)

#1446Taint Analysis Data Flow Tracking

Marking user input as "tainted" and tracking its propagation through instructions to sink functions to identify security flaws. — skip: belongs in the toolchain (build, test runner, pacman)

#1447TPM PCR Quote Remote Attestation

Validating platform boot integrity by verifying signed Platform Configuration Register quotes generated by Trusted Platform Modules. — skip: a whole service or system, not a function

#1448Confidential Computing Enclave Attestation

Validating hardware-isolated enclave measurements (Intel SGX, AMD SEV) via signed hardware manufacturer certificates. — skip: a whole service or system, not a function

#1449SIEM Log Correlation Rule Engine

Normalizing event logs from heterogeneous hosts to identify attack patterns across sliding time windows. — skip: a vendor product's architecture

#1450Network Intrusion Detection Flow Reassembly

Reassembling fragmented IP packets and out-of-order TCP streams to reconstruct full protocol payloads for deep packet inspection. — skip: implementable, but too specialised for the standard library

25. Financial Engineering, Quantitative Finance & Algorithmic Trading (1451–1500)

#1451Black-Scholes-Merton PDE Solver

Computing European option prices by solving parabolic partial differential equations via finite difference methods. — skip: quantitative-finance domain

#1452Cox-Ross-Rubinstein Binomial Option Pricing

Pricing options over discrete binomial trees tracking underlying asset upward and downward movement probabilities. — skip: quantitative-finance domain

#1453Monte Carlo Pricing with Antithetic Variates

Reducing Monte Carlo sample variance by pairing generated random path samples (Z) with complementary inverted paths (−Z). — e.math.mc.antithetic

#1454Monte Carlo Pricing with Control Variates

Accelerating option simulation convergence by adjusting generated estimates using known analytical expected values of correlated assets. — e.math.mc.control_variate

#1455Heston Stochastic Volatility Model Calibration

Calibrating European option surfaces using stochastic volatility dynamics modeled via Square-Root Feller processes. — skip: quantitative-finance domain

#1456SABR Model Calibration

Fitting implied volatility smiles using Stochastic Alpha, Beta, Rho model parameterization. — skip: quantitative-finance domain

#1457Historical Value at Risk (VaR)

Calculating maximum portfolio losses at specific confidence levels (95%,99%) by ranking historical returns directly. — e.algo.stat.quantile

#1458Parametric Value at Risk (VaR)

Computing portfolio loss distribution bounds using portfolio return means, standard deviations, and covariance matrices. — skip: quantitative-finance domain

#1459Monte Carlo Value at Risk (VaR)

Simulating thousands of forward market paths to estimate non-linear portfolio loss distributions. — skip: quantitative-finance domain

#1460Conditional Value at Risk (CVaR / Expected Shortfall)

Measuring expected tail losses exceeding specified Value at Risk thresholds. — e.algo.stat.expected_shortfall

#1461Markowitz Mean-Variance Optimization

Constructing efficient investment portfolios that maximize expected return for given levels of target portfolio variance. — e.math.opt.convex.quadratic_program

#1462Black-Litterman Portfolio Model

Blending market equilibrium returns with subjective investor views using Bayesian updating to produce stable portfolio weights. — skip: quantitative-finance domain

#1463Limit Order Book (LOB) Matching Engine

Executing financial trades by maintaining price-time priority arrays across bid and ask queues. — skip: quantitative-finance domain

#1464Order Flow Imbalance (OFI) Signal Computation

Measuring net order flow changes across top-of-book quotes to forecast short-term price movements. — skip: quantitative-finance domain

#1465Volume-Weighted Average Price (VWAP) Execution

Slicing large parent orders into historical volume distribution buckets to minimize execution market impact. — skip: quantitative-finance domain

#1466Time-Weighted Average Price (TWAP) Execution

Splitting orders evenly across fixed time intervals to achieve benchmark average price executions. — skip: quantitative-finance domain

#1467Almgren-Chriss Optimal Execution Framework

Formulating optimal order liquidation trajectories balancing market impact costs against inventory risk volatility. — skip: quantitative-finance domain

#1468Engle-Granger Two-Step Cointegration Test

Detecting stationary mean-reverting linear combinations between non-stationary asset price series for pairs trading. — skip: quantitative-finance domain

#1469Johansen Cointegration Test Engine

Testing for multiple cointegrating vectors across multivariate time series using vector autoregressive models. — skip: quantitative-finance domain

#1470Kalman Filter Dynamic Hedge Ratio Estimation

Tracking time-varying hedge ratios (β) dynamically between cointegrated pairs trading assets. — see #518 (e.math.filter.ekf)

#1471Zero-Coupon Yield Curve Bootstrapping

Extracting zero-coupon discount factors sequentially from observed market cash rates, futures, and interest rate swaps. — skip: quantitative-finance domain

#1472Overnight Index Swap (OIS) Discounting Engine

Discounting derivative cash flows using risk-free OIS rates (SOFR, ESTR) to construct multi-curve frameworks. — skip: quantitative-finance domain

#1473Merton Structural Credit Risk Model

Modeling company default probabilities by evaluating firm asset value processes as European call options over liabilities. — skip: quantitative-finance domain

#1474CreditMetrics Portfolio Simulation

Simulating credit migration and default correlation across debt portfolios to calculate Value at Risk. — skip: quantitative-finance domain

#1475Vasicek Short-Rate Interest Rate Model

Modeling interest rate evolution using mean-reverting stochastic differential equations. — skip: quantitative-finance domain

#1476Cox-Ingersoll-Ross (CIR) Interest Rate Model

Modeling short-term interest rates using square-root diffusion processes to ensure non-negative rates. — skip: quantitative-finance domain

#1477Heath-Jarrow-Morton (HJM) Framework

Modeling the entire forward rate curve dynamically driven by multi-factor volatility structures. — skip: quantitative-finance domain

#1478Hull-White One-Factor Model

Extending the Vasicek model with time-varying parameters to fit current term structures of interest rates exactly. — skip: quantitative-finance domain

#1479Longstaff-Schwartz American Option Pricing

Pricing American-style options in Monte Carlo simulations using least-squares regressions to estimate early exercise values. — skip: quantitative-finance domain

#1480Stochastic Volatility Inspired (SVI) Parametrization

Fitting arbitrage-free implied volatility smiles across option expiry slices using smooth curves. — skip: quantitative-finance domain

#1481Dupire's Local Volatility Model

Extracting unique local volatility surface functions directly from continuous European option market prices. — skip: quantitative-finance domain

#1482Delta-Gamma Financial Hedging Engine

Rebalancing options portfolios by offsetting first-order (Δ) and second-order (Γ) price sensitivities relative to underlying movement. — skip: quantitative-finance domain

#1483Square Root Law of Market Impact

Modeling price impact (ΔP) of large institutional orders as proportional to volatility and the square root of relative size (V / V_daily). — skip: quantitative-finance domain

#1484Avellaneda-Stoikov Market Making Model

Computing optimal bid-ask spread quotes and reservation prices for market makers managing inventory risk. — skip: quantitative-finance domain

#1485High-Frequency LOB Feature Extraction

Calculating real-time features (micro-price, order book slope, queue depth ratios) to drive high-frequency trading alphas. — skip: quantitative-finance domain

#1486Smart Order Router (SOR) Execution Engine

Routing liquidity sweeps across multiple competing exchanges to fill orders at optimal prices. — skip: quantitative-finance domain

#1487Optimal Stopping Boundary Computation

Calculating exercise boundaries for early-exercise financial derivatives using free-boundary PDE solvers. — skip: quantitative-finance domain

#1488PCA Yield Curve Factor Decomposition

Decomposing yield curve shifts into dominant orthogonal factors: Level, Slope, and Curvature. — see #732 (e.ml.reduce.pca)

#1489Copula Dependency Modeling (Gaussian / t-Copula)

Joining marginal asset return distributions to model non-linear joint tail dependencies in credit derivatives. — e.algo.rand.dist.copula_gaussian

#1490Credit Default Swap (CDS) Hazard Rate Bootstrapping

Extracting term structures of default probabilities from market CDS credit spreads. — skip: quantitative-finance domain

#1491Collateralized Loan Obligation (CLO) Cash Flow Waterfall

Simulating interest and principal payment distribution rules across structured tranche priorities (Equity, Mezzanine, Senior AAA). — skip: quantitative-finance domain

#1492Constant Proportion Portfolio Insurance (CPPI)

Dynamically rebalancing portfolio exposure between risky assets and safe assets based on cushions over guaranteed floors. — skip: quantitative-finance domain

#1493Risk Parity Portfolio Allocation

Weighting portfolio assets such that each asset class contributes equally to total portfolio risk variance. — skip: quantitative-finance domain

#1494Kelly Criterion Optimal Position Sizing

Calculating optimal capital allocation fractions (f∗ = pb−q) to maximize long-term logarithmic growth of wealth. b — skip: quantitative-finance domain

#1495Sharpe, Sortino, and Information Ratio Calculation

Evaluating risk-adjusted investment returns relative to total volatility, downside deviation, and benchmark tracking error. — skip: quantitative-finance domain

#1496Deflated Sharpe Ratio (DSR)

Adjusting observed Sharpe ratios to account for selection bias, non-normality, and multiple backtest trial evaluations. — skip: quantitative-finance domain

#1497Markov-Switching Autoregressive Model

Detecting changing market regimes (high volatility vs low volatility) by modeling transition probabilities between unobserved states. — skip: quantitative-finance domain

#1498GARCH(1,1) Volatility Forecasting

Modeling time-varying financial volatility clustering based on past squared residuals and previous variance estimates. — e.algo.timeseries.garch

#1499Alpha Signal Decay Modeling

Tracking predictive decay rates of quantitative signals over time to determine optimal rebalancing frequencies. — skip: quantitative-finance domain

#1500Hawkes Self-Exciting Point Process

Modeling high-frequency trade arrival clusters and order book flash crashes via self-exciting point processes.  Yes do it — e.algo.timeseries.hawkes

26. Machine Learning Systems, LLM Infrastructure & AI Engineering (1501–1550)

#1501FlashAttention-2 Kernel Optimization

IO-aware exact attention algorithm minimizing GPU HBM reads/writes via tiling and online softmax scaling. — see #754 (e.gpu.attention_flash)

#1502Quantized Low-Rank Adaptation (QLoRA)

Parameter-efficient fine-tuning method utilizing 4-bit NormalFloat (NF4) quantization and double quantization. — skip: a trained ML model or training recipe

#1503Grouped-Query Attention (GQA)

Attention mechanism partitioning key-value heads into groups to balance inference memory bandwidth and model capacity. — skip: a trained ML model or training recipe

#1504PagedAttention Virtual Memory Management

Attention algorithm managing KV-cache memory using dynamic page allocation to eliminate internal fragmentation (vLLM). — skip: a whole service or system, not a function

#1505Tensor Parallelism (Megatron-LM)

Intra-layer model parallelism splitting weight matrices across matrix multiplication operations in multi-GPU nodes. — skip: a whole service or system, not a function

#1506Pipeline Parallelism (GPipe / 1F1B Schedule)

Inter-layer parallelism partitioning model layers sequentially across nodes using One-Forward-One-Backward scheduling. — skip: a whole service or system, not a function

#1507DeepSpeed ZeRO Memory Optimization

Memory redundancy elimination partitioning optimizer states (ZeRO-1), gradients (ZeRO-2), and parameters (ZeRO-3) across data-parallel ranks. — skip: a whole service or system, not a function

#1508Speculative Decoding with Draft Models

Accelerating inference latency by using lightweight draft models to generate candidate tokens verified in parallel by target models. — skip: a trained ML model or training recipe

#1509Rotary Position Embedding (RoPE)

Incorporating explicit relative positional information into self-attention by applying rotation matrices to query/key vectors. — see #753 (e.ml.nn.rope)

#1510Continuous Batching Engine

Dynamic iteration-level scheduling algorithm batching incoming text generation requests at every forward step. — skip: a whole service or system, not a function

#1511Direct Preference Optimization (DPO)

Parameter alignment method optimizing language model preferences analytically without training explicit reward models or using PPO. — skip: a trained ML model or training recipe

#1512Mixture of Experts (MoE) Top-k Gating

Dynamic routing mechanism directing input tokens to sub-networks (experts) using auxiliary load-balancing losses. — skip: a trained ML model or training recipe

#1513Activation Checkpointing

Memory-saving technique recomputing intermediate activations during backward passes instead of caching them in GPU memory. — skip: a trained ML model or training recipe

#1514Activation-aware Weight Quantization (AWQ)

Quantizing LLM weights to 3-bit/4-bit precisions by protecting top 1% salient activation channels. — skip: a trained ML model or training recipe

#1515Hierarchical Navigable Small World (HNSW)

Multi-layer graph algorithm executing approximate nearest neighbor (ANN) vector search in O(log N) time. — see #1226 (e.ml.ann.hnsw)

#1516Inverted File Index with Product Quantization (IVF-PQ)

Vector indexing scheme combining Voronoi space partitioning with compressed vector quantization. — see #1227 (e.ml.ann.ivf_pq)

#1517Retrieval-Augmented Generation (RAG) Reciprocal Rank Fusion

Combining document retrieval scores across disparate vector and keyword search pipelines. — see #1224 (e.text.rank.reciprocal_rank_fusion)

#1518OpenAI Triton GPU Compiler

Domain-specific C-based programming language and compiler compiling high-level Python code into optimized NVIDIA PTX code. — skip: a vendor product's architecture

#1519Unified Heterogeneous GPU Memory Management

Mapping host RAM and GPU VRAM into unified virtual address spaces to handle dynamic model offloading. — skip: a whole service or system, not a function

#1520Distributed Data Parallel (DDP) AllReduce Overlap

Overlapping backward pass gradient computations with asynchronous ring-AllReduce network communications. — skip: a whole service or system, not a function

#1521Knowledge Distillation KL-Divergence Matching

Training compact student networks by minimizing Kullback-Leibler divergence relative to teacher probability distributions. — e.ml.loss.kl_divergence

#1522ZeRO-Infinity NVMe Memory Offloading

Leveraging NVMe memory architectures to offload massive model states beyond standard system RAM bounds. — skip: a whole service or system, not a function

#1523Lottery Ticket Hypothesis Pruning

Identifying sparse, trainable sub-networks within dense initializations that achieve baseline accuracy. — skip: a trained ML model or training recipe

#1524Direct Feedback Alignment (DFA)

Biologically plausible backpropagation alternative transmitting error signals directly from output layers to hidden layers using fixed random matrices. — skip: research-grade, no settled practical implementation

#1525CLIP Multimodal Embedding Alignment

Jointly training text and image encoders using contrastive loss functions over cross-modal pairs. — skip: a trained ML model or training recipe

#1526Denoising Diffusion Implicit Models (DDIM)

Accelerating diffusion model sampling by formulating generation as deterministic non-Markovian forward processes. — skip: a trained ML model or training recipe

#1527Low-Rank Adaptation (LoRA)

Parameter-efficient fine-tuning injecting trainable rank decomposition matrices (A × B) into frozen linear weights. — skip: a trained ML model or training recipe

#1528Byte-Pair Encoding (BPE) Tokenization

Iteratively merging common adjacent byte pairs to build subword vocabulary dictionaries. — see #373 (e.text.tokenize.bpe)

#1529Automatic Mixed Precision (AMP) Dynamic Scaling

Running model computations in FP16/BF16 while dynamically scaling loss to prevent floating-point underflow. — skip: a trained ML model or training recipe

#1530AI Agent ReAct Loop Execution

Iterative prompt control architecture interleaving reasoning steps ("Thought") with environmental execution tools ("Action"). — skip: a whole service or system, not a function

#1531Graph Neural Network (GNN) Neighbor Sampling

Scalable training scheme approximating full graph aggregations by sampling localized node neighborhoods. — skip: a trained ML model or training recipe

#1532Differentiable Architecture Search (DARTS)

Relaxing discrete neural architecture search spaces into continuous differentiable optimization problems. — skip: research-grade, no settled practical implementation

#1533Feature Store Low-Latency Serving (Feast/Tecton)

Maintaining synchronized offline batch data and online low-latency KV stores for real-time model inference features. — skip: a vendor product's architecture

#1534Concept Drift Detection (KS-Test / PSI)

Monitoring statistical distribution shifts in inference inputs using Kolmogorov-Smirnov tests and Population Stability Indexes. — e.algo.stat.test.ks

#1535ML Metadata Lineage Tracking Graphs

Tracking operational provenance across datasets, pipelines, hyperparameters, and model artifacts as directed acyclic graphs. — skip: a vendor product's architecture

#1536Attention Softmax Scaling Factor ( 1 )

Scaling dot-product attention queries and d k keys to prevent softmax gradients from vanishing at large dimensionality. — see #751 (e.ml.nn.attention)

#1537Structured Guardrails & Grammar Enforcers

Steering LLM output generation at the token sampling level using Pushdown Automata and Context-Free Grammars. — e.parse.constrained_decode

#1538Hogwild! Lock-Free Asynchronous SGD

Parallel stochastic gradient descent allowing worker threads to read and update shared parameters without synchronization locks. — skip: implementable, but too specialised for the standard library

#1539L-BFGS Optimization for Deep Learning

Quasi-Newton optimization algorithm approximating Hessian matrix inversions using limited past gradient vectors. — see #778 (e.math.opt.lbfgs)

#1540Sharpness-Aware Minimization (SAM)

Optimization algorithm seeking model parameters in flat loss terrain neighborhoods to improve model generalization. — skip: a trained ML model or training recipe

#1541AdamW Decoupled Weight Decay

Correcting standard L2 regularization implementation in Adam by decoupling weight decay from adaptive gradient updates. — see #750 (e.ml.optim.adamw)

#1542Cosine Annealing Learning Rate Schedule

Decay schedule decreasing learning rates following cosine curves with periodic warm restarts. — e.ml.optim.cosine_schedule

#1543MinHash LSH Data Deduplication

Locality-Sensitive Hashing filtering redundant text records across massive pre-training corpora using Jaccard similarity bounds. — see #1096 (e.ml.ann.minhash_lsh)

#1544Reinforcement Learning from Human Feedback (RLHF)

Aligning model output distributions using Proximal Policy Optimization (PPO) against learned reward models. — skip: a trained ML model or training recipe

#1545Tree-of-Thoughts (ToT) Search Decoding

Framework generalizing language model decoding over explicit tree structures using Breadth-First or Depth-First tree searches. — skip: a trained ML model or training recipe

#1546Multimodal Cross-Attention Projection

Aligning dense vector representations across visual encoders and text decoders via cross-attention layers. — skip: a trained ML model or training recipe

#1547On-Device NPU Weight INT4 Quantization

Optimizing language models for mobile Neural Processing Units using uniform post-training vector quantization. — skip: a trained ML model or training recipe

#1548Selective Concept Erasure (Machine Unlearning)

Removing specific learned facts or protected data from trained neural network parameters without full retraining. — skip: research-grade, no settled practical implementation

#1549Federated Learning Differential Privacy (FedAvg)

Aggregating distributed edge-device weight updates locally before adding Gaussian noise to guarantee client privacy bounds. — skip: a trained ML model or training recipe

#1550Contrastive Decoding

Enhancing text generation quality by evaluating log-likelihood differences between large target models and small amateur models. — e.ml.sample.contrastive

27. Networks, Telecommunications & Distributed Protocols (1551–1600)

#1551BGP Path Vector Routing Protocol

Inter-domain routing protocol exchanging AS-PATH attributes to compute policy-driven loop-free network paths. — skip: network protocol beyond the library scope

#1552Multipath TCP (MPTCP)

Transport protocol enabling single socket connections to stream data across multiple network interfaces simultaneously. — skip: OS kernel internals

#1553QUIC Protocol Connection Migration

UDP-based transport protocol maintaining active connections across client IP shifts using unique 64-bit Connection IDs. — e.net.quic.migrate

#1554HTTP/3 Binary Frame Multiplexing

Layering application communications over independent QUIC streams to eliminate TCP head-of-line blocking. — e.net.http3.frames

#1555Segment Routing over IPv6 (SRv6)

Source-routing architecture encoding packet forwarding paths directly into ordered IPv6 extension header segment lists. — skip: network protocol beyond the library scope

#1556MPLS Label Distribution Protocol (LDP)

Distributing label-to-prefix mappings across router nodes to build Label Switched Paths (LSPs). — skip: network protocol beyond the library scope

#1557Software-Defined Networking (SDN) OpenFlow Pipeline

Decoupling network control planes from data planes using centralized controllers to inject flow tables into switches. — skip: network protocol beyond the library scope

#1558Network Function Virtualization (NFV) Service Chaining

Directing traffic steering dynamically through sequential virtual network functions (firewalls, NATs, load balancers). — skip: a whole service or system, not a function

#1559Virtual Extensible LAN (VXLAN)

Layer 2 overlay scheme encapsulating Ethernet frames inside UDP packets using 24-bit Network Identifiers (VNIs). — skip: network protocol beyond the library scope

#1560Ethernet EVPN Control Plane

Utilizing MP-BGP to distribute Layer 2 MAC and Layer 3 IP reachability information across network fabrics. — skip: network protocol beyond the library scope

#1561ICE/STUN/TURN NAT Traversal

Framework discovering peer-to-peer communication paths across restrictive network NAT boundaries. — e.net.stun.gather_candidates

#1562Bidirectional Forwarding Detection (BFD)

Lightweight protocol detecting link interface failures across intermediate physical hops within sub-second thresholds. — skip: network protocol beyond the library scope

#1563TCP BBR Congestion Control Algorithm

Model-based congestion control dynamically measuring Bottleneck Bandwidth and Round-Trip Time (RTT) to maximize throughput without bufferbloat. — skip: OS kernel internals

#1564Explicit Congestion Notification (ECN)

Router mechanism marking IP headers (CE bits) during congestion to trigger client rate reductions without dropping packets. — skip: OS kernel internals

#1565Wi-Fi 7 Multi-Link Operation (MLO)

Wireless communication standard aggregating 2.4 GHz, 5 GHz, and 6 GHz radio bands across single device connections simultaneously. — skip: hardware or circuit design

#15665G Massive MIMO Beamforming

Concentrating spatial antenna radio signals dynamically toward targeted mobile user devices using active phased arrays. — skip: hardware or circuit design

#15675G Network Slicing & User Plane Function (UPF)

Partitioning single physical 5G infrastructure into isolated virtual end-to-end networks optimized for distinct SLAs. — skip: network protocol beyond the library scope

#1568LEO Satellite Inter-Satellite Laser Links (ISLL)

Routing internet traffic across low-Earth-orbit satellite constellations via optical laser transceivers in space. — skip: hardware or circuit design

#1569DNSSEC Trust Chain Validation

Cryptographically verifying DNS records by building chains of trust from target RRSIG records up to root domain keys. — see #1408 (e.net.dns.dnssec_validate)

#1570Constrained Application Protocol (CoAP)

Specialized binary web transfer protocol executing HTTP-like operations over UDP for resource-constrained IoT devices. — e.net.coap.request

#1571MQTT Quality of Service (QoS 0, 1, 2) Protocols

IoT messaging guarantees spanning At-Most-Once, At-Least-Once, and Exactly-Once delivery handshakes. — e.net.mqtt.publish

#1572LoRaWAN Adaptive Data Rate (ADR)

Dynamic optimization scheme tuning data rates, airtime, and transmission power for long-range, low-power IoT devices. — skip: hardware or circuit design

#1573RIP Split Horizon with Poison Reverse

Preventing routing loops by advertising unreachable metrics (16 hops) back on interfaces where routes were learned. — skip: network protocol beyond the library scope

#1574OSPF Link-State Advertisement (LSA) Flooding

Propagating topological changes across OSPF areas to ensure identical Link-State Databases (LSDBs) on all routers. — skip: network protocol beyond the library scope

#1575IEEE 802.1Q VLAN & QinQ Double Tagging

Multiplexing network segments by injecting 12-bit VLAN IDs into Ethernet frames, extended via nested service provider tags. — skip: network protocol beyond the library scope

#1576Link Aggregation Control Protocol (LACP)

Combining multiple physical network interfaces into single logical channels to multiply bandwidth and provide redundancy. — skip: network protocol beyond the library scope

#1577Carrier-Grade NAT (CGNAT) Port Block Allocation

Translating private IP addresses across thousands of subscribers by pre-allocating contiguous outbound port blocks per user. — skip: network protocol beyond the library scope

#1578DNS over HTTPS (DoH) / DNS over TLS (DoT)

Encrypting plain-text DNS queries inside TLS tunnels to prevent eavesdropping and DNS spoofing. — e.net.dns.query_doh

#1579Spanning Tree Protocol (RSTP / MSTP)

Eliminating physical loops in switched Ethernet networks by calculating non-blocking tree topologies. — skip: network protocol beyond the library scope

#1580Dynamic ARP Inspection (DAI)

Mitigating ARP poisoning attacks by validating network address bindings against trusted DHCP snooping databases. — skip: network protocol beyond the library scope

#1581Precision Time Protocol (IEEE 1588 PTP)

Hardware-timestamped synchronization protocol achieving sub-microsecond clock alignment across distributed network nodes. — skip: OS kernel internals

#1582NTP Marzullo's Intersection Algorithm

Selecting optimal time synchronization sources by identifying overlapping confidence intervals among noisy clock sources. — see #149 (e.time.sync.marzullo)

#1583TCP Fast Open (TFO)

Accelerating TCP session setup by enabling cryptographic cookie validation and initial payload transfers inside SYN packets. — skip: OS kernel internals

#1584FQ-CoDel Active Queue Management

Combining Fair Queueing with Controlled Delay algorithms to prevent bufferbloat and manage latency across bottleneck queues. — skip: OS kernel internals

#1585ICMP Path MTU Discovery (PMTUD)

Dynamically determining the maximum transmission unit (MTU) size across end-to-end network paths using ICMP "Fragmentation Needed" messages. — skip: OS kernel internals

#1586Generic Routing Encapsulation (GRE)

Tunneling arbitrary network layer protocols by encapsulating payloads inside standard IP transport headers. — skip: network protocol beyond the library scope

#1587WireGuard Noise IK Pattern Key Handshake

Modern VPN protocol establishing noise-authenticated, single-round-trip key exchanges over UDP. — e.crypto.noise.handshake_ik

#1588BGP Route Reflector Topologies

Eliminating full-mesh internal BGP (iBGP) requirements by re-advertising routes through centralized reflector nodes. — skip: network protocol beyond the library scope

#1589Graceful Restart Routing Protocols

Preserving packet forwarding hardware state while routing control plane daemons restart following crashes. — skip: network protocol beyond the library scope

#1590P4 Network Data Plane Programmability

Hardware-independent domain-specific language defining how packets are parsed, processed, and forwarded in network switches. — skip: hardware or circuit design

#1591Data Center Bridging Priority Flow Control (PFC)

Eliminating packet loss over Ethernet fabrics by issuing pause frames per IEEE 802.1p priority class. — skip: hardware or circuit design

#1592RDMA over Converged Ethernet Version 2 (RoCEv2)

Remote Direct Memory Access protocol routing memory transfers across UDP Layer 3 networks. — skip: hardware or circuit design

#1593InfiniBand Credit-Based Flow Control

Hardware flow control mechanism preventing buffer overflows by issuing transmitter credits per virtual lane. — skip: hardware or circuit design

#1594Dynamic Multipoint VPN (DMVPN) NHRP

Building dynamic, mesh-connected IPsec VPN tunnels across spoke sites using Next Hop Resolution Protocol. — skip: network protocol beyond the library scope

#1595High-Availability Seamless Redundancy (HSR)

Zero-failover redundancy protocol duplicating frames across dual-port ring topologies in industrial Ethernet systems. — skip: network protocol beyond the library scope

#1596Loop-Free Alternate (LFA) Fast Reroute

Pre-computing backup IP paths to redirect traffic in hardware immediately upon primary link failure detection. — skip: network protocol beyond the library scope

#1597BGP EVPN VXLAN Integrated Routing and Bridging (IRB)

Executing simultaneous Layer 2 bridging and Layer 3 routing within VXLAN fabric VTEPs. — skip: network protocol beyond the library scope

#1598L2TPv3 Pseudo-wire Encapsulation

Transporting Layer 2 protocols (Ethernet, Frame Relay, HDLC) directly across IP core backbones. — skip: network protocol beyond the library scope

#1599IS-IS Link-State Routing Protocol

Flexible interior gateway protocol routing IP and non-IP traffic using Type-Length-Value (TLV) data tuples. — skip: network protocol beyond the library scope

#1600BGP Route Flap Damping

Suppressing unstable, oscillating route announcements to protect global core routing tables from control plane instability. — skip: network protocol beyond the library scope

28. Operating Systems, Virtualization & Systems Programming (1601–1650)

#1601Linux Completely Fair Scheduler (CFS)

O(log N) task scheduling engine tracking virtual runtime (vruntime) via self-balancing Red-Black Trees. — skip: OS kernel internals

#1602eBPF In-Kernel Virtual Machine

Running sandboxed, bytecode-verified programs inside the Linux kernel to extend networking, tracing, and security functionality dynamically. — skip: OS kernel internals

#1603Linux cgroups v2 Unified Hierarchy

Kernel resource management subsystem organizing system resources (CPU, Memory, I/O, PIDs) into unified hierarchical trees. — skip: OS kernel internals

#1604Linux Namespaces (PID, Mount, Net, User)

Kernel abstraction isolates system resources per container process, masking underlying operating system states. — skip: OS kernel internals

#1605Virtual Memory Page Table Walks

Translating virtual memory addresses to physical memory addresses using multi-level hardware page tables and Translation Lookaside Buffers (TLB). — skip: OS kernel internals

#1606Linux Copy-on-Write (CoW) Fork

Deferring memory page duplication during fork() operations until child or parent processes write to pages. — skip: OS kernel internals

#1607Linux Page Cache Writeback Engine

Managing dirty page flushing asynchronously from main RAM to block storage using system flusher threads. — skip: OS kernel internals

#1608Linux Futex (Fast Userspace Mutex)

Fast synchronization primitive managing uncontested locks entirely in user space while delegating contested locks to kernel wait queues. — e.os.wait_u32

#1609Linux epoll Event Multiplexing

High-performance I/O event notification mechanism returning ready file descriptors in O(1) time via shared memory ring buffers. — e.async.poll

#1610Linux SLUB Memory Allocator

Unifying kernel memory allocation by managing object slabs without per-slab metadata overhead or fragmenting physical pages. — skip: OS kernel internals

#1611Linux Auto-NUMA Memory Balancing

Migrating physical memory pages and tasks dynamically to place data on NUMA nodes local to processing threads. — skip: OS kernel internals

#1612Virtual File System (VFS) Inode & Dentry Caches

Linux kernel Abstraction layer providing unified file access interfaces via LRU-managed dentry and inode objects. — skip: OS kernel internals

#1613KVM Hardware-Assisted Virtualization

Turning Linux kernels into Type-1 hypervisors using Intel VT-x or AMD-V CPU instructions. — skip: OS kernel internals

#1614Xen Hypervisor Paravirtualization (PV)

Virtualization approach modifying guest operating system kernels to issue hypercalls directly to underlying hypervisors. — skip: OS kernel internals

#1615QEMU Dynamic Binary Translation

Emulating non-native CPU instruction architectures by translating guest target instructions to host instructions at runtime. — skip: implementable, but too specialised for the standard library

#1616SR-IOV PCIe Virtualization

Partitioning single physical PCI Express hardware devices into multiple isolated Virtual Functions (V F) mapped directly to virtual machines. — skip: hardware or circuit design

#1617MicroVM Execution Environments (Firecracker)

Lightweight virtual machines leveraging KVM to launch isolated user spaces in milliseconds with minimal memory footprints. — skip: a vendor product's architecture

#1618Linux Seccomp-BPF System Call Filtering

Restricting process capabilities by intercepting system calls using configurable eBPF filter programs. — e.os.sandbox

#1619Linux Mandatory Access Control (SELinux / AppArmor)

Enforcing system access constraints based on security labels assigned to subjects and objects. — skip: OS kernel internals

#1620Linux Kyber & BFQ I/O Schedulers

Block-layer schedulers prioritizing throughput or latencies by calculating queue depth targets and budget allocations. — skip: OS kernel internals

#1621Linux Out-Of-Memory (OOM) Killer

Subsystem terminating high-badness processes when system RAM and swap capacity are completely exhausted. — skip: OS kernel internals

#1622POSIX Thread Synchronization Primitives

Managing concurrency via pthread mutexes, condition variables, read-write locks, and barrier abstractions. — e.sync.mutex

#1623Memory-Mapped I/O ( mmap ) Execution

Mapping storage files or physical hardware memory addresses directly into application virtual memory address spaces. — e.fs.mmap.map

#1624Read-Copy-Update (RCU) Synchronization

Lock-free kernel synchronization mechanism permitting readers concurrent access while writers defer reclamation until grace periods expire. — see #667 (e.sync.rcu)

#1625Linux Kernel Module Loading ( insmod / modprobe )

Dynamically linking compiled object code into running kernel spaces, resolving symbols on the fly. — skip: OS kernel internals

#1626Linux Device Tree Compilation & Parsing

Passing hardware structural descriptions to OS kernels via compiled flattened device trees ( .dtb ). — skip: OS kernel internals

#1627systemd Service Dependency Graph Engine

Parallelizing Linux boot execution by modeling service initializations as concurrent dependency graphs. — skip: a vendor product's architecture

#1628Hardware Inter-Processor Interrupts (IPI)

Low-level hardware signaling mechanism allowing individual CPU cores to trigger immediate execution events on other cores. — skip: hardware or circuit design

#1629Linux Top-Half & Bottom-Half Interrupt Processing

Splitting interrupt handling into fast critical tasks (Hard IRQ) and deferred processing (Softirqs, Tasklets, Workqueues). — skip: OS kernel internals

#1630Linux Transparent Huge Pages (THP)

Automatically consolidating standard 4KB memory pages into 2MB/1GB pages to reduce TLB cache misses. — skip: OS kernel internals

#1631OverlayFS Multi-Layer Merging

Union mount filesystem layering dynamic writeable file directories ( upperdir ) over read-only image bases ( lowerdir ). — skip: OS kernel internals

#1632FUSE (Filesystem in Userspace)

Executing custom file system logic inside user space programs by routing VFS requests through kernel modules. — skip: implementable, but too specialised for the standard library

#1633Unikernel Execution Model

Compiling application code together with minimal Library OS dependencies into single-address-space binary images running directly on hypervisors. — skip: a whole service or system, not a function

#1634Linux Process Memory Layout

Organizing process virtual address spaces into distinct segments: Text, Data, BSS, Heap, Memory Mapping, and Stack. — skip: OS kernel internals

#1635Priority Inversion & Priority Inheritance Protocols

Preventing high-priority thread starvation by temporarily elevating lower-priority threads holding required shared resource locks. — skip: OS kernel internals

#1636Rate-Monotonic Scheduling (RMS)

Deterministic real-time scheduling algorithm assigning higher priorities to tasks with shorter periodic interval execution cycles. — skip: OS kernel internals

#1637Earliest Deadline First (EDF) Scheduling

Dynamic real-time scheduling algorithm prioritizing tasks closest to their execution deadlines. — see #657 (e.thread.pool.edf)

#1638Memory Protection Keys (MPK)

Intel hardware feature allowing user-space applications to toggle access permissions on memory pages without executing system calls. — skip: OS kernel internals

#1639Intel Extended Page Tables (EPT)

Hardware MMU feature executing two-dimensional page table walks (Guest Virtual — Guest Physical → Host Physical). → skip: hardware or circuit design

#1640WASI Capability-Based Security Model

WebAssembly System Interface constraining sandbox environments by requiring explicit file descriptor capabilities for system accesses. — skip: implementable, but too specialised for the standard library

#1641Direct Threaded Interpreter Engine

Accelerating virtual machine bytecode execution by replacing switch dispatch loops with arrays storing target instruction handler addresses directly. — skip: a technique applied per problem, not a reusable function

#1642POSIX Signal Handling Subsystem

Interrupting process control flows to execute registered signal routines upon receiving kernel signals ( SIGSEGV , SIGKILL , SIGINT ). — e.os.signal

#1643Linux Kernel Dynamic Probing (kprobes / uprobes)

Attaching debug handlers dynamically to arbitrary kernel or user space instruction addresses without recompilation. — skip: OS kernel internals

#1644Hardware Performance Monitor Units (PMU)

Reading specialized CPU registers to profile cycle counts, instruction retirements, and cache misses ( perf ). — skip: implementable, but too specialised for the standard library

#1645Core Dump Generation & Memory Parsing

Writing complete process memory images to ELF binary files upon fatal system crashes for post-mortem analysis. — e.debug.dump.parse

#1646Linux Pressure Stall Information (PSI)

Real-time metrics monitoring hardware resource starvation across CPU, Memory, and I/O subsystems. — skip: OS kernel internals

#1647Linux zram Compressed Block Device

Offloading memory pressures by creating compressed RAM block devices that act as fast swap spaces. — skip: OS kernel internals

#1648Rust Compile-Time Ownership & Borrow Checker

Enforcing thread safety and memory safety statically without garbage collectors by enforcing strict reference ownership lifetimes. — skip: belongs in the Neper compiler, not the library

#1649C++11 Memory Model & Sequential Consistency

Language-level primitives defining hardware atomic operation visibility and memory ordering constraints across threads. — see #1327 (e.atomic.load)

#1650Hardware Transactional Memory (Intel TSX)

Execution model speculatively executing memory operations in hardware, aborting and rolling back if data conflicts occur. — skip: hardware or circuit design

29. Database Engines, Storage Systems & Big Data Architecture (1651–1700)

#1651B+ Tree Index Structural Operations

Self-balancing search tree keeping data in linked leaf nodes, guaranteeing O(log N) search, insert, and sequential range scans. — see #193 (e.data.btree.insert)

#1652LSM-Tree MemTable, WAL & SSTable Mechanics

Write-optimized storage architecture buffering writes in volatile MemTables before flushing immutable, sorted SSTables to disk. — see #863 (e.db.storage.memtable_flush)

#1653LSM-Tree Leveled vs. Size-Tiered Compaction

Merging overlapping SSTable files to minimize read amplification factors or control write amplification penalties. — see #717 (e.db.storage.lsm_compact)

#1654ARIES Database Recovery Algorithm

Crash recovery protocol executing three sequential passes: Analysis, Redo (repeating history), and Undo (rolling back uncommitted transactions). — see #719 (e.db.storage.recover)

#1655Multi-Version Concurrency Control (MVCC)

Database isolation engine enabling lock-free reads by storing concurrent transaction row versions. — see #870 (e.db.storage.txn_mvcc)

#1656PostgreSQL Heap-Only Tuples (HOT)

Optimizing update performance by storing updated tuple versions on the same data page, eliminating index update overheads. — skip: a vendor product's architecture

#1657MySQL InnoDB Buffer Pool Management

Managing cached database pages in RAM using LRU lists split into young and old sub-segments to prevent table scan pollution. — see #866 (e.db.storage.buffer_pool_evict)

#1658SQLite Write-Ahead Logging (WAL)

Appending concurrent database writes to separate WAL files, enabling non-blocking reads during active transactions. — see #718 (e.db.storage.wal_append)

#1659Apache Cassandra Distributed Consistent Hashing

Ring-based distributed NoSQL database mapping data keys to cluster token ranges using Murmur3 hashing. — skip: a vendor product's architecture

#1660Apache Parquet Columnar Compression Encoding

Efficient binary file format organizing data by columns using Dictionary, Run-Length (RLE), and Bit-Packing encodings. — e.fmt.parquet.decode

#1661Apache Iceberg Snapshot-Based Table Format

Open table format providing ACID guarantees on object stores using explicit JSON/AVRO metadata manifests. — skip: a vendor product's architecture

#1662Delta Lake ACID Transaction Log Protocol

Storage layer maintaining transactional consistency over cloud object stores using ordered JSON delta logs. — skip: a vendor product's architecture

#1663ClickHouse Vectorized Columnar Engine

High-throughput OLAP database processing data blocks in memory using SIMD CPU instructions over columnar storage. — skip: a vendor product's architecture

#1664Apache Druid Real-Time Segment Indexing

Distributed OLAP store indexing time-series data into immutable columnar segments containing dictionary-encoded inverted bitmaps. — skip: a vendor product's architecture

#1665Snowflake Multi-Cluster Shared-Data Architecture

Decoupling compute virtual warehouses from centralized cloud storage objects to scale storage and compute independently. — skip: a vendor product's architecture

#1666Google BigQuery Dremel Execution Tree

Serverless query engine organizing parallel execution nodes into hierarchical execution trees to aggregate columnar data. — skip: a vendor product's architecture

#1667Volcano Query Processing Iterator Model

Classic relational query engine processing data tuples sequentially via open-next-close iterator interfaces. — see #885 (e.db.query.iterator)

#1668Cost-Based Query Optimizer (CBO)

Query planner estimating physical plan execution costs using table histograms, column cardinalities, and join selectivity models. — e.db.query.optimize

#1669Dynamic Programming Join Order Enumeration

Generating optimal join trees for complex multi-table queries by evaluating sub-query execution costs. — e.db.query.join_order

#1670Bloom Filter Data Skipping

Probabilistic data structure evaluated against storage block headers to skip reading blocks lacking matching keys. — see #238 (e.algo.sketch.bloom_contains)

#1671Z-Order Space-Filling Curves

Mapping multi-dimensional spatial points to 1D data spaces to preserve data locality across multi-column query filters. — see #845 (e.algo.geom.morton_encode)

#1672Google S2 Spatial Indexing System

Projecting Earth's sphere onto a cube, indexing hierarchical grid cells using 64-bit Hilbert space-filling curve integers. — e.algo.geo.s2_cell

#1673HikariCP High-Performance Connection Pooling

Eliminating JDBC overheads using optimized byte-code generation and array-backed thread-local lock-free list structures. — e.db.pool.acquire

#1674Distributed Hash Join Execution

Partitioning build-side and probe-side datasets across network clusters using matching join key hash functions. — skip: a whole service or system, not a function

#1675Database Index-Only Scans

Executing queries entirely within index structures without reading underlying main table heap pages. — see #898 (e.db.query.index_only_scan)

#1676Write Amplification Factor (WAF) in SSDs

Measuring physical data written to flash media relative to logical data issued by host operating systems. — skip: hardware or circuit design

#1677NVMe Flash Translation Layer (FTL)

Solid-state drive controller firmware mapping logical block addresses (LBA) to physical flash memory locations while handling garbage collection. — skip: hardware or circuit design

#1678Zoned Namespaces (ZNS) NVMe Interface

Storage interface requiring sequential data writes into contiguous physical drive zones, bypassing standard SSD FTL garbage collection. — skip: hardware or circuit design

#1679Erasure Coding (Reed-Solomon K + M)

Object storage data protection splitting data objects into K data blocks and M parity blocks to survive M hardware failures. — see #854 (e.algo.ecc.reed_solomon_decode)

#1680AWS DynamoDB Single-Table Design

Data modeling technique representing multiple relational entities inside a single NoSQL table using overloaded primary/sort keys. — skip: a vendor product's architecture

#1681CockroachDB Multi-Raft Partitioning

Distributed SQL database partitioning keyspaces into dynamic contiguous ranges managed by independent Raft consensus groups. — skip: a vendor product's architecture

#1682TiDB Distributed HTAP Engine

Hybrid Transactional/Analytical Processing database replicating Raft row-based engine data (TiKV) asynchronously to columnar vector engines (TiFlash). — skip: a vendor product's architecture

#1683Redis In-Memory AOF Append-Only File Rewrite

Compacting transaction logs in the background into minimal instruction sets to keep recovery logs compact. — skip: a vendor product's architecture

#1684Apache Flink Event Time & Watermarking

Stream processing framework tracking event-time progress across out-of-order streams using monotonic watermark markers. — see #1297 (e.data.stream.watermark)

#1685Apache Kafka Partition Log Compaction

Retaining the most recent record value for every message key within a topic partition log on disk. — skip: a vendor product's architecture

#1686Debezium Transaction Log Change Data Capture (CDC)

Tapping database transaction logs directly to capture row-level mutations as real-time event streams. — skip: a vendor product's architecture

#1687Data Mesh Federated Architecture

Decentralized data architecture organizing data platforms into domain-driven data products with federated computational governance. — skip: a technique applied per problem, not a reusable function

#1688Spanner Distributed Lock-Free Read Transactions

Executing globally consistent read operations across multi-region databases without acquiring read locks, powered by TrueTime bounded uncertainty. — skip: a vendor product's architecture

#1689B-Tree Write-Ahead Logging Frame Checkpointing

Flushing dirty memory pages from RAM back to persistent database files to advance recovery checkpoints. — see #719 (e.db.storage.recover)

#1690PostgreSQL Generalized Inverted Index (GIN)

Multi-element index structure mapping composite column items (JSONB arrays, text search documents) to matching row IDs. — see #875 (e.text.index.build)

#1691Data Lakehouse Format Manifest Evolution

Metadata abstraction layers tracking structural schema changes and data file partitioning without rewriting underlying Parquet datasets. — skip: a vendor product's architecture

#1692Apache Calcite Query Parser & Optimization Engine

Extensible SQL parsing and optimization framework transforming AST expressions into physical query operators. — skip: a vendor product's architecture

#1693Partition Pruning Engine

Query optimizer pass static or dynamic execution paths to evaluate table partition constraints and ignore non-matching partition directories. — see #893 (e.db.query.prune_partitions)

#1694Columnar Vectorized Execution Memory Alignment

Structuring database memory arrays to align with CPU L1/L2 cache lines, maximizing SIMD instruction efficiency. — see #886 (e.db.query.vectorized)

#1695Distributed Dynamic Shuffle Service

Decoupling intermediate map-side shuffle outputs from streaming/batch execution nodes to persistent cluster storage nodes. — skip: a whole service or system, not a function

#1696Storage Class Memory (PMEM) Byte-Addressable Persistence

Programming memory-mapped persistence architectures directly over byte-addressable non-volatile RAM interfaces. — skip: hardware or circuit design

#1697Redis Hash Slot Keyspace Partitioning

Routing database commands across cluster nodes using CRC16 checksum modulo calculations over 16,384 slots. — skip: a vendor product's architecture

#1698RabbitMQ AMQP Queue Architecture

Decoupling producers and consumers by routing messages through exchanges to bound queues using binding keys. — skip: a vendor product's architecture

#1699Apache Pulsar Decoupled Storage Topology

Separating stateless serve nodes (Brokers) from stateful storage nodes (BookKeeper) to scale compute and storage independently. — skip: a vendor product's architecture

#1700Vector Database Inverted File (IVF) Centroid Clustering

Partitioning multi-dimensional vector spaces into Voronoi cells using k-means clustering to bound search queries. — see #1227 (e.ml.ann.ivf_pq)

30. Computer Vision, Graphics & Spatial Computing (1701–1750)

#1701PBR Bidirectional Reflectance Distribution Function (BRDF)

Mathematical model defining light reflection off surfaces, incorporating Fresnel, Roughness, and Metallic parameters. — e.gfx.shade.brdf_ggx

#1702Monte Carlo Path Tracing

Rendering algorithm estimating light transport integrals by firing random light paths through image pixels. — e.gfx.trace.path_trace

#1703Bounding Volume Hierarchy (BVH) Traversal

Accelerating ray-scene intersection tests by organizing geometric primitives into spatial tree hierarchies. — e.data.spatial.bvh_traverse

#1704Radiance Cascades Global Illumination

Spherical harmonic lighting technique organizing radiative transfer calculations into multi-resolution spatial cascades. — skip: research-grade, no settled practical implementation

#1705Neural Radiance Fields (NeRF)

Representing complex 3D scenes as continuous volumetric functions parameterized by deep multilayer perceptrons (MLP). — skip: a trained ML model or training recipe

#17063D Gaussian Splatting Rasterization

Scene representation model rendering real-time 3D scenes by rasterizing anisotropic 3D Gaussians onto 2D image planes. — skip: a trained ML model or training recipe

#1707Deferred Shading Rendering Pipeline

Rendering architecture separating geometry pass execution from lighting computations by writing geometric properties to intermediate G-Buffers. — see #1113 (e.gfx.scene.deferred)

#1708Screen-Space Ambient Occlusion (SSAO)

Graphics technique approximating ambient occlusion shadows in real time by evaluating nearby depth-buffer differences around pixels. — see #1104 (e.gfx.scene.ssao)

#1709Temporal Anti-Aliasing (TAA)

Anti-aliasing method blending previous frame colors with current frames using motion vectors to reduce sub-pixel aliasing. — see #1110 (e.gfx.scene.taa)

#1710DLSS / FSR Super Resolution Upscaling

Enhancing low-resolution rendered frames to higher target resolutions using temporal reconstruction models or deep learning models. — skip: a trained ML model or training recipe

#1711Vulkan / DirectX 12 Command Buffer Recording

Explicit low-overhead graphics API paradigm recording draw commands across parallel CPU worker threads before submission to GPU queues. — skip: an implementation detail of an existing module, not an API

#1712GPU Memory Pipeline Barriers & Fences

Explicit synchronization primitives forcing memory visibility and instruction completion order between GPU pipeline stages. — skip: an implementation detail of an existing module, not an API

#1713Mesh & Amplification Shaders

Modern GPU geometry pipeline replacing legacy fixed-function processing with compute-like shader threads operating on meshlets. — skip: hardware or circuit design

#1714Visual Simultaneous Localization and Mapping (V-SLAM)

Estimating camera poses while concurrently constructing 3D spatial environment maps using visual sensor feeds. — skip: a whole service or system, not a function

#1715Structure from Motion (SfM) 3D Reconstruction

Reconstructing 3D point cloud geometry and camera positions from overlapping collections of 2D photographs. — e.gfx.vision.structure_from_motion

#1716Epipolar Geometry & Fundamental Matrix Calculation

Geometric relationship constrained across two stereo views, mapping points in one image to epipolar lines in another. — e.gfx.vision.fundamental_matrix

#1717RANSAC (Random Sample Consensus) Model Estimation

Iterative parameter estimation algorithm calculating geometric transformations in the presence of strong dataset outliers. — e.gfx.vision.ransac

#1718Lucas-Kanade Optical Flow Sparse Tracking

Calculating pixel motion vectors across sequential frames assuming spatial brightness constancy inside local pixel windows. — see #791 (e.gfx.vision.optical_flow_lk)

#1719Scale-Invariant Feature Transform (SIFT)

Computer vision algorithm detecting scale- and rotation-invariant feature keypoints across Difference-of-Gaussians scale spaces. — see #784 (e.gfx.vision.sift)

#1720YOLO (You Only Look Once) One-Stage Object Detection

Frame object detection framing bounding box coordinates and class probabilities as single regression problems. — skip: a trained ML model or training recipe

#1721Mask R-CNN ROI Align Mechanics

Preserving exact spatial locations in feature maps using bilinear interpolation to extract accurate pixel-level instance segmentation masks. — skip: a trained ML model or training recipe

#1722Vision Transformer (ViT) Patch Embeddings

Image processing architecture splitting images into non-overlapping spatial patches mapped into standard Transformer input sequences. — skip: a trained ML model or training recipe

#1723Swin Transformer Shifted Window Attention

Hierarchical Vision Transformer restricting self-attention calculations to local non-overlapping shifted windows. — skip: a trained ML model or training recipe

#1724Segment Anything Model (SAM) Promptable Mask Engine

Zero-shot image segmentation architecture generating object masks based on point, box, or text prompt inputs. — skip: a trained ML model or training recipe

#1725Extended Kalman Filter (EKF) Sensor Fusion

Fusing high-frequency IMU telemetry with lower-frequency visual camera frames to compute ultra-low-latency AR/VR head poses. — see #518 (e.math.filter.ekf)

#1726Asynchronous Timewarp (ATW) VR Motion Latency Compensation

Warping rendered VR frames based on updated head orientation telemetry right before display scanouts to mitigate motion sickness. — skip: implementable, but too specialised for the standard library

#1727Foveated Rendering Pipeline

Optimizing rendering performance by targeting full resolution at eye gaze points while reducing shading quality across peripheral vision. — skip: hardware or circuit design

#1728Point Cloud Octree Space Partitioning

Structuring non-uniform 3D point cloud collections into recursive octree spatial data structures. — see #220 (e.data.spatial.octree_insert)

#1729Iterative Closest Point (ICP) Rigid Alignment

Minimizing distances between point clouds iteratively to calculate rigid 3D spatial transformations. — e.gfx.vision.icp

#1730Marching Cubes Isosurface Extraction

Extracting 3D polygonal mesh surfaces from scalar volumetric density fields using lookup tables across voxel configurations. — see #551 (e.gfx.mesh.marching_cubes)

#1731Signed Distance Functions (SDF) Sphere Tracing

Ray-marching volumetric surfaces defined analytically as distance fields along ray paths. — see #1145 (e.gfx.scene.sdf_raymarch)

#1732Cascaded Shadow Maps (CSM)

Mitigating shadow perspective aliasing by splitting view frustums into multiple depth zones rendered into separate shadow maps. — see #1102 (e.gfx.scene.shadow_cascades)

#1733Screen Space Reflections (SSR) Ray Marching

Rendering real-time reflections by marching rays along depth buffer spaces to locate surface intersections. — see #1107 (e.gfx.scene.ssr)

#1734Order-Independent Transparency (OIT) Depth Peeling

Rendering transparent geometry accurately without pre-sorting polygons by peeling geometric layers across multiple depth passes. — e.gfx.scene.depth_peel

#1735Position-Based Dynamics (PBD) Simulation

Simulating physical constraints (cloth, soft bodies) by manipulating particle positions directly rather than integrating forces. — see #1119 (e.game.physics.pbd_step)

#1736Smoothed Particle Hydrodynamics (SPH) Fluid Simulation

Lagrangian computational fluid dynamics method modeling fluid flow as interacting particle masses. — see #1030 (e.game.physics.sph)

#1737Eulerian Fluid Marker-And-Cell (MAC) Grids

Simulating fluid motion on fixed spatial grids, decoupling velocity components across staggered cell faces. — e.game.physics.fluid_mac

#1738Inverse Kinematics FABRIK Solver

Solving joint positions along kinematic chains iteratively using forward and backward reaching passes. — see #1126 (e.game.anim.ik_fabrik)

#1739SPIR-V Intermediate Shader Representation

Cross-platform byte-code language compiling high-level shader code (HLSL, GLSL) into unified GPU pipeline representations. — skip: belongs in the toolchain (build, test runner, pacman)

#1740Variable Rate Shading (VRS)

Dynamically varying shading rates across screen space regions to allocate rendering power to visually salient areas. — skip: hardware or circuit design

#1741GPU-Driven Bindless Rendering

Architecture accessing thousands of material textures and buffers from unified descriptor arrays without per-draw binding state changes. — skip: hardware or circuit design

#1742Homographic Transformation Matrix Operations

Mapping projective transformations between two 2D planar projections using 3 × 3 linear transform matrices. — e.gfx.vision.homography

#1743Canny Edge Detection Multi-Stage Filter

Image processing pipeline detecting structural edges via Gaussian blurring, Sobel gradient intensity checks, non-maximum suppression, and hysteresis thresholding. — see #782 (e.gfx.filter.canny)

#1744Convolutional Receptive Field Calculation

Determining spatial input regions contributing to specific activations in deep convolutional layers. — skip: pedagogical only

#1745Radiance Field Depth Regularization

Constraining 3D scene reconstruction models using monocular depth priors to eliminate floating artifacts in sparse regions. — skip: a trained ML model or training recipe

#1746GPU Early-Z Depth Testing

Discarding occluded fragment executions before running expensive pixel shader stages by checking frag depths against existing depth buffers. — skip: hardware or circuit design

#1747Ray Tracing Shader Execution Reordering (SER)

Dynamically sorting divergent ray execution threads on modern GPUs to maximize execution cache coherence. — skip: hardware or circuit design

#1748OpenCV Camera Calibration Calibration Matrices

Extracting intrinsic parameters (focal length, principal point) and radial distortion coefficients using checkerboard target projections. — e.gfx.vision.calibrate_camera

#1749Bilateral Filter Edge-Preserving Denoising

Blending pixel values based on spatial distance and photometric intensity similarities to reduce noise without blurring structural edges. — see #788 (e.gfx.filter.bilateral)

#1750Physically Based Hair & Fur Rendering (Marschner Model)

Modeling light scattering through translucent cylindrical fibers using reflection, transmission, and internal refraction paths (R,TT,TRT). — skip: implementable, but too specialised for the standard library

31. Compiler Optimization & Program Analysis (1751–1800)

#1751Constant Folding

Evaluating expressions whose operands are all compile-time constants. — skip: belongs in the Neper compiler, not the library

#1752Constant Propagation

Replacing uses of a variable with its known constant value along all paths. — skip: belongs in the Neper compiler, not the library

#1753Jump Threading

Redirecting a branch whose outcome is known on an incoming edge straight to its target. — skip: belongs in the Neper compiler, not the library

#1754Copy Propagation

Replacing uses of a copied variable with the original source variable. — skip: belongs in the Neper compiler, not the library

#1755Common Subexpression Elimination (CSE)

Reusing a previously computed value for an identical expression. — skip: belongs in the Neper compiler, not the library

#1756Value Range Propagation

Tracking integer intervals per variable to fold comparisons and drop checks. — skip: belongs in the Neper compiler, not the library

#1757Partial Redundancy Elimination (PRE)

Hoisting expressions computed on some paths so no path computes them twice. — skip: belongs in the Neper compiler, not the library

#1758Dead Code Elimination

Removing computations whose results are never observed. — skip: belongs in the Neper compiler, not the library

#1759Store-to-Load Forwarding

Replacing a load with the value of a dominating store to the same address. — skip: belongs in the Neper compiler, not the library

#1760Unreachable Block Elimination

Deleting basic blocks no control-flow path can enter. — skip: belongs in the Neper compiler, not the library

#1761Loop Rotation

Turning a top-tested loop into a bottom-tested one behind a guarded entry. — skip: belongs in the Neper compiler, not the library

#1762Strength Reduction

Replacing expensive operations with cheaper equivalents, such as multiplication by induction-variable addition. — skip: belongs in the Neper compiler, not the library

#1763Induction Variable Elimination

Rewriting derived loop counters in terms of a single canonical counter. — skip: belongs in the Neper compiler, not the library

#1764Loop Unrolling

Replicating a loop body to cut branch overhead and expose instruction-level parallelism. — skip: belongs in the Neper compiler, not the library

#1765Loop Peeling

Splitting off the first or last iterations so the main body needs no boundary checks. — skip: belongs in the Neper compiler, not the library

#1766Loop Fusion

Merging adjacent loops over the same range into one to improve locality. — skip: belongs in the Neper compiler, not the library

#1767Loop Fission (Distribution)

Splitting a loop into several loops to enable vectorization or reduce register pressure. — skip: belongs in the Neper compiler, not the library

#1768Loop Interchange

Swapping nested loop order to walk memory in stride-one order. — skip: belongs in the Neper compiler, not the library

#1769Loop Tiling (Blocking)

Restructuring nested loops so working sets fit in cache. — skip: belongs in the Neper compiler, not the library

#1770Loop Unswitching

Moving a loop-invariant conditional outside the loop and duplicating the body per branch. — skip: belongs in the Neper compiler, not the library

#1771Software Pipelining (Modulo Scheduling)

Overlapping iterations so each cycle executes stages from different iterations. — skip: belongs in the Neper compiler, not the library

#1772Tail Call Elimination

Replacing a call in tail position with a jump reusing the current frame. — skip: belongs in the Neper compiler, not the library

#1773Function Inlining Heuristics

Deciding by call-site cost and callee size whether to substitute a body for a call. — skip: belongs in the Neper compiler, not the library

#1774Interprocedural Constant Propagation

Propagating constant arguments across call boundaries into callee bodies. — skip: belongs in the Neper compiler, not the library

#1775Memory-to-Register Promotion (mem2reg)

Lifting stack slots whose address never escapes into SSA registers. — skip: belongs in the Neper compiler, not the library

#1776Scalar Replacement of Aggregates (SROA)

Splitting a non-escaping struct into independent scalar variables. — skip: belongs in the Neper compiler, not the library

#1777Alias Analysis (Andersen's)

Inclusion-based points-to analysis solved as a constraint graph. — skip: belongs in the Neper compiler, not the library

#1778Alias Analysis (Steensgaard's)

Unification-based near-linear points-to analysis using union-find. — skip: belongs in the Neper compiler, not the library

#1779Type-Based Alias Analysis (TBAA)

Ruling out aliasing between accesses whose declared types cannot overlap. — skip: belongs in the Neper compiler, not the library

#1780Reaching Definitions Analysis

Computing which assignments may reach each program point. — skip: belongs in the Neper compiler, not the library

#1781Live Variable Analysis

Backward dataflow determining which variables hold values still needed later. — skip: belongs in the Neper compiler, not the library

#1782Available Expressions Analysis

Forward dataflow finding expressions already computed on every incoming path. — skip: belongs in the Neper compiler, not the library

#1783Iterative Dataflow Fixpoint Solver

Worklist iteration over a lattice until transfer functions stop changing. — skip: belongs in the Neper compiler, not the library

#1784Dominance Frontier Computation

Finding the blocks where a definition's dominance ends, used to place phi nodes. — skip: belongs in the Neper compiler, not the library

#1785Phi Node Placement

Inserting SSA merge nodes at iterated dominance frontiers of each definition. — skip: belongs in the Neper compiler, not the library

#1786Out-of-SSA Translation

Replacing phi nodes with parallel copies while resolving the lost-copy and swap problems. — skip: belongs in the Neper compiler, not the library

#1787Instruction Selection (Tree Pattern Matching)

Covering an expression tree with target instructions of minimum cost. — skip: belongs in the Neper compiler, not the library

#1788Instruction Selection (BURS)

Bottom-up rewrite system tabulating optimal tree covers with dynamic programming. — skip: belongs in the Neper compiler, not the library

#1789List Scheduling

Greedy ordering of instructions by priority within a basic block subject to dependences. — skip: belongs in the Neper compiler, not the library

#1790Trace Scheduling

Scheduling across basic blocks along the most likely execution path with compensation code. — skip: belongs in the Neper compiler, not the library

#1791Basic Block Layout (Pettis-Hansen)

Ordering blocks so hot edges fall through and cold code moves away. — skip: belongs in the Neper compiler, not the library

#1792Hot-Cold Code Splitting

Moving rarely executed blocks into a separate section to improve instruction cache use. — skip: belongs in the Neper compiler, not the library

#1793Branch Prediction Hints Insertion

Annotating likely branch directions from static heuristics or profiles. — skip: belongs in the Neper compiler, not the library

#1794Bounds Check Elimination

Proving array indices in range so runtime checks can be dropped. — skip: belongs in the Neper compiler, not the library

#1795Null Check Elimination

Removing dereference guards on references proven non-null by dataflow. — skip: belongs in the Neper compiler, not the library

#1796Devirtualization

Replacing an indirect virtual call with a direct call when the receiver class is known. — skip: belongs in the Neper compiler, not the library

#1797Speculative Inlining with Deoptimization

Inlining a probable target and falling back to the interpreter if the guard fails. — skip: belongs in the Neper compiler, not the library

#1798Polyhedral Loop Optimization

Representing loop nests as integer polyhedra and applying affine transformations. — skip: belongs in the Neper compiler, not the library

#1799Auto-Vectorization Dependence Testing

Using GCD and Banerjee tests to prove loop iterations independent. — skip: belongs in the Neper compiler, not the library

#1800Identical Code Folding

Merging functions with byte-identical bodies at link time. — skip: belongs in the Neper compiler, not the library

32. Robotics, Control Systems & Motion Planning (1801–1850)

#1801PID Controller

Correcting error with proportional, integral, and derivative terms. — e.control.pid

#1802Anti-Windup PID

Clamping or back-calculating the integral term to prevent saturation overshoot. — e.control.pid_anti_windup

#1803Ziegler-Nichols Tuning

Setting PID gains from the ultimate gain and oscillation period. — e.control.pid_tune_ziegler_nichols

#1804Bang-Bang Control

Switching the actuator fully on or off around a threshold. — e.control.bang_bang

#1805Feedforward Control

Adding a model-predicted command so feedback only corrects residual error. — e.control.feedforward

#1806Linear Quadratic Regulator (LQR)

Optimal state feedback minimizing quadratic cost via the Riccati equation. — e.control.lqr

#1807Model Predictive Control (MPC)

Solving a finite-horizon optimization each step and applying only the first action. — skip: implementable, but too specialised for the standard library

#1808Sliding Mode Control

Driving the state onto a switching surface and holding it there with discontinuous control. — e.control.sliding_mode

#1809Pole Placement (Ackermann's Formula)

Choosing feedback gains that set closed-loop eigenvalues. — e.control.pole_placement

#1810Luenberger Observer

Estimating unmeasured state from outputs with a model plus correction gain. — e.control.observer

#1811Complementary Filter

Fusing gyroscope and accelerometer readings with high- and low-pass blending. — e.math.filter.complementary

#1812Madgwick Filter

Gradient-descent orientation estimate from IMU and magnetometer data. — e.math.filter.madgwick

#1813Mahony Filter

Proportional-integral orientation correction using measured reference vectors. — e.math.filter.mahony

#1814Dead Reckoning

Integrating velocity and heading over time to estimate position. — e.robot.kinematics.dead_reckon

#1815Odometry from Wheel Encoders

Converting wheel tick counts into pose changes for a differential drive. — e.robot.kinematics.odometry

#1816Differential Drive Kinematics

Mapping left and right wheel speeds to linear and angular velocity. — e.robot.kinematics.differential_drive

#1817Ackermann Steering Geometry

Computing inner and outer wheel angles for a car-like vehicle. — e.robot.kinematics.ackermann

#1818Denavit-Hartenberg Parameters

Describing serial-link geometry with four parameters per joint. — e.robot.kinematics.dh_transform

#1819Forward Kinematics

Composing joint transforms to find the end-effector pose. — e.robot.kinematics.forward

#1820Jacobian Inverse Kinematics

Iterating joint updates using the pseudo-inverse of the manipulator Jacobian. — e.robot.kinematics.ik_jacobian

#1821Cyclic Coordinate Descent (CCD) IK

Rotating one joint at a time toward the target until convergence. — see #1127 (e.game.anim.ik_ccd)

#1822Damped Least Squares IK

Regularizing the Jacobian inverse to stay stable near singularities. — e.robot.kinematics.ik_damped_least_squares

#1823Trapezoidal Velocity Profile

Planning motion with constant-acceleration ramps and a cruise phase. — e.robot.motion.trapezoid_profile

#1824S-Curve Motion Profile

Limiting jerk by smoothing the acceleration transitions of a trapezoidal profile. — e.robot.motion.s_curve_profile

#1825Cubic Spline Trajectory

Joining waypoints with piecewise cubics continuous in velocity. — e.robot.motion.spline_trajectory

#1826Minimum-Jerk Trajectory

Fifth-order polynomial minimizing the integral of squared jerk. — e.robot.motion.min_jerk

#1827Pure Pursuit Path Tracking

Steering toward a lookahead point on the path with a circular arc. — e.robot.motion.pure_pursuit

#1828Stanley Controller

Combining heading error and cross-track error for front-axle path tracking. — e.robot.motion.stanley

#1829Dynamic Window Approach (DWA)

Sampling admissible velocities and scoring short forward simulations. — e.robot.motion.dynamic_window

#1830Velocity Obstacles

Choosing velocities outside the cones that lead to collision with moving agents. — e.robot.motion.velocity_obstacles

#1831Reciprocal Velocity Obstacles (RVO / ORCA)

Sharing avoidance responsibility between agents so they do not oscillate. — e.robot.motion.orca

#1832Artificial Potential Fields

Attracting toward the goal and repelling from obstacles with summed gradients. — e.robot.motion.potential_field

#1833Probabilistic Roadmap (PRM)

Sampling free configurations and connecting neighbors into a query graph. — e.robot.plan.prm

#1834Kinodynamic RRT

Extending the random tree with dynamically feasible controls integrated forward in time. — e.robot.plan.rrt_kinodynamic

#1835RRT-Connect

Growing two trees from start and goal and joining them greedily. — e.robot.plan.rrt_connect

#1836Informed RRT*

Restricting samples to the ellipsoid that can still improve the current solution. — e.robot.plan.rrt_informed

#1837Hybrid A*

Searching over continuous headings with kinematically feasible motion primitives. — e.robot.plan.hybrid_astar

#1838State Lattice Planning

Searching precomputed feasible motion primitives on a discretized state grid. — e.robot.plan.state_lattice

#1839Theta* Any-Angle Pathfinding

Grid search with line-of-sight parent shortcuts for straighter paths. — e.game.grid.path_theta_star

#1840D* Lite

Incremental replanning from the goal as edge costs change during execution. — see #92 (e.robot.plan.dstar_lite)

#1841Elastic Band Path Smoothing

Deforming a path with internal contraction and external repulsion forces. — e.robot.motion.elastic_band

#1842Timed Elastic Band (TEB)

Optimizing waypoints and time intervals jointly under kinodynamic constraints. — skip: implementable, but too specialised for the standard library

#1843Occupancy Grid Mapping

Updating cell occupancy log-odds from range sensor inverse models. — e.robot.map.occupancy_update

#1844Bresenham Ray Casting on Grids

Marking free cells along a sensor ray up to the hit cell. — e.game.grid.ray_cells

#1845Scan Matching (Point-to-Line ICP)

Aligning consecutive laser scans by minimizing point-to-line distances. — e.robot.map.scan_match

#1846Adaptive Monte Carlo Localization (AMCL)

Particle-filter localization with KLD-sampling to resize the particle set. — e.robot.map.localize_amcl

#1847Graph SLAM Pose Graph Optimization

Minimizing relative-pose constraint residuals with sparse least squares. — e.robot.map.pose_graph_optimize

#1848Loop Closure Detection (Bag of Words)

Recognizing revisited places by matching visual word histograms. — skip: a trained ML model or training recipe

#1849Grasp Planning (Force Closure)

Selecting contact points whose wrenches span the full wrench space. — skip: implementable, but too specialised for the standard library

#1850Zero Moment Point (ZMP) Walking

Keeping the ground reaction point inside the support polygon for biped balance. — skip: implementable, but too specialised for the standard library

33. Audio, Music & Digital Signal Processing (1851–1900)

#1851Comb Filter

Adding a delayed copy of the signal to itself, producing evenly spaced spectral notches or peaks. — e.dsp.comb

#1852One-Pole Low-Pass Filter

First-order recursive smoothing with a single coefficient. — e.dsp.one_pole

#1853Biquad Filter (Direct Form II Transposed)

Second-order IIR section with numerically stable state variables. — e.dsp.biquad

#1854Elliptic (Cauer) Filter Design

Allowing ripple in both bands for the steepest possible transition. — e.dsp.design_elliptic

#1855Bessel Filter Design

Maximally flat group delay preserving waveform shape. — e.dsp.design_bessel

#1856Windowed-Sinc Filter Design

Truncating the ideal low-pass impulse response with a window function. — e.dsp.design_windowed_sinc

#1857Parks-McClellan Algorithm

Equiripple FIR design via the Remez exchange algorithm. — e.dsp.design_parks_mcclellan

#1858Bilinear Transform

Mapping an analog filter prototype to a digital one while warping frequency. — e.dsp.bilinear_transform

#1859Hann / Hamming / Blackman Windows

Tapering a frame to reduce spectral leakage before an FFT. — e.dsp.window

#1860Gabor Transform

STFT with a Gaussian window meeting the time-frequency uncertainty bound. — see #802 (e.dsp.stft)

#1861Inverse STFT with Overlap-Add

Reconstructing a signal from modified frames with window compensation. — e.dsp.istft

#1862Discrete Wavelet Transform (Mallat)

Cascaded filter banks with downsampling for multi-resolution analysis. — see #636 (e.math.fft.dwt)

#1863Discrete Cosine Transform (DCT-II)

Real-valued energy-compacting transform used in audio and image coding. — see #635 (e.math.fft.dct)

#1864Modified Discrete Cosine Transform (MDCT)

Lapped transform with perfect reconstruction used in AAC and Opus. — e.math.fft.mdct

#1865Cepstrum Computation

Inverse FFT of the log spectrum separating source from filter. — e.dsp.cepstrum

#1866Linear Predictive Coding (LPC)

Modeling each sample as a linear combination of previous samples. — e.dsp.lpc

#1867Levinson-Durbin Recursion

Solving the Toeplitz normal equations of LPC in O(p²). — e.dsp.levinson_durbin

#1868Autocorrelation Pitch Detection

Finding the lag of the first strong autocorrelation peak. — e.audio.analysis.pitch_autocorrelation

#1869Harmonic Product Spectrum

Multiplying downsampled spectra so the fundamental reinforces itself. — e.audio.analysis.pitch_hps

#1870pYIN Probabilistic Pitch Tracking

Combining YIN candidates with an HMM for smooth pitch contours. — e.audio.analysis.pitch_pyin

#1871Phase Vocoder Time Stretching

Changing duration without pitch by rescaling phase advances between frames. — e.audio.fx.time_stretch

#1872Pitch Shifting by Resampling

Combining time stretch with playback-rate change to alter pitch. — e.audio.fx.pitch_shift

#1873PSOLA (Pitch-Synchronous Overlap-Add)

Shifting pitch by repositioning pitch-period grains. — e.audio.fx.psola

#1874Onset Detection (Spectral Flux)

Flagging beats where positive spectral change exceeds a threshold. — e.audio.analysis.onsets

#1875Beat Tracking (Dynamic Programming)

Choosing beat times that maximize onset strength and tempo regularity. — e.audio.analysis.beats

#1876Tempo Estimation (Autocorrelation of Onset Envelope)

Finding the dominant periodicity of onset strength. — e.audio.analysis.tempo

#1877Chroma Feature Extraction

Folding spectral energy into twelve pitch classes. — e.audio.analysis.chroma

#1878Dynamic Time Warping for Audio Alignment

Aligning two feature sequences with a monotone warping path. — see #805 (e.dsp.dtw)

#1879Spectral Subtraction Noise Reduction

Removing an estimated noise spectrum from each frame's magnitude. — e.dsp.spectral_subtract

#1880Wiener Filter Denoising

Scaling each frequency bin by its estimated signal-to-noise ratio. — e.dsp.wiener

#1881Adaptive LMS Filter

Updating filter taps by stochastic gradient to track a reference signal. — e.dsp.lms

#1882Normalized LMS (NLMS)

Step size scaled by input power for stable convergence. — e.dsp.nlms

#1883Recursive Least Squares (RLS) Filter

Exponentially weighted least-squares tap updates with fast convergence. — e.dsp.rls

#1884Acoustic Echo Cancellation

Subtracting an adaptively filtered far-end signal from the microphone input. — e.audio.fx.echo_cancel

#1885Voice Activity Detection (Energy + Zero-Crossing)

Classifying frames as speech or silence from simple features. — e.audio.analysis.voice_activity

#1886Dynamic Range Compressor

Reducing gain above a threshold with attack and release smoothing. — e.audio.fx.compressor

#1887Lookahead Limiter

Delaying the signal so gain can drop before a peak arrives. — e.audio.fx.limiter

#1888Noise Gate

Muting the signal while its level stays below a threshold. — e.audio.fx.gate

#1889Parametric Equalizer

Cascading peaking and shelving biquads with adjustable center, gain, and Q. — e.audio.fx.equalizer

#1890Schroeder Reverberator

Combining parallel comb filters with series all-pass filters. — e.audio.fx.reverb_schroeder

#1891Feedback Delay Network Reverb

Mixing several delay lines through an orthogonal feedback matrix. — e.audio.fx.reverb_fdn

#1892Convolution Reverb (Partitioned FFT)

Applying a long impulse response in uniform frequency-domain blocks. — e.audio.fx.reverb_convolution

#1893Karplus-Strong String Synthesis

Feeding a short noise burst through a delay line with a low-pass loop. — e.audio.synth.karplus_strong

#1894Wavetable Synthesis

Reading a stored single-cycle waveform at a rate set by the desired pitch. — e.audio.synth.wavetable

#1895Band-Limited Oscillator (PolyBLEP)

Correcting discontinuities in saw and square waves to suppress aliasing. — e.audio.synth.oscillator_polyblep

#1896ADSR Envelope Generator

Shaping amplitude through attack, decay, sustain, and release stages. — e.audio.synth.adsr

#1897Sample Rate Conversion (Polyphase)

Interpolating and decimating with a filter split into subfilters. — e.dsp.resample_polyphase

#1898Sinc Interpolation Resampling

Reconstructing the band-limited signal between samples. — e.dsp.resample_sinc

#1899Dither with Noise Shaping

Adding shaped noise before quantization to push error out of audible bands. — e.audio.dither

#1900Loudness Measurement (ITU-R BS.1770)

K-weighted gated mean-square loudness in LUFS. — e.audio.analysis.loudness_lufs

34. Probability, Statistics & Sampling (1901–1950)

#1901Welford's Online Variance

Numerically stable running mean and variance in one pass. — e.algo.stat.moments_add

#1902Parallel Variance Merge (Chan's Algorithm)

Combining mean and M2 from disjoint partitions. — e.algo.stat.moments_merge

#1903Exponentially Weighted Moving Average

Smoothing a series with geometrically decaying weights. — see #795 (e.dsp.ema)

#1904Kahan-Compensated Mean

Summing with error compensation before dividing. — e.algo.stat.mean_compensated

#1905Sample Skewness and Kurtosis

Third and fourth standardized central moments. — e.algo.stat.skewness

#1906Pearson Correlation Coefficient

Normalized covariance measuring linear association. — e.algo.stat.correlation_pearson

#1907Spearman Rank Correlation

Pearson correlation applied to ranks. — e.algo.stat.correlation_spearman

#1908Kendall's Tau

Concordant minus discordant pair fraction, computed in O(n log n) with a Fenwick tree. — e.algo.stat.correlation_kendall

#1909Covariance Matrix Estimation

Averaging outer products of centered observations. — e.algo.stat.covariance_matrix

#1910Ledoit-Wolf Shrinkage

Shrinking a sample covariance toward a structured target with an optimal weight. — e.algo.stat.covariance_shrink

#1911Student's t-Test

Comparing means under unknown variance using the t distribution. — e.algo.stat.test.t_test

#1912Welch's t-Test

Two-sample t-test without assuming equal variances. — e.algo.stat.test.welch

#1913Mann-Whitney U Test

Rank-sum test for a difference between two distributions. — e.algo.stat.test.mann_whitney

#1914Wilcoxon Signed-Rank Test

Paired nonparametric test on signed rank sums. — e.algo.stat.test.wilcoxon

#1915Chi-Squared Goodness-of-Fit Test

Comparing observed and expected category counts. — e.algo.stat.test.chi_squared

#1916Fisher's Exact Test

Hypergeometric p-value for 2×2 contingency tables. — e.algo.stat.test.fisher_exact

#1917Kolmogorov-Smirnov Test

Maximum distance between empirical and reference CDFs. — e.algo.stat.test.ks

#1918Anderson-Darling Test

CDF distance test weighting the tails more heavily. — e.algo.stat.test.anderson_darling

#1919Shapiro-Wilk Normality Test

Correlating ordered sample values with normal order statistics. — e.algo.stat.test.shapiro_wilk

#1920One-Way ANOVA

Comparing group means by partitioning variance between and within groups. — e.algo.stat.test.anova

#1921Kruskal-Wallis Test

Rank-based ANOVA across three or more groups. — e.algo.stat.test.kruskal_wallis

#1922Benjamini-Hochberg Procedure

Controlling the false discovery rate over many p-values. — e.algo.stat.test.benjamini_hochberg

#1923Bonferroni Correction

Dividing the significance level by the number of tests. — e.algo.stat.test.bonferroni

#1924Bootstrap Confidence Interval

Resampling with replacement to estimate an estimator's distribution. — e.algo.stat.bootstrap

#1925Jackknife Estimator

Leave-one-out resampling for bias and variance estimates. — e.algo.stat.jackknife

#1926Permutation Test

Building the null distribution by shuffling labels. — e.algo.stat.test.permutation

#1927Wilson Score Interval

Binomial proportion confidence interval well-behaved at small counts. — e.algo.stat.interval_wilson

#1928Clopper-Pearson Interval

Exact binomial interval from beta quantiles. — e.algo.stat.interval_clopper_pearson

#1929Kernel Density Estimation

Smoothing sample points with a bandwidth-scaled kernel. — e.algo.stat.kde

#1930Silverman's Bandwidth Rule

Rule-of-thumb kernel bandwidth from sample standard deviation and size. — e.algo.stat.kde_bandwidth

#1931Maximum Likelihood Estimation (Newton)

Maximizing log-likelihood with gradient and Hessian steps. — e.algo.stat.fit_mle

#1932Method of Moments Estimation

Matching sample moments to distribution moments. — e.algo.stat.fit_moments

#1933Expectation-Maximization for Mixtures

Alternating responsibility and parameter updates for a mixture model. — see #731 (e.ml.cluster.gmm_em)

#1934Box-Muller Transform

Generating standard normals from two uniforms. — e.algo.rand.dist.normal_box_muller

#1935Marsaglia Polar Method

Rejection-based normal generation without trigonometric functions. — e.algo.rand.dist.normal_polar

#1936Ziggurat Algorithm

Fast normal or exponential sampling from stacked rectangular layers. — e.algo.rand.dist.normal

#1937Inverse Transform Sampling

Mapping a uniform through the quantile function. — e.algo.rand.dist.inverse_transform

#1938Rejection Sampling

Accepting proposals with probability proportional to the target-to-envelope ratio. — e.algo.rand.dist.rejection

#1939Importance Sampling

Weighting samples from a proposal by target-to-proposal density ratio. — e.algo.rand.dist.importance_weights

#1940Poisson Sampling (Knuth)

Multiplying uniforms until the product drops below e^(−λ). — e.algo.rand.dist.poisson

#1941Binomial Sampling (BTPE)

Efficient generation for large n via a triangle-parallelogram-exponential envelope. — e.algo.rand.dist.binomial

#1942Gamma Sampling (Marsaglia-Tsang)

Squeeze-based rejection for shape parameter ≥ 1. — e.algo.rand.dist.gamma

#1943Beta Sampling via Gammas

Normalizing two gamma variates. — e.algo.rand.dist.beta

#1944Dirichlet Sampling

Normalizing a vector of gamma variates by their sum. — e.algo.rand.dist.dirichlet

#1945Multivariate Normal Sampling (Cholesky)

Transforming standard normals by the covariance's Cholesky factor. — e.algo.rand.dist.multivariate_normal

#1946Stratified Sampling

Drawing from each stratum in proportion to its size to reduce variance. — e.algo.rand.stratified

#1947Latin Hypercube Sampling

Placing one sample per row and column of a stratified grid. — e.algo.rand.latin_hypercube

#1948Sobol Sequence Generation

Low-discrepancy quasi-random points from direction numbers. — e.algo.rand.quasi.sobol

#1949Halton Sequence Generation

Radical-inverse quasi-random sequences in coprime bases. — e.algo.rand.quasi.halton

#1950Weighted Reservoir Sampling (Efraimidis-Spirakis)

Keeping the k items with the largest u^(1/w) keys. — see #982 (e.algo.rand.reservoir_weighted)

35. Constraint Solving, SAT/SMT & Combinatorial Search (1951–2000)

#1951DPLL Algorithm

Backtracking SAT search with unit propagation and pure-literal elimination. — skip: an implementation detail of an existing module, not an API

#1952Conflict-Driven Clause Learning (CDCL)

Learning clauses from conflicts and backjumping non-chronologically. — e.algo.sat.solve

#1953Two-Watched-Literal Scheme

Tracking two literals per clause to make unit propagation cheap. — skip: an implementation detail of an existing module, not an API

#1954First-UIP Conflict Analysis

Cutting the implication graph at the first unique implication point. — skip: an implementation detail of an existing module, not an API

#1955VSIDS Variable Ordering

Bumping and decaying activity scores to pick decision variables. — skip: an implementation detail of an existing module, not an API

#1956Phase Saving

Reusing the last assigned polarity when re-deciding a variable. — skip: an implementation detail of an existing module, not an API

#1957Luby Restart Schedule

Restarting search at intervals following the Luby sequence. — skip: an implementation detail of an existing module, not an API

#1958Clause Database Reduction (LBD)

Deleting learned clauses with high literal block distance. — skip: an implementation detail of an existing module, not an API

#1959Bounded Variable Elimination

Preprocessing by resolving out variables that shrink the formula. — e.algo.sat.preprocess

#1960WalkSAT Local Search

Flipping variables in unsatisfied clauses with noise-guided choice. — e.algo.sat.walksat

#1961Tseitin Transformation

Converting an arbitrary circuit to equisatisfiable CNF in linear size. — e.algo.sat.tseitin

#1962Cardinality Constraint Encoding (Sequential Counter)

Encoding at-most-k with auxiliary variables. — e.algo.sat.encode_at_most

#1963Pseudo-Boolean to CNF (BDD Encoding)

Compiling linear constraints through a binary decision diagram. — e.algo.sat.encode_pseudo_boolean

#1964DPLL(T)

Integrating theory solvers with SAT search for satisfiability modulo theories. — skip: research-grade, no settled practical implementation

#1965Nelson-Oppen Theory Combination

Sharing equalities between disjoint theory solvers. — skip: research-grade, no settled practical implementation

#1966Congruence Closure

Deciding equality with uninterpreted functions via union-find on terms. — e.algo.smt.congruence_closure

#1967Simplex for Linear Real Arithmetic (Dutertre-de Moura)

Bounds-based simplex tailored to SMT backtracking. — skip: research-grade, no settled practical implementation

#1968Bit-Blasting

Reducing bit-vector formulas to propositional circuits. — e.algo.smt.bit_blast

#1969Model-Based Quantifier Instantiation

Instantiating quantifiers with terms drawn from candidate models. — skip: research-grade, no settled practical implementation

#1970E-Graph Equality Saturation

Applying rewrite rules to all equivalent terms without losing any. — e.algo.egraph.saturate

#1971AC-3 Arc Consistency

Pruning domain values lacking support in binary constraints. — e.algo.csp.ac3

#1972AC-4 Arc Consistency

Support counting for arc consistency in optimal worst-case time. — e.algo.csp.ac2001

#1973Maintaining Arc Consistency (MAC)

Re-establishing arc consistency after each search assignment. — e.algo.csp.solve

#1974Forward Checking

Removing conflicting values from future variables after each assignment. — skip: an implementation detail of an existing module, not an API

#1975Minimum Remaining Values Heuristic

Choosing the variable with the fewest legal values. — skip: an implementation detail of an existing module, not an API

#1976Least Constraining Value Heuristic

Trying the value that rules out the fewest options for neighbors. — skip: an implementation detail of an existing module, not an API

#1977Conflict-Directed Backjumping

Returning to the most recent variable involved in the conflict. — skip: an implementation detail of an existing module, not an API

#1978Nogood Recording

Storing partial assignments proven inconsistent to prune later search. — skip: an implementation detail of an existing module, not an API

#1979Global Constraint AllDifferent (Régin)

Bipartite matching based filtering for all-different constraints. — e.algo.csp.all_different

#1980Global Cardinality Constraint Filtering

Flow-based pruning of value occurrence bounds. — e.algo.csp.global_cardinality

#1981Cumulative Constraint (Time-Table)

Enforcing resource capacity over scheduled task intervals. — e.algo.csp.cumulative

#1982Element Constraint Propagation

Linking an index variable to an array lookup result. — e.algo.csp.element

#1983Table Constraint (Compact-Table)

Bitset-based filtering over explicit tuple lists. — e.algo.csp.table

#1984Large Neighborhood Search

Repeatedly freeing part of a solution and re-solving it. — e.algo.combopt.large_neighborhood_search

#1985Limited Discrepancy Search

Exploring paths in order of how often they disobey the heuristic. — e.algo.csp.limited_discrepancy

#1986Branch and Bound

Pruning subtrees whose bound cannot beat the incumbent. — e.algo.combopt.branch_and_bound

#1987Branch and Cut

Adding violated cutting planes to LP relaxations within branch and bound. — e.math.opt.milp.solve

#1988Gomory Cut Generation

Deriving integer cuts from fractional simplex rows. — see #1987 (e.math.opt.milp.solve)

#1989Lagrangian Relaxation

Moving hard constraints into the objective with multipliers and solving the dual. — skip: implementable, but too specialised for the standard library

#1990Column Generation

Pricing new variables into a restricted master problem. — skip: implementable, but too specialised for the standard library

#1991Dantzig-Wolfe Decomposition

Reformulating block-structured programs with convex combinations of extreme points. — skip: implementable, but too specialised for the standard library

#1992Benders Decomposition

Splitting a problem into a master and subproblem linked by optimality cuts. — skip: implementable, but too specialised for the standard library

#1993Hungarian Method on Rectangular Costs

Padding to square and solving assignment with dummy rows. — see #79 (e.algo.graph.match.hungarian)

#1994Held-Karp TSP Dynamic Programming

Exact traveling salesman over subsets in O(n² 2ⁿ). — see #115 (e.algo.combopt.tsp_held_karp)

#1995Nearest Neighbor Tour Construction

Building a TSP tour by always visiting the closest unvisited city. — e.algo.combopt.tsp_nearest_neighbor

#19962-opt / Or-opt Local Search

Reversing or relocating tour segments to shorten a route. — see #116 (e.algo.combopt.tsp_two_opt)

#1997Vehicle Routing (Clarke-Wright Savings)

Merging routes in order of the largest distance saving. — e.algo.combopt.vrp_savings

#1998Knapsack Branch and Bound

Fractional-knapsack bounds pruning the 0/1 search. — e.algo.combopt.knapsack_branch_and_bound

#1999Bin Packing First Fit Decreasing

Placing items largest-first into the first bin with room. — e.algo.combopt.bin_pack_ffd

#2000Job Shop Scheduling (Shifting Bottleneck)

Sequencing one machine at a time using one-machine subproblems. — skip: implementable, but too specialised for the standard library

36. Computational Geometry, Meshes & CAD (2001–2050)

#2001Orientation Predicate (Exact)

Sign of a 2×2 determinant with adaptive precision arithmetic. — e.algo.geom.orient

#2002In-Circle Predicate

Testing whether a point lies inside the circumcircle of a triangle. — e.algo.geom.in_circle

#2003Segment Intersection Test

Combining orientation tests to decide if two segments cross. — see #538 (e.algo.geom.segments_intersect)

#2004Bentley-Ottmann Sweep

Reporting all segment intersections in O((n+k) log n). — see #528 (e.algo.geom.segment_intersections)

#2005Point in Polygon (Ray Casting)

Counting edge crossings of a ray from the point. — see #521 (e.algo.geom.point_in_polygon)

#2006Point in Polygon (Winding Number)

Summing signed angle contributions of edges. — see #532 (e.algo.geom.winding_number)

#2007Polygon Triangulation (Ear Clipping)

Removing convex ears until three vertices remain. — see #533 (e.algo.geom.clip.triangulate_ear_clip)

#2008Polygon Triangulation (Monotone Decomposition)

Splitting into y-monotone pieces and triangulating each in linear time. — e.algo.geom.triangulate_monotone

#2009Delaunay Triangulation (Bowyer-Watson)

Inserting points and re-triangulating the cavity of violated triangles. — see #530 (e.algo.geom.delaunay)

#2010Delaunay Triangulation (Divide and Conquer)

Merging half triangulations with a rising bubble. — skip: implementable, but too specialised for the standard library

#2011Constrained Delaunay Triangulation

Forcing required edges while keeping the Delaunay property elsewhere. — e.algo.geom.delaunay_constrained

#2012Voronoi Diagram (Fortune's Sweep)

Beach-line sweep producing Voronoi cells in O(n log n). — see #529 (e.algo.geom.voronoi)

#2013Voronoi from Delaunay Dual

Connecting circumcenters of adjacent Delaunay triangles. — e.algo.geom.voronoi_from_delaunay

#2014Lloyd's Relaxation

Moving sites to Voronoi cell centroids to even out a distribution. — e.algo.geom.lloyd_relax

#2015Convex Hull 3D (Quickhull)

Recursively adding the farthest point outside each face. — e.algo.geom3.hull

#2016Convex Hull 3D (Incremental)

Adding points one at a time and re-stitching the horizon. — skip: implementable, but too specialised for the standard library

#2017Minkowski Sum of Convex Polygons

Merging edge sequences by angle. — e.algo.geom.minkowski_sum

#2018Polygon Clipping (Sutherland-Hodgman)

Clipping a polygon against each edge of a convex window. — see #534 (e.algo.geom.clip.clip_convex)

#2019Polygon Clipping (Weiler-Atherton)

Clipping arbitrary polygons by walking intersection points. — see #535 (e.algo.geom.clip_polygon)

#2020Polygon Boolean Operations (Greiner-Hormann)

Union, intersection, and difference via intersection-marked vertex lists. — e.algo.geom.polygon_boolean

#2021Polygon Offsetting (Vatti / Clipper)

Insetting or outsetting a polygon by a fixed distance. — e.algo.geom.polygon_offset

#2022Line Simplification (Douglas-Peucker)

Dropping points closer than a tolerance to the chord. — see #557 (e.algo.geom.clip.simplify_douglas_peucker)

#2023Line Simplification (Visvalingam-Whyatt)

Removing points of least effective area. — see #558 (e.algo.geom.clip.simplify_visvalingam)

#2024Farthest Pair (Diameter via Calipers)

Antipodal-pair scan of a convex hull for the maximum distance. — see #542 (e.algo.geom.farthest_pair)

#2025Smallest Enclosing Circle (Welzl)

Randomized incremental minimum enclosing disk. — see #539 (e.algo.geom.enclosing_circle)

#2026Minimum Bounding Rectangle (Rotating Calipers)

Smallest-area oriented box around a convex hull. — e.algo.geom.min_bounding_rect

#2027Largest Empty Circle

Finding the Voronoi vertex farthest from all sites. — e.algo.geom.largest_empty_circle

#2028k-d Tree Nearest Neighbor

Branch-and-bound descent with sibling pruning by split distance. — see #222 (e.data.spatial.kd_nearest)

#2029Ball Tree Nearest Neighbor

Hierarchical enclosing spheres pruning by triangle inequality. — e.data.spatial.ball_tree_nearest

#2030Half-Edge Mesh Data Structure

Storing each edge twice with next, twin, and face pointers. — e.gfx.mesh.half_edge

#2031Edge Collapse Decimation (Garland-Heckbert)

Contracting edges by minimum quadric error. — see #1148 (e.gfx.mesh.decimate)

#2032Loop Subdivision

Refining triangle meshes with weighted vertex and edge rules. — e.gfx.mesh.subdivide_loop

#2033Catmull-Clark Subdivision

Refining quad meshes toward a bicubic B-spline limit surface. — e.gfx.mesh.subdivide_catmull_clark

#2034Laplacian Mesh Smoothing

Moving each vertex toward the average of its neighbors. — e.gfx.mesh.smooth_laplacian

#2035Taubin Smoothing

Alternating positive and negative Laplacian steps to avoid shrinkage. — e.gfx.mesh.smooth_taubin

#2036Mesh Parameterization (Least Squares Conformal Maps)

Flattening a mesh to 2D minimizing angle distortion. — e.gfx.mesh.parameterize_lscm

#2037Geodesic Distance (Fast Marching on Meshes)

Propagating distances across triangles with an update rule. — e.gfx.mesh.geodesic_fast_marching

#2038Heat Method for Geodesics

Diffusing heat then solving a Poisson equation for distance. — e.gfx.mesh.geodesic_heat

#2039Mesh Boolean via BSP Trees

Classifying polygons against a binary space partition of the other solid. — e.gfx.mesh.boolean_bsp

#2040Point Cloud Normal Estimation (PCA)

Fitting a plane to each point's neighborhood. — e.gfx.mesh.estimate_normals

#2041Poisson Surface Reconstruction

Solving for an indicator function whose gradient matches oriented normals. — e.gfx.mesh.reconstruct_poisson

#2042Ball-Pivoting Surface Reconstruction

Rolling a ball over points to grow triangles. — e.gfx.mesh.reconstruct_ball_pivot

#2043Dual Contouring

Placing one vertex per cell from Hermite data to preserve sharp features. — e.gfx.mesh.dual_contouring

#2044Signed Distance Field from Mesh

Computing distance to the closest triangle with a sign from pseudonormals. — e.gfx.mesh.signed_distance

#2045Ray-Sphere Intersection

Solving the quadratic from substituting the ray into the sphere equation. — e.algo.geom3.ray_sphere

#2046Ray-Plane and Ray-Disk Intersection

Solving for the parameter where the ray meets a plane, then bounding by radius. — e.algo.geom3.ray_plane

#2047Bezier Curve Evaluation (De Casteljau)

Repeated linear interpolation of control points. — see #555 (e.gfx.curve.bezier)

#2048B-Spline Evaluation (De Boor)

Local recursive evaluation using the knot vector. — see #554 (e.gfx.curve.bspline)

#2049Surface of Revolution Generation

Sweeping a profile curve around an axis into a mesh. — e.gfx.mesh.revolve

#2050Constructive Solid Geometry Ray Evaluation

Combining interval hits along a ray with set operations. — e.gfx.trace.csg

37. Text Encoding, Serialization & Data Formats (2051–2100)

#2051Base32 Encoding

Mapping five-bit groups to a 32-character alphabet. — e.bytes.base32_encode

#2052Base58 Encoding

Big-number base conversion excluding ambiguous characters. — e.bytes.base58_encode

#2053Base85 (Ascii85) Encoding

Encoding four bytes as five printable characters. — see #321 (e.bytes.base85_encode)

#2054Quoted-Printable Encoding

Escaping non-ASCII bytes as =XX for 7-bit transports. — e.fmt.quoted_printable.encode

#2055Punycode Encoding

Representing Unicode domain labels in ASCII with a generalized variable-length integer scheme. — e.net.idna.punycode_encode

#2056Percent-Encoding

Escaping reserved URL bytes as %XX. — see #322 (e.fmt.uri.percent_encode)

#2057UTF-8 Validation (DFA)

Checking well-formedness with a table-driven state machine. — e.text.utf8.validate

#2058UTF-8 Validation (SIMD)

Vectorized lookup-based checking of continuation patterns. — e.text.utf8.validate

#2059UTF-16 to UTF-8 Transcoding

Decoding surrogate pairs and re-encoding as 1–4 bytes. — e.text.encoding.to_utf8

#2060Unicode Normalization (NFC / NFD)

Composing or decomposing characters with canonical ordering. — see #325 (e.text.normalize.normalize)

#2061Unicode Case Folding

Mapping characters to a case-insensitive comparison form. — e.text.unicode.casefold

#2062Unicode Grapheme Cluster Segmentation

Splitting text at user-perceived character boundaries. — e.text.unicode.graphemes

#2063Unicode Word Segmentation (UAX #29)

Finding word boundaries from character properties. — e.text.segment.words

#2064Unicode Line Breaking (UAX #14)

Finding permitted line-break opportunities. — e.text.segment.line_breaks

#2065Bidirectional Text Algorithm (UAX #9)

Resolving embedding levels and reordering mixed-direction runs. — e.text.bidi.reorder

#2066Unicode Collation Algorithm

Comparing strings by multi-level collation element weights. — e.text.collate.compare

#2067Byte Order Mark Detection

Sniffing UTF-8, UTF-16, and UTF-32 from leading bytes. — see #327 (e.text.encoding.detect_bom)

#2068Charset Detection (n-gram statistics)

Guessing a legacy encoding from byte frequency profiles. — e.text.encoding.detect

#2069Code Page Transcoding (Table Lookup)

Mapping single-byte encodings to and from Unicode. — e.text.encoding.to_utf8

#2070CSV Parsing (RFC 4180)

Handling quoted fields, escaped quotes, and embedded newlines. — see #966 (e.fmt.csv.reader)

#2071TSV / Delimited Writer with Quoting

Emitting fields with minimal quoting rules. — e.fmt.csv.writer

#2072JSON Serializer with Escaping

Emitting strings with control-character and Unicode escapes. — e.fmt.json.write

#2073JSON Pointer Resolution

Walking a document by a /a/0/b path with ~0 and ~1 unescaping. — e.fmt.json.pointer

#2074JSON Patch Application

Applying add, remove, replace, move, copy, and test operations. — e.fmt.json.patch

#2075JSON Merge Patch

Recursively merging objects with null meaning delete. — e.fmt.json.merge_patch

#2076JSON Schema Validation

Checking a document against type, property, and constraint keywords. — e.fmt.json.schema.validate

#2077JSON Canonicalization (RFC 8785)

Producing a deterministic byte form for hashing and signing. — e.fmt.json.canonicalize

#2078Streaming JSON Tokenizer (SAX-style)

Emitting events without building the full tree. — e.fmt.json.tokenizer

#2079XML Tokenizer

Lexing tags, attributes, entities, and CDATA sections. — see #344 (e.fmt.xml.stream)

#2080XML Namespace Resolution

Mapping prefixes to URIs through scoped declarations. — e.fmt.xml.namespaces

#2081XPath Evaluation

Walking axes and predicates over a document tree. — e.fmt.xml.xpath

#2082XSLT Template Matching

Applying the highest-priority matching template to each node. — skip: implementable, but too specialised for the standard library

#2083YAML Block Scalar Parsing

Handling literal and folded multi-line strings with indentation rules. — e.fmt.yaml.parse

#2084TOML Parser

Parsing tables, arrays of tables, and dotted keys. — e.fmt.toml.parse

#2085INI Parser with Sections

Reading key-value pairs grouped by [section] headers. — e.fmt.ini.parse

#2086Protocol Buffers Wire Decoding

Reading tag-length-value fields keyed by field number and wire type. — e.fmt.protobuf.decode

#2087FlatBuffers Zero-Copy Access

Reading fields through vtable offsets without deserialization. — e.fmt.flatbuffers.get

#2088Cap'n Proto Pointer Encoding

Locating structs and lists through segment-relative pointers. — skip: implementable, but too specialised for the standard library

#2089MessagePack Encoding

Compact binary tagging of maps, arrays, strings, and integers. — e.fmt.msgpack.encode

#2090CBOR Encoding

Concise binary object representation with major types and tags. — e.fmt.cbor.encode

#2091ASN.1 DER Encoding

Distinguished tag-length-value encoding used by X.509. — e.fmt.asn1.der_encode

#2092ASN.1 BER Decoding

Handling indefinite-length and constructed encodings. — e.fmt.asn1.ber_decode

#2093BSON Encoding

Binary JSON with typed fields and length prefixes. — e.fmt.bson.encode

#2094Avro Schema Resolution

Reconciling writer and reader schemas during decoding. — e.fmt.avro.resolve

#2095Apache Arrow Columnar Layout

Validity bitmaps plus offset and data buffers per column. — e.fmt.arrow.columns

#2096Parquet Page Encoding (RLE / Bit-Packing)

Hybrid run-length and bit-packed encoding of levels and values. — e.fmt.parquet.decode_page

#2097Delta Encoding of Integers

Storing successive differences to shrink monotone sequences. — see #627 (e.algo.coding.delta_encode)

#2098Frame-of-Reference Encoding

Storing offsets from a block minimum in fixed bit widths. — see #628 (e.algo.coding.for_encode)

#2099Simple8b Integer Packing

Packing runs of small integers into 64-bit words by selector. — e.algo.coding.simple8b_encode

#2100Dictionary Encoding

Replacing repeated values with indices into a value table. — e.algo.coding.dictionary_encode

38. Web Browsers, Frontend & UI Algorithms (2101–2150)

#2101HTML Tokenizer (WHATWG)

State-machine tokenization with insertion-mode recovery rules. — e.fmt.html.tokenize

#2102HTML Tree Construction

Building the DOM from tokens with the adoption agency algorithm. — e.fmt.html.parse

#2103CSS Selector Matching

Matching right-to-left through compound selectors and combinators. — e.fmt.css.select

#2104CSS Cascade and Specificity Resolution

Ordering declarations by origin, specificity, and source order. — e.fmt.css.cascade

#2105CSS Inheritance and Computed Values

Resolving relative units and inherited properties per element. — e.ui.style.resolve

#2106Style Invalidation (Descendant Invalidation Sets)

Restyling only subtrees affected by a class or attribute change. — skip: an implementation detail of an existing module, not an API

#2107Block Layout (Normal Flow)

Stacking block boxes vertically with margin collapsing. — e.ui.layout.flow

#2108Inline Layout and Line Breaking

Packing inline boxes into line boxes with baseline alignment. — e.text.layout.layout

#2109Flexbox Layout Algorithm

Distributing free space along the main axis with grow and shrink factors. — e.ui.layout.flex

#2110CSS Grid Layout (Track Sizing)

Resolving track sizes through intrinsic, flexible, and auto phases. — e.ui.layout.grid

#2111Table Layout (Automatic Algorithm)

Computing column widths from cell minimum and maximum widths. — e.ui.layout.table

#2112Stacking Context Painting Order

Painting layers by z-index in the order the specification defines. — e.gfx.scene.paint_order

#2113Compositing Layer Assignment

Promoting elements to GPU layers and squashing overlapping ones. — skip: an implementation detail of an existing module, not an API

#2114Display List Rasterization

Recording paint commands then rasterizing tiles on worker threads. — e.gfx.scene.rasterize

#2115Damage Rectangle Tracking

Repainting only regions invalidated since the last frame. — e.ui.window.damage

#2116Hit Testing

Finding the topmost element under a point through the layer and box trees. — e.ui.widget.hit_test

#2117Scroll Anchoring

Keeping the visible content stable while offscreen content changes size. — e.ui.widget.scroll_anchor

#2118Virtual DOM Diffing

Comparing two element trees and emitting minimal patch operations. — skip: an implementation detail of an existing module, not an API

#2119Keyed List Reconciliation

Matching children by key to move nodes instead of recreating them. — e.ui.widget.reconcile_keyed

#2120Fiber Scheduling with Time Slicing

Splitting rendering work into interruptible units by priority. — skip: an implementation detail of an existing module, not an API

#2121Fine-Grained Reactivity (Signals)

Tracking dependencies at read time and re-running only affected effects. — e.ui.state.signal

#2122Topological Effect Scheduling

Running derived computations in dependency order to avoid glitches. — e.ui.state.schedule_effects

#2123Immutable Structural Sharing Updates

Copying only the path to a changed node in a persistent tree. — see #1084 (e.data.hamt.put)

#2124Memoized Selector Computation

Recomputing derived state only when input references change. — e.ui.state.memo

#2125Undo/Redo Command Stack

Recording inverse operations for reversible edits. — e.ui.undo.push

#2126Operational Transformation

Transforming concurrent edits so they converge on all replicas. — see #1269 (e.text.collab.transform)

#2127CRDT Text Sequence (RGA / YATA)

Merging concurrent text edits with unique identifiers and tombstones. — e.text.collab.crdt_insert

#2128Fractional Indexing

Generating keys between two neighbors for orderable lists. — e.text.collab.order_key_between

#2129Debounce and Throttle

Limiting handler frequency by delaying or rate-capping invocations. — e.ui.app.debounce

#2130Request Animation Frame Scheduling

Aligning visual updates to the display refresh. — e.ui.app.request_frame

#2131Idle Callback Scheduling

Running low-priority work in frame slack time. — e.ui.app.request_idle

#2132Intersection-Based Lazy Loading

Deferring resource loads until elements near the viewport. — e.ui.widget.lazy_load

#2133Windowed List Virtualization

Rendering only the rows intersecting the scroll viewport. — e.ui.widget.virtual_list

#2134Text Measurement and Ellipsis Truncation

Fitting text to a width with binary search over characters. — see #365 (e.text.layout.ellipsis)

#2135Font Fallback Resolution

Choosing fonts per character run by coverage. — e.text.shape.fallback_font

#2136Text Shaping (HarfBuzz-style)

Applying OpenType substitution and positioning to glyph runs. — e.text.shape.shape

#2137Line Breaking (Knuth-Plass)

Choosing break points minimizing total badness over a paragraph. — see #360 (e.text.wrap.optimal)

#2138Hyphenation (Liang's Algorithm)

Finding break points from pattern-derived odd/even digit rules. — e.text.hyphen.break_points

#2139Subpixel Text Rendering

Filtering glyph coverage across RGB subpixels. — e.gfx.paint.glyph_subpixel

#2140Signed Distance Field Font Rendering

Rendering scalable glyphs from a distance texture. — e.gfx.paint.glyph_sdf

#2141Color Space Conversion (sRGB ↔ Linear)

Applying the transfer function before and after blending. — e.gfx.paint.srgb_to_linear

#2142Alpha Compositing (Porter-Duff)

Combining premultiplied colors with the over operator. — e.gfx.paint.composite

#2143Bezier Path Flattening

Subdividing curves into line segments within a tolerance. — e.gfx.geometry.flatten

#2144Nonzero and Even-Odd Fill Rules

Deciding path interiors from winding counts. — e.gfx.paint.fill_rule

#2145Scanline Polygon Rasterization with Coverage

Accumulating fractional coverage for antialiased fills. — e.gfx.paint.fill_path

#2146Stroke Geometry Generation

Offsetting paths with joins and caps into fill geometry. — e.gfx.geometry.stroke

#2147Gradient Rasterization

Mapping pixels to color stops along linear or radial parameters. — e.gfx.paint.gradient

#2148Focus Order Traversal

Ordering focusable elements by tabindex and document position. — e.ui.accessibility.focus_order

#2149Accessibility Tree Construction

Deriving roles, names, and states from DOM and ARIA attributes. — e.ui.accessibility.tree

#2150Prefetch and Preload Prioritization

Scheduling resource fetches by predicted need and render blocking. — skip: implementable, but too specialised for the standard library

39. Streaming, Sketches & Approximate Algorithms (2151–2200)

#2151Sticky Sampling

Probabilistic frequency tracking with a sampling rate that decreases as the stream grows. — skip: implementable, but too specialised for the standard library

#2152Top-k via Count-Min plus Min-Heap

Maintaining candidate heavy hitters keyed by sketch estimates. — e.algo.sketch.top_k

#2153Lossy Counting

Bucketed frequency estimates with periodic pruning of low counts. — e.algo.sketch.lossy_counting

#2154Count Sketch

Hashed counters with random signs for unbiased frequency estimates. — e.algo.sketch.count_sketch

#2155AMS Sketch (F2 Estimation)

Estimating the second frequency moment with ±1 hash projections. — e.algo.sketch.ams_f2

#2156Flajolet-Martin Sketch

Estimating distinct counts from the maximum trailing-zero count. — see #981 (e.algo.sketch.flajolet_martin)

#2157LogLog / SuperLogLog

Bucketed maximum-rank estimators preceding HyperLogLog. — see #242 (e.algo.sketch.hll_estimate)

#2158HyperLogLog++

Sparse representation and bias correction for small cardinalities. — e.algo.sketch.hll_sparse

#2159HyperLogLog Merge

Taking the per-register maximum to union two sketches. — e.algo.sketch.hll_merge

#2160KMV (K Minimum Values) Sketch

Estimating cardinality from the k-th smallest hash. — e.algo.sketch.kmv

#2161Theta Sketch Set Operations

Union, intersection, and difference of sampled hash sets with thresholds. — e.algo.sketch.theta_union

#2162MinHash Signatures

Estimating Jaccard similarity from per-hash minimum values. — see #258 (e.algo.sketch.minhash)

#2163One-Permutation Hashing

Producing many MinHash values from a single hash pass. — e.algo.sketch.minhash_one_permutation

#2164b-Bit MinHash

Storing only the low bits of each minimum to shrink signatures. — e.algo.sketch.minhash_b_bit

#2165SimHash

Locality-sensitive fingerprinting where Hamming distance tracks cosine similarity. — see #259 (e.algo.sketch.simhash)

#2166Locality-Sensitive Hashing (Random Projection)

Bucketing vectors by the signs of random hyperplanes. — see #257 (e.algo.sketch.lsh_bucket)

#2167Locality-Sensitive Hashing (p-Stable)

Quantized random projections for Euclidean nearest neighbors. — e.algo.sketch.lsh_p_stable

#2168Morton Filter

Compressed cuckoo-style filter with block-local overflow tracking. — skip: implementable, but too specialised for the standard library

#2169Bloomier Filter

Static structure mapping keys to values with false positives only on non-keys. — skip: implementable, but too specialised for the standard library

#2170Ribbon Filter

Near-optimal space static filter built by solving a banded linear system. — e.algo.sketch.ribbon_filter

#2171Vacuum Filter

Cuckoo-style filter choosing alternate buckets nearby for cache locality. — skip: implementable, but too specialised for the standard library

#2172Counting Quotient Filter

Quotient filter variant with variable-length counters. — e.algo.sketch.counting_quotient_filter

#2173Stable Bloom Filter

Bloom filter with random decrements for unbounded streams. — e.algo.sketch.stable_bloom

#2174Age-Partitioned Bloom Filter

Sliding-window membership by rotating segment groups. — e.algo.sketch.bloom_windowed

#2175Greenwald-Khanna Quantiles

Deterministic quantile summary with tuple-based error bounds. — e.algo.sketch.gk_quantiles

#2176KLL Sketch

Compactor-based quantile sketch with near-optimal space. — see #1094 (e.algo.sketch.kll)

#2177UDDSketch

Uniform-collapse DDSketch variant keeping bounded relative error under merges. — see #1095 (e.algo.sketch.ddsketch)

#2178Frugal Streaming Median

One-counter streaming median estimate. — e.algo.sketch.frugal_median

#2179P² Algorithm

Quantile estimation with five parabolic-interpolated markers. — e.algo.sketch.p_square

#2180Exponential Histogram (Datar-Gionis)

Sliding-window counts with logarithmically merged buckets. — e.data.window.exponential_histogram

#2181Sliding HyperLogLog

Timestamped registers answering cardinality over recent windows. — e.algo.sketch.hll_sliding

#2182Sliding Window Sum (Two-Stack Queue)

Amortized O(1) aggregate over a moving window. — e.data.window.two_stack

#2183DABA Sliding Window Aggregation

Worst-case O(1) window aggregation without inverses. — e.data.window.daba

#2184Reservoir Sampling with Time Decay

Biasing retention toward recent items. — e.algo.rand.reservoir_decayed

#2185Priority Sampling

Order sampling with weight-derived priorities for subset-sum estimates. — e.algo.rand.priority_sample

#2186VarOpt Sampling

Variance-optimal weighted sampling for subset sums. — e.algo.rand.varopt_sample

#2187Bloom Filter Sizing

Choosing bits and hash count from target false-positive rate. — e.algo.sketch.bloom_size

#2188Kirsch-Mitzenmacher Double Hashing

Deriving k hash values from two base hashes. — skip: an implementation detail of an existing module, not an API

#2189Count-Min Point Query with Range Trees

Dyadic decomposition for range frequency estimates. — e.algo.sketch.count_min_range

#2190Sketch-Based Join Size Estimation

Estimating result cardinality from AMS sketch inner products. — e.db.query.estimate_join_size

#2191Streaming k-Means (Coreset Tree)

Merging weighted coresets to cluster an unbounded stream. — e.ml.cluster.kmeans_streaming

#2192BIRCH Clustering Feature Tree

Incremental clustering with summarized subclusters. — e.ml.cluster.birch

#2193Streaming PCA (Oja's Rule)

Updating a principal component with each arriving vector. — e.ml.reduce.pca_online

#2194Frequent Directions

Deterministic matrix sketch by shrinking singular values. — e.ml.reduce.frequent_directions

#2195Online Gradient Descent

Updating a model per example with a decaying step. — e.ml.optim.online_gd

#2196Adaptive Windowing (ADWIN)

Detecting concept drift by comparing subwindow means. — e.algo.timeseries.adwin

#2197CUSUM Change Detection

Accumulating deviations from a target to flag shifts. — e.algo.timeseries.cusum

#2198Page-Hinkley Test

Cumulative difference test for mean change in a stream. — e.algo.timeseries.page_hinkley

#2199Seasonal-Trend Decomposition (STL)

Splitting a series into trend, seasonal, and remainder by LOESS. — e.algo.timeseries.stl

#2200Holt-Winters Forecasting

Triple exponential smoothing with level, trend, and seasonality. — e.algo.timeseries.holt_winters

40. Testing, Reliability, Fuzzing & Software Engineering Tooling (2201–2250)

#2201Property-Based Testing Generators

Producing random structured inputs from combinator descriptions. — e.test.prop.generate

#2202Test Case Shrinking

Reducing a failing input to a minimal counterexample. — e.test.prop.shrink

#2203Delta Debugging (ddmin)

Bisecting an input to isolate the failure-inducing subset. — e.test.fuzz.minimize

#2204Hierarchical Delta Debugging

Minimizing tree-structured inputs level by level. — e.test.fuzz.minimize_tree

#2205Grammar-Based Fuzzing

Generating inputs by expanding a grammar with random productions. — e.test.fuzz.grammar

#2206Mutation-Based Fuzzing

Flipping, inserting, and splicing bytes of seed inputs. — see #1444 (e.test.fuzz.run)

#2207Concolic Execution

Running concretely while collecting path constraints to flip branches. — skip: belongs in the toolchain (build, test runner, pacman)

#2208Symbolic Execution with Path Merging

Exploring program paths as constraint sets solved by SMT. — skip: belongs in the toolchain (build, test runner, pacman)

#2209Mutation Testing

Injecting small code changes and checking that tests fail. — skip: belongs in the toolchain (build, test runner, pacman)

#2210Equivalent Mutant Detection

Filtering mutants that cannot change behavior. — skip: belongs in the toolchain (build, test runner, pacman)

#2211Code Coverage Instrumentation (Basic Block)

Recording executed blocks via inserted counters. — e.test.coverage.blocks

#2212Branch Coverage Measurement

Tracking both outcomes of each conditional. — e.test.coverage.branches

#2213MC/DC Coverage Analysis

Verifying each condition independently affects a decision. — e.test.coverage.mcdc

#2214Test Impact Analysis

Selecting tests whose covered code changed. — skip: belongs in the toolchain (build, test runner, pacman)

#2215Test Prioritization by Failure History

Ordering tests by recent failure probability. — skip: belongs in the toolchain (build, test runner, pacman)

#2216Flaky Test Detection (Rerun Statistics)

Identifying tests whose outcome varies without code change. — skip: belongs in the toolchain (build, test runner, pacman)

#2217Snapshot Testing with Serialization

Comparing serialized output against a stored baseline. — e.test.support.snapshot

#2218Golden Master Comparison

Diffing current output against recorded legacy behavior. — e.test.support.golden

#2219Contract Testing (Consumer-Driven)

Verifying a provider against consumer-recorded expectations. — skip: implementable, but too specialised for the standard library

#2220Record and Replay of HTTP Interactions

Capturing responses for deterministic replay. — e.test.support.http_replay

#2221Deterministic Simulation Testing

Running distributed code on a simulated scheduler with seeded randomness. — e.test.sim.run

#2222Jepsen-Style Linearizability Checking

Verifying histories against a sequential model. — e.test.linearize.check

#2223Knossos / Porcupine Linearizability Check

Searching for a linearization of a concurrent history. — see #2222 (e.test.linearize.check)

#2224Model Checking (Explicit State)

Exhaustively exploring state space for property violations. — e.algo.check.explore

#2225Bounded Model Checking

Unrolling transitions to a depth and checking with SAT. — e.algo.check.bmc

#2226TLA+ State Space Exploration

Breadth-first exploration of specification states with invariants. — skip: belongs in the toolchain (build, test runner, pacman)

#2227Chaos Fault Injection

Introducing latency, errors, and crashes to test resilience. — e.test.support.inject_fault

#2228Circuit Breaker State Machine

Opening after failures and probing before closing. — see #710 (e.resilience.circuit_breaker)

#2229Retry with Exponential Backoff and Jitter

Spacing retries randomly to avoid thundering herds. — see #711 (e.resilience.backoff)

#2230Token Bucket Rate Limiting

Admitting requests while tokens remain and refilling at a fixed rate. — see #705 (e.ratelimit.token_bucket)

#2231Sliding Log Rate Limiting

Counting timestamps within a trailing window. — see #708 (e.ratelimit.sliding_log)

#2232Bulkhead Isolation

Partitioning resources so one failing dependency cannot exhaust all threads. — e.resilience.bulkhead

#2233Health Check Aggregation

Combining dependency probes into liveness and readiness states. — e.resilience.health

#2234Canary Analysis (Statistical Comparison)

Comparing canary and baseline metrics with hypothesis tests. — see #1911 (e.algo.stat.test.t_test)

#2235Feature Flag Percentage Rollout

Hashing user identifiers to a stable bucket for gradual exposure. — e.resilience.rollout_bucket

#2236Semantic Version Range Resolution

Selecting versions satisfying caret, tilde, and range constraints. — e.fmt.semver.satisfies

#2237Dependency Resolution (PubGrub)

Version solving with conflict-driven incompatibility learning. — pacman.resolve

#2238Lockfile Generation

Recording exact resolved versions and hashes for reproducible installs. — pacman.lock

#2239Build Graph Incremental Rebuild

Re-executing only targets whose inputs changed. — skip: belongs in the toolchain (build, test runner, pacman)

#2240Content-Addressed Build Caching

Keying outputs by hashes of inputs and commands. — skip: belongs in the toolchain (build, test runner, pacman)

#2241Three-Way Merge

Combining two changes against a common ancestor. — see #378 (e.text.diff.merge3)

#2242Merge Conflict Hunk Detection

Identifying overlapping changed regions. — e.text.diff.conflicts

#2243Git Bisect

Binary searching commit history for the first bad revision. — skip: belongs in the toolchain (build, test runner, pacman)

#2244Rename Detection by Similarity

Pairing deleted and added files with high content similarity. — e.text.diff.similarity

#2245Blame Line Attribution

Tracing each line to its last modifying commit. — skip: belongs in the toolchain (build, test runner, pacman)

#2246Semantic Diff (AST-Based)

Comparing syntax trees to ignore formatting noise. — skip: belongs in the toolchain (build, test runner, pacman)

#2247Code Clone Detection (Token-Based)

Finding duplicate fragments via suffix-tree token matching. — skip: belongs in the toolchain (build, test runner, pacman)

#2248Cyclomatic Complexity Calculation

Counting linearly independent paths through a function. — skip: belongs in the toolchain (build, test runner, pacman)

#2249Dead Code Detection via Call Graph

Flagging functions unreachable from entry points. — skip: belongs in the Neper compiler, not the library

#2250Static Taint Analysis

Tracking untrusted data from sources to sensitive sinks. — skip: belongs in the toolchain (build, test runner, pacman)