INITIAL COMMIT

This commit is contained in:
Yandrik 2024-04-30 10:03:37 +02:00
commit 25f0531dcd
18 changed files with 772 additions and 0 deletions

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
.Rproj.user
.Rhistory
.RData
.Ruserdata

BIN
Rplots.pdf Normal file

Binary file not shown.

BIN
Rplots1.pdf Normal file

Binary file not shown.

53
apply.R Normal file
View File

@ -0,0 +1,53 @@
# Creating a matrix for demonstration
matrix_data <- matrix(1:9, nrow=3, byrow=TRUE)
print("Original Matrix:")
print(matrix_data)
# Using apply on a matrix
# -----------------------
# Sum of each row
row_sums <- apply(matrix_data, 1, sum)
print("Sum of each row:")
print(row_sums)
# Sum of each column
col_sums <- apply(matrix_data, 2, sum)
print("Sum of each column:")
print(col_sums)
# Creating a list for demonstration
list_data <- list(a = 1:5, b = 6:10, c = 11:15)
print("Original List:")
print(list_data)
# Using lapply on a list
# ----------------------
# Compute the mean of each element in the list
list_means <- lapply(list_data, mean)
print("Mean of each list element:")
print(list_means)
# Using sapply on a list
# ----------------------
# sapply simplifies the result to a vector or matrix if possible
list_means_simplified <- sapply(list_data, mean)
print("Simplified mean of each list element:")
print(list_means_simplified)
# Using vapply on a list
# ----------------------
# vapply allows for specifying the type of return value, making it safer than sapply
list_means_vapply <- vapply(list_data, mean, numeric(1))
print("Vapply mean of each list element:")
print(list_means_vapply)
# Creating a vector and factor for demonstration
vector_data <- c(1, 2, 3, 4, 5, 6)
factor_data <- gl(2, 3, labels = c("Group1", "Group2"))
# Using tapply on a vector
# ------------------------
# Apply a function over subsets of a vector
group_means <- tapply(vector_data, factor_data, mean)
print("Mean of vector elements by group:")
print(group_means)

42
classes.R Normal file
View File

@ -0,0 +1,42 @@
# S3 and S4 are two different object-oriented programming (OOP) systems in R.
# S3 is a simple and informal OOP system, while S4 is a more formal and rigorous OOP system.
# S3 Classes
# ----------
# Creating an S3 class
create_person_s3 <- function(name, age) {
obj <- list(name=name, age=age)
class(obj) <- "PersonS3"
return(obj)
}
# Creating a print method for the S3 class
print.PersonS3 <- function(x) {
cat("PersonS3: Name =", x$name, "- Age =", x$age, "\n")
}
# Example of creating and printing an S3 object
person_s3 <- create_person_s3("Alice", 30)
print(person_s3)
# S4 Classes
# ----------
# Defining an S4 class
setClass("PersonS4",
slots = list(name = "character", age = "numeric"))
# Creating a constructor for the S4 class
create_person_s4 <- function(name, age) {
obj <- new("PersonS4", name=name, age=age)
return(obj)
}
# Creating a show method for the S4 class (similar to print method)
setMethod("show", "PersonS4", function(object) {
cat("PersonS4: Name =", object@name, "- Age =", object@age, "\n")
})
# Example of creating and showing an S4 object
person_s4 <- create_person_s4("Bob", 25)
show(person_s4)

58
create_lists.R Normal file
View File

@ -0,0 +1,58 @@
# 1. Creating a simple list with mixed types
simple_list <- list(name="John", age=25, scores=c(88, 92, 85))
print("Simple List:")
print(simple_list)
# 2. Creating a list using the list() function with named elements
named_list <- list(firstName="Alice", lastName="Smith", details=list(age=30, profession="Data Scientist"))
print("Named List with Nested List:")
print(named_list)
# 3. Creating a list from vectors
vector1 <- 1:5
vector2 <- seq(10, 50, by=10)
vector_list <- list(vector1, vector2)
print("List from Vectors:")
print(vector_list)
# 4. Modifying a list by adding an element
simple_list$gender <- "male" # Adding a new element
print("Modified List (Added Element):")
print(simple_list)
# 5. Modifying a list by removing an element
simple_list$scores <- NULL # Removing an element
print("Modified List (Removed Element):")
print(simple_list)
# 6. Accessing elements in a list
# Access by element name
print("Accessed Element (Name):")
print(named_list$firstName)
# Access by index
print("Accessed Element (Index):")
print(named_list[[2]])
# 7. Concatenating lists
concatenated_list <- c(simple_list, named_list)
print("Concatenated List:")
print(concatenated_list)
# 8. Using lapply to apply a function to each element of a list
# Here we use the length function to find the length of each element
lengths <- lapply(vector_list, length)
print("Lengths of List Elements:")
print(lengths)
# 9. Creating a list with repeated elements using rep()
repeated_list <- list(rep(list(x = 1:3), 3))
print("List with Repeated Elements:")
print(repeated_list)
# 10. Nested lists
nested_list <- list(
sub_list1 = list(item1 = 1, item2 = 2),
sub_list2 = list(item1 = "a", item2 = "b")
)
print("Nested List:")
print(nested_list)

60
create_matrices.R Normal file
View File

@ -0,0 +1,60 @@
# 1. Creating a matrix from a vector using the matrix() function
matrix1 <- matrix(1:9, nrow=3, ncol=3)
print("Matrix from Vector:")
print(matrix1)
# 2. Specifying row and column names at the time of creation
row_names <- c("Row1", "Row2", "Row3")
col_names <- c("Col1", "Col2", "Col3")
matrix2 <- matrix(1:9, nrow=3, ncol=3, dimnames=list(row_names, col_names))
print("Matrix with Row and Column Names:")
print(matrix2)
# 3. Creating a matrix by binding vectors column-wise using cbind()
vector1 <- 1:3
vector2 <- 4:6
vector3 <- 7:9
matrix3 <- cbind(vector1, vector2, vector3)
print("Column-Bound Matrix:")
print(matrix3)
# 4. Creating a matrix by binding vectors row-wise using rbind()
matrix4 <- rbind(vector1, vector2, vector3)
print("Row-Bound Matrix:")
print(matrix4)
# 5. Creating a diagonal matrix using diag()
diagonal_matrix <- diag(c(1, 2, 3))
print("Diagonal Matrix:")
print(diagonal_matrix)
# 6. Creating a matrix of zeros
zero_matrix <- matrix(0, nrow=3, ncol=3)
print("Zero Matrix:")
print(zero_matrix)
# 7. Creating a matrix of ones
one_matrix <- matrix(1, nrow=3, ncol=3)
print("One Matrix:")
print(one_matrix)
# 8. Creating an identity matrix
identity_matrix <- diag(1, 3)
print("Identity Matrix:")
print(identity_matrix)
# 9. Using outer to create a matrix from two vectors
matrix5 <- outer(1:3, 1:3, FUN="*")
print("Matrix from Outer Product:")
print(matrix5)
# 9.5: using the byrow
matrix6 <- matrix(1:9, nrow=3, ncol=3, byrow=TRUE)
print("Matrix by Row:")
print(matrix6)
# 10. Creating a matrix with random numbers
random_matrix <- matrix(runif(9), nrow=3)
print("Matrix with Random Numbers:")
print(random_matrix)

50
create_vectors.R Normal file
View File

@ -0,0 +1,50 @@
# 1. Using the c() function to create a numeric vector
numeric_vector <- c(1, 2, 3, 4, 5)
print("Numeric Vector:") # Output: [1] "Numeric Vector:"
print(numeric_vector) # Output: [1] 1 2 3 4 5
# 2. Using the c() function to create a character vector
character_vector <- c("apple", "banana", "cherry")
print("Character Vector:") # Output: [1] "Character Vector:"
print(character_vector) # Output: [1] "apple" "banana" "cherry"
# 3. Using the c() function to create a logical vector
logical_vector <- c(TRUE, FALSE, TRUE, FALSE)
print("Logical Vector:") # Output: [1] "Logical Vector:"
print(logical_vector) # Output: [1] TRUE FALSE TRUE FALSE
# 4. Using the seq() function to create a sequence of numbers
sequence_vector <- seq(1, 10, by=2)
print("Sequence Vector (by 2):") # Output: [1] "Sequence Vector (by 2):"
print(sequence_vector) # Output: [1] 1 3 5 7 9
# 5. Using the rep() function to create a repeated vector
repeated_vector <- rep(x = 6, times = 4)
print("Repeated Vector:") # Output: [1] "Repeated Vector:"
print(repeated_vector) # Output: [1] 6 6 6 6
# 6. Using the : operator to create an integer sequence
colon_vector <- 1:10
print("Colon Operator Vector:") # Output: [1] "Colon Operator Vector:"
print(colon_vector) # Output: [1] 1 2 3 4 5 6 7 8 9 10
# 7. Using the seq_along() function on another vector
along_vector <- seq_along(c("x", "y", "z"))
print("Seq Along Vector:") # Output: [1] "Seq Along Vector:"
print(along_vector) # Output: [1] 1 2 3
# 8. Using the seq_len() function to generate a sequence of given length
length_vector <- seq_len(5)
print("Seq Length Vector:") # Output: [1] "Seq Length Vector:"
print(length_vector) # Output: [1] 1 2 3 4 5
# 9. Combining different types in a vector (coerced to the same type)
mixed_vector <- c(1, "two", TRUE)
print("Mixed Type Vector (coerced):") # Output: [1] "Mixed Type Vector (coerced):"
print(mixed_vector) # Output: [1] "1" "two" "TRUE"
# 10. Using the gl() function to generate factors
generated_vector <- gl(n = 3, k = 2, labels = c("Group1", "Group2", "Group3"))
print("Generated Factor Vector:") # Output: [1] "Generated Factor Vector:"
print(generated_vector) # Output: [1] Group1 Group1 Group2 Group2 Group3 Group3
# Levels: Group1 Group2 Group3

57
dataframes.R Normal file
View File

@ -0,0 +1,57 @@
# Creating a data frame
employee_data <- data.frame(
EmployeeID = c(1, 2, 3, 4),
Name = c("Alice", "Bob", "Charlie", "David"),
Age = c(28, 34, 29, 40),
Department = c("HR", "IT", "Marketing", "Finance"),
stringsAsFactors = FALSE
)
print("Original Data Frame:")
print(employee_data)
# Accessing data frame columns
print("Names Column:")
print(employee_data$Name)
# Accessing rows and columns using indices
print("Second Row, Third Column:")
print(employee_data[2, 3])
# Adding a new column
employee_data$Salary <- c(50000, 55000, 49000, 53000)
print("Data Frame with Salary Column:")
print(employee_data)
# Removing a column
employee_data$Age <- NULL
print("Data Frame after Removing Age Column:")
print(employee_data)
# Filtering rows
it_department <- subset(employee_data, Department == "IT")
print("Employees in IT Department:")
print(it_department)
# Summarizing data
average_salary <- mean(employee_data$Salary)
print(paste("Average Salary:", average_salary))
# Using dplyr for more advanced data frame manipulation
# Uncomment the next lines if dplyr is not installed
# install.packages("dplyr")
library(dplyr)
# Selecting specific columns with dplyr
selected_columns <- select(employee_data, Name, Salary)
print("Selected Columns:")
print(selected_columns)
# Filtering with dplyr
high_earners <- filter(employee_data, Salary > 50000)
print("High Earners:")
print(high_earners)
# Arranging rows by a column
sorted_employees <- arrange(employee_data, desc(Salary))
print("Employees Sorted by Salary:")
print(sorted_employees)

13
evoalgs-r-practise.Rproj Normal file
View File

@ -0,0 +1,13 @@
Version: 1.0
RestoreWorkspace: Default
SaveWorkspace: Default
AlwaysSaveHistory: Default
EnableCodeIndexing: Yes
UseSpacesForTab: Yes
NumSpacesForTab: 2
Encoding: UTF-8
RnwWeave: Sweave
LaTeX: pdfLaTeX

65
functions.R Normal file
View File

@ -0,0 +1,65 @@
# Basic Function Definition
# -------------------------
# A simple function that adds two numbers
add_numbers <- function(x, y) {
sum <- x + y
return(sum)
}
# Using the function
result <- add_numbers(5, 3)
print(paste("Sum:", result))
# Function with Default Parameters
# --------------------------------
# A function with default values for parameters
multiply_numbers <- function(x, y = 2) {
product <- x * y
return(product)
}
# Using the function with default parameter
default_product <- multiply_numbers(4)
print(paste("Default Product:", default_product))
# Using the function by specifying both parameters
specified_product <- multiply_numbers(4, 3)
print(paste("Specified Product:", specified_product))
# Returning Multiple Values
# -------------------------
# A function that returns multiple values using a list
operate_numbers <- function(a, b) {
sum <- a + b
diff <- a - b
prod <- a * b
return(list(sum = sum, difference = diff, product = prod))
}
# Using the function
results <- operate_numbers(10, 5)
print("Operations Result:")
print(results)
# Variable Scope
# --------------
# A function to demonstrate variable scope
outer_function <- function() {
internal_var <- 20
inner_function <- function() {
print(paste("Accessing internal_var inside inner_function:", internal_var))
}
inner_function()
return(internal_var)
}
# Using the function
outer_result <- outer_function()
print(paste("Returned from outer_function:", outer_result))
# Anonymous Functions
# -------------------
# Using an anonymous function (a function without a name)
squared_numbers <- sapply(1:5, function(x) x^2)
print("Squared Numbers:")
print(squared_numbers)

27
if_else.R Normal file
View File

@ -0,0 +1,27 @@
# Simple if-else statement
x <- 5
if (x > 0) {
print("x is positive")
} else {
print("x is non-positive")
}
# if-else-if ladder
score <- 85
if (score >= 90) {
print("Grade: A")
} else if (score >= 80) {
print("Grade: B")
} else if (score >= 70) {
print("Grade: C")
} else {
print("Grade: F")
}
# Vectorized ifelse statement
scores <- c(92, 81, 58, 77, 85)
grades <- ifelse(scores >= 90, "A",
ifelse(scores >= 80, "B",
ifelse(scores >= 70, "C", "F")))
print("Vectorized Grades:")
print(grades)

79
lists_and_vectors.R Normal file
View File

@ -0,0 +1,79 @@
# Vectors
# -------
# Creating a numeric vector
numeric_vector <- c(1, 2, 3, 4, 5)
print("Numeric Vector:")
print(numeric_vector)
# Creating a character vector
character_vector <- c("apple", "banana", "cherry")
print("Character Vector:")
print(character_vector)
# Accessing elements in a vector
print("Element at index 2 of Numeric Vector:")
print(numeric_vector[2])
# Modifying elements in a vector
numeric_vector[2] <- 10
print("Modified Numeric Vector:")
print(numeric_vector)
# Lists
# -----
# Creating a simple list
simple_list <- list(name="John", age=25, scores=c(88, 92, 85))
print("Simple List:")
print(simple_list)
# Accessing elements in a list by name
print("Name from List:")
print(simple_list$name)
# Accessing elements in a list by index
print("Scores from List:")
print(simple_list[[3]])
# Modifying elements in a list
simple_list$age <- 26
print("Modified List:")
print(simple_list)
# Differences between Lists and Vectors
# -------------------------------------
# Lists can contain elements of different types
mixed_list <- list(number=42, text="hello", vector=c(1, 2, 3))
print("Mixed Type List:")
print(mixed_list)
# Vectors must have elements of the same type
# Attempting to mix types will coerce to the most flexible type
mixed_vector <- c(1, "two", TRUE)
print("Mixed Type Vector (coerced):")
print(mixed_vector)
# Matrices
# --------
# Creating a matrix
matrix_example <- matrix(1:9, nrow = 3, ncol = 3)
print("Matrix Example:")
print(matrix_example)
# Accessing elements in a matrix
print("Element at row 2, column 3:")
print(matrix_example[2, 3])
# Modifying elements in a matrix
matrix_example[1, 2] <- 10
print("Modified Matrix:")
print(matrix_example)
# Creating a matrix with named columns
named_matrix <- matrix(1:9, nrow = 3, ncol = 3, dimnames = list(NULL, c("col1", "col2", "col3")))
print("Matrix with Named Columns:")
print(named_matrix)
# Accessing elements in a matrix with named columns using $ indexing
print("Element in 'col2':")
print(named_matrix[, "col2"])

33
loops.R Normal file
View File

@ -0,0 +1,33 @@
# For loop example
print("For Loop Output:")
for (i in 1:5) {
print(paste("Iteration", i))
}
# While loop example
print("While Loop Output:")
count <- 1
while (count <= 5) {
print(paste("Count is", count))
count <- count + 1
}
# Repeat loop example with break
print("Repeat Loop Output (with break):")
count <- 1
repeat {
if (count > 5) {
break
}
print(paste("Repeat count is", count))
count <- count + 1
}
# Using next to skip an iteration
print("For Loop with Next:")
for (i in 1:5) {
if (i == 3) {
next
}
print(paste("Iteration", i))
}

103
operators.R Normal file
View File

@ -0,0 +1,103 @@
# Addition
result <- 10 + 5
print(result) # 15
# Subtraction
result <- 10 - 5
print(result) # 5
# Multiplication
result <- 10 * 5
print(result) # 50
# Division
result <- 10 / 5
print(result) # 2
result <- 10 / 3
print(result) # 3.333333
# Exponentiation
result <- 10 ^ 2
print(result) # 100
# Integer Division
result <- 10 %/% 3
print(result) # 3
# Modulus
result <- 10 %% 3
print(result) # 1
# AND
result <- TRUE & FALSE
print(result) # FALSE
# OR
result <- TRUE | FALSE
print(result) # TRUE
# NOT
result <- !TRUE
print(result) # FALSE
# Greater than
result <- 10 > 5
print(result) # TRUE
# Less than
result <- 10 < 5
print(result) # FALSE
# Equal to
result <- 10 == 10
print(result) # TRUE
# Not equal to
result <- 10 != 5
print(result) # TRUE
# Greater than or equal to
result <- 10 >= 10
print(result) # TRUE
# Less than or equal to
result <- 10 <= 5
print(result) # FALSE
# Basic assignment
x <- 10
print(x) # 10
# Alternate assignment (less common in R)
x = 20
print(x) # 20
# Increment and assign (not directly supported like in other languages, shown with equivalent R code)
x <- x + 5
print(x) # 25
# Decrement and assign (equivalent R code)
x <- x - 5
print(x) # 20
# Multiply and assign (equivalent R code)
x <- x * 2
print(x) # 40
# Divide and assign (equivalent R code)
x <- x / 2
print(x) # 20
# Element-wise multiplication of vectors
v1 <- c(1, 2, 3)
v2 <- c(4, 5, 6)
result <- v1 * v2
print(result) # c(4, 10, 18)
# Element-wise comparison of vectors
result <- v1 > 2
print(result) # c(FALSE, FALSE, TRUE)

47
simple_plotting.R Normal file
View File

@ -0,0 +1,47 @@
# If you don't have the ggplot2 package installed, you can install it using:
# install.packages("ggplot2")
# Load necessary library
library(ggplot2)
# Creating some data for plotting
x <- 1:10
y <- x^2
# Base R Plotting
# ---------------
# Scatter Plot using base R
plot(x, y, main="Scatter Plot", xlab="X Axis", ylab="Y Axis", col="blue", pch=19)
# Line Plot using base R
plot(x, y, type="l", main="Line Plot", xlab="X Axis", ylab="Y Axis", col="red")
# Histogram using base R
hist(y, main="Histogram", xlab="Values", col="green", breaks=5)
# Advanced Plotting with ggplot2
# ------------------------------
# Data frame for ggplot2
data <- data.frame(x, y)
# Scatter Plot using ggplot2
ggplot(data, aes(x=x, y=y)) +
geom_point() +
ggtitle("Scatter Plot with ggplot2") +
xlab("X Axis") +
ylab("Y Axis")
# Line Plot using ggplot2
ggplot(data, aes(x=x, y=y)) +
geom_line(color="red") +
ggtitle("Line Plot with ggplot2") +
xlab("X Axis") +
ylab("Y Axis")
# Histogram using ggplot2
ggplot(data, aes(x=y)) +
geom_histogram(bins=5, fill="green", color="black") +
ggtitle("Histogram with ggplot2") +
xlab("Values")

19
testfile-1.R Normal file
View File

@ -0,0 +1,19 @@
# Load necessary package
library(ggplot2)
# Create some data
df <- data.frame(
x = 1:100,
y = 2 * (1:100) + rnorm(100)
)
# Perform linear regression
model <- lm(y ~ x, data = df)
# Summary of the model
summary(model)
# Plot the data and the model
ggplot(df, aes(x = x, y = y)) +
geom_point() +
geom_smooth(method = "lm", col = "red")

62
vectors_and_matrices.R Normal file
View File

@ -0,0 +1,62 @@
# Create vectors
vector1 <- c(1, 2, 3)
vector2 <- c(4, 5, 6)
# Basic Vector Operations
# -----------------------
# Element-wise addition
vector_add <- vector1 + vector2
print("Vector Addition:")
print(vector_add)
# Element-wise multiplication
vector_mult <- vector1 * vector2
print("Vector Multiplication:")
print(vector_mult)
# Dot product
dot_product <- sum(vector1 * vector2)
print("Dot Product:")
print(dot_product)
# Create Matrices
# ---------------
# Matrix from combining vectors as rows
matrix1 <- rbind(vector1, vector2)
print("Matrix from Vectors (Rows):")
print(matrix1)
# Matrix from combining vectors as columns
matrix2 <- cbind(vector1, vector2)
print("Matrix from Vectors (Columns):")
print(matrix2)
# Matrix and Vector Operations
# ----------------------------
# Adding a vector to each row of the matrix (by replicating the vector)
matrix_row_add <- matrix1 + vector1
print("Add Vector to Each Row of Matrix:")
print(matrix_row_add)
# Adding a vector to each column of the matrix (by replicating the vector)
matrix_col_add <- matrix2 + cbind(vector1)
print("Add Vector to Each Column of Matrix:")
print(matrix_col_add)
# Element-wise multiplication of a matrix by a vector
# Note: This operation requires conformable dimensions
matrix_element_mult <- matrix1 * cbind(vector1)
print("Element-wise Multiplication of Matrix by Vector:")
print(matrix_element_mult)
# Matrix multiplication by a vector
# This treats the vector as a column vector
matrix_vector_mult <- matrix1 %*% vector1
print("Matrix Multiplication by Vector:")
print(matrix_vector_mult)
# Transpose a matrix and multiply by a vector
# This treats the vector as a row vector
transpose_mult <- t(matrix1) %*% vector1
print("Transpose Matrix and Multiply by Vector:")
print(transpose_mult)