The sounds of Pi

What is it?

The sound of Pi is another Pure Data experiment. Similar to my last one (meteor) it is focused around sonifying data.

The sound of pi is based off of the first 400 digits of pi. There are 8 sawtooth oscillators and each one is assigned 50 notes from the 400 digits. The patch is based off of pitch classes and musical set theory (we’ll get to that later).

The patch


As you can see, it’s pretty small and there aren’t many abstractions hidden underneath either.

The 8 oscillators mentioned previously are the nth-pi-oscs that you see in the patch. You can see from the creation of nth-pi-osc that each one has its own portion of pi (heh) to look after. One starts reading at 0, another at 50, another at 100 and so on…

The 50 numbers contained within each oscillator are 50 numbers of pi and are treated as integer pitch classes all relative to the root of C.

The concept of a pitch class is simple. If you can count to 12 and know the alphabet up to G, then congratulations, you can understand pitch class theory. Let’s go through it anyway…

Pitch classes

We’ll dissect the first few notes of this patch to get a better idea of what a pitch class is. Let’s take the first oscillator ([nth-pi-osc 0] in our case). It will be dealing with the first 50 digits of pi. Here are the first 10 it encounters:

` {3, 1, 4, 1, 5, 9, 2, 6, 5, 3} `

We treat each number as a semitone distance from a chosen root note. We’ve chosen the root of C so in this case it will yield the following:

` {Eb, Db, E, Db, F, A, D, Bb, A, Eb} `

For the most part, that’s it, you now understand pitch classes and musical set theory. There’s a whole lot more to pitch classes that you can explore, but for the purposes of understanding this patch, that about covers it.




This abstraction is responsible for getting the current value of pi for its oscillator and sending over the frequency. Nothing complex here but note the following:

1) + 60. We add 60 to every MIDI note as we want it to be based off of C (that is to say that 0 in our pitch class is C).



This is what produces the majority of the sound, the rest of the patch is just reading data and using math to make sure we’re using the correct digits of pi for each oscillator.

Still, this sub-patch is very simple. Where the magic happens is all contained within the line object. It takes 60000 milliseconds to reach it’s target frequency of whatever $1 is. Finally, it passes that on to our sawtooth wave (phasor~).


The patch reads from a text file which contains 1000 entries of pi (I only chose to use the first 400). Each entry is on its own line so have the following:


There’s nothing really magical here though I do like the rendered array of pi that Pure Data produced. Neato.