On 4/9/20, Baptiste Geay <address@hidden> wrote:
Est-ce que l'un d'entre vous aurait des pistes pour entrer la musique
de
manière relative ?
Oui et non.
Plus tôt que d'écrire le nom de la note je voudrais écrire
l'intervalle
qui la sépare de la précédente.
Exemple :
a gs a b cs a b e e
a8 -2m +2m +2M +2M -3M +2M -5 1
Le problème c’est que, au niveau du "parseur" (la partie du programme
qui lit le code .ly en tout premier), les chiffres dans LilyPond ont
une signification bien particulière (durées). Il y a une raison pour
laquelle on oblige les malheureux baroqueux à se taper des <> autour
de chaque chiffre lorsqu’ils veulent saisir une malheureuse basse
chiffrée. Même si on voulait autoriser la possibilité de saisir des
chaînes de caractères, LilyPond pourrait tout à fait les traiter mais
je ne suis pas sûr qu’au moment de la saisie ce soit bien pratique de
devoir mettre des guillemets partout.
D’ailleurs depuis une soixantaine d’années (voire plus, grâce à tonton
Arnold), beaucoup de compositeurs ne s’intéressent plus vraiment aux
questions de seconde augmentée/tierce mineure, mais se contentent de
compter trois demi-tons.
Ou alors peut-être qu'il est possible de faire une fonction Scheme qui
calcule par rapport à la note précédente et qui prend intervalle en
paramètre.
Exactement. Voici typiquement le genre de fonction que je m’amuse à
utiliser :
%%%
\version "2.21.1"
#(define (loop-list-ref ls x)
(let ((z (length ls)))
(list-ref ls (remainder x z))))
#(define semi->pitch
(make-semitone->pitch
(music-pitches
#{ c cis d es e f fis g gis a bes b #})))
#(define (naturalize-pitch p)
(let* ((o (ly:pitch-octave p))
(a (* 4 (ly:pitch-alteration p)))
(n (ly:pitch-notename p)))
(cond
((and (> a 1) (or (eq? n 6) (eq? n 2)))
(set! a (- a 2))
(set! n (+ n 1)))
((and (< a -1) (or (eq? n 0) (eq? n 3)))
(set! a (+ a 2))
(set! n (- n 1))))
(cond
((> a 2) (set! a (- a 4)) (set! n (+ n 1)))
((< a -2) (set! a (+ a 4)) (set! n (- n 1))))
(if (< n 0) (begin (set! o (- o 1)) (set! n (+ n 7))))
(if (> n 6) (begin (set! o (+ o 1)) (set! n (- n 7))))
(ly:make-pitch o n (/ a 4))))
#(define (transpose delta x)
(naturalize-pitch
(ly:pitch-transpose
(semi->pitch delta) x)))
applyDeltas =
#(define-music-function (music numbers)
(ly:music? list?)
(let ((tied? #f)
(prev-pitch '())
(delta-pitch '())
(i 0))
(music-filter
(lambda (m)
(let ((p (ly:music-property m 'pitch)))
(if (not (null? p))
(begin
(if tied?
(ly:music-set-property! m 'pitch prev-pitch)
(begin
(ly:music-set-property! m 'pitch
(transpose (loop-list-ref numbers i)
(if (null? prev-pitch) p prev-pitch)))
(set! i (1+ i))))
(set! tied? #f)
(map
(lambda (j)
(if (music-is-of-type? j 'tie-event)
(set! tied? #t)))
(ly:music-property m 'articulations))
(set! prev-pitch (ly:music-property m 'pitch))))
m))
(unfold-repeats-fully music))))
sequence = { \repeat unfold 16 c'8 c'1-- ~ c'2 c'4-. r }
numbers = #'(3 5 2 -6 -8 11 -13 7 6 -9 5)
\layout { \accidentalStyle Score.dodecaphonic }
\applyDeltas \sequence \numbers
\applyDeltas
{ \time 3/8 \partial 8 <>( \repeat unfold 8 e''16 f8)}
#'(0 -1 1 -1 1 -5 3 -2 -3)
%%%
Et ci-joint une autre "partition" que je me suis beaucoup amusé à
coder il y a quelques années…
Cordialement,
V. V.
lyrel.el