### About

Date: 2017-12-26### Contents

# Long and Wide Format¶

There are multiple ways of structuring data. Two sensible formats are the *long* and the *wide* data format. In this article I want to do the same problem in two different ways and show the relative merits.

## Task¶

As a task, we want to compute using Monte Carlo techniques. We want to see the scaling of the precision and accuracy with the number of iterations. For the precision we need to compute an error estimate. This will be done with the bootstrap procedure, though here we can actually sample from the underlying distribution.

For each number of samples we want to draw numbers from a uniform distribution in the interval . Then we use these as and values and compute . We count how many points have as the accepted points . The ratio will approximate , because that is the area of a quarter circle with .

In order to estimate the error, we do above prescription times and then take the standard deviation of the results to get an error estimate. We want to produce a plot which contains the absolute deviation () with error bars versus the number of samples .

We want to be the following values:

```
num_samples <- c(500, 1000, 2000, 4000)
```

shall be a fixed number always.

```
num_bootstrap <- 150
```

## Wide format¶

We first need to generate the data for each .

```
start_wide <- proc.time()
make_numbers <- function(n) {
numbers <- runif(2 * n * num_bootstrap)
array(numbers, dim = c(2, n, num_bootstrap))
}
samples <- sapply(num_samples, make_numbers)
```

`samples`

is now a list which contains arrays. Their first dimension is the bootstrap dimension, the second dimension is the actual sample, the last dimension is the - dimension and contains two elements. We now want to square all the numbers. Then we sum along axis 3 to get . After that we only have two dimensions left.

From then on, we count how many of the numbers are below 1 in each row to get the bootstrap estimates for our data.

```
values <- numeric(length(samples))
errors <- numeric(length(samples))
for (i in 1:length(samples)) {
s <- samples[[i]]
squared <- apply(s, 1:3, function(x) x^2)
summed <- apply(squared, 2:3, sum)
less_eq_one <- apply(summed, 1:2, function(x) x < 1)
ratio <- apply(less_eq_one, 2, function(x) sum(x) / length(x))
values[[i]] <- mean(ratio)
errors[[i]] <- sd(ratio)
}
```

From here on out we can just subtract the actual value and take the absolute value. The time measurement stops here.

```
accuracy <- abs(values - pi/4.0)
end_wide <- proc.time()
```

Now we can go ahead and plot this.

```
plot(x = num_samples, y = accuracy)
```

With the `hadron`

library we can also plot this with error bars:

```
library(hadron)
```

```
## Loading required package: boot
```

```
plotwitherror(x = num_samples, y = accuracy, dy = errors)
```

The result itself is rather unspectular, but that was not really the point to start with.

## Long format¶

Next we try with the long format. For this, there are a bunch of packages which are really helpful.

```
library(knitr)
library(ggplot2)
library(magrittr)
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
```

We start with generating the samples. First we need build a data frame which has one row per - combination that we want to do measurements with. The number of samples varies, so we cannot use `expand.grid`

right away but must build the data frame from multiple `expand.grid`

calls and then glue them together with `rbind`

.

```
start_long <- proc.time()
f <- function(n) {
expand.grid(N = n, r = rep(1:num_bootstrap, each = n))
}
long <- do.call(rbind, mapply(f, num_samples, SIMPLIFY = FALSE))
```

Sampling for and is easy now, we just need to add two more columns with the right number of random numbers to the data frame.

```
long$x <- runif(nrow(long))
long$y <- runif(nrow(long))
```

This is what the data structure looks like:

```
kable(head(long))
```

N | r | x | y |
---|---|---|---|

500 | 1 | 0.3472060 | 0.8126291 |

500 | 1 | 0.4836393 | 0.0258222 |

500 | 1 | 0.4090112 | 0.4127594 |

500 | 1 | 0.9862454 | 0.1251802 |

500 | 1 | 0.3422988 | 0.4724890 |

500 | 1 | 0.0246883 | 0.7189740 |

In order to incorporate the radius criterion we can use the `%<>%`

operator from `magrittr`

.

```
long %<>% mutate(accept = x^2 + y^2 < 1)
```

Alternatively one could have written this as

```
long <- mutate(long, accept = x^2 + y^2 < 1)
```

The current state of the data frame:

```
kable(head(long))
```

N | r | x | y | accept |
---|---|---|---|---|

500 | 1 | 0.3472060 | 0.8126291 | TRUE |

500 | 1 | 0.4836393 | 0.0258222 | TRUE |

500 | 1 | 0.4090112 | 0.4127594 | TRUE |

500 | 1 | 0.9862454 | 0.1251802 | TRUE |

500 | 1 | 0.3422988 | 0.4724890 | TRUE |

500 | 1 | 0.0246883 | 0.7189740 | TRUE |

We now want to compute the ratio for each value of and bootstrap sample and then average over the bootstrap samples. With `dplyr`

we first do a `group_by`

, that is like holding the margins in the `apply`

function. Then we do summarize (which is a reduction of some sort) to compute . From there on we group by again (to remove the bootstrap samples) and compute mean and standard deviation.

As a last step we add the `accuracy`

column.

```
long_res <- long %>%
group_by(N, r) %>%
summarize(accepted = sum(accept) / n()) %>%
group_by(N) %>%
summarize(value = mean(accepted), error = sd(accepted))
long_res %<>% mutate(accuracy = abs(value - pi/4.0))
end_long <- proc.time()
```

This is the resulting data frame:

```
kable(long_res)
```

N | value | error | accuracy |
---|---|---|---|

500 | 0.785920 | 0.0201350 | 0.0005218 |

1000 | 0.784820 | 0.0141536 | 0.0005782 |

2000 | 0.786420 | 0.0093601 | 0.0010218 |

4000 | 0.786255 | 0.0063300 | 0.0008568 |

This can nicely be plotted with `ggplot2`

:

```
ggplot(long_res, aes(x = N, y = accuracy)) +
geom_point() +
#scale_x_log10() +
#scale_y_log10() +
geom_errorbar(aes(ymin = accuracy - error, ymax = accuracy + error)) +
labs(title = 'Monte Carlo Error Scaling',
x = 'Samples N',
y = 'Absolute deviation') +
theme_light()
```

## Summary¶

I find the long format much easier to work with. In case we wanted to add another variable, we can just do that. With the wide format, we would have to add another dimension to the matrix. Also with the wide format we lost track of the meta data along the way. The list of arrays did now know which particular value of each eleemnt corresponded, we needed to look that up via the index in `num_samples`

. The long format does not have this problem, all the data is right there.

Contrary to my intuition the wide format version is *much slower* than the long format version:

```
end_wide - start_wide
```

```
## user system elapsed
## 12.255 0.081 12.488
```

```
end_long - start_long
```

```
## user system elapsed
## 1.628 0.016 1.661
```

I have also tried to exchange the order of the dimensions of the array in case the row-major or column-major layout was chosen incorrectly. However that does not seem to have a significant effect.

The memory layout of the wide format should be just perfect for the work that I am doing here, but somehow this is faster, even though we have to call `group_by`

twice. It would be interesting to find out why the performance is so much better.

There is a price to pay in memory, though. The long format takes up a bunch of memory:

```
library(pryr)
```

```
##
## Attaching package: 'pryr'
```

```
## The following object is masked _by_ '.GlobalEnv':
##
## f
```

```
object_size(long)
```

```
## 36 MB
```

The wide format only contains the data, so that should be smaller. However, we get similar sizes for this particular example.

```
object_size(samples)
```

```
## 18 MB
```

```
object_size(summed)
```

```
## 4.8 MB
```

```
object_size(squared)
```

```
## 9.6 MB
```

```
object_size(less_eq_one)
```

```
## 2.4 MB
```

```
object_size(ratio)
```

```
## 1.24 kB
```

The last variables only contain the data for the largest since they are used in the `for`

loop. The sum of the other ones is a little less than this. Taking everything together we end up in a similar range.

## Conclusion¶

Although I initially thought of it as inefficient and a waste of memory, I am now quite happy with the long data format for most tasks. It makes working with the data and associated meta data much easier and it seems to be quite efficient in R.