Huxtable

https://hughjonesd.github.io/huxtable/
Admin
Huxtable is an R package to create LaTeX and HTML tables, with a friendly, modern interface. It...
Tokens:113,799
Snippets:1,044
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example usage of guess_knitr_output_format

Source: https://hughjonesd.github.io/huxtable/reference/guess_knitr_output_format.html

Demonstrates how to call `guess_knitr_output_format` within a knitr document. This example is intended for execution within a knitr environment and is guarded by `if (FALSE)` to prevent execution outside of it.

```r
if (FALSE) { # \dontrun{
# in a knitr document
guess_knitr_output_format()
} # }
```

--------------------------------

### Install Huxtable from CRAN

Source: https://hughjonesd.github.io/huxtable/index.html

Provides the standard R command to install the huxtable package from CRAN. This is the most common installation method.

```R
install.packages("huxtable")
```

--------------------------------

### Example Usage of Quick Output Functions

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Demonstrates the usage of various quick output functions with a matrix and another object 'jams'. This example is wrapped in `if (FALSE)` and `\dontrun{}` to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{
m <- matrix(1:4, 2, 2)

quick_pdf(m, jams)
quick_latex(m, jams)
quick_typst(m, jams)
quick_typst_pdf(m, jams)
quick_typst_png(m, jams)
quick_typst_svg(m, jams)
quick_html(m, jams)
quick_docx(m, jams)
quick_xlsx(m, jams)
quick_pptx(m, jams)
quick_rtf(m, jams)
} # } 
```

--------------------------------

### Example: Printing a Huxtable as Markdown

Source: https://hughjonesd.github.io/huxtable/reference/to_md.html

This example demonstrates how to use `print_md` to display a huxtable object in Markdown format. The output shows a simple table with a header and data.

```R
print_md(jams)
#> -----------------------
#>  Type            Price 
#> ----------- -----------
#>  Strawberry       1.90 
#>                        
#>  Raspberry        2.10 
#>                        
#>  Plum             1.80 
#> -----------------------
#>
```

--------------------------------

### Install Huxtable Development Version from GitHub

Source: https://hughjonesd.github.io/huxtable/index.html

Shows how to install the latest development version of huxtable directly from GitHub using the devtools package. This is useful for accessing the newest features or bug fixes.

```R
library(devtools)
install_github("hughjonesd/huxtable")
```

--------------------------------

### Install Huxtable from R-Universe

Source: https://hughjonesd.github.io/huxtable/index.html

Provides the R command to install the huxtable package from the R-Universe repository. This is an alternative to installing from CRAN.

```R
install.packages("huxtable", repos = c(
  "https://hughjonesd.r-universe.dev",
  "https://cloud.r-project.org"
))
```

--------------------------------

### Merge Cells Example

Source: https://hughjonesd.github.io/huxtable/reference/merge_cells.html

Demonstrates merging cells using the merge_cells function. This example merges rows 2 to 3 and columns 1 to 2 of a huxtable.

```r
ht <- hux(a = 1:3, b = 1:3)
ht <- set_all_borders(ht, 1)
merge_cells(ht, 2:3, 1:2)
```

--------------------------------

### Huxtable Colspan Example

Source: https://hughjonesd.github.io/huxtable/news/index.html

Demonstrates the new behavior of setting `colspan` which overwrites shadowed cells. This example shows how a cell spanning multiple columns affects the layout and content of subsequent cells.

```r
ht <- hux(c(1, 1), c(2, 2), c(3, 3))
ht <- set_all_borders(ht)
colspan(ht)[1, 1] <- 3

# old behaviour                
ht[, c(2, 1, 3)]
##   +--------------------------+
##   |                  2       |
##   +--------+--------+--------+
##   |      2 |      1 |      3 |
##   +--------+--------+--------+

# new behaviour
ht[, c(2, 1, 3)]
##   +--------------------------+
##   |                  1       |
##   +--------+--------+--------+
##   |      2 |      1 |      3 |

```

--------------------------------

### install_latex_dependencies

Source: https://hughjonesd.github.io/huxtable/reference/report_latex_dependencies.html

Installs and/or updates the LaTeX packages that huxtable requires. It calls `tinytex::tlmgr_install()` if possible, or `tlmgr install` directly.

```APIDOC
## install_latex_dependencies

### Description
Installs and/or updates the LaTeX packages that huxtable requires. It calls `tinytex::tlmgr_install()` if possible, or `tlmgr install` directly.

### Usage
```
install_latex_dependencies()
```

### Value
Returns `TRUE` if `tlmgr` returns 0.

### Examples
```R
if (FALSE) { # \dontrun{
install_latex_dependencies()
}
}
```
```

--------------------------------

### Apply bold formatting to cells matching a more complex regex

Source: https://hughjonesd.github.io/huxtable/reference/by_regex.html

This example shows how to use `by_regex` with a more complex regular expression to identify and format cells. It bolds cells that start with 'a', have any characters in between, and end with 'a'.

```R
map_bold(ht, by_regex("a.*a" = TRUE))
```

--------------------------------

### Example of printing a huxtable to the screen

Source: https://hughjonesd.github.io/huxtable/reference/to_screen.html

Demonstrates how to apply formatting (borders, bold text, text color) to a huxtable and then print it to the screen using `print_screen`. The output includes formatted column names and table data.

```r
bottom_border(jams)[1, 1:2] <- 1
bold(jams)[1, 1:2] <- TRUE
jams <- map_text_color(
  jams,
  by_regex("berry" = "red")
)

print_screen(jams)
```

--------------------------------

### Install LaTeX Dependencies

Source: https://hughjonesd.github.io/huxtable/reference/report_latex_dependencies.html

Installs or updates the LaTeX packages required by huxtable. This function attempts to use tinytex or tlmgr for installation.

```R
install_latex_dependencies()
```

--------------------------------

### Quick PDF Output

Source: https://hughjonesd.github.io/huxtable/articles/huxtable.html

Generate a PDF document from a huxtable object. The first example uses the default filename, while the second specifies a custom filename.

```R
quick_pdf(iris_hux)
quick_pdf(iris_hux, file = "iris.pdf")
```

--------------------------------

### Example: Set Huxtable Label

Source: https://hughjonesd.github.io/huxtable/reference/label.html

Demonstrates how to set a LaTeX-compatible label for a huxtable using the `set_label` function. The output shows the table with the new label applied.

```r
set_label(jams, "tab:mytable")
#>                               Type           Price  
#>                               Strawberry      1.90  
#>                               Raspberry       2.10  
#>                               Plum            1.80  
#>
#> Column names: Type, Price
```

--------------------------------

### Restack Down Example

Source: https://hughjonesd.github.io/huxtable/reference/restack-across-down.html

Demonstrates how to split a huxtable vertically into specified row counts using `restack_down`.

```R
ht <- as_hux(matrix(LETTERS[1:4], 2, 2))
ht <- set_all_borders(ht)
restack_down(ht, 1)
```

--------------------------------

### Restack Across Example

Source: https://hughjonesd.github.io/huxtable/reference/restack-across-down.html

Demonstrates how to split a huxtable horizontally into specified column counts using `restack_across`.

```R
ht <- as_hux(matrix(LETTERS[1:4], 2, 2))
ht <- set_all_borders(ht)
restack_across(ht, 1)
```

--------------------------------

### Check LaTeX Dependencies

Source: https://hughjonesd.github.io/huxtable/reference/report_latex_dependencies.html

Checks if the required LaTeX packages are installed. Use this to verify your LaTeX environment before generating tables.

```R
check_latex_dependencies()
```

--------------------------------

### Transpose a huxtable

Source: https://hughjonesd.github.io/huxtable/reference/t.huxtable.html

This example demonstrates how to transpose a huxtable using the t() function. It shows the original huxtable with a bottom border and the resulting transposed huxtable.

```r
ht <- huxtable(
  a = 1:3,
  b = letters[1:3],
  autoformat = FALSE
)
bottom_border(ht)[3, ] <- 1
ht
```

```r
t(ht)
```

--------------------------------

### Apply bold formatting with case-insensitive regex matching

Source: https://hughjonesd.github.io/huxtable/reference/by_regex.html

This example demonstrates how to perform a case-insensitive search for a string using `by_regex` and `map_bold`. It utilizes the `.grepl_args` argument to pass `ignore.case = TRUE` to the underlying `grepl` function, making the match for 'the' case-insensitive.

```R
map_bold(ht, by_regex(
  "the" = TRUE,
  .grepl_args = list(
    ignore.case = TRUE
  )
))
```

--------------------------------

### Set Borders in Huxtable

Source: https://hughjonesd.github.io/huxtable/news/index.html

Demonstrates how to set right and left borders between columns in a huxtable. This example shows how borders are automatically collapsed to overwrite previous values.

```R
jams %>%
    set_right_border(everywhere, 1, 1) %>%
    set_left_border(everywhere, 2, 0.4)
```

--------------------------------

### Set Font Size for a Subset of Rows and a Specific Column

Source: https://hughjonesd.github.io/huxtable/reference/font_size.html

This example demonstrates setting a font size for rows 2 and 3 in the first column.

```r
jams3 <- set_font_size(
  jams,
  2:3, 1, 12
)
font_size(jams3)
#>     Type Price
#> 1     14    14
#> 1.1   12    14
#> 2     12    14
#> 3     14    14
```

--------------------------------

### Map background color using a simple function

Source: https://hughjonesd.github.io/huxtable/reference/by_function.html

Applies a grey scale to the background of cells based on their values. This example demonstrates the basic usage of `by_function` with the `grey` function.

```R
ht <- as_hux(matrix(runif(20), 5, 4))

map_background_color(
  ht,
  by_function(grey)
)
```

--------------------------------

### Create a Simple Huxtable

Source: https://hughjonesd.github.io/huxtable/index.html

Demonstrates basic table creation with custom styling for text, borders, alignment, padding, and number format. Use this for straightforward table generation with direct styling commands.

```R
ht <- hux(
        Employee = c("John Smith", "Jane Doe", "David Hugh-Jones"),
        Salary = c(50000, 50000, 40000),
        add_colnames = TRUE
      )

bold(ht)[1,]           <- TRUE
bottom_border(ht)[1,]  <- 0.4
align(ht)[,2]          <- "right"
right_padding(ht)      <- 10
left_padding(ht)       <- 10
width(ht)              <- 0.35
number_format(ht)      <- 2

ht
```

--------------------------------

### Create a huxtable and print its LaTeX representation

Source: https://hughjonesd.github.io/huxtable/reference/to_latex.html

Demonstrates how to create a basic huxtable and then use `print_latex` to output its LaTeX representation. This is useful for generating tables in LaTeX documents.

```R
ht <- huxtable(
  a = 1:3,
  b = letters[1:3]
)
print_latex(ht)
```

--------------------------------

### Quickly Print Objects to Various Formats

Source: https://hughjonesd.github.io/huxtable/reference/index.html

Use the `quick_*()` functions for one-line printing of objects to files like PDF, HTML, DOCX, XLSX, RTF, or images.

```r
quick_latex()
quick_pdf()
quick_typst()
quick_typst_pdf()
quick_typst_png()
quick_typst_svg()
quick_html()
quick_docx()
quick_pptx()
quick_xlsx()
quick_rtf()
```

--------------------------------

### Apply bold formatting to the last 2 rows and last column

Source: https://hughjonesd.github.io/huxtable/reference/final.html

This example demonstrates using final() to select the last two rows and the last column for applying bold formatting using set_bold().

```r
set_bold(jams, final(2), final(1), TRUE)
```

--------------------------------

### Create a Basic Huxtable

Source: https://hughjonesd.github.io/huxtable/reference/huxtable.html

Demonstrates the creation of a simple huxtable with two columns, one numeric and one character.

```R
ht <- huxtable(
  column1 = 1:5,
  column2 = letters[1:5]
)
ht
```

--------------------------------

### Get border thickness from a brdr() object

Source: https://hughjonesd.github.io/huxtable/reference/brdr_thickness.html

Shows how to get the thickness of a border defined directly using the brdr() function. This is useful for checking the thickness of programmatically created borders.

```r
brdr_thickness(brdr(1, "solid", "red"))
#> [1] 1
```

--------------------------------

### Create and Display a Huxtable

Source: https://hughjonesd.github.io/huxtable/reference/mapping-functions.html

Demonstrates the creation of a Huxtable and the default output of `as.matrix` which can lead to formatting issues.

```r
ht <- hux(c(-1, 1, 2), letters[1:3])
as.matrix(ht) # look at the spaces...
#>              
#> [1,] "-1" "a" 
#> [2,] " 1" "b" 
#> [3,] " 2" "c" 
as.matrix(ht) > 0 # uh oh
#>                
#> [1,] FALSE TRUE
#> [2,] FALSE TRUE
#> [3,] FALSE TRUE
```

--------------------------------

### Set Italic Property on Columns Starting with 'T'

Source: https://hughjonesd.github.io/huxtable/articles/huxtable.html

Applies the italic property to a specific row across all columns whose names start with 'T'. This utilizes `tidyselect` functions for column selection.

```R
jams |> 
      set_italic(1, starts_with("T"))
```

--------------------------------

### Create a Basic Huxtable

Source: https://hughjonesd.github.io/huxtable/articles/huxtable.html

Create a simple huxtable with two columns, 'Type' and 'Price', using the `hux` function. This demonstrates the basic syntax for creating a table with text and numeric data.

```r
library(huxtable)

jams <- hux(
        Type  = c("Strawberry", "Raspberry", "Plum"),
        Price = c(1.90, 2.10, 1.80)
      )
```

--------------------------------

### Usage of fmt_percent

Source: https://hughjonesd.github.io/huxtable/reference/fmt_percent.html

Demonstrates how to use the fmt_percent function with set_number_format to format a column as percentages. The function takes the number of digits as an argument and passes other formatting options to formatC.

```r
jams$Sugar <- \
  c(
    "Sugar content",
    0.4, 0.35, 0.45
  )
set_number_format(
  jams, -1, "Sugar",
  fmt_percent(1)
)
#>                        Type         Price   Sugar content  
#>                        Strawberry    1.90           40.0%  
#>                        Raspberry     2.10           35.0%  
#>                        Plum          1.80           45.0%  
#> 
#> Column names: Type, Price, Sugar

```

--------------------------------

### Load lmtest and sandwich packages

Source: https://hughjonesd.github.io/huxtable/articles/huxreg.html

Load the 'lmtest' and 'sandwich' packages for robust standard error calculations.

```r
library(lmtest)
```

```r
library(sandwich)
```

--------------------------------

### Set and Get Tabular Environment

Source: https://hughjonesd.github.io/huxtable/reference/tabular_environment.html

Allows users to set or get the LaTeX tabular environment for a huxtable. This controls whether the table is rendered using \begin{tabular} or \begin{tabularx} in LaTeX output. It also provides a function `set_tabular_environment` for setting the value.

```APIDOC
## `tabular_environment()`

### Description
Gets the LaTeX tabular environment property of a huxtable.

### Usage
```R
tabular_environment(ht)
```

### Arguments
* `ht` (huxtable): A huxtable object.

### Value
Returns the current tabular environment setting (a string).

## `tabular_environment(ht) <- value`

### Description
Sets the LaTeX tabular environment property of a huxtable.

### Usage
```R
tabular_environment(ht) <- value
```

### Arguments
* `ht` (huxtable): A huxtable object.
* `value` (string): The desired LaTeX tabular environment (e.g., "tabular", "tabularx", "longtable"). Set to `NA` to reset to the default.

### Details
Setting this to a non-default value may lead to unexpected behavior. Use with caution.

## `set_tabular_environment(ht, value)`

### Description
A convenience function to set the LaTeX tabular environment property.

### Usage
```R
set_tabular_environment(ht, value)
```

### Arguments
* `ht` (huxtable): A huxtable object.
* `value` (string): The desired LaTeX tabular environment (e.g., "tabular", "tabularx", "longtable"). Set to `NA` to reset to the default.

### Value
Returns the modified huxtable object.

### Example
```R
set_tabular_environment(jams, "longtable")
```
```

--------------------------------

### Set and Get Table Label

Source: https://hughjonesd.github.io/huxtable/reference/label.html

This section details how to set and retrieve the label for a huxtable. The label is used for external referencing in formats like LaTeX and HTML. The `label()` function gets the current label, and `label(ht) <- value` or `set_label(ht, value)` sets a new label.

```APIDOC
## `label()`

### Description
Gets the label property of a huxtable.

### Usage
```
label(ht)
```

### Arguments
* `ht` (huxtable): The huxtable object.

### Value
Returns the label of the huxtable.

## `label(ht) <- value`

### Description
Sets the label property of a huxtable.

### Usage
```
label(ht) <- value
```

### Arguments
* `ht` (huxtable): The huxtable object.
* `value` (string): The label to set. Set to `NA` to reset to the default.

## `set_label(ht, value)`

### Description
Sets the label property of a huxtable.

### Usage
```
set_label(ht, value)
```

### Arguments
* `ht` (huxtable): The huxtable object.
* `value` (string): The label to set. Set to `NA` to reset to the default.

### Value
Returns the modified huxtable.

### Details
LaTeX table labels typically start with `"tab:"`. Within knitr, huxtable labels will default to the same as the knitr chunk label. If you use bookdown, and set a label on your table, the table `caption()` will automatically be prefixed with `(#label)`. `label` needs to start with `"tab:"`; if it doesn't, the `"tab:"` prefix will be added automatically.

### Examples
```R
set_label(jams, "tab:mytable")
```
```

--------------------------------

### Create huxtable objects

Source: https://hughjonesd.github.io/huxtable/reference/huxtable-package.html

Demonstrates how to create a huxtable object using the `huxtable()` function and convert a data frame to a huxtable using `as_hux()`.

```R
library(huxtable)

employees <- huxtable(
        Names    = c("Hadley", "Yihui", "Dirk"),
        Salaries = c(1e5, 1e5, 1e5),
        add_colnames = TRUE
      )
 car_hux <- as_hux(mtcars)
```

--------------------------------

### check_latex_dependencies

Source: https://hughjonesd.github.io/huxtable/reference/report_latex_dependencies.html

Checks whether the required LaTeX packages are installed. Can suppress messages.

```APIDOC
## check_latex_dependencies

### Description
Checks whether the required LaTeX packages are installed.

### Usage
```
check_latex_dependencies(quiet = FALSE)
```

### Arguments
* `quiet` (Logical): Suppress messages.

### Value
Returns `TRUE` or `FALSE`.

### Examples
```R
if (FALSE) { # \dontrun{
check_latex_dependencies()
}
}
```
```

--------------------------------

### Get Specific Default Property

Source: https://hughjonesd.github.io/huxtable/reference/set_default_properties.html

Retrieves the current default value for the 'bold' property.

```R
get_default_properties("bold")
```

--------------------------------

### Package Index

Source: https://hughjonesd.github.io/huxtable/reference

Provides high-level documentation about the package and links to introductory and FAQ pages.

```APIDOC
## Package Index

Provides high-level documentation about the package and links to introductory and FAQ pages.

* `huxtable-package`: Quick introduction to huxtable
* `huxtable-options`: Package options
* `huxtable-FAQ`: Frequently Asked Questions, including how to get help
* `huxtable-news`: Changes to the huxtable package
* `rowspecs`: Different ways to select rows and columns
* `mapping-functions` `mapping_functions`: How to set cell properties variably by cell contents
```

--------------------------------

### na_string

Source: https://hughjonesd.github.io/huxtable/reference/na_string.html

Get or set the character string used to represent NA values in the huxtable.

```APIDOC
## na_string

### Description
Get or set the character string used to represent NA values in the huxtable. NA values in the huxtable are printed as the value of `na_string`. Setting `na_string` to `NA` resets it to the default, which is an empty string "".

### Usage
```
na_string(ht)

na_string(ht) <- value
```

### Arguments
* `ht` (huxtable): The huxtable object.
* `value` (character vector or matrix): The string to use for representing NA values. Set to `NA` to reset to the default.

### Examples
```R
jams[3, 2] <- NA
jams
set_na_string(jams, "---")
```
```

--------------------------------

### Row Height Manipulation

Source: https://hughjonesd.github.io/huxtable/reference/row_height.html

Functions to get, set, and modify the row height property of a Huxtable.

```APIDOC
## `row_height()`

### Description
Gets the `row_height` property of a huxtable.

### Usage
```
row_height(ht)
```

### Arguments

* `ht` (huxtable): The huxtable object.

### Value
Returns the `row_height` property.

## `row_height() <- value`

### Description
Sets the `row_height` property of a huxtable.

### Usage
```
row_height(ht) <- value
```

### Arguments

* `ht` (huxtable): The huxtable object.
* `value` (numeric or character vector): The desired row heights. Numeric values are scaled relative to the table height in HTML or text height in LaTeX. Character values must be valid CSS or LaTeX dimensions. Set to `NA` to reset to default.

## `set_row_height()`

### Description
Sets the `row_height` property for specific rows in a huxtable.

### Usage
```
set_row_height(ht, row, value)
```

### Arguments

* `ht` (huxtable): The huxtable object.
* `row` (row specifier): Specifies which rows to modify. See `rowspecs` for details.
* `value` (numeric or character vector): The desired row heights. Numeric values are scaled relative to the table height in HTML or text height in LaTeX. Character values must be valid CSS or LaTeX dimensions. Set to `NA` to reset to default.

### Value
Returns the modified huxtable.

### Examples
```R
row_height(jams) <- c(.4, .2, .2, .2)
row_height(jams)
```
```

--------------------------------

### Create a Huxtable using Pipe Interface

Source: https://hughjonesd.github.io/huxtable/index.html

Shows how to create and style a Huxtable using the pipe operator (%>%) for a more readable, sequential workflow. This is useful for complex styling chains.

```R
library(magrittr)
ht <- hux(
        Employee = c("John Smith", "Jane Doe", "David Hugh-Jones"),
        Salary = c(50000, 50000, 40000)
      )

ht |>
      set_bold(1, everywhere)             и> 
      set_bottom_border(1, everywhere)    и> 
      set_align(everywhere, 2, "right")   и> 
      set_lr_padding(10)                  и> 
      set_width(0.35)                     и> 
      set_number_format(2)
```

--------------------------------

### stripe

Source: https://hughjonesd.github.io/huxtable/reference/stripe.html

Returns a function that selects every n-th row or column starting from a specified number.

```APIDOC
## stripe

### Description
This is a convenience function to use in row or column specifications. In this context, `stripe(n, from)` will return `from, from + n, ...,` up to the number of rows or columns of the huxtable.

### Usage
```
stripe(n = 1, from = n)
```

### Arguments
* **n** (number) - At least 1.
* **from** (number) - At least 1.
```

--------------------------------

### Report LaTeX Dependencies

Source: https://hughjonesd.github.io/huxtable/reference/report_latex_dependencies.html

Prints or returns a list of LaTeX dependencies for a LaTeX preamble. Use this to see what packages huxtable requires.

```R
report_latex_dependencies()
```

--------------------------------

### quick_html

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Prints R objects to an HTML document (.html). Supports border customization and automatic file confirmation.

```APIDOC
## quick_html

### Description
Prints R objects to an HTML document (.html).

### Usage
```R
quick_html(
  ...,
  file = confirm("huxtable-output.html"),
  borders = 0.4,
  open = interactive()
)
```

### Arguments
* `...`: One or more huxtables or R objects with an `as_huxtable` method.
* `file`: File path for the output. Defaults to 'huxtable-output.html'.
* `borders`: Border width for members of `...` that are not huxtables.
* `open`: Logical. Automatically open the resulting file? Defaults to `interactive()`.

### Value
Invisible `NULL`.

### Details
Objects in `...` will be converted to huxtables, with borders added. If ‘file’ is not specified, the command will fail in non-interactive sessions. In interactive sessions, the default file path is "huxtable-output.html" in the working directory; if this already exists, you will be asked to confirm manually before proceeding.

### Examples
```R
# Assuming 'm' is a matrix and 'jams' is another object
# quick_html(m, jams)
```
```

--------------------------------

### rowspan

Source: https://hughjonesd.github.io/huxtable/reference/spans.html

Get or set the rowspan for cells in a Huxtable. A cell with a rowspan of 2 covers the cell directly below it.

```APIDOC
## rowspan

### Description
Get or set the rowspan for cells in a Huxtable. A cell with a rowspan of 2 covers the cell directly below it.

### Usage
```
rowspan(ht)
rowspan(ht) <- value
```

### Arguments

* `ht` (huxtable): A huxtable object.
* `value` (integer vector or matrix): The rowspan value(s) to set.
```

--------------------------------

### Get Huxtable Label

Source: https://hughjonesd.github.io/huxtable/reference/label.html

Retrieves the current label of a huxtable. This is useful for checking the existing label before modification.

```r
label(ht)
```

--------------------------------

### Combine add_colnames and add_rownames

Source: https://hughjonesd.github.io/huxtable/reference/add_colnames.html

Demonstrates how to combine `add_colnames` and `add_rownames` to add both column names as the first row and row names as the first column. The order of operations matters.

```R
# Out by 1:
add_rownames(add_colnames(ht))
```

```R
# Better:
add_colnames(add_rownames(ht))
```

```R
# Alternatively:
add_colnames(add_rownames(ht, ""))
```

--------------------------------

### Font Size

Source: https://hughjonesd.github.io/huxtable/reference/font_size.html

Get or set the font size for cells in a huxtable. Font size is measured in points.

```APIDOC
## Usage
__```
font_size(ht)

font_size(ht) <- value

set_font_size(ht, row, col, value)

map_font_size(ht, row, col, fn)
```

## Arguments 

ht
    
A huxtable. 

value
    
A numeric vector. Set to `NA` to reset to the default, which is `NA_real_`. 

row
    
A row specifier. See rowspecs for details. 

col
    
An optional column specifier. 

fn
    
A mapping function. See mapping-functions for details.

## Examples
__```
font_size(jams) <- 14
font_size(jams)
#>     Type Price
#> 1     14    14
#> 1.1   14    14
#> 2     14    14
#> 3     14    14

jams2 <- set_font_size(
  jams,
  12
)
font_size(jams2)
#>     Type Price
#> 1     12    12
#> 1.1   12    12
#> 2     12    12
#> 3     12    12

jams3 <- set_font_size(
  jams,
  2:3, 1, 12
)
font_size(jams3)
#>     Type Price
#> 1     14    14
#> 1.1   12    14
#> 2     12    14
#> 3     14    14

jams4 <- map_font_size(
  jams,
  by_rows(
    12,
    14
  )
)
font_size(jams4)
#>     Type Price
#> 1     12    12
#> 1.1   14    14
#> 2     12    12
#> 3     14    14


```
```

--------------------------------

### quick_typst_png

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Prints R objects to PNG images via Typst. Supports custom file prefixes, dimensions, and PPI, with confirmation for overwriting existing files.

```APIDOC
## quick_typst_png

### Description
Prints R objects to PNG images via Typst.

### Usage
```R
quick_typst_png(
  ...,
  file = confirm_prefix("huxtable-output"),
  borders = 0.4,
  open = interactive(),
  width = NULL,
  height = NULL,
  ppi = NULL
)
```

### Arguments
* `...`: One or more huxtables or R objects with an `as_huxtable` method.
* `file`: File prefix for the output images. Defaults to 'huxtable-output'.
* `borders`: Border width for members of `...` that are not huxtables.
* `open`: Logical. Automatically open the resulting file? Defaults to `interactive()`.
* `width`: String passed to Typst's `page` `width` option. Use `NULL` for the default width.
* `height`: String passed to Typst's `page` `height` option. Use `NULL` for the default height.
* `ppi`: Pixels per inch for PNG output.

### Value
Invisible `NULL`.

### Details
Objects in `...` will be converted to huxtables, with borders added. If ‘file’ is not specified, the command will fail in non-interactive sessions. In interactive sessions, the default file path is "huxtable-output" in the working directory; if this already exists, you will be asked to confirm manually before proceeding. `quick_typst_png()` creates one image per huxtable. If there is more than one object in `...`, images will have a numeric suffix like `"-1", "-2"` etc. Existing files with the same `file` prefix will be overwritten after confirmation in interactive sessions.

### Examples
```R
# Assuming 'm' is a matrix and 'jams' is another object
# quick_typst_png(m, jams)
```
```

--------------------------------

### colspan

Source: https://hughjonesd.github.io/huxtable/reference/spans.html

Get or set the colspan for cells in a Huxtable. A cell with a colspan of 2 covers the cell directly to its right.

```APIDOC
## colspan

### Description
Get or set the colspan for cells in a Huxtable. A cell with a colspan of 2 covers the cell directly to its right.

### Usage
```
colspan(ht)
colspan(ht) <- value
```

### Arguments

* `ht` (huxtable): A huxtable object.
* `value` (integer vector or matrix): The colspan value(s) to set.
```

--------------------------------

### header_rows

Source: https://hughjonesd.github.io/huxtable/reference/header_cols.html

Marks arbitrary rows as headers in a Huxtable. This function can be used to get or set header row properties.

```APIDOC
## header_rows

### Description
Marks arbitrary rows as headers in a Huxtable. This function can be used to get or set header row properties.

### Usage
```
header_rows(ht)

header_rows(ht) <- value

set_header_rows(ht, row, value)
```

### Arguments

*   **ht** (huxtable): A huxtable object.
*   **value** (Logical vector): Set to `NA` to reset to the default, which is FALSE. Used when setting header rows.
*   **row** (A row specifier): Specifies which row(s) to set as headers. See rowspecs for details.

### Details
By default, header rows are not visually distinct, but this can be changed using `style_headers()`. Themes may also apply specific styles to headers. Headers are also handled differently during table restacking.
```

--------------------------------

### header_cols

Source: https://hughjonesd.github.io/huxtable/reference/header_cols.html

Marks arbitrary columns as headers in a Huxtable. This function can be used to get or set header column properties.

```APIDOC
## header_cols

### Description
Marks arbitrary columns as headers in a Huxtable. This function can be used to get or set header column properties.

### Usage
```
header_cols(ht)

header_cols(ht) <- value

set_header_cols(ht, col, value)
```

### Arguments

*   **ht** (huxtable): A huxtable object.
*   **value** (Logical vector): Set to `NA` to reset to the default, which is FALSE. Used when setting header columns.
*   **col** (A column specifier): Specifies which column(s) to set as headers. See rowspecs for details.

### Details
By default, header columns are not visually distinct, but this can be changed using `style_headers()`. Themes may also apply specific styles to headers. Headers are also handled differently during table restacking.
```

--------------------------------

### quick_pptx

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Prints R objects to a Microsoft PowerPoint document (.pptx). Requires the 'flextable' and 'officer' packages. Supports border customization and automatic file confirmation.

```APIDOC
## quick_pptx

### Description
Prints R objects to a Microsoft PowerPoint document (.pptx).

### Usage
```R
quick_pptx(
  ...,
  file = confirm("huxtable-output.pptx"),
  borders = 0.4,
  open = interactive()
)
```

### Arguments
* `...`: One or more huxtables or R objects with an `as_huxtable` method.
* `file`: File path for the output. Defaults to 'huxtable-output.pptx'.
* `borders`: Border width for members of `...` that are not huxtables.
* `open`: Logical. Automatically open the resulting file? Defaults to `interactive()`.

### Value
Invisible `NULL`.

### Details
Objects in `...` will be converted to huxtables, with borders added. If ‘file’ is not specified, the command will fail in non-interactive sessions. In interactive sessions, the default file path is "huxtable-output.pptx" in the working directory; if this already exists, you will be asked to confirm manually before proceeding. To create pptx files `flextable` and `officer` must be installed.

### Examples
```R
# Assuming 'm' is a matrix and 'jams' is another object
# quick_pptx(m, jams)
```
```

--------------------------------

### General syntax for mapping functions

Source: https://hughjonesd.github.io/huxtable/reference/mapping-functions.html

Illustrates the general structure for applying a mapping function to a Huxtable, specifying the table, optional row/column ranges, and the mapping function.

```R
map_property(ht, row, col, fn)
```

--------------------------------

### escape_contents

Source: https://hughjonesd.github.io/huxtable/reference/escape_contents.html

Get or set the escape_contents property for cells in a huxtable. When FALSE, raw HTML or TeX is allowed in cells.

```APIDOC
## escape_contents()

### Description
Get or set the `escape_contents` property for cells in a huxtable. When `FALSE`, raw HTML or TeX is allowed in cells.

### Usage
```
escape_contents(ht)
escape_contents(ht) <- value
```

### Arguments

* `ht` (huxtable): A huxtable object.
* `value` (logical vector or matrix): A logical value or matrix. Set to `NA` to reset to the default (`TRUE`).

### Details
If `markdown()` is `TRUE` for a cell, the `escape_contents` property will be ignored.

### See also
`sanitize()` for escaping text manually.

### Examples
```R
ht <- huxtable(
  Text   = "x squared",
  Maths  = "$x^2$"
)
ht <- set_escape_contents(ht, FALSE)
if (FALSE) { # \dontrun{
quick_pdf(ht)
}
```
```

--------------------------------

### quick_latex

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Prints R objects to a LaTeX document (.tex). It allows for customization of borders and automatically prompts for file confirmation in interactive sessions.

```APIDOC
## quick_latex

### Description
Prints R objects to a LaTeX document (.tex).

### Usage
```R
quick_latex(
  ...,
  file = confirm("huxtable-output.tex"),
  borders = 0.4,
  open = interactive()
)
```

### Arguments
* `...`: One or more huxtables or R objects with an `as_huxtable` method.
* `file`: File path for the output. Defaults to 'huxtable-output.tex'.
* `borders`: Border width for members of `...` that are not huxtables.
* `open`: Logical. Automatically open the resulting file? Defaults to `interactive()`.

### Value
Invisible `NULL`.

### Details
Objects in `...` will be converted to huxtables, with borders added. If ‘file’ is not specified, the command will fail in non-interactive sessions. In interactive sessions, the default file path is "huxtable-output.tex" in the working directory; if this already exists, you will be asked to confirm manually before proceeding.

### Examples
```R
# Assuming 'm' is a matrix and 'jams' is another object
# quick_latex(m, jams)
```
```

--------------------------------

### Enable Colorized Screen Output

Source: https://hughjonesd.github.io/huxtable/reference/huxtable-options.html

Enable colored output for huxtables when printed to the screen, provided the 'crayon' package is installed.

```R
options("huxtable.color_screen" = TRUE)
```

--------------------------------

### Create a Huxtable

Source: https://hughjonesd.github.io/huxtable/reference/index.html

Use `huxtable()`, `hux()`, or `tribble_hux()` to create a new huxtable object. These functions are fundamental for initializing tables.

```r
huxtable()
hux()
tribble_hux()
```

--------------------------------

### huxreg with overridden p-values

Source: https://hughjonesd.github.io/huxtable/articles/huxreg.html

Override statistics in regression output using tidy_override before passing to huxreg. This example shows overriding p-values.

```r
lm_fixed <- tidy_override(lm1, p.value = c(0.5, 0.2, 0.06))
huxreg("Normal p values" = lm1, "Supplied p values" = lm_fixed)
```

--------------------------------

### Rotate Text in Cells

Source: https://hughjonesd.github.io/huxtable/reference

Allows for rotating text within cells. Functions are available to get, set, and map rotation properties.

```R
rotation()
rotation<-
set_rotation()
map_rotation()
```

--------------------------------

### theme_compact

Source: https://hughjonesd.github.io/huxtable/reference/themes.html

Applies a compact theme, similar to theme_basic but with minimal padding.

```APIDOC
## theme_compact

### Description
Is like `theme_basic` but with minimal padding.

### Usage
```R
theme_compact(ht, header_rows = TRUE, header_cols = FALSE)
```

### Arguments

*   **ht** (huxtable object) - A huxtable object.
*   **header_rows** (logical) - Style header rows?
*   **header_cols** (logical) - Style header columns?

### Value

The huxtable object, appropriately styled.
```

--------------------------------

### Create and order a Huxtable from data frame

Source: https://hughjonesd.github.io/huxtable/articles/huxtable.html

Shows how to create a huxtable from a data frame and order it by a specific column before adding column names. This approach is useful for pre-processing data.

```r
jams_data <- data.frame(
        Type = c("Strawberry", "Raspberry", "Plum"),
        Price = c(1.90, 2.10, 1.80)
      )

jams_ordered <- jams_data |> 
      arrange(Price) |> 
      as_hux() |> 
      set_bold(1, everywhere) # et cetera...
```
```

```r
# Same result as above

jams_data |> 
      as_hux(add_colnames = FALSE) |> 
      arrange(Price) |> 
      add_colnames()
```
```

--------------------------------

### Set Cell Border Colors

Source: https://hughjonesd.github.io/huxtable/reference

Functions to manage the color of cell borders. This includes getting, setting, and mapping border colors.

```R
left_border_color()
right_border_color()
top_border_color()
bottom_border_color()
left_border_color<-
right_border_color<-
top_border_color<-
bottom_border_color<-
set_left_border_color()
set_right_border_color()
set_top_border_color()
set_bottom_border_color()
map_left_border_color()
map_right_border_color()
map_top_border_color()
map_bottom_border_color()
```

--------------------------------

### Set Default Properties and Create a Table

Source: https://hughjonesd.github.io/huxtable/reference/set_default_properties.html

Sets default text color to red and border to 0.4, then creates a new huxtable. The previous defaults are stored in 'old'.

```R
old <- set_default_properties(
  text_color = "red",
  border     = 0.4
)
hux(a = 1:2, b = 1:2)
```

--------------------------------

### Get Row Height

Source: https://hughjonesd.github.io/huxtable/reference/row_height.html

Retrieves the current row height property of a Huxtable object. The output shows the assigned heights for each row.

```r
row_height(jams)
#>   1 1.1   2   3 
#> 0.4 0.2 0.2 0.2 
```

--------------------------------

### Quickly Export to PDF

Source: https://hughjonesd.github.io/huxtable/reference/quick-output.html

Use `quick_pdf` to export R objects to a .pdf file. It allows specifying file path, border width, and dimensions. The `open` argument controls automatic file opening.

```R
quick_pdf(
  ...,
  file = confirm("huxtable-output.pdf"),
  borders = 0.4,
  open = interactive(),
  width = NULL,
  height = NULL
)
```

--------------------------------

### position

Source: https://hughjonesd.github.io/huxtable/reference/position.html

Set or get the position property of a huxtable. This property controls how the table is aligned on the page and whether text should wrap around it.

```APIDOC
## `position()`

### Description
Gets the position property of a huxtable.

### Method
GET

### Endpoint
`/position`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

### Response
#### Success Response (200)
- **value** (string) - The current position setting of the table. Possible values are "left", "center", "right", "wrapleft", or "wrapright".

### Request Example
```
position(my_huxtable)
```

## `position() <- value`

### Description
Sets the position property of a huxtable.

### Method
PUT

### Endpoint
`/position`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **value** (string) - Required - The desired position for the table. Accepted values are "left", "center", "right", "wrapleft", or "wrapright". Set to `NA` to reset to the default ("center").

### Request Example
```json
{
  "value": "left"
}
```

### Response
#### Success Response (200)
- **ht** (huxtable) - The modified huxtable with the updated position property.

#### Response Example
```json
{
  "ht": "[modified huxtable object]"
}
```

## `set_position(ht, value)`

### Description
A convenience function to set the position property of a huxtable.

### Method
POST

### Endpoint
`/set_position`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **ht** (huxtable) - Required - The huxtable to modify.
- **value** (string) - Required - The desired position for the table. Accepted values are "left", "center", "right", "wrapleft", or "wrapright". Set to `NA` to reset to the default ("center").

### Request Example
```json
{
  "ht": "[huxtable object]",
  "value": "right"
}
```

### Response
#### Success Response (200)
- **ht** (huxtable) - The modified huxtable with the updated position property.

#### Response Example
```json
{
  "ht": "[modified huxtable object]"
}
```
```

--------------------------------

### Set All Borders and Padding

Source: https://hughjonesd.github.io/huxtable/reference

Convenience functions to set properties for all borders, border colors, border styles, and padding simultaneously. Also includes functions for specific pairs like top/bottom or left/right.

```R
set_all_borders()
map_all_borders()
set_all_border_colors()
map_all_border_colors()
set_all_border_styles()
map_all_border_styles()
set_all_padding()
map_all_padding()
set_tb_padding()
map_tb_padding()
set_lr_padding()
map_lr_padding()
set_tb_borders()
map_tb_borders()
set_lr_borders()
map_lr_borders()
set_tb_border_colors()
map_tb_border_colors()
set_lr_border_colors()
map_lr_border_colors()
set_tb_border_styles()
map_tb_border_styles()
set_lr_border_styles()
map_lr_border_styles()
```

--------------------------------

### background_color

Source: https://hughjonesd.github.io/huxtable/reference/background_color.html

Get or set the background color of cells in a Huxtable. Colors can be specified as names, HTML strings, or R color functions.

```APIDOC
## Function: background_color

### Description
Get or set the background color of cells in a Huxtable. Colors can be specified as names, HTML strings, or R color functions.

### Usage
```
background_color(ht)
background_color(ht) <- value
```

### Arguments
* `ht` (huxtable): The huxtable object.
* `value` (character vector or matrix): The color(s) to set. Can be `NA` to reset to default.

### Details
Transparent colors are not guaranteed to work at present.

### Examples
```R
background_color(jams) <- grey(0.7)
print(background_color(jams))
```
```

--------------------------------

### Create a Huxtable using tribble_hux

Source: https://hughjonesd.github.io/huxtable/reference/huxtable.html

Shows how to create a huxtable using the tribble_hux function, which allows for data entry in a readable format similar to tibble::tribble(). Column names are explicitly added.

```R
tribble_hux(
  ~Name, ~Salary,
  "John Smith", 50000,
  "Jane Doe", 50000,
  "David Hugh-Jones", 50000,
  add_colnames = TRUE
)
```

--------------------------------

### Wrap Cell Content

Source: https://hughjonesd.github.io/huxtable/reference

Enables wrapping of cell content over multiple lines. Functions are provided to get, set, and map wrapping behavior.

```R
wrap()
wrap<-
set_wrap()
map_wrap()
```
Tokens:
Raw