R for Data Science, Statistics & Reporting

1. Open the CRAN website.
2. Choose “Download R for Windows”.
3. Select “base”.
4. Download the current Windows installer.
5. Run the installer and accept the standard options.
6. Download RStudio Desktop from Posit.
7. Install and open RStudio.
8. In the Console, run: R.version.string

1. Open the CRAN website.
2. Choose “Download R for macOS”.
3. Select the installer that matches your Mac and macOS version.
4. Run the downloaded package.
5. Download and install RStudio Desktop.
6. Open RStudio and run: R.version.string

sudo apt update
sudo apt install r-base r-base-dev

# Verify
R --version

# Start R
R

# Exit R
q()

R.version.string
getwd()

message("R is installed and working.")

# File > New File > R Script

name <- "Imonikhe"
message <- paste("Welcome to R,", name)

print(message)

1. Select File > New Project.
2. Choose New Directory.
3. Choose New Project.
4. Give the project a meaningful name.
5. Keep scripts, data and outputs inside the project.
6. Use relative paths instead of changing the working directory manually.

my-r-project/
├── data/
├── scripts/
├── outputs/
├── reports/
├── figures/
└── my-r-project.Rproj

install.packages("tidyverse")
install.packages(c(
  "readxl",
  "openxlsx",
  "janitor",
  "skimr",
  "here"
))

library(tidyverse)
library(readxl)
library(openxlsx)
library(janitor)
library(skimr)
library(here)

installed.packages()[, c("Package", "Version")]
update.packages(ask = FALSE)

name <- "Simon"
age <- 28L
height <- 1.78
is_learning <- TRUE
missing_value <- NA

class(name)
class(age)
class(height)
class(is_learning)

a <- 10
b <- 3

a + b
a - b
a * b
a / b
a %% b
a ^ b

a > b
a == 10
a != b

message <- "R for Data Science"

tolower(message)
toupper(message)
nchar(message)
grepl("Data", message)

paste("Learning", "R")
paste0("Score: ", 95)

scores <- c(78, 82, 91, 65, 88)

scores[1]
scores[2:4]
scores[scores >= 80]

length(scores)
mean(scores)
median(scores)
sum(scores)

gender <- factor(c(
  "Female",
  "Male",
  "Female",
  "Another way"
))

levels(gender)
table(gender)

patient <- list(
  name = "John",
  age = 65,
  diagnosis = "Diabetes"
)

patient$name
patient[["age"]]

matrix_data <- matrix(
  1:6,
  nrow = 2,
  byrow = TRUE
)

matrix_data

score <- 75

if (score >= 70) {
  result <- "Distinction"
} else if (score >= 60) {
  result <- "Merit"
} else if (score >= 50) {
  result <- "Pass"
} else {
  result <- "Fail"
}

print(result)

scores <- c(70, 80, 90)

for (score in scores) {
  print(score)
}

count <- 1

while (count <= 5) {
  print(count)
  count <- count + 1
}

scores <- c(45, 67, 82, 39, 91)

result <- ifelse(
  scores >= 50,
  "Pass",
  "Fail"
)

result

calculate_mean <- function(values) {
  if (length(values) == 0) {
    stop("The vector cannot be empty.")
  }

  mean(values, na.rm = TRUE)
}

calculate_mean(c(70, 80, 90, NA))

calculate_total <- function(price, quantity = 1) {
  price * quantity
}

calculate_total(20)
calculate_total(20, 3)

safe_divide <- function(a, b) {
  tryCatch(
    {
      if (b == 0) {
        stop("Cannot divide by zero.")
      }

      a / b
    },
    error = function(error) {
      message(error$message)
      NA_real_
    }
  )
}

library(tibble)

data <- tibble(
  name = c("Alice", "Ben", "Chidi", "David"),
  age = c(25, 32, 41, 29),
  score = c(85, 72, 91, 68)
)

data

head(data)
tail(data)
dim(data)
names(data)
str(data)
summary(data)

library(skimr)
skim(data)

library(dplyr)

data |>
  select(name, score)

data |>
  filter(score >= 80)

data |>
  slice(1:3)

library(readr)
library(readxl)

csv_data <- read_csv("data/patients.csv")

excel_data <- read_excel(
  "data/patients.xlsx",
  sheet = "Responses"
)

library(haven)

spss_data <- read_sav("data/survey.sav")
stata_data <- read_dta("data/survey.dta")
sas_data <- read_sas("data/survey.sas7bdat")

library(readr)
library(openxlsx)

write_csv(
  cleaned_data,
  "outputs/cleaned_data.csv"
)

write.xlsx(
  cleaned_data,
  "outputs/cleaned_data.xlsx"
)

library(dplyr)

result <- data |>
  select(name, age, score) |>
  filter(score >= 70, age < 40) |>
  arrange(desc(score))

result

data <- data |>
  mutate(
    score_percentage = score / 100,
    result = if_else(
      score >= 70,
      "Pass",
      "Fail"
    )
  )

data <- data |>
  mutate(
    grade = case_when(
      score >= 80 ~ "Excellent",
      score >= 70 ~ "Good",
      score >= 50 ~ "Pass",
      TRUE ~ "Fail"
    )
  )

library(janitor)
library(dplyr)
library(tidyr)

data <- data |>
  clean_names() |>
  mutate(
    score = replace_na(score, median(score, na.rm = TRUE)),
    gender = replace_na(gender, "Unknown")
  )

colSums(is.na(data))

duplicated_rows <- data |>
  filter(duplicated(patient_id))

data <- data |>
  distinct(patient_id, .keep_all = TRUE) |>
  mutate(
    age = as.numeric(age),
    gender = as.factor(gender)
  )

library(lubridate)

data <- data |>
  mutate(
    appointment_date = ymd(appointment_date),
    year = year(appointment_date),
    month = month(appointment_date, label = TRUE),
    day_name = wday(appointment_date, label = TRUE)
  )

summary_table <- data |>
  group_by(gender) |>
  summarise(
    mean_score = mean(score, na.rm = TRUE),
    median_score = median(score, na.rm = TRUE),
    participants = n(),
    .groups = "drop"
  )

summary_table

distribution <- data |>
  count(gender, name = "participants") |>
  mutate(
    percentage = participants / sum(participants) * 100
  )

distribution

data |>
  summarise(
    across(
      c(age, score),
      list(
        mean = ~ mean(.x, na.rm = TRUE),
        sd = ~ sd(.x, na.rm = TRUE)
      )
    )
  )

combined <- patients |>
  left_join(
    hospitals,
    by = "hospital_id"
  )

matched_only <- patients |>
  inner_join(
    hospitals,
    by = "hospital_id"
  )

library(tidyr)

long_data <- data |>
  pivot_longer(
    cols = starts_with("score_"),
    names_to = "year",
    values_to = "score"
  )

wide_data <- long_data |>
  pivot_wider(
    names_from = year,
    values_from = score
  )

library(ggplot2)

ggplot(data, aes(x = age, y = score)) +
  geom_point() +
  labs(
    title = "Age and Score",
    x = "Age",
    y = "Score"
  ) +
  theme_minimal()

ggplot(distribution, aes(
  x = gender,
  y = percentage
)) +
  geom_col() +
  labs(
    title = "Participant Distribution",
    x = "Gender",
    y = "Percentage"
  ) +
  theme_minimal()

ggplot(data, aes(
  x = response_method,
  y = score
)) +
  geom_boxplot() +
  labs(
    title = "Scores by Response Method",
    x = "Response method",
    y = "Score"
  ) +
  theme_minimal()

test_result <- t.test(
  score ~ response_method,
  data = data,
  var.equal = FALSE
)

test_result

contingency_table <- table(
  data$gender,
  data$response_method
)

chi_result <- chisq.test(contingency_table)
chi_result

fisher_result <- fisher.test(contingency_table)
fisher_result

model <- lm(
  score ~ age + response_method + gender,
  data = data
)

summary(model)
confint(model)

model <- glm(
  has_disease ~ age + blood_pressure + cholesterol,
  data = data,
  family = binomial()
)

summary(model)

predicted_probability <- predict(
  model,
  newdata = data,
  type = "response"
)

library(tidymodels)

set.seed(42)

data_split <- initial_split(
  data,
  prop = 0.8,
  strata = has_disease
)

training_data <- training(data_split)
testing_data <- testing(data_split)

model_recipe <- recipe(
  has_disease ~ age + blood_pressure +
    cholesterol + gender,
  data = training_data
) |>
  step_impute_median(all_numeric_predictors()) |>
  step_impute_mode(all_nominal_predictors()) |>
  step_dummy(all_nominal_predictors()) |>
  step_normalize(all_numeric_predictors())

logistic_model <- logistic_reg() |>
  set_engine("glm") |>
  set_mode("classification")

model_workflow <- workflow() |>
  add_recipe(model_recipe) |>
  add_model(logistic_model)

fitted_model <- fit(
  model_workflow,
  data = training_data
)

predictions <- predict(
  fitted_model,
  testing_data,
  type = "prob"
) |>
  bind_cols(
    predict(fitted_model, testing_data),
    testing_data
  )

metrics(
  predictions,
  truth = has_disease,
  estimate = .pred_class
)

library(dplyr)
library(slider)

time_data <- time_data |>
  arrange(date) |>
  mutate(
    energy_lag_1 = lag(energy_use, 1),
    rolling_mean_7 = slide_dbl(
      energy_use,
      mean,
      .before = 6,
      .complete = TRUE,
      na.rm = TRUE
    )
  )

library(lubridate)

monthly_data <- time_data |>
  mutate(month = floor_date(date, "month")) |>
  group_by(month) |>
  summarise(
    mean_energy = mean(energy_use, na.rm = TRUE),
    .groups = "drop"
  )

---
title: "Analysis Report"
author: "Imonikhe Ayeni"
format:
  html:
    toc: true
    code-fold: true
execute:
  echo: true
  warning: false
---

```{r}
#| label: participant-summary

library(dplyr)

data |>
  summarise(
    participants = n(),
    mean_score = mean(score, na.rm = TRUE)
  )
```

quarto::quarto_render(
  "reports/analysis.qmd"
)

library(shiny)

ui <- fluidPage(
  titlePanel("Score Explorer"),
  sliderInput(
    "minimum_score",
    "Minimum score",
    min = 0,
    max = 100,
    value = 50
  ),
  tableOutput("filtered_table")
)

server <- function(input, output, session) {
  output$filtered_table <- renderTable({
    data |>
      filter(score >= input$minimum_score)
  })
}

shinyApp(ui, server)

• Use R projects and relative paths.
• Prefer clear object names over x, y or temp.
• Keep raw data unchanged.
• Put reusable logic in functions.
• Use set.seed() for reproducible random processes.
• Validate joins by checking row counts and unmatched keys.
• Comment why a decision was made, not only what the code does.
• Store package versions for important projects.

library(here)

data <- readr::read_csv(
  here("data", "patients.csv")
)

readr::write_csv(
  data,
  here("outputs", "patients_clean.csv")
)

install.packages("renv")

renv::init()
renv::snapshot()

# Restore packages later
renv::restore()

RStudio, variables, vectors, lists, data frames, conditions, loops, functions and packages.

Data import, dplyr, tidyr, missing data, joins, dates, grouped summaries and ggplot2.

Statistical tests, linear models, logistic regression, survey analysis and model interpretation.

tidymodels, time series, Quarto, Shiny and one complete end-to-end project.