Computation Rules and Comparisons
General
There are times that we want to compare two or more values to see how they relate to each other. To do this, Clojure has several comparison operators that allow us to set up comparison rules. Clojure will then tell us if those rules hold true or not. It can be thought of as “Let me know if a condition holds true for these values.” The condition can be equality (“Let me know if 3 and 4 – 1 are equal”), less than (“Let me know if 8 / 2 is less than 9 / 1”), greater than (“Let me know if 4 * 5 is greater than 3 * 6”), etc.
Comparison operators function just like mathematical operators in that they can accept multiple operands and return one result. Additionally, there are Logical Operators which can be used to ensure that multiple comparison rules hold or don’t hold under specific conditions.
Basic Comparisons
The basic comparisons for Clojure are equality, inequality, greater than (or equal to), less than (or equal to), increasing order, and decreasing order. These are explained in detail below.
You’ll also find some practice problems. To reveal the answers, just click "Answer" below each example.
Equality
The equality comparison checks to see if all the operands are equivalent. These can be dates, numbers, text, etc. Below is an example of comparing the results of several equations to see if they are equal:
(= (* 3 4) (+ 4 8) (- 15 3))
Since all of the above equations evaluate to 12, the formula evaluates to true. This can be thought of as (* 3 4) = (+ 4 8) = (- 15 3) or 12 = 12 = 12. If we add the operand (+ 2 9) to the equation, then we would get false because it would be (* 3 4) = (+ 4 8) = (- 15 3) ≠ (+ 2 9), or 12 = 12 = 12 ≠ 11. Because there is an inequality, the whole expression becomes false.
Question: What would the following formula evaluate to?
(= 5 (- 9 4) (- (* 3 4) 7) (+ 6 2))
Answer
Inequality
The inequality comparison checks to see if all the operands are not equal. This can be dates, numbers, text, etc. Below is an example of comparing the results of several equations to see if they are not equal:
(not= (* 3 3) (+ 4 9) (- 15 5))
Since all of the above equations evaluate to different numbers, the expression evaluates to true. This can be thought of as (* 3 3) ≠ (+ 4 9) ≠ (- 15 5) or 9 ≠ 13 ≠ 10. If we add the operand (+ 3 7), then we would get false because it would be (* 3 3) ≠ (+ 4 9) ≠ (- 15 5) = (+ 3 7) or 9 ≠ 13 ≠ 10 = 10. Because there is an equality, the whole expression becomes false.
Question: What would the following evaluate to?
(not= 5 (- 9 4) (- (* 3 4) 7) (+ 6 2))
Answer
Less Than and Strictly Increasing Order
The less than operator (<) acts as a less than comparison for two operands, or it ensures that items are in strictly increasing order (each item is larger than the one on the left). For example, the formula (< 2 3) can be thought of to mean 2 < 3, and the formula (< 2 4 6) can be thought of to mean 2 < 4 < 6. Like equality and inequality, this will only evaluate to true if the condition holds true for all of the operands. Note that if two items are equal then the whole will be false. Also, remember that order matters: (< 3 4 5) is true, but (< 3 5 4) is false.
Question: What would the following evaluate to?
(< 4 7 9 (*3 4) (* 3 6))
Answer
Greater Than and Strictly Decreasing Order
The greater than operator (>) acts exactly like the less than operator (<), with the only difference being that now each operand must be greater than the one that follows. For example, the formula (> 4 1) can be thought of to mean 4 > 1, and the formula (> 9 6 2) can be thought of to mean 9 > 6 > 2. Again, it will only be true if it's true for all operands. And just like with the less than operator, it will be evaluate as false if any operand is equal to another.
Question: What would the following evaluate to?
(> 15 14 7 (*3 2) (* 2 3))
Answer
Less Than or Equal To and Increasing Order
The less than or equal to operator (<=) acts as a less than or equal to comparison for two operands, or it ensures that items are in increasing order (each item is larger than or equal to the one on the left). For example, the formula (<= 2 2) can be thought of to mean 2 ≤ 2, and the formula (<= 2 4 6 6) can be thought of to mean 2 ≤ 4 ≤ 6 ≤ 6. Like equality and inequality, this will only evaluate to true if the condition holds true for all of the operands. The order matters here as well: (<= 3 4 5 4) would evaluate to false.
Question: What would the following evaluate to?
(<= 4 7 9 (*3 4) (* 2 6))
Answer
Greater Than or Equal To and Decreasing Order
In the same way that the greater than operator (>) mirrors the less than operator (<), the greater than or equal to operator (>=) works just like the less than or equal to operator (<=). It evaluates whether one item is greater than or equal to the next, which would mean that they decrease from left to right. For example, the formula (>= 4 1) can be thought of to mean 4 ≥ 1, and the formula (>= 9 6 2) can be thought of to mean 9 ≥ 6 ≥ 2. As with all the operator we've discussed, this will only hold true if it's true for every operand. So, if even one operand is less than the one to its right, the whole formula is false.
Question: What would the following evaluate to?
(>= 15 14 7 (*3 2) (* 2 3))
Answer
Logical Operations
Logical operations help us see if two or more comparisons evaluate a certain way. For example, maybe we want to know if 3 > 2 and 5 < 6, or we would like to know if 9 = 8 or 5 = 5. Because of these situations, Clojure has provided three basic logical operations which allow us to create any combination of logical conditions that we want.
In this article the operators and, or, and not are bolded when used as operators.
AND
The and operator checks to see if all comparisons hold. It can be thought of as “if x and y and z.” We can use the and operator like any other math operator, except we replace numbers with expressions that evaluate to true or false for the operands. (Please note, this does not check to see if the operands equal each other, it checks to see if the results of all the operands are true). Below is an example:
(and (= 4 4) (< 5 6))
The expression above evaluates to true because both of the formulas within parenthesis are true. However, the expression below evaluates to false, even though all of the operands are equivalent.
(and (= 5 9) (< 9 4) (> 2 3))
Below is another expression that evaluates to false, even though some of the operands are true statements.
(and (= 5 5) (< 4 9) (> 2 3))
OR
The or operator checks to see if at least one comparison holds. It can be thought of as “if x or y or z.” We can use the or operator like any other math operator, except we replace numbers with expressions that evaluate to true or false for the operands. (Like with and, this does not check to see if the operands equal each other, but if at least one of the operands is true). Below is an example:
(or (= 4 4) (< 9 6))
The above expression evaluates to true because (= 4 4) is true, even though (< 9 6) is false. Once an or operator finds at least one true statement, the whole expression becomes true regardless of other statements. Below is an example of an expression that evaluates to false.
(or (= 5 9) (< 9 4) (> 2 3))
NOT
The not operator checks to see if the given operand is not true. Unlike and and or, the not operator only takes one operand. Below is an example of an expression that evaluates to true:
(not (= 4 6))
It's a bit of a double negative: (= 4 6) is false, but (not (= 4 6)) is true. Below is an example of an expression that evaluates to false:
(not (= 6 6))
(= 6 6) is true, so (not (= 6 6)) is false. The not operator inverts its operand, making the result be the opposite of the operand.
There's a bit of overlap between the not operator and the not= operator from earlier in the article. For example both of these formulas would evaluate as true:
(not (= 2 4))
(not= 2 4)
The difference is that while not= can only be used to show that operands are not equal, not can be used to evaluate whether other formulas evaluate as true. For example:
(not (< 1 3 2)) would evaluate as true (because three is not less than two).
(not= (< 1 3 2)) on the other hand, is not valid Clojure syntax.