**NEW
FRACTALS**

**by
WARREN BURT**

This is a collection of fractals and other attractors gleaned from a variety of sources, and presented here for your pleasure. Some of them work in a quite Orthodox manner, just like you'd see in the textbooks. Others work in strange ways - they were discovered in the process of fractal research, and although they aren't quite mathematically "proper," they actually generate interesting patterns to see and hear. So they've been kept, providing results from this attractor zoo that you're unlikely to find anywhere else.

Unlike the modules in the fractal menu, most of these require that you take the outputs and put them through one or more Latest modules to make the feedback loop. The tool tips on the functions will tell you if this is necessary, or, consult the example patches for these fractals, which contain a variety of inputs and information about each fractal. Most of these fractals function just like you'll see in the textbooks, but a couple don't quite "work" - that is, they produce non-standard output. If I liked the result, I kept them, because in ArtWonk, although we're interested in mathematical exploration, we're also interested in generating unique patterns which can't be obtained any other way. The PseudoMira function is one of these, as are the QuasiSprott functions. These last require differential equation mathematics to function in the proper way. When I implemented these, solving differential equations was beyond my "lack of mathematical abilities", but when I set up various feedback loops with these equations, they still produced some very interesting patterns. I think, in the way I treated them, the results are closer to an Iterative Function System (IFS) than a fractal attactor. Since then, thanks to Mark Havryliv, I've been able to implement the Sprott Equations properly. 13 of Sprott's Chaotic Circuit functions are found in the "SprottChaosCircuits" package. If you want to make your own fractal functions, two sources of information, fractal types and data are the old DOS programs "James Gleick's Chaos" and "Fractint." These are available on the web from the following addresses:

Chaos: http://www.cs.sjsu.edu/~rucker/chaos.htm

Fractint: http://spanky.triumf.ca/www/fractint/fractint.html

Both of these programs should run on most versions of Windows.

**FUZZY
DUFFING**

This is just like the Duffing Fractal, except that a small amount of random noise is added during each iteration. The jagged lines of the path show this, as does the wavering up and down motion of the sound. In the demo patch "FuzzyDuffingDemo.awp", sound is mapped with Y axis (up and down) mapped to pitch - so that higher pitches are produced higher on the graphic, lower pitches lower on the graphic.

See the DuffingDemo.awp demo patch and the Fractal Menu Help file on the Duffing Attractor for more information as to what values will work well with this attractor.

*Outputs:*

**X out:**
X point for current iteration

**Y out:**
Y point for current iteration

*Inputs:*

**Strb:**
Strobe at input calculates next iteration

**Reset:**
Strobe input to reset and initialize the function

**X:**
Initial X value

**Y:**
Initial Y value

**A:**
A input

**B:**
B input

**W:**
Initial W value - best set to 1

**T:**
Initial T value - best set to 0

**ICONSPROTT**

The IconSprott Fractal is loosely based on Julien Sprott's Icon256.exe program, available from his website. (http://sprott.physics.wisc.edu/software.htm). It produces a wide variety of very pretty fractal shapes and patterns which change rapidly. The reason for the rapid changes is that the function, which has 12 variables, usually zooms off to infinity or falls into a repeating pattern, or zooms down to one value. Only occasionally does it actually generate a function that either has a very long period before repeating happens, or else continues drawing new points. In Sprott's program, when stasis happens, a test function drives the program back to smaller, starting values. In his program, the output of the attractor is treated symmetrically, so in our demo patch, "IconSprottDemo.awp" we do the same. However, in our version, we are looking for attractors that keep changing over a long time, and so the values we've chosen reflect that. The X and Y outputs are used for plotting the function and the Z output is used for color. The Draw screen on the left shows the fractal itself, the Canvas screen on the right (320x240 size) shows the fractal in color with 8 way Symmetry using the Symmetry function.

The sound also uses the Symmetry function. X axis = pitch, Y axis = loudness and Z out is used to set the amount of silence or sound in the RanClock. The Symmetry module makes symmetrical pitches and velocities in two voices.

In the demo patch, the Fractal Presets give values which have been proven to work. If you want to insert your own values, start by changing these .1 at a time. There are 24 to the 12th power possible sets of parameters for this function, and most do not yield interesting results such as these. Good luck with your searching. A companion patch "SprottIconTester.awp" allows you to search for new working fractal values.

Use the demo program "SprottIconTester.awp" to find values for the IconSprott function. Press Play, then if the diagram on the far right becomes stable, press the Reset button. When you get an elaborate image that keeps being drawn (about every 40 presses of reset, in my experience), advance the Inc/Dec button next to Reset to keep the values and advance to a new slot in the MultiVal, which is storing the values as you make them. Eventually, you can save the contents of the MultiVal, and use them for the IconSprott function in another patch. My criteria for selecting values is that the function must keep drawing, and if it falls into a repeating pattern, the pattern must be fairly long. As in the previous patch, the Draw screen shows just the raw output of X and Y. The Symmetry module is used to make diagrams on the Canvas with 8 way symmetry.

*Outputs:*

**X out:
**X output

**Y out:
**Y output

Z out: Z output

*Inputs:*

Strb: Strobe input to run function once

Reset: Strobe here to reset and initialize the function

Xinit: Initial value for X

Yinit: Initial value for Y

Zinit: Initial value for Z

A in - F in; J in - O in: Inputs for Variables A-F, and J-O. These should be between -1.2 and 1.2

**IKEDA**

The Ikeda fractal is an oldie, but a goodie. It makes various spiral shaped patterns. The demo patch "IkedaTest.awp" gives a selection of starting values, displaying the fractal as both graphics and sound output.

Here are some suggestions for starting values, and what they control. The question marks indicate that exploration beyond these limits might produce useful information.

C1 variable from .1 to 5 or more? controls "grainyness."

C2 variable from .2 to .99 not more than 1? controls size-radius

C3 variable from 31 to 150 or more? controls number of coils/coherence of coils.

C3=number of coils/coherence of coils

**Outputs:**

**X out:
**X output -
put into Latest1 for a feedback loop.

**Y out:
**Y output -
put into Latest2 for a feedback loop.

**Inputs:**

**Strb:
**Strobe
input to run function once.

**C1 In:
**C1 variable
input - starting value

**C2 In:
**C2 variable
input - starting value

**C3 In:
**C3 variable
input - starting value.

**X In: **X
input - from Latest1 for a feedback loop.

**Y In: **Y
input - from Latest2 for a feedback loop.

**LATOOCARFIAN,
LATOOCARFIAN2**

The Latoocarfian fractal produces beautifully elaborate patterns, and if scaled properly, musical gestures similar to the structure of traditional melodies. It's given here in two versions. Latoocarfian is a version using only sin functions, Latoocarfian2 uses sin and cos functions, which produces slightly different results. The demo patches "LatoocarfianDemo.awp" and "Latoocarfian2Demo.awp" give a variety of realizations for these fractals, and give possible ranges for the inputs.

**Outputs:**

**X:
**Output to
Latest1 for feedback loop to X in.

**Y:
**Output to
Latest2 for feedback loop to Y in.

**Inputs:**

**Strb:
**Strobe
input to run function once.

**X: **X
input from Latest1 for feedback loop.

**Y: **Y
input from Latest2 for feedback loop.

**a:
**Variable a
input.

**b:
**Variable b
input.

**c:
**Variable c
input.

**d:**
Variable d input.

**QUASI-MIRA**

This is not a completely proper Mira Fractal, but I liked the results so much from this, I decided to keep it. The patch "PseudoMiraDemo.awp" gives a selection of values for this fractal, and some suggestions as to how to map it into graphics and sound. The patch gives suggestions for the possible ranges within which the fractal will work. There may be values outside these ranges that work, but you'll have to experiment to find those. In the demo patch, there is also a Macro called "MiraMath" which is necessary for successful running of this function. If you want to use this fractal, you should save this Macro to your Macro menu for future use.

**Outputs:**

**X out:
**X new - put
into Latest1 for feedback loop.

**Y out:
**Y new - put
into Latest2 for feedback loop.

**A out:
**Variable A
out - to multiply things before loop.

**B out:
**Variable B
out - to multiply things before loop.

**Inputs:**

**Strb:
**Strobe
input to run function once.

**X in: **X
Input - from Latest1 in feedback loop.

**Y in: **Y
input - from Latest2 in feedback loop.

**A in:
**Variable A
(start with 0)

**B in:
**Variable B
(close to 1.0)

**C in:
**Variable C
- made by multiplying 2 - 2*A

**D in:
**Variable D
- made by large multiplying and dividing.

**QUADRUPTWO,
QUADRUPTWOB**

The Quadruptwo fractals are variants of the Martin Fractal. The patch "QuadrupGoodValues.awp" and "QuadruptwoBGoodValues.awp" give a range of possible inputs for them, and suggestions for ranges within which other good values might be found. Note in these patches the use of the Kicker, in case things get stuck on a repeating value. Also as with many of the Fractal Functions, the use of Latest modules to provide feedback.

This can be a musically useful fractal - the leaping from one arm of the fractal to another can produce Bach-like "counterpoint within a single line."

**Outputs:**

**X out:
**X out - put
in a feedback loop to Latest1

**Y out:
**Y out - put
in a feedback loop to Latest2

**Inputs:**

**Strb:
**Strobe
input to run function once.

**X in:
**Input for X
- feedback from Latest1

**Y in:
**Input for Y
- feedback from Latest

**A in:
**Variable A
- can be almost any value from -300 to +300 or greater.

**B in:
**Variable B
- can be almost any value from -300 to +300 or greater.

**C in:
**Variable C
- can be almost any value from -300 to +300 or greater.

Note that although variables from -300 to +300 will work in the fractal, the ranges given in the demo patches give a range of values compatible with the scaling used for the graphic and sound realizations in the patch.

**QUASI-SPROTT1,
QUASI-SPROTT2, QUASI-SPROTT3**

These three functions use differential equations from an article by Julien Sprott. (Am. J. Phys. Vol. 68, No. 8, Aug 2000) But these equations are realized NOT as differential equations, but as linear / feedback equations. I think that like this they are closer to Iterated Function Systems (IFS) than differential equations (but don't quote me on that!). My knowledge of differential equations isn't sufficient for me to program them, but used in this way, these equations still produced interesting results. BY THE WAY - if someone who uses ArtWonk has a knowledge of differential equations, and can implement the Runge-Kutta algorithm in ArtWonk's calculator script, then all the equations listed on p. 759 of Sprott's article could be realized as functions in ArtWonk. Any takers? Also: Julien Sprott's website is a fantastic place to go for information on fractals of all sorts: http://sprott.physics.wisc.edu/fractals.htm.

QuasiSprott 1: xdot3 = -0.5xdot2 - xdot1 - (x-sgn(x))

QuasiSprott 2: xdot3 = -0.19xdot2 - xdot1 - (x-2*tanh(x))

QuasiSprott 3: xdot3 = -0.6xdot2 +2.8xdot1- (xdot1^3 - (x))

The three demo patches, "QuasiSprott01.awp", "QuasiSprott02.awp", and "QuasiSprott03.awp" each give a dozen different sets of variables for each equation. These give some of the ranges of the values possible for each equation. The feedback used in these patches is as follows:

x1 out -> x in

x2 out -> xd1 in

x3 out -> xd2 in

Many
other feedback schemes are possible, and will produce different
results. As long as we're going to not realize the equation
"properly," we might as well have fun with all the ways
that it *can
*be
used.
The sound mapping here is pretty simple. Undoubtedly users will be
able to come up with more interesting mappings. The parameters are
the same for each of the functions.

**Outputs:**

**X out:
**X output
after equation.

**X1 out:
**X dot 1
output after equation.

**X2 out:
**X dot 2
output after equation.

**X3 out:
**X dot 3
output after equation - feedback to X in thru Latest module.

**Input:**

**Strb:
**Strobe
input to run function once.

**X in:
**Variable X
input from feedback loop?

**Xd1
in: **Variable
X dot 1 input.

**Xd2 in:
**Variable X
dot 2 input.

**ROSSLER**

The Rossler attractor is another classic. There are two demonstration patches here, "RosslerVisualDemo.awp" and "RosslerCanon.awp." "RosslerVisualDemo" concentrates on graphics, with only a very simplistic sound realization. "RosslerCanon" on the other hand, is a sound-only realization which uses a bit more complex handling of the data, massaging it into a cheery two-voice canon.

For each of the patches, the preset values show some of the range of possibilities with the Rossler fractal. Feel free to experiment with other values. Not all combinations of values within these ranges will produce working output, and some values outside these ranges might work as well. Trial and error is your best guide.

For the sound patch, "RosslerCanon", I favor two voices with piano sounds, your tastes may differ.

The key to this patch is four fold:

1) Pitch, Duration, and Transposition are controlled by Rossler X out, Y out, and Z out.

2) The values have an offset added to them, then they're multiplied by 100, then IMod by 8 (for pitch and transposition) or 6 (for durations). This allows a finer "grain" of the output to be heard.

3) Pitch is filtered with the Pitch Map into a sunny major scale. Durations are mapped with the Switch to select from mostly 6s, with one 12 and one 24. This gives a jaunty pulse feel with longer notes thrown in.

4) The melody is then delayed with Delay Line modules (for 408 ticks), and played by the second voice 2 octaves down.

**Outputs:**

**X out:
**for
feedback loop through Latest1 module

**Y out:
**for
feedback loop through Latest2 module

**Z out:
**for
feedback loop through Latest3 module

**Inputs:**

**Strb:
**Strobe
input to run function once.

**X in:
**for
feedback loop input from Latest module

**Y in:
**for
feedback loop input from Latest module

**Z in:
**for
feedback loop input from Latest module

**dT in:
**scaling
input

**A in:
**Variable A
input

**B in:
**Variable B
input

**C in:
**Variable C
input

**THREEPLY**

The ThreePly Fractal is another variant of the Martin Fractal. Very small differences in start values can produce very different images. The demonstration patch for this fractal "ThreePlyDemo.awp" gives start values for 10 realizations of the fractal. Look at the start values in the preset examples to see how just .04 or .004 difference can produce different images. It's best to let this one run for several minutes to see changes - sometimes, after a couple of hundred iterations, this fractal leaps into a different area.

Note that although the values in the patch give ranges within which good variables are found, not all combinations of values within these ranges will produce interesting results.

**Output:**

**X out:
**X out - put
in a feedback loop to Latest1

**Y out:
**Y out - put
in a feedback loop to Latest 2

**Inputs:**

**Strb:
**Strobe
input to run function once

**X in: **X
input - feedback from Latest1

**Y in: **Y
input - feedback from Latest2

**A in:
**Variable A
input

**B in:
**Variable B
input

**C in:
**Variable C
input

**tENT
aTTRACTOR, SINE ATTRACTOR, LOGISTIC ATTRACTOR**

These are three attractors described in Peak and Frame's classic textbook "Chaos Under Control." The all work in the same way, but with different input ranges, and all produce different results.

The tENT aTTRACTOR is the simplest of the three. It also has some of the most unpredictable patterns, changing wildly. I've used inverse type in homage to my (de)composer friend, tENTATIVELY, a cONVENIENCE, of Pittsburgh, Pa. who also loves unpredictable patterns which change wildly. S should be between 1 and 2, with best results when S is between 1.414 and 2. X should be between 0 and 1.

The Sine Attractor exists under a sine wave shaped hump, if that has any meaning to you. It produces unpredictable patterns as long as the parameter for S is between 2.5 and Pi (3.14159....). X should be between 0 and 1. As you change parameters you'll hear that some values give repeating patterns and some give random-like sequences. A diagram of its output would show some bands of repeating values, and other, more noisy areas which indicate longer sequences in the output. It's sort of an intermediate attractor between the simple, and wild tENT aTTRACTOR, and the more stratified (more predictable moments in the random-like ones) Logistic attractor.

The Logistic Attractor is the most stratified of these attractors. That means that there are more places within the allowable parameters that will produce a predictable repeating pattern very close to a non-repeating pattern. Sometimes a difference in a value of S that's only .001 different from the previous one will produce a completely different character of output. S values - must be greater than 3 and less than 4 (3.5 - 4 is better). X values - should be between 0 and 1 When S = 3.570, the result is known as the Feigenbaum attractor (Hi, Mitch!).

The three demo patches are "tENT aTTRACTOR dEMO.awp", "Sine Attractor Demo.awp", and "Logistic Attractor Demo.awp." In all three Pitch is controlled by the X output, and Velocity is controlled by X output 3 steps delayed and scaled differently. In some branches of fractal mathematics, this delaying of a single output is used to graph a function against a delayed version of itself (X-Y mapping) in order to see aspects of the structure. Here, we create a melody by having delayed versions of a function control different aspects of the melody. In each of these demo patches, there are sliders which cover only the safe range of inputs for the variables. Move these sliders and click reset to send the function into a different area. You can also see a graph of the function output with the canvas, which is included in each patch.

**Outputs:**

**Out 1:
**X out,
which also feeds back into the equation. (Feedback is internal to
the function here - no external Latest modules are required.)

**Inputs:**

**Strb:
**Strobe
input to run function once.

**Reset:
**Strobe
Reset to restart the function with new input values.

**S:
**Input for S
values. For tENT, 1.414-2.0 is best; for Sine, 2.5 - Pi (3.14159);
for Logistic 3.5-4.

**X:
**Input for X
value, which feeds back internally.

**VAN DER
POHL ATTRACTOR**

The Van Der Pohl Equation is a simple two variable differential equation that describes an oscillator that can be linear or chaotic. It's adapted from "The Chaos Cookbook" by Joe Pritchard, p. 156, and implemented here to make various kinds of spiraling patterns.

In the demo patch, "VanDerPohlDemo.awp" the Presets show a range of possibilities.

These are the ranges for the variables:

X = from -1 to +1

Y = from -1 to +1

A = from -77 to -11 AND 11 to 77 - values less than 1 also produce a nice set of very shallow spiraling curves

R = .01 to .99

F = -4 to +4

Values outside these ranges can also sometimes work

The sound is a simple X=pitch; Y = velocity mapping, but with a twist. There are two RanFRClk modules sampling the fractal output - each at a different rate - BUT, the 2 NoteOut modules are clocked by the same clock. So the harmonies heard are the result of the same output being SampHold-ed at different rates.

*Outputs:*

**X
out:** X output for latest iteration

**Y
out:** Y output for latest iteration

*Inputs:*

**Strb:**
Strobe input to run function once

**Reset:**
Strobe this to reset and initialize the function

**X:**
X input - see above for value ranges

**Y:**
Y input - see above for value ranges

**A:**
A input - see above for value ranges

**R:**
R input - see above for value ranges

**F:**
F input - see above for value ranges

**T:**
T input - should be set to 0