Function Repository Resource:

GeneralizedChaosGame

Create fractals with random partial jumps toward reference points

Contributed by: Sander Huisman

ResourceFunction["GeneralizedChaosGame"][reg,n]

plots a fractal by iteratively jumping n times toward a random point inside the reference geometry reg by jumping halfway.

ResourceFunction["GeneralizedChaosGame"][reg,n,jspec]

uses the jumping specification jspec.

ResourceFunction["GeneralizedChaosGame"][reg,n,jspec,format]

formats the result according to the output specification format.

Details and Options

Possible forms for reg are:

n points equally spaced around the unit circle

{p₁,p₂,…}

uses the points p_i as the reference geometry

reg

uses the region reg as the reference geometry

Some typical region specifications include Line, Circle, Region, etc.

reg can be specified in any dimension.

Possible forms for n are:

performs n iterations

Automatic

performs 10⁴ iterations

ResourceFunction["GeneralizedChaosGame"][reg] performs 10⁴ iterations.

Possible forms for jspec are:

jumps a distance α toward the next reference point

Scaled[α]

jumps a fraction α toward the next reference point

Automatic

jumps halfway toward the next reference point

{s₁,s₂,…}

cycle through the jumping specifications s_i

{"OriginIndexed", {s₁,s₂,…s_n}}

jump using jump specification s_i, where i is the index of the last visited reference point

{“DestinationIndexed”, {s₁,s₂,…s_n}}

jump using jump specification s_i, where i is the index of the next reference point

func

uses the function func to calculate the next position

The arguments supplied to func are the last position and the next reference point.

Possible forms for format are:

"Graphics"

outputs a graphical representation of the results

"List"

outputs the list of coordinates visited

"DensityPlot"

outputs a graphical representation of the density of points

Graphical output is limited to dimensions 1, 2 and 3.

ResourceFunction["GeneralizedChaosGame"] has the following options:

"PointStyle"

Automatic

style to use for the points

"ReferenceGeometryStyle"

Automatic

style to use for the reference geometry

"Probabilities"

Automatic

list of probabilities representing the chance to jump to each reference point

"ExclusionRegionFunction"

None

jumps that land on positions for which the function yields True are not allowed

"Choices"

All

restrict the possible points to jump to based on the current position or history

"ColorFunction"

Automatic

will use the color function ColorFunction as defined in ArrayPlot

"BinningSpecification"

Automatic

a list of binning specifications to use for the output format

Possible forms for the option "Choices" are:

"Absolute"→{b₁,b₂,…,b_n}

restrict the jump to the reference points p_i for which b_i are True

"Relative"→{b₁,b₂,…,b_n}

restrict the jump to the reference points p_i (counted relative to the last position) for which b_i are True

Possible forms for the option "BinningSpecification" are:

{{x_min,x_min,dx}, {y_min,y_max,dy}}

bins using the x specification and y specification

{dx,dy}

bins the data in bins of size dx by dy

The specifications for "Absolute" and "Relative" can be nested, allowing for restrictions based on the history, i.e. the system has memory. The specification should be a full array of True or False elements with a length in each dimension equal to the number of reference points p_i.

Examples

Basic Examples (4)

Create the classic Sierpiński triangle using 30,000 iterations:

In[1]:=

Out[1]=

Jump only 40% of the way toward the reference points:

In[2]:=

Out[2]=

Jump between 4 corners of a trapezoid:

In[3]:=

$ResourceFunction[ "GeneralizedChaosGame"][{{-1, 0}, {1, 0}, {2, 3}, {-2, 3}}, 10^5]$

Out[3]=

Jump between random points on a circle:

In[4]:=

$ResourceFunction["GeneralizedChaosGame"][Circle[{0, 0}, 1], 10^5, Scaled[0.65]]$

Out[4]=

Scope (17)

Reference Geometry (4)

Give the geometry as a list of points:

In[5]:=

$ResourceFunction[ "GeneralizedChaosGame"][{{Sqrt[3]/2, -(1/2)}, {0, 1}, {-(Sqrt[3]/2), -(1/2)}, {0, 0}}, 10^5]$

Out[5]=

The reference geometry can be any region, e.g. a Line:

In[6]:=

$ResourceFunction["GeneralizedChaosGame"][ Line[{{0, 0}, {0, 1}, {1, 1}, {1, 0}}], 4 10^4, Scaled[0.7]]$

Out[6]=

Perform the chaos game in higher dimensions:

In[7]:=

Out[8]=

Combine different regions using RegionUnion:

In[9]:=

$ResourceFunction["GeneralizedChaosGame"][ RegionUnion[Circle[{0, 0}, 1, {Pi/4, 3 Pi/4}], Circle[{0, 0}, 1, Pi + {Pi/4, 3 Pi/4}]], 10^5, Scaled[0.6]]$

Out[9]=

Jump Specification (10)

The default jump specification is Scaled[0.5]:

In[10]:=

Out[10]=

In[11]:=

Out[11]=

Perform the chaos game using a 40% jump:

In[12]:=

Out[12]=

Perform the chaos game using a jump with a distance of 0.7:

In[13]:=

Out[13]=

Alternate between a fractional and a distance jump to create a blurry Sierpiński triangle:

In[14]:=

Out[14]=

Alternating between a fractional and a distance jump creates a different result compared to the individual specifications:

In[15]:=

(* Evaluate this cell to get the example input *) CloudGet["https://www.wolframcloud.com/obj/5c58ad39-28e8-4302-b19d-0d1f301c05a2"]

Out[15]=

Jump 50%, 60% or 40% if the last reference point was point 1, 2 or 3, respectively:

In[16]:=

$ResourceFunction["GeneralizedChaosGame"][3, 10^4, {"OriginIndexed", {Scaled[0.5], Scaled[0.6], Scaled[0.4]}}]$

Out[16]=

Jump 50%, 60% or 40% if the next reference point is point 1, 2 or 3, respectively:

In[17]:=

$ResourceFunction["GeneralizedChaosGame"][3, 10^4, {"DestinationIndexed", {Scaled[0.5], Scaled[0.6], Scaled[0.4]}}]$

Out[17]=

Jump a distance of 1.75 toward the top point, and 0.5 toward all other points:

In[18]:=

$ResourceFunction["GeneralizedChaosGame"][3, 3 10^4, {"DestinationIndexed", {Scaled[0.5], 1.75, Scaled[0.5]}}]$

Out[18]=

Use a pure function to get a combination of fractional and distance jumping:

In[19]:=

Out[19]=

Use more complicated functions:

In[20]:=

Out[20]=

In[21]:=

Out[21]=

Output Format (3)

The default is a graphical output:

In[22]:=

Out[22]=

Obtain the results as a list and perform an operation on it:

In[23]:=

Out[24]=

Output a density plot instead:

In[25]:=

Out[25]=

Options (12)

PointStyle (1)

Change the style of the points:

In[26]:=

Out[26]=

ReferenceGeometryStyle (1)

Change the style of the reference geometry:

In[27]:=

Out[27]=

In[28]:=

$ResourceFunction["GeneralizedChaosGame"][Sphere[{0, 0, 0}], 3 10^4, Scaled[0.8], "ReferenceGeometryStyle" -> Directive[Opacity[0.05], Orange]]$

Out[28]=

Probabilities (1)

Change the probability to jump to each reference point:

In[29]:=

$ResourceFunction["GeneralizedChaosGame"][4, 4 10^4, "Probabilities" -> {1, 1, 1, 8}]$

Out[29]=

ExclusionRegionFunction (2)

Restrict certain landing locations:

In[30]:=

$ResourceFunction["GeneralizedChaosGame"][3, 10^5, "ExclusionRegionFunction" -> (Norm[{#1, #2}] < 0.33 &)]$

Out[30]=

Restrict the point to fall in a circle at the top:

In[31]:=

$ResourceFunction["GeneralizedChaosGame"][4, 100000, Scaled[0.5], "ExclusionRegionFunction" -> Function[{x, y}, x^2 + (y - Sqrt[1/2])^2 < 0.5]]$

Out[31]=

Choices (3)

Allow a jump of only 1, 3 or 4 reference points ahead as compared to the last reference point:

In[32]:=

$ResourceFunction["GeneralizedChaosGame"][4, 3 10^4, "Choices" -> "Relative" -> {True, False, True, True}]$

Out[32]=

Allow a jump only to points 2, 3 or 4:

In[33]:=

Out[33]=

Jump possibilities can be made to depend on history. Do not allow to jump 1 ahead from the last reference point and 3 ahead from the penultimate reference point:

In[34]:=

$ResourceFunction["GeneralizedChaosGame"][4, 10^4, "Choices" -> "Relative" -> {{True, False, False, True}, {True, True, False, True}, {True, True, False, False}, {False, True, False, True}}]$

Out[34]=

Have the jump choices depend on the previously visited point:

In[35]:=

$ResourceFunction[ "GeneralizedChaosGame"][{{-1, -1}, {1, -1}, {1, 1}, {-1, 1}}, 3 10^4, Scaled[0.5], "Choices" -> "Absolute" -> {{False, True, True, False}, {True, False, False, True}, {True, True, True, True}, {True, True, True, True}}]$

Out[35]=

ColorFunction (2)

For a density plot, specify the color function used:

In[36]:=

Out[36]=

The default is the rainbow color function:

In[37]:=

Out[37]=

BinningSpecification (2)

For a density plot, specify the binning specification:

In[38]:=

$ResourceFunction["GeneralizedChaosGame"][5, 6 10^5, Scaled[0.5], "DensityPlot", "BinningSpecification" -> {{-1.1, 1.1, 0.05}, {-1.1, 1.1, 0.1}}]$

Out[38]=

Or specify just the size of the bins:

In[39]:=

$ResourceFunction["GeneralizedChaosGame"][5, 6 10^5, Scaled[0.5], "DensityPlot", "BinningSpecification" -> {0.05, 0.1}]$

Out[39]=

Applications (1)

Explore jumping in different dimensions. Calculate the jumping in (hyper)spheres in 2D–8D, and then plot the histogram of the distance from the center:

In[40]:=

dims = Range[2, 8]
pts = ResourceFunction["GeneralizedChaosGame"][
Sphere[ConstantArray[0, #]], 5 10^4, Scaled[0.7], "List"] & /@ dims;

Out[40]=

In[41]:=

bspec = {0, 1, 0.025};
bins = MovingAverage[Range @@ bspec, 2];
bc = BinCounts[Norm /@ #, bspec] & /@ pts;
ListPlot[Transpose[{bins, #}] & /@ bc, Joined -> True, PlotLegends -> dims, PlotRange -> All]

Out[44]=

Properties and Relations (1)

Produce the Sierpiński triangle as in a rule 90 cellular automaton:

In[45]:=

$ArrayPlot[CellularAutomaton[90, {{1}, 0}, 2^7 - 1], Frame -> False]$

Out[45]=

In[46]:=

$ResourceFunction[ "GeneralizedChaosGame"][{{-1, -1}, {1, -1}, {0, 1/8}}, 3 10^4]$

Out[46]=

Possible Issues (5)

The reference geometry might occlude all the points:

In[47]:=

$ResourceFunction["GeneralizedChaosGame"][Sphere[{0, 0, 0}], 10^5, Scaled[0.8]]$

Out[47]=

Use the option "ReferenceGeometryStyle" to make the points visible:

In[48]:=

$ResourceFunction["GeneralizedChaosGame"][Sphere[{0, 0, 0}], 10^5, Scaled[0.8], "ReferenceGeometryStyle" -> Opacity[0.2]]$

Out[48]=

For a one-dimensional chaos game, explicit braces are needed:

In[49]:=

Out[49]=

In[50]:=

Out[50]=

For each possible choice, there should be at least one True element:

In[51]:=

ResourceFunction["GeneralizedChaosGame"][4, "Choices" -> "Absolute" -> {{True, False, True, True}, {True, False, True, True}, {False, False, False, False}, {True, True, False, True}}]

Out[51]=

The "Choices" option can only be used when the region is a discrete set of points:

In[52]:=

ResourceFunction["GeneralizedChaosGame"][Circle[{0, 0}], "Choices" -> "Absolute" -> {{True, False, True, True}, {True, False, True, True}, {False, False, False, False}, {True, True, False, True}}]

Out[52]=

The "Probabilities" option can only be used when the region is a discrete set of points:

In[53]:=

Out[53]=

Neat Examples (5)

Recreate the Barnsley fern:

In[54]:=

$a1 = {{0, 0}, {0, 0.16}}; a2 = {{0.85, 0.04}, {-0.04, 0.85}}; a3 = {{0.2, -0.26}, {0.23, 0.22}}; a4 = {{-0.15, 0.28}, {0.26, 0.24}}; o2 = {0, 1.6}; o3 = {0, 1.6}; o4 = {0, 0.44}; l = ResourceFunction["GeneralizedChaosGame"][ConstantArray[0, {4, 2}], 10^5, {"DestinationIndexed", {a1 . #1 &, a2 . #1 + o2 &, a3 . #1 + o3 &, a4 . #1 + o4 &}}, "Probabilities" -> {1, 85, 7, 7}]$