R Vectors

What is a Vector in R?

In the R programming language, a Vector is a fundamental data structure used for storing and manipulating collections of elements. A vector represents a one-dimensional array that can hold values of the same data type, such as numbers, characters, logical values, or factors. They are created using the c() or function and offer a range of operations and functions for efficient manipulation and analysis. Vectors are a fundamental building block in R and play a crucial role in Data Analysis, Statistical Computations, and other programming tasks.

Vectors in R are also integral to Data Analysis tasks. Many R packages and functions work with vectors as input, allowing you to perform operations like Statistical Analysis, Data Transformations, Plotting, and more. Additionally, R vectors can be combined with other vector-like Data Structures such as matrices, Data-frames, and Lists to create complex data structures for advanced Data Manipulation.

Types of Vectors in R

In R, Vector can be divided on the basis of Data-type of the Vector and the number of elements the Vector is composed of, in this Section, we will learn about different types of Vectors in R.

Vector - Based on Data-types

In R, there are several types of vectors in R based on the data types - designed to handle different types of data. The main types of vectors in R based on the data type are as follows:

Numeric Vectors

Numeric vectors in R store numerical values such as integers or floating-point numbers. They are created using the c() function or other numeric functions like seq() or rep(). For example:

Character Vectors

Character vectors in R store text or strings. They are created using quotes (either single or double) around the text values. For example:

Logical Vectors

Logical vectors in R store Boolean values, which are either TRUE or FALSE. They are often used for logical operations and comparisons. For example:

Integer Vectors

Integer vectors in R store whole numbers (integers). Unlike numeric vectors, they have a restricted range and are typically used when working with large integers or when memory efficiency is crucial. You can create integer vectors using the as.integer() function. For example:

Complex Vectors

Complex vectors in R store complex numbers with both real and imaginary components. They are created using the complex() function. For example:

Raw Vectors

Raw vectors in R store raw bytes of data. They are useful for working with binary data or low-level operations. Raw vectors can be created using the raw() function. For example:

Vector based on the Number of Elements

In R, the vectors can be classified based on the number of elements they contain, in this Section we will learn different types of vectors in R based on the number of elements in the Vectors which are as follows:

Single Element Vector

A Single-element vector in R is a vector that contains only one element. It is a special case of a vector where the length of the vector is one. Despite having just one element, it is still considered a vector in R.

To create a single-element vector in R, you can use the c() function or simply assign a value to a variable. Here are a few examples:

Using the c() function

Assigning a value to a variable

Both of these examples create a single-element vector named my_vector with a value of 5 and 10 respectively.

Single-element vectors can be used in R operations and functions just like any other vector. However, it's important to note that some vector operations may behave differently when applied to single-element vectors compared to vectors with multiple elements. For example, when performing arithmetic operations or applying functions like sum() or mean(), the result for a single-element vector will be the same as the single element itself.

Multiple Elements Vector

A Multiple-elements vector in R is a vector that contains more than one element. It is the most common type of vector used in R to store and manipulate collections of data.

To create a Multiple-elements vector in R, you can use the c() function to concatenate or combine multiple values into a vector. Here are a few examples:

In the above examples, the c() function is used to create a vector with multiple elements. The elements are separated by commas within the parentheses.

We can also create a multiple-elements vector by assigning a sequence of values to a variable using the : operator or the seq() function. For example:

These examples demonstrate how to create numeric vectors with a sequence of values.

R provides a wide range of functions and operators to efficiently work with multiple-elements vectors. Multiple-element vectors are a fundamental data structure in R and are commonly used for data storage, manipulation, and analysis. They allow you to handle collections of data of the same type and perform operations on the entire set of elements simultaneously.

Creating a Vector in R

To create a vector in R, you can use the c() function (which stands for combine or concatenate) or other functions like seq(), rep(), or vector() depending on your specific requirements. Here are a few examples:

Creating a vector using c() function

This creates a numeric vector named my_vector containing the numbers 1, 2, 3, 4, and 5.

Creating a vector using seq() function

This creates a numeric vector named my_vector with a sequence starting from 1 and incrementing by 2 until reaching 10. The resulting vector will be 1, 3, 5, 7, 9.

Creating an empty vector using vector() function

This creates an empty numeric vector named my_vector with a length of 3. The resulting vector will be filled with default NA values.

Single Element Vector

In the above Section, we have discussed about the Single Element Vector, in this section, we will create a single-element vector in R. Here's an example:

In this example, a single-element vector named my_vector is created with a value of 5. Although it contains only one element, it is still considered a vector in R.

We can also create a single-element vector using the c() function. Here's an example:

This will create a single-element vector named my_vector with a value of 10. The c() function is used to combine or concatenate values into a vector, even if it's just a single element. Both of these approaches result in a single-element vector that can be used in R operations and functions just like any other vector.

Multiple Element Vector

In the above Section, we have discussed about the Multiple Element Vector, in this section, we will create a multiple-elements vector in R, you can use the c() function to concatenate or combine multiple values into a vector. Here are a few examples:

This creates a numeric vector named my_vector containing the numbers 1, 2, 3, 4, and 5. Similarly, we can use c() to create multiple-elements vector for other Data-types in R.

We can also create a vector by assigning a sequence of values to a variable using the : operator or the seq() function. For example:

This creates a numeric vector named my_vector containing the sequence from 1 to 5: 1, 2, 3, 4, 5.

This creates a numeric vector named my_vector with a sequence starting from 1 and incrementing by 2 until reaching 10: 1, 3, 5, 7, 9.

Length of a Vector in R

In R, determining the length of a vector refers to finding the number of elements present in the vector. The length of a vector can be obtained using the length() function, which returns an integer representing the total count of elements in the vector.

Here's an example to illustrate finding the length of a vector in R:

In the code above, we have a vector called my_vector with elements [10, 20, 30, 40, 50]. To determine the length of this vector, we use the length() function and pass my_vector as an argument. The result is stored in the variable vector_length.

In this case, the length of my_vector is 5, as there are five elements present in the vector. The vector_length variable will hold the value 5.

The length of a vector is an important property as it helps you understand the size or dimensionality of the data contained within the vector. It is commonly used in loops, conditionals, and other data manipulation operations where the size of the vector affects the execution flow or required computations.

Accessing R Vector Elements

In R, a vector is a fundamental data structure that holds a collection of elements of the same data type. Accessing elements within a vector is a common task in data manipulation and analysis. R provides various indexing techniques to retrieve specific elements from a vector.

In R, we can access elements of a vector by indexing. Indexing allows you to extract specific elements or subsets of elements from a vector based on their position. There are different ways to perform indexing in R, depending on your requirements.

The most basic form of indexing is using square brackets []. We can specify the position or positions of the elements you want to access within the brackets. For example, vector[1] will return the first element of the vector, vector[2:5] will return elements 2 to 5, and vector[c(3, 6, 9)] will return elements at positions 3, 6, and 9.

You can also use logical indexing, where you provide a logical expression inside the brackets. For example, vector[vector > 5] will return all elements of the vector that are greater than 5.

Negative indexing is another useful technique that allows you to exclude specific elements. For example, vector[-1] will return all elements of the vector except the first one.

In addition to single vectors, you can also index multiple vectors simultaneously. For example, matrix[, 3] will return the third column of a matrix.

Indexing can be extended to multidimensional arrays by specifying positions for each dimension. For example, array[1, 2, 3] will return the element at the first row, second column, and third "depth" of a three-dimensional array.

R also provides named indexing, where you can assign names to individual elements in a vector. You can then use these names to access specific elements by name instead of position.

Accessing Vector using Index

In R, you can access vector elements using indexing. Indexing allows you to retrieve specific elements or subsets of elements from a vector based on their positions. Here's a breakdown of how indexing:

Single element access

To access a single element, use the vector name followed by the index of the element enclosed in square brackets. R uses 1-based indexing, so the first element is at index 1. For example:

In this case, element will have the value 30.

Multiple element access

You can access multiple elements by providing a vector of indices inside the square brackets. For example:

The elements vector will contain the values 10, 30, and 50.

Range of elements

To access a range of elements, you can use the colon operator : to specify the starting and ending indices. For example:

The subset vector will contain the values 20, 30, and 40.

You can also use negative indices to exclude elements from the vector. For instance, my_vector[-3] will return a new vector without the element at index 3.

Indexing allows you to access and manipulate vector elements efficiently in R, making it a powerful tool for data analysis and programming tasks.

Accessing Vector using Loops

In R, you can access vector elements using loops. Loops are useful when you want to iterate over each element in a vector and perform certain operations. There are different types of loops in R, including for loops and while loops.

Using loops, you can access vector elements sequentially and perform desired operations on each element. However, it's worth noting that in R, vectorized operations are often more efficient and recommended when possible, as they leverage the vectorized nature of R and can avoid explicit loops for better performance. Here's how you can access vector elements using these loops:

Using For Loop

The for loop is commonly used when you know the number of iterations in advance. You can iterate over the indices of a vector and access the corresponding elements. Here's an example:

In this loop, the variable i takes on the values 1, 2, 3, 4, and 5, corresponding to the indices of the vector my_vector. Inside the loop, you can access the element at index i using my_vector[i] and perform operations on it.

Using While Loop

The while loop is useful when you want to iterate until a certain condition is met. You can use a counter variable to access vector elements sequentially. Here's an example:

In this loop, the variable n starts from 1 and is incremented by 1 in each iteration. The loop continues until n exceeds the length of the vector my_vector. Inside the loop, you can access the element at position n using my_vector[n] and perform operations on it.

In summary, indexing in R is a powerful way to access and manipulate elements within vectors, matrices, and arrays. It allows you to retrieve specific elements or subsets based on their position or logical condition, and it can be extended to multidimensional structures. Understanding indexing is crucial for working with data in R efficiently.

Modifying a R Vector

In R, there are several ways to modify a vector. Here are some common methods:

Indexing and Assignment

You can modify specific elements of a vector by assigning new values to them using indexing. For example:

After executing this code, the vector my_vector will be modified to contain the values 10, 20, 35, 40, and 50.

Concatenation

You can modify a vector by concatenating it with another vector using the c() function. For example:

In this case, modified_vector will be a new vector with the values 10, 20, 30, 40, and 50.

Using Functions

R provides various functions that can modify vectors based on specific criteria. For instance, you can use the sort() function to sort the elements of a vector in ascending or descending order. Another example is the subset() function, which allows you to extract a subset of elements based on certain conditions.

Deleting a R Vector

To delete a vector in R, you can use the rm() function followed by the name of the vector you want to remove. This function removes the vector and frees the memory allocated to it. Here's an example:

After executing rm(my_vector), the vector my_vector will be deleted. The exists() function is used to check if the vector still exists, and it will return FALSE in this case. Deleting a vector allows you to remove it from the current R session and free up memory resources.

Vector Operations

In R, vector operations allow you to perform calculations and manipulations on entire vectors at once, taking advantage of R's vectorized nature. This means you can apply operations to vectors without needing explicit loops. Here are some common vector operations in R

Arithmetic Operations

You can perform arithmetic operations on vectors element-wise. For example:

The result vector will be [5, 7, 9], obtained by adding corresponding elements of vector1 and vector2.

Similarly, we can do other arithmetic operations such as Division, Multiplication, Substraction etc,

Mathematical Functions

R provides various mathematical functions that can be applied to entire vectors. For example:

The sqrt_result vector will be [1, 1.414, 1.732], representing the square root of each element in my_vector.

Vector Concatenation

You can concatenate vectors using the c() function. For example:

The result vector will be [1, 2, 3, 4], combining the elements of vector1 and vector2.

These are just a few examples of vector operations in R. R provides a wide range of built-in functions and operators that can be applied to vectors, making it convenient to perform calculations and manipulations on entire sets of data efficiently.