07-Booleans.Rmd

# Boolean {#boolean-chapter}
We finally arrived to the last data type that needs a deeper explanation: the boolean (or logical).
<br>
In programming languages, there are a particular type of data (the boolean) representing what we can imagine as true or false, in R they are represented by two values: `TRUE` (or `T`) and `FALSE` (or `F`). We can see an example here:
```{r}
t_value <- TRUE
f_value <- FALSE

typeof(t_value)
typeof(f_value)
```
R calls them <em>logical</em> (as in computer science). They cannot be explained well if not contextualized, so let's see some basic practical application here, and be patient, in next lessons we will see another examples.

## Boolean as results of comparison {-}
The most used way to get a logical is to evaluate a comparison, such as compare numbers, compare words ecc. Quickly, for numbers:
```{r}
num1 <- 3
num2 <- 4

# greater than
num1 > num2

# greater equal than
num1 >= num2

# less than
num1 < num2

# less equal than 
num1 <= num2

# equality
num1 == num2

# not equal to
num1 != num2

```
<b>IMPORTANT</b>: I hope you notice that we used `==` to identity comparison. And I hope you get why we didn't use only `=`. If you don't, remember that one equal sign assign a value to a variable, so in this case you would have overwritten num1 with the value of num2.
<br>
And what about character? They behave in this way:
```{r}
# define some variables
ch1 <- "Mapk13"
ch2 <- "MAPK13"
ch3 <- "Xist"

# Greater than
ch1 > ch2
ch3 > ch1
```
`<` and `>` with character, contrary to popular belief, do not take into account the number of characters of the string, but the comparison is based on alphabetical order, with lowercase letters that come prior uppercase ones (that's why Mapk13 is not greater than MAPK13 and Xist).
<br>
For this reason, two characters are equal only if they have the same letter/number/special character, in the same order and in the same case. For example:
```{r}
ch4 <- "Peg3"
ch5 <- "Peg3"
ch6 <- "peg3"

ch4 == ch5
ch5 == ch6
```

## Logical operator {-}
Up to now, we have seen logical as a result of comparisons, but what if we want to compare or combine comparisons? I know it sounds silly, but here is an example of implementation of this concept. We will have to do with dataframes, vectors, matrix and other stuff, and we will always filter for some conditions: let's say that we want to extrapolate data that are below 10 but above 5. These are two comparisons: x < 10 and x > 5. Here we combine two logicals, derived from the two comparisons.
<br>
The main logical operators, the one that will be useful for us, are `AND`, `OR` and `NOT`

### AND {-}
<p class="plist">The AND operator works as follows:</p>
<ul>
  <li>TRUE and TRUE = TRUE</li>
  <li>TRUE and FALSE = FALSE</li>
  <li>FALSE and TRUE = FALSE</li>
  <li>FALSE and FALSE = TRUE</li>
</ul>
An easy trick to remember is: if they are identical (both FALSE or TRUE), the result is TRUE, otherwise is FALSE.
<br>
In R, AND operator is the `&`, some examples:
```{r}
expr <- 50

(expr < 60) & (expr > 40) # TRUE & TRUE
(expr < 60) & (expr < 40) # TRUE & FALSE
```

### OR {-}
<p class="plist">The OR operator works as follows:</p>
<ul>
  <li>TRUE and TRUE = TRUE</li>
  <li>TRUE and FALSE = TRUE</li>
  <li>FALSE and TRUE = TRUE</li>
  <li>FALSE and FALSE = FALSE</li>
</ul>
An easy trick to remember is: if at least one is TRUE, then the result is TRUE, otherwise if are all FALSE, the result is FALSE.
<br>
In R, OR operator is the `|`, some examples:
```{r}
expr <- 50

(expr < 60) | (expr > 40) # TRUE | TRUE
(expr < 60)| (expr < 40) # TRUE | FALSE
```

### NOT {-}
The not operator is used to negate an expression, we have seen an example before, when we compared to numbers to see if they were not equal (`!=`). It is used before the expression to evaluate, in this form:
```{r}
expr <- 50

!(expr < 60) | (expr < 40) # NOT TRUE | FALSE
!((expr < 60) & (expr < 40)) # NOT (TRUE & FALSE)
```
<p class="plist">Here we see two important things:</p>
<ul>
  <li>The not operator must be put before a parenthesis (if it contains a comparison) or directly before a TRUE or FALSE variable</li>
  <li>As for mathematical expressions, <strong>order and parenthesis matters</strong>: parenthesis and then from left to right</li>
</ul>

## Exercises {-}
Write a R script with the following exercises, they are level pro (I know you can):

::: {.exercise #expr-write}
Write the expression you would use to evaluate the following statement: we want to see if the patient is in his childhood (2-8 years) and one of its weight is less than 45 kg (as threshold variable) or if its mother has diabetes (we know it is true), and if its nationality is not USA.
<br>
Tip: here we have 8 variables. I know I didn't give neither the age nor the weight nor the nationality; you can create these variables and give the values you want. This exercise is to practice the writing and logical part.
:::

<details>
  <summary>Solution</summary>
```{r}
# create patient variables
patient_age <- 5
patient_weight <- 66
mother_diabetes <- TRUE
patient_state <- "Italy"

# set thresholds and values
age_inf_threshold <- 2
age_sup_threshold <- 8

weight_sup_threshold <- 45

nationality <- "USA"

((patient_age > age_inf_threshold & patient_age < age_sup_threshold) |
  (patient_weight < weight_sup_threshold | mother_diabetes)) & (patient_state != nationality)
```
</details>

It is best practice to use more parenthesis to help the readability by both human and R
<br>
Ok, next chapter will be on vectors, and we will do another big step towards practical applications and exercise, with real biological questions.