Phrallic Frolics

It’s a classic of low literature:

There was a young man of Devizes
Whose balls were of different sizes:
     The one was so small
     ’Twas no use at all;
But t’other won several prizes.

But what if he had been a young man with balls of different colours? This is a core question I want to interrogate issues around in terms of the narrative trajectory of this blog-post. Siriusly. But it’s not the keyliest core question. More corely keyly still, I want to ask what a fractal phallus might look like. Or a phrallus, for short. The narrative trajectory initializes with this fractal, which is known as a pentaflake (so-named from its resemblance to a snowflake):

Pentaflake — a pentagon-based fractal


It’s created by repeatedly replacing pentagons with six smaller pentagons, like this:

Pentaflake stage 0


Pentaflake stage 1


Pentaflake stage 2


Pentaflake stage 3


Pentaflake stage 3


Pentaflake stage 4


Pentaflake (animated)


Pentaflake (static)


This is another version of the pentaflake, missing the central pentagon of the six used in the standard pentaflake:

No-Center Pentaflake stage 0


No-Center Pentaflake stage 1


Stage 2


Stage 3


Stage 4


No-Center Pentaflake (animated)


No-Center Pentaflake (static #1)


No-Center Pentaflake (static #2)


The phrallus, or fractal phallus, begins with an incomplete version of the first stage of the pentaflake (note balls of different colours):

Phrallus stage 1


Phrallus stage 1 (monochrome)


Phrallus stage 2


Phrallus stage 3


Stage 4


Stage 5


Stage 6


Stage 7


Stage 8


And there you have it: a fractal phallus, or phrallus. Here is an animated version:

Phrallus (animated)


Phrallus (static)


But the narrative trajectory is not over. The center of the phrallus can be rotated to yield mutant phralloi. Stage #1 of the mutants looks like this:

Phrallus (mutation #1)


Phrallus (mutation #2)


Phrallus (mutation #3)


Phrallus (mutation #4)


Phrallus (mutation #5)


Mutant phralloi (rotating)


Here are some animations of the mutant phralloi:

Phrallus (mutation #3) (animated)


Phrallus (mutation #5) (animated)


This mutation doesn’t position the pentagons in the usual way:

Phrallus (another upright version) (animated)


The static mutant phralloi look like this:

Phrallus (mutation #2)


Phrallus (mutation #3)


Phrallus (upright #2)


And if the mutant phralloi are combined in a single image, they rotate like this:

Mutant phralloi (rotating)


Coloured mutant rotating phralloi #1


Coloured mutant rotating phralloi #2


Advertisements

The Swing’s the Thing

Order emerges from chaos with a triangle or pentagon, but not with a square. That is, if you take a triangle or a pentagon, chose a point inside it, then move the point repeatedly halfway towards a vertex chosen at random, a fractal will appear:

triangle

Sierpiński triangle from point jumping halfway to randomly chosen vertex


pentagon

Sierpiński pentagon from point jumping halfway to randomly chosen vertex


But it doesn’t work with a square. Instead, the interior of the square slowly fills with random points:

square

Square filling with point jumping halfway to randomly chosen vertex


As I showed in Polymorphous Perverticity, you can create fractals from squares and randomly moving points if you ban the point from choosing the same vertex twice in a row, and so on. But there are other ways. You can take the point, move it towards a vertex at random, then swing it around the center of the square through some angle before you mark its position, like this:

square_sw90

Point moves at random, then swings by 90° around center


square_sw180

Point moves at random, then swings by 180° around center


You can also adjust the distance of the point from the center of the square using a formula like dist = r * rmdist, where dist is the distance, r is the radius of the circle in which the circle is drawn, and rm takes values like 0.1, 0.25, 0.5, 0.75 and so on:

square_dist_rm0_05

Point moves at random, dist = r * 0.05 – dist


square_dist_rm0_1

Point moves at random, dist = r * 0.1 – dist


square_dist_rm0_2

Point moves at random, dist = r * 0.2 – dist


But you can swing the point while applying a vertex-ban, like banning the previously chosen vertex, or the vertex 90° or 180° away. In fact, swinging the points converts one kind of vertex ban into the others.

square_ban0

Point moves at random towards vertex not chosen previously


square_ban0_sw405

Point moves at random, then swings by 45°


square_ban0_sw360

Point moves at random, then swings by 360°


square_ban0_sw697

Point moves at random, then swings by 697.5°


square_ban0_sw720

Point moves at random, then swings by 720°


square_ban0_sw652

Point moves at random, then swings by 652.5°


square_ban0_swing_va_animated

Animated angle swing


You can also reverse the swing at every second move, swing the point around a vertex instead of the center or around a point on the circle that encloses the square. Here are some of the fractals you get applying these techniques.
square_ban0_sw45_rock

Point moves at random, then swings alternately by 45°, -45°


square_ban0_sw90_rock

Point moves at random, then swings alternately by 90°, -90°


square_ban0_sw135_rock

Point moves at random, then swings alternately by 135°, -135°


square_ban0_sw180_rock

Point moves at random, then swings alternately by 180°, -180°


square_ban0_sw225

Point moves at random, then swings alternately by 225°, -225°


square_ban0_sw315

Point moves at random, then swings alternately by 315°, -315°


square_ban0_sw360_rock

Point moves at random, then swings alternately by 360°, -360°


square_swing_vx0_va_animated

Animated alternate swing


square_circle_sw45

Point moves at random, then swings around point on circle by 45°


square_circle_sw67

Point moves at random, then swings around point on circle by 67.5°


square_circle_sw90

Point moves at random, then swings around point on circle by 90°


square_circle_sw112

Point moves at random, then swings around point on circle by 112.5°


square_circle_sw135

Point moves at random, then swings around point on circle by 135°


square_circle_sw180

Point moves at random, then swings around point on circle by 180°


square_circle_sw_animated

Animated circle swing


For Revver and Fevver

This shape reminds me of the feathers on an exotic bird:

feathers

(click or open in new window for full size)


feathers_anim

(animated version)


The shape is created by reversing the digits of a number, so you could say it involves revvers and fevvers. I discovered it when I was looking at the Halton sequence. It’s a sequence of fractions created according to a simple but interesting rule. The rule works like this: take n in base b, reverse it, and divide reverse(n) by the first power of b that is greater thann.

For example, suppose n = 6 and b = 2. In base 2, 6 = 110 and reverse(110) = 011 = 11 = 3. The first power of 2 that is greater than 6 is 2^3 or 8. Therefore, halton(6) in base 2 equals 3/8. Here is the same procedure applied to n = 1..20:

1: halton(1) = 1/10[2] → 1/2
2: halton(10) = 01/100[2] → 1/4
3: halton(11) = 11/100[2] → 3/4
4: halton(100) = 001/1000[2] → 1/8
5: halton(101) = 101/1000[2] → 5/8
6: halton(110) = 011/1000 → 3/8
7: halton(111) = 111/1000 → 7/8
8: halton(1000) = 0001/10000 → 1/16
9: halton(1001) = 1001/10000 → 9/16
10: halton(1010) = 0101/10000 → 5/16
11: halton(1011) = 1101/10000 → 13/16
12: halton(1100) = 0011/10000 → 3/16
13: halton(1101) = 1011/10000 → 11/16
14: halton(1110) = 0111/10000 → 7/16
15: halton(1111) = 1111/10000 → 15/16
16: halton(10000) = 00001/100000 → 1/32
17: halton(10001) = 10001/100000 → 17/32
18: halton(10010) = 01001/100000 → 9/32
19: halton(10011) = 11001/100000 → 25/32
20: halton(10100) = 00101/100000 → 5/32…

Note that the sequence always produces reduced fractions, i.e. fractions in their lowest possible terms. Once 1/2 has appeared, there is no 2/4, 4/8, 8/16…; once 3/4 has appeared, there is no 6/8, 12/16, 24/32…; and so on. If the fractions are represented as points in the interval [0,1], they look like this:

line1_1_2

point = 1/2


line2_1_4

point = 1/4


line3_3_4

point = 3/4


line4_1_8

point = 1/8


line5_5_8

point = 5/8


line6_3_8

point = 3/8


line7_7_8

point = 7/8


line_b2_anim

(animated line for base = 2, n = 1..63)


It’s apparent that Halton points in base 2 will evenly fill the interval [0,1]. Now compare a Halton sequence in base 3:

1: halton(1) = 1/10[3] → 1/3
2: halton(2) = 2/10[3] → 2/3
3: halton(10) = 01/100[3] → 1/9
4: halton(11) = 11/100[3] → 4/9
5: halton(12) = 21/100[3] → 7/9
6: halton(20) = 02/100 → 2/9
7: halton(21) = 12/100 → 5/9
8: halton(22) = 22/100 → 8/9
9: halton(100) = 001/1000 → 1/27
10: halton(101) = 101/1000 → 10/27
11: halton(102) = 201/1000 → 19/27
12: halton(110) = 011/1000 → 4/27
13: halton(111) = 111/1000 → 13/27
14: halton(112) = 211/1000 → 22/27
15: halton(120) = 021/1000 → 7/27
16: halton(121) = 121/1000 → 16/27
17: halton(122) = 221/1000 → 25/27
18: halton(200) = 002/1000 → 2/27
19: halton(201) = 102/1000 → 11/27
20: halton(202) = 202/1000 → 20/27
21: halton(210) = 012/1000 → 5/27
22: halton(211) = 112/1000 → 14/27
23: halton(212) = 212/1000 → 23/27
24: halton(220) = 022/1000 → 8/27
25: halton(221) = 122/1000 → 17/27
26: halton(222) = 222/1000 → 26/27
27: halton(1000) = 0001/10000 → 1/81
28: halton(1001) = 1001/10000 → 28/81
29: halton(1002) = 2001/10000 → 55/81
30: halton(1010) = 0101/10000 → 10/81

And here is an animated gif representing the Halton sequence in base 3 as points in the interval [0,1]:

line_b3_anim


Halton points in base 3 also evenly fill the interval [0,1]. What happens if you apply the Halton sequence to a two-dimensional square rather a one-dimensional line? Suppose the bottom left-hand corner of the square has the co-ordinates (0,0) and the top right-hand corner has the co-ordinates (1,1). Find points (x,y) inside the square, with x supplied by the Halton sequence in base 2 and y supplied by the Halton sequence in base 3. The square will gradually fill like this:

square1

x = 1/2, y = 1/3


square2

x = 1/4, y = 2/3


square3

x = 3/4, y = 1/9


square4

x = 1/8, y = 4/9


square5

x = 5/8, y = 7/9


square6

x = 3/8, y = 2/9


square7

x = 7/8, y = 5/9


square8

x = 1/16, y = 8/9


square9

x = 9/16, y = 1/27…


square_anim

animated square


Read full page: For Revver and Fevver

Performativizing the Polygonic

Maths is a mountain: you can start climbing in different places and reach the same destination. There are many ways of proving the irrationality of √2 or the infinitude of the primes, for example. But you can also arrive at the same destination by accident. I’ve found that when I use different methods of creating fractals. The same fractals appear, because apparently different algorithms are actually the same underneath.

But different methods can create unique fractals too. I’ve found some new ones by using what might be called point-to-point recursion. For example, there are ten ways to select three vertices from the five vertices of a pentagon: (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5). Find the midpoint of the first three-point set, (1, 2, 3). Then select two vertices to go with this midpoint, creating a new three-point set, and find the midpoint again. And so on. The process looks like this, with the midpoints shown for all the three-point sets found at each stage:

v5_p3_stage1

vertices = 5, choose sets of 3 points, find mid-point of each

v5_p3_stage2

v5_p3_stage3


At stage 5, the fractal looks like this:

v5_p3_static

v = 5, p = 3


Note that when pixels are used again, the colour changes. That’s another interesting thing about maths: limits can sometimes produce deeper results. If these fractals were drawn at very high resolution, pixels would only be used once and the colour would never change. As it is, low resolution means that pixels are used again and again. But some are used more than others, which is why interesting colour effects appear.

If the formation of the fractal is animated, it looks like this (with close-ups of even deeper stages):
v5_p3


Here are some more examples:

v4c_p2_static

v = 4 + central point, p = 2 (cf. Fingering the Frigit)

v4c_p2

v = 4c, p = 2 (animated)


v4_p3_static

v = 4, p = 3

v4_p3


v5_p4_static

v = 5, p = 4

v5_p4


v5c_p3_static

v = 5 + central point, p = 3

v5c_p3


v5c_p4

v = 5c, p = 4


v5c_p5

v = 5c, p = 5


v6_1_p6

v = 6 + 1 point between each pair of vertices, p = 6


v6_p2

v = 6, p = 2


v6_p3_static

v = 6, p = 3

v6_p3


v6_p4

v = 6, p = 4


v6c_p2_static

v = 6c, p = 2 (cf. Fingering the Frigit)

v6c_p2


v6c_p3_static

v = 6c, p = 3

v6c_p3


v6c_p4

v = 6c, p = 4


v7_p3

v = 7, p = 3


v7_p4_static

v = 7, p = 4

v7_p4


v7_p5_static

v = ,7 p = 5

v7_p5


v7_p4

v = 7c, p = 4


v3_1_p2

v = 3+1, p = 2


v3_1_p3

v = 3+1, p = 3


v3_1_p4

v = 3+1, p = 4


v3_2_p5

v = 3+2, p = 5


v3c_1_p2

v = 3c+1, p = 2


v3c_1_p4

v = 3c+1, p = 4


v3c_p2

v = 3c, p = 2


v3c_p3

v = 3c, p = 3


v4_1_p3

v = 4+1, p = 3


v4_1_p4

v = 4+1, p = 4


v4_1_p5

v = 4+1, p = 6


v4_1_p6

v = 4+1, p = 2


v4c_1_p4

v = 4c+1, p = 4


v4c_p3_static

v = 4c, p = 3

v4c_p3


v5_1_p4_va

v = 5+1, p = 4 (and more)


v5_p2

v = 5, p = 2


Polymorphous Perverticity

As I’ve explained before on Overlord of the Über-Feral, the planet’s premier purveyor of polygonic performativity (probably (possibly (perspectivistically))), it works with triangles and pentagons, but not with squares. And what is “it”? A simple procedure in which you create a polygon, choose a point inside it, then repeatedly move half-way towards a vertex chosen at random, marking each new position as you go.

pol3_4_5

When the polygon has three vertices, you get a Sierpiński triangle. When it has five, you get what might be called a  Sierpiński pentagon. When it has four, you get nothing. Or rather: you get everything, because the whole interior of the square gradually fills with points. But, as I’ve also explained before, there’s a simple way to change this. You can adapt the procedure so that a vertex can’t be chosen twice in a row, and so on.

When the rule is “No vertex twice in a row”, you get this fractal (colours change as a pixel is selected again):

pol4_0

But you can also use what might be a vertex increment, or vi, whereby you disallow vertices that are next to the previously chosen vertex, or two positions away, and so on. When the rule is “No vertex twice in a row”, the disallowed vertex is (v + 0), that is, vi = 0. If vi = 2 and the rule is disallow(v + 2), this fractal appears (when vi = 1, there’s no fractal):

pol4_2

v = 4, vi = 2

pol4_2_anim


You can extend these rules to apply not just to the previously chosen vertex, but also to the vertex chosen before that. Here are some fractals produced by the rule disallow(v[1] + vi[1], v[2] + vi[2]), where v[1] is the vertex previously chosen and v[2] is the vertex chosen before that:

pol4_1_2

v = 4, vi[1] = 1, vi[2] = 2

pol4_1_2_anim


pol4_2_0

v = 4, vi[1] = 2, vi[2] = 0

pol4_2_0_anim

pol4_2_0_white


pol4_2_1

v = 4, vi[1] = 2, vi[2] = 1

pol4_2_1_anim


pol4_2_2

v = 4, vi[1] = 2, vi[2] = 2

pol4_2_2_anim


And here are some fractals produced by the rule disallow(v[1] + vi[1], v[2] + vi[2], v[3] + vi[3]):

pol4_1_1_0

v = 4, vi[1] = 1, vi[2] = 1, vi[3] = 0

pol4_1_1_0_anim


pol4_1_1_2

v = 4, vi[1] = 1, vi[2] = 1, vi[3] = 2

pol4_1_1_2_anim


Applying these rules to pentagons rather than squares doesn’t produce such a dramatic difference, because the original procedure – choose any vertex at random, taking no account of previous choices – produces a fractal when v = 5, as noted above, but not when v = 4. Nevertheless, here are some fractals for v > 4:

pol5_0

v = 5, vi = 0


pol5_1

v = 5, vi = 1

pol5_1_anim


pol5_2

v = 5, vi = 2

pol5_2_anim


pol5_0_0

v = 5, vi[1] = 0, vi[2] = 0


pol5_1_0

v = 5, vi[1] = 1, vi[2] = 0


pol5_2_0

v = 5, vi[1] = 2, vi[2] = 0

pol5_2_0_anim


pol5_1_1

v = 5, vi[1] = 1, vi[2] = 1

pol5_1_1_anim


pol5_1_1_1

v = 5, vi[1] = 1, vi[2] = 1, vi[3] = 1


pol5_va2

v = 5, vi = various


pol6_1

v = 6, vi = 1

pol6_1_anim

Fingering the Frigit

Fingers are fractal. Where a tree has a trunk, branches and twigs, a human being has a torso, arms and fingers. And human beings move in fractal ways. We use our legs to move large distances, then reach out with our arms over smaller distances, then move our fingers over smaller distances still. We’re fractal beings, inside and out, brains and blood-vessels, fingers and toes.

But fingers are fractal are in another way. A digit – digitus in Latin – is literally a finger, because we once counted on our fingers. And digits behave like fractals. If you look at numbers, you’ll see that they contain patterns that echo each other and, in a sense, recur on smaller and smaller scales. The simplest pattern in base 10 is (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). It occurs again and again at almost very point of a number, like a ten-hour clock that starts at zero-hour:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9…
10, 11, 12, 13, 14, 15, 16, 17, 18, 19…
200… 210… 220… 230… 240… 250… 260… 270… 280… 290…

These fractal patterns become visible if you turn numbers into images. Suppose you set up a square with four fixed points on its corners and a fixed point at its centre. Let the five points correspond to the digits (1, 2, 3, 4, 5) of numbers in base 6 (not using 0, to simplify matters):

1, 2, 3, 4, 5, 11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55, 61, 62, 63, 64, 65… 2431, 2432, 2433, 2434, 2435, 2441, 2442, 2443, 2444, 2445, 2451, 2452…

Move between the five points of the square by stepping through the individual digits of the numbers in the sequence. For example, if the number is 2451, the first set of successive digits is (2, 4), so you move to a point half-way between point 2 and point 4. Next come the successive digits (4, 5), so you move to a point half-way between point 4 and point 5. Then come (5, 1), so you move to a point half-way between point 5 and point 1.

When you’ve exhausted the digits (or frigits) of a number, mark the final point you moved to (changing the colour of the pixel if the point has been occupied before). If you follow this procedure using a five-point square, you will create a fractal something like this:
fractal4_1single

fractal4_1
A pentagon without a central point using numbers in a zero-less base 7 looks like this:
fractal5_0single

fractal5_0
A pentagon with a central point looks like this:
fractal5_1single

fractal5_1
Hexagons using a zero-less base 8 look like this:
fractal6_1single

fractal6_1


fractal6_0single

fractal6_0
But the images above are just the beginning. If you use a fixed base while varying the polygon and so on, you can create images like these (here is the program I used):
fractal4


fractal5


fractal6789

Get Your Prox Off

Create a triangle. Find a point somewhere inside it. Choose a corner at random and move halfway towards it. Mark the new point. Repeat the procedure: choose, move, mark. Repeat again and again. In time, a fractal will appear:

siertri

However, if you try the same thing with a square – choose a corner at random, move halfway towards it, mark the new point, repeat – no fractal appears. Instead, the points fill the interior of the square:

sierquad

But what happens if you impose restrictions on the randomly chosen corner (or chorner)? Suppose you can’t choose the same corner twice in a row. If this rule is applied to the square, this fractal appears:

restrict4_T


restrict4_Tanim

Now apply the no-corner-twice-in-a-row rule to a square that contains a central chorner. This fractal appears:

restrict4_Tc

And if the rule is that you can choose a corner twice in a row but not thrice? This fractal appears:

restrict4FT


restrict4FTc


Here is the rule is that a corner can’t be chosen if it was chosen two moves ago:

restrict4_3F

But what if the restriction is based not on how often or when a corner is chosen, but on its proximity, i.e. how near it is to the marked point? If the nearest corner can’t be chosen, the result is the same as the no-corner-twice-in-a-row rule:

prox4_1

But if the second-nearest corner can’t be chosen, this fractal appears:

prox4_2

This is the fractal when the third-nearest corner can’t be chosen:

prox4_3

And this is the fractal when the fourth-nearest, or most distant, corner can’t be chosen:

prox4_4

Here are the same restrictions applied to a pentagon:

prox5_1

Nearest corner forbidden


prox5_2

Second-nearest corner forbidden


prox5_3

Third corner forbidden


prox5_4

Fourth corner forbidden


prox5_5

Fifth corner forbidden


prox5_5anim

Fifth corner forbidden (animated)

And a pentagon with a central chorner:

prox5_anim_c

Now try excluding more than one corner. Here are pentagons excluding the n-nearest and n+1-nearest corners (for example, the nearest and second-nearest corners; the second-nearest and third-nearest; and so on):

prox5n_n1_anim

But what if the moving point is set equal to the n-nearest corner before it moves again? If the corner is the second-nearest and the shape is a triangle with a central chorner, this is the fractal that appears:

prox3_set2c


prox3_set2c_anim

Animated version

And here is the same rule applied to various n-nearest corners in a pentagon:

prox5_set_anim

Hex Appeal

A polyiamond is a shape consisting of equilateral triangles joined edge-to-edge. There is one moniamond, consisting of one equilateral triangle, and one diamond, consisting of two. After that, there are one triamond, three tetriamonds, four pentiamonds and twelve hexiamonds. The most famous hexiamond is known as the sphinx, because it’s reminiscent of the Great Sphinx of Giza:

sphinx_hexiamond

It’s famous because it is the only known pentagonal rep-tile, or shape that can be divided completely into smaller copies of itself. You can divide a sphinx into either four copies of itself or nine copies, like this (please open images in a new window if they fail to animate):

sphinx4

sphinx9

So far, no other pentagonal rep-tile has been discovered. Unless you count this double-triangle as a pentagon:

double_triangle_rep-tile

It has five sides, five vertices and is divisible into sixteen copies of itself. But one of the vertices sits on one of the sides, so it’s not a normal pentagon. Some might argue that this vertex divides the side into two, making the shape a hexagon. I would appeal to these ancient definitions: a point is “that which has no part” and a line is “a length without breadth” (see Neuclid on the Block). The vertex is a partless point on the breadthless line of the side, which isn’t altered by it.

But, unlike the sphinx, the double-triangle has two internal areas, not one. It can be completely drawn with five continuous lines uniting five unique points, but it definitely isn’t a normal pentagon. Even less normal are two more rep-tiles that can be drawn with five continuous lines uniting five unique points: the fish that can be created from three equilateral triangles and the fish that can be created from four isosceles right triangles:

equilateral_triangle_fish_rep-tile

right_triangle_fish_rep-tile

V for Vertex

To create a simple fractal, take an equilateral triangle and divide it into four more equilateral triangles. Remove the middle triangle. Repeat the process with each new triangle and go on repeating it. You’ll end up with a shape like this, which is known as the Sierpiński triangle, after the Polish mathematician Wacław Sierpiński (1882-1969):

Sierpinski triangle

But you can also create the Sierpiński triangle one pixel at a time. Choose any point inside an equilateral triangle. Pick a corner of the triangle at random and move half-way towards it. Mark this spot. Then pick a corner at random again and move half-way towards the corner. And repeat. The result looks like this:

triangle

A simple program to create the fractal looks like this:

initial()
repeat
  fractal()
  altervariables()
until false

function initial()
  v = 3 [v for vertex]
  r = 500
  lm = 0.5
endfunc

function fractal()
  th = 2 * pi / v
[the following loop creates the corners of the triangle]
  for l = 1 to v
    x[l]=xcenter + sin(l*th) * r
    y[l]=ycenter + cos(l*th) * r
  next l
  fx = xcenter
  fy = ycenter
  repeat
    rv = random(v)
    fx = fx + (x[rv]-fx) * lm
    fy = fy + (y[rv]-fy) * lm
    plot(fx,fy)
  until keypressed
endfunc

function altervariables()
[change v, lm, r etc]
endfunc

In this case, more is less. When v = 4 and the shape is a square, there is no fractal and plot(fx,fy) covers the entire square.

square

When v = 5 and the shape is a pentagon, this fractal appears:

pentagon

But v = 4 produces a fractal if a simple change is made in the program. This time, a corner cannot be chosen twice in a row:

square_used1

function initial()
  v = 4
  r = 500
  lm = 0.5
  ci = 1 [i.e, number of iterations since corner previously chosen]
endfunc

function fractal()
  th = 2 * pi / v
  for l = 1 to v
    x[l]=xcenter + sin(l*th) * r
    y[l]=ycenter + cos(l*th) * r
    chosen[l]=0
  next l
  fx = xcenter
  fy = ycenter
  repeat
    repeat
      rv = random(v)
    until chosen[rv]=0
    for l = 1 to v
      if chosen[l]>0 then chosen[l] = chosen[l]-1
    next l
    chosen[rv] = ci
    fx = fx + (x[rv]-fx) * lm
    fy = fy + (y[rv]-fy) * lm
    plot(fx,fy)
  until keypressed
endfunc

One can also disallow a corner if the corner next to it has been chosen previously, adjust the size of the movement towards the chosen corner, add a central point to the polygon, and so on. Here are more fractals created with such variations:

square_used1_center

square_used1_vi1

square_used1_vi2

square_used2

pentagon_lm0.6

pentagon_used1_5_vi1

hexagon_used1_6_vi3