Basic Operations and Functions
Arithmetic operations in R include addition, subtraction, multiplication, division, and exponentiation. These fundamental operations form the basis of more complex calculations in data analysis.
+): Adds two or more numbers. Can be used for summing elements in a vector. -): Subtracts one number from another. Useful for calculating differences. *): Multiplies numbers. Can be used element-wise in vectors. /): Divides one number by another. Handles both integer and floating-point numbers. ^): Raises a number to the power of another. # Basic arithmetic operations
addition <- 5 + 3 # Adding 5 and 3
subtraction <- 10 - 4 # Subtracting 4 from 10
multiplication <- 2 * 6 # Multiplying 2 and 6
division <- 8 / 2 # Dividing 8 by 2
exponentiation <- 3^2 # 3 raised to the power of 2The above basic operations are essential tools in data analysis. In R, you can use these operations repeatedly to manipulate data effectively.
# Modulus and Integer Division
modulus <- 10 %% 3 # Modulus: remainder of 10 divided by 3
int_div <- 10 %/% 3 # Integer Division: quotient of 10 divided by 3
modulus[1] 1int_div[1] 3# Vector operations
vec1 <- c(1, 2, 3)
vec2 <- c(4, 5, 6)
vec1[1] 1 2 3vec2[1] 4 5 6vec_add <- vec1 + vec2 # Element-wise addition of vectors
vec_add[1] 5 7 9vec_sub <- vec1 - vec2 # Element-wise subtraction of vectors
vec_sub[1] -3 -3 -3vec_mul <- vec1 * vec2 # Element-wise multiplication of vectors
vec_mul[1] 4 10 18vec_div <- vec1 / vec2 # Element-wise division of vectors
vec_div[1] 0.25 0.40 0.50vec_exp <- vec1^2 # Element-wise exponentiation of vectors
vec_exp[1] 1 4 9The modulus operation (%%) is useful for determining whether a number is even or odd, while integer division (%/%) is helpful in splitting data into equal parts.
Vector operations are powerful tools in R. They allow you to process multiple elements at once, making data manipulation more efficient.
# Complex number arithmetic
complex_add <- 2 + 3i + 1 - 2i # Addition and subtraction of complex numbers
complex_add[1] 3+1iR also supports complex number operations. In complex numbers, i represents the imaginary unit.
Experiment with different types of numbers, including complex numbers, to understand these operations fully.
Statistical functions in R allow for quick and efficient summary statistics, providing insights into datasets.
# Example data: Scores of superheroes
scores <- c(85, 90, 78, 92, 88)
# Basic statistical functions
mean_score <- mean(scores)
mean_score[1] 86.6median_score <- median(scores)
median_score[1] 88sd_score <- sd(scores)
sd_score[1] 5.458938variance_score <- var(scores)
variance_score[1] 29.8This example applies statistical functions to a dataset of superhero scores. By comparing the mean and median, you can gain insight into the data’s distribution.
# Additional statistical functions
range_scores <- range(scores) # Minimum and maximum
min_score <- min(scores) # Minimum score
max_score <- max(scores) # Maximum score
# Summary statistics
summary_scores <- summary(scores) # Comprehensive summary statistics
summary_scores Min. 1st Qu. Median Mean 3rd Qu. Max.
78.0 85.0 88.0 86.6 90.0 92.0 # Quantile calculation
quantiles <- quantile(scores, probs = c(0.25, 0.5, 0.75)) # 25th, 50th, and 75th percentiles
quantiles25% 50% 75%
85 88 90 The summary() function is a very useful tool for quickly getting an overview of key statistics in your data. Use it frequently to analyze your datasets efficiently.
To explore the functionality and parameters of R’s built-in functions, use:
# Accessing help documentation
# ?mean
# help(sum)The ? or help() functions in R are invaluable resources for learning how to use functions. Regularly explore and experiment with new functions to expand your skills.
Matrices are a fundamental data structure in R, useful for representing data in two dimensions. Understanding how to create and manipulate matrices is crucial for more advanced data analysis.
# Creating a matrix
matrix1 <- matrix(1:9, nrow = 3, ncol = 3) # Creating a 3x3 matrix with numbers 1 to 9
matrix1 [,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9# Transposing a matrix
transpose_matrix1 <- t(matrix1) # Transposing the matrix (swapping rows and columns)
transpose_matrix1 [,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9When creating matrices, use the matrix() function and specify the number of rows and columns with the nrow and ncol arguments. The t() function is used to compute the transpose of a matrix.
# Matrix addition and subtraction
matrix2 <- matrix(9:1, nrow = 3, ncol = 3) # Creating a second matrix with numbers 9 to 1
matrix2 [,1] [,2] [,3]
[1,] 9 6 3
[2,] 8 5 2
[3,] 7 4 1matrix_add <- matrix1 + matrix2 # Matrix addition
matrix_add [,1] [,2] [,3]
[1,] 10 10 10
[2,] 10 10 10
[3,] 10 10 10matrix_sub <- matrix1 - matrix2 # Matrix subtraction
matrix_sub [,1] [,2] [,3]
[1,] -8 -2 4
[2,] -6 0 6
[3,] -4 2 8# Matrix multiplication
matrix_mul <- matrix1 %*% matrix2 # Matrix multiplication (linear algebra multiplication)
matrix_mul [,1] [,2] [,3]
[1,] 90 54 18
[2,] 114 69 24
[3,] 138 84 30# Element-wise multiplication
element_mul <- matrix1 * matrix2 # Element-wise multiplication (multiplying corresponding elements)
element_mul [,1] [,2] [,3]
[1,] 9 24 21
[2,] 16 25 16
[3,] 21 24 9# Solving Ax = b where A is a matrix and b is a vector
A <- matrix(c(2, 1, 1, 3), nrow = 2) # Creating a 2x2 matrix A
b <- c(1, 2) # Creating vector b
solution <- solve(A, b) # Finding the solution x to the equation Ax = b
solution [1] 0.2 0.6The solve() function is used to solve systems of linear equations, which is fundamental in linear algebra. This can be particularly useful in data analysis and modeling.
Creating custom functions allows you to encapsulate code for reuse and better organization. This is especially useful when performing complex analyses.
# Function to calculate the square of a number
square <- function(x) {
return(x^2) # Returns the square of the given number
}
# Using the function
result <- square(4) # Executing the function: calculates the square of 4
result[1] 16When creating a function, use the function() keyword to define inputs, and return() to specify the output. The example above is a simple function that squares a number.
# Function to calculate the mean and standard deviation of a vector
mean_sd <- function(x) {
m <- mean(x) # Calculate mean
s <- sd(x) # Calculate standard deviation
return(list(mean = m, sd = s)) # Return both mean and standard deviation as a list
}# Using the function
stats <- mean_sd(scores) # Execute the function: calculates mean and standard deviation for scores
stats$mean
[1] 86.6
$sd
[1] 5.458938This function simultaneously calculates the mean and standard deviation and returns them as a list. Lists are useful for returning multiple results from a function.
# Function to check if a number is even or odd
even_or_odd <- function(num) {
if (num %% 2 == 0) { # Conditional statement: checks if the number is even
return("Even") # Returns "Even" if the number is even
} else { # If the number is odd
return("Odd") # Returns "Odd"
}
}
# Testing the function
test_number <- 7
even_or_odd_result <- even_or_odd(test_number) # Execute the function: checks if 7 is even or odd
even_or_odd_result[1] "Odd"# Function to calculate the power of a number with a default exponent
power <- function(base, exponent = 2) {
return(base^exponent) # Calculates the power using the default exponent
}
# Using the function with default and custom exponent
default_power <- power(3) # Uses default exponent of 2 to calculate 3^2
default_power[1] 9custom_power <- power(3, 3) # Raises 3 to the power of 3
custom_power[1] 27Using default arguments allows for more flexible function calls, where certain parameters can be omitted for simplicity. In this example, the default exponent is 2, but it can be changed as needed.
# Step 1: Creating the vector
data <- c(12, 17, 14, 22, 15, 19, 16)
# Step 2: Basic statistical functions
mean_data <- mean(data)
median_data <- median(data)
sd_data <- sd(data)
var_data <- var(data)
# Step 3: Min, Max, and Range
min_data <- min(data)
max_data <- max(data)
range_data <- range(data)
# Step 4: Summary statistics
summary_data <- summary(data)# Step 1: Creating matrices
matrix_A <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
matrix_B <- matrix(c(6, 5, 4, 3, 2, 1), nrow = 2, ncol = 3)
# Step 2: Element-wise operations
matrix_add <- matrix_A + matrix_B
matrix_sub <- matrix_A - matrix_B
# Step 3: Transposing matrix_A
matrix_A_T <- t(matrix_A)
# Step 4: Multiplying matrix_A_T by the original matrix_B
# This will work because matrix_A_T is 3x2 and matrix_B is 2x3
matrix_mul <- matrix_A_T %*% matrix_B# Step 1: Function to calculate the cube of a number
cube <- function(x) {
return(x^3)
}
# Step 2: Using the cube function on a vector
numbers <- c(2, 3, 4)
cubes <- sapply(numbers, cube)
# Step 3: Function to check if a number is positive, negative, or zero
is_positive <- function(num) {
if (num > 0) {
return("Positive")
} else if (num < 0) {
return("Negative")
} else {
return("Zero")
}
}
# Step 4: Testing the is_positive function
result_1 <- is_positive(5) # Should return "Positive"
result_2 <- is_positive(-3) # Should return "Negative"
result_3 <- is_positive(0) # Should return "Zero"In this session, we’ve delved into the basics of arithmetic operations, statistical functions, and built-in R functions. Mastery of these fundamental concepts is key to leveraging R for data analysis and statistical computation.
Practice using these functions with various datasets to build confidence and deepen your understanding.
Q&A: Please share any questions or topics you’d like to explore further. Let’s address any uncertainties and discuss the potential applications of these concepts in real-world data analysis scenarios.