R FAQS Archives - R Frequently Asked Questions

Scatter Plots In R

Scatter plots (scatter diagrams) are bivariate graphical representations for examining the relationship between two quantitative variables. Here we will discuss how to make several kinds of scatter plots in R.

In plot() function when two numeric vectors are provided as arguments (one for horizontal and other for vertical coordinates), the default behaviour of the plot() function is to make a scatter diagram. For example,

library(car)
attach(Prestige)
plot(income, prestige)

will draw a simple scatterplot of prestige by income.

Usually, the interpretation of a scatterplot is often assisted by enhancing the plot with least-squares or non-parametric regression lines. For this purpose scatterplot() in car package can be used and it will add marginal boxplots for the two variables

scatterplot(prestige ~ income, lwd = 3 )

Note that in the scatterplot, the non-parametric regression curve is drawn by a local regression smoother, where local regression works by fitting a least-square line in the neighborhood of each observation, placing greater weight on points closer to the focal observation. A fitted value for the focal observation is extracted from each local regression, and the resulting fitted values are connected to produce the non-parametric regression line.

Coded Scatterplots

The scatterplot() function can also be used to create coded scatterplots. For this purpose, a categorical variable is used for coloring or using different symbols for each category. For example, let us plot prestige by income, coded by the type of occupation

scatterplot(prestige ~ income | type)

Note that variables in the scatterplot are given in a formula-style (as y ~ x | groups).

The coded scatterplot indicates that the relationship between prestige and income may well be linear within occupation types. The slope of the relationship looks steepest for blue-collar (bc) occupation, and least steep for professional and managerial occupation.

Jittering scatterplots

Jittering the data by adding a small random quantity to each coordinate serves to separate the overplotted points.

data(Vocab)
attach(Vocab)
plot(education, vocabulary) 
# without jittering
plot(jitter (education), jitter(vocabulary) )

The degree of jittering can be controlled via factor argument. For example, specifying factor = 2 doubles the jitter.

plot(jitter(education, factor = 2), jitter(vocabulary, factor = 2))

Let add the least-squares and non-parametric regression line.

abline(lm(vocabulary ~ education), lwd=3, lty = 2)

lines(lowess(education, vocabulary, f = 0.2), lwd = 3)

The lowess function (an acronym for locally weighted regression) returns coordinates for the local-regression curve, which is drawn by lines. The span of the local regression is set by the f arguments to lowess.

Using these different kinds of graphical representations of relationships between variables may help to identify some hidden information (hidden due to overplotting).

See more on plot() function

Input Data in R using c() and scan() Functions

No Comments

| R Basics

There are many ways to input data into R and S Language. Here, I will concentrate only on typing data directly at the keyboard using c() and scan() function.

The traditional statistical computer software such as Minitab, SPSS, and SAS, etc., are designed to transform rectangular datasets (a dataset whose rows represent the observations and column represent the variables) into printed reports and graphs. However, R and S languages are designed to transform data objects into other data objects (such as reports, and graphs).

S and R language both supports rectangular datasets, in the form of data frames and in other variety of data structures. Here we will learn to know about data in R in order to work efficiently as a statistical data analyst.

There are many ways to input data in R and S-Plus. Let us learn typing data directly at the keyboard.

The best choice to enter small datasets directly at the keyboard. Remember that it is impractical to enter a large data set directly at the keyboard.

Let use the c() function to enter the a vector of numbers directly as:

x <- c(1, 3, 5, 7, 9)
char <- c('a', 'b', 'c', 'd')
TF <- c(TRUE, FALSE)

Note that the character strings can be directly inputted in single or double quotation marks. For example, "a" and 'a' both are equivalent.

It is also very convenient to use the scan() function, which prompts with the index of the next entry. Consider the example,

xyz <- scan()
1: 10 20 30 35
5: 40 35 25
8: 9 100 50
11:
Read 10 items</span>

The number before the colon on each of the inputted lines is the index of the next data entry point (observation) to be entered. Note that entering a blank line terminates the scan() function input behaviour.

Click the following links to learn about data entry (import and export internal and external data) in R Language

One-Way ANOVA in R

No Comments

| Comparisons Tests, R Basics

The two-sample t or z test is used to compare two groups from the independent population. However, if there are more than two groups, analysis of variance (ANOVA) can be used.

The statistical test statistic associated with ANOVA is the F-test (also called F-ratio). In Anova procedure an observed F-value is computed and then compared with a critical F-value derived from the relevant F-distribution. The F-value comes from a family of F-distribution defined by two numbers (the degrees of freedom). Note that the F-distribution cannot be negative as it is the ratio of variance and variances are always positive numbers.

The One-Way ANOVA is also known as one-factor ANOVA. It is the extension of independent two samples test for comparing means when there are more than two groups. The data in One-Way ANOVA is organized into several groups base on grouping variable (called factor variable too).

To compute the F-value, the ratio of “the variance between groups”, and the “variance within groups” need to be computed. The assumptions of Anova should also be checked before performing the ANOVA test. We will learn how to perform One-Way ANOVA in R.

Suppose we are interested in finding the difference of miles per gallon on the bases of numbers of the cylinder in an automobile; from the dataset “mtcars“

Let we get some basic insight into the data before performing the ANOVA.

# load and attach the data mtcars
attach(mtcars)

# see the variable names and initial observations
head(mtcars)

Let us find the means of each number of the cylinder group

print(model.tables(res, "means"), digits=4)

Let us draw the boxplot of each group

boxplot(mpg ~ cyl, main="Boxplot", xlab="Number of Cylinders", ylab="mpg")

Now, to perform One-Way ANOVA in R using the aov( ) function. For example,

aov(mpg ~ cyl)

The variable “mpg” is continuous and the variable “cyl” is the grouping variable. From the output note the degrees of freedom under the variable “cyl”. It will be one. It means the results are not correct as the degrees of freedom should be two as there are three groups on “cyl”. In mode (data type) of grouping variable required for ANOVA should be factor variable. For this purpose, the “cyl” variable can be converted to factor as

cyl <- as.factor(cyl)

Now re-issue the aov( ) function as

aov(mpg ~ cyl)

Now the results will be as required. To get the ANOVA table, use the summary( ) function as

summary(aov (mpg ~ cyl))

Let store the ANOVA results obtained from aov( ) in object say res

res <- aov(mpg ~ cyl)
summary(res)

Post-Hoc Analysis

Post-hoc tests or multiple-pairwise comparison tests help in finding out which groups differ (significantly) from one other and which do not. The Post-hoc tests allow for multiple-pairwise comparisons without inflating the type-I error. To understand it, suppose the level of significance (type-I error) is 5%. Then the probability of making at least one Type-I error (assuming independence of three events), the maximum family-wise error rate will be

$1-(0.95 \times 0.95 \times 0.95) = 14.2%$

It will give the probability of having at least one FALSE alarm (type-I error).

To perform Tykey’s Post-hoc test and plot the group’s differences in means from Tukey’s test.

# Tukey Honestly Significant Differences
TukeyHSD(res)
plot(TukeyHSD(res))

Diagnostic Plots

The diagnostic plots can be used to check the assumption of heteroscedasticity, normality, and influential observations.

layout(matrix(c(1,2,3,4), 2,2))
plot(res)

Levene’s Test

To check the assumption of ANOVA, Levene’s test can be used. For this purpose leveneTest( ) function can be used which is available in the car package.

library(car)
leveneTest(res)

For loop in R | Simulating Data using For loop

No Comments

| For loop in R, R Basics, R Control Structure

In different programming language and R, the for loop (for statement) allows one to specify the set of codes (commands) should be repeated a fixed number of times. For loop in R is not limited to integers or even number in the input. The character vectors, logical vectors, lists, or even expressions can also be used in for loop.

The general syntax of for loop is

for (named vector) {
   statements (R codes)
}

The curly braces contains the set of commands so that these commands can be treated as single command and can be repeated desired number of times.However, if there is only single statement then there is no need to use curly races.

Let us understand the loop through different examples. Note that some of the examples can be done without the use of for loop or with alternatives such as apply(), lapply(), sapply(), and tapply() functions.

Example: Suppose you want to compute the squared values for 1 to 10. It can be done in for loop as;

for (i in 1:10){
    squared <-i ^2
    print(squared)
}

Note: if you write print(squared) command outside the for loop (after the curly braces), then the last result of the loop iteration will be displayed in the console only, that is, the square of the last number (n = 10) will be printed.

To store the result of each iteration in a variable (vector, matrix, data frame, or list), a container (variable) needs to be specified of the sample length as that of the loop have. For example, the outcome of each iteration (from the above example) can be stored in a variable as,

result <- vector("numeric", 10)
for (i in length(result) ){
    squared <- i^2
    result[i] <- squared
}
result

Now results can be displayed without print() command as the results are stored in a container (vector variable). To store results in a data frame or matrix (in the form of the table) with iteration number, the above example can be extended as

result <- data.frame(matrix(nrow = 10, ncol = 2))
colnames(result) <- c("i", "Square")
for (i in 1:10 ){
    squared <- i^2
    result[i, 1] <- i  # stores iteration number in 1stcolumn of data frame
    result[i, 2] <- squared # stores iteration result in 2nd column of data frame
}
result

Nesting For loop in R

Placing the loop inside the body of another loop is called nesting. For nested loops, the outer loop takes control of the iteration of the inner loop. The inner loop will be executed (iterated) n-times for every iteration of the outer loop. For example

for (i in 1:10){
    for (j in 1:5){
        print(i*j)
    }
}

There will be a total of 50 iterations. For each iteration of the first loop (outer loop), there will be five iterations in the inner loop.

The break statement can be used inside a loop if one wants to stop the iteration when a certain condition (situation) occurs and the control will be out of the loop when the condition is satisfied. For example,

n <- 1:5
for (i in x){
   if( i == 3){
     break
   }
print(i)
}

It is also possible to jump to the next iteration using the next statement when certain condition satisfied. For example,

n <- 1:5
for( i in x ){
    if (i==2){
       next
    }
print(i)
}

Now consider the example of for loop using character vector

v = LETTERS[1:10]
for(i in v){
    print(i)
}

Using For loop in Simulations

In simulations, to generate or resample (bootstrap) data, loops are used. For example, let create a variable having 1000 observations (n = 1000), where each observation is a function of the previous observation according to the equation y_t is 80%, y_t-1 + 20%. with random noise having mean 0 and standard deviation 1. The value of y₁=1.

y<-rep(1,1000)
for(i in 2:1000){
    y[i]=0.8*y[i-1]+0.2*rnorm(1)
}
y

Consider another example of generating simulated data. Suppose, you want to simulate the mixture data and want to repeat it many times and you also want to store the data for each time.

n=100
res = list()
N=1000
X = matrix(0, nrow=N, ncol=2)
for(i in 1:n){
    U = runif(N, min = 0, max = 1)
    for(j in 1:N){
        if (U[j]<0.8){
          X[j,] <- rnorm(1, 2.5, 3)
        } else{
             X[j,] <- rnorm(1,2,1)
          }
        }
    res[[i]]=X
}
res[[100]]

Note that each res[[i]] is a separate data set, which can be used for further calculations.

Namespaces in R Language

No Comments

| Advance R Programming, R FAQS about Package, R Programming

In R language, the packages can have namespaces, and currently, all of the base and recommended packages do except the dataset packages. Understanding the use of namespaces is vital if one’s plan to submit a package to CRAN because CRAN requires that the package plays nicely with other submitted packages on CRAN. Namespaces ensure that other packages will not interfere with your code and the package works regardless of the environment in which it’s run.

For example, plyr and Hmisc both provide a function namely summarize(). Loading plyr package and then Hmise, the summarize() function will refer to the Hmisc. However, loading the package in the opposite order, the summarize() function will refer to the plyr package version.

To avoid confusion, one can explicitly refer to the specific function, for example,

> Hmisc::summarize()

and

> plyr::summarize()

Now, the order in which the packages are loaded would not matter.

Namespaces do three things:

Namespaces allow the package writer to hide functions and data that are meant only for internal use,
Namespaces prevent functions from breaking when a user (or other package writers) picks a name that clashes with one in the package, and
Namespaces provide a way to refer to an object within a particular package

Namespace Operators

In R language, there are two operators that work with namespaces.

Doule-Colon Operator
The double-colon operator:: selects definitions from a particular namespace. The transpose function t() will always be available as the base::t, because it is defined in the base package. Only functions that are exported from the package can be retrieved in this way.
Triple-Colon Operator
The triple-colon operator ::: acts like the double-colon operator but also allows access to hidden objects. Users are more likely to use the getAnywhere() function, which searches multiple packages.

Packages are often inter-dependent, and loading one may cause others to be automatically loaded. The colon operators will also cause automatic loading of the associated package. When packages with namespaces are loaded automatically they are not added to the search list.

R Frequently Asked Questions

Category: R FAQS

Scatter Plots In R

Coded Scatterplots

Jittering scatterplots

Like this:

Input Data in R using c() and scan() Functions

Like this:

One-Way ANOVA in R

Post-Hoc Analysis

Diagnostic Plots

Levene’s Test

Like this:

For loop in R | Simulating Data using For loop

Nesting For loop in R

Using For loop in Simulations

Like this:

Namespaces in R Language

Namespace Operators

Like this:

Coded Scatterplots

Jittering scatterplots

Share this:

Like this:

Share this:

Like this:

Post-Hoc Analysis

Diagnostic Plots

Levene’s Test

Share this:

Like this:

Nesting For loop in R

Using For loop in Simulations

Share this:

Like this:

Namespace Operators

Share this:

Like this: