Re: Diatonic notation system

[Graham Breed]

2008/12/7 Hans Aberg <address@hidden>:
> On 7 Dec 2008, at 14:59, Graham Breed wrote:
>
>>> That is not the problem , but that whole tone is not the double of the
>>> half
>>> tone. M = 9, m = 4, so that there are 5*M+2*m = 53 tonesteps or commas in
>>> an
>>> octave.
>>
>> How is that a problem?
>
> The rules for computing accidentals and transpositions will be different,
> and it will sound differently (see below).

To get it to sound right, you multiply by 6.  If accidentals and
transpositions don't work you may need to define a different grid from
them.  The worst is that you need one init file to define the notation
-- so that the accidentals are distinct where you want them to be --
and another init file to define the true pitches.

>>> When I looked at it, it computes accidentals as an offset from the
>>> whole-tones, which are six to the octave. That forces E12, and for
>>> intermediate pitches a multiple of 12.
>>
>> Oh, this looks like a problem.
>
> And this is what causes the problems. If done properly, the offsets should
> be computed properly, it should be done towards a scale that also involves
> m, as only in E12, there are six M in the octave.

Meaning Lilypond still has a way to go for microtonal output.  It is,
at least, improving.  Even if the pitch specifications were accurate,
they'd have to be converted to pitch bends.  Then all kinds of
problems come in.  Most of the time it's simpler to talk of "half
steps" and program the synthesizer to do the tuning.

> Yes, and that is essentially what I am saying. The Western musical notation
> system is diatonic in the sense I described it. This is very clever, because
> it then work, regardless if it is Pythagorean, E12 or meantone tunings used:
> these latter are just differently intonations of the music.

The trouble is the output is still MIDI.  If you could get Csound
output it could all work properly.  Is there a way of using the
Lilypond parser and writing different output?  If you have patches to
make Lilypond do what you want that's something you could show the
developers.

Csound is a much better place to start for microtonal output.  I'm
working on a custom format that can be processed into either Csound,
ABC, or Lilypond.  That way I don't have to fight MIDI.  Lilypond
could be very flexible for printed output if it had arbitrary
accidental glyphs.

There are also Scala .seq files.

> So I think this system of defining an interval by a number and then looking
> up accidentals does not work. Instead, the pitches should be recorded as
> written, imposing any ET relations at need. But even then, it is common to
> stick to diatonic notation conventions, and only apply E12 conventions
> selectively.
>
> Even chromatic runs may be notated in E12, but in a meantone tuning, that is
> selectively choosing flats and sharp to make up 12 in the octave. This is
> the difference between the 12-note "meantone", and the in general infinite
> "extended meantone" tunings.

Are you saying that doesn't work now?  You always specify the nominal
the alteration is relative to.  The diatonic pattern should be
preserved with transpositions and if sharps and flats get swapped it's
a bug.  All the information for extended meantone is there.

The MIDI will always be a mess because there are 7 nominals and 12
notes.  You could define alterations relative to your synthesizer's
tuning table, and even alter the size of a pitch bend.  But it'll
break when Lilypond assumes a "half step" between consecutive notes.

>> Yes, the intermediate pitches are specified as fractions of a whole
>> tone.
>
> For music without intermediate pithes, as integer pairs (p, q), referring to
> the abstract combination p m + q M.

If the music has abstract combinations instead of pitches, what is
Lilypond supposed to do about it?

> For music with intermediate pitches, one extends this to sequences (p, q,
> r_1, ..., r_s), referring to the abstract interval combination p m q M + r_1
> n_1 + r_s n_s.
>
>> How else do you suggest that be done?  You can write a function
>> that converts from your chosen units into fractions of a whole tone
>> with whatever precision you choose.
>
> Only if one knows m and M in advance, and it will generally destroy the
> musical structure.

If you don't know M and m in advance, how is Lilypond supposed to
guess them?  What's the problem with the musical structure?

>>> Now that fixation is not only a problem for MIDI files, but may cause
>>> transposition problems, as a half-flat may be erroneously altered to a
>>> half-sharp on the semi-tone below.
>>
>> Could it?  Define the "half-flat" as a bit less than half a semitone,
>> then.
>
> The problem is that one does not agree on what it should be, and the music
> may drawn towards E53 in some interpretations, so one is back to the problem
> of changing m. But the notation is still the same. So it would be better to
> keep underlying model preserving the musical intent.

That's why you have init files.  Supply a different init file, or
alter the tuning specifications.

>>> A more immediate concern would be fixing Arab music. The guy who didi it
>>> fixed it at E24, because they use such symbols, but everyone agrees that
>>> the
>>> intermediate pitch is not an exact quarter-tone.
>>
>> So change the init file.
>
>
> There is the personal interaction problem: even though one agrees what the
> notation should be, one does not agree what the tuning should be. So as it
> is, set in E24, people may typeset a lot music that can be hard to retune.

Why are you so worried about what "people" might do?

> A similar problem appear with music typeset in E12: if it should be retuned,
> one must first resolve enharmonic accidentals.

Music isn't typeset "in E12".  It's typeset in a diatonic notation
system, exactly as you wanted.  The problem is that it tends to be
heard in E12.

> By contrast, properly notated music works in any tuning.

No, not any tuning.

> So the current system invites poor notation that cannot be easily retuned.

It depends on how the pitches are specified, which depends on the init
file.  If a half-sharp above C is the same as a half-flat below C# you
may as well say so.  If you want them distinguished you have to write
an init file that gives them different names.  Given that, the music
can easily be retuned so that the two pitches are different.  And the
two pitches can be written differently.


                               Graham