jblog
toc

Multibrot Set

2017-04-22, post № 168

Java, mathematics, programming, #animated gif, #animation, #Cartesian, #complex, #complex arithmetic, #fractal, #generalization, #gif, #Mandelbrot set, #multi-threading, #polar, #reals, #threading

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).

multibrot-set-1.png

However, one can extend the fractal’s definition beyond only having the exponent 𝟤 in the function to be f_c(z)=z^\text{exp}+c with \text{exp}\in\mathbb{R} [1]. 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.

multibrot-set-2.png

The method I used in the aforementioned post consists of manually expanding (a+b\cdot i)^n for each 𝑛. 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.

multibrot-set-3.png

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 𝑥-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).
multibrot-set-4.png

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.

multibrot-set-5.png

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 𝟣𝟢𝟢% CPU-usage. (Be aware of this should you render your own Multibrot Sets!)

multibrot-set-10.png

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 [2] to use more memory).
If you are a sole Windows user, I recommend installing the Windows 10 Bash Shell.

multibrot-set.gif
Source code: multibrot.java

Easter MMXVII

2017-04-16, post № 167

art, ascii, haiku, poetry, #ascii egg, #celebration, #easter egg, #egg

Winds swirl through the air,
Water sloshes at the shore;
A peaceful island.

                           vunnnnnnnxvvczYX                         
                       uuxrjjft///tfjrnuvvcXXUU                     
                    cuxxrf/\|(|||/tttrnxuuvcczYYJL                  
                 cuuvnxrjt/\\\/\//tffrxnuvvcccXXYYCLC               
               cccvuunxjrttttttjjfrrxnnnvvcczXzXUUUJL0              
             cczvvvuuuxnrxrrrjrxrxnnuuuvvcczXXXXYXUJJLQZ            
           czzzXzvccvnuunnnnnnnnuuuvuvvccczzzXYXYUYUJCLQO           
          zzzzXzccvvvvvuunnnnunuunnuuucvzczzXXYXUYJUJJCQ0Oq         
         XXXXzzzzcccvvvvuuvunnnnnuuuvvvcczzXzXYXXYYUUCCL0Qmp        
        XXXzXzzzzzcccccvuunnnnnnnnunvucvzzzXzYXXYUUUUJJCL0OZq       
       XYYYYXXzczzzcczcvuuunxxnxxxnuuuvzzXXXXYXUYUUUUUCJCQ0Owp      
      YYUYXYYXXXXzczczcvvuunxxrrrxnnuvuzzzzXXXYYUUUUUUJJCCL0Omd     
     YYUUYUYUXXXXczzzzcvvvunxrxrrrxxnuvcczzXzYYXYXUYUUJJLQQ0OZmk    
    YUUJJJYUYYXUXYXzczzczuuxrjrrrjrxxccccczzXXXYUYUYUJUCCCL00mwdw   
    UJCJJJUYXYXXXzzXXzzvvnxxrjjjrjxxuvvczXzXYYYXXUYUUUJCJLLL0Zmpb   
   CLLCJJJCUUUXUUXXzzzccvvunxxrrxrnuuvzzzXYXXYYYUUUYJUJJJJLL0OZwda  
   QLQLCJCUUUUUUYYXXXXXzvuuxxxrrnxxuuvvccXzXYUYUYYYUUUUCCCLLQ0Zmpk  
  00QQLLLCUJUUUUUYYYXzzzccvuuxxxxnnuvczzcXXXXUUUUYYJUYUUJCLL0QOwqk* 
  Z0OQQLLJCJUUUYUYYYXXXzzcvvnunnuuvvvvczzzXXXYYYYUYUYUJJCJLL0QOmqpa 
 0ZmZ00QLLCCJCJUUUUYYXXzzcccvvuuuucvczXXXYXYYUUUYYYUUUJJJJC0L0ZOqpkM
 ZOZO0QLLLCCCJJJUUYYXYXXYXzccvvccvczzzzXXXYYYYYUYYUYUUUUJJCCQQOZwdk*
 wwmZ0OQCQCCJJJJUUUYUYYYYXXzzzcccczXXXzXXXXYYXUYYYUUJUUJJCULQQ0Zmpbo
 qmZZZ00QQLCJUJUUJUUUUUYYXXXXzcYXXzXUXYXYYYXUUUYUUUUUUUJCJCCQQOZmqb#
 dqpZZ00QQLLLLCCJJCUUUYUYUYUXYXYYYYYYYYYYUYYUYUYYUUUYUUUJJLLQ0Omwqb*
qpqwZZOO0QLQCCCJCUJYUUUUUUYXXYYYUUUUYUYYUYJUYUYUYYYUUUJJJULLQ00mwqba
pddpwmZ000QQCQCCLCJJCJUUJUJUUUUUUYUYJUUUUUYUYJUJUUUJUJUUCCLLQ0OOmpba
qkppwwmOOO0LQLLCCCCJJJJJJUJJJUCJUUUUUUUUUJUJJUJUJUUJUCCCCCLQ00OZqqh*
 kdbpmmZZO00QQQLQLCCCJCCUCJJJUJCUJJUUUUUJJUUUUJJYUJUUJJJCLLL00OZwqk#
 ahbdqwmmOZ0Q00LLLJCCCJJJCJJJJJCUJJJYUUJUUUUUUUUUUUJUJCJCLLQOQZmqdh#
 oohdqwwZZOO0QQLLQLQCCCCLLCLCCJJJJCUJUJJJJUUUUYUJJJCCCCCCCQ0OOmmpk#*
 d*abdqqwmmOOZ00OQLQ0LCLQCCCJCLCCCJCCJJUUUJUJUUJUJUJCCCCLCQOOmwpdh# 
  M#hkbqwmZmZOOO0Q00L0QLCLLQLLQLJCLCCJJCJCUJJJJJJJJCJJLLCQ0ZmwqpkaM 
   oohkddqwmmmOZOOO0LQL0LLQCL0LCLLLLLCJCJLJJJUUJJJJCCCLQ00OZmwqba*  
   WM*akbqppwmwZOZOQOO000LQLQQLCCLLLCCCCJJCCCCJCJCLCCCLQ0OZmppboo   
    MWohhdpwqwwmwOZZZOOO00QLQLQQLLLLLCCCLLLCLCLCLLJLLQ0ZOmmwdbaa    
     &W#hkbpqwqwqZZZZZZO000QQQ0QLLQLCLLCQCLQLLLLCLLQQL0ZZmwpbkap    
      8&#ohkbddpqwwmmmZOZOOO0OO0Q0Q0QLLQQLQLLQQ0QQQ00ZOmmqbdha      
       88WMohobdbpqpwwmqZZmZZZOQZO000Q0OQQQ00QQQ000OZmmqppkk*       
        M%8M#*okkbppdqqppmwZmmmwOOZZOO00O0O0O0O0OmZqqwqdbkho        
          B@8&M**ohkbbdqppqwqwwwwwZZZmZmOOOOOZZmmwwppbbkka          
            @@8&MW*ookkkbdpdpdqpqqwqpwZwZwwmqwqpppdpdkk*            
              $$%%&WM#*oahkkhkddppdpbqwpppppbpdkkbbhho              
                @$@B8&WM**#aoaahbkkhkhkbbkkbhhkhkkab                
                   $@%%8&WWM#M#*o**oooaoooaaaaook                   
                       @%%W&WWW#*##o*oa#**#M*                       
                             #88&&%8%&                              

T-3PO — Tic-Tac-Toe Played Optimally

2017-04-08, post № 166

games, HTML, JavaScript, mathematics, programming, Python, #computer player, #game ai, #perfect, #perfect play, #three in a row, #three to win, #three

Tic-Tac-Toe, noughts and crosses, Xs and Os, three in a row or whatever you want to call it may be the simplest perfect information game that is enjoyable by humans. Two players set their pieces (X or O) on an 𝟥 ⨉ 𝟥 grid, alternating their turns. The first player to get three of their pieces in a line, wins. If no player succeeds to get a line, the game ends in a draw.

Tic-Tac-Toe’s simplicity may become clear, if you consider that skilled players — people who have played a few rounds — can reliably achieve a draw, thereby playing perfectly. Two perfect players playing Tic-Tac-Toe will — whoever starts — always tie, so one may call the game virtually pointless, due to there practically never being a winner.
Because of its simple rules and short maximal number of turns (nine) it is also a game that can be solved by a computer using brute-force and trees.

The first Tic-Tac-Toe-playing program I wrote is a Python shell script. It lets you, the human player, make the first move and then calculates the best possible move for itself, leading to it never loosing. On its way it has a little chat whilst pretending to think about its next move. The Python source code can be seen below or downloaded here.

The second Tic-Tac-Toe-playing program I wrote uses the exact same method of optimizing its play, though it lets you decide who should begin and is entirely written in JavaScript. You can play against it by following this link.

Both programs look at the entire space of possible games based on the current board’s status, assumes you want to win and randomly picks between the moves that either lead to a win for the computer or to a draw. I did not include random mistakes to give the human player any chance of winning against the computer. Other Tic-Tac-Toe-playing computers, such as Google’s (just google the game [1]), have this functionality.

Source code: t-3po.py
Jonathan Frech's blog; built 2021/04/16 21:21:49 CEST