operators.qmd

# The primary types of operators in R {#sec-operators}

## Questions

-   What are the primary operator types in R?

-   How can one use the various operator types in data analysis?

-   How do arithmetic, comparison, and logical operators work in R?

-   When should I use assignment operators versus comparison operators?

## Learning Objectives

-   Identify the primary operator types in R.

-   Learn how to use various operators for data manipulation.

-   Utilize arithmetic operators for efficient numerical calculations in your R scripts.

-   Apply comparison operators to evaluate conditions and filter data based on logical comparisons.

-   Employ logical operators to combine multiple conditions and control the flow of your R code.

## Lesson Content

### Introduction

R has many types of operators that can perform different tasks. Here we will focus on 5 major types of operators. The major types of operators are:

-   Arithmetic,
-   Relational,
-   Logical,
-   Assignment, and
-   Miscellaneous.

### Arithmetic Operators

Arithmetic operators are used to perform mathematical operations. These operators were reviewed in the previous lesson on "Basic arithmetic, arithmetic operators, and variables" (@sec-arithmetic-variables)

### Relational Operators

Relational operators are used to find the relationship between 2 variables and compare objects. The output of these comparisons is Boolean (TRUE or FALSE). The table below describes the most common relational operators.

| Relational Operator |       Description        |
|:-------------------:|:------------------------:|
|         `<`         |        Less than         |
|         `>`         |       Greater than       |
|        `<=`         |  Less than or equal to   |
|        `>=`         | Greater than or equal to |
|        `==`         |         Equal to         |
|        `!=`         |       Not Equal to       |

#### Assign values to variables

```{r}
x <- 227
y <- 639
```

a.  Less than

```{r}
x < y
```

b.  Greater than

```{r}
x > y
```

c.  Less than or equal to

```{r}
x <= 300
```

d.  Greater than or equal to

```{r}
y >= 700
```

e.  Equal to

```{r}
y == 639
```

f.  Not Equal to

```{r}
x != 227
```

### Logical Operators

Logical operators are used to specify multiple conditions between objects. Logical operators work with basic data types such as logical, numeric, and complex data types. These operators generally return `TRUE` or `FALSE` values. Numbers greater that 1 are `TRUE` and 0 equals `FALSE`. The table below describes the most common logical operators.

| Logical Operator |       Description        |
|:----------------:|:------------------------:|
|       `!`        |       Logical NOT        |
|       `|`        | Element-wise logical OR  |
|       `&`        | Element-wise logical AND |

#### Assign vectors to variables

NOTE: Full discussion in the chapter on "Vectors" (@sec-vectors)

```{r}
vector_1 <- c(0,2)
vector_2 <- c(1,0)
```

a.  Logical NOT

```{r}
!vector_1
```

```{r}
!vector_2
```

b.  Element-wise Logical OR

```{r}
vector_1 | vector_2
```

c.  Element-wise Logical AND

```{r}
vector_1 & vector_2
```

### Assignment Operators

These operators assign values to variables. A more comprehensive review can be obtained in the lesson on "Basic arithmetic, arithmetic operators, and variables" (@sec-arithmetic-variables)

### Miscellaneous Operators

These are helpful operators for working in that can perform various functions. A few common miscellaneous operators are described below.

| Miscellaneous Operator |                          Description                           |
|:-------------------:|:-------------------------------------------------:|
|         `%*%`          | Matrix multiplication (to be discussed in subsequent chapters) |
|         `%in%`         |               Does an element belong to a vector               |
|          `:`           |                      Generate a sequence                       |

a.  Sequence

```{r}
a <- 1:8
a
```

```{r}
b <- 4:10
b
```

b.  Element in a vector

```{r}
a %in% b
```

```{r}
9 %in% b
```

```{r}
9 %in% a
```

## Exercises

-   List the basic operator types in R and provide an example for each.

-   What operators allow you to subset vectors, lists, and data frames in R?

-   Explain how the modulus operator (`%/%`) differs from the regular division operator (`/`).

-   What are the membership operators `%in%` and `!%in%` used for in R?

-   Assign 10 to x using `<-`. Then compare if `x == 10`.

-   Calculate `3^4` using arithmetic operators.

-   Compare `3 > 5`. Is the result TRUE or FALSE?

-   When would you use the sequence operator (`:`) in R? Give an example.

## Summary

The focus of this chapter has been the five major types of operators that can be used in R/RStudio. The operators allow one to perform numerous tasks including basic arithmetic including basic arithmetic, comparisons, subsetting, matrix multiplication, and vector generation. In the next chapter, we will discuss the available data types in R and how to utilize/handle them.