Format values as Roman numerals

With numeric values in a gt table we can transform those to Roman numerals, rounding values as necessary.

Usage

fmt_roman(
  data,
  columns = everything(),
  rows = everything(),
  case = c("upper", "lower"),
  pattern = "{x}"
)

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()

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 undergo formatting. The default everything() results in all rows in columns being formatted. Alternatively, we can supply a vector of row captions 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).

case

Use uppercase or lowercase letters

singl-kw:[upper|lower] // default: "upper"

Should Roman numerals should be rendered as uppercase ("upper") or lowercase ("lower") letters? By default, this is set to "upper".

pattern

Specification of the formatting pattern

scalar<character> // default: "{x}"

A formatting pattern that allows for decoration of the formatted value. The formatted value is represented by the {x} (which can be used multiple times, if needed) and all other characters will be interpreted as string literals.

Value

An object of class gt_tbl.

Compatibility of formatting function with data values

fmt_roman() is compatible with body cells that are of the "numeric" or "integer" types. Any other types of body cells are ignored during formatting. This is to say that cells of incompatible data types may be targeted, but there will be no attempt to format them.

Compatibility of arguments with the `from_column()` helper function

from_column() can be used with certain arguments of fmt_roman() to obtain varying parameter values from a specified column within the table. This means that each row could be formatted a little bit differently. These arguments provide support for from_column():

case
pattern

Please note that for both of the aforementioned arguments, a from_column() call needs to reference a column that has data of the correct type (this is different for each argument). Additional columns for parameter values can be generated with cols_add() (if not already present). Columns that contain parameter data can also be hidden from final display with cols_hide(). Finally, there is no limitation to how many arguments the from_column() helper is applied so long as the arguments belong to this closed set.

Examples

Create a tibble of small numeric values and generate a gt table. Format the roman column to appear as Roman numerals with fmt_roman().

dplyr::tibble(arabic = c(1, 8, 24, 85), roman = arabic) |>
  gt(rowname_col = "arabic") |>
  fmt_roman(columns = roman)

This image of a table was generated from the first code example in the `fmt_roman()` help file.

Formatting values to Roman numerals can be very useful when combining such output with row labels (usually through cols_merge()). Here's an example where we take a portion of the illness dataset and generate some row labels that combine (1) a row number (in lowercase Roman numerals), (2) the name of the test, and (3) the measurement units for the test (nicely formatted by way of fmt_units()):

illness |>
  dplyr::slice_head(n = 6) |>
  gt(rowname_col = "test") |>
  fmt_units(columns = units) |>
  cols_hide(columns = starts_with("day")) |>
  sub_missing(missing_text = "") |>
  cols_merge_range(col_begin = norm_l, col_end = norm_u) |>
  cols_add(i = 1:6) |>
  fmt_roman(columns = i, case = "lower", pattern = "{x}.") |>
  cols_merge(columns = c(test, i, units), pattern = "{2} {1} ({3})") |>
  cols_label(norm_l = "Normal Range") |>
  tab_stubhead(label = "Test")

This image of a table was generated from the second code example in the `fmt_roman()` help file.

Function ID

3-9

Function Introduced

v0.8.0 (November 16, 2022)