Gist a9d74398b2e6252deeeda63c3a3718e3

100%

Gist a9d74398b2e6252deeeda63c3a3718e3

✓ Published0🌍 Public

Last edited Dec 26, 2017

Created on Dec 26, 2017

This example simulates the Fitz-Hugh Nagumo equations, a simplified model of neural action potentials, using a custom Runge-Kutta 4th-order integrator implemented with NumPy. It sweeps across a parameter range for the variable γ, generating a 2D dataset of voltage and inactivation traces stored in an xarray array. A vector field plot, rendered via Matplotlib’s QuadMesh, visualizes how the system’s oscillatory behavior changes as γ varies. The Vue-based framework embeds this interactive notebook output, allowing inspection of the raw trajectory arrays.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist f052b3898971d32fb695

This example uses Python’s matplotlib within a Jupyter notebook to create subplots, leveraging NumPy and matplotlib’s interactive mode. The visualization demonstrates the construction of multiple panels in a single figure, with code likely generating sample plots for comparison or exploration. The notebook runs `%pylab inline` to enable inline plotting and produce rendered subplot images as output.

JJonasHeylen

61% match

Loading thumbnail…

Gist d1c4aa87fcfefde869f59c98b73ef3fb

This example uses a custom physics simulation to render a network of nodes and links, with each node’s position updated iteratively and drawn as a smooth curve. The code relies on `d3.forceSimulation` and `d3.forceLink` to compute forces, while custom `requestAnimationFrame` loops and `canvas` paths render the animated edges. The data appears to be generated randomly, with no external dataset, and the visualization emphasizes the evolving structure of the simulated graph over time.

11wheel

59% match

Loading thumbnail…

Gist 36fa85de37aeb50756ec65aa6548b25f

This example implements an artificial neural network where individual neurons are drawn as circles on a canvas. Each neuron connects to a set of previous-layer inputs, multiplying their output values by random weights, then passing the summed result through a sigmoid activation function. The code renders each neuron’s fill color based on its output value, using the Processing API’s `ellipse()` and `fill()` functions to visualize activation levels. The neural activity propagates layer by layer, producing a dynamic, self-contained simulation of a feedforward network without external data inputs.

CCharlesFr

59% match

Loading thumbnail…

Gist 94b07d6a1293b38ee46ae6841ae7f4bd

This example visualizes a force-directed network using a custom D3.js simulation. It draws nodes and edges on an HTML canvas, with node positions computed via a spring-electric force model. The code implements a custom `forceSimulation` API, integrating a cooling factor to stabilize the layout. The visualization renders a graph of interconnected data points, whose source is a hardcoded dataset, and uses the canvas `getImageData` method to apply a blur effect to the nodes.

KKopylovVitalik

59% match

Loading thumbnail…

Gist 73e5cb2c456084a9c356f9c3f89f8803

An interactive particle field visualizes the gravitational attraction between a cursor and thousands of moving points. The code uses D3's quadtree for spatial indexing and d3.forceSimulation with custom force functions to compute particle velocities and positions, while a Vue component manages the animation loop and canvas rendering. The display updates in real time, with particles flowing toward and around the pointer position based on distance-based force calculations, creating a dynamic, organic swarm effect on a dark background.

MMAKIO135

58% match

Loading thumbnail…

knots from gauss codes - stable branch

This interactive knot visualization generates random Gauss codes from four crossings and renders them as dynamic force-directed diagrams using D3 v4. Users can click translucent overlay circles to cycle each crossing through over, under, vertical, and horizontal smoothing states, which updates the link topology in real time. The SVG output combines thick colored paths representing knot strands with dashed helper lines, while `d3.forceSimulation` with x, y, and charge forces arranges the port nodes. Circle fill colors distinguish crossing types, and drag interactions let viewers manually reposition all elements.

JJazzTap

58% match

Loading thumbnail…

Gist 257543a98ae32a2d951e5f3cd5a06979

This interactive visualization simulates a dynamic network of nodes and edges, showing how force-directed layouts settle into a stable configuration. The scene renders a clustered graph where nodes repel and links constrain movement, with subtle visual feedback as positions update in real time. Built with D3.js, the example uses `d3.forceSimulation` and `d3.forceManyBody` to compute physics, while a canvas element draws the animated paths and circles. The code loads a Gist-sourced dataset via a JSON request, and the simulation updates each frame, demonstrating how forces like charge and link distance shape the final network structure.

MMbrownshoes

58% match

Loading thumbnail…

Gist 5a40403d5dadf54225cee084d8fb8b15

This example visualizes geospatial relationships using a D3.js force-directed graph overlaid on a map. The notebook configures an interactive simulation where interconnected nodes are positioned based on proximity and links, while geographic boundaries serve as a contextual base layer. It employs `d3.forceSimulation` for the physics engine, `d3.geoPath` to render map regions, and Jupyter’s inline display for rendering. The data appears to be custom-generated, with node connections defined programmatically in the notebook rather than sourced from an external file. The visualization emphasizes network topology against a spatial backdrop, allowing users to explore clustering patterns and geographic anchor points.

MMistyBlunch

57% match