# Operators in R Programming

Filed Under: R Programming Operators in a programming language are certain tokens or symbols that perform specific operations on the arguments supplied. The arguments are known as operands. These operations are usually arithmetic or logical in nature. R supports various operators across different categories.

## R Operators Classification

We can classify R operators into the following categories.

1. Arithmetic
2. Relational
3. Logical
4. Assignment
5. Special operators

## 1. Arithmetic Operators in R

These are the operators that perform basic arithmetic operations like addition, subtraction, multiplication, and division. In addition, there are also operators for modulus and exponentiation.

These operators work on both single variables and vectors. The use of these operators is straightforward.

The following code snippet will help you gain an understanding of these operators.

```#Mathemetical operations in single numeric values.
> a=2
> b=4
> a+b
 6
#Subtraction -- Operator -
> b-a
 2
#Multiplication -- Operator *
> a*b
 8
#Division -- Operator /
> b/a
 2
```

Similarly, we also have operators for exponentiation `^` and modulo `%%`. These are illustrated below. The modulo operator gives the remainder of a division operation.

```#Modulo Operator - %%
> x=10
> y=4
> z=x%%y
> z
 2
#Exponentiation Operator - ^
> w=x^y
> w
 10000
```

These operators also work on a vector level. Addition, subtraction and other operations work on an element by element level. This is illustrated in the code below.

```#Define 2 vectors
> vec1=c(2,3,5,1,4)
> vec2=c(3,4,5,1,7)
> vec1+vec2
  5  7 10  2 11
#Subtraction of two vectors
> vec1-vec2
 -1 -1  0  0 -3
#Multiplication of two vectors
> vec1*vec2
  6 12 25  1 28
#Division of two vectors
> vec1/vec2
 0.6666667 0.7500000 1.0000000 1.0000000 0.5714286
#Exponentiation of a vector using integer
> vec1^2
  4  9 25  1 16
#Element-wise exponentiation
> vec1^vec2
     8    81  3125     1 16384
```

## 2. Relational Operators in R

These are used to compare two numbers or two vectors. The main relational operators are greater than (`>`) , less than (`<`) and equal to (`==`).

There are other compound operators greater than or equal to (`>=`) and less than or equal to(`<=`). The output of these operators is a Boolean value, TRUE or FALSE. These are illustrated in the given code snippet.

When applied to vectors, these operators perform an element-wise comparison and give a vector of corresponding Boolean values as a result.

```> x
 10
> y
 4
> z
 2
> w
 10000
> x < w
 TRUE
> y > z
 TRUE
> x == w
 FALSE
> x <= x
 TRUE
> y >= z
 TRUE
> vec1<vec2 #From the previous operator set.
  TRUE  TRUE FALSE FALSE  TRUE
```

## 3. R Logical Operators

These take Boolean values as operands and give Boolean value as output. These are AND (`&`), OR (`|`) and NOT (`!`). These can be used as follows:

```#Logical AND - Gives TRUE only if both the holding conditions are TRUE.
> 2<4&4>1
 TRUE
> 8>8&9>8
 FALSE

#Logical OR - Gives TRUE if any of the holding condtions are TRUE.
> (1.3-3.14<0)|(3==0)
 TRUE

#Logical NOT - Simply negates the value from FALSE to TRUE or TRUE to FALSE.
> !(30>2)
 FALSE
```

Similar to the logical operators above, we also have element-wise logical operators – AND (&&) and OR (||). These are used upon vectors and give results corresponding to only the first elements of two vectors. This can be shown in the following code.

```> vec1
 2 3 5 1 4
> vec3
 1 0 0 0 0

> vec1&vec3
  TRUE FALSE FALSE FALSE FALSE
> vec1&&vec3
 TRUE

> vec1|vec3
 TRUE TRUE TRUE TRUE TRUE
> vec1||vec3
 TRUE
> !vec1
 FALSE FALSE FALSE FALSE FALSE
```

## 4. R Assignment Operators

The assignment operators are used to assign values to a variable. There are three assignment operators in R, left assignment (`<-`), right assignment (`-`>) and equal to (`=`). These have been discussed in detail in the variables tutorial here.

## 5. Special Operators in R

R has some operators defined for special purposes. Some of these are:

• Sequence Generator – Specified by a colon symbol (:)
• Used to define a sequence range.
• 2:10 – means a sequence from 2 to 10.
• List Indexing Operator – Specified by a dollar sign \$.
• Facilitates extracting an element of a list by its name.
• Model Formula Operator – Specified by a tilde sign ~
• Used to define a re-usable formula along with its dependent variables.

We will delve deeper into the list indexing and model formula operators in our further advanced tutorials. The sequence generator works as follows.

```> seq2 <- 2:10
> seq2
  2  3  4  5  6  7  8  9 10
```

close
Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors