GNU LilyPond – Manuel de notation: 1.1.2 Modification de plusieurs hauteurs

### 1.1.2 Modification de plusieurs hauteurs

Cette partie traite de la manière de modifier les hauteurs de note.

#### Vérifications d’octave

Les tests d’octave rendent la correction d’erreurs d’octave plus facile dans le mode d’octave `relative` – un `,` ou un `'` oublié, ça n’arrive pas qu’aux autres !

Une note peut être suivie de `=`apostrophes/virgules pour indiquer à quelle octave absolue elle devrait être. Dans l’exemple suivant, le premier `d` générera un avertissement, puisqu’on attend un `d''` – intervalle inférieur à la quarte – mais qu’on obtient un `d'`. Sur la partition, l’octave sera corrigée pour donner un `d'` et la prochaine note sera calculée en fonction de ce `d'` et non de `d''`.

>     \relative c'' {
>       c2 d='4 d
>       e2 f
>     }

Il existe aussi une vérification d’octave qui ne produit pas de musique imprimée, ayant pour syntaxe `\octaveCheck` hauteur_référence – `hauteur_référence` étant spécifiée en mode absolu. Cette commande vérifie que l’intervalle entre la note qui précède et `hauteur_référence` est inférieur à la quinte comme il se doît en mode relatif. Dans le cas contraire, un message sera émis et la note précédente ne sera pas modifiée. Les notes suivantes seront, par contre, positionnées relativement à `hauteur_référence`.

>     \relative c'' {
>       c2 d
>       \octaveCheck c'
>       e2 f
>     }

Dans les deux mesures qui suivent, les premier et troisième `\octaveCheck` échouent, mais le deuxième est concluant.

>     \relative c'' {
>       c4 f g f

>       c4
>       \octaveCheck c'
>       f
>       \octaveCheck c'
>       g
>       \octaveCheck c'
>       f
>     }

#### Voir aussi

Morceaux choisis : Hauteurs.

Référence des propriétés internes : RelativeOctaveCheck.

#### Transposition

Une expression musicale peut être transposée avec `\transpose`. En voici la syntaxe :

>     \transpose note_de_départ note_d_arrivée expression_musicale

Cela signifie que `expression_musicale` est transposé de l’intervalle séparant `note_de_départ` et `note_d_arrivée` : toute note dont la hauteur était `note_de_départ` est changée en `note_d_arrivée` ; les autres notes seront changées selon le même intervalle. Les deux hauteurs s’expriment en octave absolue.

Note : La musique contenue dans un bloc `\transpose` est en octaves absolus, sauf à inclure dans ce même bloc une clause `\relative`.

Prenons comme exemple une pièce écrite en ré majeur. Si cette pièce est un peu trop basse pour l’interprète, elle peut être transposée en mi majeur. Vous noterez que l’armure est automatiquement modifiée.

>     \transpose d e {
>       \relative c' {
>         \key d \major
>         d4 fis a d
>       }
>     }

Regardons maintenant une partie écrite pour violon – un instrument en ut. Si cette partie doit être jouée par une clarinette en la (écrite à la tierce mineure supérieure, un do écrit donnant un la réel), la transposition suivante créera la partie appropriée.

>     \transpose a c' {
>       \relative c' {
>         \key c \major
>         c4 d e g
>       }
>     }

La présence de `\key c \major` s’explique par le fait que, bien que les notes soient effectivement transposées, l’armure ne sera imprimée que dans la mesure où elle est explicitement mentionnée.

`\transpose` fait la distinction entre les notes enharmoniques : `\transpose c cis` et `\transpose c des` transposeront la pièce un demi-ton plus haut, au détail près que la première version écrira des dièses et la deuxième des bémols.

>     music = \relative c' { c d e f }
>     \new Staff {
>       \transpose c cis { \music }
>       \transpose c des { \music }
>     }

On peut aussi utiliser `\transpose` pour entrer des notes écrites pour un instrument transpositeur. Normalement, les hauteurs dans LilyPond sont écrites en ut, c’est à dire en sons réels, mais elles peuvent être écrites dans un autre ton. Prenons l’exemple d’un morceau pour trompette en si bémol commençant sur un ré à l’oreille ; on pourrait écrire

>     musiqueEnSiBemol = { e4 … }
>     \transpose c bes, \musiqueEnSiBemol

Pour imprimer cette musique en fa – et de ce fait produire une partie de cor au lieu d’un conducteur en notes réelles – on utilisera un deuxième `\transpose` :

>     musiqueEnSiBemol = { e4 … }
>     \transpose f c' { \transpose c bes, \musiqueEnSiBemol }

Pour plus d’information à ce sujet, consultez Instruments transpositeurs.

#### Morceaux choisis

Transposition et réduction du nombrer d’altérations accidentelles

Cet exemple, grâce à un peu de code Scheme, donne la priorité aux enharmoniques afin de limiter le nombre d’altérations supplémentaires. La règle appliquable est :

- Les altérations doubles sont supprimées
- Si dièse -> Do
- Mi dièse -> Fa
- Do bémol -> Si
- Fa bémol -> Mi

Cette façon de procéder aboutit à plus d’enharmoniques naturelles.

>     #(define (naturalize-pitch p)
>        (let ((o (ly:pitch-octave p))
>              (a (* 4 (ly:pitch-alteration p)))
>              ;; alteration, a, in quarter tone steps,
>              ;; for historical reasons
>              (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 (naturalize music)
>        (let ((es (ly:music-property music 'elements))
>              (e (ly:music-property music 'element))
>              (p (ly:music-property music 'pitch)))
>          (if (pair? es)
>              (ly:music-set-property!
>               music 'elements
>               (map (lambda (x) (naturalize x)) es)))
>          (if (ly:music? e)
>              (ly:music-set-property!
>               music 'element
>               (naturalize e)))
>          (if (ly:pitch? p)
>              (begin
>                (set! p (naturalize-pitch p))
>                (ly:music-set-property! music 'pitch p)))
>          music))

>     naturalizeMusic =
>     #(define-music-function (parser location m)
>        (ly:music?)
>        (naturalize m))

>     music = \relative c' { c4 d e g }

>     \score {
>       \new Staff {
>         \transpose c ais { \music }
>         \naturalizeMusic \transpose c ais { \music }
>         \transpose c deses { \music }
>         \naturalizeMusic \transpose c deses { \music }
>       }
>       \layout { }
>     }

#### Voir aussi

Manuel de notation : Octaves relatives, Instruments transpositeurs.

Morceaux choisis : Hauteurs.

Référence des propriété internes : TransposedMusic.

#### Problèmes connus et avertissements

Si vous voulez utiliser en même temps `\transpose` et `\relative`, vous devez mettre `\transpose` en dehors de `\relative`, puisque `\relative` n’aura aucun effet sur la musique apparaissant dans un `\transpose`.

Autres langues : English, deutsch, español, 日本語.

#### LilyPond — Manuel de notation