Yahoo Tuning Groups Ultimate Backup tuning Adapting Sagittal notation for use in Csound

I've been looking for some way to explore different tunings and temperaments, and evaluate various notations for these, in a way that avoids the limitations of MIDI files. I have a number of MIDI files intended for retuning, but of course there's no indication within the MIDI file itself what tuning is to be used with them! There's also the difficulty of finding the right MIDI note on a keyboard or piano roll if you're working with a non-standard tuning. And MIDI files can't easily handle scales with 31 or more notes per octave, since there are only 128 distinct MIDI notes.

So I've been looking into the possibility of using Csound. It's not the easiest thing to use, but it looks like a pretty capable system if I can get past the quirks and the initial learning difficulty. I was reading through the Csound Book and ran across the article on macros; I realized that these could be used to define more complex notation systems.

One problem with using the Sagittal notation in Csound is that macro names need to be alphanumeric. I know some of the ASCII abbreviations for Sagittal accidentals, but I can't seem to find a file that documents the complete set. In any case, not all of them are alphanumeric, so I'm going to need to come up with two-or-more-letter alphanumeric equivalents for the ones that aren't. But I've managed to work around the limitations of the system and I'm starting to come up with what seems like a reasonable notation that's usable in Csound scores.

Start with a few basic definitions: in this case the base-2 logarithms of the primes:

#define p2 #1.000000000#
#define p3 #1.584962501#
#define p5 #2.321928095#
#define p7 #2.807354922#

... and so on. If on the other hand you want to notate a temperament, such as meantone, you can alter these to the appropriate values. Here's an example of TOP 7-limit meantone, <<1, 4, 10, 4, 13, 12]].

#define p2 #1.001415434#
#define p3 #1.582719091#
#define p5 #2.325214630#
#define p7 #2.808790273#

Now comes the tricky part. Expression evaluation in Csound scores is pretty limited, and I've had to use some trial and error to get these expressions to work. The basic 7 nominals of Sagittal notation are based on factors of 2 and 3 (or their tempered equivalents):

#define C(X) #($X.-4)*$p2.+8# ; 1/1
#define D(X) #($X.-4)*$p2.+8+(2*$p3.-3*$p2.)# ; 9/8
#define E(X) #($X.-4)*$p2.+8+(4*$p3.-6*$p2.)# ; 81/64
#define F(X) #($X.-4)*$p2.+8+(2*$p2.-$p3.)# ; 4/3
#define G(X) #($X.-4)*$p2.+8+($p3.-$p2.)# ; 3/2
#define A(X) #($X.-4)*$p2.+8+(3*$p3.-4*$p2.)# ; 27/16
#define B(X) #($X.-4)*$p2.+8+(5*$p3.-7*$p2.)# ; 243/128

The initial "($X.-4)*$p2.+8" part of the expression is for setting the pitch of C(4) to be middle C (which is 8.0 in Csound). This allows for the octaves themselves to be tempered if this is desired. The rest of the expression adds together multiples of the prime logarithms to arrive at the correct pitch for each note, based on the selected temperament. Here's an example of how this could be used in a score:

i1 0 4 10000 [$C(4)]
i1 0.5 3.5 10000 [$E(4)]
i1 1 3 10000 [$G(4)]

Unless you're using a meantone temperament, this will result in a slightly detuned C-E-G major triad. If you want a just 4:5:6 triad, you'll have to add the accidental for the 5-comma 81/80. In Sagittal notation this is /| for "comma up" and \! for "comma down", but since macro names must be alphanumeric, I've used the names "cu" and "cd".

#define cu #+(4*$p3.-(4*$p2.+$p5.))# ; /| / 81/80
#define cd #-(4*$p3.-(4*$p2.+$p5.))# ; \! \ 80/81

Now you can notate the major triad like this:

i1 0 4 10000 [$C(4)]
i1 0.5 3.5 10000 [$E(4)$cd.]
i1 1 3 10000 [$G(4)]

For sharps and flats, I've defined the macros "sh" and "fl".

#define sh #+(7*$p3.-11*$p2.)# ; /N\ # 2187/2048
#define fl #-(7*$p3.-11*$p2.)# ; \U/ b 2048/2187

The 7-comma 64/63 has the convenient ASCII abbreviations "f" (up) and "t" (down), so I'll use these as the names of the macros.

#define f #+(6*$p2.-(2*$p3.+$p7.))# ; |) f 64/63
#define t #-(6*$p2.-(2*$p3.+$p7.))# ; !) t 63/64

Unfortunately I don't know of a short ASCII version of B!!!) (which is the Sagittal notation for the 7th harmonic above C). A(|\ could be used, but that really represents 729/416, which could be an entirely different note in certain temperaments. (Even in JI, when I did a test with B!!!) played simultaneously with A(|\ I could hear the beating.) So I may have to settle for writing B!!!) as [$B(4)$fl.$t.].

For the 11 M-diesis 33/32, I settled on "ss" for "semisharp" and "sf" for "semiflat".

#define ss #+($p3.+$p11.-(5*$p2.))# ; /|\ ^ 33/32
#define sf #-($p3.+$p11.-(5*$p2.))# ; \!/ v 32/33

And conveniently, the 13 L-diesis 27/26 has a single-letter ASCII abbreviation.

#define m #+(3*$p3.-($p2.+$p13.))# ; (|\ m 27/26
#define w #-(3*$p3.-($p2.+$p13.))# ; (!/ w 26/27

Now we can notate a 4:5:6:7:9:11:13:15 chord.

i1 0 4 10000 [$C(4)]
i1 0.5 3.5 10000 [$E(4)$cd.]
i1 1 3 10000 [$G(4)]
i1 1.5 2.5 10000 [$B(4)$fl.$t.]
i1 2 2 10000 [$D(5)]
i1 2.5 1.5 10000 [$F(5)$ss.]
i1 3 1 10000 [$A(5)$w.]
i1 3.5 0.5 10000 [$B(5)$cd.]

Extending this to support larger subsets of the Sagittal notation is simply a matter of defining the appropriate macros for each new pair of accidentals. The same method could also be used for representing other notation systems.

🔗George D. Secor <gdsecor@yahoo.com>

--- In tuning@yahoogroups.com, Herman Miller <hmiller@I...> wrote:
>
> One problem with using the Sagittal notation in Csound is that
macro
> names need to be alphanumeric. I know some of the ASCII
abbreviations
> for Sagittal accidentals, but I can't seem to find a file that
documents
> the complete set. In any case, not all of them are alphanumeric, so
I'm
> going to need to come up with two-or-more-letter alphanumeric
> equivalents for the ones that aren't.

> ... If you want a just 4:5:6 triad,
> you'll have to add the accidental for the 5-comma 81/80. In
Sagittal
> notation this is /| for "comma up" and \! for "comma down", but
since
> macro names must be alphanumeric, I've used the names "cu" and "cd".
>
> #define cu #+(4*$p3.-(4*$p2.+$p5.))# ; /| / 81/80
> #define cd #-(4*$p3.-(4*$p2.+$p5.))# ; \! \ 80/81

I think it would be a good idea to be more specific with your
abbreviations, since "comma" can apply to a lot of different micro-
accidentals. Since your macros can be alphanumeric, why not include
numeric digits in their names? And since you may want an easy way to
distinguish macro names for accidentals from other macro names, you
might want to begin all of them similarly, e.g.,

u5C for 81:80 (up 5-comma): /|
d5C for 80:81 (down 5-comma): \!
d7C for 63:64 (down 7-comma): !)
u11Md for 33:32 (up 11 medium-diesis): /|\
u11Ld for 729:704 (up 11-large-diesis): (|)
u5r7k for 5120:5103 (up 5:7-kleisma): |(
d5r11Sd for 44:45 (down 5:11 small-diesis): (!(
u7r11C for 45927:45056 (up 7:11 comma): (|
u7r11k for 896:891 (up 7:11 kleisma): )|(
u19s for 513:519 (up 19-schisma): |(

The character "r" in "5r7" stands for "ratio" of 5:7. I used an
upper-case "L" so that it would not be confused with the numeral "1",
likewise upper-case "C", "S", and "M" for comma, small diesis, and
large diesis for consistency. Notice that the macro names for (|
and )|( differ by only a single character, which demonstrates that
you need the interval category (schisma, kleisma, comma, diesis) in
the macro name. The boundaries that Dave Keenan determined for these
categories are given in the following table:

Square of lowerbound
.. 2-exponent
...... 3-exponent
............... Lowerbound (cents)
................................ Size range name
-------------------------------------------------
.. [ 0 0 > ....... 0 ........... schismina
.. [-84 53 > ..... 1.807522933 . schisma
.. [ 317 -200 > .. 4.499913461 . kleisma
.. [-19 12 > .... 11.73000519 .. comma
.. [ 27 -17 > ... 33.38249264 .. small-diesis
.. [ 8 -5 > ..... 45.11249784 .. (medium-)diesis
.. [-11 7 > ..... 56.84250303 .. large-diesis
.. [-30 19 > .... 68.57250822 .. small-semitone
.. [-49 31 > .... 80.30251341 .. limma
.. [-3 2 > ..... 101.9550009 ... large-semitone
.. [ 62 -39 > .. 111.8774831 ... apotome
.. [-106 67 > .. 115.492529

These interval (and macro) names would not in any way be restricted
to Sagittal notation. They're actually a byproduct of our notation
development project, since they can be used to distinguish intervals
that are very nearly the same size (and thus notated alike in medium-
resolution, athenian-level, Sagittal). For example:

d35Ld for 8192:8505 (down 35-large-diesis): (!/ ~64.91 cents
d13Ld for 26:27 (down 13-large-diesis): (!/. ~65.34 cents

BTW, we have been working on an extreme-resolution (olympian-level)
Sagittal JI notation that *will* be able to distinguish the above
intervals. This is intended for computer-based and certain
theoretical applications. I've actually used it in the above
example -- notice the period following the slash character for 26:27,
which represents an additional 4095:4096 (schismina, ~0.42 cents) of
alteration. If you want more information about this, please contact
Dave or myself off-list; there are a number of unresolved issues that
we've been discussing, and your opinion may be helpful. Dave also
developed a way to achieve extreme-resolution pitch accuracy in a
computer application using only medium-resolution (athenian-level)
symbols in conjunction with a table of "smart defaults" that he
recently created (which I have no doubt you'll be interested in).

> Now you can notate the major triad like this:
>
> i1 0 4 10000 [$C(4)]
> i1 0.5 3.5 10000 [$E(4)$cd.]
> i1 1 3 10000 [$G(4)]
>
> For sharps and flats, I've defined the macros "sh" and "fl".
>
> #define sh #+(7*$p3.-11*$p2.)# ; /N\ # 2187/2048
> #define fl #-(7*$p3.-11*$p2.)# ; \U/ b 2048/2187

How about:

ua (up apotome): /N\
da (down apotome): \U/
uda (up double apotome): /X\
dda (down double apotome): \Y/

> The 7-comma 64/63 has the convenient ASCII abbreviations "f" (up)
and
> "t" (down), so I'll use these as the names of the macros.
>
> #define f #+(6*$p2.-(2*$p3.+$p7.))# ; |) f 64/63
> #define t #-(6*$p2.-(2*$p3.+$p7.))# ; !) t 63/64
>
> Unfortunately I don't know of a short ASCII version of B!!!) (which
is
> the Sagittal notation for the 7th harmonic above C). A(|\ could be
used,
> but that really represents 729/416, which could be an entirely
different
> note in certain temperaments. (Even in JI, when I did a test with
B!!!)
> played simultaneously with A(|\ I could hear the beating.) So I may
have
> to settle for writing B!!!) as [$B(4)$fl.$t.].

Short ASCII is only for the mixed-symbol version of Sagittal, since
there are not enough characters for the pure version. I agree that
you should use two macro names for B!!!), to correspond to the mixed-
symbol Bb!) notation.

If you really wanted to get 7/4 by altering A upward, your macro
could be named:

u7Ld for 28:27 (up 7 large-diesis): .(|\ ~62.96 cents

This is a 5-schisma smaller than u35Ld. Notice the period preceding
the left-parenthesis character, which represents a decrease of
alteration of 32768:32805 (5-schisma, ~1.95 cents). The period
character is our shorthand for a grave (down) accent mark; we use the
apostrophe character as shorthand for an acute (up) accent mark.
While it's possible to use these accent marks on a staff, in real-
time performance they would probably be ignored, since the pitch
alterations they represent are very small.

> Extending this to support larger subsets of the Sagittal notation
is
> simply a matter of defining the appropriate macros for each new
pair of
> accidentals. The same method could also be used for representing
other
> notation systems.

The macro names that I've suggested are longer than the ones you
have, but they're easy to determine, once you understand how the
commas are named.

--George

🔗George D. Secor <gdsecor@yahoo.com>

🔗Dave Keenan <d.keenan@bigpond.net.au>

--- In tuning@yahoogroups.com, Herman Miller <hmiller@I...> wrote:
...
> I was reading
> through the Csound Book and ran across the article on macros; I
realized
> that these could be used to define more complex notation systems.

That's brilliant Herman! I love the way you can change the
temperament by redefining the primes.

> One problem with using the Sagittal notation in Csound is that
macro
> names need to be alphanumeric. I know some of the ASCII
abbreviations
> for Sagittal accidentals, but I can't seem to find a file that
documents
> the complete set.

See
http://dkeenan.com/sagittal/map/

This isn't the _complete_ complete set, since we haven't fully
agreed what that is yet. :-) But it certainly contains more Sagittal
symbols than most people will ever need, and it contains all those
with single-character ASCII transliterations.

> In any case, not all of them are alphanumeric, so I'm
> going to need to come up with two-or-more-letter alphanumeric
> equivalents for the ones that aren't.

That's certainly the case if they are represented in the _names_ of
macros (and I like George's suggestion there), but I wonder if you
could pass even the non-alphanumeric ones to the macro preprocessor
as string literal _arguments_, and have the macro expand to a huge
nested conditional expression. I know nothing about what operators
are allowed, but I'm guessing any valid C expression that evaluates
to a number.
e.g.

#define C(X,Y) #($X.-4)*$p2.+8+ \
($Y.=="/" + $Y.=="/|") ? (4*$p3.-(4*$p2.+$p5.)) : (\
($Y.=="\" + $Y.=="\!") ? -(4*$p3.-(4*$p2.+$p5.)) : (\
($Y.=="f" + $Y.=="|)") ? (6*$p2.-(2*$p3.+$p7.)) : (\
($Y.=="t" + $Y.=="!)") ? -(6*$p2.-(2*$p3.+$p7.)) : (\
($Y.=="^" + $Y.=="/|\") ? ($p3.+$p11.-(5*$p2.)) : (\
($Y.=="v" + $Y.=="\!/") ? -($p3.+$p11.-(5*$p2.)) : (\
...
0...))))))#

The trailing backslashes are intended as line-continuations.

Another useful property of a scheme like this is that the macro that
expands the sagittal knows what nominal it is being applied to. This
opens up the possibility of using the "smart defaults" that George
mentioned. This property might also be obtained in some other way.
More about "smart defaults" later.

> Now comes the tricky part. Expression evaluation in Csound scores
is
> pretty limited, and I've had to use some trial and error to get
these
> expressions to work.

Then I guess something like the above is unlikely and you probably
already thought of it.

> A(|\ could be used,
> but that really represents 729/416, which could be an entirely
different
> note in certain temperaments. (Even in JI, when I did a test with
B!!!)
> played simultaneously with A(|\ I could hear the beating.) So I
may have
> to settle for writing B!!!) as [$B(4)$fl.$t.].

The question of what a particular sagittal "really represents", when
combined with a particular nominal, has been reexamined recently
thanks to Robert Walker, who has been busy implementing sagittal in
Fractal Tune Smithy - particularly its chord-progression player.

For the benefit of other readers: Sagittal isn't so much a notation,
as a notation _system_. It encompasses notations for many different
tunings in such a way that they are _harmonically_ consistent with
each other, while melodic consistency is maintained as much as
possible within that constraint. For example, in any given tuning, a
4:5:6 major triad on C, or the best available approximation thereof,
will always be notated C:E\:G, unless it happens to be in a
temperament where the syntonic comma vanishes and can therefore be
notated more simply as C:E:G.

A single _notation_, within the Sagittal system, is characterised by
a notational octave size and a notational fifth size (which
determine the meaning of the nominals), and a limited set of
accidental symbols, and some lookup tables:

For unambiguously converting from pitch to symbol, a notation must
also give a range of pitch alterations corresponding to each symbol -
the symbol's "capture zone" - with no overlaps and no gaps between
capture zones. It is enough to list the symbols in pitch order and
give the lower-bound for each in cents.

And for unambiguously converting from symbol to pitch it must give a
single _default_ pitch alteration corresponding to each symbol. This
default pitch alteration must of course be within the symbol's
capture zone.

You can see this information in Scala's various SAxxx.PAR files,
although in the case of ET notations a greatly abbreviated form can
be used since the defaults are simply successive degrees of the ET
and the zone boundaries are simply half-way between the degrees.

In the case of the 12-ET-relative "Trojan" notation, the lower-
bounds are given in cents and the defaults are given as fractions of
a 12-ET semitone.

In the case of the various JI notations (of which only the medium-
resolution "Athenian" notation has so far been defined), the lower
bounds are given in cents and the defaults are given as exact
frequency ratios.

In fact, these default JI ratios are the glue holding the whole
Sagittal system together. They are, in the absence of any further
information, what the symbols "really represent". We refer to them
as the symbol's "primary comma".

In order to make the Sagittal system work as well as possible across
so many different tunings, we defined symbols for the most popular
notational commas, i.e. the commas most often needed to notate the
most popular ratios.

The best way we could figure to determine ratio popularity was to
look at their ocurrences in the Scala archive (thanks Manuel). This
decision might be controversial, but if you look at the results, you
see that in most cases the decision as to which comma to use in a
certain vicinity is like chalk and cheese, one of them notates
ratios that occur many times more often, and this usually agrees
with our intuitions based on consonance, ratio complexity, prime
limit and so on.

However, an important proviso above is that the primary comma (or
tempered version thereof) is the default pitch alteration "in the
absence of any further information". For example, if we know that an
ET is being notated, then the default pitch will be an exact degree
of the ET. In fact it will be the degree that is closest to the
tempered primary comma (with some very rare exceptions where a
secondary comma is used because no simple primary is available).

But we recently realised that even in the case of JI notations we
were not using all the available information to determine exactly
what alteration a sagittal should default to ("really represent").
We were not using the nominal (and sharps or flats), although these
were of course being used to determine the gross pitch. So for the
Athenian JI notation (the only one so far defined) we revisited the
Scala archive statistics and found the most popular ratio that would
be notated by each combination of nominal, sharps or flats and
sagittal symbol.

So the sagittal symbol can now "really represent" slightly different
pitch alterations (different commas) depending on the nominal it is
associated with. It now gives the ratio you actually wanted, maybe
99% of the time, and severely reduces the need to use higher-
resolution notations involving accented symbols or more complex
unaccented symbols. We've increased the precision without increasing
the number of symbols. This is what we call "smart defaults".

The resulting two-dimensional lookup table appears here as a zipped
Excel spreadsheet (28 kB).
http://dkeenan.com/sagittal/AthenianSmartDefaults.z
ip

Regards,
-- Dave Keenan

🔗George D. Secor <gdsecor@yahoo.com>

🔗Herman Miller <hmiller@IO.COM>

Dave Keenan wrote:
> That's certainly the case if they are represented in the _names_ of > macros (and I like George's suggestion there), but I wonder if you > could pass even the non-alphanumeric ones to the macro preprocessor > as string literal _arguments_, and have the macro expand to a huge > nested conditional expression. I know nothing about what operators > are allowed, but I'm guessing any valid C expression that evaluates > to a number.

Unfortunately macros are fairly limited in Csound scores. Csound works entirely with numbers (no characters or strings), and macros can only use the arithmetic operators + - * / together with parentheses for grouping. There isn't even a unary minus, which really complicates things. (At least that's the case with the version of Csound that came with the Csound Book; it's possible that a newer version might have improved macro preprocessing.)

> e.g. > > #define C(X,Y) #($X.-4)*$p2.+8+ \
> ($Y.=="/" + $Y.=="/|") ? (4*$p3.-(4*$p2.+$p5.)) : (\
> ($Y.=="\" + $Y.=="\!") ? -(4*$p3.-(4*$p2.+$p5.)) : (\
> ($Y.=="f" + $Y.=="|)") ? (6*$p2.-(2*$p3.+$p7.)) : (\
> ($Y.=="t" + $Y.=="!)") ? -(6*$p2.-(2*$p3.+$p7.)) : (\
> ($Y.=="^" + $Y.=="/|\") ? ($p3.+$p11.-(5*$p2.)) : (\
> ($Y.=="v" + $Y.=="\!/") ? -($p3.+$p11.-(5*$p2.)) : (\
> ...
> 0...))))))#
> > The trailing backslashes are intended as line-continuations.

I've experimented with naming conventions that have a direct alphanumeric equivalent for each character of the ASCII Sagittal notation. So for instance, Z represents '/' and T represents '|'. A few examples:

#define ZT #+(4*$p3.-(4*$p2.+$p5.))# ; /| / 81/80
#define CLZ #-(3*$p3.-($p2.+$p13.))# ; (!/ w 26/27
#define UD #-($p3.+$p7.-(2*$p2.+$p5.))# ; U) 20/21

But these abbreviations are one step further removed from the Sagittal symbols and end up being difficult to interpret. I think I prefer George's suggestion of using the comma/kleisma/diesis names. So for instance [$B(4)$d11Ld.] would represent an 11 L-diesis down from B, and you can get a pretty good idea of about what pitch that represents, but [$B(4)$CLD.] is harder to interpret, because you need to translate it mentally to B(!) before it makes any sense. On the other hand, the unmixed Sagittal notation is useful for intervals as simple as 6/5: a 6/5 above C is E!!/, which I could notate either as [$E(4)$UZ.] or [$E(4)$fl.$u5C.]. So I might want to keep a few of these short alphanumeric names around for convenience(especially for the ones smaller than an apotome).

> Another useful property of a scheme like this is that the macro that > expands the sagittal knows what nominal it is being applied to. This > opens up the possibility of using the "smart defaults" that George > mentioned. This property might also be obtained in some other way. > More about "smart defaults" later.

Wouldn't you need to know what key the music is in?

🔗Dave Seidel <dave@superluminal.com>

Herman Miller wrote:
> Unfortunately macros are fairly limited in Csound scores. Csound works
> entirely with numbers (no characters or strings), and macros can only
> use the arithmetic operators + - * / together with parentheses for
> grouping. There isn't even a unary minus, which really complicates
> things. (At least that's the case with the version of Csound that came
> with the Csound Book; it's possible that a newer version might have
> improved macro preprocessing.)

This is not completely accurate with the current "canonical" version (4.23). I use macros sometimes to paste in a block of orchestra or score code like using a template. The Csound preprocessor is limited but in basic philosophy is like the C language preprocessor: it just copies literal text unless it encounters a variable token (e.g., $foo.), at which time it replaces the token with whatever it's #define'd as. Not sure how recursive it is, though.

For example, I use:

#define IF_TRK(N) #
if (itrk == $N.) then
goto TRK$N.#

#define ELSEIF_TRK(N) #
elseif (itrk == $N.) then
goto TRK$N.#

#define ENDIF #endif#

#define SEND(N) #
ga$N. = ga$N.+asig
goto DONE#

so I can say:

$IF_TRK(1)
$ELSEIF_TRK(2)
$ELSEIF_TRK(3)
$ELSEIF_TRK(4)
$ENDIF.

TRK1: $SEND(1)
TRK2: $SEND(2)
TRK3: $SEND(3)
TRK4: $SEND(4)
DONE:

- Dave

---
Dave Seidel
[blog] http://superluminal.com/dave/weblog
[music] http://mysterybear.net

🔗Dave Keenan <d.keenan@bigpond.net.au>

--- In tuning@yahoogroups.com, Herman Miller <hmiller@I...> wrote:
> Dave Keenan wrote:
> > Another useful property of a scheme like this is that the macro
that
> > expands the sagittal knows what nominal it is being applied to.
This
> > opens up the possibility of using the "smart defaults" that
George
> > mentioned. This property might also be obtained in some other
way.
> > More about "smart defaults" later.
>
> Wouldn't you need to know what key the music is in?

If you had that information, you could certainly use it to
advantage. The horizontal index to the lookup table is intended to
be the distance in fifths of the nominal-plus-sharps-or-flats from
the (possibly local) 1/1 or tonic. But even without that
information, 1/1 can default to C and the smart defaults will still
be significantly better than always using the primary comma, unless
the key is very far from C on the chain of fifths.

If you can identify the roots of chords (as you can in Fractal Tune
Smithy's chord-progression player), then these can also be used as
local 1/1s for the purpose of sagittal smart defaults.

And we still intend to define higher resolution JI notations, that
use accent marks (like the "semantic radicals" of Chinese text) to
indicate which of several possibilities are intended, or to further
narrow the choices for a higher-resolution set of smart defaults.
These can be used if the software's educated guesses aren't good
enough, but obviously the learning curve is steeper for the user.

Another possibility is that the software could tell the user what
pitch (ratio or cents or ET degree etc.) it has interpreted the
nominal-plus-sagittal as, and if it isn't what they wanted then they
should have the option of explicitly entering the pitch _as_ a ratio
or cents or ET degree etc. I believe Robert Walker intends to do
something like this in Fractal Tune Smithy.

-- Dave Keenan