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.
+ version that you are working on. For details, see the Contributors'
+ Guide, node Updating translation committishes..
@end ignore
-@c \version "2.12.0"
+@c \version "2.16.0"
@node Simultaneous notes
@section Simultaneous notes
-@lilypondfile[quote]{simultaneous-headword.ly}
+@lilypondfile[quote,ragged-right,line-width=16\cm]{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
@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:
+and @code{>}. A chord may be followed by a duration just like simple
+notes.
-@lilypond[verbatim,quote,relative=1]
-<c e g>2 <c f a>4-> <e g c>-.
+@lilypond[verbatim,quote,relative=2]
+<a c e>1 <a c e>2 <f a c e>4 <a c>8. <g c e>16
@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.
+Chords may also be followed by articulations, again just like simple
+notes.
+
+@lilypond[verbatim,quote,relative=2]
+<a c e>1\fermata <a c e>2-> <f a c e>4\prall <a c>8.^| <g c e>16-.
+@end lilypond
+
+The notes within the chord themselves can also be followed by articulation
+and ornamentation.
+
+@lilypond[verbatim,quote,relative=2]
+<a c\prall e>1 <a-> c-^ e>2 <f-. a c-. e-.>4
+<a-+ c-->8. <g\fermata c e\turn>16
+@end lilypond
+
+However some notation, such as dynamics, hairpins and slurs must be
+attached to the chord, rather than notes within the chord, otherwise
+they will not print.
+
+@lilypond[verbatim,quote,relative=2]
+<a\f c( e>1 <a c) e>\f <a\< c e>( <a\! c e>)
+<a c e>\< <a c e> <a c e>\!
+@end lilypond
+
+@cindex chords, empty
+@cindex placeholder events
+
+A chord acts merely as a container for its notes, its articulations and
+other attached elements. Consequently, a chord without notes inside
+does not actually have a duration. Any attached articulations will
+happen at the same musical time as the next following note or chord and
+be combined with them (for more complex possibilities of combining such
+elements, see @ref{Simultaneous expressions}):
+
+@lilypond[verbatim,quote,relative=2]
+\grace { g8[( a b] }
+<> ) \p \< -. -\markup \italic "sempre staccato"
+\repeat unfold 4 { c4 e } c1\f
+@end lilypond
+
+@cindex relative pitch, chords
+@cindex chords, relative pitch
+
+Relative mode can be used for pitches in chords. The first note of
+each chord is always relative to the first note of the chord that
+came before it, or in the case where no preceding chord exists, the
+pitch of the last note that came before the chord. All remaining notes
+in the chord are relative to the note that came before it
+@emph{within the same chord}.
+
+@lilypond[verbatim,quote,relative=2]
+<a c e>1 <f a c> <a c e> <f' a c> <b, e b,>
+@end lilypond
For more information about chords, see @ref{Chord notation}.
@rlearning{Combining notes into chords}.
Notation Reference:
-@ref{Chord notation}.
+@ref{Chord notation},
+@ref{Articulations and ornamentations},
+@ref{Relative octave entry},
+@ref{Multiple voices}.
Snippets:
@rlsr{Simultaneous notes}.
+@knownissues
+Chords containing more than two pitches within a staff space,
+such as @samp{<e f! fis!>}, create overlapping noteheads.
+Depending on the situation, better representations might involve
+
+@itemize
+
+@item
+temporary use of @ref{Multiple voices},
+@samp{<< f! \\ <e fis!> >>},
+
+@item
+enharmonic transcription of one or more pitches,
+@samp{<e f ges>}, or
+
+@item
+@ref{Clusters}.
+
+@end itemize
+
@node Chord repetition
@unnumberedsubsubsec Chord repetition
+@cindex Chord, repetition
+@cindex repetition, using @code{q}
+
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
+@lilypond[verbatim,quote,relative=2]
+<a c e>1 q <f a c>2 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.
+As with regular chords, the chord repetition symbol can be used with
+durations, articulations, markups, slurs, beams, etc. as only the
+pitches of the previous chord are duplicated.
-@lilypond[verbatim,quote,relative=1]
-<c e g>8\p q q4-| q8.^"text" q16 q4-|
+@lilypond[verbatim,quote,relative=2]
+<a c e>1\p^"text" q2\<( q8)[-| q8.]\! q16-1-2-3 q8\prall
@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.
+The chord repetition symbol always remembers the last instance of
+a chord so it is possible to repeat the most recent chord even if
+other non-chorded notes or rests have been added since.
-@lilypond[verbatim,quote,relative=1]
-<c e g>8 c' q c r4 q
+@lilypond[verbatim,quote,relative=2]
+<a c e>1 c'4 q2 r8 q8 |
+q2 c, |
@end lilypond
+However, the chord repetition symbol does not retain any dynamics,
+articulation or ornamentation within, or attached to, the previous
+chord.
+
+@lilypond[verbatim,quote,relative=2]
+<a-. c\prall e>1\sfz c'4 q2 r8 q8 |
+q2 c, |
+@end lilypond
+
+To have some of them retained, the @code{\chordRepeats} function can be
+be called explicitly with an extra argument specifying a list of
+@var{event types} to keep unless events of that type are already
+present on the @code{q} chord itself.
+
+@lilypond[verbatim,quote]
+\relative c'' {
+ \chordRepeats #'(articulation-event)
+ { <a-. c\prall e>1\sfz c'4 q2 r8 q8-. } |
+ q2 c, |
+}
+@end lilypond
+
+Here using @code{\chordRepeats} inside of a @code{\relative} construction
+produces unexpected results: once chord events have been expanded, they
+are indistinguishable from having been entered as regular chords, making
+@code{\relative} assign an octave based on their current context.
+
+Since nested instances of @code{\relative} don't affect one another,
+another @code{\relative} inside of @code{\chordRepeats} can be used for
+establishing the octave relations before expanding the repeat chords.
+In that case, the whole content of the inner @code{\relative} does not
+affect the outer one; hence the different octave entry of the final note
+in this example.
+
+@c Without \new Voice, implicit voice creation does the dumbest thing.
+@lilypond[verbatim,quote]
+\new Voice
+\relative c'' {
+ \chordRepeats #'(articulation-event)
+ \relative c''
+ { <a-. c\prall e>1\sfz c'4 q2 r8 q8-. } |
+ q2 c |
+}
+@end lilypond
+
+Interactions with @code{\relative} occur only with explicit calls of
+@code{\chordRepeats}: the implicit expansion at the start of typesetting
+is done at a time where all instances of @code{\relative} have already
+been processed.
+
@seealso
+Notation Reference:
+@ref{Chord notation},
+@ref{Articulations and ornamentations}.
+
Installed Files:
-@file{ly/@/chord-repetition-init@/.ly}.
+@file{ly/chord-repetition-init.ly}.
@node Simultaneous expressions
@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.
+rhythms, but attempts to attach notes with different durations to
+the same stem will cause errors. Notes, articulations, and property
+changes in a @emph{single} @samp{Voice} are collected and engraved in
+musical order:
+
+@lilypond[quote,verbatim,relative=2]
+<a c>4-. <>-. << c a >> << { c-. <c a> } { a s-. } >>
+@end lilypond
+
+Multiple stems or beams or different note durations or properties at
+the same musical time require the use of multiple voices.
The following example shows how simultaneous expressions can
generate multiple staves implicitly:
<< { a4 b g2 } { d4 g2 c,4 } >>
@end lilypond
-Here different rhythms cause no problems.
+Here different rhythms cause no problems because they are
+interpreted in different voices.
+
+@cindex collisions, clashing note columns
+@cindex collisions, ignoring
+
+@knownissues
+If notes from two or more voices, with stems in the same direction, are
+placed at the same position on the staff and have no shift (or have the
+same shift specified), the message:
+
+@example
+warning: ignoring too many clashing note columns
+@end example
+
+will appear during compilation. This message can be suppressed by:
+
+@example
+\override NoteColumn #'ignore-collision = ##t
+@end example
+
+However, this not only suppresses the warning but will prevent any
+collision resolution whatsover and may have other unintended effects
+(also see @emph{Known Issues} in @ref{Collision resolution}).
@node Clusters
even simultaneously. In such a case no attempt is made to
automatically avoid collisions between ordinary notes and clusters.
-
@seealso
Music Glossary:
@rglos{cluster}.
@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 produce MIDI output.
+
@node Multiple voices
@subsection Multiple voices
@funindex \oneVoice
@funindex oneVoice
-@strong{@i{Explicitly instantiating voices}}
+@subsubsubheading Explicitly instantiating voices
The basic structure needed to achieve multiple independent
voices in a single staff is illustrated in the following example:
@end lilypond
@noindent
-Here, voices are instantiated explicitly and are given names. The
-@code{\voiceOne} ... @code{\voiceFour} commands set up the voices
+Here, voices are instantiated explicitly and are given names. The
+@code{\voiceOne} @dots{} @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
command returns all the voice settings to the neutral default
directions.
-@strong{@i{Temporary polyphonic passages}}
+@subsubsubheading Temporary polyphonic passages
A temporary polyphonic passage can be created with the following
construct:
Here, the @code{\voiceOne} and @code{\voiceTwo} commands are
required to define the settings of each voice.
-@strong{@i{The double backslash construct}}
+@subsubsubheading 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
+@emph{all} the expressions within this construct 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.
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
+@code{\voiceOne} @dots{} @code{\voiceFour} commands, in the order in
which they appear in the code.
In the following example, the intermediate voice has stems up,
@code{Voice} contexts as explained in @rlearning{Contexts and engravers} and
@rlearning{Explicitly instantiating voices}.
-@strong{@i{Identical rhythms}}
+@subsubsubheading Voice order
+
+When entering multiple voices in the input file, use the following
+order:
+
+@example
+Voice 1: highest
+Voice 2: lowest
+Voice 3: second highest
+Voice 4: second lowest
+Voice 5: third highest
+Voice 6: third lowest
+etc.
+@end example
+
+Though this may seem counterintuitive, it simplifies the automatic
+layout process. Note that the odd-numbered voices are given
+upstems, and the even-numbered voices are given downstems:
+
+@lilypond[quote,verbatim]
+\new Staff <<
+ \time 2/4
+ { f''2 } % 1: highest
+ \\
+ { c'2 } % 2: lowest
+ \\
+ { d''2 } % 3: second-highest
+ \\
+ { e'2 } % 4: second-lowest
+ \\
+ { b'2 } % 5: third-highest
+ \\
+ { g'2 } % 6: third-lowest
+>>
+@end lilypond
+
+@warning{Lyrics, spanners (such as slurs, ties, hairpins etc.) cannot be
+created @q{across} voices.}
+
+@subsubsubheading 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{\oneVoice}.
@endpredefined
-
@seealso
Learning Manual:
@rlearning{Voices contain music},
@code{\voiceNeutralStyle}.
@endpredefined
-
@seealso
Learning Manual:
@rlearning{I'm hearing Voices},
>>
@end lilypond
-Note heads with different dots as shown in beat 2 of bar 1 may be
+Note heads with different dots as shown in beat 3 of bar 1 may be
also be merged:
@lilypond[quote,relative=2,verbatim]
>>
@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
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.
+The @code{\shiftOn} command allows (but does not force) the notes
+in a voice to be shifted. When @code{\shiftOn} is applied to a
+voice, a note or chord in that voice is shifted only if its stem
+would otherwise collide with a stem from another voice, and only
+if the colliding stems point in the same direction. The
+@code{\shiftOff} command prevents this type of shifting from
+occurring.
+
+By default, the outer voices (normally voices one and two) have
+@code{\shiftOff} specified, while the inner voices (three and
+above) have @code{\shiftOn} specified. When a shift is applied,
+voices with upstems (odd-numbered voices) are shifted to the
+right, and voices with downstems (even-numbered voices) are
+shifted to the left.
+
+Here is an example to help you visualize how an abbreviated
+polyphonic expression would be expanded internally.
+
+@warning{Note that with three or more voices, the vertical order
+of voices in your input file should not be the same as the
+vertical order of voices on the staff!}
+
+@lilypond[quote,verbatim]
+\new Staff \relative c'' {
+ %% abbreviated entry
+ <<
+ { f2 } % 1: highest
+ \\
+ { g,2 } % 2: lowest
+ \\
+ { d'2 } % 3: upper middle
+ \\
+ { b2 } % 4: lower middle
+ >>
+ %% internal expansion of the above
+ <<
+ \new Voice = "1" { \voiceOne \shiftOff f'2 }
+ \new Voice = "2" { \voiceTwo \shiftOff g,2 }
+ \new Voice = "3" { \voiceThree \shiftOn d'2 } % shifts right
+ \new Voice = "4" { \voiceFour \shiftOn b2 } % shifts left
+ >>
+}
+@end lilypond
+
+Two additional commands, @code{\shiftOnn} and @code{\shiftOnnn}
+provide further shift levels which may be specified temporarily to
+resolve collisions in complex situations -- see
+@rlearning{Real music example}.
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{\shiftOff}.
@endpredefined
-
@snippets
-
-@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
+@lilypondfile[verbatim,quote,texidoc,doctitle]
{additional-voices-to-avoid-collisions.ly}
-@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
+@lilypondfile[verbatim,quote,texidoc,doctitle]
{forcing-horizontal-shift-of-notes.ly}
-
@seealso
Music Glossary:
@rglos{polyphony}.
@rinternals{NoteCollision},
@rinternals{RestCollision}.
+@cindex collisions, ignoring
@knownissues
+Using @code{\override NoteColumn #'ignore-collision = ##t} will cause
+differently headed notes in different voices to merge incorrectly.
+
+@lilypond[quote,relative=1,verbatim]
+\mergeDifferentlyHeadedOn
+<< { c16 a' b a } \\ { c,2 } >>
+\override NoteColumn #'ignore-collision = ##t
+<< { c16 a' b a } \\ { c,2 } >>
+@end lilypond
@ignore
+@knownissues
@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
@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.
+Automatic part combining is used to merge two separate parts of music
+onto a single staff. This can be especially helpful when typesetting
+orchestral scores. A single @code{Voice} is printed while the two parts
+of music are the same, but in places where they differ, a second
+@code{Voice} is printed. Stem directions are set up & down accordingly
+while Solo and @notation{a due} parts are also identified and marked
+appropriately.
-The syntax for part combining is:
+The syntax for automatic 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.
+The following example demonstrates the basic functionality, putting
+parts on a single staff as polyphony and setting stem directions
+accordingly. 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
+ 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
+ R1 |
+ g4 a b c |
+ d4 c b a |
+ g4 f( e) d |
+ e1 |
}
<<
>>
@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,
+Both parts have identical notes in the third measure, so only one
+instance of the notes is printed. Stem, slur, and tie directions are
+set automatically, depending on whether the parts are playing solo or in
+unison. When needed in polyphony situations, the first part (with
+context called @code{one}) gets @qq{up} stems, while the second (called
+@code{two}) always gets @qq{down} stems. In solo situations, the first
+and second parts get marked with @qq{Solo} and @qq{Solo II},
+respectively. The unison (@notation{a due}) parts are marked with the
+text @qq{a2}.
+
+Both arguments to @code{\partcombine} will be interpreted as separate
+@code{Voice} contexts, so if the music is being specified in relative
+mode then @emph{both} parts must contain a @code{\relative} function,
i.e.,
@example
@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}.
+A @code{\relative} section that encloses a @code{\partcombine} has no
+effect on the pitches of @code{@var{musicexpr1}} or
+@code{@var{musicexpr2}}.
+
+@funindex \partcombineChords
+@funindex partcombineChords
+@funindex \partcombineApart
+@funindex partcombineApart
+@funindex \partcombineUnisono
+@funindex partcombineUnisono
+@funindex \partcombineSoloI
+@funindex partcombineSoloI
+@funindex \partcombineSoloII
+@funindex partcombineSoloII
+@funindex \partcombineAutomatic
+@funindex partcombineAutomatic
+
+In professional scores, voices are often kept apart from each other for
+long passages of music even if some of the notes are the same in both
+voices, and could just as easily be printed as unison. Combining notes
+into a chord, or showing one voice as solo is, therefore, not ideal as
+the @code{\partcombine} function considers each note separately. In this
+case the @code{\partcombine} function can be overriden with the
+following commands:
+
+Commands ending in @code{...Once} apply only to the next note in the
+music expression.
+
+@itemize
+@item
+@code{\partcombineApart} and @code{\partcombineApartOnce} keep the
+notes as two separate voices, even if they can be combined into a chord
+or unison.
+
+@item
+@code{\partcombineChords} and @code{\partcombineChordsOnce} combine the
+notes into a chord.
+
+@item
+@code{\partcombineUnisono} and @code{\partcombineUnisonoOnce} combine
+both voices as @qq{unison}.
+
+@item
+@code{\partcombineSoloI} and @code{\partcombineSoloIOnce} print only
+voice one, and mark it as a @qq{Solo}.
+
+@item
+@code{\partcombineSoloII} or @code{\partcombineSoloIIOnce} print only
+voice two and mark it as a @qq{Solo}.
+
+@item
+@code{\partcombineAutomatic} and @code{\partcombineAutomaticOnce} end
+the functions of the commands above, and revert back to the standard
+@code{\partcombine} functionality.
+@end itemize
+
+@lilypond[quote,verbatim]
+instrumentOne = \relative c' {
+ \partcombineApart c2^"apart" e |
+ \partcombineAutomatic e2^"auto" e |
+ \partcombineChords e'2^"chord" e |
+ \partcombineAutomatic c2^"auto" c |
+ \partcombineApart c2^"apart" \partcombineChordsOnce e^"chord once" |
+ c2 c |
+}
+instrumentTwo = \relative c' {
+ c2 c |
+ e2 e |
+ a,2 c |
+ c2 c' |
+ c2 c |
+ c2 c |
+}
+
+<<
+ \new Staff { \instrumentOne }
+ \new Staff { \instrumentTwo }
+ \new Staff { \partcombine \instrumentOne \instrumentTwo }
+>>
+@end lilypond
+
@snippets
-@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
+@lilypondfile[verbatim,quote,texidoc,doctitle]
{combining-two-parts-on-the-same-staff.ly}
-@lilypondfile[verbatim,lilyquote,texidoc,doctitle]
+@lilypondfile[verbatim,quote,texidoc,doctitle]
{changing-partcombine-texts.ly}
-
@seealso
Music Glossary:
@rglos{a due},
@rinternals{PartCombineMusic},
@rinternals{Voice}.
-
@knownissues
+All @code{\partcombine...} functions can only accept two voices and are
+not designed to work with lyrics; such that when one of the voices is
+explicitly named in order to attach lyrics to it, the partcombiner will
+stop working.
-@code{\partcombine} can only accept two voices.
+@code{\partcombine...} functions cannot be placed inside a @code{\times}
+or @code{\relative} block.
-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.
+If @code{printPartCombineTexts} is set and the two voices play the same
+notes @qq{on and off}, in the same measure, the part combiner may
+typeset @code{a2} more than once in that measure.
-@code{\partcombine} cannot be inside @code{\times}.
+@code{\partcombine} only knows when a note starts in a @code{Voice}; it
+cannot, for example, remember if a note in one @code{Voice} has already
+started when combining notes that have just started in the other
+@code{Voice}. This can lead to a number of unexpected issues including
+@qq{Solo} or @qq{Unison} marks being printed incorrectly.
-@code{\partcombine} cannot be inside @code{\relative}.
+@code{\partcombine} keeps all spanners (slurs, ties, hairpins etc.) in
+the same @code{Voice} so that if any such spanners start or end in a
+different @code{Voice}, they may not be printed properly or at all.
-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.
+If the @code{\partcombine} function cannot combine both music
+expressions (i.e. when both voices have different durations), it will
+give the voices, internally, its own custom names: @code{one} and
+@code{two} respectively. This means if there is any @qq{switch} to a
+differently named @code{Voice} context, the events in that differently
+named @code{Voice} will be ignored.
-@code{\partcombine} only observes onset times of notes. It cannot
-determine whether a previously started note is playing or not, leading
-to various problems.
+Refer also to @emph{Known issues and warnings} when using
+@code{\partcombine} with tablature in @ref{Default tablatures} and the
+@emph{Note} in @ref{Automatic beams} when using automatic beaming.
@node Writing music in parallel
}
@end lilypond
-
@seealso
Learning Manual:
@rlearning{Organizing pieces with variables}.
projects / lilypond.git / blobdiff