On Wed 11 Sep 2019 at 20:36:22 (+0200), John McWilliam wrote:
>        I appreciate your thoughts on this one. I was looking for ways to 
> avoid repeating my code and therebye reduce the size of the LP file - I have 
> 26 scales to cover! I thought it might be possible to have a basic brocken 
> chord exersice in C and then simply transpose each scale from that. Utopia…
>       I have decided that in the long run it will be quicker and less effort 
> to write out each scale (longhand). I enclose my basic structure. If you have 
> a better idea, please let me know.

My only other suggestion would be to write a script to generate the
LP code. This presupposes that you're comfortable with a scripting
language like, say, python.

The Cmaj version contains just a sequence cegcegceg… followed by
gecgecgec… so that's just reading arrays of length 3 with an index
being incremented modulo 3.

The other versions vary in (i) the starting note (= finishing) which
you specify individually, in absolute pitch; (ii) the index 0, 1 or 2
of the second note; and (iii) whether the second note needs a ","
(because that interval can be a 4th or a 6th).

After that, the pattern is fixed: going up, the second note of each
group always has a ","; and going down, the first note of each group
always has a "'" except for the very first (ie the top note).

You'd still use LP's modal transposition on the generated sequences,
but proof-reading involves only looking at a few notes. (Your amin
version still contains that typo.)

As I say, it does require fluency in scripting.

> From: David Wright
> On Tue 10 Sep 2019 at 16:34:56 (+0200), John McWilliam wrote:
> > The reason for the adjusted first Group (a4~ a16 e, g a) is due to the fact 
> > that the lowest note on a Bb clarinet is e. Thereafter, the broken chords 
> > follow the set pattern until reaching the last group. I have extended my 
> > snippet to illustrate what I mean.
> I'm not sure how you expect LP to divine the range of the clarinet.
> What *would* be a "strange interpretation" to me is transposing an
> interval of a sixth into a fourth.
> But the solution to your particular problem might be to observe
> that most of the notes in your manually adjusted version (senza
> typo) are shifted in time by one group when compared with the
> correct (your so-called "wrong") version. Also, several of the
> groups (corresponding to lines in the source file) are exact
> repetitions.
> So I would break your Cmajor variable into 4-note chunks and then
> build each sequence from these smaller variables. Note that for
> this to work, you must put \relative { } round the composite
> scale, not round the 4-note chunks. The latter must be left
> "floating", neither absolute nor relative.
> %% ✄ %%%%
> raw = { c16 e f g }
> \score {
>   \relative c' { \raw \raw \raw \raw }
> }
> baked = \relative { c e f g }
> \score {
>   \relative c''' { \baked \baked \baked \baked }
> }
> %% ✄ %%%%
> The \relative c''' is impotent in both its effects, because \baked
> is already absolute.
> > From: David Wright
> > 
> > On Tue 10 Sep 2019 at 13:19:52 (+0200), John McWilliam wrote:
> > > Hi again,
> > >   I attach my attempt to use \modalTranspose in order to save code when 
> > > rewriting broken chords in C major and A minor.  The idea is to go ahead 
> > > and repeat the exercise in G major, Eminor etc., however, it looks as 
> > > though I am going to have to write everything out (longhand). You will 
> > > see in my example that modalTranspose gives a strange interpretation of A 
> > > minor and I wonder whether there is a solution to this?
> > 
> > Shouldn't your manual one be:
> > 
> > Aminor = \relative c' {
> >   \key a \minor
> >   a4~ a16 c, e a c e, a c e a, c e
> > }
> > 
> > which matches the modal transposition.


lilypond-user mailing list

Reply via email to