This course has three main ideas:

- computational thinking,
- simulation of deterministic systems,
- simulation of random systems.

Therefore the makeup will have three questions.

# Computational Thinking

This is essentially *programming*. There are three elements to combine:

- functions (identify input and output)
`for`

loops`if`

conditionals

These are the “Lego” pieces that you have to combine. What we want to measure is how well can you solve a complex problem using these basic parts. For that you will use *decomposition*, *pattern recognition*, *abstraction* and *algorithm design*.

Examples of this kind of problems are questions 1 and 2 on the midterm exam. In most cases I give you a description of the program in English. You have to translate the English description into R.

Pay special attention to keywords like *function*, *vector*, *list* or *data frame*. Sometimes you have to make a function, sometimes a vector, sometimes a list. This is always indicated in the text.

# Simulation of Deterministic Systems

These are the systems that we model with boxes and circles. There are several classes and exercises on this, including the zombies question in midterm, the water formation system, and the qPCR simulation.

We teach this because many real scientific questions can be answered with this philosophy. Even if you do not use R in the future, this kind of models are always true. Moreover, they are a nice way to explain your ideas to other people.

The procedure to answer these question is always the same. I will give you a diagram, you have to build the formulas, using the procedure I described previously on the blog. Then you have to answer three parts, like these questions:

- Find the formulas and simulate the system starting with given initial conditions and rates
- Find how the result changes when the initial conditions (or rates) change in a range. For example in the qPCR case.
- Find how the result changes when the initial conditions (or rates) change randomly. We want to see the variability of final conditions when the initial conditions change randomly. In other words, we want to test the sensitivity to initial conditions.

# Simulating Random Systems

The last part of the course focused on the idea that you can decompose a complex random system into a series of simpler systems, easier to simulate, and then you combine them. Then you can simulate the combination-of-simple system and see what will be the result of the complex system. When you simulate several times (that is, when you *replicate*), you can make a barplot of the frequencies of each outcome. In the exam we replicate ten thousands times, but in real life we use bigger numbers.

Examples of this questions are: number of people with epilepsy in a group (depending on group size and probability), total travel time (depending on how many transports are used, and the probabilities of each delay. Total travel time is the sum of all waiting and transport times), same-birthday probabilities, and the GC content of a random piece of DNA.

The typical questions here are: simulate many times and find mean and average, write a function to find *events* in the simulation (that is, determine if there is a pattern in the simulation result, and return `TRUE`

or `FALSE`

), find a confidence interval containing (1-𝛼) of the total cases (for example 95% and 99%).

The confidence intervals can be written as two numbers: `mean(data) - k*sd(data)`

and `mean(data) + k*sd(data)`

. That is, the same formula, just changing the sign of `k`

. The value of `k`

depends on the chosen 𝛼.

There are several ways to determine the `k`

, depending on how much you know about the probability distribution, and if the population standard deviation is known or not.

- If you know that the distribution is Normal, and you know the standard deviation of the population, then
`k <- qnorm(1-alpha/2)`

. This is the most common case, but it is not always true. - If you know that the distribution is Normal, but you do not know the standard deviation of the population, then
`k <- qt(1-alpha/2, df)`

, where the*degrees of freedom*parameter`df`

is usually`length(data)-1`

. - If you do not know anything, you have to use Tchbyshev formula. 𝛼