The Mandelbrot set on Very Plotter

I've added the Mandelbrot set to Very Plotter.

This was a fun project, especially doing various tests and enhancements to improve calculation speed. I wrote my own arbitrary precision code, based on the new-ish JavaScript BigInt class.

It was also a worthwhile challenge, I think, to get the site usable on mobile (tested on iOS) devices, where most interactive JavaScript Mandelbrot viewers I've seen do not work so well on iPhones/iPads.

Background

I originally wrote Very Plotter a couple months ago as a way to visualize prime numbers.

After adding a few other plots to that page, allowing the user to switch between several different plots, I guess it was only natural that I'd soon add the Mandelbrot set as well. And now the Internet has yet another Mandelbrot set viewer.

For background on the Mandelbrot set, I again will recommend the Numberphile YouTube channel and this video in particular.

Gallery

Here are some sample images I've generated (click images view on Very Plotter, or here for the latest gallery):

If you find a particularly fascinating or beautiful location in the Mandelbrot using Very Plotter, I'd like to see it and include it in the gallery! Send me a link via mail to "phil" at this domain.

Tips

(for more tips, see this page)

• To download the rendered image, use the "Save Image" button in the controls menu
  • before downloading the image, use the T key to add a legend to the final image
• Use Shift+click to center the view on an exact location
• Use the E key to zoom in (increase the scale by 10x) and Q to zoom out
  • for fine-grained zoom control, use the + and - keys

Features (as of v.0.7)

(for the release history, see the releases page on GitHub)

• JavaScript web workers, depending on your browser and machine, can be used to calculate the plot much faster
  • use the U and Y keys to decrease and increase the number of workers on the fly
  • iOS device browsers, as of writing, don't have sufficient support for JavaScript web workers (subworkers) and instead must use the fallback single-thread calculate/draw loop
• perturbation theory is used for deep images
• series approximation (SA) is used for very deep images
  • the SA parameters are adjustable in the "algorithm options" pane of the controls menu:
  • "sapx8.2" uses 8-term SA with (2+1)² = 9 test points evenly spaced over the image
  • "sapx64.4" uses 64-term SA with (4+1)² = 25 test points evenly spaced over the image
• pass-based rendering to allow fluid (though pixelated) pan and zoom
• works on mobile/touch devices
  • the help menu keycap icons themselves can be tapped, which is useful for mobile users
• by default, the basic escape time algorithm with fast floating point math is used for smaller scales (when "zoomed out"), and perturbation theory and series approximation are enabled when appropriate when "zooming in"
• allows custom color gradients (or use of several preset gradients) and a gradient preview
  • the gradient can be repeated several times across the range of iterations with the "mod" option
  • "mod1000" means pixels with 123 or 1,123 or 98,123 iterations are all set to the same color
  • gradient colors can be manipulated with options like repeat and mirror
  • the gradient is adjustable while a render is running
• the render size can be set to 0.5x, 1x (default), 2x, 4x, or 8x for downloads in the "window options" pane of the controls menu
  • use 0.5x for faster exploring
  • use 2x or 4x for final rendering and downloads (don't forget to enable "window lock" while waiting!)
  • 8x should only be used if you have a fast location (or lots of patience)
• any image, including custom gradients, can shared and revisited with the full page URL
• use R key to toggle displaying the mouse position
• go to location by center point and scale, or by bounding top left and bottom right corners
• to improve panning for slow locations, the last image itself is moved rather than calculating an on-the-fly preview pass

Development

I learned a lot while building this Mandelbrot set viewer.

I re-familiarized myself with the UI-freezing nature of the single-threaded JavaScript environment, and experimented with several iterations of an approach at breaking down the very slow Mandelbrot set calculations into small chunks to allow the UI to be somewhat responsive.

This was also finally my chance to try out web workers. They are a bit cumbersome to setup and use, but not bad overall. The performance I got out of running 8 threads for the first time was mind blowing. Getting that to work was a cool moment. And I'm glad I first dealt with single-threaded calculation and rendering though, because it turned out that webkit/Safari browsers (and thus all iOS mobile browsers) still need to use that single-threaded approach.

Mostly for fun I decided to write my own arbitrary precision math functions. Since JavaScript has BigInts now, it didn't seem like a big undertaking. I was able to get it working relatively easily, and it was fun to re-write some functions to speed things up — mainly the "to string" and "from string" functions. I spent a day grafting an existing arbitrary precision library (decimal.js-light) into my code, and I was relieved to see that it wasn't any faster than mine.

I have a very long list of features/improvements I'd like to make for this Mandelbrot set viewer. If you have any feedback, bugs, etc., let me know! Send mail to "phil" at this domain.

Links

Very Plotter

Source repository on GitHub