tests/testthat/test-grim-values.R

# The reference values below are what `rsprite2::GRIM_test(return_values =
# TRUE)` returns for the same inputs. rsprite2 finds them by walking outward
# from the rounded sum total one integer at a time, with a fudge factor;
# `sum_range()` derives the same set in closed form and in exact integer
# arithmetic.

test_that("`grim_values()` returns the achievable means and their sums", {
  5.19 |> grim_values(32, digits_x = 2, items_averaged = 1, data_type = "integer") |> expect_equal(tibble::tibble(case = 1L, x = 5.1875, n = 32, items_averaged = 1, sum = 166))
  5.19 |>
    grim_values(300, digits_x = 2, items_averaged = 1, data_type = "integer") |>
    expect_equal(tibble::tibble(case = 1L, x = c(1556, 1557, 1558) / 300, n = 300, items_averaged = 1, sum = c(1556, 1557, 1558)))
  # No achievable mean at all if the value set is GRIM-inconsistent:
  out <- 5.19 |> grim_values(28, digits_x = 2, items_averaged = 1, data_type = "integer")
  out |> nrow()  |> expect_equal(0L)
  out |> names() |> expect_equal(c("case", "x", "n", "items_averaged", "sum"))
})


test_that("`grim_closest()` returns the achievable mean nearest to `x`", {
  # The two sums straddling an inconsistent value set are 145 and 146; 145/28
  # is the closer of the two, and it is what rsprite2 reports (as 5.18):
  5.19 |> grim_closest(28, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(145 / 28)
  5.19 |> grim_closest(28, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> round(2) |> expect_equal(5.18)
  # For a consistent value set, it is one of the `grim_values()`:
  5.19 |> grim_closest(32, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(5.1875)
  5.19 |> grim_closest(300, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(5.19)
  # Consistent whatever the missing values are, but without a nearest mean:
  5 |> grim_closest(NA, digits_x = NA, items_averaged = 1, data_type = "integer") |> _$x |> expect_na()
  5 |> grim_closest(10, digits_x = NA, items_averaged = NA, data_type = "integer") |> _$x |> expect_na()
})


test_that("both functions are vectorized like `grim()`", {
  out <- c(5.19, 5.19, 5.19) |> grim_values(c(32, 300, 28), digits_x = 2, items_averaged = 1, data_type = "integer")
  # One row per achievable mean, none for the inconsistent third value set:
  out |> tibble::is_tibble() |> expect_true()
  out$case |> expect_equal(c(1L, 2L, 2L, 2L))
  out$n    |> expect_equal(c(32, 300, 300, 300))
  # `case` counts through `n` if `x` is a single value:
  out <- 5.19 |> grim_values(25:35, digits_x = 2, items_averaged = 1, data_type = "integer")
  out$case |> expect_equal(c(2L, 3L, 7L, 8L))
  out$n    |> expect_equal(c(26, 27, 31, 32))

  c(5.19, 5.19) |>
    grim_closest(c(32, 28), digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |>
    expect_equal(c(5.1875, 145 / 28))
  5.19 |> grim_closest(25:30, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_length(6L)

  numeric(0) |> grim_values(numeric(0), digits_x = 2, items_averaged = 1, data_type = "integer")  |> expect_equal(tibble::tibble(case = integer(), x = double(), n = double(), items_averaged = double(), sum = double()))
  numeric(0) |> grim_closest(numeric(0), digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_identical(numeric(0))
  5.19 |> grim_closest(28, digits_x = 2, items_averaged = 1, data_type = "integer", rounding = c("up", "floor")) |> expect_error("must be length 1")
  5.19 |> grim_values(28, digits_x = 2, items_averaged = 1, data_type = "integer", x_meaning = c("percentage", "mean")) |> expect_error("must be length 1")
  c(1.1, 1.2, 1.3) |> grim_closest(c(10, 20), digits_x = 1, items_averaged = 1, data_type = "integer") |> expect_error()
  5.19 |> grim_closest(28, items_averaged = 1, data_type = "integer") |> expect_error("digits_x")
})

test_that("`grim_closest()` returns one row per value set, with the columns of `grim_values()`", {
  out <- c(5.19, NA, 5.19) |> grim_closest(c(28, 28, 32), digits_x = 2, items_averaged = 1, data_type = "integer")
  out |> expect_equal(tibble::tibble(case = 1:3, x = c(145 / 28, NA, 5.1875), n = c(28, 28, 32), items_averaged = 1, sum = c(145, NA, 166)))
  out |> names() |> expect_equal(names(grim_values(5.19, 32, 2, 1, "integer")))
})


test_that("`grim_closest()` keeps a consistent `x` to the means reported as `x`", {
  # 56 / 11 is closer to 5.1 than 57 / 11, but it is floored to 5.0:
  5.1 |> grim_closest(11, digits_x = 1, items_averaged = 1, data_type = "integer", rounding = "floor") |> _$x |> expect_equal(57 / 11)
})


test_that("`grim_closest()` returns the smaller of two equally close means", {
  # The tie went by `round()` on the sum, which rounds half to even:
  0.5  |> grim_closest(17, digits_x = 1, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(8 / 17)
  0.5  |> grim_closest(19, digits_x = 1, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(9 / 19)
  -0.5 |> grim_closest(19, digits_x = 1, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(-10 / 19)
  # Over a grid, against distances in whole numbers: `100 * s - X * n` for a
  # sum `s` and `x = X / 100`. Under `"up_or_down"`, sums within `n / 2` of it
  # are reported as `x`:
  for (n in 2:40) {
    for (numerator in 0:200) {
      x <- numerator / 100
      sums <- 0:(2 * n + 1)
      distance <- abs(100 * sums - numerator * n)
      if (any(2 * distance <= n)) {
        sums <- sums[2 * distance <= n]
        distance <- distance[2 * distance <= n]
      }
      expected <- sums[distance == min(distance)][1L] / n
      x |> grim_closest(n, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(expected)
    }
  }
})


test_that("too many means is an error, not a huge allocation", {
  5 |> grim_values(1e7, digits_x = 0, items_averaged = 1, data_type = "integer")  |> expect_error("Too many achievable means")
  # The error names the value set, with `x` as given:
  1.2345 |> grim_values(2e10, digits_x = 4, items_averaged = 1, data_type = "integer") |> expect_error("`x = 1.2345`, `n = 20000000000`")
  5 |> grim_closest(1e7, digits_x = 0, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(5)
})


test_that("`grim_values()` agrees with `grim()` itself", {
  # Every achievable mean must be reported as `x` when rounded the same way,
  # and there must be as many of them as the value set is consistent:
  for (rounding in c("up_or_down", "up", "down", "ceiling", "floor", "trunc")) {
    for (n in c(28, 32, 300)) {
      for (x in c(5.19, 4.2, 0.24)) {
        values <- x |> grim_values(n, digits_x = 2, items_averaged = 1, data_type = "integer", rounding = rounding)
        info <- paste0("x = ", x, ", n = ", n, ", rounding = ", rounding)
        consistency <- grim(x, n, digits_x = 2, items_averaged = 1, data_type = "integer", rounding = rounding)
        values |> nrow() |> call_on(\(x) x > 0L) |> expect_equal(consistency, info = info)
        for (value in values$x) {
          value |>
            roundwork::reround(digits = 2, rounding = rounding) |>
            purrr::pluck(1L) |>
            round(10L) |>
            expect_equal(x, info = info)
        }
      }
    }
  }
})


test_that("`grim_values()` matches the `sum_*` columns of `grim_map()`", {
  out <- pigs1 |> grim_map(digits_x = 2, items_averaged = 1, data_type = "integer", show_rec = TRUE)
  values <- grim_values(pigs1$x, pigs1$n, digits_x = 2, items_averaged = 1, data_type = "integer")
  counts <- pmax(0L, out$sum_upper - out$sum_lower + 1L)
  values$case |> tabulate(nrow(out)) |> expect_equal(as.integer(counts))
  for (i in which(out$consistency)) {
    values$sum[values$case == i] |> expect_equal(seq(out$sum_lower[i], out$sum_upper[i]))
    # `grim_closest()` is one of them wherever there are any:
    pigs1$x[i] |>
      grim_closest(pigs1$n[i], digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |>
      expect_in(values$x[values$case == i])
  }
})


test_that("`x_meaning = \"percentage\"` returns values on the scale of `x`", {
  # Not on the decimal scale that GRIM works with internally, so that the
  # values can be read against `x`:
  closest <- grim_closest(71, 43, digits_x = 0, items_averaged = 1, data_type = "integer", x_meaning = "percentage")$x
  closest |> expect_gt(70)
  closest |> expect_lt(74)
  # 40% of 5 is 2 people, so this is consistent and there is one way to get
  # there. The value comes back as 40, not as 0.4:
  40 |> grim_values(5, digits_x = 0, items_averaged = 1, data_type = "integer", x_meaning = "percentage") |> expect_equal(tibble::tibble(case = 1L, x = 40, n = 5, items_averaged = 1, sum = 2))
  40 |> grim_closest(5, digits_x = 0, items_averaged = 1, data_type = "integer", x_meaning = "percentage") |> _$x |> expect_equal(40)
})


test_that("`items_averaged` multiplies into the sample size", {
  2.84 |>
    grim_values(16, digits_x = 2, items_averaged = 2, data_type = "integer") |>
    dplyr::select(-n, -items_averaged) |>
    expect_equal(grim_values(2.84, 32, digits_x = 2, items_averaged = 1, data_type = "integer") |> dplyr::select(-n, -items_averaged))
})


test_that("undecidable cases give one row of `NA`", {
  # A missing mean has no bounds to derive, as in `grim()`. (This used to be
  # tested with `rounding = "anti_trunc"` at a mean of zero, which had no
  # defined bounds either until `anti_trunc()` stopped sending zero away from
  # zero.)
  NA |> grim_values(40, digits_x = 2, items_averaged = 1, data_type = "integer") |> expect_undecidable()
  NA |> grim_closest(40, digits_x = 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(NA_real_)
})


test_that("`rounding = \"anti_trunc\"` at a mean of zero is decidable", {
  # Every non-zero value is taken away from zero, so a mean reported as 0.00
  # pins the sum to exactly 0 -- attainable only by all-zero data:
  0 |>
    grim_values(40, digits_x = 2, items_averaged = 1, data_type = "integer", rounding = "anti_trunc") |>
    expect_equal(tibble::tibble(case = 1L, x = 0, n = 40, items_averaged = 1, sum = 0))
  0 |> grim_closest(40, digits_x = 2, items_averaged = 1, data_type = "integer", rounding = "anti_trunc") |> _$x |> expect_equal(0)
})


test_that("`digits_x` is required, with the bespoke error message", {
  # `suppressMessages()` mutes the changelog hint that `error_digits_missing()`
  # prints via `on.exit()` as it unwinds:
  5.19 |> grim_values(28, items_averaged = 1, data_type = "integer")  |> suppressMessages() |> expect_error("digits_x")
  5.19 |> grim_closest(28, items_averaged = 1, data_type = "integer") |> suppressMessages() |> expect_error("digits_x")
})


test_that("`grim_values()` and `grim_closest()` are undecidable where `grim()` is", {
  5.19 |> grim(20.5, 2, items_averaged = 1, data_type = "integer")         |> is.na() |> expect_true()
  5.19 |> grim_values(20.5, 2, items_averaged = 1, data_type = "integer")  |> expect_undecidable()
  5.19 |> grim_closest(20.5, 2, items_averaged = 1, data_type = "integer") |> _$x |> expect_equal(NA_real_)
  5.19 |> grim_values(28, 2, items_averaged = 1.5, data_type = "integer")  |> expect_undecidable()
})


test_that("type mistakes are errors, as in `grim()`, not undecidable value sets", {
  5.19 |> grim_values(n = "20", digits_x = 2, items_averaged = 1, data_type = "integer")   |> expect_error("`n` must be one of these types")
  5.19 |> grim_closest(n = "20", digits_x = 2, items_averaged = 1, data_type = "integer")  |> expect_error("`n` must be one of these types")
  5.19 |> grim_values(n = 20, digits_x = 2, items_averaged = "1", data_type = "integer")   |> expect_error("`items_averaged` must be one of these types")
  5.19 |> grim_values(n = 20, digits_x = 2, items_averaged = 1, data_type = "integer", x_meaning = NA)    |> expect_error("`x_meaning`")
  5.19 |> grim_closest(n = 20, digits_x = 2, items_averaged = 1, data_type = "integer", x_meaning = "yes") |> expect_error("`x_meaning`")
})


test_that("`data_type` is required, and continuous data are an error", {
  5.19 |> grim_values(28, digits_x = 2, items_averaged = 1)                            |> expect_error("`grim_values()` only applies", fixed = TRUE)
  5.19 |> grim(28, digits_x = 2, items_averaged = 1)                                   |> expect_error("no data at all can have", fixed = TRUE)
  5.19 |> grim_closest(28, digits_x = 2, items_averaged = 1)                           |> expect_error("Need to specify `data_type`")
  5.19 |> grim_values(28, digits_x = 2, items_averaged = 1, data_type = "continuous")  |> expect_error("`grim_values()` only applies", fixed = TRUE)
  5.19 |> grim_closest(28, digits_x = 2, items_averaged = 1, data_type = "continuous") |> expect_error("`grim_closest()` only applies", fixed = TRUE)
  5.19 |> grim_values(28, digits_x = 2, items_averaged = 1, data_type = factor("integer")) |> expect_error("not a factor")
  # Undecidable under `NA`, whether or not whole numbers can have the mean:
  5.19 |> grim_values(c(28, 32), digits_x = 2, items_averaged = 1, data_type = NA)  |> expect_equal(tibble::tibble(case = 1:2, x = NA_real_, n = c(28, 32), items_averaged = 1, sum = NA_real_))
  5.19 |> grim_closest(c(28, 32), digits_x = 2, items_averaged = 1, data_type = NA) |> _$x |> expect_equal(c(NA_real_, NA_real_))
  5.19 |> grim_closest(28, digits_x = NA, items_averaged = 1, data_type = NA)       |> _$x |> expect_na()
})


test_that("`n` and `items_averaged` are integer, as in the mappers", {
  out <- grim_values(c(5.19, 5.2), 28, 2, items_averaged = 1, data_type = "integer")
  out$n |> expect_type("integer")
  out$items_averaged |> expect_type("integer")
  grim_closest(5.19, 28, 2, items_averaged = 1, data_type = "integer")$n |> expect_type("integer")
  grimmer_values(5.2, 1.3, 28, 1, 1, items_averaged = 1, data_type = "integer")$n |> expect_type("integer")
  grimmer_closest(5.2, 1.3, 28, 1, 1, items_averaged = 1, data_type = "integer")$items_averaged |> expect_type("integer")
  debit_values(0.5, 0.5, 20, 2, 2, "integer")$n |> expect_type("integer")
  debit_closest(0.5, 0.5, 20, 2, 2, "integer")$n |> expect_type("integer")
  # No value set, and one with a sample size too large for an integer:
  grim_values(numeric(0), 28, 2, items_averaged = 1, data_type = "integer")$n |> expect_type("integer")
  grim_closest(0.5, 1e10, 1, items_averaged = 1, data_type = "integer")$n |> expect_type("double")
})

Try the scrutiny package in your browser

Any scripts or data that you put into this service are public.

scrutiny documentation built on Nov. 11, 2026, 1:09 a.m.