Substitute small values in the table body

Usage

sub_small_vals(
  data,
  columns = everything(),
  rows = everything(),
  threshold = 0.01,
  small_pattern = if (sign == "+") "<{x}" else md("<*abs*(-{x})"),
  sign = "+"
)

Arguments

data

The gt table data object

obj:<gt_tbl> // required

This is the gt table object that is commonly created through use of the gt() function.

columns

Columns to target

<column-targeting expression> // default: everything()

The columns to which substitution operations are constrained. Can either be a series of column names provided in c(), a vector of column indices, or a select helper function (e.g. starts_with(), ends_with(), contains(), matches(), num_range(), and everything()).

rows

Rows to target

<row-targeting expression> // default: everything()

In conjunction with columns, we can specify which of their rows should form a constraint for targeting operations. The default everything() results in all rows in columns being formatted. Alternatively, we can supply a vector of row IDs within c(), a vector of row indices, or a select helper function (e.g. starts_with(), ends_with(), contains(), matches(), num_range(), and everything()). We can also use expressions to filter down to the rows we need (e.g., [colname_1] > 100 & [colname_2] < 50).

threshold

Threshold value

scalar<numeric|integer> // default: 0.01

The threshold value with which values should be considered small enough for replacement.

small_pattern

Pattern specification for small values

scalar<character> // default: if (sign == "+") "<{x}" else md("<*abs*(-{x})")

The pattern text to be used in place of the suitably small values in the rendered table.

sign

Consider positive or negative values?

scalar<character> // default: "+"

The sign of the numbers to be considered in the replacement. By default, we only consider positive values ("+"). The other option ("-") can be used to consider only negative values.

Value

An object of class gt_tbl.

Examples

Let's generate a simple, single-column tibble that contains an assortment of values that could potentially undergo some substitution.

tbl <- dplyr::tibble(num = c(10^(-4:2), 0, NA))

tbl
#> # A tibble: 9 x 1
#>        num
#>      <dbl>
#> 1   0.0001
#> 2   0.001
#> 3   0.01
#> 4   0.1
#> 5   1
#> 6  10
#> 7 100
#> 8   0
#> 9  NA

The tbl contains a variety of smaller numbers and some might be small enough to reformat with a threshold value. With sub_small_vals() we can do just that:

tbl |>
  gt() |>
  fmt_number(columns = num) |>
  sub_small_vals()

Small and negative values can also be handled but they are handled specially by the sign parameter. Setting that to "-" will format only the small, negative values.

tbl |>
  dplyr::mutate(num = -num) |>
  gt() |>
  fmt_number(columns = num) |>
  sub_small_vals(sign = "-")

You don't have to settle with the default threshold value or the default replacement pattern (in small_pattern). This can be changed and the "{x}" in small_pattern (which uses the threshold value) can even be omitted.

tbl |>
  gt() |>
  fmt_number(columns = num) |>
  sub_small_vals(
    threshold = 0.0005,
    small_pattern = "smol"
  )

Function ID

3-33

Function Introduced

v0.6.0 (May 24, 2022)

See also