## Multibrot Set

The Mandelbrot Set is typically defined as the set of all numbers $c \in \mathbb{C}$ for which — with $z_0 = 0$, $z_{n+1} = f_c(z_n)$ and $f_c(z) = z^2 + c$ — the limit $\lim\limits_{n \to \infty} z_n$ converges. Visualizations of this standard Mandelbrot Set can be seen in three of my posts (Mandelbrot Set, Mandelbrot Set Miscalculations and Mandelbrot Set II).

However, one can extend the fractal’s definition beyond only having the exponent $2$ in the function to be $f_c(z)=z^\text{exp}+c$ with $\text{exp} \in \mathbb{R}$. The third post I mentioned actually has some generalization as it allows for $\text{exp} \in \{2,3,4,5\}$, although the approach used cannot be extended to real or even rational numbers.

The method I used in the aforementioned post consists of manually expanding $(a+b\cdot i)^n$ for each $n$. The polynomial $(a+b\cdot i)^3$, for example, would be expanded to $(a^3 - 3 \cdot a \cdot b^2) + (3 \cdot a^2 \cdot b - b^3) \cdot i$.
This method is not only tedious, error-prone and has to be done for every exponent (of which there are many), it also only works for whole-number exponents. To visualize real Multibrots, I had to come up with an algorithm for complex number exponentiation.

Luckily enough, there are two main ways to represent a complex number, Cartesian form $z = a+b\cdot i$ and polar form $z = k\cdot e^{\alpha\cdot i}$. Converting from Cartesian to polar form is simply done by finding the number’s vector’s magnitude $k = \sqrt{a^2+b^2}$ and its angle to the x-axis $\alpha = \mbox{atan2}(\frac{a}{b})$. (The function $\mbox{atan2}$ is used in favor of $\arctan$ to avoid having to divide by zero. View this Wikipedia article for more on the function and its definition.)
Once having converted the number to polar form, exponentiation becomes easy as $z^\text{exp} = (k \cdot e^{\alpha\cdot i})^\text{exp} = k^\text{exp} \cdot e^{\alpha \cdot \text{exp} \cdot i}$. With the exponentiated $z^\text{exp}$ in polar form, it can be converted back in Cartesian form with $z^\text{exp} = k^\text{exp} \cdot (\cos{(\alpha \cdot \text{exp})} + \sin{(\alpha \cdot \text{exp})} \cdot i \big)$.

Using this method, converting the complex number to perform exponentiation, I wrote a Java program which visualizes the Multibrot for a given range of exponents and a number of frames.
Additionally, I added a new strategy for coloring the Multibrot Set, which consists of choosing a few anchor colors and then linearly interpolating the red, green and blue values. The resulting images have a reproducible (in contrast to randomly choosing colors) and more interesting (in contrast to only varying brightness) look.

The family of Multibrot Sets can also be visualized as an animation, showing the fractal with an increasing exponent. The animated gif shown below was created using ImageMagick’s convert -delay <ms> *.png multibrot.gif command to stitch together the various .png files the Java application creates. To speed up the rendering, a separate thread is created for each frame, often resulting in 100% CPU-usage. (Be aware of this should you render your own Multibrot Sets!)

To use the program on your own, either copy the source code listed below or download the .java file. The sections to change parameters or the color palette are clearly highlighted using block comments (simply search for ‘/*’).
To compile and execute the Java application, run (on Linux or MacOS) the command javac multibrot.java; java -Xmx4096m multibrot in the source code’s directory (-Xmx4096m tag optional, though for many frames at high quality it may be necessary as it allows Java to use more memory).
If you are a sole Windows user, I recommend installing the Windows 10 Bash Shell.

// Java 1.8 Code
// Jonathan Frech, 11th of September 2016
//          edited 17th of April     2017
//          edited 18th of April     2017
//          edited 20th of April     2017
//          edited 21st of April     2017
//          edited 22nd of April     2017

## Mandelbrot Set II

Over a year ago, I published my first Mandelbrot Set viewer, a Python program using pygame. Since then, I have published a rather short program highlighting errors that can occur when calculating the set (Mandelbrot Set Miscalculations).
Since my first viewer was in Python, which is an interpreted programming language, and I wanted to make my viewer faster, I decided to write one in Java. I was hoping for a speed increase since Java is compiled and thus should run at higher speeds. I was not disappointed. The new Java-based viewer runs noticeably faster and additionally I added a lot of new features, all listed below.

#### Controls

• Left-clicking and dragging draws a zoom frame, single left-clicking removes the frame
• Right clicking (and optionally dragging) moves the zoom frame
• Space zooms into the zoom frame
• F1 moves one step back the zoom history
• F2 shows the path a complex number at the cursor’s position follows when the function is iteratively applied
• F3 shows the $\mathbb{R}$ and $\mathbb{R}i$ axis
• F4 displays the current cursor’s corresponding complex number
• F5 toggles between showing and hiding the menu (text in the left upper corner describing the viewer’s functions and current states)
• F6 increments the exponent (going from $f_c(z)=z^2+c$ to $f_c(z)=z^5+c$ in whole-number steps)
• F7 toggles between the Mandelbrot set and the filled Julia set
• F8 toggles between previewing a small filled Julia set at the cursor’s position based upon the cursor’s complex number
• F9 completely resets the zoom and zoom history
• F11 (or F) toggles between fullscreen and windowed mode
• F12 quits the application
• L increases the color depth (starting at $256$ and increasing in steps of $256$)
• Q saves the current image to disk

To use this application, you can either trust me and download the .jar-file or view the source code listed below, verify it and compile the program yourself.
The program will start in fullscreen mode, to change to windowed mode, just press F11 (as listed above).

// Java Code
// Jonathan Frech 14th of September, 2016
//         edited 15th of September, 2016
//         edited 16th of September, 2016
//         edited 17th of September, 2016
//         edited 18th of September, 2016
//         edited 19th of September, 2016
//         edited 23rd of September, 2016
//         edited 24th of September, 2016
//         edited 26th of September, 2016
//         edited 27th of September, 2016
//         edited 28th of September, 2016
//         edited 29th of September, 2016
//         edited 30th of September, 2016
//         edited  1st of October  , 2016
//         edited  2nd of October  , 2016
//         edited  3rd of October  , 2016
//         edited  4th of October  , 2016
//         edited 21st of November , 2016
//         edited 23rd of November , 2016
//         edited 14th of December , 2016
//         edited 13th of January  , 2017

## Mandelbrot Set Miscalculations

While developing a Java program to create an image of the Mandelbrot set, I stumbled upon a small error which completely changes the set’s look. To fix this bug, you need to swap two lines of code.

The bug arises when trying to convert convenient Python features to Java.
To iteratively apply the function $z \to z^2 + c$, you update your complex number $z$ a certain amount of times. When you are not using a complex number class, but instead you use two floating point numbers (in Java doubles to gain precision) $\texttt{a}$ and $\texttt{b}$ to define the real and imaginary part $(z = \texttt{a} + \texttt{b} \cdot i)$, logically both numbers need to be updated.
In Python you may write the following, when $c$ is defined as being a complex number with parts $\texttt{c}$ and $\texttt{d}$ $(c = \texttt{c} + \texttt{d})$.

a, b = a**2 - b**2 + c, 2 * a * b + d

Which seems to be very similar to those two lines.

a = a**2 - b**2 + c
b = 2 * a * b + d

But notice that in the first code snippet you define a tuple consisting of the real and imaginary part and then assign it to the variables. The first snippet really looks like this.

t = (a**2 - b**2 + c, 2 * a * b + d)
a, b = t

Using this assignment of variables, which corresponds to $z \to z^2 + c$, you get an image of the correct Mandelbrot set.

In contrary, the second code snippet assigns the old $\texttt{a}$ its new value, then uses this new $\texttt{a}$ to define the value of new $\texttt{b}$, thus does not calculate $z \to z^2+c$, which is equivalent to $z \to (\texttt{a}^2-\texttt{b}^2+\texttt{c}) + (2\cdot\texttt{a}\cdot\texttt{b}+\texttt{d}) \cdot i$, but rather $z \to (\texttt{a}^2-\texttt{b}^2+\texttt{c}) + (2 \cdot \texttt{a}^2 \cdot \texttt{b}-2\cdot \texttt{b}^3+2\cdot\texttt{b}\cdot\texttt{c}+\texttt{d})\cdot i$.

In Java it would look like this.

a = a*a - b*b + c;
b = 2 * a * b + d;

Which results in this rather unusual depiction of the famous fractal.

You can easily avoid this bug when using two sets of variables to define old $z$ and new $z$, as shown in the following.

_a = a*a - b*b + c;
_b = 2 * a * b + d;
a = _a;
b = _b;

Or you can define variables $\texttt{asqr} = \texttt{a}^2$ and $\texttt{bsqr} = \texttt{b}^2$ and swap the assignment. Using variables for the squares of the parts of $z$ also helps to improve performance.

b = 2 * a * b + d;
a = asqr - bsqr + c;
asqr = a*a;
bsqr = b*b;

// Java 1.8 Code
// Jonathan Frech, September / November / December 2016