Find online courses made by experts from around the world.
Take your courses with you and learn anywhere, anytime.
Learn and practice realworld skills and achieve your goals.
Extra Fundamentals of R is an extension of the Udemy course Essential Fundamentals of R. Extra Fundamentals of R introduces additional topics of interest and relevance utilizing many specific Rscripted examples. These broad topics include:
(1) Details on using Base, GGPlot and Lattice graphics;
(2) An introduction to programming and simulation in R; and
(3) Character and string processing in R.
All materials, scripts, slides, documentation and anything used or viewed in any one of the video lessons is provided with the course. The course is useful for both Rnovices, as well as to intermediate R users. Rather than focus on specific and narrow Rsupported skill sets, the course paints a broad canvas illustrating many specific examples in three domains that any R user would find useful. The course is a natural extension of the more basic Udemy course, Essential Fundamentals of R and is highly recommended for those students, as well as for other new students (and for practicing professionals) interested in the three domains enumerated above.
Base, GGplot and Lattice (or "trellis) graphics are the three principal graphics systems in R. They each operate under different "rules" and each present useful and often brilliant graphics displays. However, each of these three graphics systems are generally designed and used for different domains or applications.
There are many different programming and simulation scenarios that can be modeled with R. This course provides a good sense for some of the potential simulation applications through the presentation of 'downtoearth,' practical domains or tasks that are supported. The examples are based on common and interesting 'realworld' tasks: (1) simulating a game of cointossing; (2) returning TopHats checked into a restaurant to their rightful owners; (3) collecting baseball cards and state quarters for profit: (4) validating whether socalled "streaky" behavior, such as have a string of goodhitting behavior in consecutive baseball games, is really unusual from a statistical point of view; (4) estimating the number of taxicabs in a newlyvisited city; and (5) estimating arrival times for Sam and Annie at the Empire State Building ("Sleepless in Seattle").
R is likely best known for the ability to process numerical data, but R also has quite extensive capabilities to process nonquantitative text (or character) and string variables. R also has very good facilities for implementing powerful "regular expression" naturallanguage functions. An R user is bested served with an understanding of how these text (or character) and string processing capabilities "work."
Most sessions present "handson" material that make use of many extended examples of R functions, applications, and packages for a variety of common purposes. RStudio, a popular, open source Integrated Development Environment (IDE) for developing and using R applications, is utilized in the program, supplemented with Rbased direct scripts (e.g. 'commandline prompts') when necessary.
Not for you? No problem.
30 day money back guarantee.
Forever yours.
Lifetime access.
Learn on the go.
Desktop, iOS and Android.
Get rewarded.
Certificate of completion.
Section 1: Base and GGPlot2 Graphics in R  

Lecture 1 
Introduction
Preview

01:35  
Lecture 2  15:15  
One of the greatest strengths of the R language is surely the base graphics capabilities. Grid graphics, lattice, ggplot2, and the many R packages that interface with javascript D3graphics have added astounding capabilities, well beyond what can be achieved with base graphics alone. Nevertheless, the quick, one line, base graphics plots ( like plot() ) are a tremendous aid to data exploration, and are responsible for a good bit of the "flow" of an R session. 

Lecture 3  07:25  
ggplot2 is a plotting system for R, based on the grammar of graphics, which tries to take the good parts of base and lattice graphics and none of the bad parts. It takes care of many of the fiddly details that make plotting a hassle (like drawing legends) as well as providing a powerful model of graphics that makes it easy to produce complex multilayered graphics. 

Lecture 4  15:05  
Graphical Parameters You can customize many features of your graphs (fonts, colors, axes, titles) through graphic options. One way is to specify these options in through the par( ) function. If you set parameter values here, the changes will be in effect for the rest of the session or until you change them again. The format ispar(optionname=value, optionname=value, ...) A second way to specify graphical parameters is by providing the optionname=value pairs directly to a high level plotting function. In this case, the options are only in effect for that specific graph. See the help for a specific high level plotting function (e.g. plot, hist, boxplot) to determine which graphical parameters can be set this way. 

Lecture 5 
Adding Text to Graphics

07:09  
Lecture 6 
Mathematical and Drawing Functions

11:03  
Section 2: Finish Base Graphics Capabilities, Begin Lattice Graphics  
Lecture 7 
Fitting NonLinear Curves in Base

15:49  
Lecture 8 
More Base NonLinear Plots
Preview

18:45  
Lecture 9  14:32  
Boxplots Boxplots can be created for individual variables or for variables by group. The format is boxplot(x, data=), where x is a formula and data= denotes the data frame providing the data. An example of aformula is y~group where a separate boxplot for numeric variable y is generated for each value of group. Add varwidth=TRUE to make boxplot widths proportional to the square root of the samples sizes. Addhorizontal=TRUE to reverse the axis orientation. 

Lecture 10  13:30  
Lattice Graphs The lattice package, written by Deepayan Sarkar, attempts to improve on base R graphics by providing better defaults and the ability to easily display multivariate relationships. In particular, the package supports the creation of trellis graphs  graphs that display a variable or the relationship between variables, conditioned on one or more other variables. The typical format is where graph_type is selected from the listed below. formula specifies the variable(s) to display and any conditioning variables . For example ~xA means display numeric variable x for each level of factor A.y~x  A*B means display the relationship between numeric variables y and x separately for every combination of factor A and B levels. ~x means display numeric variable x alone. 

Lecture 11 
Superposition and Lattice Exercise

04:26  
Lecture 12 
Lattice Exercise Solution

15:40  
Section 3: Lattice and GGPlot Graphics  
Lecture 13 
"In Living Color" Exercises Solution Explained

15:45  
Lecture 14 
Finish "In Living Color" Exercise and Begin Lattice Graphics

15:18  
Lecture 15 
Lattice Layouts, Groups, and Aspect Ratios
Preview

14:12  
Lecture 16 
Plotting the Titanic Data Set and Begin GGPlot Graphics

11:54  
Lecture 17 
GGPlot: NonLinear Fits and Plots

15:31  
Lecture 18 
Histograms, Bar Charts and Density Plots

16:59  
Section 4: Programming and Simulation 1  
Lecture 19 
Cuckoohost and Other Plots

14:51  
Lecture 20 
Finish Cuckoohosts and Begin Simulation

16:07  
Lecture 21  14:10  
Simulation uses methods based on random numbers to simulate a process of interest on the computer. The goal is to learn important statistical and/or practical information about the process. In statistics, simulations can be used to create simulated data sets in order to study the accuracy of mathematical approximations and the effect of assumptions being violated. We will study properties of some quantities that can be calculated from a set of data which are a random draw from a population. Random numbers form a basic tool for any simulation study. Simulations require the ability to generate random numbers. On a computer, it is only possible to generate 'pseudorandom' numbers which for practical purposes behave as if they were drawn randomly. 

Lecture 22 
Simulating a Coin Tossing Game of Chance (part 2)

14:05  
Lecture 23 
Simulating the Return of TopHats to Rightful Owners (part 1)

15:57  
Lecture 24 
Finish Simulating TopHat Returns and Begin Collecting Baseball Cards for Profit

11:51  
Section 5: Programming and Simulation 2  
Lecture 25 
Collecting Baseball Cards (part 1 continued)
Preview

11:24  
Lecture 26 
Collecting Baseball Cards (part 2)

12:42  
Lecture 27 
Collecting Baseball Cards (part 3)

10:30  
Lecture 28 
Collecting Quarters Exercise Solution

06:06  
Lecture 29 
Streaky Baseball Behavior (part 1)

11:52  
Lecture 30 
Streaky Baseball Behavior (part 2)

12:23  
Lecture 31 
Sam and Annie Arrive at the Empire State Building (part 1)

06:36  
Lecture 32 
Hats and Streakiness Exercise

07:30  
Lecture 33 
Sam and Annie Arrive at the Empire State Building (part 2)

11:14  
Section 6: Programming and Simulation 3  
Lecture 34 
Checking Hats Exercise Solution

06:43  
Lecture 35 
More Streakiness Exercise Solution

11:02  
Lecture 36 
Standard Normal Monte Carlo Simulation
Preview

06:39  
Lecture 37 
Estimating Mean Squared Error of a Trimmed Mean

08:03  
Lecture 38 
Estimating a Confidence Level

11:37  
Lecture 39 
Empirical Confidence Level

04:57  
Lecture 40 
Estimating the Taxi Population (part 1)

09:11  
Lecture 41 
Estimating the Taxi Population (part 2)

07:32  
Lecture 42 
Permutation Tests (part 1)

13:30  
Lecture 43 
Permutation Tests (part 2)

16:55  
Lecture 44 
The Bootstrap and Jackknife (part 1)

09:32  
Lecture 45 
The Bootstrap and Jackknife (part 2)

11:37  
Lecture 46 
Late to Class Again Exercise

03:01  
Section 7: Character Manipulation and String Processing  
Lecture 47 
Late to Class Exercise Solution

09:59  
Lecture 48  08:39  
Handling and processing text strings in R? Wait a second . . . you exclaim, R is not a scripting language like Perl, Python, or Ruby. Why would you want to use R for handling and processing text? Well, because sooner or later (I would say sooner than later) you will have to deal with some kind of string manipulation for your data analysis. So it's better to be prepared for such tasks and know how to perform them inside the R environment. 

Lecture 49  10:15  
Another very useful function is cat() which allows us to concatenate objects and print them either on screen or to a file. Its usage has the following structure: cat(..., file = "", sep = " ", fill = FALSE, labels = NULL, append = FALSE) 

Lecture 50 
Displaying and Concatenating Strings (part2)

14:00  
Lecture 51 
Manipulating Parts of a String

10:00  
Lecture 52 
Breaking Apart Character Values

14:13  
Lecture 53  10:27  
A regular expression (a.k.a. regex) is a special text string for describing a certain amount of text. This “certain amount of text” receives the formal name of pattern. Hence we say that a regular expression is a pattern that describes a set of strings. 

Lecture 54  13:31  
There are two main aspects that we need to consider about regular expressions in R. One has to do with the functions designed for regex pattern matching. The other aspect has to do with the way regex patterns are expressed in R. In this section we are going to talk about the latter issue: the way R works with regular expressions. Some find more convenient to first cover the specificities of R around regex operations, before discussing the functions and how to interact with regex patterns. 

Lecture 55 
Using Regular Expressions in R (part 2)

11:36  
Lecture 56 
Reversing a String Exercise

01:44  
Section 8: More Text and String Processing  
Lecture 57 
Reverse String Exercise Solution

09:29  
Lecture 58  12:41  
To find exactly where the pattern is found in a given string, we can use the regexpr() function. This function returns more detailed information than grep() providing us: a) which elements of the text vector actually contain the regex pattern, and b) identifies the position of the substring that is matched by the regular expression pattern. # some text text = c("one word", "a sentence", "you and me", "three two one") # default usage regexpr("one", text) 

Lecture 59  09:48  
The function gregexpr() does practically the same thing as regexpr(): identify where a pattern is within a string vector, by searching each element separately. The only difference is that gregexpr() has an output in the form of a list. In other words, gregexpr() returns a list of the same length as text, each element of which is of the same form as the return value for regexpr(), except that the starting positions of every (disjoint) match are given. # some text text = c("one word", "a sentence", "you and me", "three two one") # pattern pat = "one" # default usage gregexpr(pat, text) 

Lecture 60 
Testing a Filename for a Suffix

08:40  
Lecture 61 
Forming Filenames

08:46  
Lecture 62 
Substituting Text and Tagging Text

14:54  
Lecture 63  14:45  
grep() is perhaps the most basic functions that allows us to match a pattern in a string vector. The first argument in grep() is a regular expression that specifies the pattern to match. The second argument is a character vector with the text strings on which to search. The output is the indices of the elements of the text vector for which there is a match. If no matches are found, the output is an empty integer vector. # some text text = c("one word", "a sentence", "you and me", "three two one") # pattern pat = "one" # default usage grep(pat, text) 

Lecture 64 
Manipulating the Component Names of List Structures

11:07  
Lecture 65 
Sorting and Ordering Words

12:21  
Lecture 66 
Determining and Plotting Word Frequency

06:33 
Dr. Geoffrey Hubona held fulltime tenuretrack, and tenured, assistant and associate professor faculty positions at 3 major state universities in the Eastern United States from 19932010. In these positions, he taught dozens of various statistics, business information systems, and computer science courses to undergraduate, master's and Ph.D. students. He earned a Ph.D. in Business Administration (Information Systems and Computer Science) from the University of South Florida (USF) in Tampa, FL (1993); an MA in Economics (1990), also from USF; an MBA in Finance (1979) from George Mason University in Fairfax, VA; and a BA in Psychology (1972) from the University of Virginia in Charlottesville, VA. He was a fulltime assistant professor at the University of Maryland Baltimore County (19931996) in Catonsville, MD; a tenured associate professor in the department of Information Systems in the Business College at Virginia Commonwealth University (19962001) in Richmond, VA; and an associate professor in the CIS department of the Robinson College of Business at Georgia State University (20012010). He is the founder of the Georgia R School (20102014) and of RCourseware (2014Present), online educational organizations that teach research methods and quantitative analysis techniques. These research methods techniques include linear and nonlinear modeling, multivariate methods, data mining, programming and simulation, and structural equation modeling and partial least squares (PLS) path modeling. Dr. Hubona is an expert of the analytical, opensource R software suite and of various PLS path modeling software packages, including SmartPLS. He has published dozens of research articles that explain and use these techniques for the analysis of data, and, with software codevelopment partner Dean Lim, has created a popular cloudbased PLS software application, PLSGUI.