Lilypond Userthread

Be-3 · 03.10.15

Hallo SyIvia,

obwohl Du eine Lösung für Dich gefunden hast, möchte ich hier intervenieren:

SyIvia schrieb:
ich bekomme grad keine Triole hin, die ueber die Laenge von 4., also genau die Haelfte eines 3/4 Taktes geht. Geht das nicht, oder stelle ich mich an?

Du stellst Dich an! Oder besser gesagt: Du siehst den Wald vor lauter Bäumen nicht.

SyIvia schrieb:
...aeh, seltsamerweise hab ich es eben hinbekommen, und antworte mir selbst:
[...]
richtig ist es so: e4. \times 2/3 {a8. c d} - jetz ist der takt voll. - Schaut etwas merkwuerdig aus...

Das sieht allerdings merkwürdig aus :weird:

, und es gibt auch einen erschreckend einfachen Grund dafür:

Fragen:

Wie lang ist ein 3/4-Takt?
Wieviele Achtel passen in einen 3/4-Takt?
Wieviele Achtel passen in eine Takthälfte?

Antworten:

Ein 3/4-Takt hat die Länge von 3 Viertelnoten.
Deshalb passen genau 6 Achtelnoten in einen 3/4-Takt
In eine Takthälfte passen also 3 Achtelnoten.

Masterfrage:
Was muß ich tun, um mit drei gleich langen Noten eine Takthälfte auszufüllen?

Lösung: Achtelnoten!!!

Mensch, SyIvia, das ist doch also ganz einfach: nimm Achtelnoten

Rein rechnerisch geht es auch mit Deinen Triolen aus punktierten Achteln, aber das ist verwirrend, weil unnötig kompliziert hin- und hergerechnet:
Eine punktierte Achtel ist so lang wie drei Sechzehntel.
Die LilyPond-Schreibweise von Triolen mit \times 2/3 bzw. \tuplet 3/2 kommt nicht von ungefähr und enthält gerade dieses Verhältnis:
3:2 heißt, daß 3 Noten die Zeit einnehmen, die sonst 2 Noten dieses Typs beanspruchen würden.
Anders formuliert: die effektive Länge jeder Note wird um den Faktor 2/3 verändert.
Dazu braucht man in diesem Fall aber keine Triolenkonstruktion, weil man eine punktierte Viertel auf 2/3 ihres Werte zusamenstutzen kann, indem man einfach den Punkt wegläßt und ganz ordinäre Achtelnoten verwendet.

Aber noch was:
Ich kenne ja den Zusammenhang nicht, aber die punktierte Viertelnote bzw. die Takthälfte scheinen bei Deinem Stück eine wichtige Rolle zu spielen.
Ein 3/4-Takt besteht aber rhythmisch aus 3 Schlägen.
Wenn Du den Puls eher im "punktierte-Viertel-Abstand" empfindest, also immer zwei Schläge pro Takt bzw. zwei Achtel-Dreiergruppen pro Takt, dann wäre eigentlich ein 6/8-Takt die richtige Wahl.
Das erkennt man auch an der typischen Balkengruppierung: zwei Dreiergruppen:

Viele Grüße
Torsten

mjchael · 02.07.19

Ich möchte für Gitarristen Rhythmus-Notation auf den Wikibooks darstellen.

So soll es aussehen.

<score midi="1" vorbis="1">
<<
\new ChordNames {
\chordmode {
c1 f g c
}
}

\new Voice \with {
\consists "Pitch_squash_engraver"
} \relative c'' {
\improvisationOn
c4 c8 c c4 c8 c
f4 f8 f f4 f8 f
g4 g8 g g4 g8 g
c4 c8 c c4 c8 c
}
>>
</score>

Aber es sollen Akkorde erklingen, und nicht nur einzelne Noten.
Wenn ich aber versuche Akkorde unten einzufügen, dann sieht das Notenbild konfus aus.

Das war mein Chode-Versuch
<score midi="1" vorbis="1">
<<
\new ChordNames {
\chordmode {
c1 f g c
}
}

\new Voice \with {
\consists "Pitch_squash_engraver"
}{
\improvisationOn
<c e g c' e'>4 <c e g c' e'>8 <c e g c' e'>8 <c e g c' e'>4 <c e g c' e'>8 <c e g c' e'>8
<f a c' f'>4 <f a c' f'>8 <f a c' f'>8 <f a c' f'>4 <f a c' f'>8 <f a c' f'>8
<g, b, d g b g'>4 <g, b, d g b g'>8 <g, b, d g b g'>8 <g, b, d g b g'>4 <g, b, d g b g'>8 <g, b, d g b g'>8
<c e g c' e'>4 <c e g c' e'>8 <c e g c' e'>8 <c e g c' e'>4 <c e g c' e'>8 <c e g c' e'>8
}
>>
</score>

Man hört zwar halbwegs richtig den Anschlag (zwar nur für Klavier, aber erstmal egal)
Dass ich den jeweils zweiten Notenwert nicht nochmal wiederholen müsste weiß ich, aber das hat eh nichts mit dem Darstellungsfehler zu tun.

https://de.wikibooks.org/wiki/Benutzer:Mjchael/_Spielweise#Rhyhtmusnotation_mit_Lilypond

Wer kennt sich gut genug mit Lilypond aus, um diesen Code zu optimieren?

Ziel ist es, hier einen Rhythmus-Tutorial für die Gitarristen zu erstellen, der dann auch als Lektion auf den Wikibooks erscheint.

Für eigene Experimente könnt ihr die Spielwiese auf den wikibooks verwenden.
https://de.wikibooks.org/wiki/Wikibooks:Spielwiese

mjchael · 11.01.20

Lösung für mein im letzten Post genanntes Problem:

Code:

<<
  \new ChordNames {
  \chordmode {
  c1 f g c
  }
  }
 \new Voice \with {
  \consists "Pitch_squash_engraver"
  }{
  \set Staff.midiInstrument = "acoustic guitar (nylon)"
  \improvisationOn
  \override NoteHead.X-offset = 0
  <c e g c' e'>4 \downbow 
  <c e g c' e'>8 \downbow 
  <c e g c' e'>8 \upbow 
  <c e g c' e'>4 \downbow 
  <c e g c' e'>8 \downbow 
  <c e g c' e'>8 \upbow
  <f a c' f'>4 \downbow 
  <f a c' f'>8 \downbow 
  <f a c' f'>8 \upbow 
  <f a c' f'>4 \downbow 
  <f a c' f'>8 \downbow 
  <f a c' f'>8 \upbow
  <g, b, d g b g'>4 \downbow 
  <g, b, d g b g'>8 \downbow 
  <g, b, d g b g'>8 \upbow 
  <g, b, d g b g'>4 \downbow 
  <g, b, d g b g'>8 \downbow 
  <g, b, d g b g'>8 \upbow
  <c e g c' e'>4 \downbow 
  <c e g c' e'>8 \downbow 
  <c e g c' e'>8 \upbow 
  <c e g c' e'>4 \downbow 
  <c e g c' e'>8 \downbow 
  <c e g c' e'>8 \upbow
  }
>>

Danke an Malte vom Lilipond-Forum für seine Unterstützung!

Martman · 09.02.20

Sieht wohl so aus, als wenn bald LilyPond 2.20 kommt.

Sieht aber auch so aus, als wenn das dann immer noch das eigentlich mausetote Python 2 brauchen wird und der erste Stable Release, der komplett auf Python 3 umgestellt ist, erst 2.22 sein wird – wann immer der kommt. Das heißt dann für die Pinguindompteure unter uns schlimmstenfalls, eine Weile ohne LilyPond auskommen zu müssen. Wer auf Zweijahresreleases mit Langzeitunterstützung setzt, kann wohl auch mal zwei Jahre drauf verzichten müssen – vier oder sechs, wenn sie für 2.22 wieder so lange brauchen werden wie für 2.20.

2.21 soll wohl schon auf Python 3 umgestellt sein. Das ist dann aber ein Experimental Release, den sich keine Distri in die Quellen holen wird, und wir haben ja gesehen, wie lange die schon an 2.19 rumfriemeln.

Martman

Martman · 13.04.20

Seit 1. März ist übrigens LilyPond 2.20 da (Changelog). Und für die, die es gern etwas aktueller haben und Entwicklerversionen nutzen, ist seit vier Tagen LilyPond 2.21 raus (das Changelog ist schon eine Vorschau auf 2.22).

Martman

Martman · 01.02.21

Es gibt wieder Neues: Die stabile Version ist jetzt bei 2.22 (Changelog gegenüber 2.20), die Entwicklerversion bei 2.23 (bisheriger Changelog gegenüber 2.22).

Für diejenigen, die LilyPond per Hand updaten müssen, gibt es Downloads, wo es sie immer gibt.

Martman

murmichel · 01.02.21

Kannst du zufällig etwas dazu sagen, ob die aktuelle Version ohne Verrenkungen (etwas docker) auch auf macOS 10.15 (Catalina) und neuer läuft?

Martman · 10.02.21

Aus Erfahrung kann ich nichts sagen, weil ich Apple-Produkte jeglicher Art mit der Kneifzange nicht anfasse.

Es gibt inoffizielle LilyPond-Binaries für macOS 10.15, aber aktuell nur bis LilyPond 2.20.

Martman

Akkofant · 12.03.21

LilyPond hat mich nun auch gepackt. Ich benutze die Version 2.22.0 mit Hilfe von Frescobaldi.

Ich habe zum Üben 2 Lieder für Akkordeon notiert und dafür die Pianovorlage verwendet. Das Notieren der Noten hat sehr schnell gut geklappt.
Am Layout etwas zu verändern, gestaltet sich für mich noch schwierig. Wenn ich Ergänzungen oder Veränderungen der Vorlage vornehmen wollte, hat es zwar oft zu: „schwerer Fehler“ geführt, aber ein paar kleine Änderungen sind mir dann doch gelungen. Durch das Trial-and-Error-Prinzip beginne ich zu verstehen, wie es funktioniert.

Bisher habe ich PriMus verwendet und mich oft darüber geärgert, dass etwas nicht ging. Mit LilyPond weiß ich, es geht fast alles...
... ich muss nur rausfinden wie...
So konnte ich endlich ein Stück im 7/8 Takt mit LilyPond notieren.

Wenn ich im Benutzerhandbuch Suchbegriffe eingebe, bekomme ich sehr oft Suchergebnisse aus dem Entwicklerzweig. Kann ich die Infos dort 1:1 für die Version 2.22.0 verwenden?

Gibt es zum Thema Layout verständlichere Texte/Erklärungen als das Benutzerhandbuch? (für nicht-Programmiersprachen-gewohnte Menschen

)

Auf LilyPond aufmerksam geworden bin ich hierüber:

Be-3 schrieb:
Ja, genau das ist ein Problem. Wie man sich auch nicht selber kitzeln kann.
Es gibt aber Apps/Programme die zufällige oder sogar sinnvolle Tonfolgen vorgeben, manche Notensatzprogramme (z. B. LilyPond) können auch Zufalls-Tonfolgen für solche Übungen erzeugen.

Nun bin ich echt neugierig, wie kann LilyPond Zufallstonfolgen erzeugen? Toll wäre, wenn der Tonvorrat eingrenzt werden könnte, z. B. auf eine Tonart. Im Handbuch bin ich nicht fündig geworden.

Freu mich über Tipps!

Be-3 · 12.03.21

Akkofant schrieb:
Wenn ich im Benutzerhandbuch Suchbegriffe eingebe, bekomme ich sehr oft Suchergebnisse aus dem Entwicklerzweig. Kann ich die Infos dort 1:1 für die Version 2.22.0 verwenden?

Hallo Akkofant,

die meisten Dinge bleiben ja gleich, aber es empfiehlt sich natürlich, die zur genutzten Version passende Doku zu konsultieren.
Die Dokus zur aktuellen stabilen Version (momentan 2.22) findet man hier.

Akkofant schrieb:
Nun bin ich echt neugierig, wie kann LilyPond Zufallstonfolgen erzeugen? Toll wäre, wenn der Tonvorrat eingrenzt werden könnte, z. B. auf eine Tonart. Im Handbuch bin ich nicht fündig geworden.

Man kann in LilyPond beliebige Erweiterungen/Funktionen definieren. Dazu benötigt man allerdings Scheme-Kenntnisse und ein gewisses Wissen über die inneren Abläufe.
Zufalls-Notenfolgen wären so ein Beispiel und da es eine Zufalls-Funktion gibt, ist das natürlich machbar.

Es empfiehlt sich aber, idealerweise von existierenden Beispielen auszugehen und diese dann nach den eigenen Bedürfnissen anzupassen - das ist nämlich viel einfacher, als von Grund auf neu anzufangen.
Solche "Spezial-Lösungen" sind oft unter den so genannten "Snippets" zu finden und ein Beispiel für Zufalls-Notenfolgen ist auch in der 2.22er-Doku vorhanden: Scrollen zu "Generating random notes".

Das gezeigte einfache Beispiel (direkt in der \score-Umgebung eingegeben, hier ohne spezielle Funktion), sieht folgendermaßen aus:


\score {
  {
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 12 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 7)
                                        0))))))
              (make-list 24))))
  }
}

und liefert folgendes Ergebnis (oder ähnlich, weil immer anders, das ist ja der Sinn der Zufalls-Generierung).:

damit sich immer andere Zufallszahlenfolgen ergeben, wird der seed abhängig von der Zeit gesetzt, denn mit der gleichen Ausgangsbasis ergäben sich sonst immer die gleichen "zufälligen" Zahlenfolgen
Die Variable idx erhält einen zufälligen ganzzahligen Wert zwischen 0 und 11 (wegen "random 12"
Die LilyPond-Funktion ly:make-pitch hat die drei numischen Parameter Oktave, Stammton (Note ohne Versetzungszeichen, von 0 bis 7, entspricht c bis h) und Alteration (Versetzungszeichen, wobei 0 nichts ist und z. B. -1/2 einen Halbton tiefer, also ein Be).
Das "(make-list 24)" am Ende bewirkt, dass 24 Noten erzeugt werden.

Das könnte man noch verfeinern und z. B. nur Noten aus fertig definierten Skalen verwenden, aber dieses "einfache" Beispiel ist schon einmal eine Ausgangslage.

Wenn auch noch die Notendauern zufällig sein sollen (hier sind es ja immer nur Viertel), wird es natürlich aufwendiger, denn da sollte man ja dafür sorgen, dass alle Takte korrekt gefüllt sind.

Wenn Du nach dem Herumprobieren gezielte Fragen oder Änderungswünsche hast bzw. etwas nicht verstehst, kannst Du gerne hier nachfragen.

Viele Grüße
Torsten

Akkofant · 12.03.21

Dankeschön :great:

Be-3 · 13.03.21

Hallo Akkofant,

was mir an dem gezeigten Beispiel nicht gefällt, ist, dass das Coding mitten in den Notentext geschrieben ist.
Schöner wäre eine "ordentliche", allgemein aufrufbare Funktion, vielleicht sogar mit ein paar Parametern.

Akkofant schrieb:
Toll wäre, wenn der Tonvorrat eingrenzt werden könnte, z. B. auf eine Tonart. Im Handbuch bin ich nicht fündig geworden.

Das möchte ich zum Anlass nehmen, um ein wenig über Tonarten bzw. allgemeiner sogar Skalen zu schreiben.
Aus Gründen der Einfachheit zum Einstieg eine Funktion, mit der man eine Tonleiter/Skala in einer beliebigen Tonart erzeugen kann (zum Spaß aufwärts und wieder abwärts, über eine wählbare Anzahl von Oktaven).

Das kann dann leicht auf Zufall umgebaut werden, aber die vollständigen Skalen erleichtern die Kontrolle.

Skalen

Eine Skala/Tonart in LilyPond wird immer mit Grundton c definiert (entspricht Wert 0) - der Wechsel zu anderen Tonarten kann einfach über Transponieren erreicht werden.
Die Tonarten \major und \minor und die Kirchentonarten (z. B. \dorian sind sogar schon vordefiniert (im Include scale-definitions-init.ly).

Am Beispiel von \dorian sieht eine solche Definition folgendermaßen aus:

Code:

dorian = #`(
    (0 . 0)
    (1 . 0)
    (2 . ,FLAT)
    (3 . 0)
    (4 . 0)
    (5 . 0)
    (6 . ,FLAT)
  )

Das ,FLAT ist lediglich eine Konstante des Wertes -1/2. Entsprechend gibt es auch ,SHARP usw.

Funktion, die Skalen/Tonleitern erzeugt

Die genannten Tonarten Moll, Dur, Kirchentonarten sind schon vordefiniert, aber es lassen sich auch nach diesem Muster beliebige Skalen definieren.
Als Beispiel möchte ich eine Moll-Pentatonik (!) erzeugen - die hat die Besonderheit, dass statt der 7 eben nur 5 Töne in der Skala vorkommen. Sie soll \minor-pentatonic heißen.
Genauso wären aber auch chromatische Tonleitern (mit 12 Tönen), Ganztonleitern (mit 6 Tönen) usw. machbar.

Zunächst einmal das Beispiel-Coding incl. Moll-Pentatonik-Definition, Funktion und zwei Beispiel-Tonleitern.
Das kannst Du mit Copy&Paste in Frescobaldi eintragen und ausführen:

Code:

\version "2.22.0"

minor-pentatonic = #`((0 . 0)
                      (2 . ,FLAT)
                      (3 . 0)
                      (4 . 0)
                      (6 . ,FLAT))

play-scale =
#(define-music-function
  (parser location tonika anz-okt skala)
  (ly:pitch? number? list?)
  (let ((anz-stufen (length skala)))
    (ly:music-transpose
     (make-sequential-music
      (map (lambda (x)
             (let* ((pitch (list-ref skala (remainder x anz-stufen))))
               (make-event-chord
                (list
                 (make-music 'NoteEvent
                   'duration (ly:make-duration 2 0 1/1)
                   'pitch (ly:make-pitch
                           (quotient x anz-stufen)
                           (car pitch)
                           (cdr pitch)))))))
        (append (iota (* anz-okt anz-stufen))
          (reverse (iota (+ (* anz-okt anz-stufen) 1))))))
     tonika)))


\play-scale c' 1 \dorian
\play-scale b 2 \minor-pentatonic

Funktionsaufruf

Die Funktion \play-scale benötigt drei Parameter:

den Grundton, bei dem die Skala beginnen soll. Er ist gleichzeitig Start-Ton (Oktavlage wird berücksichtigt!) und Tonika der Skala
die Anzahl der Oktaven, (also 1, 2, 3, ...) über die die Skala gespielt werden soll
schließlich die zu nutzende Skala.

Beispiel-Anwendungen

Es soll eine dorische Tonleiter mit Grundton c über eine Oktave ausgegeben werden.
Aufruf: \play-scale c' 1 \dorian

Es soll die selbstdefinierte Moll-Pentatonik mit Grundton h über zwei Oktaven ausgebeben werden.
Aufruf: \play-scale b 2 \minor-pentatonic

Coding-Erläuterungen

Die Sprache Scheme ist, wie Lisp, extrem Listenorientiert.

Skala
Die genutzten Skalen sind, technisch gesehen, Listen von Paaren. Jedes Paar entspricht einem Ton und besteht jeweils aus dem "Stammton" 0 bis 6, entsprechend c bis h und einer Alteration (einem Versetzungszeichen).

Um die Skala, die ja grundsätzlich auf Grundton 0 (c) aufbaut, auf den neuen Grund- und Startton (mit Oktavlage!) zu transponieren, kommt der Standard-Befehl ly:music-transpose mit den beiden Paramtern "erzeugte Tonleiter mit Grundton c" und dem eigentlich gewünschten Grundton tonika zum Einsatz. Eigentlich ganz einfach.

"Tonnummer" der Skala
Die Tonnummer bzw. der Index der Skala (beginnend bei 0) soll der Nummer des Elements entsprechen.
Im Originalen Zufalls-Beispiel wurde deshalb immer der Rest bei Teilung durch 7 genutzt.
Wir wollen aber allgemein alle möglichen Skalen nutzen können.
Deshalb habe ich die Variable anz-stufen eingeführt, die einfach auf die Anzahl der Elemente (length skala) der genutzten Skalen-Liste skala gesetzt wird.
Die beiden Komponenten Stammton und Versetzungszeichen werden dann aus der Skalen-Liste gelesen und der Zugriff erfolgt über die Tonnummer:
(pitch (list-ref skala (remainder x anz-stufen)))
Der Variablen pitch (Name etwas unglücklich gewählt, weil die Oktavlage fehlt) wird das so-und-sovielte Element aus des Skala zugewiesen, bestehend aus einem Stammton-/Versetzungszeichen-Paar.

Auf- und absteigende Tonfolge

Der Befehl (iota 5) erzeugt eine Liste mit fünf Elementen, bestehend aus aufsteigenden ganzen Zahlen und beginnend bei 0.
Da unsere Skala anz-stufen Töne enthält, wird anz-stufen mit der Anzahl zu erzeugender Oktaven anz-okt multipliziert und der iota-Befehl erzeugt bequem eine entprechende Liste (0 1 2 3 ...).
Da die Tonleiter aber auch wieder rückwärts gespielt werden soll, kommt das ganze nochmal rückwärts (reverse), aber sogar not mit einem Ton mehr, damit die volle Oktave erreicht wird. Per append werden schließlich die beiden Teil-Listen aneinandergehängt.

Du siehst - es geht immer um Listen.

Das alles lässt sich natürlich nicht so einfach aus dem Handgelenk schütteln, aber man ist eben völlig flexibel und es ist praktisch nichts unmöglich.

Viele Grüße
Torsten

Akkofant · 14.03.21

Herzlichen Dank für die ausführlichen Erklärungen!

Ich verstehe grundsätzlich, wie es gemeint ist, es hapert bei mir trotzdem an der Anwendung, weil ich mit der Computersprache nicht vertraut bin.
Für den Anfang ist es wahrscheinlich ein bisschen viel auf einmal. Ich weiß auch gar nicht, ob ich so tief in die Materie einsteigen möchte. Es macht mir aber auf jeden Fall total Spaß innerhalb meiner Möglichkeiten damit rumzuspielen!

Mit dem Zufallsschnipsel aus dem Handbuch habe ich ein bisschen rumprobiert.

Für meinen Zweck wollte ich erstmal folgendes:
- es beginnt immer mit dem selben bekannten Ton (hier c)
- nach einem Takt Zufallsnoten folgt ein Takt Pause (zum Echospielen)
- der nächste Takt beginnt mit der selben Tonhöhe, in der der vorletzte Takt endete
( Das Echo ist für mich dann erstmal einfacher umzusetzen)
- ein bisschen rhytmische Abwechslung, damit es mehr Spaß macht
( Mit der Aneinanderreihung der Schnipsel ist es kein zufälliger Rhythmus, sondern immer das gleiche Muster. Das stört mich erstmal nicht, weil es mir hauptsächlich ums Hören und Umsetzen der Tonhöhenintervalle geht)

Habe viele Midiinstrumente ausprobiert, klang alles superkünstlich (wahrscheinlich noch verstärkt durch die nicht so eingängigen Zufallsmelodien). Bin dann bei „celesta“ gelandet, das funktioniert für mich klanglich.

Es ist nicht so einfach, abwechslungsreiche Tonfolgen mit nicht zu großen Tonhöhenintervallen zu erhalten.

Hier mein Versuch:

Code:

\version "2.22.0"

\score {
 
  {
    
    \tempo 4 = 120
    
    \set Staff.midiInstrument = "celesta"
 
 c''2
 
 $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 6 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration  1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 12)
                                        0))))))
              (make-list 1))))
 
 r1
 
 $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 6 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration  1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 12)
                                        0))))))
              (make-list 1))))
  
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 8 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 12)
                                        0))))))
              (make-list 1))))
  
   r1 
  
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 8 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration  1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 12)
                                        0))))))
              (make-list 1))))
  
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 5)
                                        (remainder idx 11)
                                        0))))))
              (make-list 1))))
  
   r1
  
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 5)
                                        (remainder idx 11)
                                        0))))))
              (make-list 3))))
    
 $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 10)
                                        0))))))
              (make-list 1))))
  
   r1
  
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 10)
                                        0))))))
              (make-list 1))))
    
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 8)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 7 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
 
  r1
 
 $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 7 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 7)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 11)
                                        (remainder idx 33)
                                        0))))))
              (make-list 2))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 4 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 33)
                                        0))))))
              (make-list 1))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 33)
                                        0))))))
              (make-list 1))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 8 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 12)
                                        (remainder idx 10)
                                        0))))))
              (make-list 1))))
 
  r1
 
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 8 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 12)
                                        (remainder idx 10)
                                        0))))))
              (make-list 2))))
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 3 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
 
   r1
 
  $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 3 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
 
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 4))))
    
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 10 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 12)
                                        0))))))
      
        (make-list 1))))
  
    r1
    
     $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 10 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 12)
                                        0))))))
      
        (make-list 1))))
    
     $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
    
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5
                             random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 12)
                                        0))))))
        
        (make-list 2))))
  
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5
                             random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 12)
                                        0))))))
      
        (make-list 1))))
  
    r1
      
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5
                             random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 10)
                                        (remainder idx 12)
                                        0))))))
      
        (make-list 1))))
    
   $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 13 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
    
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 6)
                                        (remainder idx 8)
                                        0))))))
              (make-list 1))))
    
   r1
  
     $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 2 1 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 6)
                                        (remainder idx 8)
                                        0))))))
              (make-list 1))))
    
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 5 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 3 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
    
  
    
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 1 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
    
    $(let ((random-state (seed->random-state (current-time))))
       (make-sequential-music
         (map (lambda (x)
                (let ((idx (random 9 random-state)))
                  (make-event-chord
                   (list
                    (make-music 'NoteEvent
                                'duration (ly:make-duration 0 0 1/1)
                                'pitch (ly:make-pitch
                                        (quotient idx 9)
                                        (remainder idx 7)
                                        0))))))
              (make-list 1))))
  
    r1 r     
      
  }
 
   \layout { }
  \midi { }
 
}

Christian_Hofmann · 17.04.21

Hat von euch jemand Erfahrungen mit dem Editor http://www.denemo.org/ gemacht? Die Youtube Videos dazu sind ja ganz nett und wirken so als ob man hier recht gut eine IDE mit Lilypond nutzen könnte. Aber nach meinen Leidvollen Erfahrungen mit Frescobaldi habe ich das Projekt LilyPond erst einmal beendet da ein schlechten Notenblatt aus MuseScore immer noch besser ist als gar kein Notenblatt in LilyPond. Wobei eher meine Fähigkeiten hier das Problem sind

Christoph1 · 17.04.21

Christian_Hofmann schrieb:
... Aber nach meinen Leidvollen Erfahrungen mit Frescobaldi ...

Worin bestand da ein Leid?

Be-3 · 17.04.21

Christoph1 schrieb:
Worin bestand da ein Leid?

Das würde mich jetzt auch mal interessieren.
Frescobaldi ist ja nicht "schuld" an der LilyPond-Syntax, sondern hilft viel eher durch Syntax-Highlighting, automatische Ergänzung und Navigationsmöglichkeit: Durch Anklicken kommt man direkt von eine Code-Stelle zur entsprechenden Notendarstellung im der Vorschau und umgekehrt.

Wenn man allerdings allgemein mit textbasierter Eingabe nichts anfangen kann, wird LilyPond nicht die richtige Wahl sein.

Bei mir ist es umgekehrt, mir geht die Maus-Klickerei und der ständige Wechsel zwischen Maus und Tastatur mit ständigem Blick auf den Bildschirm bei grafisch orientieren Programmen auf die Nerven. Gut, es gibt auch Keyboard-Shortcuts, aber ich bin LilyPond einfach völlig verfallen.

Christian_Hofmann schrieb:
Hat von euch jemand Erfahrungen mit dem Editor http://www.denemo.org/ gemacht?

Ich habe früher mal mit Rosegarden, Denemo usw. experimentiert und mir gerade sogar anlässlich Deiner Nachfrage das aktuelle Denemo 2.5 installiert. Damit komme ich wiederum nicht zurecht.

Christian_Hofmann schrieb:
ein schlechten Notenblatt aus MuseScore immer noch besser ist als gar kein Notenblatt in LilyPond.

... wobei ich bei aller Liebe zu LilyPond sagen muss, dass MuseScore keinesfalls schlechte Ergebnisse produziert. Dieses Programm ist mittlerweile richtig gut geworden und die Qualität des erzeugten Notensatzes hängt generell eher mit dem Menschen zusammen als mit dem Programm. Bei allen Programmen muss man eingreifen, denn wer sich allein auf Automatik verlässt, wird niemals ein professionelles Ergebnis erzielen. Auch nicht mit LilyPond. Oder Dorico.
Was Finale und Sibelius gerade bei polyphoner Musik fabrizieren (Überlappungen usw.) ist ja schon nicht mehr feierlich. Trotzdem lassen sich professionelle Ergebnisse erzielen, wenn man (manuell) korrigierend eingreift. Für vieles gibt es auch Plug-Ins.

Stell doch mal ein kleines Beispiel ein, dann könnte man MuseScore, LilyPond und vielleicht Dorico oder so vergleichen.

Ich gehe mal davon aus, dass Du als Orgler besonders unter den Tücken der Polyphonie zu leiden hast - da wird es immer leicht unübersichtlich.

Aber - wie gesagt/gefragt: Was sind Deine konkreten Probleme mit LilyPond?

Viele Grüße
Torsten

Christian_Hofmann · 17.04.21

Be-3 schrieb:
Ich gehe mal davon aus, dass Du als Orgler besonders unter den Tücken der Polyphonie zu leiden hast - da wird es immer leicht unübersichtlich.

Genau das ist der Punkt an dem ich verzweifelt bin. Unterschiedliche Takte. Während ein Choralsatz nich geht bin ich bei dem Versuch einer Fuge komplett gescheitert. Ich setze mich die kommenden Tage mal hin und schaue mal wie ich zurecht komme und teile dann mein Ergebnis gerne mal.

Be-3 · 17.04.21

Christian_Hofmann schrieb:
Während ein Choralsatz nich geht bin ich bei dem Versuch einer Fuge komplett gescheitert.

Genau so hab ich mir das vorgestellt.

Choralsätze, die streng vierstimmig sind und brav Sopran/Alt und Bass/Tenor ordentlich separat auf die beiden Systeme und immer dort immer zweistimmig (mit entgegengesetzten Halsrichtungen) haben, sind eigentlich überall recht komfortabel zu setzen.

Aber in Fugen, wo praktisch alles passieren kann und sich die Situation ständig ändert, geht's ans Eingemachte.
Aber auch dort kann man sich eine "Strategie" zurechtlegen, mit der sich ziemlich flexibel alles handhaben lässt.

Ist der Stein des Anstoßes eine althergebrachte Fuge (wenn ja: welche?) oder ein eigenes Werk?
Würde mich interessieren, dann könnte man Ansätze/Ergebnisse vergleichen - auch mit dem, was die alten Meister (Notenstecher, nicht Komponisten) daraus gemacht haben.

Viele Grüße
Torsten

PS: Nicht, dass ich missionieren möchte, aber vielleicht kann man den Knoten zum Platzen bringen.

Christian_Hofmann · 17.04.21

So, jetzt geht es schon los. Ich habe mal eine kleine Melodie übernommen direkt in Denemo was erstaunlich gut und flott ging. Nun will ich eine zweite Stimme einfügen diese soll im ersten Takt nur 16. spielen und zuerst über dem d sein beim kommenden a unter diesem weiterspielen. Vermutlich müsste das d dann zweite Stimme werden und die erste ist oben. Ab dem a wäre die zweite Stimme ja wieder unten,,,

Aber ich schaffe es im Moment nicht einmal eine zweite Stimme hinzubekommen. Schande über mich... So viele Menüs die mir so wenig sagen was sie tun

Be-3 · 18.04.21

Christian_Hofmann schrieb:
Aber ich schaffe es im Moment nicht einmal eine zweite Stimme hinzubekommen. Schande über mich... So viele Menüs die mir so wenig sagen was sie tun

Ja, so ähnlich geht's mir mit Denemo auch. Ich glaube, da müssen die separaten Stimmen in separaten Systemen eingegeben werden, die dann in der Ausgabe wieder kombiniert werden. :eek:

Verstehe ich momentan auch nicht so recht.

Aha, da ist es wieder: "Hilf, Herr, meines Lebens".

Ich würde in einem solchen Fall in LilyPond für jede Stimme eine eigene \Voice definieren.

Zum Beispiel für das obere System (aber nicht in Stein gemeißelt) \RHa und \RHb wie "Rechte Hand a und b".
Diese beiden Voices dann in einem \Staff kombinieren (parallele Inhalte immer in << >> einschließen).
Und zwar ohne die "Abkürzung" \\ zwischen den Voices, dann ist man nämlich flexibel und kann zwischen \oneVoice ("normale" Einzelstimme) oder \voiceOne, \voiceTwo, \voiceThree usw. jederzeit wechseln.

Wenn ich einfach mal die beiden ersten Takte betrachte und die Sechzehntelbewegung, die Du im Musik-im-Kopf-Thread gepostet hast (nur eben jetzt in d-Moll statt e-Moll) als 1. Stimme (\RHa} über die Choralmelodie (\RHb) schreibe, streng polyphon mit den Hälsen nach oben in der 1. Stimme und den Hälsen nach unten in der 2. Stimme, sieht das so aus.

Mit dem LilyPond-Code

Code:

\version "2.22.0"

RHa = \relative {
  \key d \minor
  \voiceOne
  \repeat unfold 3 { d''16 a' bes a } d, g a g |
  \repeat unfold 4 { d16 a' bes a } |
}

RHb = \relative {
  \key d \minor
  \voiceTwo
  d'4 a' a g |
  a2 a |
}

\score {
  \new Staff <<
    \new Voice \RHa
    \new Voice \RHb
  >>
  \layout {}
  \midi {}
}

Dabei habe ich mir den Spaß erlaubt, die sich wiederholende 16tel-Figur mit \repeat unfold zu vervielfältigen.
Im Code ist überhaupt nichts besonderes, außer, dass der ersten Stimme \voiceOne zugewiesen wird und der zweiten Stimme \voiceTwo.
Ich fange grundsätzlich für jeden Takt eine neue Zeile an und setze am Ende immer |, damit geprüft wird, ob die Takte "aufgehen" oder ob ich einen rhythmischen Fehler eingebaut habe.

Viele Grüße
Torsten

Lilypond Userthread

Beiträge mit meisten Reaktionen

Quick Links

Capella: Balken und Bogen vom System der linken auf die rechten Hand.

TuxGuitar - Tonarten und Versetzungszeichen benutzen

Songbook +, BauMSoftware