Notation relative

Bonjour !
Est-ce que l'un d'entre vous aurait des piste pour entrer la musique de manière relative ?
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

À quel niveau cela se passe-t-il ? J'imagine qu'il y a une fonction qui vient extraire les informations du texte, peut-être il est possible de la remplacer par autre personnalisé ?
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.
Est-il possible de récupérer la dernière note joué dans une fonction Scheme ?

Merci !
Baptiste

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.

curves.ly (2.46 KB)

···

On 4/9/20, Baptiste Geay <****@****> wrote:

Bonjour !

Merci, ça fait plaisir de voir que d'autres ont déjà chercher à faire ça ! C'est vrai qu'intervenir au niveau du parseur me paraît un peu trop complexe. Finalement j'ai opté pour une autre solution : plutôt que d'écrire directement les intervalles dans le fichier lilypond, je laisse Emacs trouver la bonne note en fonction de la note précédente, et de l'intervalle que je donne. De cet manière, je peux quand même voir les notes réels dans le fichier, et je n'ai besoin d'appuyer sur qu'une touche par note avec la disposition suivante :

     Descendant Ascendant
[6M] [6m] [5t] [4t] [4t] [5t] [6m] [6M]
[3M] [3m] [2M] [2m] [2m] [2M] [3m] [3M]
[7M] [7m] [TT] [ 0 ] [TT] [7m] [7M]

Si ça intéresse quelqu'un je joins le fichier elisp.

Baptiste

lyrel.el (2.23 KB)

···

Le 2020-04-10 02:15, Valentin Villenave a écrit :

On 4/9/20, Baptiste Geay <****@****> 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.

Wow, Euh, pourquoi pas en effet ?
Ça demande quand même une disposition d’esprit très particulière…
(dit-il, juste après avoir lui-même posté un gros pavé de code
justement destiné à saisir de la musique d’une façon résolument
tordue)

Vous devriez partager votre code elisp sur la liste angolphone
également, il y a pas mal de LilyPondeurs que ce serait susceptible
d’intéresser…

Nicolas Sceaux avait autrefois un mode de saisie rapide pour Emacs (il
en existe quelques autres aussi) :
http://web.archive.org/web/20100915024339/http://nicolas.sceaux.free.fr/lilypond/lyqi.html

Je crois qu’il utilisait aussi l’entrée MIDI avec le traducteur en
temps réel Rumor:
https://launchpad.net/rumor
http://web.archive.org/web/20120128093909/http://www.volny.cz/smilauer/rumor/rumor.html

Quant à mon propre exemple, je l’ai repris et développé pour le mettre
sur le LSR :
http://lsr.di.unimi.it/LSR/Snippet?id=1105

Cordialement,
V. V.

···

On 4/11/20, Baptiste Geay <****@****> wrote:

Finalement j'ai opté pour une autre solution : plutôt que
d'écrire directement les intervalles dans le fichier lilypond, je laisse
Emacs trouver la bonne note en fonction de la note précédente, et de
l'intervalle que je donne.

Apparemment il y en a d’autres qui aiment les intervalles, si j’en
juge par ce snippet ébouriffant récemment ajouté sur le LSR :
http://lsr.di.unimi.it/LSR/Item?id=1100
https://lists.gnu.org/archive/html/lilypond-user/2019-12/msg00387.html

V.

···

On 4/12/20, Valentin Villenave <****@****> wrote:

Ça demande quand même une disposition d’esprit très particulière…