Background
Fractals do not have a generally accepted mathematical definition — we can always find something that can be considered a fractal based on its properties, but is irrevelent (e.g. self-similarity is true in case of straight lines also), or something that would be worth discussing, though it does not fulfil the definition. The construction of the abstract, deterministic fractals discussed here obviously differs a lot from the stochastic fractals imitating natural forms, yet there is a sense of principle similarity. The lack of a clear definition does not mean that the studying of fractals would not raise interesting problems.
The shape in the illustration is the Koch snowflake, one of the first and perhaps the best-known fractals that can be generated recursively based on clear substitution rules.
The initial shape (initiator) is a regular polygon, and the replacement rule (generator) is to divide the sides of the polygon into thirds, then replace the middle third of each side with two other sides of a smaller regular triangle. As we repeat this substitution recursively, the sum of the side lengths (the circumference of the polygon) increases 4/3 times in each step – that is, in principle (after an infinite number of iterations) it becomes infinite. Meanwhile, its area is obviously finite, since it never leaves the area of the circumscribed circle.
A possible solution: DOWNLOAD
An established formal language for describing fractals is the L-system (after Arisztid Lindenmayer), whose grammatical rules have to be applied iteratively. Due to the self-similarity resulting from this recursive process fractal-like forms are easy to describe this way. If each symbol is associated with exactly one output, then the system is deterministic, if there are more possible outputs (and each one is selected with a certain probability during each iteration) then the system is stochastic.
The Koch snowflake can be described in a simple way as an L-system using a single variable (f) and two constants (+, –). The f (forward) draws a section, + means turning left (120°), – means turning right (60°). The starting regular triangle can be written in the form f+f+f, and the substitution rule in the form f 🡢 f-f+f-f (which can be easily implemented with the SUBSTITUTE() function). The first iteration looks like this: f–f+f–f+f–f+f–f+f–f+f–f. Unfortunately, the next iteration is not really suitable for human consumption: f–f+f–f–f–f+f–f+f–f+f–f–f–f+f–f+f–f+f–f–f–f+f–f+f–f+f–f–f–f+f–f+f–f+f–f–f–f+f–f+f–f+f–f–f–f+f–f. Another inconvenient feature of this system is that it uses relative angles, i.e. it specifies the direction of the next segment compared to the direction of the previous segment — therefore we recommend using a new system.
Parameters
• Identifiers
A possible solution is to represent the fractal as a sequence of numbers in a given positional numeral system.
The number of fractional digits corresponds to the iteration steps of the fractal, and the difference between the adjacent elements of the series is always the smallest number that can be described with the given number of digits. Thus, in step 0, the sequence contains only whole numbers, from zero to the number of sides of the starting polygon, minus one (in the case of a triangle, 0-1-2), but each new iteration step adds a new position for fractional digits.
The radix or base of the number representing the fractal corresponds to the multiplication number of the segments created during the iteration steps. In case of the Koch snowflake the iteration replaces every segment by four shorter segments, hence, it can be represented in a quaternary (radix 4) system (which uses digits from 0 through 3).
Hence, all segments of a given it iteration of a fractal can be denoted by pgn·itnit elements of a sequence in a radix itn numeral system.
In the case of the Koch snowflake, the 1st iteration (all 3 sides divided into 4 segments) can be described by 3×41=12 quaternary numbers:
0.0, 0.1, 0.2, 0.3, 1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3
Numerical parameters
- Name a cell (B1) as it and enter the number of iterations to be plotted (e.g. 4).
- Name a cell (B4) as pgn and enter the number of the sides of the polygon (3).
- Name a cell (B17) as itn and enter the number of segments resulting in each iterative step (4).
- Name a cell (B19) as n and calculate the number of segments (pgn·itnit).
=pgn*itn^it
• Lengths
The overall size of the fractal does not change during the iteration, the circumference only increases due to the more accurate measurement, i.e. because of the the shorter ruler.
- In step 0 the pgl side length of the polygon can be arbitrary.
- During the iteration, the length of the segments changes according to the itl ratio corresponding to the generation rule.
Length parameters
- Name a cell (B3) as pgl and enter the side length of the polygon (e.g. 3.0).
- Name a cell (B16) as itl and enter the ratio of the length of the segments resulting from each iterative step (1/3).
- Name a cell (B18) as l and calculate the length of the segments (pgl·itlit).
=pgl*itl^it - Name a cell (B5) as xs and enter the x coordinate of the starting point (e.g. –½pgl).
=-1/2*pgl - Name a cell (B6) as ys and enter the y coordinate of the starting point (e.g. –⅓ · 3½ · pgl/2).
=-1/3*3^(1/2)*pgl/2
• Directions
Of course, the above numbers only form the logical framework, they do not in themselves decide the direction of the segments
- As we have seen, the digits of the integer part represent the sides of the original polygon. Since the sum of the exterior angles of the polygon is 360°, if the first side is horizontal (0°), the direction of side i is i · 360°/pgn.
- The fractional digits represent the segments resulting during the iteration — their angles determine the characteristic pattern of the fractal.
Direction parameters
- Create an array (B7:B11) representing the directions of the sides of the polygon (i · 360°/pgn).
=SEQUENCE(pgn; ; 0; (360/pgn)) - Name this range dynamically as _pgd
=Sheet1!$B$7# - Enter the list of directions belonging to the set of segments in a the iteration in a range of cells (B21:B24).
0 | -60 | 60 | 0 - Name this range dynamically as _itd
=OFFSET(Sheet1!$B$21; ; ; itn)
In order to represent the fractal, the coordinates of each section must be calculated. A simple solution to this is to follow the path of the line starting from the starting point – since all sections have equal length, it is sufficient to know the direction of the segment starting from the current point. The recursive solution outlined above is suitable for this.
Unfortunately, the program cannot calculate in a base-4 number system, so we have to generate the series of numbers.
Identifiers
- From the second cell of an empty column, create a range of n rows representing the segments of the fractal:
=SEQUENCE(n; ; 0) - Name this range dynamically as _i
- To the right of the previous column, in the first row, create the descending sequence denoting the it+1 iteration steps:
=SEQUENCE(1; it+1; it; -1) - Name this range dynamically as _g
- Generate the identifiers based on these two dynamic ranges:
=MOD(INT(_i / itn^_g); itn)
The above formula may not be trivial — it's worth thinking about what it does in which row and column.
It is easy to come up with a rule where the number of segments (itn) resulting from the iterative steps is ten — meaning that the identifiers will be in the decimal number system (pgn= 4).
- itl= 1/6
- itn= 10
- _itd= 0 | 60 | -60 | 60 | 60 | -60 | -60 | 60 | -60 | 0
Since you have to use the usual decimal number system here, it might be easier to understand the formula.
However, we are not interested in the identifier itself, but rather the angle that can be calculated based on its digits.
Directions
- Transform the formula so that it uses an abbreviation instead of the relatively complicated calculation:
=LET( S; INT(_i / itn^_g); MOD(S; itn)) - Transform the formula again so that in the case of the first column it reads the value from the _pgd array of the sides, otherwise from the _itd array of the iterations:
=LET( S; INT(_i/itn^_g); IF(_g=it; INDEX(_pgd;S+1); INDEX(_itd; MOD(S;itn)+1))) - Name this range dynamically as _d
Coordinates
The previous _d array denotes the directions corresponding to the each iteration step — they just need to be added together.
Segment directions
- In the second row of an empty column find the angles belonging to the first segment:
=XLOOKUP(@_i; _i; _d) - We need the sum of all these angles, so let's modify the formula accordingly:
=MOD(SUM(XLOOKUP( @_i; _i; _d));360) - Since this formula does not form a dynamic range, copy it into the first few thousand rows
- Where the domain overextends _i, we get an error message, which is worth avoiding:
=IFERROR(MOD(SUM(XLOOKUP( @_i; _i; _d));360);"·") - Name this range dynamically as _a
=OFFSET(Sheet1!$W$2;;; n)
The resulting array gives the (absolute) direction of each edge.
In order to create a diagram, we need the coordinates of each point.
Vertex coordinates
- Enter the x and y coordinates of the starting point in the first row of two adjacent empty columns (e.g. X1, Y1).
=xs | =ys - Starting from the second cell of these columns, add the x and y projections then copy it downwards manually:
=X1 +IFERROR(l* COS(RADIANS(@_a)); 0)
=Y1 +IFERROR(l* SIN(RADIANS(@_a)); 0)
Depicting the fractal
- Select the range of coordinates (X1:Y40000)
- In the Insert menu, in the Charts group select the Scatter with Straight Lines chart type.
- Since the figure is not automatically proportional, set the maximum values of the x and y axes to the same value and adjust the ratio of the chart.