S.R.N.

Mehta Degree College

Sub: Statistical Computing & R Programming Marks: 60
__________________________________________________________________________________________________
UNIT-1
Introduction:

1).Write a note on R Programming?

R is a programming language and software environment specifically designed for statistical computing and graphics. It was
developed by Ross Ihaka and Robert Gentleman in the early 1990s and is an open-source implementation of the S programming
language.

Key characteristics and uses of R:

Statistical Computing:
R provides a comprehensive suite of tools for statistical analysis, including statistical tests, modeling (e.g., linear and generalized
linear models), time series analysis, classification, and clustering.
Data Analysis and Manipulation:
It offers robust capabilities for handling and manipulating diverse data types, including vectors, matrices, arrays, lissts, and data
frames.
Data Visualization:
R excels in creating high-quality graphical representations of data, such as histograms, scatter plots, box plots, and more complex
visualizations, often leveraging powerful packages like ggplot2.
Open-Source and Extensible:
R is free and open-source, supported by a large and active community that contributes a vast ecosystem of packages (libraries of
functions) for specialized tasks, extending its functionality significantly.
Platform Independent:
R code can be run on various operating systems, including Windows, macOS, and Linux.
Applications:
R is widely used in academia, research, data science, and various industries (e.g., finance, healthcare, marketing) for tasks like data
cleaning, exploration, predictive modeling, and reporting.
R is used in a variety of fields, including:
Data Science and Machine Learning: R is widely used for data analysis, statistical modeling and machine learning tasks.
Finance: Financial analysts use R for quantitative modeling and risk analysis.
Healthcare: In clinical research, R helps analyze medical data and test hypotheses.
Academia: Researchers and statisticians use R for data analysis and publishing reproducible research.
Advantages of R Programming
Comprehensive Statistical Tools: R includes many statistical functions and models, making it the ideal choice for data analysis.
Customizable Visualizations: R’s visualization tools allows for customizations for a simple bar chart or a detailed heatmap.
Extensive Community Support: R has a large user base and there are countless resources, forums and tutorials available.
Highly Extendable: The availability of over 15,000 R packages means we can extend R's functionality to suit any project or need.

Disadvantages of R Programming
Memory Intensive: R can be slow with very large datasets, consuming a lot of memory.
Limited Support for Error Handling: Unlike some other programming languages, R has less robust error handling features.
Steeper Learning Curve: Beginners might face challenges with some of R’s complex features and syntax.
Performance: R’s performance can lag behind languages like Python or C++ when it comes to speed, especially for large-scale
operations.
Key Features of R :

Cross-Platform Support: R works on multiple operating systems, making it versatile for different environments.
Interactive Development: R allows users to interactively experiment with data and see the results immediately.
Data Wrangling: Data cleaning Tool) Tools like dplyr and tidyr help simplify data cleaning and transformation.
Statistical Modeling: R has built-in support for various statistical models like regression, time-series analysis and clustering.
Reproducible Research: With R Markdown, users can combine code, output and narrative in one document, ensuring their
analysis is reproducible.

2). Explain datatypes of R programming Language?

Basic Data Types
Basic data types in R can be divided into the following types:
numeric - (10.5, 55, 787)
integer - (1L, 55L, 100L, where the letter "L" declares this as an integer)
complex - (9 + 3i, where "i" is the imaginary part)
character (string) - ("k", "R is exciting", "FALSE", "11.5")
logical (boolean) - (TRUE or FALSE).
Raw

Numeric Data type

Decimal values are called numeric in R. It is the default R data type for numbers in R.
If we assign a decimal value to a variable x as follows, x will be of numeric type.
Real numbers with a decimal point are represented using this data type in R.
It uses a format for double-precision floating-point numbers to represent numerical values.

Eg: x = 5.6

print(class(x)) output: "numeric"

print(typeof(x)) output: "double"

2) Integer Data type

R supports integer data types which are the set of all integers. we can create as well as convert a value into an integer type using
the [Link]() function.
we can also use the capital 'L' notation as a suffix to denote that a particular value is of the integer R data type.

x = [Link](5) output: "integer"

print(class(x)) output: "integer"
print(typeof(x)) output: "integer"
3).Logical Data type
R has logical data types that take either a value of true or false. A logical value is often created via a comparison between variables.
Boolean values, which have two possible values, are represented by this R data type: FALSE or TRUE
x=4
y=3
z=x>y
print(class(z)) "logical"
print(typeof(z)) "logical"

4. Complex Data type

R supports complex data types that are set of all the complex numbers. The complex data type is to store numbers with an
imaginary component.
x = 4 + 3i
print(class(x)) "complex"
print(typeof(x)) "complex"

5. Character Data type

R supports character data types where we have all the alphabets and special characters. It stores character values or strings.
Strings in R can contain alphabets, numbers, and symbols.

char=”SRNMEHTA”

print(class(char)) "character"
print(typeof(char)) "character"

6. Raw data type

To save and work with data at the byte level in R, use the raw data type. By displaying a series of unprocessed bytes, it enables low-
level operations on binary data. Here are some speculative data on R's raw data types:

x <- [Link](c(0x1, 0x2, 0x3, 0x4, 0x5))

print(x)

Output
[1] 01 02 03 04 05

3). Explain the datastructures in R PRogramming

R programming provides several fundamental data structures to organize and store data, each suited for different types of data and
analytical tasks. These can be categorized by their dimensionality and whether they are homogeneous (containing elements of the
same data type) or heterogeneous (containing elements of different data types). This gives rise to the six data types which are
most frequently utilized in data analysis.
1. Vectors
A vector is an ordered collection of basic data types of a given length. The only key thing here is all the elements of a vector must
be of the identical data type e.g homogeneous data structures. Vectors are one-dimensional data structures.
Example:
X = c(1, 3, 5, 7, 8)

print(X)
Output:
[1] 1 3 5 7 8

2. Lists
A list is a generic object consisting of an ordered collection of objects. Lists are heterogeneous data structures. These are also one-
dimensional data structures. A list can be a list of vectors, list of matrices, a list of characters and a list of functions and so on.
Example:
empId = c(1, 2, 3, 4,5)
empName = c("BCA1sem", "BCA2sem", " BCA3sem”,” BCA4sem ", " BCA5sem ")
numberOfEmp = 4
empList = list(empId, empName, numberOfEmp)
print(empList)

[[1]]
[1] 1 2 3 4 5
[[2]]
[2] “BCA1sem” “BCA2sem” “BCA3sem” “BCA4sem” “BCA5sem”Lists

3. Data Frames
Data frames are generic data objects of R which are used to store the tabular data. Data frames are the foremost popular data
objects in R programming because the data within the tabular form. They are two-dimensional, heterogeneous data structures.
These are lists of vectors of equal lengths.
Data frames have the following constraints placed upon them:
A data-frame must have column names and every row should have a unique name.
Each column must have the identical number of items.
Each item in a single column must be of the same data type.
Different columns may have different data types.
To create a data frame we use the [Link]() function.
Example:
Name = c("Amulya", "Raj", "Asish")
Language = c("R", "Python", "Java")
Age = c(22, 25, 45)

df = [Link](Name, Language, Age)

print(df)
Output:
Name Language Age
1 Amulya R 22
2 Raj Python 25
3 Asish Java 45

4. Matrices
A matrix is a rectangular arrangement of numbers in rows and columns. In a matrix, as we know rows are the ones that run
horizontally and columns are the ones that run vertically. Matrices are two-dimensional, homogeneous data structures.

Example:
A = matrix(
c(1, 2, 3, 4, 5, 6, 7, 8, 9),
nrow = 3, ncol = 3,
byrow = TRUE
)
print(A)
Output:
[,1] [,2] [,3]
[1,]1 2 3
[2,] 4 5 6
[3,] 7 8 9

5. Arrays
Arrays are the R data objects which store the data in more than two dimensions. Arrays are n-dimensional data structures. For
example, if we create an array of dimensions (2, 3, 3) then it creates 3 rectangular matrices each with 2 rows and 3 columns. They
are homogeneous data structures.
Example:
A = array(
c(1, 2, 3, 4, 5, 6, 7, 8),
dim = c(2, 2, 2)
)
print(A)

1 3
2 4

5 7
6 8
6. Factors
Factors are the data objects which are used to categorize the data and store it as levels. They are useful for storing categorical data.
They can store both strings and integers. They are useful to categorize unique values in columns like (“TRUE” or “FALSE”) or
(“MALE” or “FEMALE”), etc.. They are useful in data analysis for statistical modeling.
Example:
# Creating factor using factor()
fac = factor(c("Male", "Female", "Male",
"Male", "Female", "Male", "Female"))

print(fac)
Output:
[1] Male Female Male Male Female Male Female
Levels: Female Male

4). Special values in R programming language:

R programming includes several special values that represent specific conditions or results of operations. These values are:
 NA (Not Available): Represents missing or undefined data. It is commonly encountered when dealing with incomplete
datasets or when a calculation produces an uncomputable result due to missing input.
Eg:
x <- c(1, 2, NA, 4)
[Link](x) # Checks for NA values

 NULL: Represents the absence of an object or value. It is often used as an argument in functions to indicate that no value
has been assigned to a particular parameter, or returned by functions that do not produce a meaningful output.
Eg:
my_list <- list(a = 1, b = NULL, c = 3)
[Link](my_list$b) # Checks if an object is NULL

 Inf (Infinity) and -Inf (Negative Infinity): Represent positive and negative mathematical infinity, respectively. These values
can result from operations like division by zero or computations involving extremely large numbers that exceed R's
numerical limits.
Eg:
1/0 Results in Inf
-2^1024 Results in -Inf

 NaN (Not a Number): Represents an undefined or unrepresentable numerical result, such as the result of operations like
0/0 or Inf - Inf.
Eg:
0/0 # Results in NaN
Inf - Inf # Results in NaN

These special values are distinct from each other and can be checked using specific functions like [Link](), [Link](), [Link](),
and [Link](). Understanding and handling these special values is crucial for robust data analysis and programming in R.
5) .Explain the Classes in R Programming?
R has a unique three-class system: S3, S4, and Reference Classes. Each of these class systems has distinct characteristics and is used
to define and manage objects and their methods effectively.

1. S3 Class
S3 is the most widely used OOP system in R, but it lacks a formal definition and structure. An object of this type can be created
simply by adding an attribute to it.

2. S4 Class
Programmers familiar with languages like C++ or Java may find S3 significantly different from their typical concept of classes, as it
lacks the structure usually associated with classes. S4 improves upon S3 by providing a more formal definition for objects and
offering a clear structure for managing them.

[Link] Class
Reference Classes are an improvement over S4 Classes. In this system, methods are associated with the classes, making them more
similar to object-oriented classes in other languages. Defining a Reference Class is similar to defining an S4 class. Instead
of setClass(), we use setRefClass(), and instead of "slots," we use "fields."

6).Coercion of R programming?
Ans: In R programming, coercion refers to the automatic or explicit conversion of data from one type to another so that operations
can be performed correctly. Datatype conversion from one type to another type.

Types of Coercion in R

Implicit (Automatic) Coercion

Happens when R automatically converts data types to a common type in a vector or expression.
Example:
x <- c(1, 2, "3") here vector has dissimilar type [Link] converts implicitly to character type.
x
Output:
[1] "1" "2" "3"
Here, numbers are converted to characters because a vector in R can hold only one type.
R follows this hierarchy for automatic coercion:
logical → integer → numeric → complex → character

Explicit (Manual) Coercion

Done using functions like:
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()

Example:
x <- "123"
[Link](x)
Output:
[1] 123

Examples of Coercion

Logical to Numeric
 [Link](TRUE) # 1
[Link](FALSE) # 0
Character to Numeric
[Link]("5") # 5
[Link]("abc") # NA (with warning)

Mixing Types in Vectors

v <- c(TRUE, 2, "text")
v
Output:
[1] "TRUE" "2" "text"

7).Basic plotting in R programming?

In R programming, plotting is one of the most important tools for data visualization. R provides powerful built-in functions and
packages for creating plots and graphs.
1. Basic Plot Function
The most commonly used function is:
plot(x, y, type, main, xlab, ylab, col, pch)
x, y → numeric vectors (data points)
type → type of plot:
"p" (points, default)
"l" (lines)
"b" (both points and lines)
"h" (vertical lines)
"s" or "S" (stair steps)
main → title of the plot
xlab, ylab → labels for axes
col → color of points/lines
pch → symbol type (e.g., 1 = circle, 2 = triangle, 3 = plus, etc.)
Example:
x <- c(1,2,3,4,5)
y <- c(2,4,6,8,10)
plot(x, y, type="p", main="Basic Scatter Plot", xlab="X values", ylab="Y values", col="blue", pch=16)

2. Line Plot
plot(x, y, type="l", main="Line Plot", col="red")
3. Combined Points and Lines
plot(x, y, type="b", main="Points and Lines", col="darkgreen")
4. Bar Plot
values <- c(25, 40, 30, 50)
names <- c("A", "B", "C", "D")
barplot(values, [Link]=names, col="orange", main="Bar Plot")
5. Histogram
data <- c(2,3,5,6,6,7,8,9,10,10,12,13,15)
hist(data, col="skyblue", main="Histogram", xlab="Values")
6. Pie Chart
slices <- c(20, 15, 30, 35)
labels <- c("Apples", "Bananas", "Cherries", "Dates")
pie(slices, labels=labels, col=rainbow(length(slices)), main="Pie Chart")
7. Boxplot
data <- c(7,8,5,6,12,14,7,9,10,15,8)
boxplot(data, col="pink", main="Boxplot Example")
8. Multiple Plots in One Window
 par(mfrow=c(2,2)) # 2 rows, 2 columns
plot(x, y)
barplot(values)
hist(data)
boxplot(data)

_______________________________________ End ___________________________________

UNIT-2
________________________________________________________________________________________________

1).Reading and writing files

In R programming, reading and writing files is a very common task for handling datasets.
1. Reading and Writing Text Files
Reading:
# Read a text file line by line
data <- readLines("[Link]")
print(data)
Writing:
# Write text to a file
lines <- c("This is line 1", "This is line 2", "This is line 3")
writeLines(lines, "[Link]")

2. Reading and Writing CSV Files

CSV (Comma-Separated Values) is the most common format for datasets.

Reading:
# Read CSV file into a data frame
data <- [Link]("[Link]", header = TRUE)
print(data)
Writing:
# Write data frame to CSV file
[Link](data, "[Link]", [Link] = FALSE)

3. Reading and Writing Excel Files

For Excel files, we need the readxl and writexl packages.

Reading:
library(readxl)

# Read Excel file

data <- read_excel("[Link]", sheet = 1)
print(data)
Writing:
library(writexl)

# Write data to Excel file

write_xlsx(data, "[Link]")

4. Reading and Writing R Data Files

R has its own format for saving objects.
Save R objects:
# Save data frame to .RData file
save(data, file = "[Link]")

# Save multiple objects

save(data, lines, file = "[Link]")
Load R objects:
# Load RData file
load("[Link]")
Writing Files:
R supports several file formats working with (plain text, CSV, Excel, RDS, etc.).

1. Writing Text Files

write plain text or vectors to a file.
# Write a character vector to a text file
lines <- c("Hello", "This is a test file", "Written in R")
writeLines(lines, "[Link]")

2. Writing CSV Files

Common for data frames.
# Example data frame
df <- [Link](
Name = c("Alice", "Bob", "Charlie"),
Age = c(25, 30, 35),
Score = c(90, 85, 88)
)

# Write to CSV
[Link](df, "[Link]", [Link] = FALSE)

# Alternative with tab separator

[Link](df, "[Link]", sep = "\t", [Link] = FALSE)

3. Writing R Objects (Binary Format)

To save R objects to load later.
# Save object
save(df, file = "[Link]")

# Load back later

load("[Link]")

# Save a single object in RDS format

saveRDS(df, "[Link]")

# Load it back
df2 <- readRDS("[Link]")

4. Writing Excel Files

Requires the openxlsx or writexl package.
# Using writexl
[Link]("writexl")
library(writexl)

write_xlsx(df, "[Link]")

5. Appending to a File

cat("New line \n", file = "[Link]", append = TRUE)

6. dump() : dump() is a function for dumpling a textual representation of multiple R objects.

[Link](): dput() is used for outputting a textual representation of an R project.
[Link](): is useful for saving an arbitrary number of R objects in binary format to a file.

2).Programming in R Language:
Introduction to R Programming
R is a programming language mainly used for statistics, data analysis, and visualization. It is widely used by data scientists,
statisticians, and researchers.
Basic Features
 Open-source and free.
 Works well with data manipulation and visualization.
 Huge collection of packages (like ggplot2, dplyr).
 Supports matrix and vector operations directly.

Basic R Syntax
1. Printing & Variables
# Print text
print("Hello, R Programming!")

# Assigning values
x <- 10
y <- 20
z = x + y # Alternative assignment
print(z)
2. Data Types
num <- 25 # Numeric
txt <- "R Language" # Character
flag <- TRUE # Logical
vec <- c(1,2,3,4) # Vector
3. Control Structures
# If-else
x <- 5
if (x > 0) {
print("Positive")
} else {
print("Non-positive")
}

# For loop
for (i in 1:5) {
print(i)
}
4. Functions
# Defining a function
add_numbers <- function(a, b) {
return(a + b)
}

Calling function
result <- add_numbers(10, 15)
print(result)
5. Working with Data
# Create a dataframe
data <- [Link](
Name = c("Asha", "Raj", "Kiran"),
Age = c(21, 25, 30)
)

print(data)
Plotting
Example
x <- c(1,2,3,4,5)
y <- c(2,4,6,8,10)
plot(x, y, type="b", col="blue", main="Simple Plot", xlab="X-axis", ylab="Y-axis")

3).What is calling Function?

In R programming, a function is a block of code that performs a specific task.

Calling a function means executing it by using its name and passing arguments (if required).

General Syntax for Calling a Function:

function_name(arguments)
function_name → the name of the function we want to use.
arguments → values we pass to the function (optional if not required).

Example 1: Calling a Built-in Function

# Built-in function:
sqrt()
result <- sqrt(25) # calling sqrt() function print(result)

Output:
[1] 5

Example 2: Calling a Function with Multiple Arguments

# Built-in function:
sum()
total <- sum(10, 20, 30, 40) # calling sum() function print(total)
Output:
[1] 100

Example 3: Calling a User-defined Function

# Define a function
add_numbers <- function(a, b)
{
return(a + b)
} # Call the function
result <- add_numbers(15, 25) print(result)
Output:
[1] 40

Key Points:
 Functions must be defined before they are called.
 we can pass arguments by position or by name.
 Some functions have default values for arguments.

4. Conditions statements in R PRogramming .

In R, conditionals help control the flow of a program. They evaluate Boolean expressions and execute certain blocks of code
depending on whether the expression evaluates to TRUE or FALSE. This is especially useful while working with dynamic data,
automating tasks, or writing functions with variable behavior.

1.R If Statement
The R if statement is used to run a block of code if a condition is TRUE.
Here is a flowchart that showcases the flow of the if statement in R:

R If Statement Syntax

if (condition) {
# Code to execute if condition is TRUE
}
R If Statement Example
This example demonstrates the usage of the if statement in R:
x <- 10

if (x > 6) {
print("x is greater than 6")
}
Output:
[1] "x is greater than 6"

2.R If-Else Statement

The R if-else statement allows the execution of a block of code if a condition is TRUE, and a separate block of code if the
condition is FALSE.

3.R If-Else Statement Syntax

if (condition) {
# Code to execute if condition is TRUE
} else {
# Code to execute if condition is FALSE
}
R If-Else Statement Example
This example demonstrates the usage of the if-else statement in R:
x <- 3

if (x > 6) {
print("x is greater than 6")
} else {
print("x is less than or equal to 6")
}
output:
[1] "x is less than or equal to 6"

4. R Else-If Statement
When there is a need to check multiple conditions, the R else-if statement can be used to evaluate them sequentially.

R Else-If Statement Syntax

if (condition1) {
# Code if condition1 is TRUE
} else if (condition2) {
# Code if condition2 is TRUE
} else {
# Code if all conditions are FALSE
}
R Else-If Statement Example
This example demonstrates the usage of the else-if statement in R:
x <- 5

if (x > 12) {
print("x is greater than 12")
} else if (x == 5) {
print("x is equal to 5")
} else {
print("x is less than 12 and not equal to 5")
}

output:
[1] "x is equal to 5"

[Link] R If Statement

R if statements can be nested within each other for more complex logical checks.
Nested R If Statement Syntax
if (condition1) {
if (condition2) {
# Code to execute if both condition1 and condition2 are TRUE
}
}
Nested R If Statement Example
This example demonstrates the usage of nested if statements in R:
x <- 8
y <- 3

if (x > 6) {
if (y < 6) {
print("x is greater than 6 and y is less than 6")
}
}

output:
[1] "x is greater than 6 and y is less than 6"

[Link]() Statement
Used to select from multiple options.
choice <- "B"
result <- switch(choice,
"A" = "You chose A",
"B" = "You chose B",
"C" = "You chose C",
"Invalid choice")
print(result)

5).Looping Statements in R Programming Languages.

Loop:
A Loop is a Control statement that allows multiple executions of a statement or a set of statements. The word “looping” means
cycling or iterating. There are two components of a loop,control statement and the loop body. The control statement controls the
execution of statements depending on the condition and the loop body consists of the set of statements to be executed.

There are three types of loops in R Programming :

For loop
While loop
Repeat Loop

for loop
 Used when we know how many times we want to repeat.
 Iterates over a sequence (vector, list, etc.).
Syntax:
for (variable in sequence) {
# statements
}
Example:
for (i in 1:5) {
print(paste("Iteration:", i))
}

2. while loop
 Used when the number of iterations are not fixed.
 Runs until the condition becomes FALSE.
Syntax:
while (condition) {
# statements
}
Example:
count <- 1
while (count <= 5) {
print(paste("Count is", count))
count <- count + 1
}

3. repeat loop
 Runs indefinitely until a break statement is encountered.
 Must include a break to stop the loop, otherwise it will run infinitely.
Syntax:
repeat {
# statements
if (condition) {
break
 }
}
Example:
x <- 1
repeat {
print(x)
x <- x + 1
if (x > 5) {
break
}
}

6. Control statements inside loops

Control statements change the flow of execution inside a loop.
In R programming (and most other languages), the main control statements used inside loops are:
1. break → exits the loop completely.
2. next (similar to continue in other languages) → skips the current iteration and moves to the next.
3. return → exits from a function (not just the loop).

1. break Statement
Stops the loop when a condition is met.
# Example:
Stop loop when x = 3
for (x in 1:5) {
if (x == 3) {
break # exit loop
}
print(x)
}
Output:
[1] 1
[1] 2
Loop ended when x = 3.

2. next Statement
Skips current iteration and continues with the next one.
# Example: Skip 3
for (x in 1:5) {
if (x == 3) {
next # skip printing 3
}
print(x)
}
Output:
[1] 1
[1] 2
[1] 4
[1] 5
3 was skipped.

3. return Statement
Used inside a function to exit and return a value.
# Example: Find first even number
find_even <- function(nums) {
 for (n in nums) {
if (n %% 2 == 0) {
return(n) # exit function immediately
}
}
}

print(find_even(1:10))
Output:
[1] 2
Function returned as soon as it found the first even number.

 break → exits loop completely.

 next → skips one iteration, continues loop.
 return → exits function (can be used inside loops in functions).

[Link] are Standalone Statements?

Standalone statements are the independent instructions in a program that perform some action by themselves.
They are not part of an expression and don’t need to return a value to be valid.
Each one executes independently.
Examples
 Assignment statement
 Input/Output statement
 Function call
 Control flow (like break, continue)

8. Explain Stacking Statements.

In R programming, "stacking statements" can refer to several concepts, but it most commonly relates to nested control flow
structures (like if statements or loops within other if statements or loops) or stacking data (combining data from multiple sources
into a single structure).
Nested Control Flow Statements
This involves placing one control flow statement inside another to handle more complex logic.

x <- 25

if (x > 10) {
print("x is greater than 10.")
if (x > 20) {
print("x is also greater than 20.")
} else {
print("But x is not greater than 20.")
}
} else {
print("x is not greater than 10.")
}
In this example, the inner if-else statement is "stacked" within the outer if statement, meaning its execution depends on the
condition of the outer if.
Stacking Data (Combining Data Structures)
This involves combining data from different sources, often columns from data frames, into a single, longer
column. The stack() function is commonly used for this purpose.
# Create a sample data frame
df <- [Link](
 col1 = c(1, 2, 3),
col2 = c(4, 5, 6),
col3 = c(7, 8, 9)
)

# Stack selected columns

stacked_data <- stack(df[, c("col1", "col3")])

# Print the stacked data

print(stacked_data)
This code will produce a data frame where the values from col1 and col3 are combined into a single values column, and a
new column indicates the original column name for each value. This demonstrates "stacking" data from multiple columns into a
single, longer column.

9).Explain about the functions in R Programming.

Functions in R are self-contained blocks of code designed to perform specific tasks. They are fundamental for organizing code,
promoting reusability, and making programs more modular and readable.

Key aspects of functions in R:

 Definition: Functions are defined using the function keyword. The basic syntax is:
Code
function_name <- function(arg_1, arg_2, ...) {
# Function body: statements to be executed
# ...
return(result) # Optional: explicitly return a value
}
 Components:
 Function name: The name used to call the function. It's stored as an object in the R environment.
 Arguments: Input values or parameters passed to the function within parentheses. These can be optional and can
have default values.
 Function body: The set of R statements enclosed in curly braces that define the function's operations.
 Return value: The value or object that the function produces as output. By default, the last evaluated expression in
the function body is returned. The return() function can be used for explicit return and to exit the function early.
 Types of Functions:
 Built-in functions: Functions pre-defined in R or its packages (e.g., mean(), sum(), print()).
 User-defined functions: Functions created by the user to perform custom tasks.
 Benefits:
 Reusability: Avoids repetitive code by encapsulating frequently performed tasks.
 Modularity: Breaks down complex problems into smaller, manageable units.
 Readability: Makes code easier to understand and maintain.
 Error reduction: Minimizes errors associated with copying and pasting code.

[Link] the exceptions in R Programming

Error Handling is a process in which we deal with unwanted or anomalous errors which may cause abnormal termination of the
program during its execution. In R Programming, there are basically two ways in which we can implement an error handling
mechanism. Either we can directly call the functions like stop() or warning() or we can use the error options such as "warn" or
"[Link]". The basic functions that one can use for error handling in the code :

1. Try-Catch Blocks
 2. Custom Error Handling

3. Stop Function

4. Finally Block (Cleanup)

5. The warning() function

 stop(...): It halts the evaluation of the current statement and generates a message argument. The control is returned to the
top level.

 waiting(...): Its evaluation depends on the value of the error option warn. If the value of the warning is negative then it is
ignored. In case the value is 0 (zero) they are stored and printed only after the top-level function completes its execution. If
the value is 1 (one) then it is printed as soon as it has been encountered while if the value is 2 (two) then immediately the
generated warning is converted into an error.

 tryCatch(...): It helps to evaluate the code and assign the exceptions.

divide_numbers <- function(x, y) {

result <- tryCatch(
{
# Try block
if (y == 0) stop("Division by zero is not allowed!")
x/y
},
error = function(e) {
# Error handling
cat("Error occurred:", e$message, "\n")
return(NA)
},
warning = function(w) {
# Warning handling
cat("Warning:", w$message, "\n")
return(NA)
},
finally = {
# Always executed
cat("Execution completed.\n")
}
)
return(result)
}

# Test cases
cat("Result 1:", divide_numbers(10, 2), "\n")
cat("Result 2:", divide_numbers(10, 0), "\n") # Error (division by zero)
cat("Result 3:", divide_numbers("a", 5), "\n") # Error (non-numeric input)

[Link] the Timings and visibility in R program.

Timings in R
Timings usually mean measuring execution time of code in R.
This is important when analyzing performance.
Common Functions:
[Link]() – Gets the current date-time.
[Link]() – Returns how much CPU time has been used.
[Link](expr) – Measures how long an expression takes.
microbenchmark package – For fine-grained benchmarking.
Example:
# Using [Link]
[Link]({
x <- rnorm(10^6) # generate 1 million random numbers
mean(x)
})

# Using [Link]
start <- [Link]()
[Link](2) # pause for 2 seconds
end <- [Link]()
end - start

2. Visibility in R
Visibility refers to whether the result of an expression is automatically printed or hidden in the console.
Rules:
By default, the result of the last evaluated expression in a function is returned visibly.
If we assign a result with <-, it is stored but not printed.
invisible() can be used to hide output explicitly.
Example:
# Visible
5+3
# Output: 8

# Assignment (not visible)

x <- 5 + 3
# No output

# Using invisible()
invisible(5 + 3)
# No output, even though it is evaluated

# Function returning invisibly

f <- function() invisible(42)
f() # No output
x <- f()
x # Output: 42

Summary:
Timings → how long the code runs ([Link], [Link], microbenchmark).
Visibility → whether results are automatically printed or hidden (invisible(), assignments).

____________________________________2 unit -------------------------------------------------------------------