In R, boolean variables can take only 2 values: `TRUE`

and `FALSE`

. For example,

```
# declare boolean
x <- TRUE
print(x)
print(class(x))
# declare boolean using single character
y <- F
print(y)
print(class(y))
```

**Output**

[1] TRUE [1] "logical" [1] FALSE [1] "logical"

Here, we have declared `x` and `y` as boolean variables. In R, Boolean variables belong to the `logical`

class.

You can also declare boolean variables using a single character - `T`

or `F`

. Here, `T`

stands for `TRUE`

and `F`

stands for `FALSE`

.

## R Boolean With Comparison Operators

Comparison operators are used to compare two values.

Operator | Description | Example |
---|---|---|

`>` |
Greater than | `5 > 6` returns `FALSE` |

`<` |
Less than | `5 < 6` returns `TRUE` |

`==` |
Equals to | `10 == 10` returns `TRUE` |

`!=` |
Not equal to | `10 != 10` returns `FALSE` |

`>=` |
Greater than or equal to | `5 >= 6` returns `FALSE` |

`<=` |
Less than or equal to | `6 <= 6` returns `TRUE` |

The output of a comparison is a boolean value. For example, to check if two numbers are equal, you can use the `==`

operator.

```
x <- 10
y <- 23
# compare x and y
print(x == y) # FALSE
```

Similarly, to check if `x` is less than `y`, you can use the `<`

operator.

```
x <- 10
y <- 23
# compare x and y
print(x < y) # TRUE
```

Since, the value stored in `x` is less than the value stored in `y`, the comparison `x < y`

results in `TRUE`

.

## R Boolean With Logical Operators

Logical operators are used to compare the output of two comparisons. There are three types of logical operators in R. They are:

- AND operator (
`&`

) - OR operator (
`|`

) - NOT operator (
`!`

)

### AND Operator (&)

The AND operator `&`

takes as input two logical values and returns the output as another logical value.

The output of the operator is `TRUE`

only when both the input logical values are either `TRUE`

or evaluated to `TRUE`

.

Let `a` and `b` represent two operands. `0`

represents `FALSE`

and `1`

represents `TRUE`

. Then,

a | b | a & b |
---|---|---|

1 | 1 | 1 |

1 | 0 | 0 |

0 | 1 | 0 |

0 | 0 | 0 |

For example,

```
# print & of TRUE and FALSE combinations
TRUE & TRUE
TRUE & FALSE
FALSE & TRUE
FALSE & FALSE
```

**Output**

[1] TRUE [1] FALSE [1] FALSE [1] FALSE

The input to any logical operator can also be a comparison between two or more variables. For example,

```
x <- 10
y <- 23
z <- 12
print(x<y & y>z)
```

**Output**

[1] TRUE

Here, the condition checks whether `x` is less than `y` and `y` is less than `z` or not. If both the conditions evaluate to `TRUE`

, then the output is `TRUE`

. If any of them is `FALSE`

, the output turns out to be `FALSE`

.

### OR Operator (|)

The OR operator `|`

returns `TRUE`

if all or any one of the logical inputs is `TRUE`

or evaluates to `TRUE`

. If all of them are `FALSE`

, then it returns `FALSE`

. Consider the table below.

a | b | a | b |
---|---|---|

1 | 1 | 1 |

1 | 0 | 1 |

0 | 1 | 1 |

0 | 0 | 0 |

For example,

```
# print | of TRUE and FALSE combinations
TRUE | TRUE
TRUE | FALSE
FALSE | TRUE
FALSE | FALSE
```

**Output**

[1] TRUE [1] TRUE [1] TRUE [1] FALSE

Here, if any one of the inputs is `TRUE`

, then the output is `TRUE`

.

Similar to the case of AND operator, you can use any number of comparisons as input to the OR operator. For example,

```
w <- 54
x <- 12
y <- 25
z <- 1
print(w>x | x>y | z>w)
```

**Output**

[1] TRUE

Here, only the comparison `w>x`

evaluates to `TRUE`

. Apart from that, all the other comparisons evaluate to `FALSE`

. Since, at least one of the inputs is `TRUE`

, the output of the entire comparison is `TRUE`

.

### NOT (!) Operator

The NOT operator `!`

is used to negate the logical values it is used on. If the input value is `TRUE`

, it will turn to `FALSE`

and vice-versa.

a | !a |
---|---|

1 | 0 |

0 | 1 |

For example,

```
# print ! of TRUE and FALSE
!TRUE
!FALSE
```

**Output**

[1] FALSE [1] TRUE

Here, the output is the negation of the input.

We can use the `!`

operator with comparisons. For example, `!(x > 12)`

is the same as `x <= 12`

. This means that `x` is not greater than **12**. Which means that `x` can be less than or equal to **12**.

You can also use the NOT operator with any in-built function that evaluates to boolean value. For example,

```
x <- 3 + 5i
# using ! with in-built function
print(!is.numeric(x))
```

**Output**

[1] TRUE

Here, since `x` is of type `complex`

, the function `is.numeric(x)`

evaluates to `FALSE`

and the negation of `FALSE`

is `TRUE`

, hence the output.

## Example: R Comparison and Logical Operators

You can use all the three logical operators with comparison operators.

```
x <- 5
print(is.numeric(x) & (x>5 | x==5))
```

**Output**

[1] TRUE

Here, we can consider the entire operation in two parts - `is.numeric(x)`

and `(x>5 | x==5)`

. Since, there is an AND operator between them, if both of them evaluate to `TRUE`

, only then the output is `TRUE`

.

This is how the program works:

`is.numeric(x)`

- this evaluates to`TRUE`

since`x`is of`numeric`

type`(x>5 | x==5)`

- this evaluates to`TRUE`

since`x==5`

is`TRUE`