# 6 Logical

In R, logical values are stored as a distinct data type. Logical
values are very efficient to store, and are used both in statistical
modeling and in data management. In modeling, logical vectors are
often called *indicator* or *dummy* variables. In data management,
logical values also serve as *conditional* indicators.

## 6.1 Logical Values

There are three logical values:

`TRUE`

`FALSE`

`NA`

(missing)

The names `T`

and `F`

are used by default as aliases for TRUE and
FALSE, but be aware that you can redefine T and F. Do not do this
accidentally! The *names* `T`

and `F`

print the *values* `TRUE`

and `FALSE`

.

`T`

`[1] TRUE`

`F`

`[1] FALSE`

See `help(logical)`

and `help(NA)`

.

## 6.2 Logical Operators

R has the typical binary comparison operators (see `help(Comparison)`

).
These take data of arbitrary type as inputs (x and y) and return logical
values.

- Greater than,
`x > y`

, or equal to,`x >= y`

- Less than,
`x < y`

, or equal to,`x <= y`

- Equal to,
`x == y`

- Not equal,
`x != y`

R also has the typical boolean operators for creating compound logical expressions. These take logical values as inputs (x and y) and return logical values.

- And,
`x & y`

- Or,
`x | y`

- Not,
`!x`

### 6.2.1 Making Comparisons

As with the mathematical operators, logical operators work pairwise with the elements of two vectors, returning a vector of comparisons. Where one vector is shorter than the other, recycling occurs.

In this first example, we set up an arbitrary numeric vector, \(a\), and ask if each element of \(a\) is a 3.

```
a <- c(1.1, 3, 5.3, 2) # a numeric vector
f <- (a == 3) # a vector of comparisons
f
```

`[1] FALSE TRUE FALSE FALSE`

We can make comparisons with character values, too, but be aware that the result can depend on what language R thinks you are working in.

```
A <- c("a", "b", "e")
A > "d"
```

`[1] FALSE FALSE TRUE`

Comparison of two vectors is done pairwise, element by
element. (The term “vectorized” is sometimes used to mean
this sort of operation). In this example, each element
of \(a\) is compared to *one* of the integers from 1 to 4.

`a > 1:4`

`[1] TRUE TRUE TRUE FALSE`

If the two vectors being compared are of different lengths, recycling occurs just as we saw with numeric operators.

```
b <- c(1.1, 2)
a != b # silent recycling
```

`[1] FALSE TRUE TRUE FALSE`

`a > 2:4 # noisy recycling`

```
Warning in a > 2:4: longer object length is not a multiple of shorter object
length
```

`[1] FALSE FALSE TRUE FALSE`

A somewhat different kind of comparison is the value match. Here
we ask if values in the left-hand vector are elements of the *set*
represented by the right-hand vector. Despite the use of two
vectors, these are no longer
pairwise comparisons and there is no recycling.

`2 %in% a`

`[1] TRUE`

`1:4 %in% a # elementwise on the left-hand side`

`[1] FALSE TRUE TRUE FALSE`

`%in%`

will generally return the same result as `==`

:

```
z <- c(0, 1, 2)
z == 1
```

`[1] FALSE TRUE FALSE`

`z %in% 1`

`[1] FALSE TRUE FALSE`

However, if missing data is involved, the two behave differently. Where `==`

returns `NA`

, `%in%`

returns `FALSE`

. When subsetting a vector by a logical condition, be careful which one you use, since they will return different elements. See Missing Values below.

```
z[3] <- NA
z == 1
```

`[1] FALSE TRUE NA`

`z %in% 1`

`[1] FALSE TRUE FALSE`

`z[z == 1]`

`[1] 1 NA`

`z[z %in% 1]`

`[1] 1`

### 6.2.2 Boolean Algebra

We also have the usual operators - and, or, not - for combining logical inputs to produce a logical outcome.

`a == 2 & a < 5 # & - satisfy both conditions`

`[1] FALSE FALSE FALSE TRUE`

`a == 2 | a < 5 # | - satisfy at least one condition`

`[1] TRUE TRUE FALSE TRUE`

### 6.2.3 Missing Values

The logical status of missing values is treated somewhat differently in R than in some other statistical software (Stata, SAS, SPSS). Where in some languages the result of a comparison is either true or false, in R a comparison may produce a missing result.

```
b <- c(1:4, NA)
b > 3 # in SAS the final value is "true"
```

`[1] FALSE FALSE FALSE TRUE NA`

`b == 3 # in Stata and SAS the final value is "false"`

`[1] FALSE FALSE TRUE FALSE NA`

`b < 3 # in Stata the final value is "true"`

`[1] TRUE TRUE FALSE FALSE NA`

Likewise, Boolean operations on missing values produce missing results.

When *checking* for missing values a common mistake is to
use a comparison. However, in R we use a testing
function.

`b == NA # not useful, but doesn't produce an error!`

`[1] NA NA NA NA NA`

`is.na(b) # the proper way to check`

`[1] FALSE FALSE FALSE FALSE TRUE`

## 6.3 Functions with Logical Vectors

A *generic function* is a function which uses different
*methods* (implements different algorithms) depending
on the class and type of the input data. (Recall the discussion
in the chapter on Data Class.) A very few generic
functions have specific methods for logical vectors, while
most functions will coerce logical vectors to either a
numeric vector or a factor.

`summary(f) # produces counts, but also notes mode`

```
Mode FALSE TRUE
logical 3 1
```

### 6.3.1 Coercion

If you have worked with other statistical software, you won’t be surprised that very often logical values are automatically coerced to the integers 0 and 1.

`mean(f) # coerced to numeric, a proportion`

`[1] 0.25`

`f + 1 # coercion in binary operators, too`

`[1] 1 2 1 1`

You may also be aware that where numeric values are coerced into logical values, 0 is FALSE and anything else is TRUE (unless it is missing). (Recall Exercise 3 from Data Types.)

`as.logical(-1:2)`

`[1] TRUE FALSE TRUE TRUE`

## 6.4 Testing Equality

There is one logical comparison that is particularly problematic
when made by a computer: *equality*. Checking the equality of
logical values, character values, and integer values is straightforward,
but numeric values with decimal precision (stored as “doubles”) are
often imprecise. Think of the decimal representation of \(1/3\), or
0.3333333, which must be truncated at some point: 0.3333… cannot continue *forever*.

(A computer works with binary representations, but the problem is conceptually the same.)

Even simple mathematical operations can introduce numerical deviations.

```
a <- 0.5 - 0.2 # 0.3
b <- 0.4 - 0.1 # 0.3
a == b # Probably not what you expected!
```

`[1] FALSE`

`a - b # a small difference, but not exactly zero`

`[1] -5.551115e-17`

We have two general approaches for handling this imprecision
with comparisons of numeric vectors. In the special case
where we want to know of all elements of two vectors are
equivalent, we have a summary function `all.equal`

. In
the more general case, we test that the differences between
two vectors are less than a numerical *tolerance*.

```
# An example with vectors
x <- seq(0, 0.5, by = 0.1)
y <- seq(0.1, 0.6, by=0.1)-0.1
x == y # Not what you hoped for? (the third element ....)
```

`[1] TRUE TRUE FALSE TRUE TRUE TRUE`

`x - y`

```
[1] 0.000000e+00 0.000000e+00 -2.775558e-17 0.000000e+00 0.000000e+00
[6] 0.000000e+00
```

`all.equal(x,y) # checking all are equal`

`[1] TRUE`

The smallest precision available on your computer is given by

`.Machine$double.eps`

`[1] 2.220446e-16`

We commonly take our maximum imprecision to be the square root
of that value. So if we check for *numerical equivalence*, we get
the result we expected earlier with `==`

.

```
tol <- sqrt(.Machine$double.eps)
x-y < tol
```

`[1] TRUE TRUE TRUE TRUE TRUE TRUE`

## 6.5 Logical Vector Exercises

Indicators

A typical use of a comparison is to create an indicator variable. Given the mean gas mileage of cars in the

`mtcars`

data, 20.090625, create a variable that indicates which cars have above average gas mileage.The mileage variable is

`mtcars$mpg`

.Conditions

A logical vector may be used as a

*condition*to select observations from another vector (as discussed in Numeric Vectors).Use the indicator from exercise 1 to select high mileage cars, and calculate their mean displacement,

found in`mtcars$disp`

.Use the same indicator and a Boolean operator to calculate the mean displacement of low mileage cars.

Coercion

Automatic coercion of logical to numeric values and of numeric to logical values will usually be very intuitive. One place this fails spectacularly is in indexing (extracting, subsetting).

Consider this example, which at first blush might look like it should produce the same results in two different ways.

`v <- 1:4 v[c(T,F,T,F)] v[c(1,0,1,0)]`

Why do these return two

*different*vectors?Testing equality

What happens when values really are not equal? Consider

`x <- seq(0, 0.5, by = 0.1) y <- c(seq(0.1, 0.5, by=0.1)-0.1, 1) x == y`

We see two FALSE values - do they mean the same thing? How can we get an unambiguous result?

Suppose you want one value to summarize the equality of these two vectors. Try

`all.equal(x,y)`

The result in not a logical value! See

`help(isTRUE)`

and come up with a solution that is strictly TRUE or FALSE.