R Programming/ Statistical ComputingWeek 2: R Basics

Logical variables and comparisons

VideoLogical variables and comparison operatorsDuration6:48

Logical variables

A logical variable can only hold the two values TRUE and FALSE. Logical variables are sometime called Boolean variables, after George Boole (1815-1864), an English mathematician, logician and philosopher. R has the following three binary operators ! (negation), & (logical AND) and | (logical OR). The table below shows some examples of logical statement combinations and outputs.

a <- TRUE
b <- FALSE
c <- a & !b
c

[1] TRUE

In R, & has higher precedence than |. So, in the absence of parentheses, & is evaluated before |. For example, TRUE | FALSE & FALSE is treated by R as TRUE | (FALSE & FALSE), which is TRUE. We have to use parentheses to calculate (TRUE | FALSE) & FALSE, which is FALSE.

a <- TRUE
b <- FALSE
c <- TRUE

!a & b
a | !b
!(a | !b)
(a & b) | c

!a & b

[1] FALSE

a | !b

[1] TRUE

!(a | !b)

[1] FALSE

(a & b) | c

[1] TRUE

T <- FALSE
F <- TRUE

Comparison operators

The comparison operators in R are == (testing for exact equality), != ("not exactly equal") <, <=, >, and >=.

The comparison operators return a logical value (i.e. TRUE or FALSE), so you can use the operators !, & and | to combine them to more complex expressions.

x <- 2

x < 0

[1] FALSE

x <= 3

[1] TRUE

x>0 & x<1

[1] FALSE

!(x<=0 | x>=1)

[1] FALSE

Due to rounding and representation errors, you do not want to use == to compare non-integers. For example, despite , R yields

0.3 - 2 * 0.1 == 0.1

[1] FALSE

because the expression on the left-hand side is not exactly 0.1. We see this by subtracting 0.1 from the left-hand side (which should then be exactly zero, but isn't)

0.3-2*0.1 - 0.1

[1] -2.775558e-17

For non-integers we really only want to test whether they are "nearly equal", we can do so by comparing the absolute difference to a small number (say ).

abs(0.3-2*0.1 - 0.1) < 1e-8

[1] TRUE

or use the built-in function all.equal.

isTRUE(all.equal(0.3-2*0.1, 0.1))

[1] TRUE

x <- 355 / 113
x < pi

[1] FALSE

x>3 & x<4

[1] TRUE

abs(x-pi) < 1e-6

[1] TRUE

Vectors in R

VideoVectorsDuration6:20

So far we have only looked at scalar variables, i.e. variables containing only one value. In most programming languages such scalar variables are the basic data types. R however does not have scalar variables, all variables are vectors. A variable storing a number is for example just a numeric vector of length 1.

Defining vectors

The simplest way to create vectors in R is to use the function c:

a <- c(1, 4, 2)
a

[1] 1 4 2

We can use the function c as well to concatenate ("stick together") two vectors:

a <- c(1, 4, 2)
b <- c(5, 9, 13)
c <- c(a, b)
c

[1]  1  4  2  5  9 13

x <- c(1, 3, 2, 5)
y <- c(1, 0)
z <- c(x, y)
z

[1] 1 3 2 5 1 0

Naming entries

If the entries of the vectors correspond to quantities with natural names it is a good idea to associate names with the entries of the vector. This can be done using

names(a) <- c("first", "second", "third")
a

first second  third 
1      4      2

Alternatively we can set the names when creating the vector using c

a <- c(first=1, second=4, third=2)

Accessing elements

You can use square brackets to access a single element of a vector. x[i] returns the i-th element of the vector x. Using the vector a from above,

a[3]

third 
2

You can use the same notation to change elements of a vector:

a[3] <- 10
a

first second  third 
1      4     10

If the element you want to change is beyond the last element of the vector, the vector will be extended, such that the i-th element is the last element.

a[7] <- 99
a

first second  third                             
1      4     10     NA     NA     NA     99

If the entries of the vector are named, you can also use the names for accessing elements.

a["third"]

third 
10

Subsetting vectors

You can use square brackets not only to access a single element of a vector, but also to subset a vector. There are three ways of specifying subsets of vectors:

You can use a vector specifying the indices to be returned:

a <- c(1, 4, 9, 16)
a[c(1,2,3)]

[1] 1 4 9

You can use a vector specifying the indices to be removed (as negative numbers):

a[-4]

[1] 1 4 9

You can use a logical vector specifying the elements to be returned:

a[c(TRUE, TRUE, TRUE, FALSE)]

[1] 1 4 9

We can exploit the latter when we want to subset a vector based on its values. Suppose you want to keep all elements in a that are divisible by 2:

a[a%%2==0]

[1]  4 16

Why does this work? a%%2==0 returns a logical vector of length 4, indicating which elements of a are divisible by 2. These elements are then selected from a.

x <- c(1, 5, 9, 3, 8)

x[c(1,3,5)]

[1] 1 9 8

x[-c(2,4)]

[1] 1 9 8

x[c(TRUE,FALSE,TRUE,FALSE,TRUE)]

[1] 1 9 8

Vectorised calculations

VideoVectorisationDuration4:51

Vectors can be used in arithmetic expressions using the arithmetic operators and the mathematical and statistical functions we have seen when we used R as a calculator in Week 1. In this case the computations are carried out element-wise.

For example,

a <- c(1, 2, 3, 4)
b <- c(2, 0, 1, 3)
c <- 2 * a + b
c

[1]  4  4  7 11

The third entry of the result, 7, is obtained by taking twice the third entry of the vector a and adding it to third entry of the vector b, i.e. .

Recycling rules

If vectors of different length are used in an arithmetic expression, the shorter vector(s) are repeated ("recycled") until they match the length of the longest vector.

a <- c(1, 2, 3, 4)
b <- c(2, 0)
a * b

[1] 2 0 6 0

R has thus "recycled" the vector b once.

If the length of the longest vectors is not a multiple of the length of the shorter vector(s), R will produce a warning. For example,

a <- c(1, 2, 3, 4)
b <- c(2, 0, 1)
a * b

## Warning in a * b: longer object length is not a multiple of shorter object
## length

[1] 2 0 3 8

The vector b is shorter than the vector a. However, if b is recycled once, it would have 6 elements, making it longer than a. Thus R produces a warning. Such a warning is almost always a sign that you have made a mistake.

x <- c(1, 2, 9, 4, 5, 6)
y <- c(0, 2)
x+y

[1] 1 4 9 6 5 8

yyy <- c(0, 2, 0, 2, 0, 2)
x+yyy

[1] 1 4 9 6 5 8

Sequences and patterned vectors

Sequences

R has built-in functions to create simple sequences and patterned vectors:

The operator : can be used for creating basic sequences.

2:5

[1] 2 3 4 5

If the first argument is larger then the second argument, then the sequence will be decreasing.

1:0

[1] 1 0

seq(from, to, by) creates a sequence from from to to using by as increment.

seq(1, 2, by=0.2)

[1] 1.0 1.2 1.4 1.6 1.8 2.0

seq(from, to, length.out=n) creates a sequence of total length n with initial value from and ending value to.

seq(3, 5, length.out=5)

[1] 3.0 3.5 4.0 4.5 5.0

Repeats

rep(x, times=n) repeats the vector x n times.

rep(1:3, times=3)

[1] 1 2 3 1 2 3 1 2 3

rep(x, each=n) repeats each element of the vector x n times.

rep(1:3, each=3)

[1] 1 1 1 2 2 2 3 3 3

2 3 4 5 6
2 4 6
1.00 1.25 1.50 1.75 2.00 
3 3 4 4 5 5
2 3 4 2 3 4

2:6

[1] 2 3 4 5 6

seq(2, 4, by=2)

[1] 2 4

seq(1, 2, length.out=5)

[1] 1.00 1.25 1.50 1.75 2.00

rep(3:5, each=2)

[1] 3 3 4 4 5 5

rep(2:4, 2)

[1] 2 3 4 2 3 4

Useful functions for vectors

numeric(n) creates a numeric vector of length n (containing 0's).

length(x) returns the length (number of elements) of the vector x.

unique(x) returns the unique elements of x.

rev(x) reverses the vector x, i.e. returns

Sorting

The function sort(x) sorts the vector x. The function order(x) returns the permutation required to sort the vector x Consider the vector

x <- c(11, 7, 3, 9, 4)

We can sort x using

sort(x)

[1]  3  4  7  9 11

So what does the function order do?

p <- order(x)
p

[1] 3 5 2 4 1

The first entry of the result p is 3. The third entry of x is the smallest: if we want to sort x we have to put the third entry first, or, in other words, the first entry of the sorted vector would be the third entry of x. The second entry of p is 5, because the second smallest entry of x is its fifth entry.

We can obtain the sorted vector by applying the permutation obtained from order to x

x[p]

[1]  3  4  7  9 11

This trick can be used to sort an entire dataset by one column.

If we want to sort the vector is descending order, we have to append the argument decreasing=TRUE.

sort(x, decreasing=TRUE)

[1] 11  9  7  4  3

Scalar summary functions

R has a large selection of functions that compute a scalar function of a vector. Their names are self-explanatory: min, max, sum, prod, mean, median, sd, var, ...

sum(1:10)

[1] 55

sum((1:100)^2)   # correct

[1] 338350

sum(1:100)^2     # NOT correct

[1] 25502500

sum(1:100^2)     # NOT correct

[1] 50005000

n <- 1e7       # Set sample size (the bigger the better, within reason)
x <- rnorm(n)  # Draw a sample of size n from the standard normal distribution
sum(x>1)/n     # Our estimate of the probability

[1] 0.1587264

pnorm(1, lower.tail=FALSE)

[1] 0.1586553

Other data types in R

So far we have considered vectors which were either numerical or logical. In this section we will look at other data types in R.

Character strings

Character strings in R are defined using double or single quotes.

string <- "A string in single quotes"
another.string <- 'This time defined using single quotes'

string.with.newline <- "Text\nText on a new line"

string.with.escapes <- "This \" is a quote and this \\\\ is a single backslash"

Strings can be printed using print. As an example (or just the variable name)

string

[1] "A string in single quotes"

Use the function cat to print the string as it is

cat(string)

A string in single quotes

R has a variety of built-in functions for manipulating strings. It is however easier to use the functions from the package stringr (which is a part of the Tidyverse suite of packages, which we will look at in Week 4).

For example, two strings can be concatenated using the function str_c (the equivalent base R function is paste).

library(stringr)
str_c("Two strings", "put together", sep=" - ")

[1] "Two strings - put together"

"%.%" <- function(lhs, rhs) {
  str_c(lhs, rhs)
}
left <- "Two strings"
mid <- " - "
right <- "put together"
left %.% mid %.% right

[1] "Two strings - put together"

Note that you cannot use character vectors for any sort of arithmetic. For example

"120" + "5"

Error in "120" + "5" : non-numeric argument to binary operator

You are unlikely to do this deliberately, but you might come across it if R treats a supposedly numerical variable as a character string because of at least one non-numerical entry.

Comparisons between character strings use lexicographic ordering, i.e. they are compared based on where they would be in a dictionary. For example

"apple">"pear"

[1] FALSE

However character strings containing numbers are compared in an unexpected way

"120" > "5"

[1] FALSE

In lexicographic ordering "5" comes after "120" (as only the first digit "1" matters).

Factors

Factors are a variant on that theme and designed to be used with categorical variables. The main difference between a factor and a character vector is that factors are only allowed to take a pre-defined set of values ("levels"). You will learn more about factors in Learning From Data/Data Science Fundamentals.

Any vector can be converted to a factor using the function factor. It has the additional (optional) arguments levels and labels which can be used to set the labels printed when a vector is displayed.

x <- c(1, 4, 2, 4, 1, 3, 1, 2, 4)
X <- factor(x, levels=1:5, labels=c("one", "two", "three", "four", "five"))
X

[1] one   four  two   four  one   three one   two   four 
Levels: one two three four five

In our example, the factor X is only allowed to take the values "one", "two", "three", "four" and "five" (the level "five" is currently not being used). Thus we can set for example

X[1] <- "five"
X

[1] five  four  two   four  one   three one   two   four 
Levels: one two three four five

We cannot set the first entry to "six". "six" is not in the set of allowed labels.

X[1] <- "six"

## Warning in `[<-.factor`(`*tmp*`, 1, value = "six"): invalid factor level, NA
## generated

X

[1] <na>  four  two   four  one   three one   two   four 
Levels: one two three four five

In order to be able to set the first entry to "six" we need to first expand the set of levels.

levels(X) <- c(levels(X), "six")
X[1] <- "six"
X

[1] six   four  two   four  one   three one   two   four 
Levels: one two three four five six

To turn X back into its original numerical format we can use the function unclass.

unclass(X)

[1] 6 4 2 4 1 3 1 2 4
attr(,"levels")
[1] "one"   "two"   "three" "four"  "five"  "six"

Converting between data types

You can convert between different data types by using as.<target-datatype>. For example you can convert

x <- pi                  # x is numeric
x <- as.character(x)     # now x is a character string
x <- as.numeric(x)       # x is numeric again (but we lost some digits)

Often R will convert between different types automatically. The most common data types are

Missing values

R uses the special value NA to indicate that a value is missing. It is different from NaN, which is "not a number", i.e. a value for which the calculations have gone wrong.

You cat set a value to NA by simply assigning it the value NA.

x <- 1:4
x[4] <- NA
x

[1]  1  2  3 NA

Calculations (arithmetic, summary functions, etc.) involving NAs have the result set to NA as well: the result depends on the value that is not available.

mean(x)

[1] NA

If you want R to omit the missing values you can either use

mean(na.omit(x))

[1] 2

or

mean(x, na.rm=TRUE)

[1] 2

The former is more generic as not every function support the additional argument of na.rm=TRUE.

Use the function is.na to test whether a value is missing.

is.na(x)

[1] FALSE FALSE FALSE  TRUE

You cannot use == to test whether a value is missing

x==NA

[1] NA NA NA NA

The comparison just results in NA, use is.na instead.

Matrices

VideoMatricesDuration6:45

Matrices in R

Matrices are the two-dimensional generalisation of vectors. The main difference between a vector and a matrix is that a vector has a single index, whereas a matrix has two indexes: row and column.

Internally, R stores matrices in column-major mode, i.e. the matrix is stored as

1 2 3 4 5 6 7 8 9

i.e. R internally stacks the columns on top of each other, which is known as "column-major mode". If you had stored the matrix is a two-dimensional array in C or Java, it would be stored in what is called "row-major mode", i.e. the rows would be stacked on top of each other.

Creating matrices

There are essentially three ways of creating a matrix in R.

Using the internal representation

The first one consists of using the internal representation of matrices as vectors. If we want to create a matrix we can use the command matrix.

B <- matrix(c(0, 7, 2, 4, 9, 6), nrow=2)

Alternatively, you could specify the number of columns using ncol=3.

The function matrix can also be used to create "empty" matrices. matrix(a, nrow, ncol) creates a nrowncol matrix in which every entry is set to a.

Row-wise build-up

Another option is to build up the matrix row-wise using the function rbind.

B <- rbind(c(0, 2, 9),
           c(7, 4, 6))

We can also use rbind to add a row to an existing matrix.

rbind(B, c(1, 2, 9))

[,1] [,2] [,3]
[1,]    0    2    9
[2,]    7    4    6
[3,]    1    2    9

If a vector given to rbind is shorter than the other rows, it is "recycled" using the same rules as used for vector arithmetic. For example, to add a row of 0's to the matrix we can use

rbind(B, 0)

[,1] [,2] [,3]
[1,]    0    2    9
[2,]    7    4    6
[3,]    0    0    0

Column-wise build-up

The third option consists of using rbind's sibling cbind. cbind adds a column to a matrix and can be used to build up a matrix column-wise. Thus we can create the matrix using

B <- cbind(c(0, 7), c(2, 4), c(9, 6))

M <- matrix(c(9,3,4,2,-2,8,4,7,-1), ncol=3)

M <- rbind(c( 9, 2, 4),
           c( 3,-2, 7),
	   c( 4, 8,-1))

M <- cbind(c( 9, 3, 4),
           c( 2,-2, 8),
	   c( 4, 7,-1))

Dimensions of a matrix

To find out the dimensions of a matrix you can use the three functions nrow, ncol and dim.

nrow(B)

[1] 2

ncol(B)

[1] 3

dim(B)

[1] 2 3

The function length returns the number of entries of a matrix ( in our case)

length(B)

[1] 6

Diagonal matrices

Diagonal matrices have a special role in Linear Algebra and thus in Statistics. For this reason R has a function dedicated to diagonal matrices: diag.

E <- diag(c(1 ,4 , 2))
E

[,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    4    0
[3,]    0    0    2

diag can also be used to access the diagonal of an existing matrix. The matrix does not even need to be diagonal for this. You can change the second element of the diagonal of the matrix E to 5 using

diag(E)[2] <- 5
E

[,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    5    0
[3,]    0    0    2

diag(c(4,7,-9,4))

[,1] [,2] [,3] [,4]
[1,]    4    0    0    0
[2,]    0    7    0    0
[3,]    0    0   -9    0
[4,]    0    0    0    4

A <- diag(1:5e3)         # Create a dense matrix A
object.size(A)           # Estimate storage space required
system.time(solve(A))    # Get timing for matrix inversion 
                         # Third number is the time required in seconds

##    user  system elapsed 
##  10.513   0.143  10.684

library(Matrix)          # Make commands from package Matrix available
A <- Diagonal(x=1:5e3)   # Create a sparse matrix A
object.size(A)           # Estimate storage space required
system.time(solve(A))    # Get timing for matrix inversion
                         # Third number is the time required in seconds

##    user  system elapsed 
##       0       0       0

Naming rows and columns

When working with data matrices it is a good idea to name at least the columns of a matrix. It is much better to refer to variables in a matrix by their name rather than the column index in which they are stored.

Rows and columns can be named using the functions rownames and colnames.

colnames(B) <- c("First column", "Second column", "Third column")
rownames(B) <- c("First row", "Second row")
B

First column Second column Third column
First row             0             2            9
Second row            7             4            6

Accessing elements and submatrices

Single entries of matrices can be accessed using square brackets. To extract , i.e. the value in the second row and third column of we can use

B[2,3]

[1] 6

Similarly, we can set to -1 using

B[2,3] <- -1

Though this is not recommended, we could have also used the internal vector representation and extract the sixth element of the internal representation

B[6]

[1] -1

You can access arbitrary submatrices by specifying the rows and columns you wish to access. You can do so by using any combination of the three methods used for vectors and mentioned in the third handout. To extract the first row and first and second column of you can use any of the following lines ( and there are many other ways of doing so):

B[1, 1:2]

First column Second column 
0             2

B[-2, 1:2]

First column Second column 
0             2

B[c(TRUE, FALSE), -3]

First column Second column 
0             2

Each line returns the vector

Because the output object has only one row it is returned as a vector (instead of a matrix). In complex programmes in which the result is then expected to be matrix this can sometimes cause problems. In this case you can use the additional argument drop=FALSE:

B[1, 1:2, drop=FALSE]

First column Second column
First row            0             2

If we only want to subset rows and columns the selector for the other dimension can be left empty. To access the first row of the matrix use

B[1,]

First column Second column  Third column 
0             2             9

To access the third column of use

B[, 3]

First row Second row 
9         -1

To replace the third column of with the numbers 1 and 8 you can use

B[, 3] <- c(1, 8)

Furthermore, logical expressions can be used to subset matrices in the same way as they are used to subset vectors. Suppose you want to set all entries larger than 5 to 6.

B[B > 5] <- 6
B

First column Second column Third column
First row             0             2            1
Second row            6             4            6

M[1,]                # Extract first row

[1] 9 2 4

M[1,3] <- 0          # Set top-right entry to 0.
M[,3] <- M[,3] + 1   # Add 1 to the last column

Matrix multiplication and basic linear algebra

Matrix multiplication

The basic arithmetic operators can be applied to matrices in the same way as they can be applied to vectors. They are interpreted element-wise. Most importantly, * performs element-wise multiplication. In order to perform matrix multiplication you need to use the operator %*%.

To compute the matrix product in R, you can use:

A <- matrix(c(1, 0, -1, -1, 1, 0), ncol=2)
B <- matrix(c(0, 7, 2, 4, 9, -1), ncol=3)
A %*% B

[,1] [,2] [,3]
[1,]   -7   -2   10
[2,]    7    4   -1
[3,]    0   -2   -9

Note that matrix multiplication is generally not commutative (unless and are symmetric), thus A%*%B is not the same as B%*%A.

The transpose of a matrix can be computed using the function t(A). The cross product can be computed using the function crossprod(A).

C <- B%*%t(B)             # Create a square matrix C=BB'
C.inv <- solve(C)         # Compute the inverse of C
C.inv%*%C                 # Check whether C.inv is indeed the inverse

[,1]         [,2]
[1,]    1 7.589415e-19
[2,]    0 1.000000e+00

C%*%C.inv

[,1] [,2]
[1,] 1.000000e+00    0
[2,] 7.589415e-19    1

A <- rbind(c( 0, 5,  1),
           c( 0, 7, -1),
           c(11, 1,  1))
b <- c(7, 5, 14)
z <- solve(A, b)
z

[1] 1 1 2

A%*%z

[,1]
[1,]    7
[2,]    5
[3,]   14

z <- solve(A)%*%b

y <- cars$dist              # Set y (response) to distance
X <- cbind(1, cars$speed)   # Set X (covariate) to a column of ones and speed
A <- t(X)%*%X               # Assemble matrix A
b <- t(X)%*%y               # Assemble vector b
beta <- solve(A, b)         # Solve for z (which is beta)
beta

[,1]
[1,] -17.579095
[2,]   3.932409

lm(dist~speed, data=cars)$coef

(Intercept)       speed 
-17.579095    3.932409

A <- matrix(rnorm(9e6), nrow=3e3)    # Create matrix A with random entries (3000x3000)
B <- matrix(rnorm(9e6), nrow=3e3)    # Create matrix B with random entries (3000x3000)
x <- rnorm(3e3)                      # Create vector x with random entries (3000x1)

(A%*%B)%*%x

A%*%(B%*%x)

system.time((A%*%B)%*%x)

user  system elapsed 
8.696   0.023   8.719

system.time(A%*%(B%*%x))

user  system elapsed 
0.011   0.000   0.011

Lists in R

VideoListsDuration6:46

Lists allow us to combine several variables into one object. In contrast to regular vectors and matrices, the entries of a list do not all have to be of the same data type.

Creating lists

You can create a list using the list command.

example1 <- list(1:3, c(TRUE,FALSE), 7)
example1

[[1]]
[1] 1 2 3

[[2]]
[1]  TRUE FALSE

[[3]]
[1] 7

Lists can be nested within each other.

example2 <- list(list(pi, 1:2), list("some text", 1:3))
example2

[[1]]
[[1]][[1]]
[1] 3.141593

[[1]][[2]]
[1] 1 2


[[2]]
[[2]][[1]]
[1] "some text"

[[2]][[2]]
[1] 1 2 3

Just like vectors, lists can be concatenated using the function c. The fist three entries of the resulting list will come from example1. the remaining fourth and fifth entry from example2.

c(example1, example2)

[[1]]
[1] 1 2 3

[[2]]
[1]  TRUE FALSE

[[3]]
[1] 7

[[4]]
[[4]][[1]]
[1] 3.141593

[[4]][[2]]
[1] 1 2


[[5]]
[[5]][[1]]
[1] "some text"

[[5]][[2]]
[1] 1 2 3

It is good programming style to name the elements of a list (if possible). This can be done using names:

names(example1) <- c("a", "b", "c")
example1

$a
[1] 1 2 3

$b
[1]  TRUE FALSE

$c
[1] 7

Alternatively, you can specify the names directly in the list command:

example1 <- list(a=1:3, b=c(TRUE,FALSE), c=7)

Accessing elements

Elements of a list can be accessed using either double square brackets or, if the list has names, $. The following three lines of R code all return the first entry of the list example1 (using either its position or its name).

example1[[1]]

[1] 1 2 3

example1[["a"]]

[1] 1 2 3

example1$a

[1] 1 2 3

If you want to subset a list (in the sense of extracting more than one entry) use single square brackets:

example1[1:2]

$a
[1] 1 2 3

$b
[1]  TRUE FALSE

If we extract an individual entry using single square brackets we obtain a list containing that entry rather than the entry itself.

example1[1]

$a
[1] 1 2 3

Lists are everywhere ...

Most R functions return lists. Take the lm function as an example. The function lm fits a linear regression model, which is essentially a straight line fit to the data. First of all we fit a linear model using the cars dataset within R:

fit <- lm(dist~speed, data=cars)          # Fit a linear model
fit                                       # Print the model

Call:
lm(formula = dist ~ speed, data = cars)

Coefficients:
(Intercept)        speed  
-17.579        3.932

The output object fit is in fact a list.

is.list(fit)

[1] TRUE

Let's look at its entries

names(fit)

[1] "coefficients"  "residuals"     "effects"       "rank"         
[5] "fitted.values" "assign"        "qr"            "df.residual"  
[9] "xlevels"       "call"          "terms"         "model"

So, if we for example want to retrieve the regression coefficients we can use

fit$coefficients

(Intercept)       speed 
-17.579095    3.932409

Actually, we do not have to fully spell out the name of the entry after the $, we only have to use the first few characters until the name is uniquely determined. So we could have also used

fit$coef

(Intercept)       speed 
-17.579095    3.932409

We could have not used

fit$c

NULL

as there is more than one element with a name starting with a "c" ("call" and "coefficients").

attr(fit, "class")

[1] "lm"