Bifurcation Diagram

Generating the famous fractal, which can be used to model populations with various cycles, generate pseudo-random numbers and determine one of nature’s fundamental constants, the Feigenbaum constant \delta.
The fractal nature comes from iteratively applying a simple function, f(x) = \lambda \cdot x \cdot (1-x) with 0 \leq \lambda \leq 4, and looking at its poles.
The resulting image looks mundane at first, when looking at 0 \leq \lambda \leq 3, though the last quarter section is where the interesting things are happening (hence the image below only shows the diagram for 2 \leq \lambda \leq 4).
From \lambda = 3 on, the diagram bifurcates, always doubling its number of poles, until it enters the beautiful realm of chaos and fractals.

Bifurcation Diagram lambda in range [2; 4]
For more on bifurcation, fractals and \delta, I refer to this Wikipedia entry and WolframMathworld.


# Python 2.7.7 Code
# Jonathan Frech, 24th of March 2017

Continue reading

Maze Solving

Mazes have been a subject of human interest for thousands of years. The Greeks used them to trap a bull-man hybrid, the French built them to show how they could impose order on nature, and even nowadays people enjoy wandering around corn mazes.
The algorithmic art of using computers to solve mazes — and even to find the shortest path through a maze –, however, has only emerged in the last couple of decades.

I was inspired by a recent Computerphile video in which Michael Pound talks about implementing different path finding algorithms for use in maze solving. And as he used Python — one of my favourite languages out there –, I thought I could give it a try and came up with this maze solver.

One solution, 1681 pixels (enlarged)

The mazes given to the solver (through a .png file) have to have a specific form. The maze needs to have a border all around (painted black) with two holes at the top and bottom, marking the maze’s start and exit (all path pixels are white).
Then the solver — using PIL — reads in the maze file, determines start and exit and starts at the maze’s start, labelling each maze path according to its shortest distance to the start. After it has found the exit, it stops looking at the maze and traces its origins back from the exit, marking the path it goes along as the maze’s optimal solution (highlighted in red).
The different hues of blue indicate the tile’s distance to the start, the white tiles are tiles the solver did not even look at.
The different shadings also reveal information about the maze. Mazes with only one solution tend to have sharp changes as there are parts of the maze separated by only one wall, yet separated by a huge walk distance through the maze. The one maze with multiple solutions (see upper right image below) — in contrast — has only gradual changes in hue.

To solve a 4 megapixel maze, the solver takes around 3 seconds, for a 16 megapixel maze around 14 seconds and for a 225 megapixel maze around 7 minutes and 22 seconds.
Performance was measured on an Intel Core i7 (4.00 GHz).

All mazes shown were downloaded from Michael Pound’s mazesolving GitHub repository, which were mostly generated using Daedalus.

The solver’s source code is listed below, though you can also download the .py file.

One solution, 4 megapixelsMultiple solutions, 3 megapixels
One solution, 16 megapixelsOne solution, 100 megapixels

One solution, 225 megapixels


# Python 2.7.7 Code
# Jonathan Frech, 25th of Feburary 2017
#          edited 26th of February 2017
#          edited 27th of February 2017
#          edited 22nd of March    2017
#          edited 29th of March    2017

Continue reading

Double-Slit Experiment

Light is a fascinating thing in our universe. We perceive it as color, warmth and vision. Yet it does things one may not expect it to do. One of the experiments that called for a better physical model of light was the double slit experiment. In this experiment, a laser is shone through two closely adjacent slits and projected on the screen behind. Using old physical models, one would expect to see one or maybe two specs of light on the screen, when in reality there appear alternating dark and bright spots.

To explain why this seemingly strange phenomenon is occurring, one can either see light as photons and comprehend that a photon presumably follows every possible path there is in the entire universe and then — through it being observed — randomly chooses one path and thus creates stripes (according to the theory of quantum mechanics) or one can see light as simply being a wave.

For more information on the double-slit experiment, I refer to this Wikipedia entry.

The animation shown below describes light as a wave. The green vectors represent the light wave’s phase at the points on the light beam, the yellow vector represents the addition of both of the slit’s light beam’s phase when hitting the screen and the red dots at the screen represent the light’s brightness at that point (defined by the yellow vector’s length).
To create the animation, Python and a Python module called PIL were used to create single frames which were then stitched together by ImageMagick to create an animated gif.

Double-Slit Simulation (probably loading...)


# Jonathan Frech, 18th of January 2017
#          edited 19th of January 2017
#          edited 22nd of January 2017
#          edited 27th of January 2017

Continue reading