This paper describes how to implement a cellular automata
as an algorithm in a Csound instrument for sound synthesis purposes. Other
possible applications such as algorithmic composition are not studied.
It is mainly concerned with one-dimensional automatas for simplicity, driving
banks of oscillators for additive synthesis. Images, sound samples and
code are included at the end of the article.
A (quick) introduction to Cellular Automata theory
A Cellular Automata consists of several single units, called Automatas or Cells, with an initial discrete state, which interact with its adjacent cells following a given rule to get their next states. In One-dimensional automatas you have a row of "cells" which, at every iteration, compute their next state based on their own current state and their neighbour´s state:
The possible variants include both the number of possible
states and the number of neighbours taken into account.
For example, the 41 Cellular Automata I use assumes 4 possible states for each cell (0,1,2 and 3) and compute their values based on its own state and the states of the first cells located at their right and at their left sides.
Assuming cyclic contour conditions, I will consider the first and the last cells to be adjacent, thus getting a continuous cyclical space.
Usually you compute the next state by table lookup. In this way, you have a table storing the state assigned to every possible result in the computation. Let´s suppose a cell can have 2 possible states, 0 or 1. The maximum allowed result by adding a cell´s state with its first neighbour´s states will be of course 3. Other possibilities are 0,1 or 2. Thus some possible transition tables are
for example, if you get a value of 2 in the computation,
table lookup indexes the 3rd position in the table (starts with 0) giving
0,0 and 1 respectively.
In my 41CA there are 10 possible states (from 0 to 3*3=9), requiring a transition table with 16 memory locations (the nearest power of two).
The interest of Cellular Automatas is that such weak local
constrains can give rise to large scale structures. Some of them
will extinguish or generate chaotic patterns, buth some other show memory
and perdurability of their initial structures, with a characteristic fractal
behaviour (self similarity). This peculiarities are of evident musical
All the stuff runs in 3 separate instruments for clarity, simplicity and modularity. The communications between instruments is hold via the zak system.
You will need one location for the za space which is required to store the waveform generated by the Additive Synth. You will also need as many as 3 times the number of cell states in zk locations, to store both the current and the next cell states for each iteration, as well as to keep track of the phase increments for each oscillator in the additive synth.
The first instrument initialises the cells of the CA to some values stored in a table. Those values are not important for the long-term evolution of the Automata - at least in theory-, but they can be of great influence during the initial attack transient. It also initialises the phases of the oscillators to more or less random values. This (also in theory) should help to smooth the waveform amplitude, avoiding buzzing timbres and sharp peaks when dealing with harmonic textures and fast iterations.
This instrument is deactivated just after initialisation has been finished with a turnoff statement.
The second instrument runs the Cellular Automata. It is
controlled by a timout statement which allow the cell computations
to be done only once every icell_period seconds. It is therefore
quite efficient. I assumed that all the cell transitions must take place
syncronously. The instrument reads the cell values from the zk space;
for each cell it adds the value of itself and the two neighbours and, via
table lookup, it computes the resulting value which will be dependent on
the transition rule selected by the user.
Several interesting tricks are necessary to run the Automata without problems, most of them related to the periodic contour conditions stated above.
Notice also that you will have to switch the pointers (here zk offsets) for each group of cell states at each iteration, the next state becoming the actual previous state, leaving the previous previous state location free to be filled with the next next state. Not much different from the update process in a delay unit in fact.
The third instrument is the additive engine. To allow a user selectable number of partials, you won´t find hundreds of oscil units here. Instead, it works quite similar to a Phase Vocoder resynthesis routine: it adds the instantaneous value of each oscillator to a common memory location - a za location. This value is computed accessing a sine table indexed by the current phase increment of the oscillator, wich is updated at every pass depending on the oscillator frequency as
kphase = kfactor * imin_freq/kr
and weighted by the cell state linked to that oscillator.
Notice this process makes ksmps=1 necessary (as well as some conditionals
and goto´s throughout the code), but it is anyway much more
efficient and flexible thant an oscil´s bank. Of course you
can acces any wavetable, not just a sine wave.
I had some troubles with the phase update, as it grew bigger and bigger and eventually the wrap feature in the table lookup access crashed. To avoid it I work always with the fractional part of the phase after adding the current phase increment
kfactor = (kzkndx+1)*istr
kfactor pow kzkndx+1,istr
kfactor pow istr, kzkndx
Additive and geometric mapping allow both harmonic and inharmonic textures to be created, even chorus effects with small istr factors. Exponential mapping makes it possible to set the oscillator frequencies to any equal-tempered scale, like the usual 12ET and 24ET scales, and also to any ET non-octaviant scale. Thus a great variety of textures can be created with just a single Automata.
You can compare the graphical output from a program like
Fractint with the sonogram of a waveform generated from the same Automata
(here with rule 1113110301). I hope you will be able to see their morphological
|These settings generate a fast moving microtonal (quarter-tone) cluster with 128 oscillators (not sinusoidal) controlled by an organic 41CA with rule 0201200331. mp3 sample here .|
|With an harmonic texture extending from 60 Hz up to 2.5 KHz these settings simulate a robotic voice quite well, though with some annoying clicks. The 41CA rule used here is 0100102302 and shows a typical behaviour. mp3 sample here.|
|And finally, an inharmonic cluster with a CA being iterated at a quite fast rate. The initial cell states favours the extreme registers. After a clear attack transient the spectrum fills completely resulting in a rich and evolving texture. The rule used is 0112310231. mp3 sample here (with some reverb).|