refactor: moved files to intro

intro/apply.R

@@ -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)

intro/classes.R

@@ -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)

intro/create_lists.R

@@ -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)

intro/create_matrices.R

@@ -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)

intro/create_vectors.R

@@ -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

intro/dataframes.R

@@ -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)

intro/evoalgs-r-practise.Rproj

@@ -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

intro/functions.R

@@ -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)

intro/if_else.R

@@ -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)

intro/lists_and_vectors.R

@@ -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"])
+

intro/loops.R

@@ -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))
+}

intro/operators.R

@@ -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)

intro/simple_plotting.R

@@ -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")

intro/testfile-1.R

@@ -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")

intro/vectors_and_matrices.R

@@ -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)