R is a programming language and software environment

for statistical analysis, graphics representation and

reporting.
 R is a language and environment for statistical computing and graphics.
R was created by Ross Ihaka and Robert Gentleman at the University of
Auckland, New Zealand, and is currently developed by the R Development Core
Team.
R is freely available under the GNU General Public License, and pre-compiled
binary versions are provided for various operating systems like Linux,
Fundamentals Windows and Mac.
This programming language was named R, based on the first letter of first
name of the two R authors (Robert Gentleman and Ross Ihaka), and partly a
play on the name of the Bell Labs Language S.
R provides a wide variety of statistical (linear and nonlinear modelling, classical
statistical tests, time-series analysis, classification, clustering, …) and graphical
techniques, and is highly extensible.
One of R’s strengths is the ease with which well-designed publication-quality
plots can be produced, including mathematical symbols and formulae where
needed.
R is available as Free Software under the terms of the Free Software
Foundation’s GNU General Public License in source code form. It compiles and
runs on a wide variety of UNIX platforms and similar systems (including
FreeBSD and Linux), Windows and MacOS.
 R, in both its base form and user-written packages, is available on the
Comprehensive R Archive Network (CRAN) at the R home page, http://www .r-
Installation: project.org/.
Click CRAN and choose a site near you to download the appropriate base
Downloading R package for your operating system (OS).
from CRAN For most users, installing R is quite simple, regardless of the platform. You
can find precompiled binaries for Windows, Linux, and Mac OS X on CRAN. You
should be able to simply download the appropriate file and install R.
 if you’re running a Linux distribution with a centralized package repository,
such as Fedora or Ubuntu, you can install R using your OS’s package manager.
For example, if you’re running Fedora, you can install R by typing the following
Installing from a at the command line:
Linux Package $ yum install R
Manager For a Debian-based system, such as Ubuntu, the command looks like this:
$ sudo apt-get install r-base
 R is an integrated suite of software facilities for data manipulation, calculation
and graphical display. It includes
• an effective data handling and storage facility,
• a suite of operators for calculations on arrays, in particular matrices,
Uses of R • a large, coherent, integrated collection of intermediate tools for data analysis,
software • graphical facilities for data analysis and display either on-screen or on
hardcopy, and
• a well-developed, simple and effective programming language which includes
conditionals, loops, user-defined recursive functions and input and output
facilities.
Many users think of R as a statistics system. We prefer to think of it as an
environment within which statistical techniques are implemented. R can be
extended (easily) via packages. There are about eight packages supplied with
the R distribution and many more are available through the CRAN family of
Internet sites covering a very wide range of modern statistics.
R has its own LaTeX-like documentation format, which is used to supply
comprehensive documentation, both on-line in a number of formats and in
hardcopy.
 while doing programming in any programming language, you need to use
various variables to store various information.
Variables are nothing but reserved memory locations to store values. This
means that, when you create a variable you reserve some space in memory.
You may like to store information of various data types like character, wide
character, integer, floating point, double floating point, Boolean etc. Based on
the data type of a variable, the operating system allocates memory and
decides what can be stored in the reserved memory.
In contrast to other programming languages like C and java in R, the variables
Data Types are not declared as some data type. The variables are assigned with R-Objects
and the data type of the R-object becomes the data type of the variable. There
are many types of R-objects. The frequently used ones are −
• Vectors
• Lists
• Matrices
• Arrays
• Factors
• Data Frames
 The simplest of these objects is the vector object and there are six data types of these atomic vectors, also termed as six
classes of vectors.
DataThe
typeother R-Objects are built upon Example
the atomic vectors. Verify
Logical TRUE, FALSE v<- TRUE
print(class(v))
Output: [1] “logical”
Numeric 12.3,5,999 v<-23.5
print(class(v))
Result: [1] “numeric”
Integer 2L,34L,0L v<-2L
vectors print(class(v))
Result: [1]”integer”
Complex 3+2i v<-2+5i
print(class(v))
Result: [1]”complex”
Character ‘a’,”good”,”TRUE”,’23.4’ v<-”TRUE”
print(class(v))
Result:[1]”character”
Raw “Hello” is stored as 48 65 6c 6c 6f v<-charToRaw(“Hello”)
print(class(v))
Result:[1] “Raw”
 In R programming, the very basic data types are the R-objects
called vectors which hold elements of different classes as shown above.
When you want to create vector with more than one element, you should
use c() function which means to combine the elements into a vector.
# Create a vector.
apple <- c(“red”,”green”,"yellow")
print(apple)
VECTORS Result:
[1] "red" "green" "yellow"

# Get the class of the vector.

print(class(apple))
Result :
[1] "character"
 A list is an R-object which can contain many different types of elements inside it like vectors,
functions and even another list inside it.
# Create a list.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.

print(list1)
When we execute the above code, it produces the following result −
LISTS
[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]

function (x) .Primitive("sin")

 A matrix is a two-dimensional rectangular data set. It can be created using a
vector input to the matrix function.
# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
Matrices print(M)
When we execute the above code, it produces the following result −

[,1] [,2] [,3]

[1,] "a" "a" "b"
[2,] "c" "b" "a"
 While matrices are confined to two dimensions, arrays can be of any number
of dimensions. The array function takes a dim attribute which creates the
Arrays required number of dimension. In the below example we create an array with
two elements which are 3x3 matrices each.
# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)
When we execute the above code, it produces the following result −

,,1

[,1] [,2] [,3]

[1,] "green" "yellow" "green"
[2,] "yellow" "green" "yellow"
[3,] "green" "yellow" "green"

,,2

[,1] [,2] [,3]

[1,] "yellow" "green" "yellow"
[2,] "green" "yellow" "green"
[3,] "yellow" "green" "yellow"
 Factors are the r-objects which are created using a vector. It stores the vector
along with the distinct values of the elements in the vector as labels. The labels are
always character irrespective of whether it is numeric or character or Boolean
etc. in the input vector. They are useful in statistical modeling.
Factors are created using the factor() function. The nlevels functions gives the
count of levels.

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')
Factors
# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.

print(factor_apple)
print(nlevels(factor_apple))
When we execute the above code, it produces the following result −

[1] green green yellow red red red green

Levels: green red yellow
[1] 3
 Data frames are tabular data objects. Unlike a matrix in data frame each
column can contain different modes of data. The first column can be numeric
while the second column can be character and third column can be logical. It
Data Frames is a list of vectors of equal length.
A data frame is a table or a two-
dimensional array-like structure in which Data Frames are created using the data.frame() function.
each column contains values of one
variable and each row contains one set
of values from each column. # Create the data frame.
Following are the characteristics of a
data frame: BMI <- data.frame(
The column names should be non-empty. gender = c("Male", "Male","Female"),
The row names should be unique. height = c(152, 171.5, 165),
The data stored in a data frame can be weight = c(81,93, 78),
of numeric, factor or character type.
Age = c(42,38,26)
Each column should contain same
number of data items. )
print(BMI)
When we execute the above code, it produces the following result −

gender height weight Age

1 Male 152.0 81 42
2 Male 171.5 93 38
3 Female 165.0 78 26
 emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
Create Data
Frame start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11","
2015-03-27")),
stringsAsFactors = FALSE
)
# Print the data frame.
print(emp.data)
 emp_id emp_name salary start_date
11 Rick 623.30 2012-01-01
22 Dan 515.20 2013-09-23
33 Michelle 611.00 2014-11-15
44 Ryan 729.00 2014-05-11
55 Gary 843.25 2015-03-27