Complications of the new TOP finding method

Here's an example that illustrates some of the complications associated with using the projected (rank+1)-prime commas to find the TOP tuning. This might not be an especially useful temperament, but it would be nice if the algorithm could be made general enough to handle cases like this.

37&88 11-limit rank-2 temperament

wedgie: <<49, 20, 13, 16, -82, -117, -144, -26, -32, 0]]
generator mapping: [<1, -9, -2, 0, 0], <0, 49, 20, 13, 16]>

First find all the 3-prime commas and their TOP error. Since the wedgie has a zero element, some of them will only have two primes.

[-82, -20, 49, 0, 0> TOP: 0.396846
[117, 13, 0, -49, 0> TOP: 0.192414
[-144, -16, 0, 0, 49> TOP: 0.540910
[26, 0, 13, -20, 0> TOP: 0.405584
[-8, 0, -4, 0, 5> TOP: 0.327740
[0, 0, 0, -16, 13> TOP: 0.733324
[0, -26, 117, -82, 0> TOP: 0.560049
[0, 16, -72, 0, 41> TOP: 0.061991

The TOP error of the temperament is the biggest of these, which is 0.733324, and the corresponding comma is [0, 0, 0, -16, 13>.

So the TOP tuning of primes 7 and 11 can now be found; 7 is (0.733324) * log(7)/log(2) cents sharp (3370.884608) and 11 is (0.733324) * log(11)/log(2) cents flat (4148.781057).

Now to find an appropriate tuning for the other three primes. There are three obvious possibilities: tune one of the primes (picking 2 as an example) so that the error is zero, tune it flat by the TOP error or less, or tune it sharp by the TOP error or less. Conveniently, the generator mapping has 0 for the period for the mapping of primes 7 and 11, so we can calculate the value of G as 259.298816 and adjust P to find a tuning that works. In other cases, we might need to adjust both the generators.

In this case, tuning the octave to eliminate the error doesn't work, since that forces prime 3 to have a TOP error of 2.326228. Tuning the octave flat is even worse. So the octave needs to be tuned sharp. By how much? The TOP error of 0.733324 is too much, since that forces the error of prime 3 to be -1.837857.

So you need to find a tuning of the period which puts the TOP errors of 2, 3, and 5 under 0.733324 cents. This is the part that I still don't have a good solution for, but these cases are rare enough that it might not be worth the bother to find a general solution. In this case, P = 1200.513085 seems to be optimal, giving equal error of -0.587254 cents to both 3 and 5, and leaving 2 with an error of 0.513085.

Herman Miller wrote:

> So you need to find a tuning of the period which puts the TOP errors of > 2, 3, and 5 under 0.733324 cents. This is the part that I still don't > have a good solution for, but these cases are rare enough that it might > not be worth the bother to find a general solution. In this case, P = > 1200.513085 seems to be optimal, giving equal error of -0.587254 cents > to both 3 and 5, and leaving 2 with an error of 0.513085.

And I just realized that I overlooked P = 1200.333488, which has a better error for all three primes: 0.333488, 0.432559, -0.432559.

--- In tuning-math@yahoogroups.com, Herman Miller <hmiller@...> wrote:

> And I just realized that I overlooked P = 1200.333488, which has a
> better error for all three primes: 0.333488, 0.432559, -0.432559.

This method seems like a good general approach: first find the TOP
tuning with free parameter(s). In this case, the tuning will be

[u2, -9*u2+12705.641985773541534, -2*u2+5185.9763207238945037,
3370.8846084705314274, 4148.7810565791156030]

where the octave value of u2 cents is adjustible. Now find a NOT-like
tuning for the remaining primes. By "NOT-like", I mean that it isn't
necessarily the octave which is fixed. Here you fix the 7 (or
equivalently, the 11) and now are left to work out what 2, 3, and 5 are.
So you look at tunings equalizing the relative errors for 2 and 3, for
2 and 5, and for 3 and 5, with both equal and opposite errors.

The least relative error, if I've done this right, is Herman's
suggestion:

3 sharp, 5 flat
u2 = 1200.3334884159102128
relative errors = [0.3334884159102128, 0.43255860290086288455, -
0.43255860290086277862

Not much different is this:

2 and 3 sharp
u2 = 1200.3483229069449156
relative errors = [0.3483229069449156, 0.3483229069449156, -
0.44533633798005559664]