There are a number of functions that assist with music programming
around note and pitch validation, comparison, equivalence checking, and
various manipulations and transformations. In a previous section, you
saw is_note() and is_chord(). Other identity
functions include:
note_has_natural()note_has_accidental()note_has_flat()note_has_sharp()note_is_natural()note_is_accidental()note_is_flat()note_is_sharp()note_has_tick()note_has_integer()note_is_tick()note_is_integer()is_diatonic()
x <- "c e_ g b_"
note_has_accidental(x)#> [1] TRUE#> [1] FALSE TRUE FALSE TRUEThe function is_diatonic() takes a key
signature for context.
x <- "c e_ g b_ cd#g"
is_diatonic(x, key = "c")#> [1] TRUE FALSE TRUE FALSE FALSE
is_diatonic(x, key = "b_")#> [1] TRUE TRUE TRUE TRUE FALSEThere are a number of functions that parse basic metadata about noteworthy strings.
n_steps()n_notes()n_chords()n_octaves()chord_size()octave_type()accidental_type()time_format()is_space_time()is_vector_time()See help("note-metadata") for details. A few examples
are shown here.
x <- "e_2 a_, c#f#a#"
n_steps(x)#> [1] 3
n_notes(x)#> [1] 2
n_chords(x)#> [1] 1
chord_size(x)#> [1] 1 1 3
octave_type(x)#> [1] "tick"
time_format(x)#> [1] "space-delimited time"While there is not a clear delineation between the previous set of functions and the next, it helps to break them up a bit since there are many. These functions go bit further in summarizing the data in noteworthy strings.
tally_notes()tally_pitches()octaves()tally_octaves()distinct_notes()distinct_pitches()distinct_octaves()pitch_range()semitone_range()semitone_span()octave_range()octave_span()See help("note-summaries") for details. Here are some
examples.
x <- "e_2 a_, b_, c#f#a# c#'f#'a#''"
tally_notes(x)#> # A tibble: 6 × 2
#> note n
#> <chr> <int>
#> 1 c# 2
#> 2 e_ 1
#> 3 f# 2
#> 4 a_ 1
#> 5 a# 2
#> 6 b_ 1#> # A tibble: 9 × 2
#> pitch n
#> <chr> <int>
#> 1 e_2 1
#> 2 a_, 1
#> 3 b_, 1
#> 4 c# 1
#> 5 f# 1
#> 6 a# 1
#> 7 c#' 1
#> 8 f#' 1
#> 9 a#'' 1#> <Noteworthy string>
#> Format: space-delimited time
#> Values: d_ e_ g_ a_ b_ b_#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e_, a_, b_, d_ g_ b_ d_' g_' b_''
pitch_range(x)#> [1] "e_," "b_''"#> [1] 39 82Note that it is common for functions to treat notes as different if
they sound the same but one is transcribed as a flat and the other as a
sharp. tabr makes the distinction for notation purposes;
same pitch, different notes. This also supports transcription. Functions
like transpose() of course handle pitch as pitch and
therefore the style of representation does not affect computation.
There are functions for enforcing a singular representation for accidentals in noteworthy strings since it is unusual to mix flats and sharps.
#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e_, a_, b_, <d_g_b_> <d_'g_'b_''>
sharpen_flat(x)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: d#, g#, a#, <c#f#a#> <c#'f#'a#''>Do not be confused about the names of these functions. They are for
enforcing a single type of accidental. To actually lower sharps by a
half step or semitone as well as raise flats similarly, use
naturalize().
naturalize(x)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e, a, b, <cfa> <c'f'a''>These are helpful building blocks for music programming. A useful
wrapper around flatten_sharp() and
sharpen_flat() is note_set_key(). Like
is_diatonic(), this function takes a key
argument. key was more meaningful for
is_diatonic. However, providing a key signature here is
helpful for the purpose of enforcing the correct representation of
accidentals intended by the user, which tabr cannot know
until informed.
Be aware that the default for functions that take a key
argument is c, but c and am have
no accidentals in their key signatures, so note_set_key()
will have no effect if you pass these values to key. It is
also important to recognize that it does not matter for this function
what key you choose specifically; it only matters that you choose a key
that has the type of accidentals in its signature that you wish to force
your noteworthy string to use. If you want flats, it makes no difference
if you set key = "f" or key = "b_". For this
function, you can also literally enter key = "flat" or
key = "sharp", options that stress the extent to which
key actually matters to note_set_key().
note_set_key(x, "c") # no change possible#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e_, a_, b_, <d_g_b_> <d_'g_'b_''>
note_set_key(x, "f") # key of F has a flat#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e_, a_, b_, <d_g_b_> <d_'g_'b_''>
note_set_key(x, "g") # key of G has a sharp#> <Noteworthy string>
#> Format: space-delimited time
#> Values: d#, g#, a#, <c#f#a#> <c#'f#'a#''>The intent is not to force notes which may not be diatonic to the key signature to fit that signature. All pitches remain exactly what they are. It does not matter if they are not in the key. But they are forced to conform to a key’s representation of accidentals.
For other functions in tabr, key arguments
utilize the specific key signature in a more complete manner, and the
options flat and sharp are not relevant or
allowed.
Octave numbering can be ambiguous, including both tick and integer numbering format. You can coerce a noteworthy string strictly to one of the other:
x <- "c, c c' c2 c c4"
as_integer_octaves(x)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: c2 c c4 c2 c c4#> <Noteworthy string>
#> Format: space-delimited time
#> Values: c, c c' c, c c'In general, functions that operate on and return noteworthy strings will perform coercion to an internally consistent format. If formatting is ambiguous, the default is tick octave numbering and flats for accidentals.
Similarly, you can coerce the time format of a noteworthy string between space-delimited time and vectorized time:
(x <- as_space_time(c("c", "e", "g", "ceg")))#> <Noteworthy string>
#> Format: space-delimited time
#> Values: c e g <ceg>
(y <- as_vector_time("c e g ceg"))#> <Noteworthy string>
#> Format: vectorized time
#> Values: c e g <ceg>
as.character(x)#> [1] "c e g ceg"
as.character(y)#> [1] "c" "e" "g" "ceg"The note_is_* functions mentioned earlier are
vectorized, but the operations they perform are self checks. Other
functions are available for comparative checks of identity or
equivalence between two notes. These functions are also vectorized. Each
note input can be an entire noteworthy string.
There are different dimensions along which the strictness of equality varies and are worth taking a moment to break these and other properties down clearly:
*_is_equal and
*is_identical pairs. Equality is more relaxed than
identity.note_is_* pairs below also offer the argument
ignore_octave. This further weakens the requirements for
passing both equality and identity comparisons of two notes.e_ and d#, they are
equal, but not identical.octave_is_* pairs.First look at note and pitch comparisons. The main difference is that
pitch is more complete than note in that the former implicitly carries
the octave position. Setting ignore_octave = FALSE for note
comparisons makes them equivalent to their pitch comparison
counterparts.
x <- "b_2 ce_g"
y <- "b_ cd#g"
note_is_equal(x, y)#> [1] TRUE TRUE
note_is_identical(x, y)#> [1] TRUE FALSE
pitch_is_equal(x, y)#> [1] FALSE TRUE
pitch_is_identical(x, y)#> [1] FALSE FALSEThere are minimal requirements for equivalence that precede the forms
and degrees of equivalence described and shown above. At a bare minimum,
two noteworthy strings must have the same number of time steps available
for pairwise comparison. Otherwise a simple NA is returned.
In the following example, the strings x and y
have the same number of notes, in the same order, but the first has
three times steps and the second has two.
x <- "b_2 ce_g b_"
y <- "b_2 ce_gb_"
note_is_equal(x, y)#> [1] NAIn the next example, x and y have the same
number of of the same notes, again in the same order, and even have an
equal number of timesteps. Having the same number of timesteps makes
pairwise comparisons possible. They return FALSE where
unequal.
x <- "b_2 ce_g b_"
y <- "b_2 ce_ gb_"
note_is_equal(x, y)#> [1] TRUE FALSE FALSEFinally, there are octave comparisons, which must be defined and
behave somewhat differently. octave_is_equal() and
octave_is_identical() allow much weaker forms of
equivalence in that they ignore notes completely. These functions are
only concerned with comparing the octave numbers spanned by any pitches
present at each timestep.
When checking for equality, octave_is_equal() only looks
at the octave number associated with the first note at each step, e.g.,
only the root note of a chord. octave_is_identical()
compares all octaves spanned at a given timestep by considering all
notes when a chord is present.
This still leaves open the definitions of equivalence. To clarify:
Consider an example: a1b2c3 is identical to
d1e1f2g3. The notes are irrelevant. The number of notes is
irrelevant. The fact that octave number one occurs a different number of
times in each chord is irrelevant. What matters is that they both have
the same set of unique octave positions {1, 2, 3}. To be
equal, even less is required. In this case it only matters that the two
chords begin with x1, where x is any note.
One alternative, for octave_is_identical() only, is to
set single_octave = TRUE. This increases the requirement
for identity to require that all notes from both chords being compared
at a given timestep share a single octave.
x <- "a1 b_2 a1b2c3 a1b4 g1a1b1"
y <- "a_2 g#2 d1e1f2g3 a1b2b4 d1e1"
octave_is_equal(x, y)#> [1] FALSE TRUE TRUE TRUE TRUE
octave_is_identical(x, y)#> [1] FALSE TRUE TRUE FALSE TRUE
octave_is_identical(x, y, single_octave = TRUE)#> [1] FALSE TRUE FALSE FALSE TRUE
x <- "a,, b_, a,,b,c a,,b' g,,a,,b,,"
y <- "a_, g#, d,,e,,f,g a,,b,b' d,,e,,"
octave_is_equal(x, y)#> [1] FALSE TRUE TRUE TRUE TRUE
octave_is_identical(x, y)#> [1] FALSE TRUE TRUE FALSE TRUE
octave_is_identical(x, y, single_octave = TRUE)#> [1] FALSE TRUE FALSE FALSE TRUEA noteworthy string can be subset by index. This can with specific integers or with a logical vector with the same length as the number of time steps.
x <- "a b ceg"
note_slice(x, 2:3)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b <ceg>
note_slice(x, c(FALSE, TRUE, TRUE))#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b <ceg>Vectorized time is more trivial but is of course handled the same way and still applies the noteworthiness check and class assignment.
x <- c("a", "b", "ceg")
note_slice(x, 2:3)#> <Noteworthy string>
#> Format: vectorized time
#> Values: b <ceg>
note_slice(x, c(FALSE, TRUE, TRUE))#> <Noteworthy string>
#> Format: vectorized time
#> Values: b <ceg>Sorting by pitch works with chords by sorting successively across
notes in a chord. For example, a, is sorted lower than
a,ce, which in turn is lower than a,e. Below
is an example where notes and chords are not sorted by pitch. The final
chord in the sequence also spans three octaves. There is also a
ba, which is itself not ordered, but this is accounted for
when sorting by successive pitches in chords.
x <- "bd'f#' a c'e'g' b ba c'g' gd'g'd''"
note_sort(x)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: <gd'g'd''> a <ba> b <bd'f#'> <c'e'g'> <c'g'>
note_sort(x, decreasing = TRUE)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: <c'g'> <c'e'g'> <bd'f#'> b <ba> a <gd'g'd''>Rotating or cycling a sequence of notes and chords in a noteworthy
string is done with note_rotate(). This is a simple
function. It only rotates the sequence left or right. It does not do any
transposition. It does not break chords, but rather rotates them
intact.
note_rotate(x, 1)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: a <c'e'g'> b <ba> <c'g'> <gd'g'd''> <bd'f#'>
note_rotate(x, -1)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: <gd'g'd''> <bd'f#'> a <c'e'g'> b <ba> <c'g'>note_shift() also rotates notes, but does so up or down
in pitch like a moving window. It requires breaking any chords into
separate notes, ordering all notes by pitch, and then shifting the
sorted notes n times, negative or positive indicating the
direction.
note_shift("c e g", 1)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: e g c'
note_shift("c e g", -4)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: g,, c, e,note_arpeggiate() is like note_shift() but
it repeats the entire sequence rather than shifting it a note at a time
and maintaining its fixed size. n refers to the number of
repeats and must be positive. steps refers to the semitone
offset.
note_arpeggiate("c e_ g_ a", 3)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: c e_ g_ a c' e_' g_' a' c'' e_'' g_'' a'' c''' e_''' g_''' a'''
note_arpeggiate("c e_ g_ a", 3, -3)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: c e_ g_ a a, c e_ g_ g_, a, c e_ e_, g_, a, cAn important function in tabr for manipulating music
notation is the transpose() function, which also has the
alias tp().
notes1 <- "c b, c d e e d c b, c c c'"
notes2 <- "c' b c' d' e' e' d' c' b c' c' c''"
transpose(notes1, 12, octaves = "integer") == as_noteworthy(notes2)#> [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUETransposing down is done with negative integers.
transpose("a_ b_' c'", 0)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: a_ b_' c'
tp("a_ b_' c'", -1)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: g a' b
tp("a_ b_' c'", 1)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: a b' d_'
tp("a# b' c#'", 11)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: a' a#'' c''
tp("a# b' c#'", -12)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: a#, b c#
tp("a# b' c#'", 13)#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b' c''' d''transpose also offers the arguments found in
as_noteworthy() for direct control over the format of the
transposed output. You can specify the key signature with
key as an optional override to accidentals. It
does not do anything more than enforce the desired format for
accidentals.
tp("a3 b4 c5", 2, key = "f")#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b d_5 d5
tp("a3 b4 c5", 2, octaves = "tick", key = "g")#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b c#'' d''
tp("a b' c''", 2, accidentals = "flat")#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b d_'' d''
tp("a, b c'e'g'", 2, octaves = "integer", accidentals = "sharp")#> <Noteworthy string>
#> Format: space-delimited time
#> Values: b2 c#4 <d4f#4a4>transpose() also works when chords are present. The next
section on music programming covers various functions related to
chords.