Live programming @ University of Washington
Published
Edited
1 fork
3 stars
distortion
import {Play} from '@freedmand/sounds'
Play(t => Math.sin(2 * Math.PI * t * 100), 3) // simple 100 Hz sinusoidal tone
Play(t => Math.max(Math.min(Math.sin(2 * Math.PI * t * 100), t/2), -t/2), 3) // sounds distorted--why?
// as we can see if we decrease the frequency to 6 Hz, the waves are getting cut at the max/min waveshaping boundaries
Play(t => Math.max(Math.min(Math.sin(2 * Math.PI * t * 6), t/2), -t/2), 3)
// the flat tops have a "rough" sound that results from adding overtones to the pure frequency in order to get the square shape
// we can get very close to a square wave by cutting the tops even lower
Play(t => Math.max(Math.min(Math.sin(2 * Math.PI * t * 100), 1/100), -1/100), 3)
// (looks like)
Play(t => Math.max(Math.min(Math.sin(2 * Math.PI * t * 4), 1/100), -1/100), 3)
envelope = g => f => t => Math.min(Math.abs(g(t)), Math.max(-Math.abs(g(t)), f(t)))
// it's not too hard to oscillate the volume and the distortion together using a sinusoidal waveshape
// notice that the volume doesn't seem to go down much in the troughs--this is because the higher-frequency overtones created by cutting lower are more noticeable
Play(t => envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 55))(t),
15)
// (compare to the next image)
Play(t => (t =>Math.sin(2 * Math.PI * t * 4))(t),
15)
// (again, this is what is going on--things are getting cut by the envelope when it gets close to zero)
Play(t => envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 4))(t),
15)
// we can correct the volume and oscillate just the distortion, so the sound goes from smooth to rough
// this is the same volume at all times, but the frequencies differ
Play(t => 1/Math.sin(2 * Math.PI * t/4) * envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 55))(t),
15)
// (looks like this)
Play(t => 1/Math.sin(2 * Math.PI * t/4) * envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 4))(t),
15)
// just messing around with other ideas for distortion below here
// random internet formula for digital distortion, doesn't seem to work?
{
// sampled signal
let x = t => 1/Math.sin(2 * Math.PI * t/4) * envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 55))(t)
//x = t => Math.sin(2 * Math.PI * t * 440)
return Play(t => (x(t)/Math.abs(x(t)) * (1 - Math.E**((-((x(t))**2)/(Math.abs(x(t))))))),
15)
}
// {
// // this cell does too much processing and can hang the browser
// // chebyshev polynomials? http://sites.music.columbia.edu/cmc/MusicAndComputers/chapter4/04_06.php
// // apparently these can be used to shift a signal's frequency by a constant factor
// // claims you can get weird overtones by putting in values < 1
// // sampled signal
// let x = t => 1/Math.sin(2 * Math.PI * t/4)**3 * envelope(t => Math.sin(2 * Math.PI * t/4)**3)(t =>Math.sin(2 * Math.PI * t * 40))(t)
// let cheb = x => t=> 4*x(t)**3 - 3*x(t)
// let x1 = t => x(t) + cheb(x)(t)
// let x2 = t => x1(t) / (1 + Math.abs(x1(t))) // soft clipping -- just reduces the volume when things get loud, keeping a smooth wave
// //x = t => Math.sin(2 * Math.PI * t * 440)
// return Play(t => x2(t) + cheb(x2)(t),
// 15)
// }
{
// truncation distortion with "dithering" (adding random bits in truncated positions)
// pretty promising -- might be what I'm looking for if we add something to cut high frequencies, eg browser low-pass filter
// I've implemented a kind of high-frequency filter at https://observablehq.com/@elmisback/piano-transcription-tools?ui=classic ("filter treble" option)
let x = t => 1/Math.sin(2 * Math.PI * t/4)**3 * envelope(t => Math.sin(2 * Math.PI * t/4)**3)(t =>Math.sin(2 * Math.PI * t * 55))(t)
return Play(t => x(t)>>4<<4 || (Math.random() && 0b1111),
15)
}
Math.E
Play(t => 1/Math.sin(2 * Math.PI * t/2 - Math.PI/2) * envelope(t => Math.sin(2 * Math.PI * t/2 - Math.PI/2))(t => 1/Math.sin(2 * Math.PI * t/4) * envelope(t => Math.sin(2 * Math.PI * t/4))(t =>Math.sin(2 * Math.PI * t * 55))(t))(t),
15)
Math.random()
Play(t => Math.max( // envelope lower bound
Math.min( // envelope upper bound
Math.sin(2 * Math.PI * t * 100), // basic tone (100 Hz)
Math.abs(Math.sin(2 * Math.PI * t/2))
),
-Math.abs(Math.sin(2 * Math.PI * t/2))),
15) // time to play for
// we can oscillate just the distortion, so the sound goes from smooth to rough
Play(times(sin(1/8))(times(div(t=>1)(sin(1/2)))(envelope(sin(1/2))(times(div(t=>1)(sin(1/4)))(envelope(sin(1/4))(sin(55)))))),
15)
// messing with low-frequency oscillators, described at https://observablehq.com/@freedmand/sounds-2
Play(t=> (t => sin(sin(1)((t % 3) + 11.5))(t % 3+11.5))(t),
15)
Play(t=> sin(1/sin(.25)(t**3))(t),
15)
Play(t=> envelope(sin(15))(sin(1/sin(.25)(t**3)))(t),
15)
Play(t=> times(div(t=>1)(sin(1/2)))(envelope(sin(1/2))(envelope(sin(55))(sin(55))))(t),
15)
div = f => g => t => f(t) / g(t)
times = f => g => t => f(t) * g(t)
sin = f => t => Math.sin(2 * Math.PI * f * t)
One platform to build and deploy the best data apps
Experiment and prototype by building visualizations in live JavaScript notebooks. Collaborate with your team and decide which concepts to build out.
Use Observable Framework to build data apps locally. Use data loaders to build in any language or library, including Python, SQL, and R.
Seamlessly deploy to Observable. Test before you ship, use automatic deploy-on-commit, and ensure your projects are always up-to-date.