Nothing
library(dplyr)
test_that("note helpers return as expected", {
notes <- "bd'f#' a c'e'g' b ba c'g' gd'g'd''"
expect_identical(note_sort(notes),
as_noteworthy("gd'g'd'' a ba b bd'f#' c'e'g' c'g'"))
expect_equal(note_sort(notes, decreasing = TRUE),
as_noteworthy("c'g' c'e'g' bd'f#' b ba a gd'g'd''"))
notes <- "a b c,e_g' d# e_ f g"
expect_identical(note_slice(notes, c(2:3, 6)), as_noteworthy("b c,e_g' f"))
expect_identical(note_slice(notes, c(F, T, T, F, F, T, F)),
as_noteworthy("b c,e_g' f"))
expect_identical(note_slice(notes, 6:8), as_noteworthy("f g"))
expect_identical(note_slice(strsplit(notes, " ")[[1]], 6:8),
as_noteworthy(c("f", "g")))
expect_error(
note_slice(notes, "a"),
"Must provide integer or logical vector index to slice `notes`.")
expect_error(
note_slice(notes, F),
"Logical vector must be same length as the number of timesteps in `notes`."
)
expect_error(note_slice(notes, 8), "Index out of bounds.")
y <- as_noteworthy("a r")
expect_true(note_has_rest(y))
expect_equal(as_space_time(y), y)
expect_equal(as_vector_time(y), as_noteworthy(y, format = "vector"))
expect_equal(as_space_time(as.character(y)), y)
expect_equal(as_vector_time(as.character(y)),
as_noteworthy(y, format = "vector"))
expect_identical(note_rotate(notes, 3), as_noteworthy("d# e_ f g a b c,e_g'"))
expect_identical(note_rotate(notes, 0), notes)
expect_identical(note_rotate(notes, 3), as_noteworthy("d# e_ f g a b c,e_g'"))
expect_identical(pretty_notes(notes), "A B CEbG D# Eb F G")
expect_identical(pretty_notes(notes, FALSE), "A B C,EbG' D# Eb F G")
expect_identical(note_shift("c4 e' g'", 1), as_noteworthy("e' g' c''"))
expect_identical(note_shift("c e_ g", -4) |> as.character(), "g,, c, e_,")
expect_identical(note_shift("c4 e_4 g4", -3) |> as.character(), "c e_ g")
expect_identical(note_shift("a", 1), as_noteworthy("a'"))
expect_identical(note_shift("a b ceg"), as_noteworthy("c e g a b"))
expect_identical(note_shift(c("a", "b", "ceg")),
as_vector_time(as_noteworthy("c e g a b")))
expect_identical(note_shift("a"), as_noteworthy("a"))
expect_identical(note_shift("a", -1), as_noteworthy("a,"))
expect_equal(note_arpeggiate("c e g") |> as.character(), "c e g")
expect_equal(note_arpeggiate("c,,", 1) |> as.character(), "c,, c,")
expect_equal(note_arpeggiate("c,, d,,", 1) |> as.character(),
"c,, d,, c, d,")
expect_equal(note_arpeggiate("c e g ceg", 1) |> as.character(),
"c e g ceg c' e' g' c'e'g'")
expect_equal(note_arpeggiate("c e g ceg", 1, -12) |> as.character(),
"c e g ceg c, e, g, c,e,g,")
expect_equal(note_arpeggiate("gec", 2, -1) |> as.character(),
"gec g_e_b, fdb_,")
expect_equal(note_arpeggiate("c# e g", 2, 1) |> as.character(),
"c# e g d f g# d# f# a")
expect_equal(note_arpeggiate("c e g", 2) |> as.character(),
"c e g c' e' g' c'' e'' g''")
expect_equal(note_arpeggiate("c2 d#2 g2", 1, -2) |> as.character(),
"c2 d#2 g2 a#1 c#2 f2")
expect_error(note_arpeggiate("a", -1), "`n` cannot be negative.")
expect_equal(sharpen_flat("a,") |> as.character(), "a,")
expect_equal(sharpen_flat("a_,") |> as.character(), "g#,")
expect_equal(flatten_sharp("a#2") |> as.character(), "b_2")
expect_equal(naturalize(notes) |> as.character(),
"a b c,eg' d e f g")
expect_equal(naturalize(notes, "flat") |> as.character(),
"a b c,eg' d# e f g")
expect_equal(naturalize(notes, "sharp") |> as.character(),
"a b c,e_g' d e_ f g")
expect_equal(note_set_key(notes, "f") |> as.character(),
"a b c,e_g' e_ e_ f g")
expect_equal(note_set_key(notes, "g") |> as.character(),
"a b c,d#g' d# d# f g")
x <- "a# b_ c, d'' e3 g_4 A m c2e_2g2 cegh"
expect_equal(is_note(x), c(rep(TRUE, 6), rep(FALSE, 4)))
expect_equal(is_chord(x), c(rep(FALSE, 8), TRUE, FALSE))
expect_false(noteworthy(x))
x <- strsplit(x, " ")[[1]][c(1:6, 9)]
expect_true(noteworthy(x))
expect_equal(is_diatonic("a a_ a# b c"), c(TRUE, FALSE, FALSE, TRUE, TRUE))
y <- "a# b_ c, d'' e3 g_4 c2e_2g2"
y <- as_noteworthy(y)
expect_is(y, "noteworthy")
expect_is(summary(y), "NULL")
expect_is(summary(as_noteworthy("a_,*2")), "NULL")
expect_is(summary(as_noteworthy("a#2*4")), "NULL")
expect_is(summary(as_noteworthy("a_*2 a#*3")), "NULL")
expect_is(print.noteworthy("a*1"), "NULL")
expect_is(print.noteworthy(c("a", "a")), "NULL")
y <- as_noteworthy(y, "tick", "sharp", "vector")
expect_identical(
y, as_noteworthy(c("a#*2", "c,", "d''", "e", "f#'", "c,d#,g,")))
expect_error(as_noteworthy("a", format = "a"),
"`format` must be 'space' or 'vector' if not NULL.")
expect_error(as_noteworthy("a", octaves = "a"),
"`octaves` must be 'tick' or 'integer' if not NULL.")
expect_error(as_noteworthy("a", accidentals = "a"),
"`accidentals` must be 'flat' or 'sharp' if not NULL.")
x <- x[1:6]
expect_equal(note_is_natural(x), c(F, F, T, T, T, F))
expect_identical(note_is_natural(x), !note_is_accidental(x))
expect_equal(note_is_flat(x), c(F, T, F, F, F, T))
expect_equal(note_is_sharp(x), c(T, rep(F, 5)))
expect_true(note_has_accidental(x))
expect_true(note_has_natural(x))
x <- "e_2 a_, c#f#a#'"
expect_identical(note_set_key(x, "f"), note_set_key(x, "flat"))
expect_identical(note_set_key(x, "g"), as_noteworthy("d#, g#, c#f#a#'"))
expect_identical(as_tick_octaves(x), as_noteworthy("e_, a_, c#f#a#'"))
expect_identical(as_integer_octaves(x), as_noteworthy("e_2 a_2 c#f#a#4"))
y <- as_vector_time(x)
expect_equal(length(y), 3)
expect_identical(as_space_time(y), as_noteworthy(x))
expect_true(is_space_time(as_space_time(y)))
expect_error(note_rotate("a b x"), "Invalid notes or chords found.")
})
test_that("Note metadata inspection works", {
x <- "e_2 a_, c#f#a#"
expect_identical(n_steps(x), 3L)
expect_identical(n_notes(x), 2L)
expect_identical(n_chords(x), 1L)
expect_equal(octave_type(x), "tick")
expect_equal(accidental_type(x), "flat")
expect_equal(time_format(x), "space-delimited time")
expect_error(accidental_type("z"),
"Cannot coerce string to 'noteworthy' or 'music'.")
x <- "e_2 a_, b2 c c' c''g'' c''g'' c#f#a#"
expect_identical(n_steps(x), 8L)
expect_identical(n_notes(x), 5L)
expect_identical(n_chords(x), 3L)
expect_identical(n_octaves(x), 4L)
expect_equal(nrow(tally_notes(x)), 8)
expect_equal(nrow(tally_pitches(x)), 10)
expect_equal(nrow(tally_octaves(x)), 4)
expect_identical(n_notes(distinct_notes(x)), 8L)
expect_identical(n_notes(distinct_pitches(x)), 10L)
expect_identical(distinct_octaves(x), 2:5)
expect_identical(pitch_range(x), c("e_,", "g''"))
expect_identical(pitch_range("e_2"), c("e_2", "e_2"))
expect_identical(semitone_range(x), c(39L, 79L))
expect_identical(semitone_span(x), 40L)
expect_identical(octave_range(x), c(2L, 5L))
expect_identical(octave_span(x), 3L)
expect_true(is_space_time("a"))
expect_true(is_vector_time(c("a", "a")))
})
test_that("note equivalence functions return as expected", {
x <- "b_2 ce_g"
y <- "b_ cd#g"
expect_equal(note_is_equal(x, y), c(T, T))
expect_equal(note_is_identical(x, y), c(T, F))
expect_equal(note_is_identical("a", "a a"), NA)
x <- "b_2 ce_g"
y <- "b_2 cd#g"
expect_equal(pitch_is_equal(x, y), c(T, T))
expect_equal(pitch_is_identical(x, y), c(T, F))
expect_equal(pitch_is_equal("a", "a a"), NA)
expect_equal(pitch_is_identical("a", "a a"), NA)
x <- "b_2 ce_g b_"
y <- "b_2 ce_gb_"
expect_equal(note_is_equal(x, y), NA)
x <- "b_2 ce_g b_"
y <- "b_2 ce_ gb_"
expect_equal(note_is_equal(x, y), c(T, F, F))
x <- "a1 b_2 a1b2c3 a1b4 g1a1b1"
y <- "a_2 g#2 d1e1f2g3 a1b2b4 d1e1"
expect_equal(octave_is_equal(x, y), c(F, T, T, T, T))
expect_equal(octave_is_identical(x, y), c(F, T, T, F, T))
expect_equal(octave_is_identical(x, y, single_octave = TRUE),
c(F, T, F, F, T))
expect_equal(octave_is_identical("a1 a1", "b1 b2", single_octave = TRUE),
c(TRUE, FALSE))
expect_equal(
octave_is_identical("a2c2 a2c2", "b2d2 b1d2", single_octave = TRUE),
c(TRUE, FALSE))
expect_equal(octave_is_equal("a", "a a"), NA)
expect_equal(octave_is_identical("a", "a a"), NA)
x <- c("b_2", "ce_g")
y <- c("b_", "cd#g")
expect_equal(note_is_equal(x, y), c(T, T))
expect_equal(note_is_identical(x, y), c(T, F))
x <- c("b_2", "ce_g")
y <- c("b_2", "cd#g")
expect_equal(pitch_is_equal(x, y), c(T, T))
expect_equal(pitch_is_identical(x, y), c(T, F))
x <- c("b_2", "ce_g", "b_")
y <- c("b_2", "ce_gb_")
expect_equal(note_is_equal(x, y), NA)
x <- c("b_2", "ce_g", "b_")
y <- c("b_2", "ce_", "gb_")
expect_equal(note_is_equal(x, y), c(T, F, F))
x <- c("a,,", "b_,", "a,,b,c3", "a,,b'", "g,,a,,b,,")
y <- c("a_2", "g#2", "d1e1f2g3", "a1b2b4", "d1e1")
expect_equal(octave_is_equal(x, y), c(F, T, T, T, T))
expect_equal(octave_is_identical(x, y), c(F, T, T, F, T))
expect_equal(octave_is_identical(x, y, single_octave = TRUE),
c(F, T, F, F, T))
})
test_that("note_ngram returns as expected", {
x <- as_noteworthy("a, ceg")
y <- note_ngram(x)
expect_equal(length(y), 2)
expect_equal(sapply(y, length), c(1, 2))
y <- note_ngram(x, tally = TRUE)
expect_equal(dim(y), c(2, 2))
expect_error(note_ngram("a", n = 0),
"`n` must be >= 1 and <= number of timesteps.")
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.