R Programming Swirl

R version 3.6.
1 (2019-07-05) -- "Action of the Toes"
Copyright (C) 2019 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.
Natural language support but running in an English locale
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.
> swirl()
Error in swirl() : could not find function "swirl"
> swirl()
Error in swirl() : could not find function "swirl"
> install.packages("swirl")
Installing package into ‘C:/Users/Paras Dhama/Documents/R/win-library/3.6’
(as ‘lib’ is unspecified)
--- Please select a CRAN mirror for use in this session ---
trying URL 'https://cloud.r-project.org/bin/windows/contrib/3.6/swirl_2.4.4.zip'
Content type 'application/zip' length 350179 bytes (341 KB)
downloaded 341 KB
package ‘swirl’ successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:\Users\Paras Dhama\AppData\Local\Temp\RtmpOquy0B\downloaded_packages
> packageVersion("swirl")
[1] ‘2.4.4’
> 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? paras
| Thanks, paras. Let's cover a couple of quick housekeeping items before we
| begin our first lesson. First of all, you should know that when you see
| '...', that means you should press Enter when you are done reading and ready
| to continue.
... <-- That's your cue to press Enter to continue
| Also, when you see 'ANSWER:', the R prompt (>), or when you are asked to
| select from a list, that means it's your turn to enter a response, then press
| Enter to continue.
Select 1, 2, or 3 and press Enter
1: Continue.
2: Proceed.
3: Let's get going!
Selection: 1
| You can exit swirl and return to the R prompt (>) at any time by pressing the
| Esc key. If you are already at the prompt, type bye() to exit and save your
| progress. When you exit properly, you'll see a short message letting you know
| you've done so.
| When you are at the R prompt (>):
| -- Typing skip() allows you to skip the current question.
| -- Typing play() lets you experiment with R on your own; swirl will ignore
| what you do...
| -- UNTIL you type nxt() which will regain swirl's attention.
| -- Typing bye() causes swirl to exit. Your progress will be saved.
| -- Typing main() returns you to swirl's main menu.
| -- Typing info() displays these options again.
| Let's get started!
...
| To begin, you must install a course. I can install a course for you from the
| internet, or I can send you to a web page
| (https://github.com/swirldev/swirl_courses) which will provide course options
| and directions for installing courses yourself. (If you are not connected to
| the internet, type 0 to exit.)
1: R Programming: The basics of programming in R
2: Regression Models: The basics of regression modeling in R

3: Statistical Inference: The basics of statistical inference in R
4: Exploratory Data Analysis: The basics of exploring data in R
5: Don't install anything for me. I'll do it myself.
Selection: 1
|
| | 0%
|
| | 1%
|
|========= | 13%
|
|================== | 26%
|
|======================= | 33%
|
|========================= | 36%
|
|================================= | 47%
|
|================================== | 48%
|
|=========================================== | 61%
|
|================================================= | 71%
|
|========================================================== | 83%
|
|============================================================== | 89%
|
|================================================================== | 94%
|
|======================================================================| 100%
| Course installed successfully!
| 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: 2
|
| | 0%
| In this lesson, you'll learn how to examine your local workspace in R and
| begin to explore the relationship between your workspace and the file system
| of your machine.
...
|
|== | 3%
| Because different operating systems have different conventions with regards
| to things like file paths, the outputs of these commands may vary across
| machines.
...
|
|==== | 5%
| However it's important to note that R provides a common API (a common set of
| commands) for interacting with files, that way your code will work across
| different kinds of computers.
...
|
|===== | 8%
| Let's jump right in so you can get a feel for how these special functions
| work!
...
|
|======= | 10%
| Determine which directory your R session is using as its current working
| directory using getwd().
> getwd()
[1] "C:/Users/Paras Dhama/Documents"
| Great job!
|
|========= | 13%
| List all the objects in your local workspace using ls().
> ls()
character(0)
| You're the best!
|
|=========== | 15%
| Some R commands are the same as their equivalents commands on Linux or on a
| Mac. Both Linux and Mac operating systems are based on an operating system
| called Unix. It's always a good idea to learn more about Unix!
...
|
|============= | 18%
| Assign 9 to x using x <- 9.
> x <- 9
| You're the best!
|
|============== | 21%
| Now take a look at objects that are in your workspace using ls().
> ls()
[1] "x"
| Keep working like that and you'll get there!
|
|================ | 23%
| List all the files in your working directory using list.files() or dir().
> list.files()
[1] "Add-in Express" "Custom Office Templates"
[3] "desktop.ini" "My Music"
[5] "My Pictures" "My Videos"
[7] "OneNote Notebooks" "Power-user"
[9] "R" "R Directory"
[11] "Wondershare Filmora 9"
| That's a job well done!
|
|================== | 26%
| As we go through this lesson, you should be examining the help page for each
| new function. Check out the help page for list.files with the command
| ?list.files.
> ?list.files
starting httpd help server ... done
| Excellent job!
|
|==================== | 28%
| One of the most helpful parts of any R help file is the See Also section.
| Read that section for list.files. Some of these functions may be used in
| later portions of this lesson.
...
|
|====================== | 31%
| Using the args() function on a function name is also a handy way to see what
| arguments a function can take.
...args()
|
|======================= | 33%
| Use the args() function to determine the arguments to list.files().
> args()
Error in args() : argument "name" is missing, with no default
> args(list.files())
NULL
| One more time. You can do it! Or, type info() for more options.
| Type args(list.files) to see the arguments to list.files.
> args(list.files)
function (path = ".", pattern = NULL, all.files = FALSE,

full.names = FALSE, recursive = FALSE, ignore.case = FALSE,
include.dirs = FALSE, no.. = FALSE)
NULL
| All that hard work is paying off!
|
|========================= | 36%
| Assign the value of the current working directory to a variable called
| "old.dir".
> old.dir <- getwd()
| You are quite good my friend!
|
|=========================== | 38%
| We will use old.dir at the end of this lesson to move back to the place that
| we started. A lot of query functions like getwd() have the useful property
| that they return the answer to the question as a result of the function.
...
|
|============================= | 41%
| Use dir.create() to create a directory in the current working directory
| called "testdir".
> args(dir.create)
function (path, showWarnings = TRUE, recursive = FALSE, mode = "0777")

NULL
| Not quite right, but keep trying. Or, type info() for more options.
| Type dir.create("testdir") to create a directory in the current working
| directory called "testdir".
> dir.create("testdir")
| You are really on a roll!
|
|=============================== | 44%
| We will do all our work in this new directory and then delete it after we are
| done. This is the R analog to "Take only pictures, leave only footprints."
...
|
|================================ | 46%
| Set your working directory to "testdir" with the setwd() command.
> info(setwd)
Error in info(setwd) : unused argument (setwd)
> info("setwd")
Error in info("setwd") : unused argument ("setwd")
> info("setwd()")
Error in info("setwd()") : unused argument ("setwd()")
> setwd()
Error in setwd() : argument "dir" is missing, with no default

> setwd(testdir)
Error in setwd(testdir) : object 'testdir' not found
> setwd("testdir")
| Perseverance, that's the answer.
|
|================================== | 49%
| In general, you will want your working directory to be someplace sensible,
| perhaps created for the specific project that you are working on. In fact,
| organizing your work in R packages using RStudio is an excellent option.
| Check out RStudio at http://www.rstudio.com/
...
|
|==================================== | 51%
| Create a file in your working directory called "mytest.R" using the
| file.create() function.
> file.create("mytest.R")
[1] TRUE
|
|====================================== | 54%
| This should be the only file in this newly created directory. Let's check
| this by listing all the files in the current directory.

> list.files
function (path = ".", pattern = NULL, all.files = FALSE,
full.names = FALSE, recursive = FALSE, ignore.case = FALSE,
include.dirs = FALSE, no.. = FALSE)
.Internal(list.files(path, pattern, all.files, full.names, recursive,
ignore.case, include.dirs, no..))
<bytecode: 0x00000000149e9000>
<environment: namespace:base>
| Not quite! Try again. Or, type info() for more options.
| list.files() shows that the directory only contains mytest.R.
> list.files()
[1] "mytest.R"
| Your dedication is inspiring!
|
|======================================= | 56%
| Check to see if "mytest.R" exists in the working directory using the
| file.exists() function.
> file.exists(getwd())
[1] TRUE
| That's not the answer I was looking for, but try again. Or, type info() for
| more options.
| Use file.exists("mytest.R") to check that a file exists.

> file.exists("mytest.R")
[1] TRUE
|
|========================================= | 59%
| These sorts of functions are excessive for interactive use. But, if you are
| running a program that loops through a series of files and does some
| processing on each one, you will want to check to see that each exists before
| you try to process it.
...
|
|=========================================== | 62%
| Access information about the file "mytest.R" by using file.info().
> file.info("mytest.R")
size isdir mode mtime ctime
mytest.R 0 FALSE 666 2019-10-25 00:59:44 2019-10-25 00:59:44
atime exe
mytest.R 2019-10-25 00:59:44 no
|
|============================================= | 64%
| You can use the $ operator --- e.g., file.info("mytest.R")$mode --- to grab
| specific items.
...
|
|=============================================== | 67%
| Change the name of the file "mytest.R" to "mytest2.R" by using file.rename().
> ?file.rename
> file.rename("mytest.R","mytest2.R")
[1] TRUE
|
|================================================ | 69%
| Your operating system will provide simpler tools for these sorts of tasks,
| but having the ability to manipulate files programatically is useful. You
| might now try to delete mytest.R using file.remove('mytest.R'), but that
| won't work since mytest.R no longer exists. You have already renamed it.
...
|
|================================================== | 72%
| Make a copy of "mytest2.R" called "mytest3.R" using file.copy().
> file.copy("mytest2.R","mytest3.R")
[1] TRUE
| Great job!
|
|==================================================== | 74%
| You now have two files in the current directory. That may not seem very
| interesting. But what if you were working with dozens, or millions, of
| individual files? In that case, being able to programatically act on many
| files would be absolutely necessary. Don't forget that you can, temporarily,
| leave the lesson by typing play() and then return by typing nxt().
...
|
|====================================================== | 77%
| Provide the relative path to the file "mytest3.R" by using file.path().
> file.path("mytest.R")
[1] "mytest.R"
| file.path("mytest3.R") works.
> file.path("mytest3.R")
[1] "mytest3.R"
| Keep up the great work!
|
|======================================================== | 79%
| You can use file.path to construct file and directory paths that are
| independent of the operating system your R code is running on. Pass 'folder1'
| and 'folder2' as arguments to file.path to make a platform-independent
| pathname.
>
> file.path("folder1")
[1] "folder1"
| file.path("folder1", "folder2") works.
> file.path("folder1","folder2")
[1] "folder1/folder2"
| That's correct!
|
|========================================================= | 82%
| Take a look at the documentation for dir.create by entering ?dir.create .
| Notice the 'recursive' argument. In order to create nested directories,
| 'recursive' must be set to TRUE.
> ?dir.create
| You're the best!
|
|=========================================================== | 85%
| Create a directory in the current working directory called "testdir2" and a

| subdirectory for it called "testdir3", all in one command by using
| dir.create() and file.path().
> dir.create("testdir3")
| Not quite, but you're learning! Try again. Or, type info() for more options.
| dir.create(file.path('testdir2', 'testdir3'), recursive = TRUE) will do the
| trick. If you forgot the recursive argument, the command may have appeared to
| work, but it didn't create the nested directory.
> dir.create(file.path('testdir2','testdir3'),recursive = TRUE)
| Excellent job!
|
|============================================================= | 87%
| Go back to your original working directory using setwd(). (Recall that we
| created the variable old.dir with the full path for the orginal working
| directory at the start of these questions.)
> ..
Error: object '..' not found
> setwd("old.dir")
Error in setwd("old.dir") : cannot change working directory
> setwd(old.dir)

|
|=============================================================== | 90%
| It is often helpful to save the settings that you had before you began an
| analysis and then go back to them at the end. This trick is often used within
| functions; you save, say, the par() settings that you started with, mess
| around a bunch, and then set them back to the original values at the end.
| This isn't the same as what we have done here, but it seems similar enough to
| mention.
...
|
|================================================================= | 92%
| After you finish this lesson delete the 'testdir' directory that you just
| left (and everything in it)
...
|
|================================================================== | 95%
| Take nothing but results. Leave nothing but assumptions. That sounds like
| 'Take nothing but pictures. Leave nothing but footprints.' But it makes no
| sense! Surely our readers can come up with a better motto . . .
...
|
|==================================================================== | 97%
| In this lesson, you learned how to examine your R workspace and work with the
| file system of your machine from within R. Thanks for playing!

...
|
|======================================================================| 100%
| Would you like to receive credit for completing this course on Coursera.org?
1: No
2: Yes
Selection: 2
What is your email address? parasdhama1@gmail.com
What is your assignment token? EoMhGoLwqojZKx6p
Error in curl::curl_fetch_memory(url, handle = handle) :
Timeout was reached: [www.coursera.org] Operation timed out after 10002 milliseconds with 0 out
of 0 bytes received
| Leaving swirl now. Type swirl() to resume.
> 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? paras
| Would you like to continue with one of these lessons?
1: R Programming Workspace and Files
2: No. Let me start something new.

Selection: 1
1: No
2: Yes
Selection: 2
What is your assignment token? hwUUuUUm9nnM7Msw
Grade submission succeeded!
| Excellent job!
| You've reached the end of this lesson! Returning to the main menu...
1: R Programming
Selection: 1

15: Base Graphics
Selection: 3
|
| | 0%
| In this lesson, you'll learn how to create sequences of numbers in R.
...
|
|=== | 4%
| The simplest way to create a sequence of numbers in R is by using the `:`
| operator. Type 1:20 to see how it works.
> 1:20
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| Excellent work!
|
|====== | 9%
| That gave us every integer between (and including) 1 and 20. We could also
| use it to create a sequence of real numbers. For example, try pi:10.
> pi:10
[1] 3.141593 4.141593 5.141593 6.141593 7.141593 8.141593 9.141593
| You got it right!
|
|========= | 13%
| The result is a vector of real numbers starting with pi (3.142...) and
| increasing in increments of 1. The upper limit of 10 is never reached, since
| the next number in our sequence would be greater than 10.
...
|
|============ | 17%
| What happens if we do 15:1? Give it a try to find out.
> 15:1
[1] 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
| You're the best!
|
|=============== | 22%
| It counted backwards in increments of 1! It's unlikely we'd want this
| behavior, but nonetheless it's good to know how it could happen.
...
|
|================== | 26%
| Remember that if you have questions about a particular R function, you can
| access its documentation with a question mark followed by the function name:
| ?function_name_here. However, in the case of an operator like the colon used
| above, you must enclose the symbol in backticks like this: ?`:`. (NOTE: The
| backtick (`) key is generally located in the top left corner of a keyboard,
| above the Tab key. If you don't have a backtick key, you can use regular
| quotes.)
...
|
|===================== | 30%
| Pull up the documentation for `:` now.
> ?`:`
| You nailed it! Good job!
|
|======================== | 35%
| Often, we'll desire more control over a sequence we're creating than what the
| `:` operator gives us. The seq() function serves this purpose.
...
|
|=========================== | 39%
| The most basic use of seq() does exactly the same thing as the `:` operator.
| Try seq(1, 20) to see this.

> seq(1,20)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
|
|============================== | 43%
| This gives us the same output as 1:20. However, let's say that instead we
| want a vector of numbers ranging from 0 to 10, incremented by 0.5. seq(0, 10,
| by=0.5) does just that. Try it out.
> seq(0,10,by=0.5)
[1] 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0
[16] 7.5 8.0 8.5 9.0 9.5 10.0
| Great job!
|
|================================= | 48%
| Or maybe we don't care what the increment is and we just want a sequence of
| 30 numbers between 5 and 10. seq(5, 10, length=30) does the trick. Give it a
| shot now and store the result in a new variable called my_seq.
> my_seq = seq(5,10,length = 30)
| You're using the same function here, but changing its arguments for different
| results. Be sure to store the result in a new variable called my_seq, like
| this: my_seq <- seq(5, 10, length=30).

> my_seq <- seq(5,10,length = 30)
|
|===================================== | 52%
| To confirm that my_seq has length 30, we can use the length() function. Try
| it now.
> length(my_seq)
[1] 30
| All that practice is paying off!
|
|======================================== | 57%
| Let's pretend we don't know the length of my_seq, but we want to generate a
| sequence of integers from 1 to N, where N represents the length of the my_seq
| vector. In other words, we want a new vector (1, 2, 3, ...) that is the same
| length as my_seq.
...
|
|=========================================== | 61%
| There are several ways we could do this. One possibility is to combine the
| `:` operator and the length() function like this: 1:length(my_seq). Give that
| a try.
> 1:length(my_seq)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30
| You're the best!
|
|============================================== | 65%
| Another option is to use seq(along.with = my_seq). Give that a try.
> seq(along.with = my_seq)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30
| That's the answer I was looking for.
|
|================================================= | 70%
| However, as is the case with many common tasks, R has a separate built-in
| function for this purpose called seq_along(). Type seq_along(my_seq) to see
| it in action.
> seq_along(my_seq)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30
|
|==================================================== | 74%
| There are often several approaches to solving the same problem, particularly
| in R. Simple approaches that involve less typing are generally best. It's
| also important for your code to be readable, so that you and others can
| figure out what's going on without too much hassle.
...
|
|======================================================= | 78%
| If R has a built-in function for a particular task, it's likely that function
| is highly optimized for that purpose and is your best option. As you become a
| more advanced R programmer, you'll design your own functions to perform tasks
| when there are no better options. We'll explore writing your own functions in
| future lessons.
...
|
|========================================================== | 83%
| One more function related to creating sequences of numbers is rep(), which
| stands for 'replicate'. Let's look at a few uses.
...
|
|============================================================= | 87%
| If we're interested in creating a vector that contains 40 zeros, we can use
| rep(0, times = 40). Try it out.
> rep(0, imtes = 40)

[1] 0
| Not exactly. Give it another go. Or, type info() for more options.
| Type rep(0, times = 40) to make a vector containing 40 zeros.
> rep(0, times = 40)
[1] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
[39] 0 0
|
|================================================================ | 91%
| If instead we want our vector to contain 10 repetitions of the vector (0, 1,
| 2), we can do rep(c(0, 1, 2), times = 10). Go ahead.
> save.image("C:\\Users\\Paras Dhama\\Documents\\R Directory\\sequences")
| Try rep(c(0, 1, 2), times = 10) for a different variation on the same theme.
| Be sure to use the c() function to tell R that the numbers 0, 1, and 2 make
| up a vector.
> rep(c(0,1,2),times = 10)
[1] 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2

|
|=================================================================== | 96%
| Finally, let's say that rather than repeating the vector (0, 1, 2) over and
| over again, we want our vector to contain 10 zeros, then 10 ones, then 10
| twos. We can do this with the `each` argument. Try rep(c(0, 1, 2), each =
| 10).
> rep(c(0,1,2), each = 10)
[1] 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2
|
|======================================================================| 100%
1: No
2: Yes
Selection: yes
Enter an item from the menu, or 0 to exit
Selection: 2
What is your assignment token? KESllhbTEvNGBV8w
1: R Programming
Selection: 1
15: Base Graphics
Selection: 4
|
| | 0%
| The simplest and most common data structure in R is the vector.
...
|
|== | 3%
| Vectors come in two different flavors: atomic vectors and lists. An atomic
| vector contains exactly one data type, whereas a list may contain multiple
| data types. We'll explore atomic vectors further before we get to lists.
...
|
|==== | 5%
| In previous lessons, we dealt entirely with numeric vectors, which are one
| type of atomic vector. Other types of atomic vectors include logical,
| character, integer, and complex. In this lesson, we'll take a closer look at
| logical and character vectors.
...
|
|====== | 8%
| Logical vectors can contain the values TRUE, FALSE, and NA (for 'not
| available'). These values are generated as the result of logical
| 'conditions'. Let's experiment with some simple conditions.
...
|
|======= | 11%
| First, create a numeric vector num_vect that contains the values 0.5, 55,
| -10, and 6.
> num_vect <- c(0.5,55,-10,6)
| Excellent work!
|
|========= | 13%
| Now, create a variable called tf that gets the result of num_vect < 1, which
| is read as 'num_vect is less than 1'.
> tf <- num_vect<1
| You are doing so well!
|
|=========== | 16%
| What do you think tf will look like?
1: a single logical value
2: a vector of 4 logical values
Selection: 1
| Not quite right, but keep trying.
| Remember our lesson on vector arithmetic? The theme was that R performs many
| operations on an element-by-element basis. We called these 'vectorized'
| operations.
1: a vector of 4 logical values
2: a single logical value
Selection: 1
| You're the best!
|
|============= | 18%
| Print the contents of tf now.
> tf
[1] TRUE FALSE TRUE FALSE
|
|=============== | 21%
| The statement num_vect < 1 is a condition and tf tells us whether each
| corresponding element of our numeric vector num_vect satisfies this
| condition.
...
|
|================= | 24%
| The first element of num_vect is 0.5, which is less than 1 and therefore the
| statement 0.5 < 1 is TRUE. The second element of num_vect is 55, which is
| greater than 1, so the statement 55 < 1 is FALSE. The same logic applies for
| the third and fourth elements.
...
|
|================== | 26%
| Let's try another. Type num_vect >= 6 without assigning the result to a new
| variable.
> num_vect >=6
[1] FALSE TRUE FALSE TRUE
|
|==================== | 29%
| This time, we are asking whether each individual element of num_vect is
| greater than OR equal to 6. Since only 55 and 6 are greater than or equal to
| 6, the second and fourth elements of the result are TRUE and the first and
| third elements are FALSE.
...
|
|====================== | 32%
| The `<` and `>=` symbols in these examples are called 'logical operators'.
| Other logical operators include `>`, `<=`, `==` for exact equality, and `!=`
| for inequality.
...
|
|======================== | 34%
| If we have two logical expressions, A and B, we can ask whether at least one
| is TRUE with A | B (logical 'or' a.k.a. 'union') or whether they are both
| TRUE with A & B (logical 'and' a.k.a. 'intersection'). Lastly, !A is the

| negation of A and is TRUE when A is FALSE and vice versa.
...
|
|========================== | 37%
| It's a good idea to spend some time playing around with various combinations
| of these logical operators until you get comfortable with their use. We'll do
| a few examples here to get you started.
...
|
|============================ | 39%
| Try your best to predict the result of each of the following statements. You
| can use pencil and paper to work them out if it's helpful. If you get stuck,
| just guess and you've got a 50% chance of getting the right answer!
...
|
|============================= | 42%
| (3 > 5) & (4 == 4)
1: TRUE
2: FALSE
Selection: 2
| You're the best!

|
|=============================== | 45%
| (TRUE == TRUE) | (TRUE == FALSE)
1: FALSE
2: TRUE
Selection: 2
|
|================================= | 47%
| ((111 >= 111) | !(TRUE)) & ((4 + 1) == 5)
1: TRUE
2: FALSE
Selection: 2
| Nice try, but that's not exactly what I was hoping for. Try again.
| This is a tricky one. Remember that the `!` symbol negates whatever comes
| after it. There's also an 'order of operations' going on here. Conditions
| that are enclosed within parentheses should be evaluated first. Then, work
| your way outwards.
1: FALSE
2: TRUE
Selection: 1
| That's not exactly what I'm looking for. Try again.
| This is a tricky one. Remember that the `!` symbol negates whatever comes
| after it. There's also an 'order of operations' going on here. Conditions
| that are enclosed within parentheses should be evaluated first. Then, work
| your way outwards.
1: TRUE
2: FALSE
Selection: 1
| You're the best!
|
|=================================== | 50%
| Don't worry if you found these to be tricky. They're supposed to be. Working
| with logical statements in R takes practice, but your efforts will be
| rewarded in future lessons (e.g. subsetting and control structures).
...
|
|===================================== | 53%
| Character vectors are also very common in R. Double quotes are used to
| distinguish character objects, as in the following example.

...
|
|======================================= | 55%
| Create a character vector that contains the following words: "My", "name",
| "is". Remember to enclose each word in its own set of double quotes, so that
| R knows they are character strings. Store the vector in a variable called
| my_char.
> my_char <- c("My", "name", "is")
| Nice work!
|
|========================================= | 58%
| Print the contents of my_char to see what it looks like.
> my_char
[1] "My" "name" "is"
|
|========================================== | 61%
| Right now, my_char is a character vector of length 3. Let's say we want to
| join the elements of my_char together into one continuous character string
| (i.e. a character vector of length 1). We can do this using the paste()
| function.
...
|
|============================================ | 63%
| Type paste(my_char, collapse = " ") now. Make sure there's a space between
| the double quotes in the `collapse` argument. You'll see why in a second.
> paste(my_char, collapse = " ")
[1] "My name is"
|
|============================================== | 66%
| The `collapse` argument to the paste() function tells R that when we join
| together the elements of the my_char character vector, we'd like to separate
| them with single spaces.
...
|
|================================================ | 68%
| It seems that we're missing something.... Ah, yes! Your name!
...
|
|================================================== | 71%
| To add (or 'concatenate') your name to the end of my_char, use the c()
| function like this: c(my_char, "your_name_here"). Place your name in double
| quotes where I've put "your_name_here". Try it now, storing the result in a
| new variable called my_name.
> my_name <- c(my_char, "paras")
|
|==================================================== | 74%
| Take a look at the contents of my_name.
> my_name
[1] "My" "name" "is" "paras"
|
|===================================================== | 76%
| Now, use the paste() function once more to join the words in my_name together
| into a single character string. Don't forget to say collapse = " "!
> paste(my_name, collapse = " ")
[1] "My name is paras"
|
|======================================================= | 79%
| In this example, we used the paste() function to collapse the elements of a
| single character vector. paste() can also be used to join the elements of
| multiple character vectors.

...
|
|========================================================= | 82%
| In the simplest case, we can join two character vectors that are each of
| length 1 (i.e. join two words). Try paste("Hello", "world!", sep = " "),
| where the `sep` argument tells R that we want to separate the joined elements
| with a single space.
> paste("Hello", "world!", sep = " ")
[1] "Hello world!"
|
|=========================================================== | 84%
| For a slightly more complicated example, we can join two vectors, each of
| length 3. Use paste() to join the integer vector 1:3 with the character
| vector c("X", "Y", "Z"). This time, use sep = "" to leave no space between
| the joined elements.
> paste(1:3, "X", "Y", "Z")
[1] "1 X Y Z" "2 X Y Z" "3 X Y Z"
| Use paste(1:3, c("X", "Y", "Z"), sep = "") to see what happens when we join
| two vectors of equal length using paste().

> paste(c(1:3), "X", "Y", "Z")
[1] "1 X Y Z" "2 X Y Z" "3 X Y Z"
> paste(c(1:3), c("X", "Y", "Z"))
[1] "1 X" "2 Y" "3 Z"
| more options.
> paste(1:3, c("X", "Y", "Z"))
[1] "1 X" "2 Y" "3 Z"
| That's not exactly what I'm looking for. Try again. Or, type info() for more
| options.
> paste(1:3, c("X", "Y", "Z"), sep = "")
[1] "1X" "2Y" "3Z"

|
|============================================================= | 87%
| What do you think will happen if our vectors are of different length? (Hint:
| we talked about this in a previous lesson.)
...
|
|=============================================================== | 89%
| Vector recycling! Try paste(LETTERS, 1:4, sep = "-"), where LETTERS is a
| predefined variable in R containing a character vector of all 26 letters in
| the English alphabet.
> paste(LETTERS, 1:4, sep = "-")
[1] "A-1" "B-2" "C-3" "D-4" "E-1" "F-2" "G-3" "H-4" "I-1" "J-2" "K-3" "L-4"
[13] "M-1" "N-2" "O-3" "P-4" "Q-1" "R-2" "S-3" "T-4" "U-1" "V-2" "W-3" "X-4"
[25] "Y-1" "Z-2"
|
|================================================================ | 92%
| Since the character vector LETTERS is longer than the numeric vector 1:4, R
| simply recycles, or repeats, 1:4 until it matches the length of LETTERS.
...
|
|================================================================== | 95%
| Also worth noting is that the numeric vector 1:4 gets 'coerced' into a
| character vector by the paste() function.
...
|
|==================================================================== | 97%
| We'll discuss coercion in another lesson, but all it really means is that the
| numbers 1, 2, 3, and 4 in the output above are no longer numbers to R, but
| rather characters "1", "2", "3", and "4".
...
|
|======================================================================| 100%
1: No
2: Yes
Selection: yes
Selection: 2
What is your assignment token? KE83rUaRYLqCq9mi
1: R Programming
Selection: 1
15: Base Graphics
Selection: 5
|
| | 0%
| Missing values play an important role in statistics and data analysis. Often,
| missing values must not be ignored, but rather they should be carefully
| studied to see if there's an underlying pattern or cause for their
| missingness.
...
|
|==== | 5%
| In R, NA is used to represent any value that is 'not available' or 'missing'
| (in the statistical sense). In this lesson, we'll explore missing values
| further.
...
|
|======= | 10%
| Any operation involving NA generally yields NA as the result. To illustrate,
| let's create a vector c(44, NA, 5, NA) and assign it to a variable x.
> x <- c(44,NA,5,NA)
|
|=========== | 15%
| Now, let's multiply x by 3.
> x*3
[1] 132 NA 15 NA
|
|============== | 20%
| Notice that the elements of the resulting vector that correspond with the NA
| values in x are also NA.

...
|
|================== | 25%
| To make things a little more interesting, lets create a vector containing
| 1000 draws from a standard normal distribution with y <- rnorm(1000).
> y <- rnorm(1000)
|
|===================== | 30%
| Next, let's create a vector containing 1000 NAs with z <- rep(NA, 1000).
> z<- rep(NA,1000)
| You got it right!
|
|========================= | 35%
| Finally, let's select 100 elements at random from these 2000 values
| (combining y and z) such that we don't know how many NAs we'll wind up with
| or what positions they'll occupy in our final vector -- my_data <-
| sample(c(y, z), 100).
> my_data <- sample(c(y,z),100)

|
|============================ | 40%
| Let's first ask the question of where our NAs are located in our data. The
| is.na() function tells us whether each element of a vector is NA. Call
| is.na() on my_data and assign the result to my_na.
> my_na <- is.na(my_data)
|
|================================ | 45%
| Now, print my_na to see what you came up with.
> my_na
[1] FALSE FALSE TRUE FALSE TRUE TRUE FALSE FALSE FALSE TRUE TRUE TRUE
[13] TRUE TRUE FALSE FALSE TRUE FALSE FALSE TRUE TRUE FALSE FALSE FALSE
[25] FALSE FALSE FALSE TRUE TRUE TRUE FALSE TRUE TRUE FALSE FALSE FALSE
[37] TRUE TRUE TRUE TRUE TRUE FALSE TRUE TRUE TRUE TRUE TRUE TRUE
[49] FALSE FALSE FALSE TRUE FALSE TRUE TRUE FALSE TRUE TRUE TRUE TRUE
[61] FALSE FALSE TRUE FALSE TRUE FALSE TRUE TRUE TRUE TRUE FALSE TRUE
[73] TRUE TRUE TRUE TRUE FALSE TRUE FALSE TRUE TRUE FALSE FALSE FALSE
[85] FALSE TRUE FALSE TRUE TRUE TRUE FALSE FALSE FALSE FALSE TRUE FALSE
[97] FALSE TRUE TRUE TRUE
|
|=================================== | 50%
| Everywhere you see a TRUE, you know the corresponding element of my_data is
| NA. Likewise, everywhere you see a FALSE, you know the corresponding element
| of my_data is one of our random draws from the standard normal distribution.
...
|
|====================================== | 55%
| In our previous discussion of logical operators, we introduced the `==`
| operator as a method of testing for equality between two objects. So, you
| might think the expression my_data == NA yields the same results as is.na().
| Give it a try.
> my
Error: object 'my' not found
> my
Error: object 'my' not found
> my_data == NA
[1] NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA
| You're the best!
|
|========================================== | 60%
| The reason you got a vector of all NAs is that NA is not really a value, but
| just a placeholder for a quantity that is not available. Therefore the
| logical expression is incomplete and R has no choice but to return a vector

| of the same length as my_data that contains all NAs.
...
|
|============================================== | 65%
| Don't worry if that's a little confusing. The key takeaway is to be cautious
| when using logical expressions anytime NAs might creep in, since a single NA
| value can derail the entire thing.
...
|
|================================================= | 70%
| So, back to the task at hand. Now that we have a vector, my_na, that has a
| TRUE for every NA and FALSE for every numeric value, we can compute the total
| number of NAs in our data.
...
|
|==================================================== | 75%
| The trick is to recognize that underneath the surface, R represents TRUE as
| the number 1 and FALSE as the number 0. Therefore, if we take the sum of a
| bunch of TRUEs and FALSEs, we get the total number of TRUEs.
...
|
|======================================================== | 80%
| Let's give that a try here. Call the sum() function on my_na to count the
| total number of TRUEs in my_na, and thus the total number of NAs in my_data.
| Don't assign the result to a new variable.
> sum(my_na)
[1] 56
| Nice work!
|
|============================================================ | 85%
| Pretty cool, huh? Finally, let's take a look at the data to convince
| ourselves that everything 'adds up'. Print my_data to the console.
> my_data
[1] 0.66994987 -0.73889150 NA 1.93922350 NA NA
[7] -0.58942884 -1.23273096 2.79492507 NA NA NA
[13] NA NA -1.99712835 0.44378930 NA 0.95137103
[19] 0.20457424 NA NA -0.84241763 1.43326940 0.75307916
[25] -1.79058295 -0.28484466 -0.88542310 NA NA NA
[31] -1.05878510 NA NA -0.28858383 0.27931180 1.27614407
[37] NA NA NA NA NA 2.50670961
[43] NA NA NA NA NA NA
[49] -0.35519570 1.74724116 0.07100943 NA -0.30674160 NA
[55] NA -0.83728019 NA NA NA NA
[61] -0.21579677 0.18783916 NA -1.09952810 NA 1.46404312
[67] NA NA NA NA -0.52111371 NA
[73] NA NA NA NA 0.40754269 NA
[79] 0.02350444 NA NA -0.49446657 -0.20605674 1.80054334
[85] 0.30054164 NA -0.04960923 NA NA NA
[91] -0.60862007 -0.05518489 -0.27115256 0.68661771 NA 0.57213622

[97] -0.61638772 NA NA NA
|
|=============================================================== | 90%
| Now that we've got NAs down pat, let's look at a second type of missing value
| -- NaN, which stands for 'not a number'. To generate NaN, try dividing (using
| a forward slash) 0 by 0 now.
> 0/0
[1] NaN
|
|================================================================== | 95%
| Let's do one more, just for fun. In R, Inf stands for infinity. What happens
| if you subtract Inf from Inf?
> Inf-Inf
[1] NaN
|
|======================================================================| 100%
1: Yes
2: No
Selection: 1
What is your assignment token? F5D9t0bzjS0RR4zk
1: R Programming
Selection: 1
15: Base Graphics
Selection: 6
|
| | 0%
| In this lesson, we'll see how to extract elements from a vector based on some
| conditions that we specify.
...
|
|== | 3%
| For example, we may only be interested in the first 20 elements of a vector,
| or only the elements that are not NA, or only those that are positive or
| correspond to a specific variable of interest. By the end of this lesson,
| you'll know how to handle each of these scenarios.
...
|
|==== | 5%
| I've created for you a vector called x that contains a random ordering of 20
| numbers (from a standard normal distribution) and 20 NAs. Type x now to see
| what it looks like.
>x
[1] NA 0.810871714 NA NA 0.113029419
[6] -0.037985255 NA 0.970165249 1.676377240 -0.638148997
[11] NA NA 0.870245551 0.497840488 NA
[16] NA NA NA 0.695277418 -0.007839292
[21] -0.067661834 NA NA NA NA
[26] NA 0.031770282 -1.352238702 0.256095104 NA

[31] 0.224212993 0.531983846 NA NA -0.395985685
[36] NA -0.222017514 NA 0.400979326 -0.494050466
|
|===== | 8%
| The way you tell R that you want to select some particular elements (i.e. a
| 'subset') from a vector is by placing an 'index vector' in square brackets
| immediately following the name of the vector.
...
|
|======= | 10%
| For a simple example, try x[1:10] to view the first ten elements of x.
> x[1:10]
[1] NA 0.81087171 NA NA 0.11302942 -0.03798525
[7] NA 0.97016525 1.67637724 -0.63814900
|
|========= | 13%
| Index vectors come in four different flavors -- logical vectors, vectors of
| positive integers, vectors of negative integers, and vectors of character
| strings -- each of which we'll cover in this lesson.
...
|
|=========== | 15%
| Let's start by indexing with logical vectors. One common scenario when
| working with real-world data is that we want to extract all elements of a
| vector that are not NA (i.e. missing data). Recall that is.na(x) yields a
| vector of logical values the same length as x, with TRUEs corresponding to NA
| values in x and FALSEs corresponding to non-NA values in x.
...
|
|============= | 18%
| What do you think x[is.na(x)] will give you?
1: A vector of all NAs
2: A vector with no NAs
3: A vector of TRUEs and FALSEs
4: A vector of length 0
Selection: 1
|
|============== | 21%
| Prove it to yourself by typing x[is.na(x)].
> x[is.na(x)]
[1] NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA
| Great job!
|
|================ | 23%
| Recall that `!` gives us the negation of a logical expression, so !is.na(x)
| can be read as 'is not NA'. Therefore, if we want to create a vector called y
| that contains all of the non-NA values from x, we can use y <- x[!is.na(x)].
| Give it a try.
> x[!is.na(x)]
[1] 0.810871714 0.113029419 -0.037985255 0.970165249 1.676377240
[6] -0.638148997 0.870245551 0.497840488 0.695277418 -0.007839292
[11] -0.067661834 0.031770282 -1.352238702 0.256095104 0.224212993
[16] 0.531983846 -0.395985685 -0.222017514 0.400979326 -0.494050466
| Keep trying! Or, type info() for more options.
| Type y <- x[!is.na(x)] to capture all non-missing values from x.
> y <- x[!is.na(x)]
| You got it right!
|
|================== | 26%
| Print y to the console.
>y
[1] 0.810871714 0.113029419 -0.037985255 0.970165249 1.676377240

[6] -0.638148997 0.870245551 0.497840488 0.695277418 -0.007839292
[11] -0.067661834 0.031770282 -1.352238702 0.256095104 0.224212993
[16] 0.531983846 -0.395985685 -0.222017514 0.400979326 -0.494050466
|
|==================== | 28%
| Now that we've isolated the non-missing values of x and put them in y, we can
| subset y as we please.
...
|
|====================== | 31%
| Recall that the expression y > 0 will give us a vector of logical values the
| same length as y, with TRUEs corresponding to values of y that are greater
| than zero and FALSEs corresponding to values of y that are less than or equal
| to zero. What do you think y[y > 0] will give you?
1: A vector of all the negative elements of y
2: A vector of length 0
3: A vector of all NAs
4: A vector of all the positive elements of y
5: A vector of TRUEs and FALSEs
Selection: 4
| You got it!

|
|======================= | 33%
| Type y[y > 0] to see that we get all of the positive elements of y, which are
| also the positive elements of our original vector x.
> y[y>0]
[1] 0.81087171 0.11302942 0.97016525 1.67637724 0.87024555 0.49784049
[7] 0.69527742 0.03177028 0.25609510 0.22421299 0.53198385 0.40097933
| Excellent job!
|
|========================= | 36%
| You might wonder why we didn't just start with x[x > 0] to isolate the
| positive elements of x. Try that now to see why.
> x[x>0]
[1] NA 0.81087171 NA NA 0.11302942 NA
[7] 0.97016525 1.67637724 NA NA 0.87024555 0.49784049
[13] NA NA NA NA 0.69527742 NA
[19] NA NA NA NA 0.03177028 0.25609510
[25] NA 0.22421299 0.53198385 NA NA NA
[31] NA 0.40097933
|
|=========================== | 38%
| Since NA is not a value, but rather a placeholder for an unknown quantity,
| the expression NA > 0 evaluates to NA. Hence we get a bunch of NAs mixed in
| with our positive numbers when we do this.
...
|
|============================= | 41%
| Combining our knowledge of logical operators with our new knowledge of
| subsetting, we could do this -- x[!is.na(x) & x > 0]. Try it out.
> x[!is.na(x) & x>0 ]
[1] 0.81087171 0.11302942 0.97016525 1.67637724 0.87024555 0.49784049
[7] 0.69527742 0.03177028 0.25609510 0.22421299 0.53198385 0.40097933
|
|=============================== | 44%
| In this case, we request only values of x that are both non-missing AND
| greater than zero.
...
|
|================================ | 46%
| I've already shown you how to subset just the first ten values of x using
| x[1:10]. In this case, we're providing a vector of positive integers inside
| of the square brackets, which tells R to return only the elements of x
| numbered 1 through 10.
...
|
|================================== | 49%
| Many programming languages use what's called 'zero-based indexing', which
| means that the first element of a vector is considered element 0. R uses
| 'one-based indexing', which (you guessed it!) means the first element of a
| vector is considered element 1.
...
|
|==================================== | 51%
| Can you figure out how we'd subset the 3rd, 5th, and 7th elements of x? Hint
| -- Use the c() function to specify the element numbers as a numeric vector.
> c(x[3],x[5],x[7])
[1] NA 0.1130294 NA
| Create a vector of indexes with c(3, 5, 7), then put that inside of the
| square brackets.
> c(3,5,7)
[1] 3 5 7
| Nice try, but that's not exactly what I was hoping for. Try again. Or, type
| info() for more options.
| square brackets.
> info()
| When you are at the R prompt (>):
| -- Typing skip() allows you to skip the current question.
| -- Typing play() lets you experiment with R on your own; swirl will ignore
| what you do...
| -- UNTIL you type nxt() which will regain swirl's attention.
| -- Typing bye() causes swirl to exit. Your progress will be saved.
| -- Typing main() returns you to swirl's main menu.
| -- Typing info() displays these options again.
> c(x[3],x[5],x[7])
[1] NA 0.1130294 NA
| You're close...I can feel it! Try it again. Or, type info() for more options.
| square brackets.
> c(x[3],x[5],x[7])
[1] NA 0.1130294 NA
| square brackets.
> c(x[3],x[5],x[7])
[1] NA 0.1130294 NA
| options.
| square brackets.
> c(y[3],y[5],y[7])
[1] -0.03798525 1.67637724 0.87024555
| Almost! Try again. Or, type info() for more options.
| square brackets.
> x[c(3,5,7)]
[1] NA 0.1130294 NA
|
|====================================== | 54%
| It's important that when using integer vectors to subset our vector x, we
| stick with the set of indexes {1, 2, ..., 40} since x only has 40 elements.
| What happens if we ask for the zeroth element of x (i.e. x[0])? Give it a
| try.
> x[0]
numeric(0)

|
|======================================= | 56%
| As you might expect, we get nothing useful. Unfortunately, R doesn't prevent
| us from doing this. What if we ask for the 3000th element of x? Try it out.
> x[3000]
[1] NA
|
|========================================= | 59%
| Again, nothing useful, but R doesn't prevent us from asking for it. This
| should be a cautionary tale. You should always make sure that what you are
| asking for is within the bounds of the vector you're working with.
...
|
|=========================================== | 62%
| What if we're interested in all elements of x EXCEPT the 2nd and 10th? It
| would be pretty tedious to construct a vector containing all numbers 1
| through 40 EXCEPT 2 and 10.
...
|
|============================================= | 64%
| Luckily, R accepts negative integer indexes. Whereas x[c(2, 10)] gives us

| ONLY the 2nd and 10th elements of x, x[c(-2, -10)] gives us all elements of x
| EXCEPT for the 2nd and 10 elements. Try x[c(-2, -10)] now to see this.
> x[c(-2,-10)]
[1] NA NA NA 0.113029419 -0.037985255
[6] NA 0.970165249 1.676377240 NA NA
[11] 0.870245551 0.497840488 NA NA NA
[16] NA 0.695277418 -0.007839292 -0.067661834 NA
[21] NA NA NA NA 0.031770282
[26] -1.352238702 0.256095104 NA 0.224212993 0.531983846
[31] NA NA -0.395985685 NA -0.222017514
[36] NA 0.400979326 -0.494050466
| Excellent work!
|
|=============================================== | 67%
| A shorthand way of specifying multiple negative numbers is to put the
| negative sign out in front of the vector of positive numbers. Type x[-c(2,
| 10)] to get the exact same result.
> x[-c(2,10)]
[1] NA NA NA 0.113029419 -0.037985255
[6] NA 0.970165249 1.676377240 NA NA
[11] 0.870245551 0.497840488 NA NA NA
[16] NA 0.695277418 -0.007839292 -0.067661834 NA
[21] NA NA NA NA 0.031770282
[26] -1.352238702 0.256095104 NA 0.224212993 0.531983846
[31] NA NA -0.395985685 NA -0.222017514
[36] NA 0.400979326 -0.494050466

|
|================================================ | 69%
| So far, we've covered three types of index vectors -- logical, positive
| integer, and negative integer. The only remaining type requires us to
| introduce the concept of 'named' elements.
...
|
|================================================== | 72%
| Create a numeric vector with three named elements using vect <- c(foo = 11,
| bar = 2, norf = NA).
> vect <- c(foo=11,bar = 2, norf = NA)
|
|==================================================== | 74%
| When we print vect to the console, you'll see that each element has a name.
| Try it out.
> vect
foo bar norf
11 2 NA

|
|====================================================== | 77%
| We can also get the names of vect by passing vect as an argument to the
| names() function. Give that a try.
> names(vect)
[1] "foo" "bar" "norf"
| Nice work!
|
|======================================================== | 79%
| Alternatively, we can create an unnamed vector vect2 with c(11, 2, NA). Do
| that now.
> vect2 <- c(11,2,NA)
| You got it right!
|
|========================================================= | 82%
| Then, we can add the `names` attribute to vect2 after the fact with
| names(vect2) <- c("foo", "bar", "norf"). Go ahead.
> names
function (x) .Primitive("names")
| Almost! Try again. Or, type info() for more options.
| Add names to vect2 with names(vect2) <- c("foo", "bar", "norf").

> names(vect2)
NULL
| You almost had it, but not quite. Try again. Or, type info() for more
| options.
| Add names to vect2 with names(vect2) <- c("foo", "bar", "norf").
> names(vect2) <- c("foo","bar","norf")
| You got it right!
|
|=========================================================== | 85%
| Now, let's check that vect and vect2 are the same by passing them as
| arguments to the identical() function.
> identical(vect2)
Error in identical(vect2) : argument "y" is missing, with no default
> identical("vect2")
Error in identical("vect2") : argument "y" is missing, with no default
> identical("vect","vect2")
[1] FALSE
| options.
| The identical() function tells us if its first two arguments are, well,
| identical.
> identical(vect,vect2)
[1] TRUE
|
|============================================================= | 87%
| Indeed, vect and vect2 are identical named vectors.
...
|
|=============================================================== | 90%
| Now, back to the matter of subsetting a vector by named elements. Which of
| the following commands do you think would give us the second element of vect?
1: vect["bar"]
2: vect[bar]
3: vect["2"]
Selection: 1
| You're the best!
|
|================================================================= | 92%
| Now, try it out.
> vect["bar"]
bar
2
|
|================================================================== | 95%
| Likewise, we can specify a vector of names with vect[c("foo", "bar")]. Try it
| out.
> vect[c("foo","bar")]
foo bar
11 2
| You got it!
|
|==================================================================== | 97%
| Now you know all four methods of subsetting data from vectors. Different
| approaches are best in different scenarios and when in doubt, try it out!
...
|
|======================================================================| 100%
1: Yes
2: No
Selection: 1
What is your assignment token? zDhoTo4p6ULnjExT
1: R Programming
Selection: 1
15: Base Graphics
Selection: 7
|
| | 0%
| In this lesson, we'll cover matrices and data frames. Both represent
| 'rectangular' data types, meaning that they are used to store tabular data,
| with rows and columns.
...
|
|== | 3%
| The main difference, as you'll see, is that matrices can only contain a
| single class of data, while data frames can consist of many different classes
| of data.
...
|
|==== | 6%
| Let's create a vector containing the numbers 1 through 20 using the `:`
| operator. Store the result in a variable called my_vector.
> my_vector <- 1:20
| You got it right!
|
|====== | 8%
| View the contents of the vector you just created.
> my_vector
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
|
|======== | 11%
| The dim() function tells us the 'dimensions' of an object. What happens if we
| do dim(my_vector)? Give it a try.
> dim(my_vector)
NULL
| You got it!
|
|========== | 14%
| Clearly, that's not very helpful! Since my_vector is a vector, it doesn't
| have a `dim` attribute (so it's just NULL), but we can find its length using
| the length() function. Try that now.
> length(my_vector)
[1] 20
|
|============ | 17%
| Ah! That's what we wanted. But, what happens if we give my_vector a `dim`
| attribute? Let's give it a try. Type dim(my_vector) <- c(4, 5).
> dim(my_vector) <- c(4,5)

|
|============== | 19%
| It's okay if that last command seemed a little strange to you. It should! The
| dim() function allows you to get OR set the `dim` attribute for an R object.
| In this case, we assigned the value c(4, 5) to the `dim` attribute of
| my_vector.
...
|
|================ | 22%
| Use dim(my_vector) to confirm that we've set the `dim` attribute correctly.
> dim(my_vector)
[1] 4 5
| You are amazing!
|
|================== | 25%
| Another way to see this is by calling the attributes() function on my_vector.
| Try it now.
> attributes(my_vector)
$dim
[1] 4 5
|
|=================== | 28%
| Just like in math class, when dealing with a 2-dimensional object (think
| rectangular table), the first number is the number of rows and the second is
| the number of columns. Therefore, we just gave my_vector 4 rows and 5
| columns.
...
|
|===================== | 31%
| But, wait! That doesn't sound like a vector any more. Well, it's not. Now
| it's a matrix. View the contents of my_vector now to see what it looks like.
> my_vector
[,1] [,2] [,3] [,4] [,5]
[1,] 1 5 9 13 17
[2,] 2 6 10 14 18
[3,] 3 7 11 15 19
[4,] 4 8 12 16 20
|
|======================= | 33%
| Now, let's confirm it's actually a matrix by using the class() function. Type
| class(my_vector) to see what I mean.

> class(my_vector)
[1] "matrix"
|
|========================= | 36%
| Sure enough, my_vector is now a matrix. We should store it in a new variable
| that helps us remember what it is. Store the value of my_vector in a new
| variable called my_matrix.
> my_matrix <-my_vector
| You got it!
|
|=========================== | 39%
| The example that we've used so far was meant to illustrate the point that a
| matrix is simply an atomic vector with a dimension attribute. A more direct
| method of creating the same matrix uses the matrix() function.
...
|
|============================= | 42%
| Bring up the help file for the matrix() function now using the `?` function.
> ?matrix
| That's correct!
|
|=============================== | 44%
| Now, look at the documentation for the matrix function and see if you can
| figure out how to create a matrix containing the same numbers (1-20) and
| dimensions (4 rows, 5 columns) by calling the matrix() function. Store the
| result in a variable called my_matrix2.
> my_matrix2 <- matrix(data = 1:20, nrow = 4, ncol = 5)
|
|================================= | 47%
| Finally, let's confirm that my_matrix and my_matrix2 are actually identical.
| The identical() function will tell us if its first two arguments are the
| same. Try it out.
> identical(my_matrix, mymatrix2)
Error in identical(my_matrix, mymatrix2) : object 'mymatrix2' not found
> identical(my_matrix, my_matrix2)
[1] TRUE
| Excellent job!
|
|=================================== | 50%
| Now, imagine that the numbers in our table represent some measurements from a
| clinical experiment, where each row represents one patient and each column
| represents one variable for which measurements were taken.

...
|
|===================================== | 53%
| We may want to label the rows, so that we know which numbers belong to each
| patient in the experiment. One way to do this is to add a column to the
| matrix, which contains the names of all four people.
...
|
|======================================= | 56%
| Let's start by creating a character vector containing the names of our
| patients -- Bill, Gina, Kelly, and Sean. Remember that double quotes tell R
| that something is a character string. Store the result in a variable called
| patients.
> patients <- c("Bill", "Gina", "Kelly", "Sean")
| You're the best!
|
|========================================= | 58%
| Now we'll use the cbind() function to 'combine columns'. Don't worry about
| storing the result in a new variable. Just call cbind() with two arguments --
| the patients vector and my_matrix.
> cbin(pateints, my_matrix)
Error in cbin(pateints, my_matrix) : could not find function "cbin"

> cbind(pateints, my_matrix)
Error in cbind(pateints, my_matrix) : object 'pateints' not found
> cbind(patients, my_matrix)
patients
[1,] "Bill" "1" "5" "9" "13" "17"
[2,] "Gina" "2" "6" "10" "14" "18"
[3,] "Kelly" "3" "7" "11" "15" "19"
[4,] "Sean" "4" "8" "12" "16" "20"
| That's correct!
|
|=========================================== | 61%
| Something is fishy about our result! It appears that combining the character
| vector with our matrix of numbers caused everything to be enclosed in double
| quotes. This means we're left with a matrix of character strings, which is no
| good.
...
|
|============================================= | 64%
| If you remember back to the beginning of this lesson, I told you that
| matrices can only contain ONE class of data. Therefore, when we tried to
| combine a character vector with a numeric matrix, R was forced to 'coerce'
| the numbers to characters, hence the double quotes.
...
|
|=============================================== | 67%
| This is called 'implicit coercion', because we didn't ask for it. It just
| happened. But why didn't R just convert the names of our patients to numbers?
| I'll let you ponder that question on your own.
...
|
|================================================= | 69%
| So, we're still left with the question of how to include the names of our
| patients in the table without destroying the integrity of our numeric data.
| Try the following -- my_data <- data.frame(patients, my_matrix)
> my_data <- data.frame(patients, my_matrix)
|
|=================================================== | 72%
| Now view the contents of my_data to see what we've come up with.
> my_data
patients X1 X2 X3 X4 X5
1 Bill 1 5 9 13 17
2 Gina 2 6 10 14 18
3 Kelly 3 7 11 15 19
4 Sean 4 8 12 16 20

|
|==================================================== | 75%
| It looks like the data.frame() function allowed us to store our character
| vector of names right alongside our matrix of numbers. That's exactly what we
| were hoping for!
...
|
|====================================================== | 78%
| Behind the scenes, the data.frame() function takes any number of arguments
| and returns a single object of class `data.frame` that is composed of the
| original objects.
...
|
|======================================================== | 81%
| Let's confirm this by calling the class() function on our newly created data
| frame.
> class(data_frame)
Error: object 'data_frame' not found
> class(my_data)
[1] "data.frame"
| Nice work!
|
|========================================================== | 83%
| It's also possible to assign names to the individual rows and columns of a
| data frame, which presents another possible way of determining which row of
| values in our table belongs to each patient.
...
|
|============================================================ | 86%
| However, since we've already solved that problem, let's solve a different
| problem by assigning names to the columns of our data frame so that we know
| what type of measurement each column represents.
...
|
|============================================================== | 89%
| Since we have six columns (including patient names), we'll need to first
| create a vector containing one element for each column. Create a character
| vector called cnames that contains the following values (in order) --
| "patient", "age", "weight", "bp", "rating", "test".
> cnames <- c("patient", "age", "weight", "bp", "rating", "test")
| You got it right!
|
|================================================================ | 92%
| Now, use the colnames() function to set the `colnames` attribute for our data
| frame. This is similar to the way we used the dim() function earlier in this
| lesson.
> colnames(cnames)
NULL
| more options.
| Try colnames(my_data) <- cnames.
> colnames(my_data) <-cnames
| Nice work!
|
|================================================================== | 94%
| Let's see if that got the job done. Print the contents of my_data.
> my_data
patient age weight bp rating test
1 Bill 1 5 9 13 17
2 Gina 2 6 10 14 18
3 Kelly 3 7 11 15 19
4 Sean 4 8 12 16 20
|
|==================================================================== | 97%
| In this lesson, you learned the basics of working with two very important and
| common data structures -- matrices and data frames. There's much more to
| learn and we'll be covering more advanced topics, particularly with respect
| to data frames, in future lessons.
...
|
|======================================================================| 100%
1: No
2: Yes
Selection: yes
Selection: 2
What is your assignment token? 0EJozntiY5TyKpDx
| Great job!
1: R Programming

R Programming Swirl

Uploaded by

Copyright:

Available Formats

R Programming Swirl

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

R Programming Swirl

Uploaded by

Copyright:

Available Formats

R version 3.6.

1 (2019-07-05) -- "Action of the Toes"

Copyright (C) 2019 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.

Natural language support but running in an English locale

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.

Error in swirl() : could not find function "swirl"

Error in swirl() : could not find function "swirl"

Installing package into ‘C:/Users/Paras Dhama/Documents/R/win-library/3.6’

(as ‘lib’ is unspecified)

trying URL 'https://cloud.r-project.org/bin/windows/contrib/3.6/swirl_2.4.4.zip'

Content type 'application/zip' length 350179 bytes (341 KB)

The downloaded binary packages are in

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

What shall I call you? paras

| Thanks, paras. Let's cover a couple of quick housekeeping items before we

... <-- That's your cue to press Enter to continue

Select 1, 2, or 3 and press Enter

3: Let's get going!

| you've done so.

| When you are at the R prompt (>):

| -- Typing skip() allows you to skip the current question.

| what you do...

| -- UNTIL you type nxt() which will regain swirl's attention.

| -- Typing bye() causes swirl to exit. Your progress will be saved.

| -- Typing main() returns you to swirl's main menu.

| -- Typing info() displays these options again.

| Let's get started!

| internet, or I can send you to a web page

| (https://github.com/swirldev/swirl_courses) which will provide course options

| the internet, type 0 to exit.)

1: R Programming: The basics of programming in R

2: Regression Models: The basics of regression modeling in R

4: Exploratory Data Analysis: The basics of exploring data in R

5: Don't install anything for me. I'll do it myself.

| Course installed successfully!

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

| 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

| Because different operating systems have different conventions with regards

| different kinds of computers.

| Determine which directory your R session is using as its current working

| directory using getwd().

[1] "C:/Users/Paras Dhama/Documents"