Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[N. Andrew Walsh]

sorry. You have to switch to the just-intonation-stub branch, which is
here:
https://github.com/openlilylib/snippets/tree/just-intonation-stub/notation-snippets

Cheers,

A

On Sun, Dec 13, 2015 at 10:13 AM,  wrote:

> On Sun, 13 Dec 2015, N. Andrew Walsh wrote:
> > Actually, coverting between the ratios and semitones has alread been
> done,
> > as there's a simple set of log and mround functions that do it. Have a
> look
> > in the OLL repository under notation-tools and you should find the .ily
>
> At what URL?  I'm looking in https://github.com/openlilylib/openlilylib
> and can't find a directory called "notation-tools" at all, nor this kind
> of code in the directories that do exist.
>
> --
> Matthew Skala
> msk...@ansuz.sooke.bc.ca People before principles.
> http://ansuz.sooke.bc.ca/
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[N. Andrew Walsh]

This is a whole other issue: that of placement. Yes, the way I use them is
within the staff, and this raises issues when dealing with chord. For one,
I align the accidentals vertically according to two rules:

1) the side with more factors is centered on the note, or (if they have the
same number)
2) the side with the higher prime factor is centered on the note

The accidental for the tonic is a special case, as it is vertically
symmetrical.

So, for example, the accidental for 6/5 (with the prime factors 3 and 5
respectively) would be aligned with the symbol for 5 next to the note, and
extend upwards. But the sign for 9/5 (3*3 / 5), since it has two signs on
top, would center those on the note, and extend downwards. I'm attaching a
photo from one of my scores to show what they look like in a chord (sorry
for the quality; also note it's a hand-drawn score). In the middle of the
image near the top you see a chord with circular noteheads. The ratios for
the notes in that chord are, from top down, 4/3, 1/1, 8/5, 7/6, 16/9, and
4/3. Note that 7/6 and 4/3 both have the horizontal line at the bottom
aligned to the same note; you have to notice the curved sign at the top of
the former to know that it's supposed to be anchored to the D above.
Accidentals are arranged with the sign for the top note closest to the
chord, then moving outwards from there.

Hope this clarifies a bit what I'm talking about.

Cheers,

A

On Sun, Dec 13, 2015 at 12:40 AM, Urs Liska  wrote:

>
>
> Am 12. Dezember 2015 16:38:13 MEZ, schrieb "N. Andrew Walsh" <
> n.andrew.wa...@gmail.com>:
> >Hi Paul,
> >
>
> ...
>
> >
> >The system works like this:
> >
> >1) each accidental has a long thin vertical line: approximately 1
> >staff-height,
>
> This triggers a question: *where* do you want the accidental to be
> printed, at the usual accidental position or above the staff? And: does it
> work properly with non-monophonic music?
>
> > though maybe slightly less or more depending on:
>
> Urs
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Graham Breed]

From: "N. Andrew Walsh"



Actually, coverting between the ratios and semitones has alread been done,
as there's a simple set of log and mround functions that do it. Have a look
in the OLL repository under notation-tools and you should find the .ily
files.


What's the OLL repository?


 Graham

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[mskala]

On Sun, 13 Dec 2015, N. Andrew Walsh wrote:
> Actually, coverting between the ratios and semitones has alread been done,
> as there's a simple set of log and mround functions that do it. Have a look
> in the OLL repository under notation-tools and you should find the .ily

At what URL?  I'm looking in https://github.com/openlilylib/openlilylib
and can't find a directory called "notation-tools" at all, nor this kind
of code in the directories that do exist.

-- 
Matthew Skala
msk...@ansuz.sooke.bc.ca People before principles.
http://ansuz.sooke.bc.ca/

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Graham Breed]

From: Urs Liska



>Maybe so, but the result is less portable because (if I understand
>correctly) you'd have to have a custom font and have it installed
>correctly, etc. for anyone to be able to use the glyph...  as opposed
>to just having the custom glyphs in an include file that you?re going
>to be including anyway.
>
>-Paul

I think the font idea*may*  be an approach worth considering.

Our stuff will reside in a library anyway, and I think it should be possible to 
have that library call a font reliably when it is in the same directory IIRC.


I can get fonts from the current directory no problem on Linux.  But 
there's a problem with Windows that I still haven't looked into. 
There's surely a way around it, though.



We could then have a font with glyphs for each constituent of your accidentals 
and construct the actual accidental as a markup using \combine, which should be 
pretty straightforward.


If the glyphs are pre-built, a font file is the obvious place to store 
them.  If they have to be combined, it's a bit harder because it has to 
be a text font, but this problem is also solved.  There's a problem with 
more recent Lilyponds where the accidentals can collide with barlines, 
but if you can pin it down and report it I'm sure that can be fixed.  I 
think the rules for combining symbols into glyphs can all be written 
into the font files but that may not be the easiest way to do it.


The nice thing about fonts, though, is that some already exist.  The 
problems with generating large lookup tables, or multiplying ratios, or 
factorizing this or that, can all be solved with the Extended 
Helmholtz-Ellis JI system, and when everything's working you can drop 
the new glyphs or start drawing them some other way.


It's nice that you think keeping the primes distinct is straightforward. 
 I thought it was difficult, especially if you want MIDI playback and 
transpositions to be correct, but not impossible.


A large lookup table, corresponding to a sensible equal temperament for 
wraparound, is probably the best way to get started.  The system is 
potentially infinite, but you can set limits on how far you expect 
modulation to go.  People keep being pessimistic about Lilypond or 
Scheme's performance with large tables but so far nobody's produced a 
huge table and demonstrated it to be unacceptably slow.



  Graham


___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Johan Vromans]

On Sun, 13 Dec 2015 15:55:08 +0100
"N. Andrew Walsh"  wrote:

> So I've kludged around with Inkscape, and I'm attaching a few .svg files
> to show what I'm getting at. These are *very ugly*, and I would want to
> spend a good bit of time working on proportion, weighting, etc..

Please, please, use a font editor like fontforge. It has all the tools
built in to deal with proportion, weighting, kerning, combining, and so on.
Learning how to use fontforge will pay back quickly.

If you want you can still export individual glyphs as svg.

-- Johan

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[N. Andrew Walsh]

See the previous message from me, which links to it and provides
instructions for its use.

Cheers,

A

On Sun, Dec 13, 2015 at 1:04 PM, Graham Breed  wrote:

> From: "N. Andrew Walsh"
>>
>
> Actually, coverting between the ratios and semitones has alread been done,
>> as there's a simple set of log and mround functions that do it. Have a
>> look
>> in the OLL repository under notation-tools and you should find the .ily
>> files.
>>
>
> What's the OLL repository?
>
>
>  Graham
>
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[N. Andrew Walsh]

So I've kludged around with Inkscape, and I'm attaching a few .svg files to
show what I'm getting at. These are *very ugly*, and I would want to spend
a good bit of time working on proportion, weighting, etc..

However, these are the components to build any accidental within a 7-limit
system: a vertical line, components for the primes 3, 5, and 7, and the
unique accidental for the tonic. The vertical is the file "000.svg", and
all the rest should be clear.

I don't know enough about making fonts to know how these would work as part
of a font file. They would need hinting for ordering and collision
avoidance, keeping in mind that there could potentially exits ratios
requiring many more of each of these modules (for example, 49/45 would have
two of the 007 on top, and two of 003 and one of 005 on the bottom. It
would thus probably need to expand vertically somewhat).

Anyway, now that I have some svg files, I suppose I can get to working with
fiddling with the scaling for Lily.

Cheers,

A

On Sun, Dec 13, 2015 at 2:04 PM, Graham Breed  wrote:

> From: Urs Liska
>>
>
> >Maybe so, but the result is less portable because (if I understand
>>> >correctly) you'd have to have a custom font and have it installed
>>> >correctly, etc. for anyone to be able to use the glyph...  as opposed
>>> >to just having the custom glyphs in an include file that you?re going
>>> >to be including anyway.
>>> >
>>> >-Paul
>>>
>> I think the font idea*may*  be an approach worth considering.
>>
>> Our stuff will reside in a library anyway, and I think it should be
>> possible to have that library call a font reliably when it is in the same
>> directory IIRC.
>>
>
> I can get fonts from the current directory no problem on Linux.  But
> there's a problem with Windows that I still haven't looked into. There's
> surely a way around it, though.
>
> We could then have a font with glyphs for each constituent of your
>> accidentals and construct the actual accidental as a markup using \combine,
>> which should be pretty straightforward.
>>
>
> If the glyphs are pre-built, a font file is the obvious place to store
> them.  If they have to be combined, it's a bit harder because it has to be
> a text font, but this problem is also solved.  There's a problem with more
> recent Lilyponds where the accidentals can collide with barlines, but if
> you can pin it down and report it I'm sure that can be fixed.  I think the
> rules for combining symbols into glyphs can all be written into the font
> files but that may not be the easiest way to do it.
>
> The nice thing about fonts, though, is that some already exist.  The
> problems with generating large lookup tables, or multiplying ratios, or
> factorizing this or that, can all be solved with the Extended
> Helmholtz-Ellis JI system, and when everything's working you can drop the
> new glyphs or start drawing them some other way.
>
> It's nice that you think keeping the primes distinct is straightforward.
> I thought it was difficult, especially if you want MIDI playback and
> transpositions to be correct, but not impossible.
>
> A large lookup table, corresponding to a sensible equal temperament for
> wraparound, is probably the best way to get started.  The system is
> potentially infinite, but you can set limits on how far you expect
> modulation to go.  People keep being pessimistic about Lilypond or Scheme's
> performance with large tables but so far nobody's produced a huge table and
> demonstrated it to be unacceptably slow.
>
>
>
>   Graham
>
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[N. Andrew Walsh]

Actually, coverting between the ratios and semitones has alread been done,
as there's a simple set of log and mround functions that do it. Have a look
in the OLL repository under notation-tools and you should find the .ily
files.

Cheers,

A

On Sun, Dec 13, 2015 at 7:51 AM,  wrote:

> On Sat, 12 Dec 2015, N. Andrew Walsh wrote:
> > accidentals as needed. I suppose, rather than having Lily/Scheme
> calculate
> > prime factors on the fly at runtime, it would be easier to have a lookup
> > table of the prime factorization for each integer up to a certain limit
> (but
> > that would end up being very high, so maybe not). That's a computational
> > problem for further down the road, though.
>
> For numbers of 32 bits or so, doing prime factorization by simple-minded
> trial and error on a present-day computer is cheaper than most people
> realize.  It's a tight loop that fits in cache; the arithmetic may
> actually be faster than a lookup table in main memory, and it's at least
> unlikely to be prohibitively slow.
>
> I think a trickier computational problem may be converting between
> LilyPond's "rational number of semitones" and just-intonation's "rational
> ratio of frequencies" ways to express pitch.  Because of the log function
> in between, in general any number that has a representation on one of
> those scales will have no exact representation on the other, and you're
> forced to do some kind of rounding, or maybe abandon LilyPond's pitch
> scheme for something else.  Have you decided how you want to deal with
> this issue yet?
>
> --
> Matthew Skala
> msk...@ansuz.sooke.bc.ca People before principles.
> http://ansuz.sooke.bc.ca/
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[mskala]

On Sat, 12 Dec 2015, N. Andrew Walsh wrote:
> accidentals as needed. I suppose, rather than having Lily/Scheme calculate
> prime factors on the fly at runtime, it would be easier to have a lookup
> table of the prime factorization for each integer up to a certain limit (but
> that would end up being very high, so maybe not). That's a computational
> problem for further down the road, though.

For numbers of 32 bits or so, doing prime factorization by simple-minded
trial and error on a present-day computer is cheaper than most people
realize.  It's a tight loop that fits in cache; the arithmetic may
actually be faster than a lookup table in main memory, and it's at least
unlikely to be prohibitively slow.

I think a trickier computational problem may be converting between
LilyPond's "rational number of semitones" and just-intonation's "rational
ratio of frequencies" ways to express pitch.  Because of the log function
in between, in general any number that has a representation on one of
those scales will have no exact representation on the other, and you're
forced to do some kind of rounding, or maybe abandon LilyPond's pitch
scheme for something else.  Have you decided how you want to deal with
this issue yet?

-- 
Matthew Skala
msk...@ansuz.sooke.bc.ca People before principles.
http://ansuz.sooke.bc.ca/

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[N. Andrew Walsh]

Hi Paul,

thanks for getting back to me. To update the list: I'm working on making a
set of stencils (using the various svg-to-path functions that Lily and the
snippets repository have), which will then be used by the just-intonation
toolset Urs is working on to build custom accidentals from individual
stencils on the fly.

The way that system would work is complicated, and based on fundamentally
different design principles than conventional accidentals (or any of the
usual variants used for music in just intonation, including Helmholtz, Ben
Johnson's set, or [I suspect] any others). I want to reiterate: I'm not
looking to be convinced of why some *other* system of accidentals is better
(for whatever metric one might use to measure "better"), but rather want to
see what's involved in getting the system I use to engrave properly within
Lily.

The system works like this:

1) each accidental has a long thin vertical line: approximately 1
staff-height, though maybe slightly less or more depending on:
2) any number of smaller stencils, each approximately as wide as a normal
accidental. Each of these corresponds to a prime number
3) the number and arrangement of those smaller stencils is determined by
the prime factorization of the numerator and denominator of the fraction
that makes up the harmonic ratio.

So, I suspect the thin vertical line needs no stencil, as it's easy enough
to draw on the fly. But the smaller stencils are more efficiently drawn as
stencils beforehand (rather than drawing a path each time), especially
since their placement depends on things like collision avoidance.

Paul says he can give me tips on drawing the stencils. I can fire up
Inkscape, but where do I start? How large should the shape be?

Thanks in advance for the help.

Cheers,

A

On Sat, Dec 12, 2015 at 3:27 PM, Paul Morris <p...@paulwmorris.com> wrote:

> Hi Andrew,
>
> Glad to share what I know about svg-to-path work.  Could we continue the
> discussion on the user list so that it’s public for others to benefit from,
> and/or chime in?  If that works for you, would you re-send your message
> below to the user list and I’ll reply there?
>
> Cheers,
> -Paul
>
>
> On Dec 11, 2015, at 8:57 AM, N. Andrew Walsh <n.andrew.wa...@gmail.com>
> wrote:
>
> Hi Paul,
>
> I've been doing some background work on my just-intonation accidentals,
> and I was hoping you could give me some advice on the svg-to-path
> translation. I know what the stencils should look like, but I'm not sure
> about things like scaling (how many units high or wide should a stencil
> have if it's equivalent, say, to the thick bars in a sharp sign?), and what
> the best procedure might be for drawing them. Could you give me some
> advice/help?
>
> I think this is going to be geared towards adding into the OLL repository
> as part of the "contemporary notation" extensions, so probably aimed at the
> dev branch. So I'll see about the make-path-stencil (are you sure it's that
> and not the "make-connected-path-stencil" I see in the LSR?).
>
> Cheers,
>
> A
>
>
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Paul Morris]

Hi Andrew,

> On Dec 12, 2015, at 10:38 AM, N. Andrew Walsh <n.andrew.wa...@gmail.com> 
> wrote:
> 
> I've been doing some background work on my just-intonation accidentals, and I 
> was hoping you could give me some advice on the svg-to-path translation. I 
> know what the stencils should look like, but I'm not sure about things like 
> scaling (how many units high or wide should a stencil have if it's 
> equivalent, say, to the thick bars in a sharp sign?), and what the best 
> procedure might be for drawing them. Could you give me some advice/help? 
> 
> I think this is going to be geared towards adding into the OLL repository as 
> part of the "contemporary notation" extensions, so probably aimed at the dev 
> branch. So I'll see about the make-path-stencil (are you sure it's that and 
> not the "make-connected-path-stencil" I see in the LSR?).


Here’s what I’d suggest for going from an svg to a path from my experience with 
doing this.  

You can create a simple .ly file with a few notes and accidentals, then render 
it to SVG and open that SVG in Inkscape.  Then use Inkscape to draw your 
accidentals (or parts of accidentals) so they look good next to the notes and 
standard accidentals.  Having the default notes, accidentals, staff, in the SVG 
will help you get it at approximately the right scale.  (Although this may not 
matter, you will probably have to change the scaling later anyway…  I can’t 
remember for sure.)

Cut and paste your shape into a separate Inkscape SVG file and export/save as a 
plain SVG.  I found that I had to horizontally flip the shape in Inkscape first 
because svgs from Inkscape apparently come out reversed for some reason.  So 
you may need to do that.

Open that SVG file in a text editor and find the path data.  It should look 
something like this (a custom whole note glyph I made):



Working with this is the tedious part…  You can take out the parts you don’t 
need.  Here’s the part you do need:

d="m 304.96006,540.93655 c 11.66747,0 16.5678,6.05308 16.5678,16.78715 
0,18.43458 -14.00096,28.9213 -32.43555,28.9213 -11.66747,0 -16.33444,-6.05308 
-16.33444,-16.78715 0,-18.43458 13.7676,-28.9213 32.20219,-28.9213 z m 
-66.27119,22.85423 c 0,10.03402 7.93387,17.50119 17.0345,22.40152 
12.60086,6.76713 27.06851,9.33397 41.30282,9.33397 14.23429,0 28.9353,-2.56684 
41.53616,-9.33397 9.10063,-4.90033 17.0345,-12.3675 17.0345,-22.40152 
0,-10.03402 -7.93387,-17.5012 -17.0345,-22.40153 -12.60086,-6.76713 
-27.30186,-9.33397 -41.53616,-9.33397 -14.23431,0 -28.70196,2.56684 
-41.30282,9.33397 -9.10063,4.90033 -17.0345,12.36751 -17.0345,22.40153 z"

You can manually reformat that so it is easier to read and then use something 
like
http://petercollingridge.appspot.com/svg_transforms 
<http://petercollingridge.appspot.com/svg_transforms>
to transform the path in various ways. 

For example the following is scaled using "scale(0.016, 0.016)" and converted 
to absolute coordinates.  It may help to look up "SVG path" on the web to get 
familiar with the commands C c M m z and the possible transformations, etc.



You might want to shift / translate it so it is snug to (0,0) with 
“translate(x, y)” where x and y are the inverse of the smallest X and Y values 
in the path.  (I did this, but it may not be necessary…)

Now you have a path that can be used by “make-path-stencil”.  It will look 
something like the following as embedded scheme in a LilyPond file:

#(define whole-note-outline
'(M 0 0
   C 0 0.16054432 0.12694192 0.28001904 0.272552 0.35842432
   C 0.47416576 0.4666984 0.70564816 0.50776784 0.93339712 0.50776784
   C 1.16114576 0.50776784 1.39636192 0.4666984 1.59797568 0.35842432
   C 1.74358576 0.28001904 1.87052768 0.16054432 1.87052768 0
   C 1.87052768 -0.16054432 1.74358576 -0.2800192 1.59797568 -0.35842448
   C 1.39636192 -0.46669856 1.16114592 -0.507768 0.93339712 -0.507768
   C 0.70564816 -0.507768 0.47416576 -0.46669856 0.272552 -0.35842448
   C 0.12694192 -0.2800192 0 -0.16054432 0 0
   z))

Then you can use it like so:

  (make-path-stencil whole-note-outline 0.0001 1 1 #t)

in the scheme code you’re using to override the accidental glyphs.  The 
arguments are:

(make-path-stencil 
path-data-list 
thickness-of-path-line
x-scale-factor 
y-scale-factor 
filled-or-not)

(Oh, and yes make-path-stencil is what I'd use if you’re targeting 2.19 or 
higher.  The make-connected-path-stencil procedure is similar but more limited. 
 make-path-stencil is not in the LSR yet...)

To get the scaling right is basically a trial and error dance.  Use the scale 
factor arguments to test until you’ve got it right, then go back and scale the 
path data itself with those values so it’s the correct size to start with.  
(You could go back to Inkscape and scale there if you prefer…)

…so you’ll need some scheme code for overriding the stand

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Johan Vromans]

> Anyway, that’s how I’ve done this kind of thing.  It’s not simple but it
> works!

If I understand the procedure correctly, wouldn't it be easier to use a
tool like fontforge add/adjust font glyphs?

-- Johan

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Urs Liska]

Am 12. Dezember 2015 16:38:13 MEZ, schrieb "N. Andrew Walsh" 
:
>Hi Paul,
>

...

>
>The system works like this:
>
>1) each accidental has a long thin vertical line: approximately 1
>staff-height,

This triggers a question: *where* do you want the accidental to be printed, at 
the usual accidental position or above the staff? And: does it work properly 
with non-monophonic music?

> though maybe slightly less or more depending on:

Urs

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Urs Liska]

Am 12. Dezember 2015 23:08:53 MEZ, schrieb Paul Morris :
>> On Dec 12, 2015, at 3:34 PM, Johan Vromans 
>wrote:
>> 
>> If I understand the procedure correctly, wouldn't it be easier to use
>a
>> tool like fontforge add/adjust font glyphs?
>
>Maybe so, but the result is less portable because (if I understand
>correctly) you'd have to have a custom font and have it installed
>correctly, etc. for anyone to be able to use the glyph...  as opposed
>to just having the custom glyphs in an include file that you’re going
>to be including anyway.  
>
>-Paul

I think the font idea *may* be an approach worth considering.

Our stuff will reside in a library anyway, and I think it should be possible to 
have that library call a font reliably when it is in the same directory IIRC.

We could then have a font with glyphs for each constituent of your accidentals 
and construct the actual accidental as a markup using \combine, which should be 
pretty straightforward.

Urs

>___
>lilypond-user mailing list
>lilypond-user@gnu.org
>https://lists.gnu.org/mailman/listinfo/lilypond-user

-- 
Diese Nachricht wurde von meinem Android-Mobiltelefon mit K-9 Mail gesendet.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[N. Andrew Walsh]

It would not, because the accidentals I use are in an open system of just
intonation (not a fixed scale) in which *any* conceivable ratio can be
represented (so long as I have the module for its respective prime
factors). This is a serious limitation of a lot of systems, in that the
moment you start getting into primes above, say, 17 (or even to certain
combinations of them), there are no accidentals to represent them, and
you're back to using numbers in markups.

My endgame here is to make stencils for each prime factor up to 512 (so,
2^10, thus ten octaves, of which there are about 100 primes [which seems
felicitous]), so that you can represent any conceivable fraction up to a
ridiculous complexity, on the fly, within Lily.

In that context, it makes much more sense (so far as I can tell) to make
individual stencils for each prime, and then arrange them for the
accidentals as needed. I suppose, rather than having Lily/Scheme calculate
prime factors on the fly at runtime, it would be easier to have a lookup
table of the prime factorization for each integer up to a certain limit
(but that would end up being very high, so maybe not). That's a
computational problem for further down the road, though.

For now, I'll get to fiddling with Inkscape and trying to make some
stencils, so I can at least show what I'm talking about.

Cheers,

A

On Sat, Dec 12, 2015 at 9:34 PM, Johan Vromans  wrote:

> > Anyway, that’s how I’ve done this kind of thing.  It’s not simple but it
> > works!
>
> If I understand the procedure correctly, wouldn't it be easier to use a
> tool like fontforge add/adjust font glyphs?
>
> -- Johan
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: converting svg glyph to path data for use in scheme (was: accidentals for just intonation)

[Paul Morris]

> On Dec 12, 2015, at 3:34 PM, Johan Vromans  wrote:
> 
> If I understand the procedure correctly, wouldn't it be easier to use a
> tool like fontforge add/adjust font glyphs?

Maybe so, but the result is less portable because (if I understand correctly) 
you'd have to have a custom font and have it installed correctly, etc. for 
anyone to be able to use the glyph...  as opposed to just having the custom 
glyphs in an include file that you’re going to be including anyway.  

-Paul
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[N. Andrew Walsh]

Thank you for the links. As I said above, I have significant objections to
a system of accidentals for just intonation that are based on cents
deviations from equal temperament. They're legitimate objections, and it's
outside of the scope of this thread to discuss them (I find, unfortunately,
that attachments to one system or another tend to be deeply personal, and
it's not my desire to provoke discussions that will invariably turn
unnecessarily … heated). The point of this project is that it should be
possible to specify a library file for each of these different systems,
that each might be able to extract different information from the scripting
that Urs is doing, and apply the accidentals correctly.

If your system requires only a range in cents to determine which accidental
to use, that should be easy to calculate and apply. If it requires only the
prime factors of the ratios, that should be easy, too. If it's some mixture
of them, that works as well. And for all of them, it should be possible to
output something different to different instrumental parts, as needed.

To answer ciconia's question as well: Partch used a tabulature notation
most of the time (ie, "strike this key, producing the ratio x/y"). It makes
it very practical to play his instruments (which are almost all
percussion), but extremely difficult to figure out how the music sounded
with access to them. Young wrote his scores (when he wrote them at all)
giving numbers for the primes. such that the scores are almost entirely
text. I'm not sure how he notated "The Well-Tuned Piano," or even if he
ever did, since it's on a pre-tuned piano and always improvised by him
personally.

Cheers,

A

On Wed, Dec 2, 2015 at 10:26 PM, Graham Breed <gbr...@gmail.com> wrote:

> From: "N. Andrew Walsh"<n.andrew.wa...@gmail.com>
>> To: lilypond-user<lilypond-user@gnu.org>
>>
>
> If you've been watching the OpenLilyLib repository, you'll see that Urs has
>> been working on a set of tools for rendering music in just intonation. He
>> (quite modestly) says that it isn't ready for production, but there are
>> already some impressive things it can do: for one, the interface allows to
>> input a fraction and get back a nearest-semitone pitch with a deviation in
>> cents*automatically*, which is something the commercial programs don't
>> offer in any way (every composer I know who works with JI just inputs text
>> entries manually for every note, with no change in, for example, MIDI
>> output for ability to handle transpositions).
>>
>
> I haven't been watching that ... I don't know what it is.  But it sounds
> similar to my Sagittal support.  Latest code here, works for me but
> something broken on Windows:
>
> https://bitbucket.org/x31eq/microlily
>
> It's possible to turn off the Sagittal accidentals to get output using
> standard accidentals, given essentially the AFMM output.  I don't remember
> if I ever got that working though.  You have to specify the staff position
> as well as the ratio.
>
> I'd like to be able to put these into Lily, and Urs tells me it can be done
>> by calling a draw function to draw a path. I can relatively easily make up
>> some paths with Inkscape and save them as SVGs, but is there a better way
>> to do this? The NR describes (here:
>>
>> http://lilypond.org/doc/v2.19/Documentation/notation/formatting-text#graphic-notation-inside-markup
>> )
>> the means to include eps files into a markup, which presumably could be
>> used to replace the accidental.
>>
>> There are some potential complicating factors here. First, the accidentals
>> I use change depending on the prime factorization of the ratio involved:
>> for example, the ratio 9/8 (a type of whole tone) would comprise two of
>> the
>> symbol for 3 (because "9/8" is really "(3*3)/8" ), which means that Urs'
>> interface for JI ratios would need an add-on to do prime factorization of
>> the ratios (which is also computationally intensive, even for relatively
>> simple numbers) or a means to encode ratios as lists of primes that are
>> then calculated to return the value in cents (that is, do the process in
>> reverse, starting from "(3*3)/8" and getting 9/8, which might be easier to
>> do).
>>
>
> I've thought about this with respect to the Extended Helmholtz-JI
> notation, for which there are already fonts that would work with my
> system.  Generating accidentals from pitches is problematic, and would
> really mean generating your gamut in advance, with some implied equal
> temperament that doesn't give any ambiguity, and the accidentals would
> disappear if you exceed that gamut.
>
> Another idea is for commands to add the accidental gl

Re: accidentals for just intonation

[Urs Liska]

Am 03.12.2015 um 13:11 schrieb N. Andrew Walsh:
> The point of this project is that it should be possible to specify a
> library file for each of these different systems, that each might be
> able to extract different information from the scripting that Urs is
> doing, and apply the accidentals correctly. 
>

Yes, the idea is to tell LilyPond: This pitch is a 13/11 ratio over d,
and then choose an appropriate display mode through simply configuration
switches. This should *not* be exclusive for one mode of display but a
rather modular approach where one can easily add other systems.
For (a contrived) example: If someone had the idea asking someone with a
19th-tone trumpet (dividing the octave in 19 equal steps) to play a
piece that is conceived as ratios LilyPond should be able to determine
the proper "step" in that system and write the remaining cent deviation
next to it. This invented composer should take the trouble adding the
necessary calculations for the specific system, but our LilyPond library
should (then) already provide the necessary building blocks to make that
as easy as possible.

Urs



___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Urs Liska]

Am 01.12.2015 um 15:56 schrieb Paul Morris:
>> On Dec 1, 2015, at 5:38 AM, Urs Liska  wrote:
>>
>> You have a rather small number of individual components (vertical,
>> horizontal and diagonal elements) that can all represented by a
>> postscript path. A function should be able to determine from the input
>> ratio which of these elements have to be combined and then generate the
>> appropriate path and eventually use that to replace Accidental.stencil.
> Yep, sounds like a matter of creating path stencils for each component part, 
> as static unchanging building blocks, and then have a function that 
> dynamically combines these stencils to produce the accidental needed for a 
> given note.  Combining stencils in different ways is simpler than producing a 
> path on the fly, so that will make things easier.

This is definitely better than creating the full path from scratch.

>
> I have done this kind of thing by creating an SVG with Inkscape and then 
> opening the SVG file in a text editor where I can copy the path coordinates.  
> Then I can paste those coordinates into a LilyPond include file, in a 
> procedure that produces a path stencil.  (With some tedious back and forth to 
> get the scaling right.)  Then that stencil is available to use by LilyPond.  
>
> For Clairnote music notation I have code that replaces accidental signs with 
> custom accidentals[0] that might be helpful to look at.  It combines a dot 
> stencil with a line stencil, so no paths are needed.  However, I also use 
> path coordinates to create whole note glyphs, so there’s an example of that 
> as well.  That code is available here:
>
> http://clairnote.org/software/
>
> [0] http://clairnote.org/accidental-signs/
>
>> How these paths can be created is something I won't be of much help, but
>> if you get to the point where you have very concrete necessities you'll
>> surely be able to get help by others with more experience in that.
> There are several ways to create a stencil from a path.  Search the LSR for 
> “path” for two different ways in addition to the \path markup command.  The 
> most recent development version of LilyPond (2.19.x) also has a 
> make-path-stencil function that combines the benefits of the two ways 
> documented on the LSR without their drawbacks, so I prefer to use that unless 
> I’m supporting LilyPond 2.18. 

This was what I vaguely recalled. Andrew should definitely look into
that as we have already decided not to support 2.18 for the whole
contemporary notation library idea. There are just too many substantial
improvements in 2.19, and the target group (advanced and daring
composers) can be expected to install and use the development version.

Urs


>
> -Paul
>


___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Graham Breed]

On 03/12/15 12:11, N. Andrew Walsh wrote:


If your system requires only a range in cents to determine which accidental
to use, that should be easy to calculate and apply. If it requires only the
prime factors of the ratios, that should be easy, too. If it's some mixture
of them, that works as well. And for all of them, it should be possible to
output something different to different instrumental parts, as needed.


Prime factorization to control the accidentals wasn't easy when I looked 
at it.  The only information available when the accidental was chosen is 
the pitch-difference, so that's what I used.  There are ways 
communicating, though, like choosing different accidental sets according 
to the factors or building the accidental string recursively.  Maybe 
it's easier with new versions of Lilypond and improved documentation.  I 
did this a while ago and learned the internals as I went along.  I 
welcome assistance from more experienced Lilypond-Schemers, and if it's 
going to be re-implemented from scratch, at least my code's there as an 
example of what can work.



Graham




___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[ciconia]

> Harry Partch writes music that tops out at the 13th overtone, but La Monte
Young has pieces with primes in the upper 300s.

How does Partch notate his music? If I remember correctly he does put ratios
over his notes, but I'm not sure how it works. As for La Monte Young - I
don't think any of his music that *is* notated uses any form of conventional
notation. Please correct me if I'm wrong.

Sharon



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/accidentals-for-just-intonation-tp184322p184393.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Graham Breed]

From: "N. Andrew Walsh"
To: lilypond-user



If you've been watching the OpenLilyLib repository, you'll see that Urs has
been working on a set of tools for rendering music in just intonation. He
(quite modestly) says that it isn't ready for production, but there are
already some impressive things it can do: for one, the interface allows to
input a fraction and get back a nearest-semitone pitch with a deviation in
cents*automatically*, which is something the commercial programs don't
offer in any way (every composer I know who works with JI just inputs text
entries manually for every note, with no change in, for example, MIDI
output for ability to handle transpositions).


I haven't been watching that ... I don't know what it is.  But it sounds 
similar to my Sagittal support.  Latest code here, works for me but 
something broken on Windows:


https://bitbucket.org/x31eq/microlily

It's possible to turn off the Sagittal accidentals to get output using 
standard accidentals, given essentially the AFMM output.  I don't 
remember if I ever got that working though.  You have to specify the 
staff position as well as the ratio.



I'd like to be able to put these into Lily, and Urs tells me it can be done
by calling a draw function to draw a path. I can relatively easily make up
some paths with Inkscape and save them as SVGs, but is there a better way
to do this? The NR describes (here:
http://lilypond.org/doc/v2.19/Documentation/notation/formatting-text#graphic-notation-inside-markup)
the means to include eps files into a markup, which presumably could be
used to replace the accidental.

There are some potential complicating factors here. First, the accidentals
I use change depending on the prime factorization of the ratio involved:
for example, the ratio 9/8 (a type of whole tone) would comprise two of the
symbol for 3 (because "9/8" is really "(3*3)/8" ), which means that Urs'
interface for JI ratios would need an add-on to do prime factorization of
the ratios (which is also computationally intensive, even for relatively
simple numbers) or a means to encode ratios as lists of primes that are
then calculated to return the value in cents (that is, do the process in
reverse, starting from "(3*3)/8" and getting 9/8, which might be easier to
do).


I've thought about this with respect to the Extended Helmholtz-JI 
notation, for which there are already fonts that would work with my 
system.  Generating accidentals from pitches is problematic, and would 
really mean generating your gamut in advance, with some implied equal 
temperament that doesn't give any ambiguity, and the accidentals would 
disappear if you exceed that gamut.


Another idea is for commands to add the accidental glyphs, and also do 
the correct pitch shift.  I think this was prototyped without the pitch 
shifting (so ignoring MIDI output) before I implemented my Sagittal 
approach.  Where it's problematic to get tuning and display working 
together, you can define separate functions for the "midi" and "score" 
blocks.


Another idea I had, though, is to shove annotations into the list 
describing each note.  (I think the new parser makes this easier than it 
used to be, because each note in a chord is a list.)  You can then run a 
function over the whole music block to strip out the annotations, set 
the pitch, and override the accidental.  You can also apply different 
functions to the same music block in the midi and score blocks to make 
that approach easier.  I did a proof of concept of this, which I can't 
find now, but I haven't followed it up.



The advantage here, though, would be this: one of the interesting things
about just intonation is that there is no theoretical limit to what kinds
of ratios you use. You could theoretically have unique signs for all the
primes you want, and then the draw function could build them on the fly.
The accidentals become modular, scaling to whatever level of complexity the
composer wants. Harry Partch writes music that tops out at the 13th
overtone, but La Monte Young has pieces with primes in the upper 300s.


You can also make a font with a fixed level of complexity, and it will 
be easier to get working for now.  An issue with drawing the glyphs in 
is that you have to be sure to inform LilyPond of the correct amount of 
space to allow for them.


You could also look at the Extended Helmholtz-Ellis JI set, where the 
advantage is that the font already exists.  It's on this page, along 
with some PDFs explaining it:


http://www.marcsabat.com/


So, List: this is, as I said, a somewhat long-term project, but would any
of you be willing to help me learn/do the programming necessary to develop
a system like this? I also have in mind a more general add-on to the OLL
just-intonation library: I'd like to see a set of different .ily files,
each with different sets of accidentals, which a composer could \include
into the score as needed. For example, I could 

accidentals for just intonation

[N. Andrew Walsh]

Hi List,

this is a somewhat specialist request, and more of a long-term project, but
I'm hoping you nice people can help me with something I'd like to do with
Lily someday.

If you've been watching the OpenLilyLib repository, you'll see that Urs has
been working on a set of tools for rendering music in just intonation. He
(quite modestly) says that it isn't ready for production, but there are
already some impressive things it can do: for one, the interface allows to
input a fraction and get back a nearest-semitone pitch with a deviation in
cents *automatically*, which is something the commercial programs don't
offer in any way (every composer I know who works with JI just inputs text
entries manually for every note, with no change in, for example, MIDI
output for ability to handle transpositions).

There's something I'd very much like to do with this, largely out of my own
(admittedly rather opinionated) view on the best means of producing
accidentals for just intonation. I'm going to assume some familiarity with
just intonation concepts, but (in short) it works like this: the
relationship between two pitches is defined in terms of the frequency
relationship, given usually as a fraction. For example, the interval of a
perfect fifth may be rendered as 3/2: that is, if I play notes with base
frequencies of 200 and 300Hz, we hear them as a (very purely tuned) fifth.
The equal-tempered one you have on a piano (ie, 7 semitones) is about two
1/100th of a semitone (called "cents" logically enough) too narrow to be
pure (ie, a 3/2 fifth is about 702 cents).

Here's my thing: I believe that the most appropriate type of accidental for
such a system is one that reflects the harmonic ratio, not the number of
steps on a scale. Flats and sharps tell us whether a pitch is lowered or
raised from its "natural" position in the scale, and just intonation
doesn't have those positions. So, I designed accidentals that graphically
reflect the harmonic ratio between a note and the tonic.

I'd like to be able to put these into Lily, and Urs tells me it can be done
by calling a draw function to draw a path. I can relatively easily make up
some paths with Inkscape and save them as SVGs, but is there a better way
to do this? The NR describes (here:
http://lilypond.org/doc/v2.19/Documentation/notation/formatting-text#graphic-notation-inside-markup)
the means to include eps files into a markup, which presumably could be
used to replace the accidental.

There are some potential complicating factors here. First, the accidentals
I use change depending on the prime factorization of the ratio involved:
for example, the ratio 9/8 (a type of whole tone) would comprise two of the
symbol for 3 (because "9/8" is really "(3*3)/8" ), which means that Urs'
interface for JI ratios would need an add-on to do prime factorization of
the ratios (which is also computationally intensive, even for relatively
simple numbers) or a means to encode ratios as lists of primes that are
then calculated to return the value in cents (that is, do the process in
reverse, starting from "(3*3)/8" and getting 9/8, which might be easier to
do).

The advantage here, though, would be this: one of the interesting things
about just intonation is that there is no theoretical limit to what kinds
of ratios you use. You could theoretically have unique signs for all the
primes you want, and then the draw function could build them on the fly.
The accidentals become modular, scaling to whatever level of complexity the
composer wants. Harry Partch writes music that tops out at the 13th
overtone, but La Monte Young has pieces with primes in the upper 300s.

So, List: this is, as I said, a somewhat long-term project, but would any
of you be willing to help me learn/do the programming necessary to develop
a system like this? I also have in mind a more general add-on to the OLL
just-intonation library: I'd like to see a set of different .ily files,
each with different sets of accidentals, which a composer could \include
into the score as needed. For example, I could write the ratios using my
system, or use a system that shows accidentals approximated to the nearest
12th-tone, with cents deviation for more exact tuning (which might be of
more relevance to keyed instruments).

I can send a few hand-drawn mock-ups of the accidentals to show what I
mean; I've been doing them by hand, but I'd really like to see them
engraved.

Thanks for the help.

Cheers,

A
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Urs Liska]

Am 01.12.2015 um 10:10 schrieb N. Andrew Walsh:
> Hi List,
>
> this is a somewhat specialist request, and more of a long-term
> project, but I'm hoping you nice people can help me with something I'd
> like to do with Lily someday.
>
> If you've been watching the OpenLilyLib repository, you'll see that
> Urs has been working on a set of tools for rendering music in just
> intonation. He (quite modestly) says that it isn't ready for production,

Well, it isn't ...

> but there are already some impressive things it can do: for one, the
> interface allows to input a fraction and get back a nearest-semitone
> pitch with a deviation in cents *automatically*, which is something
> the commercial programs don't offer in any way (every composer I know
> who works with JI just inputs text entries manually for every note,
> with no change in, for example, MIDI output for ability to handle
> transpositions). 
>

Yes, I also find this exciting prospects, and I don't expect the
limitations there are so far to be really problematic. But basically you
can now use the functionality to produce individual notes, in a
monophonic context.
Probably it will be more clear once the second and third part of my
latest blog post are out.

> There's something I'd very much like to do with this, largely out of
> my own (admittedly rather opinionated) view on the best means of
> producing accidentals for just intonation. I'm going to assume some
> familiarity with just intonation concepts, but (in short) it works
> like this: the relationship between two pitches is defined in terms of
> the frequency relationship, given usually as a fraction. For example,
> the interval of a perfect fifth may be rendered as 3/2: that is, if I
> play notes with base frequencies of 200 and 300Hz, we hear them as a
> (very purely tuned) fifth. The equal-tempered one you have on a piano
> (ie, 7 semitones) is about two 1/100th of a semitone (called "cents"
> logically enough) too narrow to be pure (ie, a 3/2 fifth is about 702
> cents). 
>
> Here's my thing: I believe that the most appropriate type of
> accidental for such a system is one that reflects the harmonic ratio,
> not the number of steps on a scale. Flats and sharps tell us whether a
> pitch is lowered or raised from its "natural" position in the scale,
> and just intonation doesn't have those positions. So, I designed
> accidentals that graphically reflect the harmonic ratio between a note
> and the tonic. 
>
> I'd like to be able to put these into Lily, and Urs tells me it can be
> done by calling a draw function to draw a path. I can relatively
> easily make up some paths with Inkscape and save them as SVGs, but is
> there a better way to do this? The NR describes
> (here: 
> http://lilypond.org/doc/v2.19/Documentation/notation/formatting-text#graphic-notation-inside-markup)
> the means to include eps files into a markup, which presumably could
> be used to replace the accidental.

That's not exactly what I meant. I was rather thinking of the \path
command on http://lilypond.org/doc/v2.19/Documentation/notation/graphic
and have LilyPond *generate* the paths on-the-fly. This will make the
modularity of your accidentals pretty straightforward to achieve.

But I don't have significant experience with paths (although I'd be very
interested in learning), others have done more on the topic, and I think
there are quite some helper tools and functionality already availabe
that I can't point you to.

>
> There are some potential complicating factors here. First, the
> accidentals I use change depending on the prime factorization of the
> ratio involved: for example, the ratio 9/8 (a type of whole tone)
> would comprise two of the symbol for 3 (because "9/8" is really
> "(3*3)/8" ), which means that Urs' interface for JI ratios would need
> an add-on to do prime factorization of the ratios (which is also
> computationally intensive, even for relatively simple numbers) or a
> means to encode ratios as lists of primes that are then calculated to
> return the value in cents (that is, do the process in reverse,
> starting from "(3*3)/8" and getting 9/8, which might be easier to do).
>
> The advantage here, though, would be this: one of the interesting
> things about just intonation is that there is no theoretical limit to
> what kinds of ratios you use. You could theoretically have unique
> signs for all the primes you want, and then the draw function could
> build them on the fly. The accidentals become modular, scaling to
> whatever level of complexity the composer wants. Harry Partch writes
> music that tops out at the 13th overtone, but La Monte Young has
> pieces with primes in the upper 300s. 
>
> So, List: this is, as I said, a somewhat long-term p

Re: accidentals for just intonation

[Phil Holmes]

I have quite an interest in intonation, and my degree dissertation was based on 
the study of musician's reaction to just and equal tempered music, and was 
created using LilyPond.  However, I'm not clear why you believe that 
accidentals in non-equal temperaments require different signs (I think that's 
what you're proposing here).  It's said that early music was based on one or 
other form of just temperament, and used normal accidental signs.  To me, they 
indicate that the music is altered to the next higher or lower semitone in the 
key and temperament being employed: so why are other signs needed?

The only extra indication that I would use would be rather like a tempo sign, 
but instead a temperament sign: "Quarter comma meantone" at the top, for 
example.

--
Phil Holmes


  - Original Message - 
  From: N. Andrew Walsh 
  To: lilypond-user 
  Sent: Tuesday, December 01, 2015 9:10 AM
  Subject: accidentals for just intonation


  Hi List,


  this is a somewhat specialist request, and more of a long-term project, but 
I'm hoping you nice people can help me with something I'd like to do with Lily 
someday.


  If you've been watching the OpenLilyLib repository, you'll see that Urs has 
been working on a set of tools for rendering music in just intonation. He 
(quite modestly) says that it isn't ready for production, but there are already 
some impressive things it can do: for one, the interface allows to input a 
fraction and get back a nearest-semitone pitch with a deviation in cents 
*automatically*, which is something the commercial programs don't offer in any 
way (every composer I know who works with JI just inputs text entries manually 
for every note, with no change in, for example, MIDI output for ability to 
handle transpositions). 


  There's something I'd very much like to do with this, largely out of my own 
(admittedly rather opinionated) view on the best means of producing accidentals 
for just intonation. I'm going to assume some familiarity with just intonation 
concepts, but (in short) it works like this: the relationship between two 
pitches is defined in terms of the frequency relationship, given usually as a 
fraction. For example, the interval of a perfect fifth may be rendered as 3/2: 
that is, if I play notes with base frequencies of 200 and 300Hz, we hear them 
as a (very purely tuned) fifth. The equal-tempered one you have on a piano (ie, 
7 semitones) is about two 1/100th of a semitone (called "cents" logically 
enough) too narrow to be pure (ie, a 3/2 fifth is about 702 cents). 


  Here's my thing: I believe that the most appropriate type of accidental for 
such a system is one that reflects the harmonic ratio, not the number of steps 
on a scale. Flats and sharps tell us whether a pitch is lowered or raised from 
its "natural" position in the scale, and just intonation doesn't have those 
positions. So, I designed accidentals that graphically reflect the harmonic 
ratio between a note and the tonic. 


  I'd like to be able to put these into Lily, and Urs tells me it can be done 
by calling a draw function to draw a path. I can relatively easily make up some 
paths with Inkscape and save them as SVGs, but is there a better way to do 
this? The NR describes (here: 
http://lilypond.org/doc/v2.19/Documentation/notation/formatting-text#graphic-notation-inside-markup)
 the means to include eps files into a markup, which presumably could be used 
to replace the accidental.


  There are some potential complicating factors here. First, the accidentals I 
use change depending on the prime factorization of the ratio involved: for 
example, the ratio 9/8 (a type of whole tone) would comprise two of the symbol 
for 3 (because "9/8" is really "(3*3)/8" ), which means that Urs' interface for 
JI ratios would need an add-on to do prime factorization of the ratios (which 
is also computationally intensive, even for relatively simple numbers) or a 
means to encode ratios as lists of primes that are then calculated to return 
the value in cents (that is, do the process in reverse, starting from "(3*3)/8" 
and getting 9/8, which might be easier to do).


  The advantage here, though, would be this: one of the interesting things 
about just intonation is that there is no theoretical limit to what kinds of 
ratios you use. You could theoretically have unique signs for all the primes 
you want, and then the draw function could build them on the fly. The 
accidentals become modular, scaling to whatever level of complexity the 
composer wants. Harry Partch writes music that tops out at the 13th overtone, 
but La Monte Young has pieces with primes in the upper 300s. 


  So, List: this is, as I said, a somewhat long-term project, but would any of 
you be willing to help me learn/do the programming necessary to develop a 
system like this? I also have in mind a more general add-on to the OLL 
just-intonation library: I'd lik

Re: accidentals for just intonation

[N. Andrew Walsh]

Right then. Let me include a few files to show what I mean.

The basic principle is this: the fraction that makes up a ratio in just
intonation can be broken down to its prime factors, as I said in the
previous message. In just intonation, this is what matters for determining
harmonic relationships. So, the accidentals are graphic representations of
these primes. The basic concept of an accidental is a thin vertical line,
with different parts attached to it: say, a one-quarter-sharp sign is
usually a single vertical line, with two thick angled lines; the others
follow similar principles (see here:
http://www.rpmseattle.com/of_note/wp-content/uploads/2012/06/03_QT_Symbols.png).
So I want to preserve that basic "thin vertical line with stuff attached"
design principle in my own set. For brevity, let's call that thin vertical
line the scaffold, and everything attached to it a "module."

Second, I want the simplest ratios to have the simplest visual design. This
makes them visually uncluttered. Third, they should (roughly) resemble
corresponding relationships with which we are already familiar.

So, the relationship "3" attaches a single thick horizontal line to the
"scaffold", since ascending by pure fifth (remember, a perfect fifth in
just intonation is a 3/2 relationship) usually results in sharps (thus a
rough visual similarity to the basic idea of what a sharp sign looks like).
Each additional upward fifth adds another horizontal line. It is also
possible to go downward by fifth, but here's the difference relative to
normal accidentals: a downward leap uses the same symbol, flipped
vertically and placed at the bottom of the "scaffold." See the attached
files for 3/2 and 9/8. The next prime is 5, and gets the next simplest
symbol: also a thick line, but now angled. See the attached file for 5/4.
You can combine both in various ways: the ratio 6/5 (a minor third) is the
symbol for 3 over the (flipped) symbol for 5; the ratio 15/8 is really
(5*3)/8, so both 5 and 3 appear at the top.

I'm not going to include any more files, but you get the idea. These are
really low-grade scans of stuff I did by hand; obviously a path I draw in
Inkscape or whatever would be much cleaner.

So, the just-intonation accidental engraver would be able to break down the
ratio given for a pitch into its prime factors (or expect that they are
already thus formatted), and then place the paths on the accidental in the
correct positions, and then typeset the resultant accidental into music
notation in place of regular accidentals.

I hope that clarifies a bit what I'm going after. Thanks again for the help.

Cheers,

A

On Tue, Dec 1, 2015 at 10:20 AM, Urs Liska <u...@openlilylib.org> wrote:

>
>
> Am 01.12.2015 um 10:10 schrieb N. Andrew Walsh:
>
> Hi List,
>
> this is a somewhat specialist request, and more of a long-term project,
> but I'm hoping you nice people can help me with something I'd like to do
> with Lily someday.
>
> If you've been watching the OpenLilyLib repository, you'll see that Urs
> has been working on a set of tools for rendering music in just intonation.
> He (quite modestly) says that it isn't ready for production,
>
>
> Well, it isn't ...
>
> but there are already some impressive things it can do: for one, the
> interface allows to input a fraction and get back a nearest-semitone pitch
> with a deviation in cents *automatically*, which is something the
> commercial programs don't offer in any way (every composer I know who works
> with JI just inputs text entries manually for every note, with no change
> in, for example, MIDI output for ability to handle transpositions).
>
>
> Yes, I also find this exciting prospects, and I don't expect the
> limitations there are so far to be really problematic. But basically you
> can now use the functionality to produce individual notes, in a monophonic
> context.
> Probably it will be more clear once the second and third part of my latest
> blog post are out.
>
> There's something I'd very much like to do with this, largely out of my
> own (admittedly rather opinionated) view on the best means of producing
> accidentals for just intonation. I'm going to assume some familiarity with
> just intonation concepts, but (in short) it works like this: the
> relationship between two pitches is defined in terms of the frequency
> relationship, given usually as a fraction. For example, the interval of a
> perfect fifth may be rendered as 3/2: that is, if I play notes with base
> frequencies of 200 and 300Hz, we hear them as a (very purely tuned) fifth.
> The equal-tempered one you have on a piano (ie, 7 semitones) is about two
> 1/100th of a semitone (called "cents" logically enough) too narrow to be
> pure (ie, a 3/2 fifth is about 702 cents).
>
> Here's my thing: I believe that the mo

Re: accidentals for just intonation

[Urs Liska]

Am 01.12.2015 um 10:45 schrieb Phil Holmes:
> I have quite an interest in intonation, and my degree dissertation was
> based on the study of musician's reaction to just and equal tempered
> music, and was created using LilyPond.  However, I'm not clear why you
> believe that accidentals in non-equal temperaments require different
> signs (I think that's what you're proposing here).

This is because Andrew is not talking about music that uses a scale of
notes that just deviates from the well-tempered scale through a tuning
system. Instead he's (and of course a number of composers) conceiving
pitches as ratios over fundamental frequencies. So you may have two
consecutive notes that are very similar in frequency but stem from
completely different contexts: for example a 5/1 ratio (major third
flageolet) over b, resulting in a pitch that is 14 cent below d',
followed by a pitch that is 2 cent above d' because it is the 3/1 ratio
over g.

You can notate that as

d' -\markup "(-14)" d' -\markup "(-2)"

but what Andrew suggests (and does himself by hand so far IIUC) is a
notation that indicates the same as (pseudo-code):

b,{5:1] g{3:1}

Depending on the instrument that will create those pitches different
notations may be appropriate. I clarinetist who is bending will prefer
the indication of the cent detuning, while when I have to play them as
piano flageolets I don't really care about that and have to know the key
to press (fundamental note) and the ratio or node of the string - the
resulting pitch with its cent deviation will only be there as a courtesy.

>   It's said that early music was based on one or other form of just
> temperament, and used normal accidental signs.  To me, they indicate
> that the music is altered to the next higher or lower semitone in the
> key and temperament being employed: so why are other signs needed?

I don't know how Andrew "thinks" as a composer, but music in just
intonation (in it's modern conception) is a very different thing from
ancient music in different tunings.

Urs

>  
> The only extra indication that I would use would be rather like a
> tempo sign, but instead a temperament sign: "Quarter comma meantone"
> at the top, for example.
>
> --
> Phil Holmes
>  
>  
>
> - Original Message -
> *From:* N. Andrew Walsh <mailto:n.andrew.wa...@gmail.com>
> *To:* lilypond-user <mailto:lilypond-user@gnu.org>
> *Sent:* Tuesday, December 01, 2015 9:10 AM
> *Subject:* accidentals for just intonation
>
> Hi List,
>
> this is a somewhat specialist request, and more of a long-term
> project, but I'm hoping you nice people can help me with something
> I'd like to do with Lily someday.
>
> If you've been watching the OpenLilyLib repository, you'll see
> that Urs has been working on a set of tools for rendering music in
> just intonation. He (quite modestly) says that it isn't ready for
> production, but there are already some impressive things it can
> do: for one, the interface allows to input a fraction and get back
> a nearest-semitone pitch with a deviation in cents
> *automatically*, which is something the commercial programs don't
> offer in any way (every composer I know who works with JI just
> inputs text entries manually for every note, with no change in,
> for example, MIDI output for ability to handle transpositions). 
>
> There's something I'd very much like to do with this, largely out
> of my own (admittedly rather opinionated) view on the best means
> of producing accidentals for just intonation. I'm going to assume
> some familiarity with just intonation concepts, but (in short) it
> works like this: the relationship between two pitches is defined
> in terms of the frequency relationship, given usually as a
> fraction. For example, the interval of a perfect fifth may be
> rendered as 3/2: that is, if I play notes with base frequencies of
> 200 and 300Hz, we hear them as a (very purely tuned) fifth. The
> equal-tempered one you have on a piano (ie, 7 semitones) is about
> two 1/100th of a semitone (called "cents" logically enough) too
> narrow to be pure (ie, a 3/2 fifth is about 702 cents). 
>
> Here's my thing: I believe that the most appropriate type of
> accidental for such a system is one that reflects the harmonic
> ratio, not the number of steps on a scale. Flats and sharps tell
> us whether a pitch is lowered or raised from its "natural"
> position in the scale, and just intonation doesn't have those
> positions. So, I designed accidentals that graphically reflect the
> harmonic ratio between a note and the tonic. 
>
> I'd like to be able

Re: accidentals for just intonation

[N. Andrew Walsh]

Well, this is a much longer and different discussion, but in short: I don't
intend these for non-equal temperaments, but rather music in an open system
of justly-tuned ratios. So, for example, you might certainly wish to define
your basic scale that way (a major scale thus being 1/1, 9/8, 5/4, 4/3,
3/2, 5/3, 15/8, 2/1), but you could also go *much* further up the harmonic
series. How would you describe an 11th? A 13th? Those are primes that have
no representation in music of the common practice, and a ratio like 13/9 is
on the relatively low end of what's possible (like I said, La Monte Young
uses primes up to the low 300s, I think).

I don't like using symbols from tempered music because they are visually
and semiotically confusing: after a while, you have so many very similar
looking signs that telling them apart becomes difficult (is the sign for a
13th a sharp sign with an arrow, or with a minus?). If you're using a
system with 50 or 60 different pitches to the octave, it very quickly gets
difficult to tell the signs apart. They also don't convey the information
that is actually important to just intonation: the harmonic ratio.

Obviously, this is also very much a matter of taste. I tend to think in
terms of wanting to convey the essential information of the musical
material, and nothing more. Efficiency of visual information comes at the
cost of it being based on different principles, and thus being rather
unfamiliar, relative to the usual systems. You could very certainly use
modified quartertone accidentals for extended meantone temperaments (such
as the 24-pitch meantone temperament Johannes Keller is playing in here:
https://www.youtube.com/channel/UCFG2Y__ODlxuIwcdzMM5zrQ), and that might
even be the appropriate system to use. But for an open system of just
intonation, I feel that those accidentals convey too much of the wrong
information, and not enough of the important information.

But that's a bit of a different discussion, as I said. There are probably
more different systems for notating music in non-standard tunings than
there are composers using them, and I certainly don't expect everybody to
use *this* system (though it'd be nice to see it get more use).

Hope that makes sense.

A

On Tue, Dec 1, 2015 at 10:45 AM, Phil Holmes <m...@philholmes.net> wrote:

> I have quite an interest in intonation, and my degree dissertation was
> based on the study of musician's reaction to just and equal tempered music,
> and was created using LilyPond.  However, I'm not clear why you believe
> that accidentals in non-equal temperaments require different signs (I think
> that's what you're proposing here).  It's said that early music was based
> on one or other form of just temperament, and used normal accidental
> signs.  To me, they indicate that the music is altered to the next higher
> or lower semitone in the key and temperament being employed: so why are
> other signs needed?
>
> The only extra indication that I would use would be rather like a tempo
> sign, but instead a temperament sign: "Quarter comma meantone" at the top,
> for example.
>
> --
> Phil Holmes
>
>
>
> - Original Message -
> *From:* N. Andrew Walsh <n.andrew.wa...@gmail.com>
> *To:* lilypond-user <lilypond-user@gnu.org>
> *Sent:* Tuesday, December 01, 2015 9:10 AM
> *Subject:* accidentals for just intonation
>
> Hi List,
>
> this is a somewhat specialist request, and more of a long-term project,
> but I'm hoping you nice people can help me with something I'd like to do
> with Lily someday.
>
> If you've been watching the OpenLilyLib repository, you'll see that Urs
> has been working on a set of tools for rendering music in just intonation.
> He (quite modestly) says that it isn't ready for production, but there are
> already some impressive things it can do: for one, the interface allows to
> input a fraction and get back a nearest-semitone pitch with a deviation in
> cents *automatically*, which is something the commercial programs don't
> offer in any way (every composer I know who works with JI just inputs text
> entries manually for every note, with no change in, for example, MIDI
> output for ability to handle transpositions).
>
> There's something I'd very much like to do with this, largely out of my
> own (admittedly rather opinionated) view on the best means of producing
> accidentals for just intonation. I'm going to assume some familiarity with
> just intonation concepts, but (in short) it works like this: the
> relationship between two pitches is defined in terms of the frequency
> relationship, given usually as a fraction. For example, the interval of a
> perfect fifth may be rendered as 3/2: that is, if I play notes with base
> frequencies of 200 and 300Hz, we hear them as a (very purely tuned) fifth.
> The equal-tempered one you ha

Re: accidentals for just intonation

[N. Andrew Walsh]

Let me give another example of what I mean, just so you have an idea. I'm
in a singing ensemble that performs music in just intonation. We have a
soprano who is *terrifyingly* good at it. One of the things she does is
sing a scale comprising the following harmonic ratios relative to the
tonic: 14/8, 16/9, 18/10, 20/11, 22/12, 24/13, 26/14, 28/15, 30/16. The
first and last pitches reduce to 7/4 and 15/8, respectively: a minor and
major seventh. So, she can sing a total of *nine* pitches within the space
of a semitone and, because she can hear the harmonic ratios they each
represent, tune them all correctly. She can do this without accompaniment
(like I said, she's scary!).

Now, you *could* just give those pitches as flats and sharps, with their
respective deviations in cents, but it would be much harder to tune by ear.
Even then, it would be guesswork. The last two pitches are less than 8
cents apart; it would be extremely difficult to get them both tuned
accurately, even with feedback from a tuner. Knowing the ratios, though,
makes it possible to hear, and thus to perform.

But, as I said, whether that's a music that others might find æsthetically
interesting is an entirely different discussion. My question is: if I were
to use such a system, how would I engrave it?

Cheers,

A

On Tue, Dec 1, 2015 at 11:01 AM, Urs Liska <u...@openlilylib.org> wrote:

>
>
> Am 01.12.2015 um 10:45 schrieb Phil Holmes:
>
> I have quite an interest in intonation, and my degree dissertation was
> based on the study of musician's reaction to just and equal tempered music,
> and was created using LilyPond.  However, I'm not clear why you believe
> that accidentals in non-equal temperaments require different signs (I think
> that's what you're proposing here).
>
>
> This is because Andrew is not talking about music that uses a scale of
> notes that just deviates from the well-tempered scale through a tuning
> system. Instead he's (and of course a number of composers) conceiving
> pitches as ratios over fundamental frequencies. So you may have two
> consecutive notes that are very similar in frequency but stem from
> completely different contexts: for example a 5/1 ratio (major third
> flageolet) over b, resulting in a pitch that is 14 cent below d', followed
> by a pitch that is 2 cent above d' because it is the 3/1 ratio over g.
>
> You can notate that as
>
> d' -\markup "(-14)" d' -\markup "(-2)"
>
> but what Andrew suggests (and does himself by hand so far IIUC) is a
> notation that indicates the same as (pseudo-code):
>
> b,{5:1] g{3:1}
>
> Depending on the instrument that will create those pitches different
> notations may be appropriate. I clarinetist who is bending will prefer the
> indication of the cent detuning, while when I have to play them as piano
> flageolets I don't really care about that and have to know the key to press
> (fundamental note) and the ratio or node of the string - the resulting
> pitch with its cent deviation will only be there as a courtesy.
>
>   It's said that early music was based on one or other form of just
> temperament, and used normal accidental signs.  To me, they indicate that
> the music is altered to the next higher or lower semitone in the key and
> temperament being employed: so why are other signs needed?
>
>
> I don't know how Andrew "thinks" as a composer, but music in just
> intonation (in it's modern conception) is a very different thing from
> ancient music in different tunings.
>
> Urs
>
>
>
> The only extra indication that I would use would be rather like a tempo
> sign, but instead a temperament sign: "Quarter comma meantone" at the top,
> for example.
>
> --
> Phil Holmes
>
>
>
> - Original Message -
> *From:* N. Andrew Walsh <n.andrew.wa...@gmail.com>
> *To:* lilypond-user <lilypond-user@gnu.org>
> *Sent:* Tuesday, December 01, 2015 9:10 AM
> *Subject:* accidentals for just intonation
>
> Hi List,
>
> this is a somewhat specialist request, and more of a long-term project,
> but I'm hoping you nice people can help me with something I'd like to do
> with Lily someday.
>
> If you've been watching the OpenLilyLib repository, you'll see that Urs
> has been working on a set of tools for rendering music in just intonation.
> He (quite modestly) says that it isn't ready for production, but there are
> already some impressive things it can do: for one, the interface allows to
> input a fraction and get back a nearest-semitone pitch with a deviation in
> cents *automatically*, which is something the commercial programs don't
> offer in any way (every composer I know who works with JI just inputs text
> entries manually for every note, with no change in, for example, MIDI
> o

Re: accidentals for just intonation

[Urs Liska]

Am 01.12.2015 um 10:47 schrieb N. Andrew Walsh:
> So, the just-intonation accidental engraver would be able to break
> down the ratio given for a pitch into its prime factors (or expect
> that they are already thus formatted), and then place the paths on the
> accidental in the correct positions, and then typeset the resultant
> accidental into music notation in place of regular accidentals. 
>
> I hope that clarifies a bit what I'm going after. Thanks again for the
> help.
>

I have to admit it would need more mental capacity than I have available
right now to really get through this, but I think my basic approach
should be the right one:

You have a rather small number of individual components (vertical,
horizontal and diagonal elements) that can all represented by a
postscript path. A function should be able to determine from the input
ratio which of these elements have to be combined and then generate the
appropriate path and eventually use that to replace Accidental.stencil.

How these paths can be created is something I won't be of much help, but
if you get to the point where you have very concrete necessities you'll
surely be able to get help by others with more experience in that.

Urs

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[David Kastrup]

"N. Andrew Walsh" <n.andrew.wa...@gmail.com> writes:

> There's something I'd very much like to do with this, largely out of
> my own (admittedly rather opinionated) view on the best means of
> producing accidentals for just intonation.

It seems like with notational systems that everyone has an opinion and a
plan for that.  The best that LilyPond can reasonably hope for is
providing the tools for making it easy to implement your own schemes.

-- 
David Kastrup

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[David Kastrup]

"Phil Holmes"  writes:

> I have quite an interest in intonation, and my degree dissertation was
> based on the study of musician's reaction to just and equal tempered
> music, and was created using LilyPond.  However, I'm not clear why you
> believe that accidentals in non-equal temperaments require different
> signs (I think that's what you're proposing here).  It's said that
> early music was based on one or other form of just temperament, and
> used normal accidental signs.  To me, they indicate that the music is
> altered to the next higher or lower semitone in the key and
> temperament being employed: so why are other signs needed?

Well, Urs' printing of the cents does have educational purpose.  For
example, I can spell out the tuning of a guitar done by pure harmonics
(the highest-sounding two strings in relation to harmonics of the
lowest-sounding one):

e, as a, * 3/4 (e, +2)
a, as a,   (a, +0)
d as a, * 4/3  (d  -2)
g as d * 4/3   (g  -4)
b as e, * 3(b  +4)
e' as e, * 4   (e' +2)

And if that kind of information is spelled in a scale, it becomes
obvious why G major and E minor chords have a problem sounding good out
of the box if you tune to perfect harmonics.  Because the interval g-b
should end up as -14 (!) in order to be a pure third, but actually ends
up as +8, a discrepancy of 22 cent.

Which explains why my default manner of tuning a guitar, namely just
tuning each string to sound as I think it should in relation to the
sequence of previous strings, has a good chance to end up more playable
than the followup work of a "serious" guitar player believing in tuning
by using harmonics.

In the scheme of talking about tunings or ad-hoc modifications, a scheme
like Urs' that can accommodate basically a continuity of values
certainly has some merit.  As a continuous notation for the sake of
playing, I think it would end up a nuisance.

-- 
David Kastrup

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Stephan Neuhaus]

On 2015-12-01 11:27, David Kastrup wrote:

[...]

Which explains why my default manner of tuning a guitar, namely just
tuning each string to sound as I think it should in relation to the
sequence of previous strings, has a good chance to end up more playable
than the followup work of a "serious" guitar player believing in tuning
by using harmonics.


This may be off-topic, but this is *exactly* how I do it. For a while I 
was worried that this might be too slapdash, but then I thought, "if it 
sounds good, who am I to argue?" :-)


Fun,

Stephan

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[Paul Morris]

> On Dec 1, 2015, at 5:38 AM, Urs Liska  wrote:
> 
> You have a rather small number of individual components (vertical,
> horizontal and diagonal elements) that can all represented by a
> postscript path. A function should be able to determine from the input
> ratio which of these elements have to be combined and then generate the
> appropriate path and eventually use that to replace Accidental.stencil.

Yep, sounds like a matter of creating path stencils for each component part, as 
static unchanging building blocks, and then have a function that dynamically 
combines these stencils to produce the accidental needed for a given note.  
Combining stencils in different ways is simpler than producing a path on the 
fly, so that will make things easier.

I have done this kind of thing by creating an SVG with Inkscape and then 
opening the SVG file in a text editor where I can copy the path coordinates.  
Then I can paste those coordinates into a LilyPond include file, in a procedure 
that produces a path stencil.  (With some tedious back and forth to get the 
scaling right.)  Then that stencil is available to use by LilyPond.  

For Clairnote music notation I have code that replaces accidental signs with 
custom accidentals[0] that might be helpful to look at.  It combines a dot 
stencil with a line stencil, so no paths are needed.  However, I also use path 
coordinates to create whole note glyphs, so there’s an example of that as well. 
 That code is available here:

http://clairnote.org/software/

[0] http://clairnote.org/accidental-signs/

> How these paths can be created is something I won't be of much help, but
> if you get to the point where you have very concrete necessities you'll
> surely be able to get help by others with more experience in that.

There are several ways to create a stencil from a path.  Search the LSR for 
“path” for two different ways in addition to the \path markup command.  The 
most recent development version of LilyPond (2.19.x) also has a 
make-path-stencil function that combines the benefits of the two ways 
documented on the LSR without their drawbacks, so I prefer to use that unless 
I’m supporting LilyPond 2.18. 

-Paul


___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: accidentals for just intonation

[N. Andrew Walsh]

These sorts of conflicts in tuning arise, as Urs pointed out, from using
one note to designate two different harmonic contexts. The whole field of
temperament is largely an effort to reconcile them, with varying solutions
in various time periods, depending on what kind of sound was preferred (for
example, in some meantone temperaments you hear much purer thirds, at the
expense of fifths being too low. In others, you have exactly the opposite).
In just intonation, I would describe the two kinds of D -- a fifth over G
and a major third over Bb -- in the key of F as 27/16 and 5/3, respectively
(and they have, as you note, a difference between them of about 20 cents).

There's reasonable benefit to giving cents values, beyond educational: one
of the conventions in just intonation -- one which a colleague of mine
really wants to see -- is to approximate the accidentals to 12th-tones (so,
12 steps to the whole tone), and then give a markup above indicating the
nearest semitone with cents deviation. In the case of our 5/4 third, that
would show "D -13.7" above, but the accidental would be a D 2/12th
flattened. Other instruments, which maybe can't use 12th-tones, might use
other kinds of accidentals, which behave according to different rules (for
example, there are common fingering charts for flute and oboe that give
8th-tones, but clarinet just has quartertones). Being able to specify an
exact harmonic ratio, and then have Lily output different accidentals, each
behaving according to different rules as needed, would be a big advantage
over other software (and would open it up to systems like mine, which
behave according to totally different rules which can nevertheless be
extracted from the information given).

Cheers,

A

On Tue, Dec 1, 2015 at 1:50 PM, Stephan Neuhaus  wrote:

> On 2015-12-01 11:27, David Kastrup wrote:
>
>> [...]
>>
>> Which explains why my default manner of tuning a guitar, namely just
>> tuning each string to sound as I think it should in relation to the
>> sequence of previous strings, has a good chance to end up more playable
>> than the followup work of a "serious" guitar player believing in tuning
>> by using harmonics.
>>
>
> This may be off-topic, but this is *exactly* how I do it. For a while I
> was worried that this might be too slapdash, but then I thought, "if it
> sounds good, who am I to argue?" :-)
>
> Fun,
>
> Stephan
>
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user