Sounds (part 2) *Interactive sound wave primer.* In the second part of the sound primer, we cover white noise, low-frequency oscillators, 8-bit music, and more experimental sounds. All the code in this notebook is editable and can be modified on the fly. Click here to view the first part of the sound primer, where we cover basic oscillator functions and share usage information and credits. While sine waves, sawtooth waves, square waves, and triangle waves are the most commonly taught waveforms, there is no limit to what can be done with sound.
White noise Supplying a random value at each time step results in white noise. Because there is no obvious discernible pattern, it sounds erratic and lacks a clear pitch, like TV static.
Play(() => (Math.random() - 0.5) * 2, 1.5)
tex`f(t) = \text{random}(-1, 1)`
Low-frequency oscillators LFOs, or low-frequency oscillators, can be applied to the time step or frequency of existing sound functions to produce vibrato and other effects. It is basically like applying a sine wave to some parameter within a sound's generation function. Here's a sine wave generated with vibrato. See if you can manipulate the variables to make it sound like a police or ambulance siren:
viewof vibratoFrequency = slider({ min: 40, max: 2000, step: 1, value: 300, title: 'Frequency of sine wave', })
viewof vibratoFactor = slider({ min: 1, max: 100, step: 1, value: 3, title: 'Frequency width of vibrato', })
viewof vibratoSpeed = slider({ min: 1, max: 300, step: 1, value: 10, title: 'Speed of vibrato', })
Play((t) => Math.sin(vibratoFrequency * (t + (vibratoFactor / 1000) * Math.sin(t * 2 * vibratoSpeed)) * 2 * Math.PI), 2)
Or, for fun, you can multiply a sine wave's frequency by an LFO to produce an interesting effect:
Play((t) => Math.sin(300 * t * Math.sin(20 * t)), 2)
Or, multiply the amplitude by an LFO:
Play((t) => Math.sin(3000 * t) * Math.sin(40 * t), 2)
Experimental infinite sums What if we were to make our own waveform by using only square harmonics (1, 4, 9, ...) of sine waves, dividing the amplitude of each harmonic by its harmonic number. Every other harmonic we'll subtract rather than add. Let's see what happens:
viewof experimentalHarmonics = slider({ min: 1, max: 30, step: 1, value: 1, title: 'Number of square harmonics', description: 'Sine waves are added to create an experimental wave' })
Draw((t) => sum(1, experimentalHarmonics, (i) => (Math.pow(-1, i) * Math.sin(Math.pow(i, 2) * 70 * t) / (Math.pow(i, 2)))))
Title(`Experimental wave formed from ${experimentalHarmonics} sine wave${experimentalHarmonics != 1 ? 's' : ''}`, Play((t) => sum(1, experimentalHarmonics, (i) => Math.pow(-1, i) * Math.sin((Math.pow(i, 2)) * 330 * 2 * Math.PI * t) / (Math.pow(i, 2)))))
Well, it definitely sounds distinct, but the waveform doesn't have a pretty geometric shape like the classics. Feel free to edit the function and try to create your own waveforms. Inharmonic waveforms We can also try to generate waveforms using inharmonic partials, that is non-integer multiples of the base frequency. Here's an inharmonic wave that's the same construction as a sawtooth wave but the square root of each partial number is used for the frequency of the sine waves.
viewof inharmonics = slider({ min: 1, max: 30, step: 1, value: 1, title: 'Number of square root partials', description: 'Sine waves are added to create an inharmonic wave' })
Draw((t) => sum(1, inharmonics, (i) => Math.pow(-1, i) * (Math.sin(Math.pow(i, 0.5) * 70 * t) / i)))
Title(`Inharmonic wave formed from ${inharmonics} sine wave${inharmonics != 1 ? 's' : ''}`, Play((t) => (-2 / Math.PI) * sum(1, inharmonics, (i) => Math.pow(-1, i) * (Math.sin(Math.pow(i, 0.5) * 330 * 2 * Math.PI * t) / i)), 2))
8-bit music A few years ago, a YouTube video popularized experimental music that was written in one line of C code. We can replicate the idea in JavaScript and recreate some of the songs others composed using the function Play8Bit, which constrains the output of the function to an 8-bit signed number. While for many of these tunes it is quite mysterious how they make music with such a simple function, it may help to think they are likely emitting sawtooth waves. Just playing the timestep back will create a sawtooth wave since the output function automatically wraps around:
Play8Bit((t) => t)
Here are some more mysterious and amazing compositions pulled from the internet:
Title('Twinkly', Play8Bit((t) => (t * 5 & t >> 7) | (t * 3 & t >> 10), 10)) // by viznut (title mine), https://youtu.be/tCRPUv8V22o?t=10s
Title('Pistons', Play8Bit((t) => ((t * ('36364689'.charCodeAt(t >> 13 & 7) & 15)) / 12 & 128) + (((((t >> 12) ^ (t >> 12) - 2) % 11 * t) / 4 | t >> 13) & 127), 25)) // from ryg (title mine), https://youtu.be/tCRPUv8V22o?t=2m56s
Title('Canon', Play8Bit((t) => (t * 0.3)*Math.pow(2,(0x75054970>>(((t * 0.3)>>13&7)<<2)&0xF)/12+2)*(((t * 0.3)>>11&3)+1), 10)) // from https://www.youtube.com/watch?v=tCRPUv8V22o&lc=Ugg4D93oXeRtrXgCoAEC
Title('Big endian blues', Play8Bit((t) => (t * 0.3) * (((t * 0.3)>>12|(t * 0.3)>>16)&31&(t * 0.3)>>11), 45)) // from https://www.youtube.com/watch?v=tCRPUv8V22o&lc=Ugg4VzDeIkw_YHgCoAEC, title mine
Experimental sonic functions Compositions can also be made with simple mathematical functions in full resolution audio. The following is an experimental song that oscillates between generating sound with sine and sawtooth waves that I call industrial soundscape:
Play((t) => { const saw = Math.sin(t * 2) * 440 - Math.floor(Math.sin(t * 2) * 440); const sine = Math.sin(t * Math.sin(800 * t) * 2 * Math.PI); return Math.sin(t * Math.sin(800 * 30 * t) * 2 * Math.PI) < 0 ? saw : sine; }, 100)
import {Play, Play8Bit, Draw, Title, sum} from '@freedmand/sounds'
import {slider} from '@jashkenas/inputs'