---
title: "Furniture"
output: rmarkdown::html_vignette
vignette: >
  %\VignetteIndexEntry{Furniture}
  \usepackage[utf8]{inputenc}
  %\VignetteEngine{knitr::rmarkdown}
date: "`r Sys.Date()`"
editor_options: 
  chunk_output_type: console
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

This vignette is current as of `furniture` `r packageVersion("furniture")`.

## Using `furniture`

```{r}
library(furniture)
```


We will first make a fictitious data set:
```{r data}
df <- data.frame(a = rnorm(1000, 1.5, 2), 
                 b = seq(1, 1000, 1), 
                 c = c(rep("control", 400), rep("Other", 70), rep("treatment", 500), rep("None", 30)),
                 d = c(sample(1:1000, 900, replace=TRUE), rep(-99, 100)))
```

There are four functions that we'll demonstrate here:

1. `washer`
2. `table1`
3. `tableC`
4. `tableF`

## Washer

`washer` is a great function for quick data cleaning. In situations where there are placeholders, extra levels in a factor, or several values need to be changed to another.
```{r washer, message=FALSE, warning=FALSE}
library(dplyr)

df <- df %>%
  mutate(d = washer(d, -99),  ## changes the placeholder -99 to NA
         c = washer(c, "Other", "None", value = "control")) ## changes "Other" and "None" to "Control"
```


## Table1

Now that the data is "washed" we can start exploring and reporting.
```{r table1}
table1(df, a, b, factor(c), d)
```

The variables must be numeric or factor. Since we use a special type of evaluation (i.e. Non-Standard Evaluation) we can change the variables in the function (e.g., `factor(c)`). This can be extended to making a whole new variable in the function as well.

```{r table1.2}
table1(df, a, b, d, ifelse(a > 1, 1, 0))
```

This is just the beginning though. Two powerful things the function can do are shown below:

```{r table1.3}
table1(df, a, b, d, ifelse(a > 1, 1, 0),
       splitby=~factor(c), 
       test=TRUE)
```

The `splitby = ~factor(c)` stratifies the means and counts by a factor variable (in this case either control or treatment). When we use this we can also automatically compute tests of significance using `test=TRUE`. 

We can also use it intuitively within the pipe (for more about this, see the "Table 1" vignette):
```{r table1.3.2, message=FALSE, warning=FALSE}
df %>%
  group_by(c) %>%
  table1(a, b, d, ifelse(a > 1, 1, 0), 
        test=TRUE)
```
In this case, we used the `group_by()` function from `dplyr` (within the `tidyverse`) and `table1()` knows to use that as the grouping variable in place of the `splitby` argument.

If the parametric tests (default) are not appropriate, you can set `param = FALSE`.
```{r table1.3.3, message=FALSE, warning=FALSE}
df %>%
  group_by(c) %>%
  table1(a, b, d, ifelse(a > 1, 1, 0), 
        test=TRUE,
        param=FALSE)
```


Finally, you can polish it quite a bit using a few other options. For example, you can do the following:
```{r table1.4}
table1(df, a, b, d, ifelse(a > 1, 1, 0),
       splitby=~factor(c), 
       test=TRUE,
       var_names = c("A", "B", "D", "New Var"),
       type = c("simple", "condensed"))
```

Note that `var_names` can be used for more complex naming (e.g., with spaces, brackets) that otherwise cannot be used with data frames. Alternatively, for more simple naming, we can name them directly.
```{r table1.4.2}
table1(df, A = a, B = b, D = d, A2 = ifelse(a > 1, 1, 0),
       splitby=~factor(c), 
       test=TRUE,
       type = c("simple", "condensed"))
```


You can also format the numbers (adding a comma for big numbers such as in 20,000 instead of 20000):
```{r table1.5}
table1(df, a, b, d, ifelse(a > 1, 1, 0),
       splitby=~factor(c), 
       test=TRUE,
       var_names = c("A", "B", "D", "New Var"),
       format_number = TRUE)
```

The table can be exported directly to a folder in the working directory called "Table1". Using `export`, we provide it with a string that will be the name of the CSV containing the formatted table.
```{r table1.6, eval=FALSE}
table1(df, a, b, d, ifelse(a > 1, 1, 0),
       splitby=~factor(c), 
       test=TRUE,
       var_names = c("A", "B", "D", "New Var"),
       format_number = TRUE,
       export = "example_table1")
```

This can also be outputted as a latex, markdown, or pandoc table (matching all the output types of `knitr::kable`). Below shows how to do a latex table (not using `kable` however, but a built-in function that provides the variable name at the top of the table):
```{r table1.7}
table1(df, a, b, d, "new var" = ifelse(a > 1, 1, 0),
       splitby = ~factor(c), 
       test = TRUE,
       output = "latex2")
```

Last item to show you regarding `table1()` is that it can be printed in a simplified and condensed form. This instead of reporting counts and percentages for categorical variables, it reports only percentages and the table has much less white space.
```{r simple_table1.1}
table1(df, a, b, d, "new var" = ifelse(a > 1, 1, 0),
       splitby = ~factor(c), 
       test = TRUE,
       type = c("simple", "condensed"))
```


## Table C

This function is to create simple, beautiful correlation tables. The syntax is just like `table1()` in most respects. Below we include all the numeric variables to see their correlations. Since there are missing values in `d` we will use the natural `na.rm=TRUE`.

```{r tableC.1}
tableC(df, 
       a, b, d,
       na.rm = TRUE)
```

All the adjustments that you can make in `table1()` can be done here as well. For example,

```{r tableC.2}
tableC(df, 
       "A" = a, "B" = b, "D" = d,
       na.rm = TRUE,
       output = "html")
```

## Table F

This function is to create simple frequency tables. The syntax is just like `table1()` and `tableC()` in most respects, except that it uses only one variable instead of many.

```{r tableF.1}
tableF(df, a)
```

Similarly to `table1()` we can use a `splitby` argument (or `group_by()`).

```{r tableF.2}
tableF(df, d, splitby = c)
```

```{r tableF.3}
df %>%
  group_by(c) %>%
  tableF(d)
```


## Table X

Lastly, `tableX()` is a pipe-able two-way version of `table()` with a similar syntax to that of the rest of the `furniture` functions.

```{r tableX.1}
df %>%
  tableX(c, ifelse(d > 500, 1, 0))
```

By default, it provides the total counts for the rows and columns with flexibility as to what is displayed and where.


## Conclusion

The four functions: `table1()`, `tableC()`, `tableF()`, and `washer()` add simplicity to cleaning up and understanding your data. Use these pieces of furniture to make your quantitative life a bit easier.

