1
2
3
4
# Single-line comment
print("Hello, R!")  # Printing to console
x <- 10  # Assignment operator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Numeric
x <- 42.5
is.numeric(x)  # TRUE

# Integer
y <- 42L
is.integer(y)  # TRUE

# Character
name <- "R Programming"
is.character(name)  # TRUE

# Logical
is_true <- TRUE
is.logical(is_true)  # TRUE

# Complex
z <- 3 + 2i
is.complex(z)  # TRUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Vector (homogeneous)
numeric_vector <- c(1, 2, 3, 4, 5)
character_vector <- c("a", "b", "c")

# List (heterogeneous)
mixed_list <- list(1, "a", TRUE, 3.14)

# Factor (categorical variable)
gender <- factor(c("male", "female", "male"))

# Data Frame
df <- data.frame(
  name = c("Alice", "Bob", "Charlie"),
  age = c(25, 30, 35),
  stringsAsFactors = FALSE
)

1
2
3
4
5
6
7
8
9
# Variable assignment
x <- 10  # Preferred method
y = 20   # Also works, but not recommended
x <<- 30 # Global assignment

# Constant (R doesn't have true constants)
# Use conventions or packages like 'constants'
PI <- 3.14159

1
2
3
4
5
6
7
8
9
a <- 10
b <- 3
c <- a + b   # Addition
d <- a - b   # Subtraction
e <- a * b   # Multiplication
f <- a / b   # Division
g <- a %% b  # Modulo
h <- a ^ b   # Exponentiation

1
2
3
4
5
6
7
x == y  # Equal to
x != y  # Not equal to
x < y   # Less than
x > y   # Greater than
x <= y  # Less than or equal to
x >= y  # Greater than or equal to

1
2
3
4
5
TRUE & FALSE   # Logical AND
TRUE | FALSE   # Logical OR
!TRUE          # Logical NOT
isTRUE(x)      # Check if TRUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# If-else
if (condition) {
  # code
} else if (another_condition) {
  # code
} else {
  # code
}

# Switch statement
switch(x,
  "a" = "First option",
  "b" = "Second option",
  "default"
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# For loop
for (i in 1:5) {
  print(i)
}

# While loop
while (condition) {
  # code
}

# Repeat loop
repeat {
  # code
  if (condition) break
}

1
2
3
4
5
6
7
8
# Function definition
my_function <- function(x, y = 10) {
  return(x + y)
}

# Anonymous function (lambda-like)
square <- function(x) x^2

1
2
3
4
5
6
7
8
9
10
# Ellipsis for variable arguments
variable_args <- function(...) {
  args <- list(...)
  print(args)
}

# Functional programming with apply family
lapply(list(1, 2, 3), function(x) x^2)
sapply(list(1, 2, 3), function(x) x^2)

1
2
3
4
5
6
7
8
9
# Creating vectors
v1 <- c(1, 2, 3)
v2 <- seq(1, 10, by = 2)
v3 <- rep(1, times = 5)

# Vector operations
v1 + v2  # Element-wise addition
length(v1)  # Vector length

1
2
3
4
5
6
7
8
9
10
11
# Creating data frames
df <- data.frame(
  name = c("Alice", "Bob"),
  age = c(25, 30)
)

# Subsetting
df$name
df[1, 2]  # First row, second column
subset(df, age > 25)

1
2
3
4
5
6
7
8
9
# S3 class creation
person <- list(name = "John", age = 30)
class(person) <- "Person"

# Method definition
print.Person <- function(x) {
  cat("Name:", x$name, "Age:", x$age, "\n")
}

1
2
3
4
5
6
7
8
9
10
11
# Try-catch equivalent
tryCatch({
  # code that might throw an error
}, error = function(e) {
  print("An error occurred")
}, warning = function(w) {
  print("A warning occurred")
}, finally = {
  # cleanup code
})

1
2
3
4
5
6
7
8
# Reading files
read.csv("data.csv")
read.table("data.txt")

# Writing files
write.csv(df, "output.csv")
write.table(df, "output.txt")

1
2
3
4
5
6
7
8
9
# Install package from CRAN
install.packages("ggplot2")

# Load package
library(ggplot2)

# Check installed packages
installed.packages()

1
2
3
4
5
6
7
# Using testthat package
library(testthat)

test_that("Addition works", {
  expect_equal(2 + 2, 4)
})

1
2
3
4
# R Markdown
library(rmarkdown)
render("report.Rmd")