EHEC, Introduction to R

Indiana University | University of Oregon | Chicago FED

Prologue: R Markdown

What is R Markdown?

Traditional .R scripts (analogous to a .do file in Stata) are a standard way to write pure R code. You could create a new R script yourself now by clicking the “New File” icon at the top-left of your RStudio session. Seriously, go ahead and try quickly.

What you see in front of you, however, is not a plain R script. It is an R Markdown document (file extension: .Rmd). This is simply a document type that allows you to combine both text — like the sentence you are reading now — and actual R code. It is similar to Stata’s dyndoc and is a very convenient way to integrate text and code in a single document. Think of it like LaTeX and R had a baby, but was very easy to use (was a very good baby?). In fact, the same Rmd file can be “knitted” to multiple formats: html, pdf, rich text, etc.

We don’t want to get too sidetracked by the special features of R Markdown… and should emphasise that it is not the only (or even “standard”) way to do analysis in R. But it is an extremely popular feature of R and is also a great way to teach a session like this. If you are interested in learning more, then the official website is a great place to start.¹ Note further that this document is about as vanilla as it gets, but you can get extremely fancy.

Send commands to R in R Markdown

Behind the scenes, in the .Rmd document we are typing in “code-chunks” that get run by R. These code chunks are fenced in with the backticks.

For example, this is a code chunk that will evaluate the command sin(3)

```{r}
sin(3)
```

The output of this will appear as follows:

## [1] 0.14112

You can also create calculations inline for example `r sin(3)` will evaluate sin(3). With output rendering like this 0.14112.

Okay, with that bit of R Markdown prologue out of the way, let’s get down to running actual R code.

Load packages into memory

An awful lot of work in R gets done through third-party packages that must be installed separately to “base” R. This is similar to how third-party packages in Stata can be installed from ssc. We recommend using RStudio’s package installer to find and install (or update) any external packages. We’ll show you how do to this in the live session, or you can take a look here. But note that you can also install R packages directly from the R console, e.g.

install.packages(c('ggplot2', 'dplyr'))

A key difference between R and Stata, however, is that installed R packages must be loaded into memory if you want to use them in that session. Think of it like an app on your phone. You might have downloaded the app already, but you need to open it every time you use it. Later on we will cover how to manage packages efficiently. But right now, assuming that you have already installed them, let’s load and play around with some R packages.

Here we are going to load the ggplot2 package, which is an excellent graphics package. gg here stands for “grammar of graphics”. This is a part of the tidyverse suite of packages that you may have heard of. We will also load the dplyr package, which is a popular data wrangling package (and is also a part of the tidyverse).

# library(tidyverse) ## Shortcut to load both ggplot2 & dplyr (& several other packages)
library(ggplot2)
library(dplyr)

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

Aside: Comments in .R files (or code chunks) are denoted with the # character. A shortcut to comment out a line (or region) in RStudio is Ctrl + Shift + c. This shortcut generally just works correctly for whatever language or script that you open in RStudio.²

View data

Now that these packages are loaded into memory, we can begin to use them. In the code below, we’ll explore the diamonds dataset that comes bundled with ggplot2. Much like Stata’s auto dataset, many packages bundle pre-installed datasets that are useful for tutorials and debugging.

The diamonds dataset is already available to us, since we’ve loaded ggplot2 into memory. But let’s bring it visibly into our global Environment (top right-hand pane in RStudio). This would happen automatically if we read in an external file like a .csv or .dta. We’ll get to external file I/O later, though.

data("diamonds")

We can look at the first five observations using the head command

head(diamonds)

## # A tibble: 6 x 10
##   carat cut       color clarity depth table price     x     y     z
##   <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
## 1  0.23 Ideal     E     SI2      61.5    55   326  3.95  3.98  2.43
## 2  0.21 Premium   E     SI1      59.8    61   326  3.89  3.84  2.31
## 3  0.23 Good      E     VS1      56.9    65   327  4.05  4.07  2.31
## 4  0.29 Premium   I     VS2      62.4    58   334  4.2   4.23  2.63
## 5  0.31 Good      J     SI2      63.3    58   335  4.34  4.35  2.75
## 6  0.24 Very Good J     VVS2     62.8    57   336  3.94  3.96  2.48

We can get a list of column names fairly easily too

names(diamonds)

##  [1] "carat"   "cut"     "color"   "clarity" "depth"   "table"   "price"  
##  [8] "x"       "y"       "z"

Tip: You can bring the dataset into view (similar to Stata’s browse feature) by typing View(diamonds), or just by clicking on it in your Environment pane.

Let’s compute the average price by color. The next code chunk is using dplyr commands (“verbs”) and invokes a “pipe” (the %>% syntax) to write cleaner code.

## summarise(group_by(diamonds, color), mean(price))
diamonds %>% group_by(color) %>% summarise(mean(price)) 

## # A tibble: 7 x 2
##   color `mean(price)`
##   <ord>         <dbl>
## 1 D             3170.
## 2 E             3077.
## 3 F             3725.
## 4 G             3999.
## 5 H             4487.
## 6 I             5092.
## 7 J             5324.

Here the pipe command %>% will take the output from the command on the left and “pipes” it as input to the command on the right. So above we

1. take the dataset called diamonds
2. send it as input to the command group_by, which groups by the unique values in the column color
3. We then send this grouped data to the summarize command, which calculates the mean price in each group.

Two things to note. First off, you can just move onto a new line without an error. This is neat because it allows us to write cleaner code and you don’t need a delimiter or the /// you may be used to from stata. So we can rewrite the above like this.

diamonds %>% 
    group_by(color) %>% 
    summarize(mean(price)) 

## # A tibble: 7 x 2
##   color `mean(price)`
##   <ord>         <dbl>
## 1 D             3170.
## 2 E             3077.
## 3 F             3725.
## 4 G             3999.
## 5 H             4487.
## 6 I             5092.
## 7 J             5324.

Second, in more recent versions of R (4.1 and above), you don’t need to have dpylr installed to pipe. You can do the same thing using |>.

diamonds |>
    group_by(color) |>
    summarize(mean(price)) 

## # A tibble: 7 x 2
##   color `mean(price)`
##   <ord>         <dbl>
## 1 D             3170.
## 2 E             3077.
## 3 F             3725.
## 4 G             3999.
## 5 H             4487.
## 6 I             5092.
## 7 J             5324.

Note: In this example, %>% and |> are interchangeable, but the two are not interchangeable in all settings. See https://www.r-bloggers.com/2021/05/the-new-r-pipe/ for more details.

Make summary statistics table.

An annoying, but also powerful, feature of R is that there are 15 ways to accomplish any task. In general, limiting the number of packages you use is a good idea since you won’t build dependencies on code that could become outdated as base R and other packages are updated. That being said, the power of R is the ability to use fantastic user written packages. Here we will use the datasummary*() family of functions from the modelsummary package to make fantastic summary statistic plots. Otherwise we’d have to continue to do things like we did above, exploring the data and making summary tables on our own.

Aside: In Stata, many ssc modules consist of one primary function, which shares the same name (e.g. ivreg2, reghdfe). R packages tend to have many functions, so you shouldn’t expect these functions to share the exact same name as the package itself.

First, load the model summary package

library(modelsummary)

Now we can use the datasummary_skim function.

datasummary_skim(diamonds)

	Unique (#)	Missing (%)	Mean	SD	Min	Median	Max
carat	273	0	0.8	0.5	0.2	0.7	5.0
depth	184	0	61.7	1.4	43.0	61.8	79.0
table	127	0	57.5	2.2	43.0	57.0	95.0
price	11602	0	3932.8	3989.4	326.0	2401.0	18823.0
x	554	0	5.7	1.1	0.0	5.7	10.7
y	552	0	5.7	1.1	0.0	5.7	58.9
z	375	0	3.5	0.7	0.0	3.5	31.8

But not every variable is numeric. datasummary has this covered with the type = "categorical" sub-option.

datasummary_skim(diamonds, type = "categorical")

		N	%
cut	Fair	1610	3.0
	Good	4906	9.1
	Very Good	12082	22.4
	Premium	13791	25.6
	Ideal	21551	40.0
color	D	6775	12.6
	E	9797	18.2
	F	9542	17.7
	G	11292	20.9
	H	8304	15.4
	I	5422	10.1
	J	2808	5.2
clarity	I1	741	1.4
	SI2	9194	17.0
	SI1	13065	24.2
	VS2	12258	22.7
	VS1	8171	15.1
	VVS2	5066	9.4
	VVS1	3655	6.8
	IF	1790	3.3

Learn more about the datasummary* family of functions here: https://vincentarelbundock.github.io/modelsummary/articles/datasummary.html

Graphing

Next we will use the ggplot function. You can learn more about any R function by typing in ? before the function name (e.g., ?ggplot).

• On the first line, we call the function, then clarify the dataset we wish to use (referable to by its name, diamonds), the y-variable (price), and the x-variable (carat).
• On the second line, we clarify that we want the geometry to be points

ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point() 

Think changing graphic features in ggplot as adding layers. You can do this by repeating all of the same code. Or by saving the above as an object then adding to that object.

For example let’s add a third line where use a default theme called classic that I like.

ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point() +
    theme_classic()

We can obtain the same result, by saving the above as an object and adding to it.

base_plot = ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point()

You can also use the <- arrow instead of the = to the name base_plot

base_plot +
    theme_classic()

All we need to do is add this theme line theme_classic() to the above.

Deviations from simple scatter plot

It’s very simple to make complex plots in R.

We can add some transparency

ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point(alpha = .33) +
    theme_classic()

Customized labels and increased size of text

ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point(alpha = .1) +
    theme_classic() + 
    theme(text = element_text(size = 18)) +
    labs(title = "Larger diamonds cost more", 
          subtitle = "Price, $",
          y = "", 
          x = "Carat")

Recall that the data contain information on diamond color. We can easily create small multiples of the scatter plot for each color.

ggplot(data = diamonds, aes(y = price, x = carat)) +
    geom_point(alpha = .1) +
    facet_wrap(~color) +
    theme_classic() + 
    theme(text = element_text(size = 14)) +
    labs(title = "Larger diamonds cost more by diamond color", 
          subtitle = "Price, $",
          y = "", 
          x = "Carat")

Similarly, we can add color (or shapes) based on diamond clarity

ggplot(data = diamonds, aes(y = price, x = carat, color = clarity)) +
    geom_point(alpha = .33) +
    facet_wrap(~color) +
    theme_classic() + 
    theme(text = element_text(size = 14)) +
    labs(title = "Larger diamonds cost more by diamond color", 
          subtitle = "Price, $",
          y = "", 
          x = "Carat")

It’s also trivial to add a regression line to each. We will pick method lm, which is a simple linear regression.

ggplot(data = diamonds, aes(y = price, x = carat, color = clarity)) +
    geom_point(alpha = .33) +
    facet_wrap(~color) + 
    geom_smooth(method = "lm") +
    theme_classic() + 
    theme(text = element_text(size = 14)) +
    labs(title = "Larger diamonds cost more by diamond color", 
          subtitle = "Price, $",
          y = "", 
          x = "Carat")

## `geom_smooth()` using formula 'y ~ x'

We can even remove the points below by simply removing the second line

ggplot(data = diamonds, aes(y = price, x = carat, color = clarity)) +
    facet_wrap(~color) + 
    geom_smooth(method = "lm") +
    theme_classic() + 
    theme(text = element_text(size = 14)) +
    labs(title = "Larger diamonds cost more by diamond color", 
          subtitle = "Price, $",
          y = "", 
          x = "Carat")

## `geom_smooth()` using formula 'y ~ x'

We can use ggplot to create all sorts of cool graphics. See cool gallery with code here: http://r-statistics.co/Top50-Ggplot2-Visualizations-MasterList-R-Code.html

Run regressions

To do this we can use a few different methods. We will first demonstrate using base R’s lm() (linear models) function and then with the fixest package.

Base R

Regressions in R use a formula interface a la y ~ x1 + x2 + .... Let’s see that in action via a simple OLS model using the lm function

base_model = lm(price ~ carat, data = diamonds)

Two things to note:

1. We saved the resulting model as an object. If you take a look at your global Environment pane (top right window in RStudio). You should see the base_model object there. This reflects the fact that R can hold a multitude of objects in memory at any one time. Speaking fo which…

2. Note that we specified the dataset that we want to use in the above call, i.e. lm(..., data = diamonds). Specifying the dataset is very important in R; precisely because it can hold multiple objects and datasets in memory at any one time. This is a major difference to Stata where, frames aside, we only ever hold one dataset in memory at a time.

To view detailed information about our saved regression model, I can use the generic summary() function.

summary(base_model)

## 
## Call:
## lm(formula = price ~ carat, data = diamonds)
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -18585.3   -804.8    -18.9    537.4  12731.7 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -2256.36      13.06  -172.8   <2e-16 ***
## carat        7756.43      14.07   551.4   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 1549 on 53938 degrees of freedom
## Multiple R-squared:  0.8493, Adjusted R-squared:  0.8493 
## F-statistic: 3.041e+05 on 1 and 53938 DF,  p-value: < 2.2e-16

To put this in a regression table form, we can use the modelsummary() function from the aforementioned package.

# library(modelsummary) ## Already loaded
modelsummary(base_model) 

	Model 1
(Intercept)	-2256.361
	(13.055)
carat	7756.426
	(14.067)
Num.Obs.	53940
R2	0.849
R2 Adj.	0.849
AIC	945466.5
BIC	945493.2
Log.Lik.	-472730.266
F	304050.906

We don’t have time to go into much detail, but modelsummary() is extremely flexible and powerful. It also plays very well with other packages. For example, can tweak this output to look a bit better. We will use the nice kableExtra package to help.

library(kableExtra) ## For adding a footnote to our table

## 
## Attaching package: 'kableExtra'

## The following object is masked from 'package:dplyr':
## 
##     group_rows

modelsummary(
  base_model,  
  title = "Fantastic regression table", 
  stars = TRUE, 
  coef_map = c("carat" = "Carat"),
  gof_omit = "Adj|Pseudo|Log|AIC|BIC|F|R2"
  ) %>%
  add_footnote("An important note.")

## Warning: In version 0.8.0 of the `modelsummary` package, the default significance markers produced by the `stars=TRUE` argument were changed to be consistent with R's defaults.
## This warning is displayed once per session.

Fantastic regression table

	Model 1
Carat	7756.426***
	(14.067)
Num.Obs.	53940
a An important note.
+ p < 0.1, * p < 0.05, ** p < 0.01, *** p < 0.001

Now we can run all sorts of other models and display them side-by-side. Let’s add some controls

model_add_controls = lm(price ~ carat + depth + table , data = diamonds)

We can add this model to a list with the base model. We name each item here.

models = list(
    "Base"  = base_model, 
    "Add Controls"  = model_add_controls
    )

We can use the same format as earlier.

modelsummary(
  models,  
  title = "Fantastic regression table", 
  stars = TRUE,
  coef_omit = c("(Intercept)"), 
  coef_rename = c("carat" = "Carat", "depth" = "Depth", "table" = "Table width"),
  gof_omit = "Adj|Pseudo|Log|AIC|BIC|F|R2"
  ) %>%
  add_footnote("An important note.")

Fantastic regression table

	Base	Add Controls
Carat	7756.426***	7858.771***
	(14.067)	(14.151)
Depth		-151.236***
		(4.820)
Table width		-104.473***
		(3.141)
Num.Obs.	53940	53940
a An important note.
+ p < 0.1, * p < 0.05, ** p < 0.01, *** p < 0.001

Aside 1: Adjusting standard errors

Several R packages provide support for adjusting standard errors (SEs) at estimation time, similar to Stata’s , robust syntax. We’ll see an example of that in the next section. However, R also offers a powerful alternative: Namely “on-the-fly” SE adjustment for models that have already been run. This alternative approach takes a little getting used to if you’re coming from Stata. But separating estimation from inference in this way comes with some big potential upsides.

Grant has a blog post that explains this on-the-fly adjustment process in more depth. However, to very quickly illustrate using the modelsummary() function again, consider what happens when we feed our single base_model object a set of “vcov” arguments. Answer: It automatically reports the adjusted SEs for all those case without having to re-run the model again!

modelsummary(
  base_model,  
  vcov = c('iid', 'robust', 'stata', 'NeweyWest'), ## New
  title = "One model, many standard errors", 
  stars = TRUE,
  coef_map = c("carat" = "Carat"),
  gof_omit = "Adj|Pseudo|Log|AIC|BIC|F|R2"
  )

One model, many standard errors

	Model 1	Model 2	Model 3	Model 4
Carat	7756.426***	7756.426***	7756.426***	7756.426***
	(14.067)	(25.408)	(25.399)	(150.790)
Num.Obs.	53940	53940	53940	53940
Std. Errors	IID	Robust	Stata	Newey-West
+ p < 0.1, * p < 0.05, ** p < 0.01, *** p < 0.001

Note: R (and Python) use a different default sandwich estimator for calculating “robust” (HC) SEs than Stata. The differences in most cases are likely to be small and due to a different DoF adjustment choice. For more information, see here or here.

Aside 2: Coefficient plot

The final arrow in the modelsummary quiver is modelplot(). This accepts most of the same arguments as its modelsummary() companion and produces nice, ggplot2-friendly coefficient plots. Adapting our previous example:

modelplot(
    base_model,  
    vcov = c(iid = 'iid', 'robust', 'stata', 'NeweyWest'), 
    coef_map = c("carat" = "Carat")
    )

Using fixest

Next, we will use fixest to run a regression with fixed effects.

library(fixest)

## fixest 0.9.0, BREAKING changes! (Permanently remove this message with fixest_startup_msg(FALSE).) 
## - In i():
##     + the first two arguments have been swapped! Now it's i(factor_var, continuous_var) for interactions. 
##     + argument 'drop' has been removed (put everything in 'ref' now).
## - In feglm(): 
##     + the default family becomes 'gaussian' to be in line with glm(). Hence, for Poisson estimations, please use fepois() instead.

The fixed effects are those after the | symbol.

fe_model = feols(price ~ carat + depth + table | color + cut + clarity, data = diamonds, cluster = ~color)

We can create a similar list as earlier.

models = list(
    "Base"  = base_model, 
    "Add Controls"  = model_add_controls,
    "Fixed-Effects" = fe_model
)

modelsummary(models,  
  title = "Fantastic regression table", 
  stars = TRUE,
  gof_omit = "Adj|Pseudo|Log|AIC|BIC|F|R2", 
  coef_omit = c("(Intercept)"), 
  coef_rename = c("carat" = "Carat", 
                  "Num.Obs." = "N")) %>%
  add_footnote("An important note.",
  threeparttable = TRUE)

Fantastic regression table

	Base	Add Controls	Fixed-Effects
Carat	7756.426***	7858.771***	8895.194***
	(14.067)	(14.151)	(283.956)
depth		-151.236***	-21.024*
		(4.820)	(6.770)
table		-104.473***	-24.803**
		(3.141)	(4.298)
Num.Obs.	53940	53940	53940
Std. Errors			Clustered (color)
a An important note.
+ p < 0.1, * p < 0.05, ** p < 0.01, *** p < 0.001

See more html display options here, https://cran.r-project.org/web/packages/kableExtra/vignettes/awesome_table_in_html.html

Now we can export this to latex

modelsummary(
  models,  
  title = "Fantastic regression table", 
  stars = TRUE,
  gof_omit = "Adj|Pseudo|Log|AIC|BIC|F|R2", 
  coef_omit = c("(Intercept)"), 
  coef_rename = c("carat" = "Carat", 
                  "Num.Obs." = "N"), 
  output = 'output/table.tex'
  )

Table using etable

We can also use the etable function that is a part of fixest package.

models_for_etable = list(
    "Fixed-Effects" = fe_model
)

etable(models_for_etable) %>%
    kbl(caption = "Fantastic regression table") %>%
    kable_styling(full_width = F)

Fantastic regression table

	Fixed-Effects
Dependent Var.:	price
carat	8,895.2*** (284.0)
depth	-21.02* (6.770)
table	-24.80** (4.298)
Fixed-Effects:	——————
color	Yes
cut	Yes
clarity	Yes
_______________	__________________
S.E.: Clustered	by: color
Observations	53,940
R2	0.91605
Within R2	0.91014

Aside: See this excellent blog post by Patrick Baylis on how to “fine-tune” your tables using etable for latex export. It’s quite simple to do, but will require a bit of time perfecting it to your exact liking. While it’s outside the scope of this presentation, it’s some hard earned knowledge he’s sharing that should make your life easier. https://www.patrickbaylis.com/blog/2021-05-30-making-tables/

Package management

A key feature of R is that you’ll need to have packages installed and load them as needed. This can be painful to keep track of across machines and especially across coauthors. In addition to simply having the package installed, making sure you have the right version of the package is important.

pacman

pacman is a fantastically named package manager, it can handle both packages on CRAN and packages stored only on places like github. The p_load function will include the library if you have it and install it and include it if you do not. For this code chunk I have it set to not evaluate since we previously included many of these libraries.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(
  ggplot2, dplyr, modelsummary, kableExtra, fixest, devtools
)
pacman::p_load_gh("hemken/Statamarkdown")

This will install pacman if it’s not currently installed. This code also introduces us to some other coding in R. You can call a function from a package using the :: syntax where the package name is on the left and the function name on the right. This is helpful if there are two packages that have the same function name (e.g., this happens with the select function sometimes).

renv

renv helps make sure that differences in package versions won’t prevent you from being able to replicate your results. Essentially it stores the exact version of each package you are using in a sandboxed environment. It makes it easy for another person (or future you) to use the exact same version of each package. It saves these in a renv.lock file. Once you’ve installed renv and you’ve opened up a new R-project, just type renv::init() and you should be good to go. renv::snapshot() will update changes.

You can read more about renv here: https://rstudio.github.io/renv/articles/renv.html

Running stata from R

• First you’ll need to make sure that you have stata on the computer you’re using.
• Second, you’ll need to install Statamarkdown

Here you’d load the package devtools, this allows you to install packages from github. If you’re using pacman the p_load_gh function is a great way to load these packages. Then I’ll install the Statamarkdown package. Again, not needed if you’ve done this using pacman so I’ve set this code chunk to only show the code and not run it.

library("devtools")
install_github("hemken/Statamarkdown")

Load the package Statamarkdown, again not needed if using pacman.

library("Statamarkdown")

## Stata found at /Applications/Stata//StataMP.app/Contents/MacOS/StataMP

## The 'stata' engine is ready to use.

Then you just need to type this code chunk.

```{stata}
sysuse auto
summarize
```

which will result in the following output.

(1978 Automobile Data)

    Variable |        Obs        Mean    Std. Dev.  
>      Min        Max
-------------+--------------------------------------
> -------------------
        make |          0
       price |         74    6165.257    2949.496   
>     3291      15906
         mpg |         74     21.2973    5.785503   
>       12         41
       rep78 |         69    3.405797    .9899323   
>        1          5
    headroom |         74    2.993243    .8459948   
>      1.5          5
-------------+--------------------------------------
> -------------------
       trunk |         74    13.75676    4.277404   
>        5         23
      weight |         74    3019.459    777.1936   
>     1760       4840
      length |         74    187.9324    22.26634   
>      142        233
        turn |         74    39.64865    4.399354   
>       31         51
displacement |         74    197.2973    91.83722   
>       79        425
-------------+--------------------------------------
> -------------------
  gear_ratio |         74    3.014865    .4562871   
>     2.19       3.89
     foreign |         74    .2972973    .4601885   
>        0          1

/Users/hollinal/Documents/GitHub/ehec-intro-to-r/not
> es


(file output/scatter.png written in PNG format)

You can then put these image in the RMarkdown document.

Note: If you run this on your computer the scatter will likely not look the same. These are not default stata graph preferences. See blindschemes with the suboption plotplainblind if you like this formatting.

Aside: It’s possible to do this without the Statamarkdown package, but I struggeled to get it to work, possibly because I have Stata-MP. You can see this link for more details: https://bookdown.org/yihui/rmarkdown-cookbook/eng-stata.html For more information on Statamarkdown see here: https://www.ssc.wisc.edu/~hemken/Stataworkshops/Stata%20and%20R%20Markdown/StataEnginePath.html

Meta: Use R to call stata to call R

Say that you have an R-script called test.R. This test script just shows sin(3) and is saved in the same folder as this .Rmd file.

```{stata}
shell /usr/local/bin/R --vanilla <test.R
```

R version 4.1.0 (2021-05-18) -- "Camp Pontanezen"
Copyright (C) 2021 The R Foundation for Statistical 
> Computing
Platform: x86_64-apple-darwin17.0 (64-bit)

R is free software and comes with ABSOLUTELY NO WARR
> ANTY.
You are welcome to redistribute it under certain con
> ditions.
Type 'license()' or 'licence()' for distribution det
> ails.

  Natural language support but running in an English
>  locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publi
> cations.

Type 'demo()' for some demos, 'help()' for on-line h
> elp, or
'help.start()' for an HTML browser interface to help
> .
Type 'q()' to quit R.

> sin(3)
[1] 0.14112
> 

Misc. tips

Use R projects

If you take a look at the parent directory (repo) containing this document, you’ll see a file called ehec-intro-to-r.Rproj. The .Rproj denotes an “R project” file.

What is this and why is it useful? Think of .Rproj files as specifying the root of a bunch of related files. Among other things, this helps to keep your projects organised and ergonomic. For example, you can open a group of related files in RStudio simply by clicking the .Rproj file. It also means that you never have to worry about specifying absolute paths when reading or writing files. You need only specify relative paths, since R knows that the project file acts as a base (root) for everything else.

R Projects are just as easy to create as regular R scripts or Rmd files. You can use them to start new projects or associate with an existing directory. Read more about them here.

Clear memory

You can remove objects at any time using the rm() function. For example, rm(base_model) will remove our simple OLS model from earlier. To completely clear your memory and remove all objects, it’s best to simply restart your R session. In RStudio, go to Session > Restart R. (Or use the keyboard shortcut: Ctrl + Shift + F10.)

Reading and writing data

• Whenever possible, I try to use the data.table functions fread and fwrite. These work really well for csv data.

For example, let’s save the diamonds dataset so we can import it in stata for a little example later on.

library(data.table)

Attaching package: 'data.table'

The following objects are masked from 'package:dplyr':

    between, first, last

fwrite(diamonds, file = "data/diamonds.csv")

data.table is really really good with big datasets. Check out this walkthrough: https://cran.r-project.org/web/packages/data.table/vignettes/datatable-intro.html

library(haven)
haven::write_dta(diamonds, path = "data/diamonds.dta", version = 14)

Note: Reading and writing data in other formats is really easy with the haven package. This can also handle, wait for it, SAS datasets really easily.

• You can read and write excel data with readxl package, which is a part of the tidyverse

We can show that this worked by using the Statamarkdown package.

// Use the csv file saved by fwrite in R
import delimited data/diamonds.csv, clear

twoway ///
  || scatter price carat, ///
  title("Bigger diamonds cost more- using fwrite to csv", pos(11)) ///
  subtitle("Price", pos(11)) ///
  ytitle("") ///
  xtitle("Carat") ///
  yla(,nogrid notick) ///
  xla(,nogrid notick)
  
graph export "output/scatter-diamonds-using-csv.png", replace

// Use the dta file saved by fwrite in R
use data/diamonds.dta, clear

twoway ///
  || scatter price carat, ///
  title("Bigger diamonds cost more- using write_dta to dta", pos(11)) ///
  subtitle("Price", pos(11)) ///
  ytitle("") ///
  xtitle("Carat") ///
  yla(,nogrid notick) ///
  xla(,nogrid notick)

graph export "output/scatter-diamonds-using-dta.png", replace

(10 vars, 53,940 obs)


(file output/scatter-diamonds-using-csv.png written 
> in PNG format)



(file output/scatter-diamonds-using-dta.png written 
> in PNG format)

You can then put these image in the RMarkdown document.

Collapsing data

The collapse package is amazing. It’s crazy fast too. collapse plus data.table make creating analyitic files from large microdata a breeze.

Reshaping data.

pivot_wider and pivot_longer are both a part of the tidyverse. Read more about them here. https://tidyr.tidyverse.org/articles/pivot.html

---

1. If you are curious about Markdown formatting on its own — how to get bold text or italics, how to create tables or headers, etc — then see this handy cheatsheet.↩︎

2. Case in point: .Rmd files are Markdown files, so using a leading # in the text will create a heading rather than a comment. However, if we hit Ctrl + Shift + c then RStudio will automatically generate the correct comment syntax, namely <!–– to start the comment and ––> to end it.↩︎