Many fractals are based on the idea of an iterated function. In this article we will look at what an iterated function is. Here are some articles that explore well known fractals that can be craeted in ths way with generativepy:
The idea on an iterated function is quite simple. Let's illustrate it with the function:
xnext = x * 2
If we start with a value
x of 1, and apply the function, we get a value
xnext of 2.
To iterate this function, we take the previous result, 2, and feed it back into the equation as
x. This gives us a new
xnext value of 4.
If we iterate again we will get a value of 8, the n 16, then 32, and so on. On each iteration, the value gets exponentially bigger, without bounds.
Here is some Python code to illustrate an iterated function:
x = 1 for i in range(10): xnext = x * 2 x = xnext
This iterates the function 10 times. We don't really need the variable
xnext, we can simply do this (the result will be the same):
x = 1 for i in range(10): x = x * 2
Different equations give different behaviours. In the one above the value grows larger and larger. If we tried the function
x * 0.5, starting with a value of 1 we would get the sequence 0.5, 0.25, 0.125 etc. The value gradually decreases towards 0 (but never actually reaches 0). This value is bounded, all the values are in the range 0 to 1.
x * -1 gives another different behaviour. Starting from 1 we would et the sequence -1, 1, -1, 1 etc. The value alternates between 1 and -1.
Many fractals use iterated functions in two dimensions. Here is an example:
xnext = 1.4*x*x + y - 1 ynext = 0.3*x
From a starting value
(x, y), the equations calculate new values
(xnext, ynext). This values can be fed back into the equations iteratively to craete a sequence of
(x, y) values, as in this loop:
x = 1 y = 1 for i in range(10): xnext = 1.4*x*x + y - 1 ynext = 0.3*x x = xnext y = ynext
Notice that it is important that we calculate
ynext before we change either
y. We can't do this:
x = 1 y = 1 for i in range(10): x = 1.4*x*x + y - 1 # WRONG!!! y= 0.3*x
This won't work because we are changing the value of
x before we have calculated
y. But we can use this neat bit of Python syntax to avoid using temporary variables:
x = 1 y = 1 for i in range(10): x, y = 1.4*x*x + y - 1, 0.3*x
With this code, the values
1.4*x*x + y - 1 and
0.3*x are calculated first, and packed into a tuple. The assignment then unpacks the tuple and puts the values into
y. This means that both calculations are done before
y are updated.
There are several ways that a 2D iterated function can be used to create a fractal.
(x, y)that is in an almost a random place compared to the previous value. Rather than joining the points, we simply place a small dot at each point that occurs. After plotting thousands of points, we see that the points aren't completely random, but actually form interesting and often beautiful patterns - these are called strange attractors. The equations above create the Henon Attractor and the King's Dream attractor but there are many other fractals of this kind.
(x, y), we only care about whether the value is bounded or unbounded (that is, do
ystay small forever, or do they grow to huge values). We create a map based on the initial conditions, and the number of iterations before the values exceed some value. These are called escape-time fractals and the famous Mandelbrot Set is an example.
An iterated function system (IFS) is a another type of fractal created when the functions of x and y from an affine transformation.
An affine transformation is a way to transform one set of
(x, y) coordinates onto another. Starting with out initial coordinate space, we can translate the space, rotate it, scale it to be larger of smaller, flip it over, or skew it, or any combination of those things. That is called an affine transformation.
In an IFS we use two or more different affine transformations and do the following:
We do this procedure thousands of times, using a random start point each time, and the resulting distribution of points will create a shape.
The useful thing about an IFS is that we can use a technique called the collage theorem to actually design a set of affine transformations that will create a specific fractal shape.
Copyright (c) Axlesoft Ltd 2020