Instructions

library(ggplot2)
library(reshape2)
#' @name assign_vector
#' @param data A vector of data to perform the t-test on.
#' @param n An integer indicating the number of t-tests to perform. Default is 1000
#' @return A data frame in "tall" format
assign_vector <- function(data, n = 1000) {
  # replicate the call to shapiro.test n times to build up a vector of p-values
  p.5 <- replicate(n=n, expr=shapiro.test(sample(my.data, 5, replace=TRUE))$p.value)
  p.10 <- replicate(n=n, expr=shapiro.test(sample(my.data, 10, replace=TRUE))$p.value)
  p.1000 <- replicate(n=n, expr=shapiro.test(sample(my.data, 1000, replace=TRUE))$p.value)
  #' Combine the data into a data frame, 
  #' one column for each number of samples tested.
  p.df <- cbind(p.5, p.10, p.1000)
  p.df <- as.data.frame(p.df)
  colnames(p.df) <- c("5 samples","10 samples","1000 samples")
  #' Put the data in "tall" format, one column for number of samples
  #' and one column for the p-value.
  p.df.m <- melt(p.df)
  #' Make sure the levels are sorted correctly.
  p.df.m <- transform(p.df.m, variable = factor(variable, levels = c("5 samples","10 samples","1000 samples")))
  return(p.df.m)  
}
n.rand <- 100000
n.test <- 10000
my.data <- rnorm(n.rand)
p.df.m <- assign_vector(my.data, n = n.test)
ggplot(p.df.m, aes(x = value)) + 
  geom_histogram(binwidth = 1/10) + 
  facet_grid(facets=variable ~ ., scales="free_y") + 
  xlim(0,1) +
  ylab("Count of p-values") +
  xlab("p-values") +
  theme(text = element_text(size = 16))
ggplot(NULL, aes(x=x, colour = distribution)) + 
  stat_function(fun=dnorm, data = data.frame(x = c(-6,6), distribution = factor(1))) + 
  stat_function(fun=dt, args = list( df = 20), data = data.frame(x = c(-6,6), distribution = factor(2)), linetype = "dashed") + 
  scale_colour_manual(values = c("blue","red"), labels = c("Normal","T-Distribution"))
my.data <- rt(n.rand, df = 20)
p.df.m <- assign_vector(my.data, n = n.test)
ggplot(p.df.m, aes(x = value)) + 
  geom_histogram(binwidth = 1/10) + 
  facet_grid(facets=variable ~ ., scales="free_y") + 
  xlim(0,1) +
  ylab("Count of p-values") +
  xlab("p-values") +
  theme(text = element_text(size = 16))
my.data <- rt(n.rand, df = 20)
my.data.2 <- rnorm(n.rand)
# Trim off the tails
my.data <- my.data[which(my.data < 3 & my.data > -3)]
# Add in tails from the other distribution
my.data <- c(my.data, my.data.2[which(my.data.2 < -3 | my.data.2 > 3)])
p.df.m <- assign_vector(my.data, n = n.test)
ggplot(p.df.m, aes(x = value)) + 
  geom_histogram(binwidth = 1/10) + 
  facet_grid(facets=variable ~ ., scales="free_y") + 
  xlim(0,1) +
  ylab("Count of p-values") +
  xlab("p-values") +
  theme(text = element_text(size = 16))

my.data <- rnorm(n.rand)
my.data.2 <- rt(n.rand, df = 20)
# Trim off the tails
my.data <- my.data[which(my.data < 3 & my.data > -3)]
# Add in tails from the other distribution
my.data <- c(my.data, my.data.2[which(my.data.2 < -3 | my.data.2 > 3)])
p.df.m <- assign_vector(my.data, n = n.test)
ggplot(p.df.m, aes(x = value)) + 
  geom_histogram(binwidth = 1/10) + 
  facet_grid(facets=variable ~ ., scales="free_y") + 
  xlim(0,1) +
  ylab("Count of p-values") +
  xlab("p-values") +
  theme(text = element_text(size = 16))
my.data <- rlnorm(n.rand, 0, 0.4)
p.df.m <- assign_vector(my.data, n = n.test)
ggplot(p.df.m, aes(x = value)) + 
  geom_histogram(binwidth = 1/10) + 
  facet_grid(facets=variable ~ ., scales="free_y") + 
  xlim(-0.05,1.05) +
  ylab("Count of p-values") +
  xlab("p-values") +
  theme(text = element_text(size = 16))
hist(my.data)

small sample sizes will have a normal distribution. The normality tests are, indeed, very sensitive to what goes on in the extreme tails.

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