Skip to main content
100%

Gist fe03ac887568cbb468c1d93a0c33d307

✓ Published0🌍 Public
WWilliamNHarvey
Last edited Mar 15, 2021
Created on Mar 15, 2021

This example estimates the value of pi using a Monte Carlo simulation implemented in Go, running ten parallel goroutines to generate ten million random point samples within a unit square. It calculates pi by comparing the fraction of points falling inside a quarter-circle to the total sample area. The visualization uses the `sync.WaitGroup` and channels to coordinate parallel workers, with `rand.Float64()` generating coordinates and `math.Pow` computing the distance check. The program prints the resulting pi estimate and the wall-clock execution time.

AI-generated description

Similar vizzes

Loading thumbnail…

Value of PI

This interactive visualization demonstrates the Monte Carlo method for estimating the value of π. By randomly placing points within a square, the application calculates the ratio of points falling inside an inscribed circle to the total number of points, updating the π approximation in a readout panel. The React component uses D3.js for SVG rendering and state management. A button adds 100 points per click, instantly updating the counts and the elliptical estimate. The code leverages the `d3.select` API for SVG creation and `useState` for tracking point coordinates and calculations.

AAnimesh Nautiyal
63% match
Loading thumbnail…

Fork of Value of PI

This interactive Monte Carlo simulation estimates the value of pi by randomly placing steel-blue points inside a square and counting how many fall within an inscribed sky-blue circle. Each click of the "Add 100 Points" button appends 100 new circles to an SVG canvas using D3.js selection and append methods, while React state tracks the running totals. The estimate updates in real time, calculated as four times the number of points inside the circle divided by the total points, with the current counts and approximation displayed in a grey overlay panel.

NNita
63% match
Loading thumbnail…

Fork of Fork of Value of PI

This interactive visualization demonstrates the Monte Carlo method for estimating the value of π. A sky-blue circle is drawn on a square canvas, and users can add 100 randomly placed steel-blue points at a time via a button. The display updates counters for points inside the circle and the total, calculating an estimate of π as 4 times the ratio of inside points to total points. Built with React and D3.js, the app uses D3’s selection API to append SVG circles and calculates distances mathematically to determine whether each point falls within the circle.

CCurran Kelleher
62% match
Loading thumbnail…

Gist 0f0c45136069ee6e7366afef684f3373

This animation cycles through the digits of pi, displaying each digit one at a time in a console. The digits are sourced from a remote JSON file containing the mathematical constant. The code uses the `fetch` API to retrieve the data, `console.clear()` and `console.log()` for output, and a `setInterval` timer to control the pace of the digit display.

MMAKIO135
57% match
Loading thumbnail…

Gist 4621876

This example demonstrates how to automate the setup of a Go workspace and package installation via a shell script, following the official Go documentation. The script creates a temporary directory structure with a `src/newmath` folder and writes a custom `sqrt.go` file implementing a basic square root function. It then runs `go install example/newmath` to compile and install the package, verifying the result by checking for zero output or errors. The code relies on the Go command-line tool and standard shell utilities like `echo` and `mkdir`; no external visualization libraries are involved.

HHoffmannP
55% match
Loading thumbnail…

The Walk of PI

The Walk of PI visualizes the first 2216 digits of pi in base 8 as a continuous path on an SVG canvas. It shows the digits as a walk where each digit (0-7) determines one of eight directional steps from the previous point, creating a dense, meandering line. The visualization uses D3.js (v3) to render the path and circles, with hover interactions revealing individual digits. It includes zoom and pan via D3’s zoom behavior, plus buttons to redraw the animation or reset the view. The data comes from a static string of pi’s octal digits, processed sequentially to build the path.

GGerardoFurtado
54% match
Loading thumbnail…

Gist 585271

This example demonstrates a one-dimensional Gaussian kernel generated by the Ruby class `GThang`, which computes a discrete approximation of the kernel over a radius of three units. It shows the resulting array of kernel values printed to the console via `puts`, highlighting the symmetric, bell-shaped weighting used in kernel density estimation. The code implements the Gaussian function manually using `Math.sqrt`, `Math::PI`, and `Math::E`, with no external visualization libraries or data sources. The output is a simple numeric list, not a graphical plot, so the visualization is limited to the textual representation of the kernel’s weights.

XXXX
52% match
Loading thumbnail…

Poisson-Disc

The visualization shows a square canvas being progressively filled with small circles using Poisson-disc sampling, a method for generating evenly distributed random points. The algorithm, based on Bridson’s technique, ensures each new point is at least a specified distance from existing ones, creating a uniform, pseudo-random pattern. Built with d3.v3, the animation adds circles one at a time via `d3.timer`, with each circle’s radius animated using `transition()`. The code explicitly implements the sampling logic, including a grid-based spatial index for efficient distance checks, and renders the result as SVG circles.

JJaapSuter
52% match