R Data Structure: Vector
Somsak Chanaim
International College of Digital Innovation, CMU
April 8, 2025
Data Stucture
Data Stucture in R ref: First Steps in R
Object vs Function
In R, objects and functions are two fundamental concepts, but they serve different purposes and have different characteristics.
Object
An object in R is a data structure that stores values or data. Objects can be of various types, such as vectors, lists, matrices, data frames, or even more complex structures like models.
Purpose: Objects are used to hold data that you can manipulate, analyze, or pass as inputs to functions.
Function
A function in R is a set of instructions or code designed to perform a specific task. Functions take inputs (arguments), execute a series of commands, and often return a result.
Purpose: Functions are used to perform operations, calculations, or transformations on data (objects).
Characters
In R, characters are a basic data type used to represent text.
They are typically stored as character vectors.
R Code
9
1
2
3
4
›
"SOMSAK"
"ICDI"
"12125"
"T"
_webr_editor_3 = Object {code: null, options: Object, indicator: Ke}
Numerics
In R, numeric data types are used to represent numbers. This includes both integers and floating-point (decimal) numbers.
R Code
9
1
2
3
4
›
1
2.3
2/7
pi
_webr_editor_4 = Object {code: null, options: Object, indicator: Ke}
Integers
In R, integers are a specific type of numeric data that represent whole numbers.
We can define integers with the L suffix:
R Code
9
1
2
3
›
1L
10L
1000L
_webr_editor_5 = Object {code: null, options: Object, indicator: Ke}
Logicals
In R, logical data types are used to represent boolean values, which can be either TRUE or FALSE (T or F).
R Code
9
1
2
3
4
›
T
TRUE
F
FALSE
_webr_editor_6 = Object {code: null, options: Object, indicator: Ke}
Logical values are essential for controlling the flow of programs through conditional statements and loops, and they are also useful for indexing and subsetting data.
Operators in R
Operators in R are used to perform various operations on variables and values.
They can be categorized into several types:
Arithmetic Operators
Comparison Operators
Logical Operators
Assignment Operators
etc.
Arithmetic Operators
In R, arithmetic operators are used to perform basic mathematical operations on numeric values.
These operators are fundamental to performing calculations and are applied element-wise when used with vectors.
Basic arithmetic operations:
Addition (
+)Subtraction (
-)Multiplication (
*)Division (
/)
Exponentiation (
^)Modulus (
%%)Integer Division (
%/%)
R Code
9
1
2
3
4
›
5+2 # Addition = 7
5-2 # Subtraction = 3
5*2 # Multiplication = 10
5/2 # Division = 2.5
_webr_editor_7 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
3
›
5^2 # Exponentiation = 25
5%%2 # 5 = 2*2+1, Modulus is 1
5 %/% 2 # 5 = 2*2+1, Integer Division is 2
_webr_editor_8 = Object {code: null, options: Object, indicator: Ke}
Comparison Operators
In R, comparison operators are used to compare two values or variables. The result of a comparison operation is a logical value (TRUE or FALSE).
Greater than (>):
R Code
9
1
›
5 > 2
_webr_editor_9 = Object {code: null, options: Object, indicator: Ke}
Less than (<):
R Code
9
1
›
5 < 2
_webr_editor_10 = Object {code: null, options: Object, indicator: Ke}
Equal to (==):
R Code
9
1
›
5 == 2
_webr_editor_11 = Object {code: null, options: Object, indicator: Ke}
Greater than or equal to (>=):
R Code
9
1
›
5 >= 2
_webr_editor_12 = Object {code: null, options: Object, indicator: Ke}
Less than or equal to (<=):
R Code
9
1
›
5 <= 2
_webr_editor_13 = Object {code: null, options: Object, indicator: Ke}
Not equal to (!=):
R Code
9
1
›
5 != 2
_webr_editor_14 = Object {code: null, options: Object, indicator: Ke}
Logical Operators
Logical operators are used to perform logical operations, often in the context of conditional statements or when working with Boolean values (TRUE or FALSE).
Logical operators
&: Element-wise logical AND|: Element-wise logical OR!: Negation (Unitary operator for negating a logical value)
These operators are essential for making decisions and controlling the flow of your code.
Logical operator Negation of Not (!)
R Code
9
1
›
!TRUE
_webr_editor_19 = Object {code: null, options: Object, indicator: Ke}
Example
R Code
9
1
›
!(2<3)
_webr_editor_20 = Object {code: null, options: Object, indicator: Ke}
Assignment Operators
In R, assignment operators are used to assign values to variables. They are fundamental for storing data, defining variables, and setting up computations.
<-: The most commonly used assignment operator in R. It assigns the value on the right to the variable on the left.=: Also used for assignment but is generally preferred for specifying arguments in function calls rather than variable assignment.
Example
R Code
9
1
2
›
D <- 10
D
_webr_editor_23 = Object {code: null, options: Object, indicator: Ke}
or
R Code
9
1
2
›
D = 10
D
_webr_editor_24 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
›
# We recommend to use = in the argument only.
plot( x = cars$speed, y = cars$dist)
_webr_editor_25 = Object {code: null, options: Object, indicator: Ke}
Remark
When we assign any data structure to an object name, R does not display the value on your screen.
Reserved Words in R
In R, reserved words (or keywords) are special words that have a specific meaning within the language.
These words cannot be used as identifiers (such as variable names, function names, etc.) because they are part of the language syntax.
List of Reserved Words in R:
- Control Flow Keywords:
if,elserepeatwhilefunctionforinnextbreakreturn
- Logical Constants:
TRUEFALSENULLNA(and variants likeNA_integer_,NA_real_,NA_complex_,NA_character_)
- Special Operators:
Inf(represents infinity)NaN(Not a Number)NA(Not Available or missing value)
- Others:
...(Ellipsis, used to pass additional arguments to functions)~(Tilde, used in model formulas)
Reserved Words in Context:
- Control Flow:
- The keywords
if,else,for,while,repeat,break,next, andreturnare used to control the flow of execution in an R program.
- The keywords
- Logical Constants:
TRUE,FALSE, andNULLare used to represent logical values and the absence of any value.
- Special Operators:
InfandNaNrepresent mathematical concepts (infinity and an undefined result, respectively).NAis used for missing data, which is very common in data analysis.
- Function Definition:
- The
functionkeyword is used to define new functions in R.
- The
Importance of Reserved Words:
Syntax Rules: Reserved words form the core syntax of R, and their correct usage is essential for writing valid R code.
Naming Restrictions: Since reserved words have specific functions within the language, you cannot use them as variable or function names, which helps avoid confusion and errors in the code.
Understanding reserved words in R helps in writing clear, error-free code and avoids conflicts in naming conventions.
Vector
In R, the c() function is one of the most fundamental functions.
It is used to combine or concatenate elements to create a vector.
The
c()function can take multiple arguments and combine them into a single vector.
The vector of number
R Code
9
1
2
›
vector.num <- c(1, 2, 3)
vector.num
_webr_editor_26 = Object {code: null, options: Object, indicator: Ke}
The vector of character
R Code
9
1
2
›
vector.cha <- c("ICDI", "ECON", "LAW")
vector.cha
_webr_editor_27 = Object {code: null, options: Object, indicator: Ke}
The vector of logical
R Code
9
1
2
›
vector.logic <- c(TRUE, FALSE, T, F)
vector.logic
_webr_editor_28 = Object {code: null, options: Object, indicator: Ke}
Multi element type is character
R Code
9
1
›
c(1, "BUS", T)
_webr_editor_29 = Object {code: null, options: Object, indicator: Ke}
The sequence in R
In R, you can create sequences of numbers using various functions.
The most common ways to generate sequences are by using
the
:operator.the
seq()function.the
rep()function.
1. Using the : Operator
The : operator generates a simple sequence of integers.
2. Using the seq() function
The seq() function provides more control over the sequence, including the ability to set the step size, length, and more.
from: The starting number.
to: The ending number.
by: The step size to increment by.
R Code
9
1
2
3
4
5
6
›
# Generate a sequence from 1 to 10
# with a step of 2
sequence <- seq(from = 1,
to = 10,
by = 2)
sequence # Outputs: 1 3 5 7 9
_webr_editor_32 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
3
4
5
6
›
# Generate a sequence of 5 numbers
# from 1 to 10
sequence <- seq(from = 1,
to = 10,
length.out = 5)
sequence # Outputs: 1.0 3.25 5.50 7.75 10.00
_webr_editor_33 = Object {code: null, options: Object, indicator: Ke}
3. Using the rep() function
The rep() function is used to replicate
x is vector.
each: Repeat each element in the vector x
ktimes.times: Repeat the vector x
ntimes.
R Code
9
1
2
3
›
# Repeat the number 5, three times
sequence <- rep(x = 1:3, times = 3)
sequence # Outputs: 5 5 5
_webr_editor_34 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
3
›
# Repeat a sequence of numbers
sequence <- rep(x = 1:3, each = 2)
sequence # Outputs: 1 1 2 2 3 3
_webr_editor_35 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
3
›
# mixing the argument times and each
sequence <- rep(x = 1:3, times = 3, each = 2)
sequence # Outputs: 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3
_webr_editor_36 = Object {code: null, options: Object, indicator: Ke}
These methods allow you to generate sequences easily and are fundamental for data manipulation and iteration in R.
Arithmetic Operators for length of vector more than one
Example
R Code
9
1
2
›
vec.1 <- 1:5
vec.2 <- 2:6
_webr_editor_37 = Object {code: "vec.1 <- 1:5\nvec.2 <- 2:6", options: Object, indicator: Ke}
Arithmetic Operation examples
R Code
9
1
›
vec.1 + vec.2
_webr_editor_38 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
›
vec.1 - vec.2
_webr_editor_39 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
3
4
5
6
›
#[1,2]*[3,4]=[1*3, 2*4]=[3, 8]
vec.1 * 2
vec.1 / 2
vec.1 + 2
vec.1 - 2
vec.1 ^ 2
_webr_editor_42 = Object {code: null, options: Object, indicator: Ke}
Important
In R, e is a way to express numbers in scientific notation. Specifically:
1e2means (1 ^2), which equals 100.
Explanation:
- The
ein1e2stands for “exponent,” so:1e2is equivalent to1 * (10 ^ 2)- This makes it easier to represent very large or very small numbers without writing out all the zeros.
Examples:
Here are a few more examples of using scientific notation in R:
2e3is equal to 2×103, which equals 2000.5e-2is equal to 5×10−2, which equals 0.05.3.14e1is equal to 3.14×101, which equals 31.4.
R Code
9
1
2
3
›
2e3
5e-2
3.14e1
_webr_editor_43 = Object {code: null, options: Object, indicator: Ke}
This notation is particularly useful for dealing with very large or very small numbers in calculations.
Note: ou cannot use the notation e alone without a number before and after it, as shown in the example below.
R Code
9
1
2
3
›
e
2e
e2
_webr_editor_44 = Object {code: null, options: Object, indicator: Ke}
Comparison Operators for length of vector more than one
Example
R Code
9
1
2
›
vec.1 <- 1:5
vec.2 <- 2:6
_webr_editor_45 = Object {code: "vec.1 <- 1:5\nvec.2 <- 2:6", options: Object, indicator: Ke}
Greater than
R Code
9
1
›
vec.1 > vec.2
_webr_editor_46 = Object {code: null, options: Object, indicator: Ke}
Less than
R Code
9
1
›
vec.1 < vec.2
_webr_editor_47 = Object {code: null, options: Object, indicator: Ke}
Equal to
R Code
9
1
›
vec.1 == vec.2
_webr_editor_48 = Object {code: null, options: Object, indicator: Ke}
Greater than or equal to
R Code
9
1
›
vec.1 >= vec.2
_webr_editor_49 = Object {code: null, options: Object, indicator: Ke}
Less than or equal to
R Code
9
1
›
vec.1 <= vec.2
_webr_editor_50 = Object {code: null, options: Object, indicator: Ke}
Not equal to
R Code
9
1
›
vec.1 != vec.2
_webr_editor_51 = Object {code: null, options: Object, indicator: Ke}
how to merge/combine vector
Merge/Access/Replace value in vector
Merge
R Code
9
1
2
3
›
A <- c(1, 2, 3)
B <- 4:6
C <- seq(from = 7, to = 9, by = 1)
_webr_editor_52 = Object {code: "A <- c(1, 2, 3)\nB <- 4:6\nC <- seq(from = 7, to = 9, by = 1)", options: Object, indicator: Ke}
R Code
9
1
›
c(A, B, C, 10)
_webr_editor_55 = Object {code: null, options: Object, indicator: Ke}
Access
R Code
9
1
2
›
D <- c(A,B,C,10)+10
D
_webr_editor_56 = Object {code: "D <- c(A,B,C,10)+10\nD", options: Object, indicator: Ke}
From D, show a value at position 1,2,3,4 and 5
R Code
9
1
›
D[1:5]
_webr_editor_57 = Object {code: null, options: Object, indicator: Ke}
Or
R Code
9
1
›
D[1:5]
_webr_editor_58 = Object {code: null, options: Object, indicator: Ke}
From D, show the value at even position
R Code
9
1
2
›
D[2*(1:5)]
D[2*c(1:5)]
_webr_editor_59 = Object {code: null, options: Object, indicator: Ke}
From D, don’t show the value at position 5.
R Code
9
1
2
›
D[c(1:4, 6:10)]
D[-5]
_webr_editor_60 = Object {code: null, options: Object, indicator: Ke}
From D, show the value at position 9 and 1 respectively.
R Code
9
1
›
D[c(9, 1)]
_webr_editor_61 = Object {code: null, options: Object, indicator: Ke}
Replace
From D, change the value in position 1 to 21.
R Code
9
1
2
›
D[1] <- 21
D
_webr_editor_62 = Object {code: null, options: Object, indicator: Ke}
From D, change every value in position 1 until position 5 equal 25.
R Code
9
1
2
›
D[1:5] <- 25
D
_webr_editor_63 = Object {code: null, options: Object, indicator: Ke}
From D, change the value in position 1 and position 10 to 30 and 35 respectively.
R Code
9
1
2
›
D[c(1, 10)] <- c(30, 35)
D
_webr_editor_64 = Object {code: null, options: Object, indicator: Ke}
Check the object types?
typeof() and class() functions
typeof(): This function tells you the internal storage mode or type of the object, which is how R internally represents the data. It focuses on the low-level storage type.class(): This function returns the class or high-level type of an object, which often corresponds to how the object is treated by R’s methods.
R Code
9
1
2
›
typeof(D)
class(D)
_webr_editor_65 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
›
typeof("Somsak")
class("Somsak")
_webr_editor_66 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
2
›
typeof(T)
class(TRUE)
_webr_editor_67 = Object {code: null, options: Object, indicator: Ke}
Common types returned by typeof() include:
“logical”
“integer”
“double”
“complex”
“character”
“list”
“NULL”
Some common classes are:
“numeric”
“factor”
“data.frame”
“matrix”
“lm” (linear model)
Is the object a character/numeric/logical/integer?
In R, is.xxxx() functions are a family of functions used to check if an object is of a particular type or class. These functions return TRUE if the object matches the specified type or class, and FALSE otherwise.
is.character(): Checks if an object is of type character.is.numeric(): Checks if an object is of type numeric (either integer or double).is.logical(): Checks if an object is of type logical (TRUE or FALSE).is.integer(): Checks if an object is of type integer.
How to delete object
R Code
9
1
2
3
4
›
A <- 1:5
B <- c("A", "B", "C", "D")
C1 <- c(TRUE, FALSE, T, F)
D1 <- rep(x = 1, time = 5)
_webr_editor_70 = Object {code: "A <- 1:5\nB <- c(\"A\", \"B\", \"C\", \"D\")\nC1 <- c(TRUE, FALSE, T, F)\nD1 <- rep(x = 1, time = 5)", options: Object, indicator: Ke}
Use the rm() function
the rm() function is used to remove objects from the environment.
R Code
9
1
›
rm(B)
_webr_editor_73 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
›
rm(C1, D1)
_webr_editor_74 = Object {code: null, options: Object, indicator: Ke}
check
R Code
9
1
›
B
_webr_editor_75 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
›
C1
_webr_editor_76 = Object {code: null, options: Object, indicator: Ke}
R Code
9
1
›
D1
_webr_editor_77 = Object {code: null, options: Object, indicator: Ke}
Remove all objects from the environment, we can use this code
Save/Load object in the environment
Save object into the environment
R Code
9
1
›
save.image(file = "data2.RData")
_webr_editor_78 = Object {code: null, options: Object, indicator: Ke}
Note: you can use <anyname>.RData
Load file into the environment
R Code
9
1
›
load(file = "data2.RData")
_webr_editor_79 = Object {code: null, options: Object, indicator: Ke}
Useful Function: sample()
The sample() function in R is used to generate a random sample of elements from a specified set of data, with or without replacement.
Syntax:
Parameters:
x: A vector of elements from which to choose.
size: The number of items to choose.
replace: Logical; if
TRUE, sampling is done with replacement (elements can be selected more than once). Default isFALSE.prob: A vector of probability weights for obtaining the elements of the vector being sampled.
Examples
- Basic Sampling Without Replacement:
R Code
9
1
2
3
›
set.seed(123) # Set seed for reproducibility
sample(x = 1:10, size = 5)
# Output: A random sample of 5 numbers from 1 to 10
_webr_editor_80 = Object {code: null, options: Object, indicator: Ke}
- Sampling With Replacement:
R Code
9
1
2
›
sample(x = 1:10, size = 15, replace = TRUE)
# Output: A random sample of 15 numbers from 1 to 10, with replacement
_webr_editor_81 = Object {code: null, options: Object, indicator: Ke}
- Sampling with Specified Probabilities:
R Code
9
1
2
›
sample( x = 1:5, size = 5, replace = TRUE, prob = c(0.1, 0.2, 0.3, 0.2, 0.2))
# Output: A random sample where some elements are more likely to be chosen than others
_webr_editor_82 = Object {code: null, options: Object, indicator: Ke}
- Random Permutation:
R Code
9
1
2
›
sample(1:10)
# Output: A random permutation of numbers from 1 to 10
_webr_editor_83 = Object {code: null, options: Object, indicator: Ke}
Useful Function: paste() and paste0()
The paste() and paste0() functions in R are used to concatenate strings or other objects into a single string. While they serve similar purposes, they have some key differences in how they handle separators.
Examples
- Create a vector object named ID with values ranging from ‘ID:1’ to ‘ID:1000’.
R Code
9
1
›
paste("ID:",1:1000)
_webr_editor_84 = Object {code: null, options: Object, indicator: Ke}
- Create a vector object named ID with values ranging from ‘ID: 1’ to ‘ID: 1000’.
R Code
9
1
›
paste0("ID:",1:1000)
_webr_editor_85 = Object {code: null, options: Object, indicator: Ke}
- Create a vector object named ID with values ranging from ‘ID:1-ICDI’ to ‘ID: 1000-ICDI’.
R Code
9
1
›
paste0("ID:",1:1000, "-ICDI")
_webr_editor_86 = Object {code: null, options: Object, indicator: Ke}
Useful Function: length()
The length() function in R is used to determine the number of elements in an object.
It returns the count of elements present in vectors, lists, arrays, or other objects in R.
For instance, if you have a vector containing numbers or strings, length() will provide the count of elements present within that vector.
R Code
9
1
›
length(1:10)
_webr_editor_87 = Object {code: null, options: Object, indicator: Ke}
Exercise: vector part 1
1. Create a Numeric Vector
- Create a numeric vector with the values 10, 20, 30, 40, and 50. Assign it to a variable named
my_vector.
Exercise
9
1
›
_webr_editor_89 = Object {code: null, options: Object, indicator: Ke}
2. Access Elements in a Vector
- Given the vector
my_vector, access the third element in the vector.
Exercise
9
1
›
_webr_editor_90 = Object {code: null, options: Object, indicator: Ke}
3. Vector Length
- Find the length of
my_vector.
Exercise
9
1
›
_webr_editor_91 = Object {code: null, options: Object, indicator: Ke}
4. Sum of Vector Elements
- Calculate the sum of all elements in
my_vector.
Exercise
9
1
›
_webr_editor_92 = Object {code: null, options: Object, indicator: Ke}
5. Vector Arithmetic
- Create a new vector
my_vector2with the values 1, 2, 3, 4, and 5. Addmy_vectorandmy_vector2element-wise.
Exercise
9
1
›
_webr_editor_93 = Object {code: null, options: Object, indicator: Ke}
6. Logical Indexing
- Create a logical vector indicating which elements of
my_vectorare greater than 25.
Exercise
9
1
›
_webr_editor_94 = Object {code: null, options: Object, indicator: Ke}
7. Subsetting with a Condition
- Subset
my_vectorto only include elements that are greater than
Exercise
9
1
›
_webr_editor_95 = Object {code: null, options: Object, indicator: Ke}
8. Replacing Elements in a Vector
- Replace the value of the second element in
my_vectorwith 99.
Exercise
9
1
›
_webr_editor_96 = Object {code: null, options: Object, indicator: Ke}
9. Vector Repetition
- Create a vector that repeats the values 1, 2, 3 three times.
Exercise
9
1
›
_webr_editor_97 = Object {code: null, options: Object, indicator: Ke}
Exercise: vector part 2
The 5 exercises focusing on the seq(), rep(), paste()/paste0(), and sample() functions in R:
10. Generate a Sequence
- Use the
seq()function to create a sequence of numbers from 5 to 50 with a step of 5. Assign the result to a variable namedmy_seq.
Exercise
9
1
›
_webr_editor_98 = Object {code: null, options: Object, indicator: Ke}
11. Repeat Elements
- Use the
rep()function to create a vector that repeats the elements 1, 2, and 3, each five times.
Exercise
9
1
›
_webr_editor_99 = Object {code: null, options: Object, indicator: Ke}
12. Combine Strings with Numbers
- Create a character vector using the
paste()function that combines the string “Day” with the numbers from 1 to 7. The result should bec("Day 1", "Day 2", ..., "Day 7").
Exercise
9
1
›
_webr_editor_100 = Object {code: null, options: Object, indicator: Ke}
13. Random Sampling
- Use the
sample()function to generate a random sample of 5 unique numbers from the sequence you created in Exercise 1 (my_seq). Assign the result tomy_sample.
Exercise
9
1
›
_webr_editor_101 = Object {code: null, options: Object, indicator: Ke}
14. Creating IDs with paste0()
- Generate a vector of IDs using the
paste0()function. The IDs should be in the format “ID1”, “ID2”, …, “ID10”. Usepaste0()and theseq()function to create this vector.
Exercise
9
1
›
_webr_editor_102 = Object {code: null, options: Object, indicator: Ke}
Downloading webR
9
1
›
This component is an instance of the CodeMirror interactive text editor. The editor has been configured so that the Tab key controls the indentation of code. To move focus away from the editor, press the Escape key, and then press the Tab key directly after it. Escape and then Shift-Tab can also be used to move focus backwards.
wait...
WebR is downloading, please wait...
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
R Data Structure: Vector Somsak Chanaim International College of Digital Innovation, CMU April 8, 2025