Minor updates.

[lilypond.git] / Documentation / user / rhythms.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

@node Rhythms
@section Rhythms

@lilypondfile[ragged-right,line-width=16\cm,staffsize=16,quote]
{rhythms-headword.ly}

This section discusses rhythms, durations, and bars.

@menu
* Writing rhythms::             
* Writing rests::               
* Displaying rhythms::          
* Beams::                       
* Bars::                        
* Special rhythmic concerns::   
@end menu


@node Writing rhythms
@subsection Writing rhythms

@menu
* Durations::                   
* Tuplets::                     
* Scaling durations::           
* Ties::                        
@end menu

@node Durations
@unnumberedsubsubsec Durations

@cindex duration
@funindex \longa
@funindex \breve
@funindex \maxima

When entering notes, durations are designated by numbers and dots:
durations are entered as their reciprocal values.  For example, a
quarter note is entered using a @code{4} (since it is a 1/4 note),
while a half note is entered using a @code{2} (since it is a 1/2
note).  For notes longer than a whole you must use the
@code{\longa} (a double breve) and @code{\breve} commands.  Note
durations as short as 64th notes may be specified.  Shorter values
are possible, but only as beamed notes.

@c Two 64th notes are needed to obtain beams
@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
\time 8/1
c\longa c\breve c1 c2
c4 c8 c16 c32 c64 c64
@end lilypond

@noindent
and the same durations with automatic beaming turned off 
see @ref{Automatic beams}:

@c not strictly "writing rhythms"; more of a "displaying" thing,
@c but it's ok here.  -gp
@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
\time 8/1
\autoBeamOff
c\longa c\breve c1 c2
c4 c8 c16 c32 c64 c64
@end lilypond

If the duration is omitted then it is set to the previously
entered duration.  The default for the first note is a quarter
note.

@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
a a a2 a a4 a a1 a
@end lilypond


@funindex .

To obtain dotted note lengths, simply add a dot (@samp{.}) to the
number.  Double-dotted notes are produced in a similar way.

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
a4 b c4. b8 a4. b4.. c8.
@end lilypond

Some durations cannot be entered using only binary durations
and dots, and can only be represented by tying two or more 
notes together.  Tied notes are covered in @ref{Ties}.

@refcommands

Dots are normally moved up to avoid staff lines, except in
polyphonic situations.  The following commands may be used to
force a particular direction manually:

@funindex \dotsUp
@code{\dotsUp},
@funindex \dotsDown
@code{\dotsDown},
@funindex \dotsNeutral
@code{\dotsNeutral}.

@c TODO: after deciding the link question, fix these.  -gp
Durations are entered in the same way in @code{drummode},
@code{chordmode}, @code{figuremode}, and (optionally) 
in @code{lyricmode}.

@seealso

For ways of specifying durations for the syllables of lyrics
and ways of aligning lyrics to notes see @ref{Vocal music}.

For a description of how to enter rests see @ref{Writing rests}.

A note with the duration of a quadruple breve may be
entered with \maxima, but this is supported only within
ancient music notation; see @ref{Ancient notation}.

Optionally, notes can be spaced proportionately to their duration.
For details of this and other settings which control
proportional notation see @ref{Proportional notation}.

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Dots}, and
@internalsref{DotColumn}.


@refbugs

@c duplicated in Durations and Rests.  -gp
There is no fundamental limit to note durations (both in terms of
longest and shortest), but the number of glyphs is limited: there
are flags up to 64th and rests up to 128th.  At the other extreme,
there are note heads up to longa (4x whole note) and rests up to
maxima (8 x whole).  Since beams can be stacked without needing
extra glyphs, beamed notes can be arbitrarily short.



@node Tuplets
@unnumberedsubsubsec Tuplets

@cindex tuplets
@cindex triplets
@funindex \times

@c TODO Add Tuplet to glossary

Tuplets are made out of a music expression by multiplying all
durations with a fraction:

@example
\times @var{fraction} @var{musicexpr}
@end example

@noindent
The duration of @var{musicexpr} will be multiplied by the 
fraction.  The fraction's denominator will be printed over or 
under the notes, optionally with a bracket.  The most common 
tuplet is the triplet in which 3 notes have the length of 2, so 
the notes are 2/3 of their written length.

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
g4 \times 2/3 {c4 c c} d4 d4
@end lilypond

Tuplets may be nested, for example,

@lilypond[fragment,ragged-right,verbatim,relative=2]
\times 2/3 {
  a4 a
  \times 3/5 { a a a a a }
}
@end lilypond

@refcommands

@funindex \tupletUp
@code{\tupletUp},
@funindex \tupletDown
@code{\tupletDown},
@funindex \tupletNeutral
@code{\tupletNeutral}.


@commonprop

@funindex tupletNumberFormatFunction
@cindex tuplet formatting

The property @code{tupletSpannerDuration} specifies how long each
bracket should last.  With this, you can make lots of tuplets
while typing @code{\times} only once, thus saving lots of typing.
In the next example, there are two triplets shown, while
@code{\times} was only used once.

@lilypond[quote,fragment,relative=2,ragged-right,verbatim]
\set tupletSpannerDuration = #(ly:make-moment 1 4)
\times 2/3 { c8 c c c c c }
@end lilypond

@noindent
For more information about @code{make-moment}, see
@ref{Time administration}.

The format of the number is determined by the property @code{text}
in @code{TupletNumber}.  The default prints only the denominator,
but if the property is set with @code{\override
TupletNumber #'text = #tuplet-number::calc-fraction-text},
@var{num}:@var{den} will be printed instead.

To print tuplets without tuplet numbers, use
@code{\override TupletNumber #'transparent = ##t}:

@lilypond[quote,fragment,relative=2,ragged-right,verbatim]
\times 2/3 { c8 c c } \times 2/3 { c8 c c }
\override TupletNumber #'text = #tuplet-number::calc-fraction-text
\times 2/3 { c8 c c }
\override TupletNumber #'transparent = ##t
\times 2/3 { c8 c c }
@end lilypond

To change the appearance of nested tuplets beginning at the same
music moment individually, the @code{\tweak} function must be used
(see @ref{Objects connected to the input}).  In the following
example, @code{\tweak} specifies fraction text for the outer
@code{TupletNumber} and denominator text for the
@code{TupletNumber} of the first of the three inner tuplets.

@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
\tweak #'text #tuplet-number::calc-fraction-text
\times 4/3 {
   \tweak #'text #tuplet-number::calc-denominator-text
   \times 2/3 { c8[ c8 c8] }
   \times 2/3 { c8[ c8 c8] }
   \times 2/3 { c8[ c8 c8] }
}
@end lilypond

@c TODO: after LM 6 Tweaks includes \tweak info, look at this.-gp
@c It *should* be explained why \tweak must be used here, and why
@c \override doesn't work. I've made an attempt, but I'm not sure
@c if it is factually correct to say that \tweak must be used.
In the next example, @code{\tweak} and @code{\override} work
together to specify @code{TupletBracket} direction.  The first
@code{\tweak} positions the @code{TupletBracket} of the outer
tuplet above the staff.  The second @code{\tweak} positions the
@code{TupletBracket} of the first of the three inner tuplets below
the staff.  Note that the @code{\tweak} function affects only
events that begin at the same music moment: the outer tuplet and
the first of the three inner tuplets.  To position the
@code{TupletBrackets} of the second and third of the inner tuplets
below the staff, we use @code{\override} in the usual way.

@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
\tweak #'text #tuplet-number::calc-fraction-text
\tweak #'direction #up
\times 4/3 {
   \tweak #'direction #down
   \times 2/3 { c8[ c8 c8] }
   \override TupletBracket #'direction = #down
   \times 2/3 { c8[ c8 c8] }
   \times 2/3 { c8[ c8 c8] }
}
@end lilypond

Tuplet brackets can be made to run to prefatory matter or the next
note:

@lilypond[ragged-right,verbatim,quote]
\new RhythmicStaff {
  \set tupletFullLength = ##t
  \time 4/4
  \times 4/5 {
    c4 c1
  }
  \set tupletFullLengthNote = ##t
  \time 2/4
  \times 2/3 {
    c4 c c 
  }
  \time 3/4
  c4 
}
@end lilypond

@refbugs

Tuplets which cross bar lines will prevent a line break at that
point.

@seealso

@code{\compressMusic} works similarly to \times, but does not
create a tuplet bracket; see @ref{Polymetric notation}.

FIXME: totally irrelevant link to real-music for
discussion/demonstration purposes.

Snippets: @lsrdir{rhythms},
@lsr{real-music,creating-music-with-scheme.ly}.

Internals Reference: @internalsref{TupletBracket},
@internalsref{TupletNumber}, and @internalsref{TimeScaledMusic}.



@node Scaling durations
@unnumberedsubsubsec Scaling durations

You can alter the length of a duration by a fraction @var{N/M}
by appending @code{*@var{N/M}} (or @code{*@var{N}} if @var{M=1}).
This will not affect the appearance of the notes or rests
produced, but the altered duration will be used in calculating the
position within the measure and setting the duration in the MIDI
output.  Multiplying factors may be combined
such as @code{*M*N}.

In the following example, the first three notes take up exactly
two beats, but no triplet bracket is printed.

@lilypond[quote,ragged-right,fragment,relative=2,verbatim]
\time 2/4
a4*2/3 gis4*2/3 a4*2/3
a4 a4 a4*2
b16*4 c4
@end lilypond

The duration of skip or spacing notes may also be modified by
a multiplier.  This is useful for skipping many measures, e.g., 
@code{s1*23}.

@seealso

This manual: @ref{Tuplets}, @ref{Skips}, @ref{Polymetric notation}.

Snippets: @lsrdir{rhythms}

@node Ties
@unnumberedsubsubsec Ties

@cindex tie
@funindex ~

A tie connects two adjacent note heads of the same pitch.  The tie
in effect extends the length of a note. 

@warning{Ties should not be confused with @emph{slurs}, which
indicate articulation, or @emph{phrasing slurs}, which indicate
musical phrasing. A tie is just a way of extending a note
duration, similar to the augmentation dot.}

A tie is entered using the tilde symbol @code{~}

@lilypond[quote,ragged-right,fragment,verbatim]
e' ~ e'
@end lilypond


@noindent
Ties are used either when the note crosses a bar line, or when
dots cannot be used to denote the rhythm.  Ties should also be
used when note values cross larger subdivisions of the measure:

@lilypond[fragment,quote,ragged-right]
\relative {
  r8 c8 ~ c2 r4 | r8^"not" c2 ~ c8 r4
}
@end lilypond

If you need to tie a lot of notes across bar lines, it may be
easier to use automatic note splitting (see @ref{Automatic note
splitting}).  This mechanism automatically splits long notes, and
ties them across bar lines.

@funindex \repeatTie
@cindex repeating ties
@cindex volta brackets and ties

When a tie is applied to a chord, all note heads whose pitches
match are connected.  When no note heads match, no ties will be
created.  Chords may be partially tied by placing the tie inside
the chord.

@lilypond[quote,ragged-right,fragment,verbatim,relative=1]
 <c e g> ~ <c e g>
<c~ e g~ b> <c e g b>
@end lilypond

When a second alternative of a repeat starts with a tied note, you
have to repeat the tie.  This can be achieved with
@code{\repeatTie},

@lilypond[fragment,quote,ragged-right,relative=2,verbatim]
\repeat volta 2 { c g <c e>2 ~ }
\alternative {{ <c e>2. r4 } {<c e>2\repeatTie d4 c }} 
@end lilypond

@cindex Laissez vibrer
@cindex Ties, laissez vibrer

@notation{L.v.} ties (@notation{laissez vibrer}) indicate that
notes must not be damped at the end.  It is used in notation for
piano, harp and other string and percussion instruments.  They can
be entered using @code{\laissezVibrer}:

@lilypond[fragment,ragged-right,verbatim,relative=1]
<c f g>\laissezVibrer
@end lilypond

The direction of a tie can be specified with @code{\tieUp} or
@code{\tieDown} (see example below).  @code{\tieNeutral} reverts
to the default behaviour again.

However, as with other music elements of this kind, there is a
convenient shorthand for forcing tie directions.  By adding
@code{_} or @code{^} before the tilde, the direction is also set:

@lilypond[relative=2,ragged-right,quote,verbatim,fragment]
c4_~ c c^~ c)
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference:
@internalsref{LaissezVibrerTie}
@internalsref{LaissezVibrerTieColumn}

Example files:
@lsr{connecting,laissez-vibrer-ties.ly}


@commonprop

Ties are sometimes used to write out arpeggios.  In this case, two
tied notes need not be consecutive.  This can be achieved by
setting the @code{tieWaitForNote} property to true.  The same
feature is also useful, for example, to tie a tremolo to a chord,
but in principle, it can also be used for ordinary, consecutive
notes:

@lilypond[fragment,verbatim,relative=1,ragged-right,quote]
\set tieWaitForNote = ##t
\grace { c16[~ e~ g]~ } <c, e g>2
\repeat tremolo 8 { c32~ c'~ } <c c,>1
e8~ c~ a~ f~ <e' c a f>2
\tieUp c8~ a \tieDown \tieDotted g~ c g2
@end lilypond

Ties may be engraved manually by changing the
@code{tie-configuration} property of the @code{TieColumn} object.
The first number indicates the distance from the center of the
staff in staff-spaces, and the second number indicates the
direction (1=up, -1=down).

@lilypond[fragment,verbatim,relative=1,ragged-right,quote]
<c e g>2~ <c e g> |
\override TieColumn #'tie-configuration =
  #'((0.0 . 1) (-2.0 . 1) (-4.0 . 1))
<c e g>~ <c e g> |
@end lilypond


@refcommands


@funindex \tieUp
@code{\tieUp},
@funindex \tieDown
@code{\tieDown},
@funindex \tieNeutral
@code{\tieNeutral},
@funindex \tieDotted
@code{\tieDotted},
@funindex \tieDashed
@code{\tieDashed},
@funindex \tieSolid
@code{\tieSolid}.


@seealso



In this manual: @ref{Automatic note splitting}.

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Tie}.


@refbugs

Switching staves when a tie is active will not produce a slanted
tie.

Changing clefs or octavations during a tie is not really
well-defined.  In these cases, a slur may be preferable.





@node Writing rests
@subsection Writing rests

@menu
* Rests::                       
* Skips::                       
* Multi measure rests::         
@end menu

@node Rests
@unnumberedsubsubsec Rests
@cindex Rests

@funindex \rest
@funindex r
@funindex \maxima

Rests are entered like notes with the note name @code{r}:

@c \time 16/1 is used to avoid spurious bar lines
@c and long tracts of empty measures
@lilypond[fragment,quote,ragged-right,verbatim]
\new Staff {
  \time 16/1
  \override Staff.TimeSignature #'stencil = ##f
  r\maxima
  r\longa r\breve r1 r2
  r4 r8 r16 r32 r64
}
@end lilypond

Whole measure rests, centered in middle of the measure, must be entered as
multi-measure rests.  They can be used for a single measure as well as
many measures and are discussed in @ref{Multi measure rests}.

To explicitly specify a rest's vertical position, write a note
followed by @code{\rest}.  A rest will be placed in the position
where the note would appear.  This allows for precise manual
formatting of polyphonic music, since the automatic rest collision
formatter will leave these rests alone.

@lilypond[fragment,quote,ragged-right,verbatim,relative=2]
a4\rest d4\rest
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Rest}.


@refbugs

@c duplicated in Durations and Rests.  -gp
There is no fundamental limit to note durations (both in terms of
longest and shortest), but the number of glyphs is limited: there
are flags up 64th and rests up to 128th.  At the other extreme,
there are note heads up to longa (4x whole note) and rests up to
maxima (8 x whole).  Since beams can be stacked without needing
extra glyphs, beamed notes can be arbitrarily short.


@node Skips
@unnumberedsubsubsec Skips

@cindex Skip
@cindex Invisible rest
@cindex Space note
@funindex \skip
@funindex s

An invisible rest (also called a @q{skip}) can be entered like a
note with note name @code{s} or with @code{\skip @var{duration}}

@lilypond[fragment,quote,ragged-right,verbatim,relative=2]
a4 a4 s4 a4 \skip 1 a4
@end lilypond

The @code{s} syntax is only available in note mode and chord mode.
In other situations, for example, when entering lyrics, one must
use the @code{\skip} command:

@lilypond[quote,ragged-right,verbatim,relative=2]
<<
  { a2 a2 }
  \new Lyrics \lyricmode { \skip 2 bla2 }
>>
@end lilypond

The skip command is merely an empty musical placeholder.  It does
not produce any output, not even transparent output.

The @code{s} skip command does create @internalsref{Staff} and
@internalsref{Voice} when necessary, similar to note and rest
commands.  For example, the following results in an empty staff.

@lilypond[quote,verbatim]
{ s4 }
@end lilypond
@c with ragged-right, the staff lines are cut BEFORE the time
@c signature, which makes for a VERY empty staff

@c The fragment @code{@{ \skip 4 @} } would produce an empty page.
@c Misleading -- it doesn't produce anything, not even an empty page.
@c Ppl who want to make empty sheets will see this and wonder what's
@c happening.  -eo

@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{SkipMusic}.


@node Multi measure rests
@unnumberedsubsubsec Multi measure rests

@cindex multi measure rests
@cindex full measure rests
@cindex Rests, multi measure
@cindex Rests, full measure
@cindex whole rests for a full measure
@funindex R

Rests for one or more full measures are entered using @code{R}
followed by a duration (see @ref{Durations}).  The duration should
correspond to an integral number of measures, otherwise a barcheck
warning is printed.  Multi-measure rests are principally used to
indicate that a part in a multi-part score should be silent:

@lilypond[quote,fragment,verbatim,relative=2]
\set Score.skipBars = ##t
R1*4
R1*24
R1*4
b2^"Tutti" b4 a4
@end lilypond

A multi-measure rest can be expanded in the printed score
to show all the rest measures explicitly, or, as above, it can be 
condensed to a single measure
containing a multi-measure rest symbol, with the number of
measures of rest printed above the measure.  This expansion
is controlled by the property @code{Score.skipBars}.  If this is
set to true, empty measures will be condensed to a single measure.

@lilypond[quote,ragged-right,fragment,verbatim]
\time 4/4 r1 | R1 | R1*2 | 
\time 2/4 R2 | 
\time 4/4
\set Score.skipBars = ##t 
R1*17 | R1*4 |
@end lilypond

The @code{1} in @code{R1} is similar to the duration notation 
used for notes and is the length of a measure in 2/2 or 4/4 time.
The duration in a multi-measure rest must always be an integral
number of measure-lengths, so in other time signatures augmentation
dots or fractions must be used:

@lilypond[quote,ragged-right,fragment,verbatim]
\set Score.skipBars = ##t
\time 3/4
R2. | R2.*2
\time 13/8
R1*13/8 | R1*13/8*12 |
\time 10/8 
R4*5*4 |
@end lilypond

An @code{R} spanning a single measure is printed as either a whole
or breve rest, centered in the measure, regardless of the time
signature.

If there are 10 or fewer measures of rest, LilyPond prints
@rglos{church rests} (a series of longa and breve rests)
in the staff and
prints a simple line otherwise.  This default number of 10
may be changed by overriding 
@code{MultiMeasureRest.expand-limit}.

@lilypond[quote,ragged-right,fragment,verbatim]
\set Score.skipBars = ##t
R1*2 | R1*5 | R1*9
\override MultiMeasureRest #'expand-limit = 3
R1*2 | R1*5 | R1*9
@end lilypond

Note that unlike ordinary rests, the vertical position on the
staff of the multi-measure rest symbol of either form cannot be
changed.

@cindex text on multi-measure rest
@cindex script on multi-measure rest
@cindex fermata on multi-measure rest

Text can be added to multi-measure rests by using the
@var{note}-@code{markup} syntax described in @ref{Text markup}.
The variable @code{\fermataMarkup} is provided for adding
fermatas.

@lilypond[quote,ragged-right,verbatim,fragment]
\set Score.skipBars = ##t
\time 3/4
R2.*10^\markup { \italic "ad lib." }
R2.^\fermataMarkup
@end lilypond

@warning{Text attached to a multi-measure rest is created 
by @code{MultiMeasureRestText}, not
@code{TextScript}.  Overrides must be directed to the correct
object, or they will be ignored.  See the following example.}

@lilypond[quote,ragged-right,verbatim,fragment]
\override TextScript #'padding = #5
R1^"low"
\override MultiMeasureRestText #'padding = #5
R1^"high"
@end lilypond

Text attached to a multi-measure rest will be centered above or
below it.  Long text attached in this way does not cause the
measure to expand, and may collide with text in adjacent measures.
Long text is better attached to a zero-length skip note preceding
the rest, preceded by @code{\fatText} (turn off again with
@code{\emptyText}), since this will cause the measure to expand to
accommodate the length of the text:

@lilypond[quote,ragged-right,verbatim,fragment]
\set Score.skipBars = ##t
\fatText
s1*0^\markup {[MAJOR GENERAL]}
R1*19
s1*0^\markup {[MABEL] }
s1*0_\markup {\italic {Cue: ... it is yours}}
R1*30
s1^\markup {CHORUS} % Chorus notes would go here
c1
@end lilypond


@seealso

This manual: @ref{Text}, @ref{Text scripts}.

Snippets: @lsrdir{rhythms}

Internals Reference: 

@internalsref{MultiMeasureRest}.

The layout object @internalsref{MultiMeasureRestNumber} is for the
default number, and @internalsref{MultiMeasureRestText} for user
specified texts.


@refbugs

If an attempt is made to use fingerings (e.g., 
@code{R1*10-4}) to put numbers over multi-measure rests, the
fingering numeral (4) may collide with the bar counter 
numeral (10).  

@cindex condensing rests

There is no way to automatically condense multiple rests into a
single multi-measure rest.  Multi-measure rests do not take part
in rest collisions.

Be careful when entering multi-measure rests followed by whole
notes.  The following will enter two notes lasting four measures
each:

@example
R1*4 cis cis
@end example


@node Displaying rhythms
@subsection Displaying rhythms

@menu
* Time signature::              
* Upbeats::                     
* Unmetered music::             
* Polymetric notation::         
* Automatic note splitting::    
* Setting automatic beam behavior::  
@end menu

@node Time signature
@unnumberedsubsubsec Time signature

@cindex Time signature
@cindex meter
@funindex \time

The time signature is set with the @code{\time} command:

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\time 2/4 c2 \time 3/4 c2.
@end lilypond

@commonprop

The symbol that is printed can be customized with the @code{style}
property.  Setting it to @code{#'()} uses fraction style for 4/4
and 2/2 time,

@lilypond[fragment,quote,ragged-right,verbatim,relative=2]
\time 4/4 c1
\time 2/2 c1
\override Staff.TimeSignature #'style = #'()
\time 4/4 c1
\time 2/2 c1
@end lilypond

A time signature symbol is normally printed whenever the time
signature changes.  If this takes place at the end of a line a
warning time signature sign is printed at the end of the line and
again at the start of a new line.  This default behaviour can be
modified by setting the value of the @code{break-visibility}
property.  This takes three values which may be set to @code{#t}
or @code{#f} to specify whether the corresponding time signature
is visible or not.  The order of the three values is @code{end of
line visible}, @code{middle of line visible}, @code{beginning of
line visible}.

@lilypond[fragment,quote,ragged-right,verbatim,relative=2]
% Do not print any time signatures at end of line
\override Staff.TimeSignature #'break-visibility = ##(#f #t #t)
\time 4/4 c1
\time 3/4 c2.
% Do not print the following 9/8 time signature
\once \override Staff.TimeSignature #'break-visibility = ##(#t #f #t)
\time 9/8 c4. c c
\time 2/2 c1
\break
\time 9/8 c4. c c
\time 12/8 c2. c2.
@end lilypond

There are many more options for its layout.  See @ref{Ancient time
signatures}, for more examples.

@code{\time} sets the properties @code{timeSignatureFraction},
@code{beatLength}, and @code{measureLength} in the @code{Timing}
context, which is normally aliased to @internalsref{Score}.  The
property @code{measureLength} determines where bar lines should be
inserted, and how automatic beams should be generated.  Changing
the value of @code{timeSignatureFraction} also causes the symbol
to be printed.

@cindex Measure groupings
 
More options are available through the Scheme function
@code{set-time-signature}, which takes three arguments: the number
of beats, the beat length, and the internal grouping of beats in
the measure.  If the @internalsref{Measure_grouping_engraver} is
included, the function will also create
@internalsref{MeasureGrouping} signs.  Such signs ease reading
rhythmically complex modern music.  In the following example, the
9/8 measure is subdivided in 2, 2, 2 and 3.  This is passed to
@code{set-time-signature} as the third argument @code{(2 2 2 3)}:

@lilypond[quote,ragged-right,verbatim]
\score {
  \relative c'' {
    #(set-time-signature 9 8 '(2 2 2 3))
    g8[ g] d[ d] g[ g] a8[( bes g]) |
    #(set-time-signature 5 8 '(3 2))
    a4. g4
  }
  \layout {
    \context {
      \Staff
      \consists "Measure_grouping_engraver"
    }
  }
}
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{TimeSignature}, and
@internalsref{Timing_translator}.

Examples: @lsr{contemporary,compound-time-signature.ly}.


@refbugs

Automatic beaming does not use the measure grouping specified with
@code{set-time-signature}.


@node Upbeats
@unnumberedsubsubsec Upbeats

@cindex anacrusis
@cindex upbeat
@cindex partial measure
@cindex measure, partial
@cindex pickup measure
@cindex shorten measures
@funindex \partial

Partial or pickup measures, such as an anacrusis or upbeat, are
entered using the @code{\partial} command, with the syntax

@example
\partial @var{duration}
@end example

where @code{duration} is the rhythmic length to be added before
the next measure:

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\partial 16*5 c16 cis d dis e | a2. c,4 | b2
@end lilypond

Internally, this is translated into

@example
\set Timing.measurePosition = -@var{length of duration}
@end example

The property @code{measurePosition} contains a rational number
indicating how much of the measure has passed at this point.  Note
that this is a negative number; @code{\partial 4} is internally
translated to mean @qq{there is a quarter note left in the bar.}


@refbugs

This command does not take into account grace notes at the start
of the music.  When a piece starts with grace notes in the
pickup, then the @code{\partial} should follow the grace notes:

@lilypond[verbatim,quote,ragged-right,relative,fragment]
\grace f16
\partial 4
g4
a2 g2
@end lilypond

@code{\partial} is only intended to be used at the beginning of a
piece.  If you use it after the beginning, some odd warnings may
occur.

@seealso

Snippets: @lsrdir{rhythms}

@node Unmetered music
@unnumberedsubsubsec Unmetered music

@cindex cadenza
@funindex \cadenzaOn
@funindex \cadenzaOff

Bar lines and bar numbers are calculated automatically.  For
unmetered music (cadenzas, for example), this is not desirable.
To turn off automatic bar lines and bar numbers, use the commands
@code{\cadenzaOn} and @code{\cadenzaOff}.

@lilypond[verbatim,quote,ragged-right,relative=2,fragment]
c4 d e d
\cadenzaOn
c4 c d8 d d f4 g4.
\cadenzaOff
\bar "|"
d4 e d c
@end lilypond


@refbugs

LilyPond will only insert line breaks and page breaks at a
bar line.  Unless the unmetered music ends before the end of the
staff line, you will need to insert invisible bar lines with

@example
\bar ""
@end example

@noindent
to indicate where breaks can occur.

@seealso

Snippets: @lsrdir{rhythms}


@node Polymetric notation
@unnumberedsubsubsec Polymetric notation

@cindex double time signatures
@cindex signatures, polymetric
@cindex polymetric signatures
@cindex meter, polymetric

Double time signatures are not supported explicitly, but they can
be faked.  In the next example, the markup for the time signature
is created with a markup text.  This markup text is inserted in
the @internalsref{TimeSignature} grob.  See also
@lsr{contemporary,compound-time-signature}.

@lilypond[verbatim,ragged-right]
% create 2/4 + 5/8
tsMarkup = \markup {
  \override #'(baseline-skip . 2) \number {
    \column { "2" "4" }
    \vcenter "+"
    \bracket \column { "5" "8" }
  }
}

{
  \override Staff.TimeSignature #'stencil =
    #ly:text-interface::print
  \override Staff.TimeSignature #'text = #tsMarkup
  \time 3/2
  c'2 \bar ":" c'4 c'4.
}
@end lilypond

Each staff can also have its own time signature.  This is done by
moving the @internalsref{Timing_translator} to the
@internalsref{Staff} context.

@lilypond[quote,verbatim,ragged-right]
\layout {
  \context {
    \Score
    \remove "Timing_translator"
    \remove "Default_bar_line_engraver"
  }
  \context {
    \Staff
    \consists "Timing_translator"
    \consists "Default_bar_line_engraver"
  }
}
%Now, each staff has its own time signature.

\relative c' <<
  \new Staff {
    \time 3/4
    c4 c c | c c c |
  }
  \new Staff {
    \time 2/4
    c4 c | c c | c c
  }
  \new Staff {
    \time 3/8
    c4. c8 c c c4. c8 c c
  }
>>
@end lilypond


A different form of polymetric notation is where note lengths have
different values across staves, but the measures are all the same 
length.

This notation can be created by setting a common time signature
for each staff but replacing it manually using
@code{timeSignatureFraction} to the desired fraction.  Then the
printed durations in each staff are scaled to the common time
signature.  The latter is done with @code{\compressMusic}, which
is used in a similar way to @code{\times}, but does not create 
a tuplet bracket.  The syntax is 
@funindex \compressMusic

@example 
\compressMusic 
#'(@var{numerator} . @var{denominator}) @var{musicexpr} 
@end example



In this example, music with the time signatures of 3/4, 9/8, and
10/8 are used in parallel.  In the second staff, shown durations
are multiplied by 2/3, so that 2/3 * 9/8 = 3/4, and in the third
staff, shown durations are multiplied by 3/5, so that 3/5 * 10/8 =
3/4.

@lilypond[quote,ragged-right,verbatim,fragment]
\relative c' { <<
  \new Staff {
    \time 3/4
    c4 c c | c c c |
  }
  \new Staff {
    \time 3/4
    \set Staff.timeSignatureFraction = #'(9 . 8)
    \compressMusic #'(2 . 3)
      \repeat unfold 6 { c8[ c c] }
  }
  \new Staff {
    \time 3/4
    \set Staff.timeSignatureFraction = #'(10 . 8)
    \compressMusic #'(3 . 5) {
      \repeat unfold 2 { c8[ c c] }
      \repeat unfold 2 { c8[ c] }
      | c4. c4. \times 2/3 { c8 c c } c4
    }
  }
>> }
@end lilypond


@refbugs

When using different time signatures in parallel, the spacing is
aligned vertically, but bar lines distort the regular spacing.

@seealso

Snippets: @lsrdir{rhythms}


@node Automatic note splitting
@unnumberedsubsubsec Automatic note splitting

Long notes which overrun bar lines can be converted automatically
to tied notes.  This is done by replacing the
@internalsref{Note_heads_engraver} by the
@internalsref{Completion_heads_engraver}.  In the following
examples, notes crossing the bar line are split and tied.

@lilypond[quote,fragment,verbatim,relative=1,line-width=12\cm]
\new Voice \with {
  \remove "Note_heads_engraver"
  \consists "Completion_heads_engraver"
} {
  c2. c8 d4 e f g a b c8 c2 b4 a g16 f4 e d c8. c2
}
@end lilypond

This engraver splits all running notes at the bar line, and
inserts ties.  One of its uses is to debug complex scores: if the
measures are not entirely filled, then the ties exactly show how
much each measure is off.

If you want to allow line breaking on the bar lines where
@internalsref{Completion_heads_engraver} splits notes, you must
also remove @internalsref{Forbid_line_break_engraver}.


@refbugs

Not all durations (especially those containing tuplets) can be
represented exactly with normal notes and dots, but the engraver
will not insert tuplets.

@code{Completion_heads_engraver} only affects notes; it does not
split rests.


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Completion_heads_engraver}.


@node Setting automatic beam behavior
@unnumberedsubsubsec Setting automatic beam behavior

@funindex autoBeamSettings
@funindex (end * * * *)
@funindex (begin * * * *)
@cindex automatic beams, tuning
@cindex tuning automatic beaming

@c [TODO: use \applyContext]

In normal time signatures, automatic beams can start on any note
but can only end in a few positions within the measure: beams can
end on a beat, or at durations specified by the properties in
@code{autoBeamSettings}.  The properties in
@code{autoBeamSettings} consist of a list of rules for where beams
can begin and end.  The default @code{autoBeamSettings} rules are
defined in @file{scm/@/auto@/-beam@/.scm}.

In order to add a rule to the list, use
@example
#(override-auto-beam-setting '(be p q n m) a b [context])
@end example

@itemize

@item @code{be} is either @code{begin} or @code{end}.

@item @code{p/q} is the duration of the note for which you want
to add a rule.  A beam is considered to have the duration of its
shortest note.  Set @code{p} and @code{q} to @code{'*'} to
have this apply to any beam.

@item @code{n/m} is the time signature to which
this rule should apply.  Set @code{n} and @code{m} to @code{'*'}
to have this apply in any time signature.

@item @code{a/b} is the position in the bar at which the beam should
begin/end.

@item @code{context} is optional, and it specifies the context at which
the change should be made.  The default is @code{'Voice}.

@code{#(score-override-auto-beam-setting '(A B C D) E F)} is equivalent to
@code{#(override-auto-beam-setting '(A B C D) E F 'Score)}.

@end itemize

For example, if automatic beams should always end on the first quarter
note, use

@example
#(override-auto-beam-setting '(end * * * *) 1 4)
@end example

You can force the beam settings to only take effect on beams whose shortest
note is a certain duration

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 2/4
#(override-auto-beam-setting '(end 1 16 * *) 1 16)
a16 a a a a a a a |
a32 a a a a16 a a a a a |
#(override-auto-beam-setting '(end 1 32 * *) 1 16)
a32 a a a a16 a a a a a |
@end lilypond

You can force the beam settings to only take effect in certain time
signatures

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 5/8
#(override-auto-beam-setting '(end * * 5 8) 2 8)
c8 c d d d
\time 4/4
e8 e f f e e d d
\time 5/8
c8 c d d d
@end lilypond

You can also remove a previously set beam-ending rule by using

@example
#(revert-auto-beam-setting '(be p q n m) a b [context])
@end example

@noindent
be, p, q, n, m, a, b and context are the same as above.  Note that the
default rules are specified in @file{scm/@/auto@/-beam@/.scm},
so you can revert rules that you did not explicitly create.

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 4/4
a16 a a a a a a a a a a a a a a a
#(revert-auto-beam-setting '(end 1 16 4 4) 1 4)
a16 a a a a a a a a a a a a a a a
@end lilypond

The rule in a revert-auto-beam-setting statement must exactly match the
original rule.  That is, no wildcard expansion is taken into account.

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 1/4
#(override-auto-beam-setting '(end 1 16 1 4) 1 8)
a16 a a a
#(revert-auto-beam-setting '(end 1 16 * *) 1 8) % this won't revert it!
a a a a
#(revert-auto-beam-setting '(end 1 16 1 4) 1 8) % this will
a a a a
@end lilypond



@c TODO:  old material -- not covered by above stuff, I think.
If automatic beams should end on every quarter in 5/4 time, specify
all endings
@example
#(override-auto-beam-setting '(end * * * *) 1 4 'Staff)
#(override-auto-beam-setting '(end * * * *) 1 2 'Staff)
#(override-auto-beam-setting '(end * * * *) 3 4 'Staff)
#(override-auto-beam-setting '(end * * * *) 5 4 'Staff)
@dots{}
@end example

The same syntax can be used to specify beam starting points.  In this
example, automatic beams can only end on a dotted quarter note
@example
#(override-auto-beam-setting '(end * * * *) 3 8)
#(override-auto-beam-setting '(end * * * *) 1 2)
#(override-auto-beam-setting '(end * * * *) 7 8)
@end example
In 4/4 time signature, this means that automatic beams could end only on
3/8 and on the fourth beat of the measure (after 3/4, that is 2 times
3/8, has passed within the measure).

If any unexpected beam behaviour occurs, check the default automatic beam
settings in @file{scm/@/auto@/-beam@/.scm}
for possible interference, because the beam
endings defined there will still apply on top of your own overrides.  Any
unwanted endings in the default vales must be reverted for your time
signature(s).

For example, to typeset @code{(3 4 3 2)}-beam endings in 12/8, begin
with

@example
%%% revert default values in scm/auto-beam.scm regarding 12/8 time
#(revert-auto-beam-setting '(end * * 12 8) 3 8)
#(revert-auto-beam-setting '(end * * 12 8) 3 4)
#(revert-auto-beam-setting '(end * * 12 8) 9 8)

%%% your new values
#(override-auto-beam-setting '(end 1 8 12 8) 3 8)
#(override-auto-beam-setting '(end 1 8 12 8) 7 8)
#(override-auto-beam-setting '(end 1 8 12 8) 10 8)
@end example

@cindex automatic beam generation
@cindex autobeam
@funindex autoBeaming
@cindex lyrics

If beams are used to indicate melismata in songs, then automatic
beaming should be switched off with @code{\autoBeamOff}.


@refcommands

@funindex \autoBeamOff
@code{\autoBeamOff},
@funindex \autoBeamOn
@code{\autoBeamOn}.

@commonprop

Beaming patterns may be altered with the @code{beatGrouping} property,

@lilypond[quote,verbatim,relative=2,fragment,ragged-right]
\time 5/16
\set beatGrouping = #'(2 3)
c8[^"(2+3)" c16 c8]
\set beatGrouping = #'(3 2)
c8[^"(3+2)" c16 c8]
@end lilypond


@refbugs

If a score ends while an automatic beam has not been ended and is
still accepting notes, this last beam will not be typeset at all.  The
same holds polyphonic voices, entered with @code{<< @dots{} \\ @dots{}
>>}.  If a polyphonic voice ends while an automatic beam is still
accepting notes, it is not typeset.

@seealso

Snippets: @lsrdir{rhythms}




@node Beams
@subsection Beams

@menu
* Automatic beams::             
* Manual beams::                
@end menu

@node Automatic beams
@unnumberedsubsubsec Automatic beams

By default beams are inserted automatically

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\time 2/4 c8 c c c
\time 6/8 c c c c8. c16 c8
@end lilypond

When these automatic decisions are not good enough, beaming 
can be entered explicitly.  It is also possible to define beaming
patterns that differ from the defaults.  See @ref{Manual beams}
and @ref{Setting automatic beam behavior}.

@cindex autoBeamOn
@cindex autoBeamOff

@noindent
Automatic beaming may be turned off and on with
@code{\autoBeamOff} and @code{\autoBeamOn} commands:

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
c4 c8 c8. c16 c8. c16 c8
\autoBeamOff
c4 c8 c8. c16 c8.
\autoBeamOn
c16 c8
@end lilypond


@commonprop

@funindex stemLeftBeamCount
@funindex stemRightBeamCount

LilyPond can automatically determine beaming patterns within a
beam, but this automatic behavior can sometimes produce odd
results; therefore the @code{stemLeftBeamCount} and
@code{stemRightBeamCount} properties can be used to override the
defaults.  If either property is set, its value will be used only
once, and then it is erased.

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
{
   f8[ r16
      f g a]
   f8[ r16
   \set stemLeftBeamCount = #1
      f g a]
}
@end lilypond

The property @code{subdivideBeams} can be set in order to
subdivide all 16th or shorter beams.
When set, multiple beams will be sub-divided at beat 
positions, defined by the current value of @code{beatLength},
by drawing only one beam over the beat.

@lilypond[fragment,ragged-right,quote,relative=2,verbatim]
c16[ c c c c c c c]
\set subdivideBeams = ##t
c16[ c c c c c c c]
\set Score.beatLength = #(ly:make-moment 1 8)
c16[ c c c c c c c]
@end lilypond
@funindex subdivideBeams

@noindent
For more information about @code{make-moment}, see
@ref{Time administration}.

@c TODO Consider whether the section Setting automatic
@c beam behavior should all be moved here.  For now
@c here's a link to it.

For details about modifying the automatic beam behaviour
see @ref{Setting automatic beam behavior}

@funindex breakable

Line breaks are normally forbidden when beams cross barlines.
This behavior can be changed by setting the @code{breakable} 
property: @code{\override Beam #'breakable = ##t}.

@cindex beams and line breaks
@cindex beams, kneed
@cindex kneed beams
@cindex auto-knee-gap

Kneed beams are inserted automatically when a large gap is
detected between the note heads.  This behavior can be tuned
through the @code{auto-knee-gap} property.  A kneed beam is
drawn if the gap is larger than the value of 
@code{auto-knee-gap} plus the width of the beam object (which
depends on the duration of the notes and the slope of the beam).
By default @code{auto-knee-gap} is set to 5.5 staff spaces.

@lilypond[fragment,ragged-right,quote,verbatim]
f8 f''8 f8 f''8
\override Beam #'auto-knee-gap = #6
f8 f''8 f8 f''8
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Beam}.


@refbugs

Automatically kneed cross-staff beams cannot be used together with
hidden staves.  See @ref{Hiding staves}.

Beams can collide with noteheads and accidentals in other voices

@node Manual beams
@unnumberedsubsubsec Manual beams

@cindex beams, manual

Individual notes may be marked with @code{\noBeam} to prevent them
from being beamed:

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\time 2/4 c8 c\noBeam c c
@end lilypond

@funindex ]
@funindex [

@funindex stemLeftBeamCount
@funindex stemRightBeamCount

Even more strict manual control with the beams can be achieved by
setting the properties @code{stemLeftBeamCount} and
@code{stemRightBeamCount}.  They specify the number of beams to
draw on the left and right side, respectively, of the next note.
If either property is set, its value will be used only once, and
then it is erased.  In this example, the last @code{f} is printed
with only one beam on the left side, i.e. the eigth-note beam of
the group as a whole.

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
{
  f8[ r16 f g a]
  f8[ r16
  \set stemLeftBeamCount = #1
  f g a]
}
@end lilypond


@commonprop

@cindex beams, feathered
@funindex \featherDurations 

Feathered beams are used to indicate that a small group of notes
should be played at an increasing (or decreasing) tempo, without
changing the overall tempo of the piece.  The extent of the 
feathered beam must be indicated manually using @code{[} and
@code{]}, and the beam feathering is turned on by specifying a 
direction to the Beam property @code{grow-direction}.

If the placement of the notes and the sound in the MIDI output
is to reflect the ritardando or accelerando indicated by the
feathered beam the notes must be grouped as a
music expression delimited by braces and preceded by a
@code{featheredDurations} command which specifies the ratio
between the durations of the first and last notes in the group.

The square brackets
show the extent of the beam and the braces show
which notes are to have their durations modified.  Normally 
these would delimit the same group of notes, but this is not
required: the two commands are independent. 

In the following example the eight 16th notes occupy exactly
the same time as a half note, but the first note is twice
as short as the last one, with the intermediate notes gradually
lengthening.  The first four 32nd notes gradually speed up,
while the last four 32nd notes are at a constant tempo.

@lilypond[ragged-right,relative=1,fragment,verbatim,quote]
\override Beam #'grow-direction = #LEFT
\featherDurations #(ly:make-moment 2 1)
{ c16[ c c c c c c c] }
\override Beam #'grow-direction = #RIGHT
\featherDurations #(ly:make-moment 2 3)
{ c32[ d e f] }
% revert to non-feathered beams
\override Beam #'grow-direction = #'()
{ g32[ a b c] }
@end lilypond

@noindent
The spacing in the printed output represents the 
note durations only approximately, but the midi output is exact.


@commonprop

Line breaking is prevented by beams which straddle barlines. The
@samp{breakable} property of @code{Beam} allows this behaviour
to be overridden:

@lilypond[ragged-right,relative=2,fragment,verbatim,quote]
\override Beam #'breakable = ##t
c8 \repeat unfold 15 {c[ c] } c
@end lilypond


@refbugs

The @code{\featherDurations} command only works with very short
music snippets, and when numbers in the fraction are small.

@seealso

Snippets: @lsrdir{rhythms}



@node Bars
@subsection Bars


@menu
* Bar lines::                   
* Bar numbers::                 
* Bar and bar number checks::   
* Rehearsal marks::             
@end menu

@node Bar lines
@unnumberedsubsubsec Bar lines

@cindex Bar lines
@cindex Barlines
@funindex \bar
@cindex measure lines
@cindex repeat bars

Bar lines delimit measures, and are also used to indicate
repeats.  Normally, simple bar lines are automatically inserted
into the printed output at places based on the current time 
signature.  

The simple bar lines inserted automatically can be changed to 
other types with the @code{\bar} command.  For example, a closing
double bar line is usually placed at the end of a piece:

@lilypond[quote,ragged-right,relative=1,fragment,verbatim]
e4 d c2 \bar "|."
@end lilypond

@warning{An incorrect duration can lead to poorly formatted
music.}
 
It is not invalid if the final note in a bar does not 
end on the automatically entered bar line: the note is assumed 
to carry over into the next bar.  But if a long sequence
of such carry-over bars appears the music can appear compressed
or even flowing off the page.  This is because automatic line
breaks happen only at the end of complete bars, i.e. where 
the end of a note coincides with the end of a bar.

Line breaks are also permitted at manually inserted bar lines
even within incomplete bars.  To allow a line break without 
printing a bar line, use

@example
\bar ""
@end example

@noindent
This will insert an invisible bar line and allow (but not
force) a line break to occur at this point.  The bar number 
counter is not increased.  To force a line break see 
@ref{Line breaking}.

This and other special bar lines may be inserted manually at any
point.  When they coincide with the end of a bar they replace
the simple bar line which would have been inserted there 
automatically.  When they do not coincide
with the end of a bar the specified bar line is inserted at that
point in the printed output.  Such insertions do not affect
the calculation and placement of subsequent automatic bar lines.  

The simple bar line and four types of double bar line are available
for manual insertion:

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
f1 \bar "|" g \bar "||" a \bar ".|" b \bar ".|." c \bar "|." d
@end lilypond

@noindent
together with dotted and dashed bar lines:

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
f1 \bar ":" g \bar "dashed" a
@end lilypond

@noindent
and three types of repeat bar line:

@lilypond[quote,ragged-right,fragment,relative=1,verbatim]
f1 \bar "|:" g \bar ":|:" a \bar ":|" b
@end lilypond

Although the bar line types signifying repeats may be inserted
manually they do not in themselves cause LilyPond to recognise
a repeated section.  Such repeated sections are better entered
using the various repeat commands (see @ref{Repeats}), which
automatically print the appropriate bar lines.

In addition, you can specify @code{"||:"}, which is equivalent to
@code{"|:"} except at line breaks, where it gives a double bar
line at the end of the line and a start repeat at the beginning of
the next line. 

@lilypond[quote,ragged-right,relative=2,fragment,verbatim]
\override Score.RehearsalMark #'padding = #3
c c c c
\bar "||:" 
c c c c \break
\bar "||:" 
c c c c
@end lilypond

In scores with many staves, a @code{\bar} command in one staff is
automatically applied to all staves.  The resulting bar lines are
connected between different staves of a @code{StaffGroup},
@code{PianoStaff}, or @code{GrandStaff}.

@lilypond[quote,ragged-right,fragment,verbatim]
<<
  \new StaffGroup <<
    \new Staff {
      e'4 d'
      \bar "||"
      f' e'
    }
    \new Staff { \clef bass c4 g e g }
  >>
  \new Staff { \clef bass c2 c2 }
>>
@end lilypond


@commonprop

@funindex whichBar
@funindex defaultBarType

The command @code{\bar }@var{bartype} is a shortcut for
@code{\set Timing.whichBar = }@var{bartype}.  A bar line is 
created whenever the @code{whichBar} property is
set.  

The default bar type used for automatically inserted bar lines is
@code{"|"}.  This may be changed at any time
with @code{\set Timing.defaultBarType = }@var{bartype}.  

@seealso

In this manual: @ref{Repeats}, @ref{System start delimiters}.

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{BarLine} (created at
@internalsref{Staff} level), @internalsref{SpanBar} (across
staves), @internalsref{Timing_translator} (for Timing 
properties).


@node Bar numbers
@unnumberedsubsubsec Bar numbers

@cindex Bar numbers
@cindex measure numbers
@funindex currentBarNumber

Bar numbers are typeset by default at the start of every line
except the first line.  The
number itself is stored in the @code{currentBarNumber} property,
which is normally updated automatically for every measure.  It
may also be set manually:

@lilypond[verbatim,ragged-right,quote,fragment,relative]
c1 c c c
\break
\set Score.currentBarNumber = #50
c1 c c c
@end lilypond


@commonprop

@funindex barNumberVisibility
@cindex bar numbers, regular spacing

Bar numbers can be typeset at regular intervals instead of just at
the beginning of every line.  To do this the default behaviour
must be overridden to permit bar numbers to be printed at places
other than the start of a line.  This is controlled by the
@code{break-visibility} property of @code{BarNumber}.  This takes
three values which may be set to @code{#t} or @code{#f} to specify
whether the corresponding bar number is visible or not.  The order
of the three values is @code{end of line visible}, @code{middle of
line visible}, @code{beginning of line visible}.  In the following
example bar numbers are printed at all possible places:

@lilypond[verbatim,ragged-right,quote,fragment,relative]
\override Score.BarNumber #'break-visibility = ##(#t #t #t)
\set Score.currentBarNumber = #11
\bar ""  % Permit first bar number to be printed
c1 c c c
\break
c c c c
@end lilypond

@c  All the rest of these examples will be added to LSR
@c  and moved into the Snippets.  -gp

@noindent
and here the bar numbers are printed every two bars
except at the end of the line:

@lilypond[verbatim,ragged-right,quote,fragment,relative]
\override Score.BarNumber #'break-visibility = ##(#f #t #t)
\set Score.currentBarNumber = #11
\bar ""  % Permit first bar number to be printed
% Print a bar number every 2nd bar
\set Score.barNumberVisibility = #(every-nth-bar-number-visible 2)
c1 c c c c
\break
c c c c c
@end lilypond

The size of the bar number may be changed.  This is illustrated
in the following example, which also shows how to enclose bar 
numbers in boxes and circles, and shows an alternative way
of specifying @code{#(#f #t #t)} for @code{break-visibility}.

@lilypond[verbatim,ragged-right,quote,fragment,relative]
% Prevent bar numbers at the end of a line and permit them elsewhere
\override Score.BarNumber #'break-visibility
  = #end-of-line-invisible

% Increase the size of the bar number by 2 
\override Score.BarNumber #'font-size = #2
\repeat unfold 3 { c1 } \bar "|"

% Draw a box round the following bar number(s)
\override Score.BarNumber  #'stencil
  = #(make-stencil-boxer 0.1 0.25 ly:text-interface::print)
\repeat unfold 3 { c1 } \bar "|"

% Draw a circle round the following bar number(s)
\override Score.BarNumber  #'stencil
  = #(make-stencil-circler 0.1 0.25 ly:text-interface::print)
\repeat unfold 4 { c1 } \bar "|."
@end lilypond

@cindex Bar number alignment

Bar numbers by default are left-aligned to their parent object.
This is usually the left edge of a line or, if numbers are printed
within a line, the left bar line of the bar.  The numbers may also
be positioned directly on the bar line or right-aligned to the 
bar line:

@lilypond[verbatim,ragged-right,quote,fragment,relative]
\set Score.currentBarNumber = #111
\override Score.BarNumber #'break-visibility = ##(#t #t #t)
% Increase the size of the bar number by 2
\override Score.BarNumber #'font-size = #2
% Print a bar number every 2nd bar
\set Score.barNumberVisibility = #(every-nth-bar-number-visible 2)
c1 c1
% Centre-align bar numbers
\override Score.BarNumber #'self-alignment-X = #0
c1 c1
% Right-align bar numbers
\override Score.BarNumber #'self-alignment-X = #-1
c1 c1
@end lilypond

Bar numbers can be removed entirely by removing the Bar number
engraver from the score context.

@lilypond[verbatim,ragged-right,quote]
\layout {
  \context {
    \Score
    \remove "Bar_number_engraver"
  }
}
\relative c''{
  c4 c c c \break
  c4 c c c
}
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{BarNumber}.

Examples: @lsrdir{bar number}


@refbugs

Bar numbers may collide with the top of the
@internalsref{StaffGroup} bracket, if there is one.  To solve
this, the @code{padding} property of @internalsref{BarNumber} can
be used to position the number correctly.

Bar numbers may only be printed at bar lines; to print a bar
number at the beginning of a piece, an empty bar line must be
inserted there, and a value other than @code{1} must be placed
in @code{currentBarNumber}:

@lilypond[verbatim,ragged-right,quote,fragment,relative]
\set Score.currentBarNumber = #50
\bar ""
c1 c c c
c1 c c c
\break
@end lilypond



@node Bar and bar number checks
@unnumberedsubsubsec Bar and bar number checks

@cindex Bar check
@funindex barCheckSynchronize
@funindex |

Bar checks help detect errors in the entered durations.
A bar check may be entered using the bar symbol, @samp{|}, 
at any place where a bar line is expected to fall.  
If bar check lines are encountered at other places, 
a list of warnings is printed in the log file,
showing the line numbers and lines  
in which the bar checks failed.  In the next
example, the second bar check will signal an error

@example
\time 3/4 c2 e4 | g2 |
@end example

Bar checks can also be used in lyrics, for example

@example
\lyricmode @{
  \time 2/4
  Twin -- kle | Twin -- kle |
@}
@end example

An incorrect duration can result in a completely garbled score,
especially if the score is polyphonic, so a good place to start
correcting input is by scanning for failed bar checks and
incorrect durations.

@funindex |
@funindex pipeSymbol

It is also possible to redefine the action taken when a bar check 
or pipe symbol, @samp{|}, is encountered in the input, so that 
it does something other than a bar check.  This is done by 
assigning a music expression to @code{pipeSymbol}.  
In the following example @samp{|} is set to insert a double bar 
line wherever it appears in the input, rather than checking 
for end of bar.

@lilypond[quote,ragged-right,verbatim]
pipeSymbol = \bar "||"
{ 
  c'2 c'2 |
  c'2 c'2
  c'2 | c'2
  c'2 c'2
}
@end lilypond

When copying large pieces of music, it can be helpful to check
that the LilyPond bar number corresponds to the original that you
are entering from.  This can be checked with
@code{\barNumberCheck}, for example,

@verbatim
\barNumberCheck #123
@end verbatim

@noindent
will print a warning if the @code{currentBarNumber} is not 123
when it is processed.

@seealso

Snippets: @lsrdir{rhythms}


@node Rehearsal marks
@unnumberedsubsubsec Rehearsal marks

@cindex Rehearsal marks
@funindex \mark

To print a rehearsal mark, use the @code{\mark} command

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
c1 \mark \default
c1 \mark \default
c1 \mark #8
c1 \mark \default
c1 \mark \default
@end lilypond

@noindent
The letter@tie{}@q{I} is skipped in accordance with engraving
traditions.  If you wish to include the letter @q{I}, then use

@example
\set Score.markFormatter = #format-mark-alphabet
@end example

The mark is incremented automatically if you use @code{\mark
\default}, but you can also use an integer argument to set the
mark manually.  The value to use is stored in the property
@code{rehearsalMark}.

The style is defined by the property @code{markFormatter}.  It is
a function taking the current mark (an integer) and the current
context as argument.  It should return a markup object.  In the
following example, @code{markFormatter} is set to a pre-defined
procedure.  After a few measures, it is set to a procedure that
produces a boxed number.

@lilypond[fragment,quote,ragged-right,verbatim,relative=2]
\set Score.markFormatter = #format-mark-numbers
c1 \mark \default
c1 \mark \default
\set Score.markFormatter = #format-mark-box-numbers
c1 \mark \default
c1 \mark \default
c1
@end lilypond

The file @file{scm/@/translation@/-functions@/.scm} contains the
definitions of @code{format-mark-numbers} (the default format),
@code{format-mark-box-numbers}, @code{format-mark-letters} and
@code{format-mark-box-letters}.  These can be used as inspiration
for other formatting functions.

You may use @code{format-mark-barnumbers},
@code{format-mark-box-barnumbers}, and
@code{format-mark-circle-barnumbers} to get bar numbers instead of
incremented numbers or letters.

Other styles of rehearsal mark can be specified manually

@example
\mark "A1"
@end example

@noindent
@code{Score.markFormatter} does not affect marks specified in this
manner.  However, it is possible to apply a @code{\markup} to the
string.

@example
\mark \markup@{ \box A1 @}
@end example

@cindex segno
@cindex coda
@cindex D.S al Fine

Music glyphs (such as the segno sign) may be printed inside a
@code{\mark}

@lilypond[fragment,quote,ragged-right,verbatim,relative]
c1 \mark \markup { \musicglyph #"scripts.segno" }
c1 \mark \markup { \musicglyph #"scripts.coda" }
c1 \mark \markup { \musicglyph #"scripts.ufermata" }
c1
@end lilypond

@noindent
See @ref{The Feta font}, for a list of symbols which may be
printed with @code{\musicglyph}.

For common tweaks to the positioning of rehearsal marks, see
@ref{Text marks}.

@seealso

Snippets: @lsrdir{rhythms}

This manual: @ref{Text marks}.

Internals Reference: @internalsref{RehearsalMark}.

Init files: @file{scm/@/translation@/-functions@/.scm} contains
the definition of @code{format-mark-numbers} and
@code{format-mark-letters}.  They can be used as inspiration for
other formatting functions.

Examples: @lsr{parts,rehearsal-mark-numbers.ly}


@node Special rhythmic concerns
@subsection Special rhythmic concerns


@menu
* Grace notes::                 
* Aligning to cadenzas::        
* Time administration::         
@end menu

@node Grace notes
@unnumberedsubsubsec Grace notes

@funindex \grace
@cindex ornaments
@cindex grace notes
@cindex appoggiatura
@cindex acciaccatura

Grace notes are ornaments that are written out. They are made with
the @code{\grace} command.  By prefixing this keyword to a music
expression, a new one is formed, which will be printed in a
smaller font and takes up no logical time in a measure.

@lilypond[quote,ragged-right,relative=2,verbatim,fragment]
c4 \grace c16 c4
\grace { c16[ d16] } c2 c4
@end lilypond

Two special forms of the @code{\grace} command exist.
An @emph{acciaccatura}, which should be played as very short,
is denoted by a slurred small note with a slashed stem.  The
@emph{appoggiatura}, a grace note that takes a fixed fraction of the
main note, is denoted as a slurred note in small print without
a slash.  They are entered with the commands @code{\acciaccatura}
and @code{\appoggiatura}, as demonstrated in the following
example:

@lilypond[quote,ragged-right,relative=2,verbatim,fragment]
b4 \acciaccatura d8 c4 
\appoggiatura e8 d4
\acciaccatura { g16[ f] } e4
@end lilypond

@noindent
@code{\acciaccatura} and @code{\appoggiatura} start a slur, 
@code{\grace} does not.

The placement of grace notes is synchronized between different
staves.  In the following example, there are two sixteenth grace
notes for every eighth grace note

@lilypond[quote,ragged-right,relative=2,verbatim,fragment]
<< \new Staff { e4 \grace { c16[ d e f] } e4 }
   \new Staff { c4 \grace { g8[ b] } c4 } >>
@end lilypond

@funindex \afterGrace

If you want to end a note with a grace, use the @code{\afterGrace}
command.  It takes two arguments: the main note, and the grace
notes following the main note.

@lilypond[ragged-right, verbatim,relative=2,fragment]
c1 \afterGrace d1 { c16[ d] } c4
@end lilypond

This will put the grace notes after a @q{space} lasting 3/4 of the
length of the main note.  The fraction 3/4 can be changed by
setting @code{afterGraceFraction}, ie.

@example
#(define afterGraceFraction (cons 7 8))
@end example

@noindent
will put the grace note at 7/8 of the main note.

The same effect can be achieved manually by doing

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\new Voice {
  << { d1^\trill_( }
     { s2 \grace { c16[ d] } } >>
  c4)
}
@end lilypond

@noindent
By adjusting the duration of the skip note (here it is a
half-note), the space between the main-note and the grace
may be adjusted.

A @code{\grace} music expression will introduce special
typesetting settings, for example, to produce smaller type, and
set directions.  Hence, when introducing layout tweaks, they
should be inside the grace expression, for example,

@lilypond[quote,ragged-right,fragment,verbatim,relative=2]
\new Voice {
  \acciaccatura {
    \stemDown
    f16->
    \stemNeutral
  }
  g4
}
@end lilypond

@noindent
The overrides should also be reverted inside the grace expression.

The layout of grace expressions can be changed throughout the
music using the function @code{add-grace-property}.  The following
example undefines the @code{Stem} direction for this grace, so
that stems do not always point up.

@example
\new Staff @{
  #(add-grace-property 'Voice 'Stem 'direction '())
  @dots{}
@}
@end example

@noindent
Another option is to change the variables @code{startGraceMusic},
@code{stopGraceMusic}, @code{startAcciaccaturaMusic},
@code{stopAcciaccaturaMusic}, @code{startAppoggiaturaMusic},
@code{stopAppoggiaturaMusic}.  The default values of these can be
seen in the file @file{ly/@/grace@/-init@/.ly}.  By redefining
them other effects may be obtained.

@noindent
The slash through the stem in @emph{acciaccatura}s can be obtained in
other situations by @code{\override Stem  #'stroke-style =
#"grace"}.


@commonprop

Grace notes may be forced to use align with regular notes
in other staves by setting @code{strict-grace-spacing} to
##t:

@lilypond[relative=2,ragged-right]
<<
  \override Score.SpacingSpanner #'strict-grace-spacing = ##t
  \new Staff {
     c'4
     \afterGrace
     c'4
     { c'16[ c'8 c'16] }
     c'4
  }  
  \new Staff {
     c'16[ c'16 c'16 c'16]
     c'16[ c'16 c'16 c'16]
     c'4
  }
>>
@end lilypond


@seealso

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{GraceMusic}.


@refbugs

A multi-note beamed @emph{acciaccatura} is printed without a slash, 
and looks exactly the same as a multi-note beamed
@emph{appoggiatura}.
@c TODO Add link to LSR snippet to add slash when available 

Grace note synchronization can also lead to surprises.  Staff
notation, such as key signatures, bar lines, etc., are also
synchronized.  Take care when you mix staves with grace notes and
staves without, for example,

@lilypond[quote,ragged-right,relative=2,verbatim,fragment]
<< \new Staff { e4 \bar "|:" \grace c16 d4 }
   \new Staff { c4 \bar "|:" d4 } >>
@end lilypond

@noindent
This can be remedied by inserting grace skips of the corresponding
durations in the other staves.  For the above example

@lilypond[quote,ragged-right,relative=2,verbatim,fragment]
<< \new Staff { e4 \bar "|:" \grace c16 d4 }
   \new Staff { c4 \bar "|:" \grace s16 d4 } >>
@end lilypond

Grace sections should only be used within sequential music
expressions.  Nesting or juxtaposing grace sections is not
supported, and might produce crashes or other errors.

@node Aligning to cadenzas
@unnumberedsubsubsec Aligning to cadenzas

In an orchestral context, cadenzas present a special problem: when
constructing a score that includes a cadenza, all other
instruments should skip just as many notes as the length of the
cadenza, otherwise they will start too soon or too late.

A solution to this problem are the functions
@code{mmrest-of-length} and @code{skip-of-length}.  These Scheme
functions take a piece of music as argument, and generate a
multi-rest or @code{\skip}, exactly as long as the piece.  The use
of @code{mmrest-of-length} is demonstrated in the following
example.

@lilypond[verbatim,ragged-right,quote]
cadenza = \relative c' {
  c4 d8 << { e f g } \\ { d4. } >>
  g4 f2 g4 g
}

\new GrandStaff <<
  \new Staff { \cadenza c'4 }
  \new Staff {
    #(ly:export (mmrest-of-length cadenza))
    c'4
  }
>>
@end lilypond

@seealso

Snippets: @lsrdir{rhythms}


@node Time administration
@unnumberedsubsubsec Time administration

@cindex Time administration

@funindex currentBarNumber
@funindex measurePosition
@funindex measureLength

Time is administered by the @code{Timing_translator}, which by
default is to be found in the @code{Score} context.  An alias,
@code{Timing}, is added to the context in which the
@code{Timing_translator} is placed.

The following properties of @code{Timing} are used
to keep track of timing within the score.
 
@table @code
@item currentBarNumber
The current measure number.  For an example showing the
use of this property see @ref{Bar numbers}.

@item measureLength
The length of the measures in the current time signature.  For a
4/4 time this is@tie{}1, and for 6/8 it is 3/4.  Its value
determines when bar lines are inserted and how automatic beams
should be generated.

@item measurePosition
The point within the measure where we currently are.  This
quantity is reset by subtracting @code{measureLength} whenever
@code{measureLength} is reached or exceeded.  When that happens, 
@code{currentBarNumber} is incremented.

@item timing
If set to true, the above variables are updated for every time
step.  When set to false, the engraver stays in the current
measure indefinitely.

@end table

Timing can be changed by setting any of these variables
explicitly.  In the next example, the default 4/4 time 
signature is printed, but @code{measureLength} is set to 5/4.
At 4/8 through the third measure, the @code{measurePosition} is
advanced by 1/8 to 5/8, shortening that bar by 1/8.
The next bar line then falls at 9/8 rather than 5/4.

@lilypond[quote,ragged-right,verbatim,relative,fragment]
\set Score.measureLength = #(ly:make-moment 5 4)
c1 c4
c1 c4
c4 c4
\set Score.measurePosition = #(ly:make-moment 5 8)
b4 b4 b8
c4 c1
@end lilypond

@noindent
As the example illustrates, @code{ly:make-moment n m} constructs a
duration of n/m of a whole note.  For example,
@code{ly:make-moment 1 8} is an eighth note duration and
@code{ly:make-moment 7 16} is the duration of seven sixteenths
notes.


@seealso

This manual: @ref{Bar numbers}, @ref{Unmetered music}

Snippets: @lsrdir{rhythms}

Internals Reference: @internalsref{Timing_translator},
@internalsref{Score}