Atomic Vectors and Types

# How the parser reads constants: the suffix L makes an integer.
typeof(42)
#> [1] "double"
typeof(42L)
#> [1] "integer"
typeof(0x10L)
#> [1] "integer"
typeof(1e3)
#> [1] "double"
typeof(1e3L)
#> [1] "integer"
typeof(0x10)
#> [1] "double"
typeof(TRUE)
#> [1] "logical"
typeof(2i)
#> [1] "complex"
typeof("text")
#> [1] "character"
typeof(r"(C:\no\escapes)")
#> [1] "character"
typeof(NA)
#> [1] "logical"
typeof(NA_integer_)
#> [1] "integer"
typeof(NA_real_)
#> [1] "double"
typeof(NA_character_)
#> [1] "character"

# A value that cannot be an integer keeps its double type and the parser
# says so (the warning is caught here so that the script exits cleanly).
parse_message <- function(code) {
  tryCatch(
    {
      parse(text = code)
      "no warning"
    },
    warning = \(w) conditionMessage(w)
  )
}
parse_message("1.5L")
#> [1] "integer literal 1.5L contains decimal; using numeric value"
parse_message("3000000000L")
#> [1] "non-integer value 3000000000L qualified with L; using numeric value"
parse_message("12L")
#> [1] "no warning"

# class() reports one thing; dispatch uses the implicit class, which is longer.
class(1L)
#> [1] "integer"
class(1)
#> [1] "numeric"
.class2(1L)
#> [1] "integer" "numeric"
.class2(1)
#> [1] "double"  "numeric"
.class2(matrix(1:4, nrow = 2))
#> [1] "matrix"  "array"   "integer" "numeric"
inherits(1L, "integer")
#> [1] TRUE
inherits(1L, "numeric")
#> [1] FALSE
is.numeric(1L)
#> [1] TRUE
inherits(1, "numeric")
#> [1] TRUE
inherits(1, "double")
#> [1] FALSE
mode(1L) == "numeric"
#> [1] TRUE

# storage.mode<- changes the type and keeps the attributes;
# as.integer() changes the type and drops them.
m <- matrix(c(1, 2, 3, 4), nrow = 2)
typeof(m)
#> [1] "double"
storage.mode(m) <- "integer"
typeof(m)
#> [1] "integer"
m
#>      [,1] [,2]
#> [1,]    1    3
#> [2,]    2    4
as.integer(m)
#> [1] 1 2 3 4

# mode<- is the same operation with the mode vocabulary.
x <- c(2.5, 3.5)
mode(x) <- "character"
x
#> [1] "2.5" "3.5"
mode(x) <- "numeric"
x
#> [1] 2.5 3.5

# is.atomic(NULL) is FALSE since R 4.4.0 (it was TRUE before).
is.atomic(NULL)
#> [1] FALSE
is.null(NULL)
#> [1] TRUE
is.vector(NULL)
#> [1] FALSE
typeof(NULL)
#> [1] "NULL"
length(NULL)
#> [1] 0

# The help page of is.atomic() gives the way to get the old answer back.
is_atomic_or_null <- function(x) is.atomic(x) || is.null(x)
is_atomic_or_null(NULL)
#> [1] TRUE
is_atomic_or_null(1:3)
#> [1] TRUE
is_atomic_or_null(list())
#> [1] FALSE

# Atomic and recursive are not complementary: NULL and symbols are neither.
atomic_or_recursive <- function(x) {
  c(is_atomic = is.atomic(x), is_recursive = is.recursive(x))
}
atomic_or_recursive(c(a = 1, b = 3))
#>    is_atomic is_recursive
#>         TRUE        FALSE
atomic_or_recursive(list(2))
#>    is_atomic is_recursive
#>        FALSE         TRUE
atomic_or_recursive(sum)
#>    is_atomic is_recursive
#>        FALSE         TRUE
atomic_or_recursive(quote(x))
#>    is_atomic is_recursive
#>        FALSE        FALSE
atomic_or_recursive(NULL)
#>    is_atomic is_recursive
#>        FALSE        FALSE

# is.vector() is TRUE only when the names are the only attribute.
is.vector(1:3)
#> [1] TRUE
is.vector(c(a = 1, b = 2))
#> [1] TRUE
is.vector(structure(1:3, note = "a comment"))
#> [1] FALSE
is.vector(matrix(1:4, nrow = 2))
#> [1] FALSE
is.vector(factor("a"))
#> [1] FALSE
is.vector(list(1))
#> [1] TRUE
is.vector(expression(x + 1))
#> [1] TRUE
is.vector(quote(x))
#> [1] FALSE
is.vector(1:3, mode = "numeric")
#> [1] TRUE
is.vector(1:3, mode = "double")
#> [1] FALSE
is.vector(1:3, mode = "integer")
#> [1] TRUE
is.vector(1:3, mode = "list")
#> [1] FALSE

# is.atomic() does not care about attributes.
is.atomic(matrix(1:4, nrow = 2))
#> [1] TRUE
is.atomic(factor("a"))
#> [1] TRUE

# as.vector() strips every attribute of an atomic result, even the names.
as.vector(c(a = 1, b = 2))
#> [1] 1 2
as.vector(matrix(1:4, nrow = 2))
#> [1] 1 2 3 4
as.vector(factor(c("x", "y", "x")))
#> [1] "x" "y" "x"
as.vector(list(a = 1, b = 2))
#> $a
#> [1] 1
#>
#> $b
#> [1] 2
#>
as.vector(c(a = 1, b = 2), mode = "list")
#> $a
#> [1] 1
#>
#> $b
#> [1] 2
#>

# A helper that prints a value and, if there was one, the warning raised.
report <- function(expr) {
  warning_text <- NULL
  value <- withCallingHandlers(expr, warning = \(w) {
    warning_text <<- conditionMessage(w)
    invokeRestart("muffleWarning")
  })
  print(value)
  if (!is.null(warning_text)) cat("warning: ", warning_text, "\n", sep = "")
  invisible(value)
}

# as.integer() truncates towards zero; it does not round.
as.integer(c(3.9, 3.1, -3.9, -3.1))
#> [1]  3  3 -3 -3
round(c(3.9, 3.1, -3.9, -3.1))
#> [1]  4  3 -4 -3
as.integer("3.9")
#> [1] 3
as.integer(TRUE)
#> [1] 1
as.integer(c(TRUE, FALSE, NA))
#> [1]  1  0 NA

# Strings are read as numbers: blanks around the number are fine, so are
# exponents, hexadecimal, Inf and NaN; the empty string gives NA quietly.
as.numeric(c(" 12 ", "1e3", "0x1A", "-.5", "+5", "inf", "NaN", ""))
#> [1]   12.0 1000.0   26.0   -0.5    5.0    Inf    NaN     NA
# A comma, a unit, a word or the text "NA" are not numbers.
report(as.numeric("1,5"))
#> [1] NA
#> warning: NAs introduced by coercion
report(as.numeric("12 pages"))
#> [1] NA
#> warning: NAs introduced by coercion
report(as.numeric(c("7", "seven", "8")))
#> [1]  7 NA  8
#> warning: NAs introduced by coercion
report(as.integer("seven"))
#> [1] NA
#> warning: NAs introduced by coercion
report(as.numeric("NA"))
#> [1] NA
#> warning: NAs introduced by coercion
as.numeric(NA_character_)
#> [1] NA

# as.character() and as.complex().
as.character(c(1L, 25L))
#> [1] "1"  "25"
as.character(c(1.5, 100000, 0.1 + 0.2, 1 / 3))
#> [1] "1.5"               "1e+05"             "0.3"
#> [4] "0.333333333333333"
as.character(c(TRUE, NA))
#> [1] "TRUE" NA
as.complex("1+2i")
#> [1] 1+2i
report(as.numeric(1 + 2i))
#> [1] 1
#> warning: imaginary parts discarded in coercion

# The same ISBN column read as text, then forced to numbers.
report <- function(expr) {
  warning_text <- NULL
  value <- withCallingHandlers(expr, warning = \(w) {
    warning_text <<- conditionMessage(w)
    invokeRestart("muffleWarning")
  })
  print(value)
  if (!is.null(warning_text)) cat("warning: ", warning_text, "\n", sep = "")
  invisible(value)
}
books <- read.csv("books.csv")
books$isbn[c(1, 3, 9)]
#> [1] "978-0-306-40615-7" "9780001000100"     ""
report(as.numeric(books$isbn[c(1, 3, 9)]))
#> [1]           NA 9.780001e+12           NA
#> warning: NAs introduced by coercion
report(as.numeric(books$isbn[c(3, 11)]))
#> [1] 9.780001e+12 9.780009e+12
report(as.integer(books$isbn[c(3, 11)]))
#> [1] NA NA
#> warning: NAs introduced by coercion to integer range

# Hyphens are the problem, not the length: remove them first.
digits <- gsub("-", "", books$isbn, fixed = TRUE)
report(as.numeric(digits[1:3]))
#> [1] 9.780306e+12 9.780141e+12 9.780001e+12

# Numbers outside the integer range have the same message.
report(as.integer(2^31))
#> [1] NA
#> warning: NAs introduced by coercion to integer range
report(as.integer(-2^31))
#> [1] NA
#> warning: NAs introduced by coercion to integer range
report(as.integer(.Machine$integer.max))
#> [1] 2147483647
report(as.integer("2147483648"))
#> [1] NA
#> warning: NAs introduced by coercion to integer range
report(as.integer(c(1e10, 5)))
#> [1] NA  5
#> warning: NAs introduced by coercion to integer range

# A character ISBN is an identifier, not a quantity: keep it as text.
class(books$isbn)
#> [1] "character"

# as.logical() accepts a short list of spellings and gives NA for the rest,
# without a warning.
words <- c("TRUE", "true", "True", "T", "FALSE", "false", "False", "F")
as.logical(words)
#> [1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE
others <- c("yes", "no", "Y", "1", "0", "t", "TRUE ", "")
as.logical(others)
#> [1] NA NA NA NA NA NA NA NA
as.logical(c(0, 1, 2, -1, 0.5, NA, NaN))
#> [1] FALSE  TRUE  TRUE  TRUE  TRUE    NA    NA
as.logical(c(0L, 5L))
#> [1] FALSE  TRUE
as.logical(0 + 0i)
#> [1] FALSE
as.logical(as.raw(c(0, 1, 2)))
#> [1] FALSE  TRUE  TRUE

# Counting with a logical vector uses the same coercion in reverse.
answers <- c("yes", "no", "yes", "maybe")
sum(answers == "yes")
#> [1] 2
mean(answers == "yes")
#> [1] 0.5
answers %in% c("yes", "no")
#> [1]  TRUE  TRUE  TRUE FALSE

# A factor is an integer vector with levels: as.numeric() gives the codes.
sizes <- factor(c("20", "10", "20", "5"))
typeof(sizes)
#> [1] "integer"
as.integer(sizes)
#> [1] 2 1 2 3
as.numeric(sizes)
#> [1] 2 1 2 3
levels(sizes)
#> [1] "10" "20" "5"

# Go through the labels to get the numbers the labels spell.
as.numeric(as.character(sizes))
#> [1] 20 10 20  5
as.numeric(levels(sizes))[sizes]
#> [1] 20 10 20  5
is.numeric(sizes)
#> [1] FALSE
sum(as.numeric(as.character(sizes)))
#> [1] 55

# Logical values take part in arithmetic as 0 and 1.
TRUE + TRUE
#> [1] 2
typeof(TRUE + TRUE)
#> [1] "integer"
sum(c(TRUE, FALSE, TRUE, TRUE))
#> [1] 3
mean(c(TRUE, FALSE, TRUE, TRUE))
#> [1] 0.75

# Integer arithmetic stays integer, except for division and powers.
typeof(5L + 2L)
#> [1] "integer"
typeof(5L * 2L)
#> [1] "integer"
typeof(5L / 2L)
#> [1] "double"
typeof(5L %/% 2L)
#> [1] "integer"
typeof(5L^2L)
#> [1] "double"
typeof(5L + 2)
#> [1] "double"

# Comparisons coerce to the common type, and a string wins.
1 == "1"
#> [1] TRUE
TRUE == "TRUE"
#> [1] TRUE
"10" < 9
#> [1] TRUE
"10" < "9"
#> [1] TRUE

# Arithmetic does not do that; it refuses text.
tryCatch("1" + 1, error = \(e) conditionMessage(e))
#> [1] "non-numeric argument to binary operator"

# if() accepts what can be read as a single logical value.
if ("TRUE") "string TRUE is accepted"
#> [1] "string TRUE is accepted"
if (2L) "a non-zero number is TRUE"
#> [1] "a non-zero number is TRUE"
tryCatch(if ("yes") 1, error = \(e) conditionMessage(e))
#> [1] "argument is not interpretable as logical"
tryCatch(if (NA) 1, error = \(e) conditionMessage(e))
#> [1] "missing value where TRUE/FALSE needed"

# Equal values of different types: == compares values, identical() types too.
1L == 1
#> [1] TRUE
identical(1L, 1)
#> [1] FALSE
identical(c(a = 1), 1)
#> [1] FALSE
identical(as.integer(c(1, 2, 3)), 1:3)
#> [1] TRUE
identical(TRUE, 1L)
#> [1] FALSE
all.equal(1L, 1)
#> [1] TRUE
all.equal(1, "1")
#> [1] "Modes: numeric, character"
#> [2] "target is numeric, current is character"
identical(NA, NA_integer_)
#> [1] FALSE
is.na(NA) && is.na(NA_integer_)
#> [1] TRUE

# The type of a result matters when it is stored back into a column.
ids <- c(101L, 102L, 103L)
ids[2] <- 999
typeof(ids)
#> [1] "double"
ids[2] <- "ten"
typeof(ids)
#> [1] "character"
ids
#> [1] "101" "ten" "103"

source("scenario.R")

# What type did read.csv() give each column of the shelf?
vapply(books, typeof, character(1L))
#>       title      author        isbn        year       genre       pages
#> "character" "character" "character"   "integer" "character"   "integer"
vapply(books, \(column) class(column)[1L], character(1L))
#>       title      author        isbn        year       genre       pages
#> "character" "character" "character"   "integer" "character"   "integer"
vapply(loans, \(column) class(column)[1L], character(1L))
#>     loan_id        isbn      member   loan_date return_date
#> "character" "character" "character"      "Date"      "Date"

# str() abbreviates the types: int, num, chr, logi, cplx, raw.
str(books$year)
#>  int [1:16] 1974 1813 2019 2021 2016 2008 NA 1999 2012 2023 ...
str(books$title)
#>  chr [1:16] "The Dispossessed" "Pride and Prejudice" "  the quiet streets " ...
str(1.5)
#>  num 1.5
str(c(TRUE, NA))
#>  logi [1:2] TRUE NA
str(2i)
#>  cplx 0+2i
str(as.raw(1:3))
#>  raw [1:3] 01 02 03
str(shelf_today)
#>  Date[1:1], format: "2026-06-30"

# The year column is integer, so adding a double changes its type.
typeof(books$year)
#> [1] "integer"
typeof(books$year + 1L)
#> [1] "integer"
typeof(books$year + 1)
#> [1] "double"
typeof(books$pages > 300)
#> [1] "logical"
sum(books$pages > 300, na.rm = TRUE)
#> [1] 6

source("scenario.R")

# c() joins its arguments into one flat vector.
c(1, 2, 3)
#> [1] 1 2 3
c(c(1, 2), c(3, c(4, 5)))
#> [1] 1 2 3 4 5
c(books$year[1:3], 2030L)
#> [1] 1974 1813 2019 2030
c()
#> NULL
c(NULL, 1, NULL)
#> [1] 1

# Names given in c() become the names attribute; unnamed parts get "".
founders <- c(first = books$year[1], second = books$year[2], 2019L)
founders
#>  first second
#>   1974   1813   2019
names(founders)
#> [1] "first"  "second" ""

# A named argument that is itself a vector gets a prefix.
c(x = c(a = 1, b = 2))
#> x.a x.b
#>   1   2
c(x = 1:2)
#> x1 x2
#>  1  2
c(x = c(a = 1, b = 2), y = 3)
#> x.a x.b   y
#>   1   2   3

# use.names = FALSE drops all of them.
c(first = 1, second = 2, use.names = FALSE)
#> [1] 1 2

# Two arguments of c() are not element names: recursive and use.names.
c(recursive = 1, value = 2)
#> value
#>     2
c(value = 1, 2)
#> value
#>     1     2

# Duplicated names are allowed; lookup by name takes the first.
dup <- c(a = 1, a = 2)
dup["a"]
#> a
#> 1
dup[["a"]]
#> [1] 1

# vector(mode, length) makes a vector of "empty" values of any mode.
vector("logical", 3)
#> [1] FALSE FALSE FALSE
vector("integer", 3)
#> [1] 0 0 0
vector("numeric", 3)
#> [1] 0 0 0
vector("double", 3)
#> [1] 0 0 0
vector("complex", 2)
#> [1] 0+0i 0+0i
vector("character", 2)
#> [1] "" ""
vector("raw", 3)
#> [1] 00 00 00
vector("list", 3)
#> [[1]]
#> NULL
#>
#> [[2]]
#> NULL
#>
#> [[3]]
#> NULL
#>

# The typed shortcuts are the same call with the mode in the name.
identical(numeric(3), vector("numeric", 3))
#> [1] TRUE
identical(character(0), vector("character", 0))
#> [1] TRUE
identical(double(2), numeric(2))
#> [1] TRUE
integer(0)
#> integer(0)
character(0)
#> character(0)
logical(0)
#> logical(0)

# The "empty" value of each type.
typeof(numeric(1))
#> [1] "double"
numeric(1) == 0
#> [1] TRUE
character(1) == ""
#> [1] TRUE
logical(1)
#> [1] FALSE
as.integer(raw(1))
#> [1] 0
vapply(vector("list", 2), is.null, logical(1))
#> [1] TRUE TRUE

# The colon operator builds an integer sequence when it can.
1:5
#> [1] 1 2 3 4 5
5:1
#> [1] 5 4 3 2 1
0:3
#> [1] 0 1 2 3
-1:3
#> [1] -1  0  1  2  3
-(1:3)
#> [1] -1 -2 -3
typeof(1:5)
#> [1] "integer"
typeof(1.5:4)
#> [1] "double"
1.5:4
#> [1] 1.5 2.5 3.5
typeof(0:3 + 0.5)
#> [1] "double"

# The colon binds tighter than + - * / but looser than ^ and unary minus.
n <- 4
1:n - 1
#> [1] 0 1 2 3
1:(n - 1)
#> [1] 1 2 3
2:3^2
#> [1] 2 3 4 5 6 7 8 9
(2:3)^2
#> [1] 4 9

# The empty-sequence trap: 1:0 is c(1, 0), not an empty vector.
x <- character(0)
1:length(x) # nolint: seq_linter.
#> [1] 1 0
seq_len(length(x)) # nolint: seq_linter.
#> integer(0)
seq_along(x)
#> integer(0)
for (i in 1:length(x)) { # nolint: seq_linter.
  cat("iteration", i, "\n")
}
#> iteration 1
#> iteration 0
for (i in seq_along(x)) {
  cat("never printed", i, "\n")
}
tryCatch(1:NA, error = \(e) conditionMessage(e))
#> [1] "NA/NaN argument"
tryCatch(1:c(3, 4), warning = \(w) conditionMessage(w))
#> [1] "numerical expression has 2 elements: only the first used"

source("scenario.R")

# seq() with from, to and by.
seq(1, 10, by = 3)
#> [1]  1  4  7 10
seq(0, 1, by = 0.25)
#> [1] 0.00 0.25 0.50 0.75 1.00
seq(10, 1)
#>  [1] 10  9  8  7  6  5  4  3  2  1
seq(10, 1, by = -3)
#> [1] 10  7  4  1
tryCatch(seq(1, 10, by = -1), error = \(e) conditionMessage(e))
#> [1] "wrong sign in 'by' argument"

# seq() with length.out spreads points evenly.
seq(1, 10, length.out = 4)
#> [1]  1  4  7 10
seq(0, 1, length.out = 5)
#> [1] 0.00 0.25 0.50 0.75 1.00
seq(5, by = 2, length.out = 4)
#> [1]  5  7  9 11
seq(to = 100, by = 25, length.out = 3)
#> [1]  50  75 100

# One argument: seq(n) is 1:n, seq(v) is seq_along(v).
seq(5)
#> [1] 1 2 3 4 5
seq(c(10, 20, 30))
#> [1] 1 2 3

# The result type: integer when everything is whole, double otherwise.
typeof(seq(1, 10))
#> [1] "integer"
typeof(seq(1, 10, by = 3))
#> [1] "double"
typeof(seq(1L, 10L, by = 3L))
#> [1] "integer"
typeof(seq(1, 10, length.out = 4))
#> [1] "double"
typeof(seq_len(3))
#> [1] "integer"
typeof(seq_along(letters))
#> [1] "integer"

# seq_len() and seq_along() are the safe loop helpers.
seq_len(0)
#> integer(0)
seq_len(3)
#> [1] 1 2 3
seq_along(books$title)[1:5]
#> [1] 1 2 3 4 5
seq_len(nrow(books))
#>  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
seq(1950, 2020, by = 10)
#> [1] 1950 1960 1970 1980 1990 2000 2010 2020
tryCatch(seq_len(-1), error = \(e) conditionMessage(e))
#> [1] "argument must be coercible to non-negative integer"
rev(seq_len(4))
#> [1] 4 3 2 1

source("scenario.R")

# times repeats the whole vector, each repeats every element.
rep(c("a", "b"), times = 3)
#> [1] "a" "b" "a" "b" "a" "b"
rep(c("a", "b"), each = 3)
#> [1] "a" "a" "a" "b" "b" "b"
rep(c("a", "b"), times = 2, each = 2)
#> [1] "a" "a" "b" "b" "a" "a" "b" "b"

# A vector of times gives one count per element.
rep(1:3, times = c(3, 1, 2))
#> [1] 1 1 1 2 3 3

# length.out stops (or recycles) at an exact length.
rep(c(1, 2, 3), length.out = 7)
#> [1] 1 2 3 1 2 3 1
rep(c("x", "y"), length.out = 5)
#> [1] "x" "y" "x" "y" "x"
rep_len(1:3, 8)
#> [1] 1 2 3 1 2 3 1 2
rep.int(c(0, 1), 3)
#> [1] 0 1 0 1 0 1

# Names survive rep().
rep(c(a = 1, b = 2), 2)
#> a b a b
#> 1 2 1 2

# Preallocating a typed vector of NA values for a loop or a column.
rep(NA_character_, 3)
#> [1] NA NA NA
rep(NA_integer_, 4)
#> [1] NA NA NA NA
pages_filled <- rep(NA_integer_, nrow(books))
length(pages_filled)
#> [1] 16

# A divider line, and the first title three times.
paste(rep("-", 20), collapse = "")
#> [1] "--------------------"
rep(books$title[1], 3)
#> [1] "The Dispossessed" "The Dispossessed" "The Dispossessed"

# Invalid counts are errors.
tryCatch(rep(1:2, times = -1), error = \(e) conditionMessage(e))
#> [1] "invalid 'times' argument"
tryCatch(rep(1:3, times = c(1, 2)), error = \(e) conditionMessage(e))
#> [1] "invalid 'times' argument"

source("scenario.R")

# Arithmetic, comparison and maths functions work on whole vectors.
pages <- books$pages
head(pages * 2L)
#> [1] 774 864 428 396 602  NA
head(sqrt(pages))
#> [1] 19.67232 20.78461 14.62874 14.07125 17.34935       NA
head(pages %/% 100L)
#> [1]  3  4  2  1  3 NA
head(pages %% 100L)
#> [1] 87 32 14 98  1 NA
head(pages > 300)
#> [1]  TRUE  TRUE FALSE FALSE  TRUE    NA
cumsum(1:5)
#> [1]  1  3  6 10 15

# One value out of many: summaries return a single number.
sum(pages, na.rm = TRUE)
#> [1] 3755
range(pages, na.rm = TRUE)
#> [1]  88 432
max(pages, na.rm = TRUE)
#> [1] 432

# max() versus pmax(): pmax() works element by element.
max(c(1, 5, 3), c(4, 2, 6))
#> [1] 6
pmax(c(1, 5, 3), c(4, 2, 6))
#> [1] 4 5 6
pmin(c(1, 5, 3), 4)
#> [1] 1 4 3

# Names follow the first operand (or the longer one); other attributes too.
c(a = 1, b = 2) + c(x = 10, y = 20)
#>  a  b
#> 11 22
c(a = 1, b = 2) + 10
#>  a  b
#> 11 12
c(1, 2) + c(x = 10, y = 20)
#>  x  y
#> 11 22
c(a = 1, b = 2, c = 3, d = 4) + c(x = 10, y = 20)
#>  a  b  c  d
#> 11 22 13 24

# Logic: & and | work element by element; all() and any() reduce.
c(TRUE, FALSE, NA) & c(TRUE, TRUE, TRUE)
#> [1]  TRUE FALSE    NA
c(TRUE, FALSE, NA) | c(FALSE, FALSE, FALSE)
#> [1]  TRUE FALSE    NA
all(pages > 50, na.rm = TRUE)
#> [1] TRUE
any(pages > 400, na.rm = TRUE)
#> [1] TRUE

source("scenario.R")

# Raw vectors hold bytes, shown as two hexadecimal digits.
as.raw(c(1, 15, 16, 255))
#> [1] 01 0f 10 ff
raw(3)
#> [1] 00 00 00
as.integer(as.raw(c(1, 15, 16, 255)))
#> [1]   1  15  16 255
tryCatch(as.raw(256), warning = \(w) conditionMessage(w))
#> [1] "out-of-range values treated as 0 in coercion to raw"
tryCatch(as.raw(-1), warning = \(w) conditionMessage(w))
#> [1] "out-of-range values treated as 0 in coercion to raw"

# Text is bytes in some encoding.
charToRaw("A")
#> [1] 41
charToRaw("\u00e9")
#> [1] c3 a9
nchar("\u00e9")
#> [1] 1
nchar("\u00e9", type = "bytes")
#> [1] 2
bytes <- charToRaw(books$title[1])
length(bytes)
#> [1] 16
rawToChar(rev(bytes))
#> [1] "dessessopsiD ehT"
utf8ToInt("A")
#> [1] 65
intToUtf8(c(82, 33))
#> [1] "R!"

# Logic on raw vectors is bitwise; arithmetic is not defined.
as.raw(12) & as.raw(10)
#> [1] 08
as.raw(12) | as.raw(10)
#> [1] 0e
xor(as.raw(12), as.raw(10))
#> [1] 06
!as.raw(1)
#> [1] fe
rawShift(as.raw(1), 3)
#> [1] 08
tryCatch(as.raw(1) + as.raw(1), error = \(e) conditionMessage(e))
#> [1] "non-numeric argument to binary operator"
rawToBits(as.raw(5))
#> [1] 01 00 01 00 00 00 00 00
packBits(rawToBits(as.raw(5)))
#> [1] 05

# A string is an element, so a character vector is a vector of strings.
x <- c("one", "two", NA)
length(x)
#> [1] 3
nchar(x)
#> [1]  3  3 NA
is.na(x)
#> [1] FALSE FALSE  TRUE
x == "one"
#> [1]  TRUE FALSE    NA
NA_character_ == "one" # nolint: equals_na_linter.
#> [1] NA

# Quotes: either kind, escapes with a backslash, raw strings since R 4.0.0.
'single' # nolint: quotes_linter.
#> [1] "single"
"say \"hi\""
#> [1] "say \"hi\""
r"(C:\temp\file)"
#> [1] "C:\\temp\\file"
nchar(r"(C:\temp\file)")
#> [1] 12

# Complex numbers have a real and an imaginary part.
z <- complex(real = 3, imaginary = 4)
z
#> [1] 3+4i
Re(z)
#> [1] 3
Im(z)
#> [1] 4
Mod(z)
#> [1] 5
Conj(z)
#> [1] 3-4i
typeof(z)
#> [1] "complex"
tryCatch(sqrt(-1), warning = \(w) conditionMessage(w))
#> [1] "NaNs produced"
sqrt(as.complex(-1))
#> [1] 0+1i