R version 3.1.

2 (2014-10-31) -- "Pumpkin Helmet"

Copyright (C) 2014 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64 (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.

You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.

Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or

'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> library(swirl)

| Hi! Type swirl() when you are ready to begin.

> swirl()

| Welcome to swirl!

| Please sign in. If you've been here before, use the same name as you did then. If
you
| are new, call yourself something unique.

What shall I call you? Johnny

| Please choose a course, or type 0 to exit swirl.

1: R Programming
2: Take me to the swirl course repository!

Selection: 1

| Please choose a lesson, or type 0 to return to course menu.

1: Basic Building Blocks 2: Workspace and Files

3: Sequences of Numbers 4: Vectors
5: Missing Values 6: Subsetting Vectors
7: Matrices and Data Frames 8: Logic
9: Functions 10: lapply and sapply
11: vapply and tapply 12: Looking at Data
13: Simulation 14: Dates and Times
15: Base Graphics

Selection: 8

| |
0%

| This lesson is meant to be a short introduction to logical operations in R.

...

|== |
2%
| There are two logical values in R, also called boolean values. They are TRUE and
| FALSE. In R you can construct logical expressions which will evaluate to either
TRUE
| or FALSE.

...

|=== |
4%

| Many of the questions in this lesson will involve evaluating logical expressions.
It
| may be useful to open up a second R terminal where you can experiment with some
of
| these expressions.

...

|===== |
6%

| Creating logical expressions requires logical operators. You're probably familiar

| with arithmetic operators like `+`, `-`, `*`, and `/`. The first logical operator
we
| are going to discuss is the equality operator, represented by two equals signs
`==`.
| Use the equality operator below to find out if TRUE is equal to TRUE.

>
> TRUE == true
Error: object 'true' not found
> TRUE == TRUE
[1] TRUE

| Your dedication is inspiring!

|====== |
8%

| Just like arithmetic, logical expressions can be grouped by parenthesis so that

the
| entire expression (TRUE == TRUE) == TRUE evaluates to TRUE.

...

|======== |
10%

| To test out this property, try evaluating (FALSE == TRUE) == FALSE .

> (FALSE == TRUE) == FALSE

[1] TRUE

| You are really on a roll!

|========= |
12%
| The equality operator can also be used to compare numbers. Use `==` to see if 6
is
| equal to 7.

> 6 == 7
[1] FALSE

| That's correct!

|=========== |
14%

| The previous expression evaluates to FALSE because 6 is less than 7. Thankfully,

| there are inequality operators that allow us to test if a value is less than or
| greater than another value.

...

|============ |
16%

| The less than operator `<` tests whether the number on the left side of the
operator
| (called the left operand) is less than the number on the right side of the
operator
| (called the right operand). Write an expression to test whether 6 is less than 7.

> 6 < 7
[1] TRUE

| You got it!

|============== |
18%

| There is also a less-than-or-equal-to operator `<=` which tests whether the left
| operand is less than or equal to the right operand. Write an expression to test
| whether 10 is less than or equal to 10.

> 10 <= 10
[1] TRUE

| That's a job well done!

|=============== |
20%

| Keep in mind that there are the corresponding greater than `>` and
| greater-than-or-equal-to `>=` operators.

...

|================= |
22%

| Which of the following evaluates to FALSE?

1: 7 == 7
2: 0 > -36
3: 6 < 8
4: 9 >= 10

Selection: 4

| That's the answer I was looking for.

|================== |
24%

| Which of the following evaluates to TRUE?

1: 9 >= 10
2: 7 == 9
3: -6 > -7
4: 57 < 8

Selection: 3

| You are quite good my friend!

|==================== |
25%

| The next operator we will discuss is the 'not equals' operator represented by `!
=`.
| Not equals tests whether two values are unequal, so TRUE != FALSE evaluates to
TRUE.
| Like the equality operator, `!=` can also be used with numbers. Try writing an
| expression to see if 5 is not equal to 7.

> 5 != 7
[1] TRUE

| You nailed it! Good job!

|===================== |
27%

| In order to negate boolean expressions you can use the NOT operator. An
exclamation
| point `!` will cause !TRUE (say: not true) to evaluate to FALSE and !FALSE (say:
not
| false) to evaluate to TRUE. Try using the NOT operator and the equals operator to
| find the opposite of whether 5 is equal to 7.

> !(5 == 7)
[1] TRUE

| You are doing so well!

|======================= |
29%

| Let's take a moment to review. The equals operator `==` tests whether two boolean
| values or numbers are equal, the not equals operator `!=` tests whether two
boolean
| values or numbers are unequal, and the NOT operator `!` negates logical
expressions
| so that TRUE expressions become FALSE and FALSE expressions become TRUE.

...

|======================== |
31%

| Which of the following evaluates to FALSE?

1: 9 < 10
2: !FALSE
3: !(0 >= -1)
4: 7 != 8

Selection: 3

| That's a job well done!

|========================== |
33%

| What do you think the following expression will evaluate to?: (TRUE != FALSE)
== !(6
| == 7)

1: TRUE
2: Can there be objective truth when programming?
3: %>%
4: FALSE

Selection: 1

| Excellent job!

|============================ |
35%

| At some point you may need to examine relationships between multiple logical
| expressions. This is where the AND operator and the OR operator come in.

...

|============================= |
37%

| Let's look at how the AND operator works. There are two AND operators in R, `&`
and
| `&&`. Both operators work similarly, if the right and left operands of AND are
both
| TRUE the entire expression is TRUE, otherwise it is FALSE. For example, TRUE &
TRUE
| evaluates to TRUE. Try typing FALSE & FALSE to how it is evaluated.

> FALSE & FALSE

[1] FALSE

| You are quite good my friend!

|=============================== |
39%

| You can use the `&` operator to evaluate AND across a vector. The `&&` version of
AND
| only evaluates the first member of a vector. Let's test both for practice. Type
the
| expression TRUE & c(TRUE, FALSE, FALSE).

> TRUE & c(TRUE, FALSE, FALSE)

[1] TRUE FALSE FALSE

| You're the best!

|================================ |
41%

| What happens in this case is that the left operand `TRUE` is recycled across
every
| element in the vector of the right operand. This is the equivalent statement as
| c(TRUE, TRUE, TRUE) & c(TRUE, FALSE, FALSE).

...

|================================== |
43%

| Now we'll type the same expression except we'll use the `&&` operator. Type the
| expression TRUE && c(TRUE, FALSE, FALSE).

> TRUE && c(true, FALSE, FALSE)

Error: object 'true' not found
> TRUE && c(TRUE, FALSE, FALSE)
[1] TRUE

| You nailed it! Good job!

|=================================== |
45%

| In this case, the left operand is only evaluated with the first member of the
right
| operand (the vector). The rest of the elements in the vector aren't evaluated at
all
| in this expression.

...

|===================================== |
47%

| The OR operator follows a similar set of rules. The `|` version of OR evaluates
OR
| across an entire vector, while the `||` version of OR only evaluates the first
member
| of a vector.

...

|====================================== |
49%

| An expression using the OR operator will evaluate to TRUE if the left operand or
the
| right operand is TRUE. If both are TRUE, the expression will evaluate to TRUE,
| however if neither are TRUE, then the expression will be FALSE.

...

|======================================== |
51%

| Let's test out the vectorized version of the OR operator. Type the expression
TRUE |
| c(TRUE, FALSE, FALSE).

> TRUE | c(TRUE, FALSE, FALSE)

[1] TRUE TRUE TRUE

| Excellent work!

|========================================= |
53%

| Now let's try out the non-vectorized version of the OR operator. Type the
expression
| TRUE || c(TRUE, FALSE, FALSE).

> TRUE || c(TRUE, FALSE, FALSE)

[1] TRUE

| That's a job well done!

|=========================================== |
55%

| Logical operators can be chained together just like arithmetic operators. The
| expressions: `6 != 10 && FALSE && 1 >= 2` or `TRUE || 5 < 9.3 || FALSE` are
perfectly
| normal to see.

...

|============================================ |
57%

| As you may recall, arithmetic has an order of operations and so do logical

| expressions. All AND operators are evaluated before OR operators. Let's look at
an
| example of an ambiguous case. Type: 5 > 8 || 6 != 8 && 4 > 3.9

> 5 > 8 || 6 != 7 && 4 > 3.9

[1] TRUE

| Not quite, but you're learning! Try again. Or, type info() for more options.

| See how the order of operations works by typing: 5 > 8 || 6 != 8 && 4 > 3.9

> 5 > 8 || 6 != 8 && 4 > 3.9

[1] TRUE

| That's correct!

|============================================== |
59%

| Let's walk through the order of operations in the above case. First the left and
| right operands of the AND operator are evaluated. 6 is not equal 8, 4 is greater
than
| 3.9, therefore both operands are TRUE so the resulting expression `TRUE && TRUE`
| evaluates to TRUE. Then the left operand of the OR operator is evaluated: 5 is
not
| greater than 8 so the entire expression is reduced to FALSE || TRUE. Since the
right
| operand of this expression is TRUE the entire expression evaluates to TRUE.

...

|=============================================== |
61%

| Which one of the following expressions evaluates to TRUE?

1: TRUE && 62 < 62 && 44 >= 44

2: 99.99 > 100 || 45 < 7.3 || 4 != 4.0
3: FALSE || TRUE && FALSE
4: TRUE && FALSE || 9 >= 4 && 3 < 6

Selection: 2

| Not exactly. Give it another go.

| Try to evaluate each expression in isolation and build up an answer.

1: TRUE && 62 < 62 && 44 >= 44

2: 99.99 > 100 || 45 < 7.3 || 4 != 4.0
3: TRUE && FALSE || 9 >= 4 && 3 < 6
4: FALSE || TRUE && FALSE

Selection: 4

| That's not exactly what I'm looking for. Try again.

| Try to evaluate each expression in isolation and build up an answer.

1: TRUE && 62 < 62 && 44 >= 44

2: TRUE && FALSE || 9 >= 4 && 3 < 6
3: FALSE || TRUE && FALSE
4: 99.99 > 100 || 45 < 7.3 || 4 != 4.0

Selection: 3

| Not exactly. Give it another go.

| Try to evaluate each expression in isolation and build up an answer.

1: TRUE && FALSE || 9 >= 4 && 3 < 6

2: TRUE && 62 < 62 && 44 >= 44
3: FALSE || TRUE && FALSE
4: 99.99 > 100 || 45 < 7.3 || 4 != 4.0

Selection: 1

| You're the best!

|================================================= |
63%

| Which one of the following expressions evaluates to FALSE?

1: !(8 > 4) || 5 == 5.0 && 7.8 >= 7.79

2: FALSE || TRUE && 6 != 4 || 9 > 4
3: FALSE && 6 >= 6 || 7 >= 8 || 50 <= 49.5
4: 6 >= -9 && !(6 > 7) && !(!TRUE)

Selection: 1

| You're close...I can feel it! Try it again.

| Try to evaluate each expression in isolation and build up an answer.

1: FALSE && 6 >= 6 || 7 >= 8 || 50 <= 49.5

2: FALSE || TRUE && 6 != 4 || 9 > 4
3: !(8 > 4) || 5 == 5.0 && 7.8 >= 7.79
4: 6 >= -9 && !(6 > 7) && !(!TRUE)

Selection: 3

| Not quite! Try again.

| Try to evaluate each expression in isolation and build up an answer.

1: FALSE && 6 >= 6 || 7 >= 8 || 50 <= 49.5

2: 6 >= -9 && !(6 > 7) && !(!TRUE)
3: !(8 > 4) || 5 == 5.0 && 7.8 >= 7.79
4: FALSE || TRUE && 6 != 4 || 9 > 4

Selection: 1

| You nailed it! Good job!

|================================================== |
65%

| Now that you're familiar with R's logical operators you can take advantage of a
few
| functions that R provides for dealing with logical expressions.

...

|==================================================== |
67%

| The function isTRUE() takes one argument. If that argument evaluates to TRUE, the
| function will return TRUE. Otherwise, the function will return FALSE. Try using
this
| function by typing: isTRUE(6 > 4)
> isTRUE(6 > 4)
[1] TRUE

| Keep working like that and you'll get there!

|====================================================== |
69%

| Which of the following evaluates to TRUE?

1: isTRUE(3)
2: !isTRUE(4 < 3)
3: isTRUE(NA)
4: isTRUE(!TRUE)
5: !isTRUE(8 != 5)

Selection: 2

| All that hard work is paying off!

|======================================================= |
71%

| The function identical() will return TRUE if the two R objects passed to it as
| arguments are identical. Try out the identical() function by typing:
| identical('twins', 'twins')

> identical('twins', 'twins')

[1] TRUE

| Great job!

|========================================================= |
73%

| Which of the following evaluates to TRUE?

1: !identical(7, 7)
2: identical(4, 3.1)
3: identical('hello', 'Hello')
4: identical(5 > 4, 3 < 3.1)

Selection: 4

| You nailed it! Good job!

|========================================================== |
75%

| You should also be aware of the xor() function, which takes two arguments. The
xor()
| function stands for exclusive OR. If one argument evaluates to TRUE and one
argument
| evaluates to FALSE, then this function will return TRUE, otherwise it will return
| FALSE. Try out the xor() function by typing: xor(5 == 6, !FALSE)

> xor(5 == 6, !FALSE)

[1] TRUE
| Your dedication is inspiring!

|============================================================ |
76%

| 5 == 6 evaluates to FALSE, !FALSE evaluates to TRUE, so xor(FALSE, TRUE)

evaluates to
| TRUE. On the other hand if the first argument was changed to 5 == 5 and the
second
| argument was unchanged then both arguments would have been TRUE, so xor(TRUE,
TRUE)
| would have evaluated to FALSE.

...

|============================================================= |
78%

| Which of the following evaluates to FALSE?

1: xor(!!TRUE, !!FALSE)
2: xor(4 >= 9, 8 != 8.0)
3: xor(!isTRUE(TRUE), 6 > -1)
4: xor(identical(xor, 'xor'), 7 == 7.0)

Selection: 4

| Not quite right, but keep trying.

| For xor() to evaluate to TRUE, one argument must be TRUE and one must be FALSE.

1: xor(!!TRUE, !!FALSE)
2: xor(4 >= 9, 8 != 8.0)
3: xor(!isTRUE(TRUE), 6 > -1)
4: xor(identical(xor, 'xor'), 7 == 7.0)

Selection: 2

| All that hard work is paying off!

|=============================================================== |
80%

| For the next few questions, we're going to need to create a vector of integers
called
| ints. Create this vector by typing: ints <- sample(10)

> ints <- sample(10)

| You got it right!

|================================================================ |
82%

| Now simply display the contents of ints.

> ints
[1] 6 3 9 2 8 1 7 5 10 4
| That's correct!

|================================================================== |
84%

| The vector `ints` is a random sampling of integers from 1 to 10 without

replacement.
| Let's say we wanted to ask some logical questions about contents of ints. If we
type
| ints > 5, we will get a logical vector corresponding to whether each element of
ints
| is greater than 5. Try typing: ints > 5

> ints > 5

[1] TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE

| Keep up the great work!

|=================================================================== |
86%

| We can use the resulting logical vector to ask other questions about ints. The
| which() function takes a logical vector as an argument and returns the indices of
the
| vector that are TRUE. For example which(c(TRUE, FALSE, TRUE)) would return the
vector
| c(1, 3).

...

|===================================================================== |
88%

| Use the which() function to find the indices of ints that are greater than 7.

> which(ints > 7)

[1] 3 5 9

| Perseverance, that's the answer.

|====================================================================== |
90%

| Which of the following commands would produce the indices of the elements in ints
| that are less than or equal to 2?

1: ints <= 2
2: ints < 2
3: which(ints < 2)
4: which(ints <= 2)

Selection: 4

| Excellent job!

|======================================================================== |
92%
| Like the which() function, the functions any() and all() take logical vectors as
| their argument. The any() function will return TRUE if one or more of the
elements in
| the logical vector is TRUE. The all() function will return TRUE if every element
in
| the logical vector is TRUE.

...

|========================================================================= |
94%

| Use the any() function to see if any of the elements of ints are less than zero.

> any(ints < 0)

[1] FALSE

| Your dedication is inspiring!

|=========================================================================== |
96%

| Use the all() function to see if all of the elements of ints are greater than
zero.

> all(ints > 0)

[1] TRUE

| You're the best!

|============================================================================ |
98%

| Which of the following evaluates to TRUE?

1: all(ints == 10)
2: all(c(TRUE, FALSE, TRUE))
3: any(ints == 10)
4: any(ints == 2.5)

Selection: 3

| You got it!

|==============================================================================|
100%

| That's all for this introduction to logic in R. If you really want to see what
you
| can do with logic, check out the control flow lesson!

...

| Are you currently enrolled in the Coursera course associated with this lesson?

1: Yes
2: No

Selection: No