Lecture 3 Activity 4

2.6 Vectorized Operations

2.6.1 Vector In, Vector Out

First, create 2 vectors u and v using the concatenate function. Then, we investigate whether each entry of u is greater than the corresponding entry of v.

u <- c(5,2,8)
v <- c(1,3,9)
u>v

[1]  TRUE FALSE FALSE

Below create two vectors y and z and compare them, this time using the <= operator.

y <- c(5,1,4,9)
z <- c(25,3,4,1)
y <= z

[1]  TRUE  TRUE  TRUE FALSE

Above, the > function was applied to u[1] and v[1], resulting in TRUE, then to u[2] and v[2], resulting in FALSE, and so on.

A key point is that if an R function uses vectorized operations, it, too, is vectorized, thus enabling a potential speedup. Here is an example:

w <- function(x) return(x+1)
w(u)

[1] 6 3 9

We created a function w which takes an input and increases it by 1. If the input is an integer x, the output is just x + 1. When entering a vector, each vector entry is increased by 1. Just like we applied our function to the vector us above, we do the same with v.

w(v)

[1]  2  4 10

Here, w() uses +, which is vectorized, so w() is vectorized as well. As you can see, there is an unlimited number of vectorized functions, as complex ones are built up from simpler ones.

Our next function m takes an input value, squares it and adds 1 to the result.

m <- function(x) return(x**2+1)

We apply the new function to the vector u.

m(u)

[1] 26  5 65

We apply m to the vector v as well.

m(v)

[1]  2 10 82

Now create a function that returns x^2 - 1:

n <- function(x) return(x**2 - 1)

We apply the function to the vector y:

n(y)

[1] 24  0 15 80

Next, let’s apply the function for rounding to the nearest integer to a new example vector y. To create the new y, we overwrite the old y that we created above.

y <- c(1.2,3.9,0.4)
z <- round(y)
z

[1] 1 4 0

The round function rounds the input to the nearest integer. 1.2 is getting rounded to 1, 3.9 to 4, and 0.4 to 0.

Let’s apply the function for rounding to the nearest integer to an example vector r<-c(0.25,0.9,2.1,4.7,5.1):

r <- c(0.25, 0.9, 2.1, 4.7, 5.1)
round(r)

[1] 0 1 2 5 5

We get the integer vector (0, 1, 2, 5, 5).

Since we know that R has no scalars, let’s consider vectorized functions that appear to have scalar arguments.

f<-function(x,c) return((x+c)^2)
f(1:3,0)

[1] 1 4 9

Recall that for a 3D vector x and a scalar c, x + c = (x[1] + c, x[2] + c, x[3] + c).

f(1:3,1)

[1]  4  9 16

Create a function that returns (x-c)^2 and calculate f(1:3,0) and f(1:3,1)

f2 <- function(x,c) return((x - c)^2)
f2(1:3,1)

[1] 0 1 4

2.6.2 Vector In, Matrix Out

The vectorized functions we’ve been working with so far have scalar return values. Calling sqrt() on a number gives us a number. If we apply this function to an eight-element vector, we get eight numbers, thus another eightelement vector, as output. But what if our function itself is vector-valued, as z12() is here:

z12 <- function(z) return(c(z,z^2))

Applying z12() to 5, say, gives us the two-element vector (5,25). If we apply this function to an eight-element vector, it produces 16 numbers:

x <- 1:8
z12(x)

 [1]  1  2  3  4  5  6  7  8  1  4  9 16 25 36 49 64

Compute z12(x2) where x2<-1:5. Explain the output.

x2 <- c(1:5)
z12(x2)

 [1]  1  2  3  4  5  1  4  9 16 25

z12 returns the vector 1:5 first and then returns the squared values of x2. c(1, 4, 9, 16, 25) is just the squared vector x2.

It might be more natural to have these arranged as an 8-by-2 matrix, which we can do with the matrix function:

matrix(z12(x),ncol=2)

     [,1] [,2]
[1,]    1    1
[2,]    2    4
[3,]    3    9
[4,]    4   16
[5,]    5   25
[6,]    6   36
[7,]    7   49
[8,]    8   64

Create a similar matrix using z12(x2):

matrix(z12(x2),ncol=2)

     [,1] [,2]
[1,]    1    1
[2,]    2    4
[3,]    3    9
[4,]    4   16
[5,]    5   25

2.7 NA and NULL Values

2.7.1 Using NA

In many of R’s statistical functions, we can instruct the function to skip over any missing values, or NAs. Here is an example:

x <- c(88,NA,12,168,13)
x

[1]  88  NA  12 168  13

When calculating the mean without further specification, the NA value is taken into account. Since NA + x = NA for all real numbers x, the mean is also evaluated as NA.

mean(x)

[1] NA

We have to remove the NA values with the NA.rm function in order to get a representative mean.

mean(x,na.rm=T)

[1] 70.25

If we write NULL instead of NA, we don`t have to make special removements. This is due to the fact that a NULL value is interpreted as an empty value (None), while NA is an unknown missing value that exists.

x <- c(88,NULL,12,168,13)
mean(x)

[1] 70.25

Let us now work with the mode:

x <- c(5,NA,12)
mode(x[1])

[1] "numeric"

5 is a numeric value.

mode(x[2])

[1] "numeric"

In this case, NA is also seen as a numeric value.

Now create a vector with characters and NA:

y <- c("abc","def",NA)

mode(y[2])

[1] "character"

“def” is interpreted as a character, exactly as we would expect.

mode(y[3])

[1] "character"

NA, on the other hand, is interpreted as a character as well this time. This is because the vector has character values as entries, so NA is also interpreted as a character.