Variables and functions

Tabular data

Table 1: Top longevity Europe 2007
country	LifeExpectancy
Iceland	81.757
Switzerland	81.701
Spain	80.941
Sweden	80.884
France	80.657

Before we delve into programming, let us sort out how we use tables to capture data and generate insights from them. This will help us to understand how things are done with R, because R was designed for statistical computation on tables. You can imagine that most things R does to an objects, it makes sure to keep that object ready to include into a table or convert to one.

Table is a central concept in data science. It has rows and columns. Columns \(\approx\) statistical variables (not to confuse with programming variables that we will meet soon).

🏋️

How many observations and how many variables can you see in the table in Table 1?[^1]
How would you characterize each variable in terms of discreteness-continuity and whether it is qualitative/categorical or quantitative?[^2]
Sketch for yourself a few tables with different sorts of variables, as you could meet them or need to create in real life.

Observations vs. aggregations (summaries)

Table 2: Life expectancy data in two countries
country	year	LifeExpectancy
Albania	2007	76.423
Albania	2002	75.651
Albania	1997	72.950
Denmark	2007	78.332
Denmark	2002	77.180
Denmark	1997	76.110

Table 3: Average life expectancy in Albania and Denmark 1997 - 2007
country	AverageLifeExpectancy
Albania	75.00800
Denmark	77.20733

Data structures

Data Structures in R

Now let us try and trace these concepts in R data structures. The table itself is implemented as data frame, or, in the tidyverse dialect, tibble (a tibble is an enhanced data frame, so let me just stick to data frame). Data frames have columns and these columns have names. Each value in a column corresponds to a row. Rows, on the other hand, are not explicitly described in R. All operations on tables are conceived from the perspective of columns. R believes that each column stores one statistical variable and it is ready to aggregate it to a summary statistics with a one-line command.

And now is the right moment to introduce the most basic R data structure, which is the vector. A vector is an ordered sequence of elements. An element is an individual value, such as a number. In terms of data science, it is the value of a statistical variable in one observation. If you imagine you record the air temperature at noon every day. When you have done this for a week, you have a vector of seven elements. Each element contains the temperature value. To store this as a meaningful information, you will probably keep another vector, in which each element is going to be the date of the measurement. After a week, you are going to have a seven-element vector. You can put them together into a data frame as two columns and give them some column names. Then the first element of the date vector is going to correspond to the first element of the temperature vector, and so on. Vector elements on the same position in the vector are the implicit rows in a data frame.

So when you add a row to a data frame, you actually add one element to each of its column vectors.

Vector and data frame are the most relevant data structures in this course. Let us leave the others (factor, list, and matrix) aside for a while.

Data types (aka classes)

R data types: characters, numbers, TRUE/FALSE (aka logical/Boolean)

Programmatic objects

object \(\approx\) anything you enter to the computer without an error message coming
```
3 + 2
```
```
[1] 5
```
The resulting object vanished as soon as it appeared on the screen.

Programmatic variables

variable \(\approx\) a labeled box in computer memory to store an object
```
my_calculation <- 3 + 2
```
Nothing appeared, but the object exists in the variable.
```
my_calculation
```
```
[1] 5
```

Variable assignment statement

variable_name <- object

variable names must not
- start with a digit
- contain any characters but ASCII letters, numbers, and _ (underscore)
- coincide with a few reserved words in R (e.g. for or in)
Each variable appears in the Environment tab

Variable overwriting

create a different variable for each step in your script
```
a <- 1
b <- a + 2
b
```
```
[1] 3
```
overwrite the variable
```
a <- 1
a <- a + 2
a
```
```
[1] 3
```

You must save each step in your script to a variable. When you write this:

a <- 3
a + 2

[1] 5

[1] 3

The result (5) has not be stored in a.

Functions and their arguments

Functions \(\approx\) verbs
“argument structure”/“valency”
- obligatory vs. free vs. unacceptable (no slot)
- collocability
  - argument does not fit
  - argument causes a meaning shift

Functions are very similar to content verbs in natural languages. Like verbs, they have a meaning on their own and individual argument structure; that is, they open slots for diverse clause elements.

Argument structure is a syntactic property. Virtually all verbs open a slot for subject. Transitive verbs open another slot for the direct object. These are then obligatory. When any of them remains unfilled, odds are that the whole clause becomes non-grammatical or at least confusing.

Collocability primarily concerns meaning. Many verbs require their arguments to belong to a specific semantic class; e.g. the direct object of read would be a textual medium. You can often use the verb metaphorically, such as read someone’s mood or read the weather. Some of these metaphors are so widely used that a dictionary may even capture them as separate senses), but some just would not work. For instance read a mushroom would require an explanation.

Each function in R that you load from CRAN has a user documentation. Sometimes it is extremely technical to read, but at least it exists.

Documentation in `Help`

Help - functions to replace strings

This help page in the R manual describes four similar functions in one bulk. Functions come in packages/libraries. These functions are part of the base library, which downloads with every installation of R. You see the library name in the curled braces above.

Normally, each function gets its own documentation page, but such a bulk documentation for a set of related functions is also quite common. All these functions take a character string and either modify its letter case or replace a substring (i.e. piece) with another substring.

Each documentation page has the following sections:

Description (one line)
Usage (all arguments listed, with their default values if applicable)
- When you use the function, you do not need to list the arguments that have default values, unless you want to override the default value with your own choice.
Arguments (each argument described)
Details (a more description)
Value (what output you get from the function)
Examples (thankfully, you can run a few examples and observe the function’s behavior in the Help pane.)

Libraries (aka packages)

additional functions and data sets
first install (Packages tab)
load when you need a function from there
- library(thelibrary) without quotes
when functions from different packages happen to have the same name
- R warns when it finds such a pair across your loaded libraries.
- Use these functions with package name like this: library::function()

Function with an argument

toupper(x = "hello")

[1] "HELLO"

This function is called toupper and requires one argument that it calls x . This argument is supposed to be a string. The function returns the same string, only with all letters converted to upper case if they were originally lower case.

Each function has a name and requires some arguments in parentheses. Their number, names and accepted data class are a decision of the programmer who wrote that function.

Functions in R have been written by many different authors over several decades. You must not expect that they are all written in the same way. Sometimes the value that you input is called x like here, but that is a fully arbitrary decision of the author of that function. Other functions can call it differently. To make sure to use a new function correctly, you must read its documentation in the Help tab.

Function with several arguments

chartr(old = "a", new = "A", x = "banana")

[1] "bAnAnA"

chartr(new = "A", x = "banana", old = "a")

[1] "bAnAnA"

chartr("a", "A", "banana")

[1] "bAnAnA"

Coercion to string

toupper(3)

[1] "3"

toupper(TRUE)

[1] "TRUE"

No coercion with error

chartr(old = "mo", new = "fa", x = "mother") # strings

[1] "father"

chartr(old = "5", new = "0",   x = "5toFour") # digits as strings

[1] "0toFour"

chartr(old = "5", new = 0, x = "5toFour" ) # new won't work

Error in chartr(old = "5", new = 0, x = "5toFour"): invalid 'new' argument

Write and run your own function

my_function <- function(my_1_arg, 
                        my_2_arg) {
  my_argument <- paste(my_1_arg,# existing R function
                       my_2_arg, 
                       sep = "--")
  toupper(my_argument)
}
# run it like so:
my_function(my_1_arg = "Hello",
            my_2_arg = "again")

[1] "HELLO--AGAIN"

Vector

c() function to concatenate / combine values to a vector

my_vector <- c(200, 0.3, 8)
my_vector

[1] 200.0   0.3   8.0

str(my_vector) # shows object's structure: numeric vector of 3 elements

 num [1:3] 200 0.3 8

Vectorized functions

nice_strings <- c("HOME", "EYE", "SET") # create vector 
result_vector <- tolower(nice_strings) # process with tolower
str(result_vector)

 chr [1:3] "home" "eye" "set"

chartr(new = "e", old = "E", x = result_vector)

[1] "home" "eye"  "set"

Non-vectorized case

chartr cannot do a vector of replacements:

chartr(old = c("a", "b"), new = c("A", "B"), x = "banana")

Warning in chartr(old = c("a", "b"), new = c("A", "B"), x = "banana"): argument
'old' has length > 1 and only the first element will be used

Warning in chartr(old = c("a", "b"), new = c("A", "B"), x = "banana"): argument
'new' has length > 1 and only the first element will be used

[1] "bAnAnA"

Step by step (no automation)

banana_1 <- chartr(old = "a", new = "A",  x = "banana")
banana_1

[1] "bAnAnA"

banana_2 <- chartr(old = "b", new = "B", x = banana_1)
banana_2

[1] "BAnAnA"

Vector

Class
- numeric, character, logical
Length (how many elements)
Elements can have names (named vector).
Order of elements matters.

Create a vector, combine them

(a <- c(23:27)) # colon generates incremental sequence

[1] 23 24 25 26 27

(b <- c(a, FALSE, TRUE))

[1] 23 24 25 26 27  0  1

Programming basics

Put each command on one line.

When you enclose an assignment statement in parentheses, the variable will print out.

What you see in the second chunk is called class coercion.

Vector class coercion logical to numeric

logical + numeric = numeric
boolean values translate to 0 and 1

boolean_vec <- c(TRUE, TRUE, FALSE) # logical 
numeric_vec <-  c(3, 2, 6) # numeric
c(boolean_vec, numeric_vec)

[1] 1 1 0 3 2 6

class(c(boolean_vec, numeric_vec))

[1] "numeric"

You have to watch out for the class being changed from any kind of numeric to character or from logical to numeric or character. Whenever you wonder why your numbers result in a character vector, you must check each element for non-numeric characters. The most common causes of a sequence of apparent numbers being resolved as characters are a space after the digit, or the decimal sign not corresponding to the locale of your system (by default, R is US-centric, so it uses decimal points, not commas). This is extremely important because wrong class on input to a function may either cause error, or worse, you get something different from what you expected. Most typically, if you call the function sort on numbers, they will get sorted in the linear order, but when this vector silently converts to characters, they will be sorted alphabetically. In the former case, you will get 1,2,3…11. In the latter case, you will get 1, 11, 2, 3....

Vector class coercion to character

anything + character = character
even digits can be characters

mix_vec <- c(boolean_vec, 
             numeric_vec, 
             "June 8", "3 ") 
class(mix_vec)

[1] "character"

Programming with vectors

select elements of a vector
- by their position
- by some condition

Vector subsetting by positions

vec <- c("John", "Mary", "Paul")
vec[1]

[1] "John"

vec[2:3]

[1] "Mary" "Paul"

vec[c(1,3)]

[1] "John" "Paul"

Vector subsetting with logical operators

vec <- c(1, 20, 3, 4)
vec[vec < 20]

[1] 1 3 4

vec[vec < 20 & vec > 1] # and

[1] 3 4

vec[vec > 15 | vec < 3 ] # or

[1]  1 20

Vector recycling

many functions proceed element by element
nothing gets recycled with equally long vectors

c(2,4,6,8)/c(2,2,2,2)

[1] 1 2 3 4

c(1000, 100, 10) / c(100, 10, 1)

[1] 10 10 10

Vector recycling

The second vector contains just one value and that must serve each element of the first vector
2 gets recycled

c(2,4,6,8) / 2

[1] 1 2 3 4

Vector recycling

the second vector gets recycled once
each of its element must serve twice
R believes you want it this way

c(2,4,6,8) / c(2,1)

[1] 1 4 3 8

Vector recycling

Did you really want this? Warning.

c(10, 10, 10) * c(1,2)

Warning in c(10, 10, 10) * c(1, 2): longer object length is not a multiple of
shorter object length

[1] 10 20 10

Endnotes

1: Variables = columns (two), observations = rows

2: Qualitative/categorical variables are always discrete: When the values are names of countries like in the example, you cannot have a value that would lie, e.g., between Denmark and Sri Lanka. Life expectancy is a quantitative value and it is continuous. When you see neighboring values, it is very well possible that another country’s life expectancy would still lie between. When you disregard rounding, you could see extremely tiny differences, for instance five seconds or so… On the other hand, year is usually interpreted as a discrete variable, although time is unarguably a continuous concept.

Variables and functions

Tabular data

Observations vs. aggregations (summaries)

Data structures

Data types (aka classes)

Programmatic objects

Programmatic variables

Variable assignment statement

Variable overwriting

Functions and their arguments

Documentation in Help

Libraries (aka packages)

Function with an argument

Function with several arguments

Coercion to string

No coercion with error

Write and run your own function

Vector

Vectorized functions

Non-vectorized case

Step by step (no automation)

Vector

Create a vector, combine them

Programming basics

Vector class coercion logical to numeric

Vector class coercion to character

Programming with vectors

Vector subsetting by positions

Vector subsetting with logical operators

Vector recycling

Vector recycling

Vector recycling

Vector recycling

Endnotes

Documentation in `Help`