---
title: "Making dummy rows with dummy_rows()"
author: "Jacob Kaplan"
date: "`r Sys.Date()`"
output: rmarkdown::html_vignette
vignette: >
  %\VignetteIndexEntry{Making dummy rows with dummy_rows()}
  %\VignetteEngine{knitr::rmarkdown}
  %\VignetteEncoding{UTF-8}
---

When dealing with data, there are often missing rows. While truly handling missing data is far beyond the scope of this package, the function `dummy_rows()` lets you add those missing rows back into the data. 

The function takes all character, factor, and Date columns, finds all possible combinations of their values, and adds the rows that are not in the original data set. Any columns not used in creating the combinations (e.g. numeric) are given a value of NA (unless otherwise specified with *dummy_value*).

Lets start with a simple example. 

```{r echo=TRUE}
fastDummies_example <- data.frame(numbers = 1:3,
                    gender  = c("male", "male", "female"),
                    animals = c("dog", "dog", "cat"),
                    dates   = as.Date(c("2012-01-01", "2011-12-31",
                                          "2012-01-01")),
                    stringsAsFactors = FALSE)
knitr::kable(fastDummies_example)
```

This data set has four columns: two character, one Date, and one numeric. The function by default will use the character and Date columns in creating the combinations. First, a small amount of math to explain the combinations. Each column has two distinct values - gender: male & female; animals: dog & cat; dates: 2011-12-31 & 2011-12-31. To find the number of possible combinations, multiple the number of unique values in each column together. 2 \* 2 \* 2 = 8. 

```{r echo=TRUE}
results <- fastDummies::dummy_rows(fastDummies_example)
knitr::kable(results)
```

When we run the function we can see that there are indeed 8 rows possible, and that the 5 rows missing from the original data have been added. 

To explicitly see which rows are new, set the *dummy_indicator* parameter to TRUE. This provides a column called dummy_indicator with a value of 0 if the row is in the original data and 1 if it was added. 

```{r echo=TRUE}
results <- fastDummies::dummy_rows(fastDummies_example, dummy_indicator = TRUE)
knitr::kable(results)
```

By default, columns not used for making the combinations are given a value of NA in the new rows. You can choose the value given with the parameter *dummy_value*. It takes an input, a string or single number.

```{r echo=TRUE}
results1 <- fastDummies::dummy_rows(fastDummies_example, dummy_value = 0)
results2 <- fastDummies::dummy_rows(fastDummies_example, dummy_value = "new value")
knitr::kable(results1)
knitr::kable(results2)
```

The parameter *select_columns* lets you choose which columns to use when making the combinations. It accepts a string or vector of column names. This can come in handy when you want to include a numeric column, such as years, when making the combinations. A new data set will help demonstrate this. This data set shows (imaginary) crime in New York City and San Francisco during 1990 and 2000. The problem is that there is no row for New York City for 2000. We want to add that row. 

```{r echo = TRUE}
crime <- data.frame(city = c("SF", "SF", "NYC"),
                    year = c(1990, 2000, 1990),
                    crime = 1:3)
knitr::kable(crime)
```

Using the default parameters for `dummy_rows()` doesn't give us what we want since it only selects the city column. We need to select both city and year to get all the combinations we want. 

```{r echo=TRUE}
results <- fastDummies::dummy_rows(crime, select_columns = c("city", "year"))
knitr::kable(results)
```

