Fabulous Adventures In Coding : Music

Desafinado, Part Five: Getting Down Without Hitting The Bottom

Eric Lippert — Mon, 18 Apr 2005 21:49:00 GMT

Back in the 1960's a guy named Shepard published a paper which described a way to create a descending scale of twelve notes such that every consecutive pair was perceived as being two notes, the second one lower than the first. That's not hard -- every descending scale has that property! The kicker is that in a Shepard scale, people also perceive the last note of the scale as higher than the first.

Clearly that's totally impossible. If every note is lower than the one before then the twelfth cannot be higher than the first. And yet Shepard's Illusion is pretty strong. Another guy named Risset figured out a way to make the scale "continuous", so it sounds like one long note constantly getting lower but never hitting bottom.

It's pretty tricky to pull off the illusion, and I haven't done a perfect job, but this at least illustrates it somewhat.

The key to pulling off the illusion is to have the tone actually made up of many overtones and subtones of a primary tone. Take A=440Hz, for example. As I mentioned back in part one, for some reason humans seem to strongly associate perfect octaves. 220Hz and 880Hz sound like "the same note", only lower or higher respectively. It is hard to realize that this is not one tone, but actually many.

What we'll do is play the three A's from the three different octaves simultaneously. If we played them all at the same volume, it's hard for the human ear to pick out which one is the "most important", but if we play the bottom one very softly, the middle one very loud, and the top one about medium, then it's easy to "lock on" to the mid-range component of the sound.

Imagine someone playing this on the piano -- hitting three A's, the middle one loud and the bottom and top ones quietly.

Now move all three notes UP eleven semitones, so that the A♭ at the bottom is just below what was previously the middle A. Play the bottom note really loud but slightly softer than the previous loud A, the middle note slightly louder than the previous high A, and the new high note very soft indeed. The human ear does not perceive that as every note moving eleven semitones up, but rather that the loudest tone has moved down.

Now take all three notes down a semitone. Every time you go down a semitone, make the bottom note a little quieter and the middle and top notes a little louder. Keep going until you get back to where you started, at which point go up eleven semitones again.

That's the essence of the illusion. The human ear attunes itself to the loudest part of the tone, and therefore doesn't notice that the lows are dropping out of the bottom and being replaced by very faint notes at the top. As the top notes descend they get louder and louder, and eventually the ear switches from hearing the middle note as the primary to the bottom note as the primary, and then back to the middle later.

Doing this as a continuously sliding tone requires some easy calculus.

Consider just one component of the sound. We want to have a sine wave that is getting slower and slower over time. Say it starts at 440Hz and when we're done, it's going at 220Hz. How are we going to model this? Well, think "cycles per second". Take a wheel spinning on a fixed axle and put a mark on the edge. Ignore the side-to-side component of the mark as the wheel spins and just look at the up-and-down motion. That motion describes a sine wave. Spin the wheel at 440 cycles per second, and we'll get a 440 Hz sine wave out of the vertical component.

How are we going to slow down from 440 Hz to 220 Hz, over, say, 16 seconds? We could use a linear model -- lose 14 Hz a second -- but that's not very sensible when we're thinking of sound. Remember, humans hear sounds based on ratios, not based on absolute numbers of cycles. Really what we want is for this to decay geometrically. We want the sound to have a "half life" in the frequency domain.

It is convenient to measure the speed not in revolutions per second but in radians per second. There are 2π radians per revolution, so a wheel that is spinning at 440 Hz is spinning at 880π radians per second. Let's say that we're going to decay from our original frequency f=440 Hz down to f/2 in T seconds. What is the angular velocity at time t if it is an exponential decay?

ω(t) = (2πf) 2^-t/T radians per second

Check that -- yep, that gives you 880π radians per second for t = 0, and 440π radians per second for t=T.

Super. Now we need to determine the height of the mark at any given time. The angular position is easily determined from the angular velocity, and the height is the sine of the angle. Let's work out the angle:

Θ(t) = ∫ω(t) dt = (-2fTπ/ln 2) 2^-t/T + C

for some constant C which we'll just set to zero arbitrarily -- we do not care about the phase, just the frequency.

Take the sine of the angle, and we're all set, we've got our decaying wave.

That takes care of the frequency decay. What about the change in volume of each component?

We'll do a rough approximation of a bell curve. We want the very highest highs to come in very quietly. We want the very lowest lows to go out very quietly. And we want most of the sound energy in the middle, so that that's what you hear. Rather than muck around with computing a real bell curve, we'll just do a simple linear approximation of one.

I find the illusion to be strongest when the primary note is pretty low. Let's try 110 Hz, two octaves below concert A. We'll make some simple modifications to yesterday's program. We'll decay over 16 seconds, and we'll do three decays. And we'll use eight full octaves.

namespace Wave {
using System;
using System.IO;
class MainClass {
    public static void Main(String[] args) {
      FileStream stream = new FileStream("test.wav", FileMode.Create);
      BinaryWriter writer = new BinaryWriter(stream);
      int RIFF = 0x46464952;
      int WAVE = 0x45564157;
      int formatChunkSize = 16;
      int headerSize = 8;
      int format = 0x20746D66;
      short formatType = 1;
      short tracks = 1;
      int samplesPerSecond = 44100;
      short bitsPerSample = 16;
      short frameSize = (short)(tracks * ((bitsPerSample + 7)/8));
      int bytesPerSecond = samplesPerSecond * frameSize;
      int waveSize = 4;
      int data = 0x61746164;
      int T = 16;
      int reps = 3;
      int samplesperrep = samplesPerSecond * T;
      int dataChunkSize = samplesperrep * reps * frameSize;
      int fileSize = waveSize + headerSize + formatChunkSize + headerSize + dataChunkSize;
      writer.Write(RIFF);
      writer.Write(fileSize);
      writer.Write(WAVE);
      writer.Write(format);
      writer.Write(formatChunkSize);
      writer.Write(formatType);
      writer.Write(tracks);
      writer.Write(samplesPerSecond);
      writer.Write(bytesPerSecond);
      writer.Write(frameSize);
      writer.Write(bitsPerSample);
      writer.Write(data);
      writer.Write(dataChunkSize);
      double fundamental = 110.0;
      double ampl = 10000;
      for (int j = 0 ; j < reps ; ++j) {
        for (int i = 0; i < samplesperrep; i++) {
          double t = (double)i / (double)samplesPerSecond;
          double amp0 = (ampl/8) * t / T;
          double amp1 = (ampl/8) + (ampl/8) * t/T;
          double amp2 = (ampl/4) + (ampl/4) * t/T;
          double amp3 = (ampl/2) + (ampl/2) * t/T;
          double amp4 = (ampl/1) - (ampl/2) * t/T;
          double amp5 = (ampl/2) - (ampl/4) * t/T;
          double amp6 = (ampl/4) - (ampl/8) * t/T;
          double amp7 = (ampl/8) - (ampl/8) * t/T;
          double theta = -fundamental * 2 * Math.PI * T * Math.Pow(2, -t/T) / Math.Log(2);
          short s = (short)(
            amp0*Math.Sin(theta*16)+amp1*Math.Sin(theta*8)+
            amp2*Math.Sin(theta*4)+amp3*Math.Sin(theta*2)+
            amp4*Math.Sin(theta*1)+amp5*Math.Sin(theta/2)+
            amp6*Math.Sin(theta/4)+amp7*Math.Sin(theta/8)
          );
          writer.Write(s);
        }
      }
      writer.Close();
      stream.Close();
    }
}
}

The brain at some point stops thinking that the lower midrange frequency is the interesting one, and switches to the higher. If you listen attentively you can notice when your brain makes the switch, and the illusion is then somewhat dispelled.

Pretty weird, eh?

Coming up soon: back to wackiness in scripting!

Desafinado, Part Four: Rolling Your Own WAV Files

Eric Lippert — Fri, 15 Apr 2005 21:29:00 GMT

We’ve established why every just about piano in the world -- in fact, every concert-pitched musical instrument in the world -- is slightly out of tune. No one actually plays perfect fifths; every fifth interval is slightly flat. Why don't we hear the difference? Is the difference even perceptible?

It is very hard to hear unless you compare and contrast. So let's do that. Here's a little C# program I just whipped up. This program creates a WAV file that first plays two seconds of E a perfect fifth above concert A=220Hz, and then two seconds of E a slightly flattened fifth above A.

Can you hear the difference? I can't hear the difference between the two E's at all.

However, you can REALLY hear the difference in the next section. The file then plays two seconds of E and a "perfect B" above it together, and then two seconds of E and a "concert B" above it.

Now it is obvious -- with such clean, perfect waves you can really strongly hear it when it goes out of tune. You get a sort of ringing "wah wah wah" effect as the waves go in and out of sync with each other. The number of wahs, or, as piano tuners call them, beats per second tells you how close to a perfect fifth the notes are -- the slower the beats, the more in tune. Experienced piano tuners can easily hear when the number of beats per second is just right for the piano to be exactly out of tune enough to be evenly tempered.

This code could use some explanation.

The basic WAV file format follows the Interchange File Format specification. An IFF file consists of a series of "chunks" where chunks can contain other chunks. Each chunk starts with an eight byte header: four bytes describing the chunk, followed by four bytes giving the size of the chunk (not counting the eight byte header). The header is followed by the given number of bytes of data in a chunk-specific format. A WAV file consists of one main chunk called RIFF that contains three things: the string "WAVE", a "format" chunk that describes the sample rate, etc, and a "data" chunk that contains the sampled waveform.

We won't mess around with any advanced WAV file features like cue points or playlists or compression. We'll just dump out some data and play it with the WAV file player of your choice. We'll use CD quality audio -- 44100 samples per second, each one with 16 bits per sample. (Unlike a CD, we'll do this in mono, not stereo.)

namespace Wave
{
   using System;
   using System.IO;
   class MainClass {
      public static void Main() {
         FileStream stream = new FileStream("test.wav", FileMode.Create);
         BinaryWriter writer = new BinaryWriter(stream);
         int RIFF = 0x46464952;
         int WAVE = 0x45564157;
         int formatChunkSize = 16;
         int headerSize = 8;
         int format = 0x20746D66;
         short formatType = 1;
         short tracks = 1;
         int samplesPerSecond = 44100;
         short bitsPerSample = 16;
         short frameSize = (short)(tracks * ((bitsPerSample + 7)/8));
         int bytesPerSecond = samplesPerSecond * frameSize;
         int waveSize = 4;
         int data = 0x61746164;
         int samples = 88200 * 4;
         int dataChunkSize = samples * frameSize;
         int fileSize = waveSize + headerSize + formatChunkSize + headerSize + dataChunkSize;
         writer.Write(RIFF);
         writer.Write(fileSize);
         writer.Write(WAVE);
         writer.Write(format);
         writer.Write(formatChunkSize);
         writer.Write(formatType);
         writer.Write(tracks);
         writer.Write(samplesPerSecond);
         writer.Write(bytesPerSecond);
         writer.Write(frameSize);
         writer.Write(bitsPerSample);
         writer.Write(data);
         writer.Write(dataChunkSize);
         double aNatural = 220.0;
         double ampl = 10000;
         double perfect = 1.5;
         double concert = 1.498307077;
         double freq = aNatural * perfect;
         for (int i = 0; i < samples / 4; i++) {
            double t = (double)i / (double)samplesPerSecond;
            short s = (short)(ampl * (Math.Sin(t * freq * 2.0 * Math.PI)));
            writer.Write(s);
         }
         freq = aNatural * concert;
         for (int i = 0; i < samples / 4; i++) {
            double t = (double)i / (double)samplesPerSecond;
            short s = (short)(ampl * (Math.Sin(t * freq * 2.0 * Math.PI)));
            writer.Write(s);
         }
         for (int i = 0; i < samples / 4; i++) {
            double t = (double)i / (double)samplesPerSecond;
            short s = (short)(ampl * (Math.Sin(t * freq * 2.0 * Math.PI) + Math.Sin(t * freq * perfect * 2.0 * Math.PI)));
            writer.Write(s);
         }
         for (int i = 0; i < samples / 4; i++) {
            double t = (double)i / (double)samplesPerSecond;
            short s = (short)(ampl * (Math.Sin(t * freq * 2.0 * Math.PI) + Math.Sin(t * freq * concert * 2.0 * Math.PI)));
            writer.Write(s);
         }
         writer.Close();
         stream.Close();
      }
   }
}

Compile this guy up, run it, and listen to test.wav. Pretty cool eh?

Next time, we'll wrap up with one of the most interesting psychological effects you can get in music -- a tone that goes down, but never hits bottom.

Desafinado, Part Three: Too Many Fifths

Eric Lippert — Wed, 13 Apr 2005 22:27:00 GMT

Last time we established the diatonic scale which has the nice property that there are five tone intervals and six fifths:

Note	Frequency
A	220.000
B	247.500
C	260.741
D	293.333
E	330.000
F	347.654
G	391.111

and then double for the next octave up and so on.

But it's a little weird in that B doesn't have a fifth above it, just E a fifth below it. Similarly, F has no fifth below it. If there were any justice in this world, B and F ought to be fifth's of each other. But they're not quite right! A fifth above B is smack between F and G. Similarly, a fifth below F is between A and B.

We stuck E and B between two other notes. So let’s do it again. The fifth below F is a little bit below B, so we'll call it "B flat", or B♭. A fifth above B is a little bit above F, so we'll call it "F sharp", or F♯ In our first octave we have

Note	Frequency
A	220.000
B♭	231.769
B	247.500
C	260.741
D	293.333
E	330.000
F	347.654
F♯	371.250
G	391.111

Gah. This doesn't solve anything. Now we've got two more notes missing a fifth. Well, let's add them. A fifth below B♭ is E♭, a fifth above F♯ is C♯. And again, we've got the same problem! A fifth below E♭ is A♭, a fifth above C♯ is G♯, and our first octave and a bit now looks like this:

Note	Frequency
A♭	206.017
A	220.000
B♭	231.769
B	247.500
C	260.741
C♯	278.438
D	293.333
E♭	309.025
E	330.000
F	347.654
F♯	371.250
G	391.111
A♭	412.033
G♯	417.657
A	440.000

Hold on a minute here. This is getting ridiculous. A♭ and G♯ are less than 2% apart, and seem to have gotten out of order -- how is it that A♭ is lower than G♯?

This is a mess. In two octaves our stringed instrument now has over 25 strings and we don't seem to be slowing down at all as far as adding new ones goes!

We could keep on doing this literally forever. Why? Because as the Pythagoreans discovered, there are no whole number ratios that can be squared, cubed, or put to any other power such that you eventually end up with two. We are never going to multiply any new note by any combination of 2/1, 1/2, 3/2 or 2/3 and end up with a note that we've already got in any other octave. The system is not closed.

Look at how close A♭ and G♯ are. Wouldn't it be tempting to just "split the difference", set them equal to each other, and be done with it?

Hmm.

Let's throw out that A♭ in there and look at the ratios of successive notes -- not as whole number ratios, but as percentages.

Note	Increase
A♭	7.0%
A	5.3%
B♭	6.8%
B	5.3%
C	6.8%
D	5.1%
E♭	7.0%
E	5.3%
F	6.8%
F♯	5.3%
G	6.8%
G♯	5.3%

Each note on this scale is between 5.1% and 7.0% higher than the previous note. What if we made every interval the same percentage? What percentage would it be? We need to double in frequency over an octave, and have twelve steps to do it in. The twelfth root of two is about 1.05946. Suppose we redo this twelve-note scale so that every note is 5.946% higher than the previous. What do we get?

Note	Frequency	Difference
A	220.000	0.00%
A♯/B♭	233.082	0.57%
B	246.942	-0.23%
C	261.625	0.34%
C♯/D♭	277.183	-0.45%
D	293.664	-0.11%
D♯/E♭	311.127	0.68%
E	329.627	-0.11%
F	349.228	0.45%
F♯/G♭	369.995	-0.34%
G	391.995	0.23%
G♯/A♭	415.305	-0.56%
A	440.000	0.00%

This is pretty darn close to the scale we deduced from Pythagorean principles. And we have successfully split the difference -- we say that A♭ and G♯ are the same frequency. Similarly, we add D♭ = C♯ and so on, so that every note has a fifth below and a fifth above.

This twelve-note scale is called the equally-tempered chromatic scale, and it is the scale that pianos and other musical instruments are actually tuned to.

This scale is a compromise between flexibility and tonal perfection. The price you pay for having a closed system is that instead of the frequency of the higher note being 1.5 times the frequency of the lower note, it's actually 1.4983 times higher -- every fifth interval is slightly flat.

And in fact that's how piano tuners do it "by ear". They tune one string to a tuning fork, then tune a fifth above it to a perfect 3:2 fifth, and then flatten the upper string just very slightly (or, equivalently, slightly sharpen the lower string if they are tuning a fifth below). Then they use that as the reference to tune the next note above it to a slightly flattened fifth, and so on until all twelve notes in one octave are tuned. Every other note can then be tuned to those reference notes. The process of getting the middle octave of the piano tuned is called "setting the temperament", which explains my little pun in part one.

Bach's famous set of preludes and fugues, one in all twelve major and minor keys, is called "The Well-Tempered Clavier". Though it sounds good when played in an equal temperament, Bach actually designed the pieces to be played on a "Well Tempered" instrument. In that temperament certain intervals are kept pure while others are significantly off, and must be avoided by the composer.

Next time, we get computers back into the picture. We'll write some programs that illustrate this fact, and thereby show how piano tuners can tune pianos by ear. Then in my final installment we'll write a program that illustrates a psychoacoustic oddity called Shepard's Illusion.

Desafinado, Part Two: A Perfect Pythagorean Tuning

Eric Lippert — Mon, 11 Apr 2005 21:22:00 GMT

Last time we talked about the Pythagorean's discovery that sounds with vibrations in the ratios 1:2 and 2:3 sound consonant to the human ear. Let's explore the consequences of that a bit.

Suppose we're building a stringed instrument from scratch and we want to tune it so that it sounds good to human ears. Let's tune the first string so that it vibrates at 440 vibrations per second. The unit of vibrations per second is the Hertz, so this is a 440Hz string. Call that string "A2".

There's no particularly good reason to pick 440Hz versus any other frequency, but we've got to start somewhere. Also, note that I'm assuming here that we have some magical way to exactly tune a string to a particular number of vibrations. The practical details of piano tuning in the absense of electronic measuring equipment are interesting, but before we get into that, I want to have a theoretical basis for what the ideal tuning ought to be.

Anyway, we've labeled this string "A2", and it's 440Hz. We'll add two more strings, an octave above and below that: A1=220Hz and A3=880Hz.

If we want to do nice harmonies and melodies, we have an intuition from Pythagorus that fifths are a good idea. What note below A2 makes a perfect fifth with A2? That is, what to 440Hz makes a 2:3 ratio? Easy -- 293.333Hz. Call that string D1, and make a string D2 an octave above it. So far we've got

Note Frequency
A1   220.000
D1   293.333
A2   440.000
D2   586.666
A3   880.000

A now has a fifth below, D has a fifth above. Let's make a fifth below D. What to D2 makes a 2:3 ratio? Call that G1, and add an octave G2 above it:

Note Frequency
A1 220.000
D1   293.333
G1   391.111
A2   440.000
D2   586.666
G2   782.222
A3   880.000

Now do the same thing to G2 to make C1 and C2, and the same thing to C2 to make F1 and F2, and we end up with a stringed instrument that looks like this in the first octave: (the second octave is all these doubled, so I'm going to stop calling out which octave we're in when I name the note. It'll be clear from context.)

Note Frequency
A   220.000
C    260.741
D    293.333
F    347.654
G    391.111

We'd then have an eleven-stringed instrument on which you could play traditional Asian music. This is called the pentatonic scale because it has five notes before it repeats.

Something that's interesting about this scale is the ratios between successive notes' frequencies:

A : C = 27 : 32
C : D = 8 : 9
D : F = 27 : 32
F : G = 8 : 9
G : A = 8 : 9

Clearly there is something interesting going on with this 8:9 ratio. Therefore, we'll give it a name. Just as the interval between two notes that are 2:3 is called a "fifth", the interval between two notes that are 8:9 is called a "tone".

There are two notable things here. First, the gaps from A to C and D to F are awfully big, quite a bit bigger than a tone. Second, though D:A is a fifth, there is no string such that A:x forms a fifth. We forgot to add a fifth above A.

In keeping with our intuition that the 8:9 ratio is important, let's insert tones above A and D. We'll add notes in an 8:9 ratio, call them B and E, and then work out the ratios of each string to its neighbour again:

Note Frequency Ratio to next
A     220.000      8 : 9
B     247.500    243 : 256
C     260.741      8 : 9
D     293.333      8 : 9
E     330.000    243 : 256
F     347.654      8 : 9
G     391.111      8 : 9

Hey, check it out -- this has the nice additional property that E is a fifth above A! Coolness. Two birds with one stone and all that.

This is called the diatonic scale, and is the standard scale for western music. These are the white keys on a piano.

Interestingly, the ancient Greeks developed this standard scale, but different groups wrote music in modes that emphasized different starting notes. If you play the scale CDEFGABC, we'd call that a "major" scale, but the Greeks would have called it the "Ionian Mode". The Aeolian Mode started on A, and we'd call that the "natural minor" scale. The Mixolydians started on G. (The Beatles wrote several songs in Mixolydian Mode, which is why songs like "Love Me Do" and "A Hard Day's Night" have a kind of odd sound to their chord progressions.) There is a different Greek tribe associated with each possible starting note, but they all used this scale.

Now we see where the terms "octave" and "fifth" come from. There are eight diatonic notes between (inclusive) any two notes an octave apart, and for every note except B and F, there are five notes between two notes a fifth apart. B has no fifth above, F has no fifth below.

The diatonic scale has many nice properties -- it has a large number of pairs of notes that sound good together. The greatest number of consonant pairs of any seven note scale, in fact. (The proof is left as an exercise to the reader.) A consequence of this fact is that if we want more consonant pairs, we're going to have to add more notes. Let's do that. After all, so far everything is working out great!

Next time: fixing that problem with B and F not having one of their fifths is going to screw everything up.

(Foreshadowing -- your sign of a quality blog.)

Desafinado, Part One: Eric Continues His Obsession With The Greeks

Eric Lippert — Fri, 08 Apr 2005 22:02:00 GMT

Whew. That's enough wacky VBScript for a while.

As I said a long, long time ago now, I came up with the idea of doing a little "wacky VBScript" quiz in order to illustrate some of the weird corner cases in language design. I want to do a long -- potentially very long -- series on some of the more computer sciency fundamental issues in the theory of programming languages and what "computation" means. These quirks are just the fun corner cases.

But I feel like changing gears for a bit before I get into that heavy lifting, if you'll pardon the mixed metaphor.

So for the next little while, music! No computers!

Well, ok, maybe some computers. In parts one through three, we'll build up some musical theory starting from the Ancient Greeks. In Part Four, we'll write a program that illustrates what I'm talking about. In Part Five, weird psychoacoustics!

*********************************************

One of my many dilletantish hobbies is playing the piano. I've got an upright at home with a lovely case and a terrible action, and it's not really in tune. I have all the equipment I need to tune it myself, I just don't have the time right now, or the temperament.

Ha ha ha ha, little piano tuner joke there. It'll become clear why that's so funny in a bit.

The ironic thing about tuning a piano is this: all pianos are out of tune. On purpose.

In fact, almost all music you've ever heard on all instruments has been deliberately out of tune.

How is that possible? Surely you'd have noticed!

To explain, we have to go way, way back to the time of Pythagoras, that mystic ancient Greek whose dour band of crazy math geeks violently suppressed information about dodecahedra and the irrationality of root two. Amongst the Pythagoreans' many fundamental discoveries in mathematics is that if you pluck tightened strings of equal tension and different lengths, the sound is most consonant -- pleasing to the ear -- when the ratio between the string lengths is a ratio of small whole numbers.

For instance, take a string under tension and press down on it like you would on a guitar, dividing it into two strings, one twice as long as the other. Or, equivalently, get two strings under the same tension, one twice as long as the other. If you pluck them at the same time then you get a very pleasing sound. The ratio is 1:2, and this is a "perfect octave". Find yourself a piano and hit middle C and the next higher or lower C and you'll hear what I mean. In some very strong sense the human ear hears these two tones as extremely similar. We hear it as "the same tone, only higher".

Clearly "octave" has something to do with the number eight -- what exactly will become clear later.

Why it is that humans find small ratios pleasant is an interesting question that I might explore in another post. But for now, just accept that small whole number ratios sound really good.

If 1:2 sounds good, what about other small-number ratios? Doubling/halving the string length gives you an octave. What about making the string 50% longer -- a ratio of 2:3? Yes, that also sounds really good. If you play C on a piano and then hit the G below it, that's a ratio of 2:3 in terms of string length (again, assuming that the strings are under the same tension, etc.)

This is the ratio used in Gregorian chants. This ratio is called a "fifth", again, for reasons which will become clear later.

We know nowadays something that the Pythagoreans did not: that what really matters is not the lengths of the strings, but the speed at which they vibrate. It just happens that a string that is twice as long vibrates half as slowly, all other things being equal, so basically the ratios are the same whether you're talking about string length or vibration frequency, they're just opposite in order.

From now on we'll talk only about ratios in terms of their vibrations per second, and stop worrying about string length. A piano has eight octaves. If the longest string had to be 128 times longer than the shortest string then you'd need a big room! Therefore we vary the thickness, weight and tension of the strings so that they can be a reasonable length and yet vibrate at the right frequency. It's the vibrations that matter. (The variance in thickness of the strings leads to practical problems with inharmonicity in the short strings, but we probably won't get into that level of detail in this series.)

Next time we'll mentally build a stringed instrument from scratch and figure out how to tune it to perfect Pythagorean pitches.