Dieses Wiki enthält einerseits Tipps&Tricks zum Thema Lilypond, andererseits Lilypond-Scores.
Elise-rechteHand.png

Lily:Leitereigene Mehrklänge per Scheme erzeugen

Wechseln zu: Navigation, Suche

Idee[Bearbeiten]

Dieses Programm erzeugt eine Liste von beliebigen Mehrklängen basierend auf einer vorgegebenen Tonleiter. Diese ist nichts anderes als eine Abfolge von Noten, es muss nicht unbedingt eine klassische Tonleiter sein, sondern kann auch ein exotisches Gebilde wie Gipsy-Scales etc. sein.

Das Programm macht nichts anderes als stur die Töne hintereinander anzuordnen, sollten Terzen erzeugt werden, nimmt es es jeden zweiten Ton. Die Tonleiter wird am oberen Ende mit den um eine Oktave höheren Tönen ergänzt.

Das Programm unterscheidet drei Möglichkeiten der Eingabe: eine einzelne Zahl, ein Paar oder eine Liste. Gibt man eine Zahl an, werden so viele Terzen gestapelt wie durch diese Zahl vorgegeben. Ein Paar #'(a . b) bedeutet, dass a-1 Intervalle der Größe b (5 ergibt Quinten) gestapelt werden. Eine Liste gibt die Intervallfolge vor, z.B. #'(4 3) eine Quart, gefolgt von einer Terz.

Eine Terz ist ein Tonintervall, in dem zwischen den zwei Tönen genau ein Element der Tonleiter sitzt. Daraus ergibt sich, dass man durch Wahl der Tonleiter den Output beinahe beliebig variieren kann. Zu beachten ist, dass die Töne der Tonleiter nach Tonhöhe sortiert und doppelte entfernt werden. Ist dies nicht gewünscht, muss der entsprechende Code entfernt werden.

Code inklusive Anwendungsbeispiel[Bearbeiten]

\version "2.19.37"
\language "deutsch"

%% create diatonic chords from a scale
%% enter the steps of the scale as lily music
%% and chose the number of notes the chords should have

#(define (music-elts x)
   (if (not (ly:music? x))
       '()
       (ly:music-property x 'elements)))

#(define (music-name x)
   (if (not (ly:music? x))
       #f
       (ly:music-property x 'name)))

%% convert pitchlist to a music chord
#(define (pitches->chord plist)
   (make-music 'EventChord 'elements
     (if (list? plist)
         (map (lambda (p)
                (make-music
                 'NoteEvent 'duration (ly:make-duration 0)
                 'pitch p))
           plist)
         (make-music
          'NoteEvent 'duration (ly:make-duration 0)
          'pitch plist)
         )))

%% convert pitchlist to plain music
#(define (pitches->music plist)
   (if (list? plist)
       (make-music 'SequentialMusic 'elements
         (map (lambda (p)
                (make-music
                 'NoteEvent 'duration (ly:make-duration 0)
                 'pitch p))
           plist))
       (make-music 'SequentialMusic 'elements
         (make-music
          'NoteEvent 'duration (ly:make-duration 0)
          'pitch plist))))

%% create all n-th chords from scale
%% actually we staple every other pitch from the-scale
%% until we reach n

%% create chords with arbitraty intervals from the scale
%% input: scale
%% list: the distances of the notes, 3=terz, 4=quart ...

#(define (stacked-intervals the-scale list-or-number-or-pair)
   ;; the-scale: music from which the pitchlist is constructed
   ;; usually a scale, but could be any music
   ;; duplicate pitches are removed and sorting according to pitch height is done
   ;; list-or-number-or-pair: tells the programm which intervals to produce
   ;; list: a list of chords, 3=third, 4=forth etc. '(2 4) creates a quart-sext chord
   ;; pair: '(a . b)  a: how many notes the chord contains, b: the interval, 3=third, 4=forth
   ;; number: terzes are stapled, 3=triad, 4=tetrads, 5=pentachord etc
   ;; actually the program does not much counting
   ;; a list of intervals is created by picking notes in the order they appear
   ;; in the scale leaving gaps defined by the list
   (let* ((scpi (music-pitches the-scale))
          (pili (sort
                 (delete-duplicates scpi) ly:pitch<?))
          (m (length pili))
          (elist (cond
                  ((list? list-or-number-or-pair)
                   ;; we need to add an element to the list
                   ;; otherwise the last element of the list would not appear
                   ;; in the result
                   (append list-or-number-or-pair '(1)))
                  ((pair? list-or-number-or-pair)
                   ;; car: number of notes
                   ;; cdr: distance, 3=third, 4=forth etc.
                   (make-list  (car list-or-number-or-pair) (cdr list-or-number-or-pair)))
                  ((number? list-or-number-or-pair)
                   ;; standard definition: chord consists of thirds
                   (make-list list-or-number-or-pair 3))))
          (n (length elist)))
     (map
      (lambda (w)
        (let ((u 0))
          (map
           (lambda (x)
             (let* ((y (modulo (+ u w) m))
                    (q (quotient (+ u w) m))
                    (z (list-ref pili y))
                    (a (ly:pitch-alteration z))
                    (o (ly:pitch-octave z))
                    (n (ly:pitch-notename z))
                    (p (ly:make-pitch (+ o q) n a)))
               (set! u (+ u (list-ref elist x) -1))
               p))
           (iota n))))
      (iota m))))

CreateIntervals=
#(define-music-function (the-scale pair-list-number)(ly:music? scheme?)
   ;; creates the pure music without chordnames and other staff
   (make-sequential-music
    (map (lambda(x) (pitches->chord x))
      (stacked-intervals the-scale pair-list-number))))

CMajor=\relative c' { c d e f g a h }
SpanishGipsy=\relative c' { c cis e f g gis ais }
CMinor = \relative c' { c d es f g as h }

\markup "Diatonic Pentachords in C-major"
penta=\CreateIntervals \relative c' \CMajor #5

\score {
  <<
    \new Staff \penta
    \new ChordNames \penta
  >>
}

\markup "Diatonic Tetrachords in C-major"
tetra=\CreateIntervals \relative c' \CMajor #4

\score {
  <<
    \new Staff \tetra
    \new ChordNames \tetra
  >>
}

\markup "Create Quart-Sext-Chords in C-major"
\CreateIntervals \CMajor #'(4 3)


\markup "stack four fifths in C-minor"

{
  \new Staff \key es \major
  \CreateIntervals \CMinor #'(5 . 5)
}


Output[Bearbeiten]

Automatisch Akkorde erzeugen

Kategorien[Bearbeiten]

Wer verlinkt auf diese Seite?