4 Variables, booleans and strings

In R, the variable attribution is done through the arrow operator <- instead of the = one – for historical reasons. The equal sign, =, would still work though, but you should just take up the habit of using <-.

In reality, scalar numbers don’t exist in R, they are simply 1 element vector: this is why #> [1] is printed in the following outputs.

To understand what you will encounter further down this class, inputs (what you type in the R script and hit Ctrl+⏎ (⌘+⏎)) are the shaded areas with syntax coloring, while outputs (what R returns) are the area underneath starting with #> [1]. In case the output spans several lines, each line would start with #> [x] where x is the index of the first element printed on the line.

Note

Note that different instructions are usually given on separated lines (i.e. one instruction per line), but several instructions can be written on a single line if separated with a ; sign.

In R code, what is written after the # sign is a comment and is thus not interpreted.

4.1 Scalars and booleans

Defining a scalar value is done with:

x <- 1 # attribute the value '1' to the variable 'x'
x      # print the value of 'x'

#> [1] 1

You can use the R console as an advanced calculator:

1 + 3

#> [1] 4

x <- 1/2
y <- exp(log(sin(cos(x*pi))))
x - y

#> [1] 0.5

Attention

Typing x + 1 will only print the result of x + 1, but not add 1 to x and save this as the new value of x.

To actually modify the value stored in x, type x <- x + 1.

4.1.1 Special values

R handles infinity, NaN (Not a Number), and has $\pi$ defined. Missing numbers are handled through the NA keyword (Not Attributed).

pi

#> [1] 3.141593

10/0

#> [1] Inf

0/0

#> [1] NaN

NA

#> [1] NA

4.1.2 Booleans and common tests on values

Booleans are handled with the TRUE and FALSE keywords, and are usually obtained as the result of a test on values.

Once you’ve understood these tests, you can use them in conditional actions of the type if(test){then}else{then}, or to apply some filter on your data.

Let’s create two variables x and y and test some assertions on these two variables (i.e. answer the following questions):

x <- 1
y <- 2

Is x equal to y?

x == y

#> [1] FALSE

Is x not equal to y?

x != y

#> [1] TRUE

Is x smaller than y?

x < y

#> [1] TRUE

Is x smaller or equal than y?

x <= y

#> [1] TRUE

Operator “and”: &

x == y & x < y

#> [1] FALSE

Operator “or”: |

x == y | x < y

#> [1] TRUE

Is x a NaN?

is.nan(x)

#> [1] FALSE

Is x a number?

is.numeric(x)

#> [1] TRUE

Is x a string?

is.character(x)

#> [1] FALSE

Is x a NA?

is.na(x)

#> [1] FALSE

Operator “not” (inverse)

!is.na(x)

#> [1] TRUE

A number can by converted to a boolean using as.logical(): any number non 0 is equivalent to TRUE, and 0 is FALSE.

as.logical(1)

#> [1] TRUE

as.logical(0)

#> [1] FALSE

4.2 Complex values

Click to expand

R also natively handles complex values:

1+i   # not a valid complex value

#> Error: object 'i' not found

1+1i  # valid complex value

#> [1] 1+1i

exp(1i*pi)

#> [1] -1+1.224647e-16i

sqrt(-1)

#> [1] NaN

sqrt(-1 + 0i)

#> [1] 0+1i

Im(exp(1i*pi))

#> [1] 1.224647e-16

Re(exp(1i*pi))

#> [1] -1

Mod(exp(1i*pi))

#> [1] 1

4.3 Strings

A string is defined between quotation marks such as: "string". Thus "1" is not the number 1, but rather the character “1”. Here are some operations on strings :

Definition of a string:

phrase <- "Hello World "

Concatenation of strings using paste():

paste("phrase", phrase, sep=" = ")

#> [1] "phrase = Hello World "

Concatenation of strings using glue::glue():

library(glue)
glue("phrase = {phrase}")

#> phrase = Hello World

Acessing a sub-string:

substr(phrase, 1, 4)

#> [1] "Hell"

Change case of string with tolower() and toupper():

tolower(phrase); toupper(phrase)

#> [1] "hello world "

#> [1] "HELLO WORLD "

Change the first occurrence of “o” in “a” with sub():

sub("o", "a", phrase)

#> [1] "Hella World "

Change all occurrences of “o” in “a” with gsub():

gsub("o", "a", phrase)

#> [1] "Hella Warld "

Trim white spaces with trimws():

trimws(phrase)

#> [1] "Hello World"

Get a vector from string separation based on a character with strsplit():

strsplit(phrase, " ")         # returns a list

#> [[1]]
#> [1] "Hello" "World"

unlist(strsplit(phrase, " ")) # returns a vector

#> [1] "Hello" "World"

Attention!!

phrase2 <- "1234"
phrase2 - 4321             # won't work: string - double

#> Error in phrase2 - 4321: non-numeric argument to binary operator

as.numeric(phrase2) - 4321 # conversion of string to double

#> [1] -3087

For more complex operations, see the stringr package and its cheatsheet.

4.4 Exercises

Download the exercises and solutions from the following repository, then create a Rstudio project from the unzipped folder:

Beginner exercises

# Variables, booleans and strings In R, the variable attribution is done through the arrow operator `<-`{.R} instead of the `=`{.R} one – for historical reasons. The equal sign, `=`{.R}, would still work though, but you should just take up the habit of using `<-`{.R}. In reality, scalar numbers don't exist in R, they are simply 1 element vector: this is why `#> [1]` is printed in the following outputs. To understand what you will encounter further down this class, inputs (what you type in the R script and hit Ctrl+⏎ (⌘+⏎)) are the shaded areas with syntax coloring, while outputs (what R returns) are the area underneath starting with `#> [1]`. In case the output spans several lines, each line would start with `#> [x]` where `x` is the index of the first element printed on the line. :::{.callout-note} Note that different instructions are usually given on separated lines (*i.e.* one instruction per line), but several instructions can be written on a single line if separated with a `;` sign. In R code, what is written after the `#` sign is a comment and is thus not interpreted. ::: ## Scalars and booleans Defining a scalar value is done with: ```{r, warnings=FALSE} x <- 1 # attribute the value '1' to the variable 'x' x # print the value of 'x' ``` You can use the R console as an advanced calculator: ```{r, warnings=FALSE} 1 + 3 x <- 1/2 y <- exp(log(sin(cos(x*pi)))) x - y ``` :::{.callout-warning} ## Attention Typing `x + 1`{.R} will **only print** the result of `x + 1`{.R}, but not add 1 to `x` and save this as the new value of `x`. **To actually modify** the value stored in `x`, type `x <- x + 1`{.R}. ::: ### Special values R handles infinity, NaN (Not a Number), and has $\pi$ defined. Missing numbers are handled through the `NA`{.R} keyword (Not Attributed). ```{r, warnings=FALSE} pi 10/0 0/0 NA ``` ### Booleans and common tests on values Booleans are handled with the `TRUE`{.R} and `FALSE`{.R} keywords, and are usually obtained as the result of a test on values. Once you've understood these tests, you can use them in [conditional actions](11-conditions_loops.qmd) of the type `if(test){then}else{then}`{.R}, or to apply some filter on your data. Let's create two variables `x` and `y` and test some assertions on these two variables (*i.e.* answer the following questions): ```{r} x <- 1 y <- 2 ``` - Is `x` equal to `y`? ```{r} x == y ``` - Is `x` not equal to `y`? ```{r} x != y ``` - Is `x` smaller than `y`? ```{r} x < y ``` - Is `x` smaller or equal than `y`? ```{r} x <= y ``` - Operator "and": `&`{.R} ```{r} x == y & x < y ``` - Operator "or": `|`{.R} ```{r} x == y | x < y ``` - Is `x` a NaN? ```{r} is.nan(x) ``` - Is `x` a number? ```{r} is.numeric(x) ``` - Is `x` a string? ```{r} is.character(x) ``` - Is `x` a NA? ```{r} is.na(x) ``` - Operator "not" (inverse) ```{r} !is.na(x) ``` A number can by converted to a boolean using `as.logical()`{.R}: any number non 0 is equivalent to `TRUE`, and 0 is `FALSE`. ```{r, warnings=FALSE} as.logical(1) as.logical(0) ``` ## Complex values :::{.callout-note collapse="true"} ## Click to expand R also natively handles complex values: ```{r, warnings=FALSE, error=TRUE} 1+i # not a valid complex value 1+1i # valid complex value exp(1i*pi) sqrt(-1) sqrt(-1 + 0i) Im(exp(1i*pi)) Re(exp(1i*pi)) Mod(exp(1i*pi)) ``` ::: ## Strings A string is defined between quotation marks such as: `"string"`{.R}. Thus `"1"`{.R} is not the number *1*, but rather the character "1". Here are some operations on strings : - Definition of a string: ```{r} phrase <- "Hello World " ``` - Concatenation of strings using `paste()`{.R}: ```{r} paste("phrase", phrase, sep=" = ") ``` - Concatenation of strings using `glue::glue()`{.R}: ```{r} library(glue) glue("phrase = {phrase}") ``` - Acessing a sub-string: ```{r} substr(phrase, 1, 4) ``` - Change case of string with `tolower()`{.R} and `toupper()`{.R}: ```{r} tolower(phrase); toupper(phrase) ``` - Change the first occurrence of "o" in "a" with `sub()`{.R}: ```{r} sub("o", "a", phrase) ``` - Change all occurrences of "o" in "a" with `gsub()`{.R}: ```{r} gsub("o", "a", phrase) ``` - Trim white spaces with `trimws()`{.R}: ```{r} trimws(phrase) ``` - Get a vector from string separation based on a character with `strsplit()`{.R}: ```{r} strsplit(phrase, " ") # returns a list unlist(strsplit(phrase, " ")) # returns a vector ``` :::{.callout-warning} ## Attention!! ```{r, warnings=FALSE, error=TRUE} phrase2 <- "1234" phrase2 - 4321 # won't work: string - double as.numeric(phrase2) - 4321 # conversion of string to double ``` ::: For more complex operations, see the `stringr` package and its [cheatsheet](https://github.com/rstudio/cheatsheets/blob/main/strings.pdf). ## Exercises {#exo-variables} Download the exercises and solutions from the following repository, then create a Rstudio project from the unzipped folder: - [Beginner exercises](https://github.com/colinbousige/R1-beginner)