Typo.

[lilypond.git] / Documentation / notation / simultaneous.itely

@c -*- coding: utf-8; mode: texinfo; -*-
@ignore
    Translation of GIT committish: FILL-IN-HEAD-COMMITTISH

    When revising a translation, copy the HEAD committish of the
    version that you are working on.  See TRANSLATION for details.
@end ignore

@c \version "2.12.0"


@node Simultaneous notes
@section Simultaneous notes

@lilypondfile[quote]{simultaneous-headword.ly}

Polyphony in music refers to having more than one voice occurring
in a piece of music.  Polyphony in LilyPond refers to having more
than one voice on the same staff.

@menu
* Single voice::
* Multiple voices::
@end menu


@node Single voice
@subsection Single voice

This section discusses simultaneous notes inside the same voice.

@menu
* Chorded notes::
* Chord repetition::
* Simultaneous expressions::
* Clusters::
@end menu


@node Chorded notes
@unnumberedsubsubsec Chorded notes

@cindex chords
@cindex brackets, angle
@cindex angle brackets
@cindex relative pitch in chords

@funindex <
@funindex >
@funindex <...>

A chord is formed by enclosing a set of pitches between @code{<}
and @code{>}.  A chord may be followed by a duration and/or a set
of articulations, just like simple notes:

@lilypond[verbatim,quote,relative=1]
<c e g>2 <c f a>4-> <e g c>-.
@end lilypond

Relative mode can be used for pitches in chords. The octave of each
pitch is chosen using the preceding pitch as a reference except in
the case of the first pitch in a chord: the reference for the first
pitch is the @emph{first} pitch of the preceding chord.

For more information about chords, see @ref{Chord notation}.

@seealso
Music Glossary:
@rglos{chord}.

Learning Manual:
@rlearning{Combining notes into chords}.

Notation Reference:
@ref{Chord notation}.

Snippets:
@rlsr{Simultaneous notes}.


@node Chord repetition
@unnumberedsubsubsec Chord repetition

In order to save typing, a shortcut can be used to repeat the preceding
chord.  The chord repetition symbol is @code{q}:

@lilypond[verbatim,quote,relative=1]
<c e g> q q q
@end lilypond

As in the case of regular chords, the chord repetition symbol can be
followed by a duration and articulations.  Only the pitches of the
previous chord are duplicated; articulations, dynamics, etc, are not
repeated.

@lilypond[verbatim,quote,relative=1]
<c e g>8\p q q4-| q8.^"text" q16 q4-|
@end lilypond

Note chords (entered using angle brackets) only are memorized in order
to be repeated by @code{q}: it is possible to repeat a chord even if for
instance a simple note (without angle brackets) or a rest have been
entered meanwhile.

@lilypond[verbatim,quote,relative=1]
<c e g>8 c' q c r4 q
@end lilypond

@seealso
Installed Files:
@file{ly/@/chord-repetition-init@/.ly}.


@node Simultaneous expressions
@unnumberedsubsubsec Simultaneous expressions

One or more music expressions enclosed in double angle brackets are
taken to be simultaneous.  If the first expression begins with a
single note or if the whole simultaneous expression appears
explicitly within a single voice, the whole expression is placed on
a single staff; otherwise the elements of the simultaneous
expression are placed on separate staves.

The following examples show simultaneous expressions on one staff:

@lilypond[quote,verbatim,relative=2]
\new Voice {  % explicit single voice
  << { a4 b g2 } { d4 g c,2 } >>
}
@end lilypond

@lilypond[quote,verbatim,relative=2]
% single first note
a << { a4 b g } { d4 g c, } >>
@end lilypond

This can be useful if the simultaneous sections have identical
rhythms, but attempts to attach notes with different durations
to the same stem will cause errors.

The following example shows how simultaneous expressions can
generate multiple staves implicitly:

@lilypond[quote,verbatim,relative=2]
% no single first note
<< { a4 b g2 } { d4 g2 c,4 } >>
@end lilypond

Here different rhythms cause no problems.


@node Clusters
@unnumberedsubsubsec Clusters

@cindex cluster
@cindex note cluster

@funindex \makeClusters
@funindex makeClusters

A cluster indicates a continuous range of pitches to be played.
They can be denoted as the envelope of a set of notes.  They are
entered by applying the function @code{\makeClusters} to a sequence
of chords, e.g.,

@lilypond[quote,relative=2,verbatim]
\makeClusters { <g b>2 <c g'> }
@end lilypond

Ordinary notes and clusters can be put together in the same staff,
even simultaneously.  In such a case no attempt is made to
automatically avoid collisions between ordinary notes and clusters.


@seealso
Music Glossary:
@rglos{cluster}.

Snippets:
@rlsr{Simultaneous notes}.

Internals Reference:
@rinternals{ClusterSpanner},
@rinternals{ClusterSpannerBeacon},
@rinternals{Cluster_spanner_engraver}.


@knownissues

Clusters look good only if they span at least two chords; otherwise
they appear too narrow.

Clusters do not have a stem and cannot indicate durations by
themselves, but the length of the printed cluster is determined by
the durations of the defining chords.  Separate clusters need a
separating rest between them.

Clusters do not produce MIDI output.

@node Multiple voices
@subsection Multiple voices

This section discusses simultaneous notes in multiple voices or
multiple staves.

@menu
* Single-staff polyphony::
* Voice styles::
* Collision resolution::
* Automatic part combining::
* Writing music in parallel::
@end menu


@node Single-staff polyphony
@unnumberedsubsubsec Single-staff polyphony

@cindex single-staff polyphony
@cindex polyphony, single-staff
@cindex voice
@cindex lyrics assigned to one voice

@funindex \voiceOne
@funindex voiceOne
@funindex \voiceOne ... \voiceFour
@funindex Voice
@funindex \oneVoice
@funindex oneVoice

@strong{@i{Explicitly instantiating voices}}

The basic structure needed to achieve multiple independent
voices in a single staff is illustrated in the following example:

@lilypond[quote,relative=3,verbatim]
\new Staff <<
  \new Voice = "first"
    { \voiceOne r8 r16 g e8. f16 g8[ c,] f e16 d }
  \new Voice= "second"
    { \voiceTwo d16 c d8~ d16 b c8~ c16 b c8~ c16 b8. }
>>
@end lilypond

@noindent
Here, voices are instantiated explicitly and are given names. The
@code{\voiceOne} ... @code{\voiceFour} commands set up the voices
so that first and third voices get stems up, second and fourth
voices get stems down, third and fourth voice note heads are
horizontally shifted, and rests in the respective voices are
automatically moved to avoid collisions.  The @code{\oneVoice}
command returns all the voice settings to the neutral default
directions.

@strong{@i{Temporary polyphonic passages}}

A temporary polyphonic passage can be created with the following
construct:

@example
<< @{ \voiceOne ... @}
  \new Voice @{ \voiceTwo ... @}
>> \oneVoice
@end example

@noindent
Here, the first expression within a temporary polyphonic passage is
placed into the @code{Voice} context which was in use immediately
before the polyphonic passage, and that same @code{Voice} context
continues after the temporary section.  Other expressions within
the angle brackets are assigned to distinct temporary voices.
This allows lyrics to be assigned to one continuing voice before,
during and after a polyphonic section:

@lilypond[quote, verbatim, relative=2]
<<
  \new Voice = "melody" {
    a4
    <<
      {
        \voiceOne
        g f
      }
      \new Voice {
        \voiceTwo
        d2
      }
    >>
    \oneVoice
    e4
  }
  \new Lyrics \lyricsto "melody" {
  This is my song.
  }
>>
@end lilypond

@noindent
Here, the @code{\voiceOne} and @code{\voiceTwo} commands are
required to define the settings of each voice.

@strong{@i{The double backslash construct}}

The @code{<< @{...@} \\ @{...@} >>} construct, where the two (or
more) expressions are separated by double backslashes, behaves
differently to the similar construct without the double backslashes:
@emph{all} the expressions within this contruct are assigned
to new @code{Voice} contexts.  These new @code{Voice} contexts
are created implicitly and are given the fixed names @code{"1"},
@code{"2"}, etc.

The first example could be typeset as follows:

@lilypond[quote,relative=3,verbatim]
<<
  { r8 r16 g e8. f16 g8[ c,] f e16 d }
  \\
  { d16 c d8~ d16 b c8~ c16 b c8~ c16 b8. }
>>
@end lilypond

This syntax can be used where it does not matter that temporary
voices are created and then discarded.  These implicitly created
voices are given the settings equivalent to the effect of the
@code{\voiceOne} ... @code{\voiceFour} commands, in the order in
which they appear in the code.

In the following example, the intermediate voice has stems up,
therefore we enter it in the third place, so it becomes voice
three, which has the stems up as desired.  Spacer rests are
used to avoid printing doubled rests.

@lilypond[quote,relative=3,verbatim]
<<
  { r8 g g  g g f16 ees f8 d }
  \\
  { ees,8 r ees r d r d r }
  \\
  { d'8 s c s bes s a s }
>>
@end lilypond

In all but the simplest works it is advisable to create explicit
@code{Voice} contexts as explained in @rlearning{Contexts and engravers} and
@rlearning{Explicitly instantiating voices}.

@strong{@i{Identical rhythms}}

In the special case that we want to typeset parallel pieces of music
that have the same rhythm, we can combine them into a single
@code{Voice} context, thus forming chords.  To achieve this, enclose
them in a simple simultaneous music construct within an explicit voice:

@lilypond[quote,relative=2,verbatim]
\new Voice <<
  { e4 f8 d e16 f g8 d4 }
  { c4 d8 b c16 d e8 b4 }
>>
@end lilypond

This method leads to strange beamings and warnings if the pieces of
music do not have the same rhythm.


@predefined
@code{\voiceOne},
@code{\voiceTwo},
@code{\voiceThree},
@code{\voiceFour},
@code{\oneVoice}.
@endpredefined


@seealso
Learning Manual:
@rlearning{Voices contain music},
@rlearning{Explicitly instantiating voices}.

Notation Reference:
@ref{Percussion staves},
@ref{Invisible rests},
@ref{Stems}.

Snippets:
@rlsr{Simultaneous notes}.


@node Voice styles
@unnumberedsubsubsec Voice styles

@cindex voice styles
@cindex styles, voice
@cindex coloring voices
@funindex \voiceOneStyle
@funindex \voiceTwoStyle
@funindex \voiceThreeStyle
@funindex \voiceFourStyle
@funindex \voiceNeutralStyle

Voices may be given distinct colors and shapes, allowing them to be
easily identified:

@lilypond[quote,relative=2,verbatim]
<<
  { \voiceOneStyle d4 c2 b4 }
  \\
  { \voiceTwoStyle e,2 e }
  \\
  { \voiceThreeStyle b2. c4 }
  \\
  { \voiceFourStyle g'2 g }
>>
@end lilypond

The @code{\voiceNeutralStyle} command is used to revert to the
standard presentation.


@predefined
@code{\voiceOneStyle},
@code{\voiceTwoStyle},
@code{\voiceThreeStyle},
@code{\voiceFourStyle},
@code{\voiceNeutralStyle}.
@endpredefined


@seealso
Learning Manual:
@rlearning{I'm hearing Voices},
@rlearning{Other sources of information}.

Snippets:
@rlsr{Simultaneous notes}.


@node Collision resolution
@unnumberedsubsubsec Collision resolution

@cindex merging notes
@cindex note collisions
@cindex collisions
@cindex shift note
@cindex multiple voices
@cindex voices, multiple
@cindex polyphonic music
@cindex shifting voices
@cindex voices, multiple
@cindex shift rest, automatic
@funindex \shiftOn
@funindex shiftOn
@funindex \shiftOnn
@funindex shiftOnn
@funindex \shiftOnnn
@funindex shiftOnnn
@funindex \shiftOff
@funindex shiftOff
@funindex \mergeDifferentlyDottedOn
@funindex mergeDifferentlyDottedOn
@funindex \mergeDifferentlyDottedOff
@funindex mergeDifferentlyDottedOff
@funindex \mergeDifferentlyHeadedOn
@funindex mergeDifferentlyHeadedOn
@funindex \mergeDifferentlyHeadedOff
@funindex mergeDifferentlyHeadedOff

The note heads of notes in different voices with the same pitch,
same note head and opposite stem direction are automatically
merged, but notes with different note heads or the same stem
direction are not.  Rests opposite a stem in a different voice
are shifted vertically.  The following example shows three
different circumstances, on beats 1 and 3 in bar 1 and beat 1
in bar 2, where the automatic merging fails.

@lilypond[quote,verbatim,relative=2]
<<
  {
    c8 d e d c d c4
    g'2 fis
  } \\ {
    c2 c8. b16 c4
    e,2 r
  } \\ {
    \oneVoice
    s1
    e8 a b c d2
  }
>>
@end lilypond

Notes with different note heads may be merged, with the
exception of half-note heads and quarter-note heads, as shown
below.  Here the note heads on beat 1 of bar 1 are now merged:

@lilypond[quote,verbatim,relative=2]
<<
  {
    \mergeDifferentlyHeadedOn
    c8 d e d c d c4
    g'2 fis
  } \\ {
    c2 c8. b16 c4
    e,2 r
  } \\ {
    \oneVoice
    s1
    e8 a b c d2
  }
>>
@end lilypond

Note heads with different dots as shown in beat 2 of bar 1 may be
also be merged:

@lilypond[quote,relative=2,verbatim]
<<
  {
    \mergeDifferentlyHeadedOn
    \mergeDifferentlyDottedOn
    c8 d e d c d c4
    g'2 fis
  } \\ {
    c2 c8. b16 c4
    e,2 r
  } \\ {
    \oneVoice
    s1
    e8 a b c d2
  }
>>
@end lilypond


The half note and eighth note at the start of the second measure
are incorrectly merged because the automatic merge cannot
successfully complete the merge when three or more notes line up in
the same note column, and in this case the merged note head is
incorrect.  To allow the merge to select the correct note head
a @code{\shift} must be applied to the note that should not be
merged.  Here, @code{\shiftOn} is applied to move the top
@notation{g} out of the column, and @code{\mergeDifferentlyHeadedOn}
then works properly.

@lilypond[quote,relative=2,verbatim]
<<
  {
    \mergeDifferentlyHeadedOn
    \mergeDifferentlyDottedOn
    c8 d e d c d c4
    \shiftOn
    g'2 fis
  } \\ {
    c2 c8. b16 c4
    e,2 r
  } \\ {
    \oneVoice
    s1
    e8 a b c d2
  }

>>
@end lilypond

The @code{\shiftOn}, @code{\shiftOnn}, and @code{\shiftOnnn}
commands specify the degree to which chords of the current voice
should be shifted.  The outer voices (normally: voices one and
two) have @code{\shiftOff}, while the inner voices (three and
four) have @code{\shiftOn}.  @code{\shiftOnn} and
@code{\shiftOnnn} define further shift levels.

Notes are only merged if they have opposing stem directions (as
they have, for example, in voices one and two by default or when
the stems are explicitly set in opposite directions).


@predefined
@code{\mergeDifferentlyDottedOn},
@code{\mergeDifferentlyDottedOff},
@code{\mergeDifferentlyHeadedOn},
@code{\mergeDifferentlyHeadedOff}.

@code{\shiftOn},
@code{\shiftOnn},
@code{\shiftOnnn},
@code{\shiftOff}.
@endpredefined


@snippets

@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
{additional-voices-to-avoid-collisions.ly}

@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
{forcing-horizontal-shift-of-notes.ly}


@seealso
Music Glossary:
@rglos{polyphony}.

Learning Manual:
@rlearning{Multiple notes at once},
@rlearning{Voices contain music},
@rlearning{Real music example}.

Snippets:
@rlsr{Simultaneous notes}.

Internals Reference:
@rinternals{NoteColumn},
@rinternals{NoteCollision},
@rinternals{RestCollision}.


@knownissues

@ignore
@c TODO investigate! Sometimes it works, sometimes not. --FV
The requirements for successfully merging different note heads that
are at the same time differently dotted are not clear.
@end ignore

There is no support for chords where the same note occurs with
different accidentals in the same chord.  In this case, it is
recommended to use enharmonic transcription, or to use special
cluster notation (see @ref{Clusters}).


@node Automatic part combining
@unnumberedsubsubsec Automatic part combining

@cindex automatic part combining
@cindex part combiner
@cindex combining parts
@cindex a due part
@cindex solo part
@funindex \partcombine
@funindex partcombine

Automatic part combining is used to merge two parts of music onto
a staff.  It is aimed at typesetting orchestral scores.  When the
two parts are identical for a period of time, only one is shown.
In places where the two parts differ, they are typeset as separate
voices, and stem directions are set automatically.  Also, solo and
@notation{a due} parts are identified and marked by default.

The syntax for part combining is:

@example
\partcombine @var{musicexpr1} @var{musicexpr2}
@end example

The following example demonstrates the basic functionality of the
part combiner: putting parts on one staff and setting stem
directions and polyphony.  The same variables are used for the
independent parts and the combined staff.

@lilypond[quote,verbatim]
instrumentOne = \relative c' {
  c4 d e f
  R1
  d'4 c b a
  b4 g2 f4
  e1
}

instrumentTwo = \relative g' {
  R1
  g4 a b c
  d c b a
  g f( e) d
  e1
}

<<
  \new Staff \instrumentOne
  \new Staff \instrumentTwo
  \new Staff \partcombine \instrumentOne \instrumentTwo
>>
@end lilypond

The notes in the third measure appear only once, although they were
specified in both parts.  Stem, slur, and tie directions are set
automatically, depending whether there is a solo or unison.  When
needed in polyphony situations, the first part (with context called
@code{one}) always gets up stems, while the second (called @code{two})
always gets down stems.  In solo situations, the first and second
parts get marked with @q{Solo} and @q{Solo II}, respectively.  The
unisono (@notation{a due}) parts are marked by default with the text
@qq{a2}.

Both arguments to @code{\partcombine} will be interpreted as
@code{Voice} contexts.  If using relative octaves,
@code{\relative} should be specified for both music expressions,
i.e.,

@example
\partcombine
  \relative @dots{} @var{musicexpr1}
  \relative @dots{} @var{musicexpr2}
@end example

@noindent
A @code{\relative} section that is outside of @code{\partcombine}
has no effect on the pitches of @var{musicexpr1} and
@var{musicexpr2}.

@snippets

@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
{combining-two-parts-on-the-same-staff.ly}

@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
{changing-partcombine-texts.ly}


@seealso
Music Glossary:
@rglos{a due},
@rglos{part}.

Notation Reference:
@ref{Writing parts}.

Snippets:
@rlsr{Simultaneous notes}.

Internals Reference:
@rinternals{PartCombineMusic},
@rinternals{Voice}.


@knownissues

@code{\partcombine} can only accept two voices.

When @code{printPartCombineTexts} is set, if the two voices play
the same notes on and off, the part combiner may typeset @code{a2}
more than once in a measure.

@code{\partcombine} cannot be inside @code{\times}.

@code{\partcombine} cannot be inside @code{\relative}.

Internally, the @code{\partcombine} interprets both arguments as
@code{Voice}s and decides when the parts can be combined.  When they have
different durations they cannot be combined and are given the names
@code{one} and @code{two}.  Consequently, if the arguments switch to
differently named @rinternals{Voice} contexts, the events in those will
be ignored.  Likewise, partcombining isn't designed to work with lyrics;
when one of the voices is explicitly named in order to attach lyrics to
it, the partcombining stops working.

@code{\partcombine} only observes onset times of notes. It cannot
determine whether a previously started note is playing or not, leading
to various problems.


@node Writing music in parallel
@unnumberedsubsubsec Writing music in parallel

@cindex writing music in parallel
@cindex interleaved music
@cindex parallel music
@funindex \parallelMusic
@funindex parallelMusic

Music for multiple parts can be interleaved in input code.  The
function @code{\parallelMusic} accepts a list with the names of a
number of variables to be created, and a musical expression.  The
content of alternate measures from the expression become the value
of the respective variables, so you can use them afterwards to
print the music.

@warning{Bar checks @code{|} must be used, and the measures must
be of the same length.}

@lilypond[quote,verbatim]
\parallelMusic #'(voiceA voiceB voiceC) {
  % Bar 1
  r8 g'16 c'' e'' g' c'' e'' r8 g'16 c'' e'' g' c'' e'' |
  r16 e'8.~   e'4            r16 e'8.~   e'4            |
  c'2                        c'2                        |

  % Bar 2
  r8 a'16 d'' f'' a' d'' f'' r8 a'16 d'' f'' a' d'' f'' |
  r16 d'8.~   d'4            r16 d'8.~   d'4            |
  c'2                        c'2                        |

}
\new StaffGroup <<
  \new Staff << \voiceA \\ \voiceB >>
  \new Staff { \clef bass \voiceC }
>>
@end lilypond

Relative mode may be used.  Note that the @code{\relative} command
is not used inside @code{\parallelMusic} itself.  The notes are
relative to the preceding note in the voice, not to the previous
note in the input -- in other words, relative notes for
@code{voiceA} ignore the notes in @code{voiceB}.

@lilypond[quote,verbatim]
\parallelMusic #'(voiceA voiceB voiceC) {
  % Bar 1
  r8 g16 c e g, c e r8 g,16 c e g, c e  |
  r16 e8.~ e4       r16 e8.~  e4        |
  c2                c                   |

  % Bar 2
  r8 a,16 d f a, d f r8 a,16 d f a, d f |
  r16 d8.~  d4       r16 d8.~  d4       |
  c2                 c                  |

 }
\new StaffGroup <<
  \new Staff << \relative c'' \voiceA \\ \relative c' \voiceB >>
  \new Staff \relative c' { \clef bass \voiceC }
>>
@end lilypond

This works quite well for piano music.  This example maps four
consecutive measures to four variables:

@lilypond[quote,verbatim]
global = {
  \key g \major
  \time 2/4
}

\parallelMusic #'(voiceA voiceB voiceC voiceD) {
  % Bar 1
  a8    b     c   d     |
  d4          e         |
  c16 d e fis d e fis g |
  a4          a         |

  % Bar 2
  e8      fis  g     a   |
  fis4         g         |
  e16 fis g  a fis g a b |
  a4           a         |

  % Bar 3 ...
}

\score {
  \new PianoStaff <<
     \new Staff {
       \global
       <<
         \relative c'' \voiceA
         \\
         \relative c'  \voiceB
       >>
     }
     \new Staff {
       \global \clef bass
       <<
         \relative c \voiceC
         \\
         \relative c \voiceD
       >>
     }
  >>
}
@end lilypond


@seealso
Learning Manual:
@rlearning{Organizing pieces with variables}.

Snippets:
@rlsr{Simultaneous notes}.