A common thing to do when working with pitch is transpose them by some amount: down a 4th, up an octave, etc. If you are working with equal temperament (12 or other) you simply add your transposition interval to every note:

[0, 4, 7] + 4 = [4, 8, 11]

or

[C, E, G] up a M3 = [E, G#, B]

(since I’m a programmer, I’m writing all of these as arrays, deal with it =P)

This is very intuitive and even someone who knows little or nothing about music could probably understand it (just go up by N keys from each note on the piano and you are done). When working with Just Intonation however, we are working with multiplication rather than addition. While the math involved is actually not terribly more difficult, the resulting numbers often appear really complicated:

[0, 4, 7] + 4 = [4, 8, 11]

as ratios would look like

[1:1, 5:4, 3:2] * 5:4 = [5:4, 25:16, 15:8]

or as partials

[4, 5, 6] * 5:4 = [20, 25, 30]

“Ack, those numbers are really big! How complex!!” is a common response to seeing this. You could imagine that if we were transposing by more “complex” ratios (those involving larger numbers and/or more distance between numerator and denominator) we would quickly end up with an unwieldily mess. No one wants to deal with 3, 4, or 5 digit numbers: this is music, not calculus (…hah)!

Beyond the ugly large numbers, I have one other major issue with the above approach (which I will call here **absolute pitch JI**: it completely looses its identity. Yes, seeing [5:4, 25:16, 15:8] means I can get out my calculator and figure out what frequencies I’ll get quite precisely, but I have no idea what is going on when I look at it. [1:1, 5:4] and [5:4, 25:16] are both the same interval but that’s difficult to see at first glance (and even more difficult when larger numbers are involved).

Stepping back to my first example, something like [0, 4, 7] is very familiar to anyone who’s studied 20th century music: it’s a pitch class set. What is a pitch class set at it’s core? It’s the *relative* intervals between pitches from some arbitrary reference point. Before I labeled [0, 4, 7] as [C, E, G] but [E, G#, B] is the exact same pitch class set, and when analyzing music with pitch class sets you would identify them as the same thing.

Applying the same approach to JI, what is the resulting chord from [1:1, 5:4, 3:2] * 5:4?

…

[1:1, 5:4, 3:2] * 5:4

Why would we change it? That just makes it less readable. In fact, now it’s perfectly clear both what the chord is AND that we are transposing it by 5:4. I’ll call this **relative** JI.

“But now I don’t know EXACTLY what notes I need!”

You’re doing it wrong! It doesn’t matter. An [0, 4, 7] is an [0, 4, 7] no matter where you start it from so why should it be any different with ratios?

“But… math!!”

Yes yes, I know. Eventually you’ll need to multiply everything out to get your frequencies for your fancy notes. You’ll also need to multiply all your ratios by your fundamental frequency for that anyway (since JI is always relative to a reference pitch in the first place).

**The Anatomy of a Pitch**

There is no reason to bounce everything down to frequencies until you are going to play them really. Before that, we might as well keep things in a format that’s more friendly for working with it. Taking an approach from programming, rather than thinking of pitches as **a number**, let’s think about if as a data structure:

// a single pitch

{

fundamental: 440,

ratio: 5/4,

transposition: 3/2

}

fundamental * ratio * transposition = frequency

Which equals 15:8 or 825Hz, but we can actually see how we got there. Often we don’t even want to include the fundamental with the actual pitch since it is more of a global thing (you’ll *usually* only have 1 fundamental for a piece or section). So really we are looking at:

{

ratio: 5/4,

transposition: 3/2

}

most of the time.

Here “ratio” is the identity (or Odentity/Udentity if you would rather use Partch’s terminology) of the pitch. What is “transposition” exactly? Just a series of ratios to multiply the ratio by to get to where you want to be. We can just as easily have this:

{

ratio: 5/4,

transposition: 3/2, 2/1, 6/5

}

which is 5:4 up a perfect fifth, then up an octave, then up a minor third: FAR more useful than seeing 225:32 by itself. Since multiplication is commutative, the order of the transpositions doesn’t matter. Just multiply everything together and you get your result!

**Use Case: Pitch Lattice**

A common way or working in JI is to use an n-limit lattice (just google “pitch lattice”). These usually look like a 2, 3, 4+ diminutional grid of number vomit when written out because people typically write the resulting ratio for each location. At its core however, a lattice isn’t *all* the possible ratios, it’s a set of transpositions. A typical 5-limit lattice in its simplest form is this:

….5/4

4/3 1/1 3/2

….8/5

What happens when you move one space in any direction? The lattice moves with you! That means that all you need to do is keep track of where you move. So in this example if I move right, right, up I would get:

{

ratio:

transposition: 3/2, 3/2, 5/4

}

“But derp, 3/2 * 3/2 is 9/8 man! Learn to math!!”

I don’t care what it is, I care how I got there. Remember, all a lattice *really* is is a grid of transpositions, not absolute notes. Much more useful than seeing 45/16, which, while it makes us look like we math pretty hard, doesn’t tell us anything.

**Final Thoughts**

Hopefully you will find this approach to be somewhat useful. As I mentioned many times, this is about valuing clarity over all else. It should also make working with ratios less daunting as I’m rather sick of hearing the complaint that “just intonation gets too complex/difficult/meh!” when you try to transpose, modulate, or even just stack ratios on top of ratios. It’s conceptually no different from equal temperament, only you end up multiplying rather than adding.

If math is a sticking point, why are you working with tunings?!?! (joking)

Seriously though, if you are working with things like this, it’s probably a good idea to use a computer to handle the math. This is 2014 after all! Even if you know nothing about programming in general, learn how to use a basic python interpreter or something like that so that you can write out:

440 * (3/2) * (3/2) * (5/4)

and it spits out 1237.5, rather than grabbing your calculator or abacus and slogging through all of it yourself (although you *should* be able to, it’s just way faster and less accident prone).