R

R terminal
Paradigms	Multi-paradigm: procedural, object-oriented, functional, reflective, imperative, array[1]
Designed by	Ross Ihaka and Robert Gentleman
Developer	R Core Team
First appeared	August 1993; 30 years ago (1993-08)
Stable release	4.3.2[2]  / 31 October 2023; 2 months ago (31 October 2023)
Typing discipline	Dynamic
Platform	arm64 and x86-64
License	GNU GPL v2
Filename extensions	.r[3] .rdata .rds .rda[4]
Website	www.r-project.org
Influenced by
Lisp S[5] Scheme[1]
Influenced
Julia[6]
R Programming at Wikibooks

R is a programming language for statistical computing and graphics. Created by statisticians Ross Ihaka and Robert Gentleman, R is used for data mining, bioinformatics, and data analysis.^[7]

The core R language is augmented by a large number of extension packages containing reusable code and documentation.

R software is open-source free software, licensed by the GNU Project, and available under the GNU General Public License. It is written primarily in C, Fortran, and R itself. Precompiled executables are provided for various operating systems. R is supported by the R Core Team and the R Foundation for Statistical Computing.

R has a native command line interface.^[8] Moreover, multiple third-party graphical user interfaces are available, such as RStudio -- an integrated development environment, and Jupyter -- a notebook interface.

History

Robert Gentleman, co-originator of R

Ross Ihaka, co-originator of R

R was started by professors Ross Ihaka and Robert Gentleman as a programming language to teach introductory statistics at the University of Auckland.^[9] The language took heavy inspiration from the S programming language, with most S programs able to run unaltered in R,^[5] as well as from Scheme's lexical scoping, allowing for local variables.^[1]

The name of the language, R, comes from being both an S language successor as well as the shared first letter of the authors, Ross and Robert.^[10] Ihaka and Gentleman first shared binaries of R on the data archive StatLib and the s-news mailing list in August 1993.^[11] In June 1995, statistician Martin Mächler convinced Ihaka and Gentleman to make R free and open-source under the GNU General Public License.^[11][12] Mailing lists for the R project began on 1 April 1997 preceding the release of version 0.50.^[13] R officially became a GNU project on 5 December 1997 when version 0.60 released.^[14] The first official 1.0 version was released on 29 February 2000.^[9]

The Comprehensive R Archive Network (CRAN) was founded in 1997 by Kurt Hornik and Fritz Leisch to host R's source code, executable files, documentation, and user-created packages.^[15] Its name and scope mimics the Comprehensive TeX Archive Network and the Comprehensive Perl Archive Network.^[15] CRAN originally had three mirrors and 12 contributed packages.^[16] As of December 2022, it has 103 mirrors^[17] and 18,976 contributed packages.^[18]

The R Core Team was formed in 1997 to further develop the language.^[19][20] As of January 2022, it consists of Chambers, Gentleman, Ihaka, and Mächler, plus statisticians Douglas Bates, Peter Dalgaard, Kurt Hornik, Michael Lawrence, Friedrich Leisch, Uwe Ligges, Thomas Lumley, Sebastian Meyer, Paul Murrell, Martyn Plummer, Brian Ripley, Deepayan Sarkar, Duncan Temple Lang, Luke Tierney, and Simon Urbanek, as well as computer scientist Tomas Kalibera. Stefano Iacus, Guido Masarotto, Heiner Schwarte, Seth Falcon, Martin Morgan, and Duncan Murdoch were members.^[11][21] In April 2003,^[22] the R Foundation was founded as a non-profit organization to provide further support for the R project.^[23]

Examples

Mean — a measure of center

A numeric data set may have a central tendency — where some of the most typical data points reside.^[24] The arithmetic mean (average) is the most commonly used measure of central tendency.^[24] The mean of a numeric data set is the sum of the data points divided by the number of data points.^[24]. It is represented by the symbol .

Let = a list of data points.

Let = the number of data points.

Suppose a sample of four observations of Celsius temperature measurements were taken 12 hours apart.

Let = a list of degrees Celsius data points of 30, 27, 31, 28.

This R computer program will output the mean of :

# The c() function "combines" a list into a single structure.
x <- c( 30, 27, 31, 28 )

sum <- sum( x )
length <- length( x )
mean <- sum / length

message( "Mean:" )
print( mean )

Note: R can have the same identifier represent both a function name and its result. For more information, visit scope.

Output:

Mean:
[1] 29

This R program will execute the native mean() function to output the mean of x:

x <- c( 30, 27, 31, 28 )

message( "Mean:" )
print( mean( x ) )

Output:

Mean:
[1] 29

Standard Deviation — a measure of dispersion

A standard deviation of a numeric data set is an indication of the average distance all the data points are from the mean.^[25] For a data set with a small amount of variation, then each data point will be close to the mean, so the standard deviation will be small.^[25]. Standard deviation is represented by the symbol .

Let = a list of data points.

Let = the number of data points.

Suppose a sample of four observations of Celsius temperature measurements were taken 12 hours apart.

Let = a list of degrees Celsius data points of 30, 27, 31, 28.

This R program will output the standard deviation of :

x <- c( 30, 27, 31, 28 )
distanceFromMean <- x - mean( x )
distanceFromMeanSquared <- distanceFromMean**2
distanceFromMeanSquaredSum <- sum( distanceFromMeanSquared )
variance <- distanceFromMeanSquaredSum / ( length( x ) - 1 )
standardDeviation <- sqrt( variance )

message( "Standard Deviation:" )
print( standardDeviation )

Output:

Standard Deviation:
[1] 1.825742

This R program will execute the native sd() function to output the standard deviation of :

x <- c( 30, 27, 31, 28 )

message( "Standard Deviation:" )
print( sd( x ) )

Output:

Standard Deviation:
[1] 1.825742

Linear regression — a measure of relation

A phenomenon may be the result of one or more observable events. For example, the phenomenon of skiing accidents may be the result of having snow in the mountains. A method to measure whether or not a numeric data set is related to another data set is linear regression.^[26]

Let = a data set of independent data points, in which each point occurred at a specific time.

Let = a data set of dependent data points, in which each point occurred at the same time of an independent data point.

If a linear relationship exists, then a scatter plot of the two data sets will show a pattern that resembles a straight line.^[27] If a straight line is embedded into the scatter plot such that the average distance from all the points to the line is minimal, then the line is called a regression line. The equation of the regression line is called the regression equation.^[28]

The regression equation is a linear equation; therefore, it has a slope and y-intercept. The format of the regression equation is .^{[29] [a]}

Let = a list of independent data points.

Let = a list of dependent data points.

Let = the slope of the regression equation.

Let = the y-intercept of the regression equation.

Suppose a sample of four observations of Celsius temperature measurements were taken 12 hours apart. At the same time, the thermometer was switched to Fahrenheit temperature and another measurement was taken.

Let = a list of degrees Celsius data points of 30, 27, 31, 28.

Let = a list of degrees Fahrenheit data points of 86.0, 80.6, 87.8, 82.4.

This R program will output the slope and y-intercept of the linear relationship between and :

x <- c( 30, 27, 31, 28 )
y <- c( 86.0, 80.6, 87.8, 82.4 )

independentDistanceFromMean <- x - mean( x )

sampledDependentDistanceFromMean <- y - mean( y )

independentDistanceTimesSampledDistance <-
    independentDistanceFromMean *
    sampledDependentDistanceFromMean

independentDistanceTimesSampledDistanceSum <-
    sum( independentDistanceTimesSampledDistance )

independentDistanceFromMeanSquared <-
    independentDistanceFromMean ** 2

independentDistanceFromMeanSquaredSum <-
    sum( independentDistanceFromMeanSquared )

slope <-
    independentDistanceTimesSampledDistanceSum /
    independentDistanceFromMeanSquaredSum

yIntercept <- mean( y ) - slope * ( mean( x ) )

message( "Slope:" )
slope

message( "Y-intercept" )
yIntercept

Output:

Slope:
[1] 1.8
Y-intercept:
[1] 32

This R program will execute the native functions to output the slope and y-intercept of the linear relationship between and :

x <- c( 30, 27, 31, 28 )
y <- c( 86.0, 80.6, 87.8, 82.4 )

# Execute lm() with Fahrenheit depends upon Celsius
linearModel <- lm( y ~ x )

# coefficients() returns a structure containing the slope and y intercept
coefficients <- coefficients( linearModel )

# Extract the slope from the structure
slope <- coefficients[["x"]]

# Extract the y intercept from the structure
yIntercept <- coefficients[["(Intercept)"]]

message( "Slope:" )
slope

message( "Y-intercept" )
yIntercept

Output:

Slope:
[1] 1.8
Y-intercept:
[1] 32

This R program will display a scatterplot with an embedded regression line and regression equation illustrating the relationship between and :

# Let x = list of degrees in Celsius
x <- c( 30, 27, 31, 28 )

# Let y = list of degrees in Fahrenheit
y <- c( 86.0, 80.6, 87.8, 82.4 )

# Execute lm() with Fahrenheit depends upon Celsius
linearModel <- lm( y ~ x )

# coefficients() returns a structure containing the slope and y intercept
coefficients <- coefficients( linearModel )

# Extract the slope from the structure
slope <- coefficients[["x"]]

# Extract the y intercept from the structure
intercept <- coefficients[["(Intercept)"]]

# Execute paste() to build the regression equation string
regressionEquation <- paste( "y =", intercept, "+", slope, "x" )

# Display a scatterplot with the regression line and equation embedded
plot(
    x,
	y,
	main = "Fahrenheit Depends Upon Celsius",
	sub = regressionEquation,
	xlab = "Degress Celsius",
	ylab = "Degress Fahrenheit",
	abline( linearModel ) )

Output:

Structure of a function

One of R's strengths is the ease of creating new functions.^[30] Objects in the function body remain local to the function, and any data type may be returned.

Create a function:

# The input parameters are x and y.
# The function returns a linear combination of x and y.
f <- function(x, y) {
  z <- 3 * x + 4 * y

  # this return() statement is optional
  return(z)
}

Usage output:

> f(1, 2)
[1] 11

> f(c(1,2,3), c(5,3,4))
[1] 23 18 25

> f(1:3, 4)
[1] 19 22 25

Modeling and plotting

The R language has built-in support for data modeling and graphics. The following example shows how R can generate and plot a linear model with residuals.

# Create x and y values
x <- 1:6
y <- x^2

# Linear regression model y = A + B * x
model <- lm(y ~ x)

# Display an in-depth summary of the model
summary(model)

# Create a 2 by 2 layout for figures
par(mfrow = c(2, 2))

# Output diagnostic plots of the model
plot(model)

Output:

Residuals:
      1       2       3       4       5       6       7       8      9      10
 3.3333 -0.6667 -2.6667 -2.6667 -0.6667  3.3333

Coefficients:
            Estimate Std. Error t value Pr(>|t|)   
(Intercept)  -9.3333     2.8441  -3.282 0.030453 * 
x             7.0000     0.7303   9.585 0.000662 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.055 on 4 degrees of freedom
Multiple R-squared:  0.9583, Adjusted R-squared:  0.9478
F-statistic: 91.88 on 1 and 4 DF,  p-value: 0.000662

Mandelbrot set

This Mandelbrot set example highlights the use of complex numbers. It models the first 20 iterations of the equation z = z2 + c, where c represents different complex constants.

Install the package that provides the write.gif() function beforehand:

install.packages("caTools")

R Source code:

library(caTools)

jet.colors <-
    colorRampPalette(
        c("green", "pink", "#007FFF", "cyan", "#7FFF7F",
          "white", "#FF7F00", "red", "#7F0000"))

dx <- 1500 # define width
dy <- 1400 # define height

C  <-
    complex(
        real =
            rep(
                seq(-2.2, 1.0, length.out = dx), each = dy),
                imag = rep(seq(-1.2, 1.2, length.out = dy),
                dx))

# reshape as matrix of complex numbers
C <- matrix(C, dy, dx)

# initialize output 3D array
X <- array(0, c(dy, dx, 20))

Z <- 0

# loop with 20 iterations
for (k in 1:20) {

  # the central difference equation
  Z <- Z^2 + C

  # capture the results
  X[, , k] <- exp(-abs(Z))
}

write.gif(
    X,
    "Mandelbrot.gif",
    col = jet.colors,
    delay = 100)

Features

Data structures

R's data structures include vectors, arrays, lists, data frames, and environments.^[31] Vectors are ordered collections of values and can be mapped to arrays of one or more dimensions in a column major order. That is, given an ordered collection of dimensions, one fills in values along the first dimension first, then fills in one-dimensional arrays across the second dimension, and so on.^[32]

R supports array arithmetic and in this regard is like languages such as APL and MATLAB.^[31][33] The special case of an array with two dimensions is called a matrix. Lists serve as collections of objects that do not necessarily have the same data type. Data frames contain a list of vectors of the same length, plus a unique set of row names.^[31] R has no scalar data type.^[34] Instead, a scalar is represented as a length-one vector.^[35]

Programming

R is an interpreted language; users can access it through a command-line interpreter. If a user types 1+1 at the R command prompt and presses enter, the computer replies with 2.^[36]

R supports procedural programming with functions and, for some functions, object-oriented programming with generic functions.^[37] Extending it is facilitated by its lexical scoping rules, which are derived from Scheme.^[38] R uses S syntax (not to be confused with S-expressions) to represent both data and code.^[39] R's extensible object system includes objects for (among others) regression models, time-series, and geo-spatial coordinates. Advanced users can write C, C++,^[40] Java via the Rserve socket server (website), .NET (website) and Python code to manipulate R objects directly.^[41]

Functions are first-class objects and can be manipulated in the same way as data objects, facilitating meta-programming that allows multiple dispatch. Function arguments are passed by value, and are lazy—that is to say, they are only evaluated when they are used, not when the function is called.^[42] A generic function acts differently depending on the classes of the arguments passed to it. In other words, the generic function dispatches the method implementation specific to that object's class. For example, R has a generic print function that can print almost every class of object in R with print(objectname).^[43]

R and its libraries implement various statistical techniques, including linear, generalized linear and nonlinear modeling, classical statistical tests, spatial and time-series analysis, classification, clustering, and others. For computationally intensive tasks, C, C++, and Fortran code can be linked and called at run time. Another of R's strengths is static graphics; it can produce publication-quality graphs that include mathematical symbols.^[44]

Packages

An R package is a collection of functions, documentation, and data that expands R.^[45] As examples: packages add output features to more graphical devices, transform features to import and export data, and report features such as RMarkdown, knitr and Sweave. Easy package installation and use have contributed to the language's adoption in data science.^[46]

Multiple packages are included with the basic installation. Additional packages are available on different repositories: CRAN,^[18] Bioconductor, R-Forge,^[47] Omegahat,^[48] GitHub, and others.

The "Task Views" on the CRAN website^[49] lists packages in fields including Finance, Genetics, High-Performance Computing, Machine Learning, Medical Imaging, Meta-Analysis,^[50] Social Sciences and Spatial Statistics.^[50]

The Bioconductor project provides packages for genomic data analysis, including object-oriented data handling and analysis tools for data from Affymetrix, cDNA microarray, and next-generation high-throughput sequencing methods.^[51]

Packages add the capability to interface with standalone, interactive graphics.^[52]

The Tidyverse package is organized to have a common interface. Each function in the package is designed to couple together all the other functions in the package.^[45]

Installing a package occurs only once. To install tidyverse:^[45]

> install.packages( "tidyverse" )

To instantiate the functions, data, and documentation of a package, execute the library() function. To instantiate tidyverse:^[b]

> library( tidyverse )

Interfaces

R comes installed with a command line console. Available for installation are various integrated development environments (IDE). IDEs for R include R.app (OSX/macOS only), Rattle GUI, R Commander, RKWard, RStudio, and Tinn-R.

General purpose IDEs that support R include Eclipse via the StatET plugin and Visual Studio via R Tools for Visual Studio.

Editors that support R include Emacs, Vim via the Nvim-R plugin (website), Kate, LyX via Sweave, WinEdt (website), and Jupyter (website).

Scripting languages that support R include Python (website), Perl (website), Ruby (source code), F# (website), and Julia (source code).

General purpose programming languages that support R include Java via the Rserve socket server (website) and .NET C# (website).

Statistical frameworks which use R in the background include Jamovi and JASP.

Implementations

The main R implementation is written primarily in C, Fortran, and R itself. Several other implementations are aimed at improving speed or increasing extensibility. A closely related implementation is pqR (pretty quick R) by Radford M. Neal with improved memory management and support for automatic multithreading. Renjin and FastR are Java implementations of R for use in a Java Virtual Machine. CXXR, rho, and Riposte^[53] are implementations of R in C++. Renjin, Riposte, and pqR attempt to improve performance by using multiple cores and deferred evaluation.^[54]

TIBCO, who previous sold the commercial implementation S-PLUS, built a runtime engine called TERR, which is part of Spotfire.^[55]

Microsoft R Open (MRO) was a fully compatible R distribution with modifications for multi-threaded computations.^[56] As of 30 June 2021, Microsoft started to phase out MRO in favor of the CRAN distribution.^[57]

Community

The R community hosts many conferences and in-person meetups. Some of these groups include:

• UseR!: an annual international R user conference (website)
• Directions in Statistical Computing (DSC) (website)
• R-Ladies: an organization to promote gender diversity in the R community (website)
• SatRdays: R-focused conferences held on Saturdays (website)
• R Conference (website)
• Posit::conf (formerly known as Rstudio::conf) (website)

The R Journal

The R Journal is an open access, refereed journal of the R project. It features short to medium-length articles on the use and development of R, including packages, programming tips, CRAN news, and foundation news.

Commercial support

Although R is an open-source project, some companies provide commercial support and extensions.

In 2007, Richard Schultz, Martin Schultz, Steve Weston, and Kirk Mettler founded Revolution Analytics to provide commercial support for Revolution R, their distribution of R, which includes components developed by the company. Major additional components include ParallelR, the R Productivity Environment IDE, RevoScaleR (for big data analysis), RevoDeployR, web services framework, and the ability for reading and writing data in the SAS file format.^[58] Revolution Analytics offers an R distribution designed to comply with established IQ/OQ/PQ criteria that enables clients in the pharmaceutical sector to validate their installation of REvolution R.^[59] In 2015, Microsoft Corporation acquired Revolution Analytics^[60] and integrated the R programming language into SQL Server, Power BI, Azure SQL Managed Instance, Azure Cortana Intelligence, Microsoft ML Server and Visual Studio 2017.^[61]

In October 2011, Oracle announced the Big Data Appliance, which integrates R, Apache Hadoop, Oracle Linux, and a NoSQL database with Exadata hardware.^[62] As of 2012, Oracle R Enterprise^[63] became one of two components of the "Oracle Advanced Analytics Option"^[64] (alongside Oracle Data Mining).^{[citation needed]}

IBM offers support for in-Hadoop execution of R,^[65] and provides a programming model for massively parallel in-database analytics in R.^[66]

TIBCO offers a runtime-version R as a part of Spotfire.^[67]

Mango Solutions offers a validation package for R, ValidR,^[68][69] to comply with drug approval agencies, such as the FDA. These agencies required the use of validated software, as attested by the vendor or sponsor.^[70]

See also

• R package
• Comparison of numerical-analysis software
• Comparison of statistical packages
• List of numerical-analysis software
• List of statistical software
• Rmetrics

Notes

References

External links

• Official website of the R project
• R Technical Papers