Marcin Kierczak

Statistics from the beginning: location and spread

Marcin Kierczak — Thu, 15 Oct 2026 22:00:00 GMT

Series · Statistics from the beginning · Part 1

About this series

This series is adapted from lecture notes I wrote in 2017, Introduction to Statistical Tests (original PDF). I am turning them into short posts with fresh code and figures, starting from the very beginning. This first part covers location and spread. Later parts cover covariance and correlation, and then the tests themselves.

Statistics, and a statistic

Statistics is a branch of mathematics concerned with the collection, analysis, interpretation and presentation of data. A very similar word, a statistic, means something narrower: a single number that summarises some feature of a data sample, produced by a statistical procedure. The sample mean and the sample standard deviation are statistics.

One distinction runs through everything that follows:

distributions (populations) are described by parameters,
samples are described by statistics.

We almost never see the whole population, so we use statistics computed from a sample to estimate the parameters of the distribution it came from. Every distribution can be described by two kinds of parameters: location parameters (where are the data?) and spread (dispersion) parameters (how widely is it scattered?).

library(ggplot2)

# A shared look for the figures in this series
accent <- "#8c2f39"; gold <- "#b08d4a"; ink <- "#5d6070"
theme_set(
  theme_minimal(base_size = 13) +
    theme(plot.background = element_rect(fill = "#FFFDF8", colour = NA),
          panel.grid.minor = element_blank(),
          panel.grid.major = element_line(colour = "#EEEAE0", linewidth = 0.3),
          plot.title.position = "plot")
)

Location: where are the data?

Mean

The mean measures the central tendency of the data: the sum of all values divided by the number of observations,

The population mean is written and the sample mean ; is the number of observations.

The mean has a weakness: it uses every value, so it is pulled around by outliers and by skewed distributions. Five sheep weighing between 52 and 57 kg have a mean of 54.8 kg. Add one animal recorded as 120 kg (perhaps a typo) and see what happens:

sheep <- c(52, 54, 55, 56, 57)
c(mean = mean(sheep), median = median(sheep))

  mean median 
  54.8   55.0

sheep_typo <- c(sheep, 120)
c(mean = mean(sheep_typo), median = median(sheep_typo))

    mean   median 
65.66667 55.50000

The mean jumps by more than ten kilos; the median barely moves. People handle this problem with variants of the mean, such as the weighted mean or the Winsorised mean, which tames extreme observations, but we will not go into those here.

Median

The median is another location parameter. Unlike the mean it does not use all the observations: it is simply the middle value of the ordered data. With an odd number of data points it is easy to find. With an even number, it is the mean of the two middle values.

Comparing the mean with the median tells us something about skewness:

for a perfectly symmetric distribution, mean and median are equal,
for a right-skewed distribution (a long tail to the right), the mean is greater than the median, because the tail drags the mean along,
for a left-skewed distribution (a long tail to the left), the mean is less than the median.

set.seed(42)
x <- data.frame(value = rgamma(2000, shape = 2, rate = 0.5))

ggplot(x, aes(value)) +
  geom_histogram(bins = 45, fill = "#d8cfba", colour = "#FFFDF8") +
  geom_vline(xintercept = median(x$value), colour = gold, linewidth = 1) +
  geom_vline(xintercept = mean(x$value), colour = accent, linewidth = 1) +
  annotate("text", x = median(x$value) - 0.2, y = Inf, vjust = 2, hjust = 1,
           label = "median", colour = gold) +
  annotate("text", x = mean(x$value) + 0.2, y = Inf, vjust = 2, hjust = 0,
           label = "mean", colour = accent) +
  labs(x = NULL, y = NULL, title = "A right-skewed sample: mean > median")

Spread: how scattered are the data?

Variance

Variance measures dispersion around the mean: the more spread out the observations, the larger the variance. The population variance is and the sample variance is :

Why divide by rather than ? We want to be as good an estimate of as possible. Think of estimating the variance of weights in a herd of 2,000 sheep from a sample of 200. It is quite likely that our sample misses the few very light and very heavy animals, which would otherwise have contributed large terms. There is a second, more precise way to see it: we measure the deviations from , a number computed from the same sample, and the sample is always closer to its own mean than to the true mean . Dividing by would therefore underestimate the variance systematically; dividing by corrects it exactly.

Let’s check this with a simulation. We create a herd of 2,000 sheep, draw many samples of each size, and compare the two estimators with the true population variance.

set.seed(2017)
herd <- rnorm(2000, mean = 55, sd = 4)

# population variance: divide by N
pop_var <- function(x) sum((x - mean(x))^2) / length(x)
true_var <- pop_var(herd)

compare_var <- function(pop, n_draws, sample_size) {
  draws <- replicate(n_draws, sample(pop, sample_size))   # one sample per column
  c(corrected   = mean(apply(draws, 2, var)),             # divides by n - 1
    uncorrected = mean(apply(draws, 2, pop_var)))         # divides by n
}

sizes <- 5:100
sim <- t(sapply(sizes, function(n) compare_var(herd, 1000, n)))
sim <- data.frame(n = rep(sizes, 2),
                  estimate = c(sim[, "uncorrected"], sim[, "corrected"]),
                  version = rep(c("divide by n", "divide by n − 1"), each = length(sizes)))

ggplot(sim, aes(n, estimate, colour = version)) +
  geom_hline(yintercept = true_var, colour = ink, linetype = "dotted") +
  geom_point(size = 1.4) +
  scale_colour_manual(values = c("divide by n" = "#2b2117", "divide by n − 1" = accent)) +
  labs(x = "Sample size", y = "Average estimated variance", colour = NULL,
       title = "The effect of using n − 1 in the denominator",
       subtitle = "Dotted line: true population variance, averaged over 1,000 samples per size") +
  theme(legend.position = "top")

For small samples, dividing by clearly underestimates the variance; for large samples the choice hardly matters, because and are nearly the same number.

Variance can never be negative, since we square the deviations. A side effect of that squaring is that variance is expressed in squared units (kilograms squared for weights). That is why we usually report its square root instead.

Standard deviation

The standard deviation (sd, SD, std. dev.) is the square root of the variance, written for a population and for a sample. It is in the same units as the data, which makes it far easier to interpret: for our sheep, an sd of about 4 means that a typical animal is within a few kilograms of the herd’s mean weight.

Putting different scales on the same footing

If two traits are measured on different scales (say, body weight in kilograms and fleece length in centimetres), their variances cannot be compared directly: the numbers depend on the units. The usual remedy is standardisation: we transform each variable so that it has mean 0 and standard deviation 1, i.e. it follows the standard normal scale . The standardised values are called z-scores; each one tells us how many standard deviations an observation lies from the mean:

set.seed(7)
herd2 <- data.frame(weight_kg = rnorm(200, 55, 4),
                    fleece_cm = rnorm(200, 11, 1.5))

ewe <- c(weight_kg = 58, fleece_cm = 13.4)
z <- (ewe - colMeans(herd2)) / sapply(herd2, sd)
round(z, 2)

weight_kg fleece_cm 
     0.65      1.56

On the raw scale, 58 kg and 13.4 cm cannot be compared. As z-scores they can: this hypothetical ewe is about two-thirds of a standard deviation heavier than average, but more than one and a half standard deviations above average in fleece length. Relative to the rest of the herd, her fleece is the more unusual feature.

What’s next

We now have the vocabulary to describe a single variable: where it sits and how much it varies. In the next part we look at two variables at once, with covariance and correlation. Spoiler: correlation is simply covariance after standardisation.

All parts in this series

Next in the series: covariance and correlation.

Pest in R using R6 classes

Marcin Kierczak — Wed, 19 Jun 2024 22:00:00 GMT

Hello! In this post, I will show you how one can implement an agent-based simulation in R using object-oriented programming paradigm (OOP) and R6 classes.

This simulation is working yet it still has to be polished. It has been implemented as a live coding demo during “OOP in R” session at RaukR 2024.

Our goal is to simulate epidemics dynamics on an island (an isolated world). Let us establish some simple rules:

we have a N x N squares large rectangular world (think of each square as of, e.g. a building)
in each square dwell individuals that can be: healthy, immune (after recovering or vaccination), infected (= sick) or, unfortunately, also dead
in total, we have P individuals randomly distributed in our world’s squares
at every time step/round of our simulation individuals move and update their state
probability of becoming infected is proportional to the number of already infected individuals in the same square
probabilities of the remaining state transitions are given by simulation parameters
we continue the simulation for T rounds

An individual

Let’s begin by formulating an R6 class that represents an individual (= agent):

library(R6)

Agent <- R6Class("Agent",
  public = list(
    state = character(),
    initialize = function(state = "healthy") {
      self$state <- state
    },
    update_state = function(sick_prob, recovery_prob, death_prob) {
      # If agent is healthy it can either stay healthy or get infected
      if (self$state == "healthy") {
        new_state <- sample(x = c("healthy", "sick"), 
                       size = 1, 
                       prob = c(1-sick_prob, sick_prob))
      # A sick agent can continue being sick, recover and become immune or die
      } else if (self$state == "sick") { 
        new_state <- sample(x = c("sick", "immune", "dead"), 
                       size = 1, 
                       prob = c((1-(recovery_prob + death_prob)), recovery_prob, death_prob))
      
      } else {
        new_state <- self$state # Immune and dead states do not change
      }
      self$state <- new_state  # Update state
    }
  )
)

Observe that:

The default state of a new agent is “healthy”
We use sample and its prob argument to sample agent’s fate according to provided probabilities
“immune” and “dead” states do not change
when an individual is sick it can either continue to be sick, recover and become immune or die
we are using the fact that probabilities of mutually exclusive elementary events sum to 1

Simulation world

Now it is time to create a class for our world which we can next populate with our agents. We need the following:

variable size where we store information about our world size N,
variable world which will store our representation of the world. Since the world is a square, we can use R base data structure – matrix and each cell in the matrix will contain a list of our individuals that dwell there – they are of class Agent that we have just created
method initialize that creates the world
method add_agent to populate our world
method move_agent to move agents around at each simulation step
method update_states that updates states of agents
method get_counts that will record current state of the world (count of healthy, sick etc.)

World <- R6Class("World",
  public = list(
    size = NULL,
    world = NULL,
    
    initialize = function(size) {
      self$size <- size
      self$world <- matrix(vector("list", size * size), nrow = size, ncol = size)
      for (i in 1:size) {
        for (j in 1:size) {
          self$world[[i, j]] <- list()
        }
      }
    },
    
    add_agent = function(row, col, agent) {
      self$world[[row, col]] <- c(self$world[[row, col]], list(agent))
    },
    
    move_agents = function() {
      new_world <- matrix(vector("list", self$size * self$size), nrow = self$size, ncol = self$size)
      for (i in 1:self$size) {
        for (j in 1:self$size) {
          agents <- self$world[[i, j]]
          for (agent in agents) {
            if (agent$state != "dead") { # dead do not move
              move <- rnorm(2, mean = 0, sd = 1) # some arbitrary motility
              new_row <- min(max(1, round(i + move[1])), self$size)
              new_col <- min(max(1, round(j + move[2])), self$size)
              new_world[[new_row, new_col]] <- c(new_world[[new_row, new_col]], list(agent))
            } else {
              new_world[[i, j]] <- c(new_world[[i, j]], list(agent))
            }
          }
        }
      }
      self$world <- new_world
    },
    
    update_states = function(beta, recovery_prob, death_prob) {
      # Iterate over all grid cells in the world and 
      # determine infection probability based on
      # the number of already sick individuals in that grid cell.
      for (i in 1:self$size) {
        for (j in 1:self$size) {
          agents <- self$world[[i, j]]
          num_sick <- sum(vapply(agents, function(agent) agent$state == "sick", logical(1)))
          # Now, probability of becoming sick is naively proportional 
          # to the percentage of already sick individuals in the cell
          # where beta is the transmission probability
          sick_prob <- 1 - ((1 - beta) ^ num_sick)
          for (agent in agents) {
            agent$update_state(sick_prob, recovery_prob, death_prob)
          }
        }
      }
    },
    
    get_counts = function() {
      counts <- data.frame(
        row = integer(),
        col = integer(),
        healthy = integer(),
        immune = integer(),
        sick = integer(),
        dead = integer()
      )
      for (i in 1:self$size) {
        for (j in 1:self$size) {
          agents <- self$world[[i, j]]
          counts <- rbind(counts, data.frame(
            row = i,
            col = j,
            healthy = sum(vapply(agents, function(agent) agent$state == "healthy", logical(1))),
            immune = sum(vapply(agents, function(agent) agent$state == "immune", logical(1))),
            sick = sum(vapply(agents, function(agent) agent$state == "sick", logical(1))),
            dead = sum(vapply(agents, function(agent) agent$state == "dead", logical(1)))
          ))
        }
      }
      return(counts)
    }
  )
)

Tip

One line of code is probably a bit non-intuitive:

sick_prob <- 1 - ((1 - beta) ^ num_sick)

Here, parameter beta () is the so-called transmission probability that is specific for each disease agent. Now, is the probability of NOT catching the disease from any of neighbors. Finally, the chance of becoming sick in a given cell is

Auxiliary functions

I have written a function that visualizes states of our world as the simulation goes on using ggplot2 and gganimate packages. Here is the code:

visualize_simulation <- function(results) {
  p <- ggplot(results, aes(x = col, y = row)) +
    geom_tile(aes(fill = sick)) +
    scale_fill_gradient(low = "white", high = "red") +
    theme_minimal() +
    labs(title = "Disease Spread Simulation", x = "X", y = "Y", fill = "Sick Individuals") +
    transition_states(step, transition_length = 2, state_length = 1) +
    ease_aes('linear') +
    ggtitle('Disease Spread Simulation - Generation {closest_state}') +
    theme(plot.title = element_text(size = 16, face = "bold", hjust = 0.5))
  
  animate(p, nframes = length(unique(results$step)), fps = 2, renderer = gifski_renderer())
}

Running simulation

Now, we need a function that will enable us to run the simulation:

library(ggplot2)
library(gganimate)
library(progress)

run_simulation <- function(size, num_steps, initial_healthy, initial_immune, initial_sick, beta, recovery_prob, death_prob) {
  stopifnot(recovery_prob + death_prob <= 1) # some simplistic input validation
  pb <- progress_bar$new(total = num_steps + 1)
  
  world <- World$new(size)
  
  # Initialize agents
  if (initial_healthy > 0) {
    for (i in 1:initial_healthy) {
      row <- sample(1:size, 1)
      col <- sample(1:size, 1)
      world$add_agent(row, col, Agent$new())
    }
  }
  
  # Introduce immune and sick agents
  if (initial_immune > 0) {
    for (i in 1:initial_immune) {
      row <- sample(1:size, 1)
      col <- sample(1:size, 1)
      world$add_agent(row, col, Agent$new(state = "immune"))
    }
  }
  
  if (initial_sick > 0) {
    for (i in 1:initial_sick) {
      row <- sample(1:size, 1)
      col <- sample(1:size, 1)
      world$add_agent(row, col, Agent$new(state = "sick"))
    }
  }
  
  results <- list()
  
  # Save the initial state of the world
  counts <- world$get_counts()
  counts$step <- 1
  results[[1]] <- counts
  
  
  # Simulate one generation
  for (step in 2:num_steps + 1) {
    world$update_states(beta, recovery_prob, death_prob)
    world$move_agents()
    counts <- world$get_counts()
    counts$step <- step
    results[[step]] <- counts
    pb$tick()
  }
  
  results <- do.call(rbind, results)
  
  return(results)
}

Finally, we can run our simulation:

library(tidyverse)

── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ dplyr     1.2.1     ✔ readr     2.2.0
✔ forcats   1.0.1     ✔ stringr   1.6.0
✔ lubridate 1.9.5     ✔ tibble    3.3.1
✔ purrr     1.2.2     ✔ tidyr     1.3.2
── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag()    masks stats::lag()
ℹ Use the conflicted package () to force all conflicts to become errors

# Parameters
size <- 20                    # World size
num_steps <- 50               # Number of generations
initial_healthy <- 998
initial_immune <- 0
initial_sick <- 2
beta <- 0.5                  # Transmission probability
recovery_prob <- 0.1
death_prob <- 0.05

# Run the simulation
results <- run_simulation(size, num_steps, initial_healthy, initial_immune, initial_sick, beta, recovery_prob, death_prob)

results |> group_by(step) |> 
  summarise(n_sick = sum(sick), n_healthy = sum(healthy), n_immune = sum(immune), n_dead = sum(dead)) |> 
  pivot_longer(starts_with("n_"), names_to = 'measure') |> 
  ggplot(aes(x = step, y = value, col=measure)) + geom_line() + theme_minimal()

Making more glamorous graphs in ggplot2

Marcin Kierczak — Mon, 03 Feb 2020 23:00:00 GMT

Updated in 2026

Lightly edited from a 2020 post. The plot is re-rendered with current packages (size became linewidth in ggplot2). The data stop in February 2020, and the scraper is shown but not run, since the repository pages it parsed have changed.

Inspired by William R. Chase’s rstudio::conf 2020 talk “The Glamour of Graphics”, I decided to spruce up an old plot. It is the one I show my students every year to motivate them to learn R: the number of R packages available in various repositories over the years.

From William’s talk I took these lessons:

Left-align titles.
Use non-white backgrounds.
Skip axis labels if not necessary.
Use as few grid lines as possible.
Capture the legend in the title.

There is much more in the talk that I do not implement here, for example using professional fonts.

Libraries

library(tidyverse)
library(curl)
library(ggrepel)
library(scales)
library(ggtext)
library(glue)

Data

I have an ugly function that scrapes CRAN, R-Forge, Bioconductor and, later, also GitHub to count R packages (GitHub is a bit problematic, but hopefully a good proxy). The function repeats code that I should have encapsulated and parametrised. No one is perfect.

interrogate_repos <- function() {
  # CRAN
  cran_con <- curl::curl(url = 'https://cran.r-project.org/web/packages/index.html')
  cran <- paste0(readLines(con = cran_con, n = 20), collapse = '')
  cran_pkgs <- stringr::str_match(cran, 'repository features ([0-9]{1,}) available packages')[2]

  # R-Forge
  rforge_con <- curl::curl(url = 'https://r-forge.r-project.org')
  rforge <- paste0(readLines(con = rforge_con, n = 200), collapse = '')
  rforge_pkgs <- stringr::str_replace(stringr::str_match(rforge, 'Projects: ([0-9]{1,},[0-9]{1,})')[2], ',', '')

  # Bioconductor
  bioconductor_con <- curl::curl(url = 'https://bioconductor.org')
  bioconductor <- paste0(readLines(con = bioconductor_con, n = 200), collapse = '')
  bioconductor_pkgs <- stringr::str_match(bioconductor, 'Software\">([0-9]{1,}).*software packages.')[2]

  # GitHub
  github_con <- curl::curl(url = 'https://github.com/search?l=R&q=R+package&type=Repositories')
  github <- paste0(readLines(con = github_con, n = 1200), collapse = '')
  github_pkgs <- stringr::str_replace(stringr::str_match(github, '([0-9]{1,},[0-9]{1,}) repository results')[2], ',', '')

  day <- format(Sys.time(), "%Y-%m-%d")
  result <- c(day, cran_pkgs, rforge_pkgs, bioconductor_pkgs, github_pkgs)
  names(result) <- c('date', 'CRAN', 'R-Forge', 'Bioconductor', 'GitHub')
  return(result)
}

From time to time I ran the following code to update my dataset:

prev_data <- read_csv('num_pkgs_data.csv')
today <- interrogate_repos()
if (last(prev_data$date) < today[1]) {
  prev_data <- rbind(prev_data, today)
  write_csv(x = prev_data, 'num_pkgs_data.csv')
}

The dataset looks like this:

prev_data <- read_csv('num_pkgs_data.csv')
prev_data

# A tibble: 10 × 5
   date        cran rforge bioconductor github
                    
 1 2011-05-17  2984    998          460     NA
 2 2011-11-22  3429   1182          516     NA
 3 2012-04-25  3745   1274          554     NA
 4 2013-07-11  4689   1584          671     NA
 5 2013-09-24  4846   1631          671     NA
 6 2016-08-31  9066   2024         1211     NA
 7 2017-03-22 10312   2048         1296     NA
 8 2017-10-20 11646   2063         1383     NA
 9 2018-11-11 13342   2086         1649     NA
10 2020-02-03 15330   2121         1823  28667

Data transformation

To plot this sensibly, I convert it from wide to long format:

data <- prev_data |>
  pivot_longer(cols = c(cran, rforge, bioconductor, github), names_to = 'repo') |>
  mutate(value = as.integer(value))

Plotting

I needed some cool colours. On my way home from rstudio::conf 2020 I watched Taika Waititi’s “Jojo Rabbit”, which I found visually appealing. I grabbed a screenshot and, with the Colormind tool, created two palettes from it.

jojo1 <- c('#c0b3aa', '#2b2117', '#9a8268', '#d3a677', '#e1d0ba')
jojo2 <- c('#221c17', '#947e66', '#da9869', '#e0c6a4', '#c1b3ab')

And now the most glamorous version of the plot, with the legend living in the title:

cols <- c('bioconductor' = jojo2[2], 'cran' = jojo2[3], 'github' = jojo2[1], 'rforge' = jojo2[5])

title <- glue('Log # of R packages available at',
              ' **CRAN**,',
              ' **R-Forge**,',
              ' **Bioconductor**',
              ' and',
              ' **GitHub**',
              ' over time.')

ggplot(data, mapping = aes(x = date, y = log(value), col = repo)) +
  geom_point(show.legend = FALSE) +
  geom_line(show.legend = FALSE) +
  geom_text_repel(aes(label = comma(value)), direction = 'y', vjust = 0.5, show.legend = FALSE) +
  scale_colour_manual(values = cols) +
  labs(title = title, x = '', y = '') +
  theme_minimal() +
  theme(panel.grid.major = element_line(colour = '#EEEEEE', linewidth = 0.25),
        plot.background = element_rect(fill = '#FFFDF8', colour = '#FFFDF8'),
        axis.title = element_text(colour = jojo2[5]),
        axis.text = element_text(colour = jojo2[5], size = 10),
        axis.title.y = element_blank(),
        plot.title = element_markdown(lineheight = 1.5, size = 12),
        plot.title.position = 'plot')

Plotting 23andMe marker density with karyoploteR

Marcin Kierczak — Tue, 30 Jan 2018 23:00:00 GMT

Updated in 2026

This is a lightly edited version of a 2018 post. The prose and figures are the originals. The code is updated for current Bioconductor, but it is shown, not re-run: the SNPedia files the post relied on are no longer downloadable, so the figures below are the ones produced in 2018.

Background

23andMe is a personal genomics company that offers saliva-based, direct-to-consumer genetic testing. It is probably one of the most popular ways for people to learn more about their own genetic makeup, including ancestry.

For genotyping, the company uses a SNP array (SNP-chip). In short, such a chip lets us “read” polymorphic sites in human DNA: sites known to vary between individuals. Different versions of these sites are associated with traits such as eye colour, blood group or the risk of developing a disease. A given version does not always cause the phenotype. Often a SNP is a good proxy: it tags the phenotype. This works because DNA is inherited in rather long chunks (haplotypes), so a variant tends to travel together with its neighbours, including the actual causative variant. Thanks to this, genotyping a limited number of SNPs can tell you a lot about many traits.

23andMe has used three versions of its chip, introduced in 2008, 2012 and 2014. I was curious how they differ, so I wanted to visualise the density of genotyped SNPs per fixed-length window along the genome.

The data

23andMe uses the Mendel family as its showcase. We look at the data for one family member, Lily Mendel (a real person: Linda Avey, a co-founder of the company). Data from all three chips were available at SNPedia (2008 v1, 2012 v3 and 2014 v4). The format is simple: one row per marker, with four columns:

rsid – unique rs identifier of the marker,
chr – chromosome,
pos – coordinate of the marker,
gtype – the genotype, e.g. GG.

Analysis

Preparations

# install once:
# if (!requireNamespace("BiocManager")) install.packages("BiocManager")
# BiocManager::install(c("karyoploteR", "biomaRt"))

library(karyoploteR)

Loading the data

We load the data, fix the column names and convert it into a GRanges object, which is what the density plot needs.

gdata <- read.table(file = "genome_Lilly_Mendel_v4.txt", comment.char = "#")
names(gdata) <- c("rsid", "chr", "pos", "gtype")

regions <- GRanges(seqnames = paste0("chr", gdata$chr),
                   ranges = IRanges(start = gdata$pos, width = 2))

Plotting marker density

A karyogram is an ideogram of ordered chromosomes: a map of the genome. We plot marker density over each chromosome with kpPlotDensity(). A nice feature of karyoploteR is that it also draws the G-bands, the pattern produced by Giemsa staining, which cytogeneticists use to visualise chromosome structure. The one important parameter here is the window size, which I set empirically to 1 Mbp.

kp <- plotKaryotype(cex = .7) |>
  kpAddBaseNumbers(cex = .5) |>
  kpPlotDensity(data = regions,
                window.size = 1e6,
                col = "slateblue",
                border = "slateblue")

Density of genotyped markers (1 Mbp windows) along the human karyotype.

So what?

I think the visualisation is neat, although the y-axis is missing (we fix that next). We can see low marker density around centromeres (the central, red-stained parts of the chromosomes) and a long stretch with no markers on the Y chromosome, probably its non-pseudoautosomal region. The density is also very low at the start of chromosomes 13, 14, 15, 21 and 22, and exceptionally high on the short arm of chromosome 6. I had no idea why, and not much time to research it…

Plotting the actual counts

What if we want the counts per window rather than the density? Easy enough:

counts <- kp$latest.plot$computed.values$density
data_counts <- GRanges(kp$latest.plot$computed.values$windows, y = counts)
max_count <- floor(max(counts) + .1 * max(counts))

# Plotting parameters established by trial and error
pp <- getDefaultPlotParams(plot.type = 1)
pp$leftmargin <- 0.15  # keep chromosome names clear of the plot
pp$topmargin <- 150    # avoid overlap between chromosomes
pp$bottommargin <- 150

kp <- plotKaryotype(cex = .7, plot.params = pp) |>
  kpAddBaseNumbers(cex = .5) |>
  kpLines(data = data_counts, ymin = 0, ymax = max_count) |>
  kpAxis(cex = .5, ymin = 0, ymax = max_count)

Marker counts per 1 Mbp window.

I did not manage to avoid all overlap between chromosomes and their data panels. It can probably be refined by playing with the graphical parameters, but you get the idea.

Zooming in

We spotted a region of high marker density on the short arm of chromosome 6. Let’s take a closer look.

pp <- getDefaultPlotParams(plot.type = 1)
pp$leftmargin <- 0.15
pp$topmargin <- 120
to_zoom <- GRanges("chr6", IRanges(start = 20e6, end = 60e6))

kp <- plotKaryotype(cex = .7, plot.params = pp, zoom = to_zoom) |>
  kpAddBaseNumbers(cex = .5) |>
  kpAxis(cex = .5, ymin = 0) |>
  kpBars(data = data_counts, y1 = data_counts$y, ymax = max_count)

Chromosome 6, 20-60 Mbp.

Almost perfect; only the y-axis has vanished in a mysterious way (my fault or a feature of the package, I never found out). The highest counts occur roughly between 30 and 35 Mbp. It would be interesting to see which genes sit there.

What a real study would need

Check the exact coordinates of the dense region rather than eyeballing 30-35 Mbp.
23andMe uses hg19 coordinates, while current Ensembl uses hg38. The code below asks Ensembl for GRCh37 (= hg19) so the two agree. Otherwise you would lift the coordinates over, for instance with liftOver. I did that back then, and the regions were close enough not to matter for this post.

To find the attributes and filters available in BioMart, see the BioMart web interface; once you have set them, click XML.

library(biomaRt)

ensembl <- useEnsembl(biomart = "genes",
                      dataset = "hsapiens_gene_ensembl",
                      GRCh = 37)

genes <- getBM(attributes = c("ensembl_gene_id", "external_gene_name", "description"),
               filters = c("chromosome_name", "start", "end"),
               values = list("6", 30000000, 35000000),
               mart = ensembl)

knitr::kable(genes)

Conclusion

Now we know what sits in the region. Any guesses why 23andMe put so many markers there?