Relational Operators
Relational Operators or also known as comparators
which help you see how one RObject relates to another Robject. For example, you can check whether two objects are equal or not, which can be accomplished with the help of ==
(double equal) sign. A logical operator which is TRUE on both sides, will return a logical value as TRUE since TRUE equals TRUE, as shown below.
TRUE == TRUE
TRUE
However, if you have TRUE on one side and FALSE on the other, you will get a logical value FALSE as an output.
TRUE == FALSE
FALSE
Apart from logical variables, you can check the equality of other types.
Let's compare strings and numbers.
100 == 100
TRUE
100 == 200
FALSE
'tutorial' == 'R'
FALSE
 The opposite of the equality operator is the
inequality
operator, which is given by!
sign (a combination of exclamation followed by equal to).
Now all the conditions which resulted in FALSE earlier, will turn TRUE, let's check it out!
100 != 200
TRUE
'tutorial' != 'R'
TRUE
TRUE != FALSE
TRUE
Similarly, the inequality operator can also be used for numerical and other RObjects like matrices, vectors, and lists.

What if you want to check whether given two RObjects which one of them is greater or less than the other. Well, of course, you can, using simple
<
and>
sign (lessthan and greaterthan sign).Let's first see a numerical example.
2 > 10
FALSE
200 < 0
TRUE
As you can see, it is selfexplanatory why $2$ is not greater than $10$ or why $200$ is less than $0$. But, what about strings or characters? Let's see how it can be achieved.
It looks like R gives preference to alphabetical order while deciding which string or character is greater than the other.
In the example below, as t
comes after R
as per the alphabetical order; hence, t
is greater than R
.
'tutorial' > 'RRRRRRRRR'
TRUE
It is important to note that in R and almost all programming languages, TRUE is numerically interpreted as 1 and FALSE as 0. So based on this analogy, TRUE will be greater than FALSE.
TRUE > FALSE
TRUE
 You can also check whether an Robject is greater than or equal to
(>=)
(or less than or equal to<=
) another Robject. To achieve this, you can use the less than or equal to sign in combination with an equal sign. This means that if one of the two conditions (less than or equal to / greater than or equal to) is TRUE, then the complete condition will be TRUE.
5 >= 5 # 5 is not greater than 5 but is equal, hence, it returns TRUE.
TRUE
5 >= 10
FALSE
You can learn about R data types in this DataCamp tutorial. It shows that R is pretty good with handling lists, matrices, and vectors.
So can the R comparators handle the R vectors? Let's find out.
For example, you have a rowvector that has a record of the number of views you got on your recent datacamp tutorial in the last 10 days. Now, you want to find out which days you received more than or equal to 100 views. You can use the greaterthan sign offtheshelf.
datacamp_views < c(100,20,5,200,60,88,190,33,290,64)
length(datacamp_views)
10
datacamp_views >= 100
 TRUE
 FALSE
 FALSE
 TRUE
 FALSE
 FALSE
 TRUE
 FALSE
 TRUE
 FALSE
As you can see from the above output, for the first, fourth, seventh, and ninth, the results are TRUE, which on these days, the views were more than or equal to 100.
Similarly, you can also compare two vectors or even two matrices.
youtube_views < c(10,20,1000,64,100,9,19,3,90,4)
So with this way, you can build a nice and simple application to find out when were your datacamp tutorial views more than your youtube video views or viceversa.
How this works in R is that it compares the two vectors elementwise. For example, in the below output, if you consider the first element from both the vectors, you can see that the DataCamp views vector has a value of 100, which the other vector has a value 10, and hence, it returned TRUE.
datacamp_views > youtube_views
 TRUE
 FALSE
 FALSE
 TRUE
 FALSE
 TRUE
 TRUE
 TRUE
 TRUE
 TRUE
Let's quickly compare to numerics. If you remember elementary mathematics, there is a rule known as BODMAS (or PEMDAS), which means bracket of division, multiplication, addition, and subtraction based on which any mathematical equation is solved. So, you will use the same rule to solve the below two R expressions.
6 * 5 + 2 >= 10 + 1 #on left hand side multiplication will be done first and then addition as per BODMAS
FALSE
Master your data skills with DataCamp
More than 10 million people learn Python, R, SQL, and other tech skills using our handson courses crafted by industry experts.
Compare matrices
R's ability to deal with different data structures for comparisons does not stop at vectors. Matrices and relational operators also work together seamlessly!
Instead of vectors (as in the previous example), the DataCamp and YouTube data are now stored in a matrix called views
. The first row contains the DataCamp information; the second row the YouTube information. You will use R's inbuilt matrix
function to create a matrix with the help of datacamp and youtube vectors created in the previous example.
datacamp_views < c(100,20,5,200,60,88,190,33,290,64)
youtube_views < c(10,20,1000,64,100,9,19,3,90,4)
views < matrix(c(datacamp_views, youtube_views), nrow = 2, byrow = TRUE)
views
100  20  5  200  60  88  190  33  290  64 
10  20  1000  64  100  9  19  3  90  4 
Let's find out when were the views of both datacamp as well as youtube equal to 20.
views == 20
FALSE  TRUE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE 
FALSE  TRUE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE 
Great! So you are done with understanding how relational operators work, now let's move on to logical operators.
Logical Operators
R helps you in combining the results of relational operators by providing you following logical operators:
AND
( & ) operatorOR
(  ) operatorNOT
( ! ) operator
Let's have a look at each one of them.
 AND operator: Like in any other programming language, the R's AND operator takes two logical values and returns TRUE only & only if both appear to be true else it returns false.
Let's look at some of the selfexplanatory examples.
TRUE & TRUE # 1.1 = 1
TRUE
TRUE & FALSE # 1.0 = 0
FALSE
FALSE & FALSE # 0.0 = 0
FALSE
FALSE & TRUE # 0.1 = 0
FALSE
Similarly, instead of using logical values as above, you can use the results of comparators with these operators.
x < 100
x < 200 & x >= 100 # since x is less than 200 but less than equal to 100, so it returns TRUE.
TRUE
x < 200 & x > 100 # this holds FALSE since the second comparison i.e. x greater than 100 is false.
FALSE
 OR Operator: The OR operator is quite similar to the AND operator. However, the only main difference is that here the overall OR expression is TRUE if either one of the logical values it uses is TRUE.
Let's look at some of the selfexplanatory examples.
TRUE  TRUE # 1 + 1 = 1
TRUE
TRUE  FALSE # 1 + 0 = 0
TRUE
FALSE  FALSE # 0 + 0 = 0
FALSE
FALSE  TRUE # 0 + 1 = 0
TRUE
Let us use the same numerical example as used above, but this time the result should differ.
x < 100
x < 200  x > 100 # this holds TRUE since the first comparison i.e. x less than 100 is True.
TRUE
 NOT Operator: It's the most simple operator to understand, which just negates the logical operator it is applied on, or you can think of it as the opposite of the logical operator.
Let's look at some examples!
a = 1
!a # this returns false since not of a will be 0 which is FALSE.
FALSE
a = 0
!a #similar to the above example this return TRUE since a = 0 and not of a is 1.
TRUE
Let's look at some cases where the NOT operator can be helpful when dealing with R's inbuilt functions.
is.numeric(5) #returns TRUE since 5 is numeric
TRUE
!is.numeric(5) #not of the same will return FALSE
FALSE
is.numeric('aditya')
FALSE
The below example can be useful in a situation where you are dealing with a mix of numeric and string data, and you want to filter out the strings/characters from maybe a list and only keep numeric data.
!is.numeric('aditya')
TRUE
Finally, let's find out how logical operators function on vectors and matrices.
a < c(FALSE, TRUE, FALSE)
b < c(TRUE, TRUE, FALSE)
a & b # AND operator
 FALSE
 TRUE
 FALSE
a  b # OR operator
 TRUE
 TRUE
 FALSE
Based on the above two outputs, it is apparent that similar to vectors in relational operators. Logical operators also perform operations elementwise.
However, the NOT operator can only be applied on a single vector at a time or maybe on the result of two vectors.
!a
 TRUE
 FALSE
 TRUE
!b
 FALSE
 FALSE
 TRUE
In the example below, the NOT operator is outside the brackets, which means it is applied to the result of a and b. The below operator can also be termed as a NOR
(NotOR) operator.
!(a  b) # NOR operator
 FALSE
 FALSE
 TRUE
Before moving on to conditional statements, let's do a small exercise.
You have the same datacamp tutorial views in a vector form that you had defined above. Let's extract the last element from it using R's tail
method.
last < tail(datacamp_views,1)
print (last)
[1] 64
Let's find out if the last element is under 100 or above 100.
last < 100  last > 100
TRUE
Since the last element is under 100, one of the expression satisfies that, hence, it returned TRUE.
Let's move on to the final topic of this tutorial, i.e., conditional statements!
Conditional Statements
Until now, you have already learned about relational operators, which tells you how RObjects relate to each other and logical operators, which allow you to combine logical values. R provides you a way to combine all of these operators and use the result to change the behavior of your R scripts. With this, let's get into the if
and else
statements.
The syntax of the if
condition is defined below: if(condition){ // expression } The if
statement takes an input a condition ( inside parentheses ) which you can relate to a relational or some logical operator and if that condition is TRUE then the R code associated with the condition ( inside curly brackets ) is executed. Simple, isn't it?
Let's understand it with an example.
Suppose you have a variable x which equals to 10, now, you will put a condition which checks whether x is greater than zero and negates that with a NOT operator. Since the condition is TRUE, the R code inside the curly brackets will be executed.
x < 10
if (!x > 0){
print("x is a negative number")
}
[1] "x is a negative number"
However, if you remove the NOT operator, then the condition will turn FALSE, and the code inside the curly brackets will not be executed.
if (x > 0){
print("x is a positive number")
}
Let's now understand the else
statement with the help of a syntax. if(condition){ // expression1 }else{ // expression2 } Unlike the if
statement, the else
statement does not require an explicit condition with it, it has to be used in combination with the if
statement. The R code associated with the else
statement is executed only if the condition of the if` statement is not TRUE.
Let's take the same if
statement example to understand the else
statement.
x < 10
if (x > 0){
print("x is a positive number")
}else{
print("x is a negative number")
}
[1] "x is a negative number"
In the above example, since the if
statement was not valid, hence, the else
statement was executed.
Similar to if
and else
statement, you have else if
statement which comes in between if
and else
statement. It is executed when the if
statement condition is not satisfied. So, in short, the else
statement is given the last priority. if(condition){ // expression1 }else if(condition){ // expression2 }else{ // expression3 }
x < 0
if (x > 0){
print("x is a positive number")
}else if (x == 0){
print("x is zero")
}else{
print("x is a negative number")
}
[1] "x is zero"
Predominantly, one of the reasons we use the else if
statement is when the condition at hand is not mutually exclusive, meaning they could occur at the same time. Let's look at it with an example.
x < 12
if (x %% 3 == 0){
print("x is divisible by 3")
}else if (x %% 4 == 0){
print("x is divisible by 4")
}else{
print("x is neither divisible by 3 nor by 4")
}
[1] "x is divisible by 3"
In the above example, the if
condition became TRUE, so R exits the control structure and does not go to the next statements even though the else if
condition would evaluate to TRUE it didn't execute it. However, instead of else if
statement if you would have used another if
condition, then even that would have been executed.
Conclusion
Congratulations on finishing the tutorial.
This tutorial was a good starting point for beginners who are curious to learn the R programming language. As a good exercise, you might want to apply the relational and logical operators as conditions in the conditional statements.
There are still topics that are yet to be covered in R like Utilities in R and Machine Learning using R, which will be covered in the future tutorials, so stay tuned!
Please feel free to ask any questions related to this tutorial in the comments section below.
If you would like to learn more about R, take DataCamp's Intermediate R course.
Learn more about R