four variations of isprime for the first thousand integers, shuffled and rotated counts don't include original in their counts, but require it

The Maximum number in prime factorization

This example visualizes the largest prime factor of each integer from 2 to 104, plotting circles at coordinates where the x-axis represents the integer and the y-axis is 500 minus ten times that factor. An SVG line chart connects these points, revealing the scattered pattern of maximum prime factors. The code uses D3 v6 to bind the data array to circles via `selectAll` and `data`, positions them with `attr`, and draws the connecting path using `d3.line()`. Each circle responds to `mouseover` by logging its coordinates to the console.

MMTR

63% match

Gaussian Primes - MrWatson after Jason Davies

This visualization plots Gaussian primes as filled squares on the complex plane, with the pattern emerging across a grid of integers. It uses d3.v5 to render the SVG elements, with a custom `isGaussianPrime` function that checks the criteria for primes on the axes and in the interior. The code generates points by iterating over a symmetric range and applies a static rendering, with a circular clipping mask defining the visible area. The implementation follows Jason Davies’ original approach, though the developer notes that a cached prime-checking function underperforms the simpler dynamic version.

RRussell Watson

63% match

Prim’s Algorithm IV

The visualization displays an animated spanning tree generated by Prim’s algorithm on a maze, with colors cycling through a cubehelix color scale to highlight the tree's structure. The maze is computed asynchronously in a worker thread using a min-heap priority queue. The animation renders to a Canvas via `putImageData`, updating pixel colors every 20 milliseconds based on each cell's distance from the start, while rotating the hue through 360 degrees. D3.js (v3) provides the cubehelix interpolation and animation timing.

55% match

Shuffle II

An array of 200 vertical lines rotates in place to visualize a Fisher–Yates shuffle, with shuffled elements rendered in black while unshuffled ones stay light gray. The animation plays the swap sequence in reverse, shuffling the array from a fully shuffled state back to its original order. Built with D3 v3, it uses ordinal and linear scales, SVG line elements, and chained transitions to update each line’s rotation transform after every swap. The shuffle function generates random pairwise swaps, and the code references DOM nodes directly to swap their positions efficiently.

54% match

Quicksort III

Two hundred vertical lines represent an array of shuffled numbers, each line rotated by its value. The animation plays out the swaps of the quicksort algorithm in reverse, showing the array gradually becoming disordered. The visualization uses D3 v3 with SVG line elements, a linear scale for rotation, and an ordinal scale for x-positioning. The quicksort function generates a list of swap pairs, which d3 transitions then animate sequentially, adjusting line transforms on each step.

Shuffle I

A Fisher–Yates shuffle is animated as 200 vertical line segments, each rotating to illustrate the random swapping of array positions. The visualization uses D3.js v3 with SVG and a transition system that chains animations step-by-step, reversing the shuffle steps to trace the algorithm’s progression. The `d3.scale.ordinal` and `d3.scale.linear` maps data indices to x-coordinates and rotation angles, while the `shuffle` function generates swap pairs for the animation sequence.

Pie_Chart_ICE7

This pie chart visualizes the total number of movies and shows available on Amazon Prime, broken down by country for the top ten entries. The chart uses D3 v5’s `pie` and `arc` generators to create the SVG segments, with a `scaleOrdinal` color scheme distinguishing each country. A legend lists the country names and their corresponding library sizes, formatted as plain numbers. The data is loaded as CSV from a GitHub gist, then sorted and filtered before rendering in the SVG container.

AAnanthulaaditya

gcd-viz

The visualization animates the Euclidean algorithm as it computes the greatest common divisor of two random integers, revealing the recursive subtraction steps as nested square blocks. It shows how each division step’s quotient and remainder tile a rectangle, with the final GCD emerging from the arranged squares. The code uses D3.js with SVG and transitions to fade in colored square groups sequentially, while text spans display the intermediate division equations. Random inputs are regenerated after the animation completes, looping the process. The `d3.range` and `transition.delay` orchestrate the cascading reveal, and the colors cycle through a palette per step.

11wheel