Julia Language Comparisons Using ==, ===, and isequal
Example
There are three equality operators: ==, ===, and isequal. (The last is not really an operator, but it is a function and all operators are functions.)
When to use ==
== is value equality. It returns true when two objects represent, in their present state, the same value.
For instance, it is obvious that
julia> 1 == 1
true
but furthermore
julia> 1 == 1.0
true
julia> 1 == 1.0 + 0.0im
true
julia> 1 == 1//1
true
The right hand sides of each equality above are of a different type, but they still represent the same value.
For mutable objects, like arrays, == compares their present value.
julia> A = [1, 2, 3]
3-element Array{Int64,1}:
1
2
3
julia> B = [1, 2, 3]
3-element Array{Int64,1}:
1
2
3
julia> C = [1, 3, 2]
3-element Array{Int64,1}:
1
3
2
julia> A == B
true
julia> A == C
false
julia> A[2], A[3] = A[3], A[2] # swap 2nd and 3rd elements of A
(3,2)
julia> A
3-element Array{Int64,1}:
1
3
2
julia> A == B
false
julia> A == C
true
Most of the time, == is the right choice.
When to use ===
=== is a far stricter operation than ==. Instead of value equality, it measures egality. Two objects are egal if they cannot be distinguished from each other by the program itself. Thus we have
julia> 1 === 1
true
as there is no way to tell a 1 apart from another 1. But
julia> 1 === 1.0
false
because although 1 and 1.0 are the same value, they are of different types, and so the program can tell them apart.
Furthermore,
julia> A = [1, 2, 3]
3-element Array{Int64,1}:
1
2
3
julia> B = [1, 2, 3]
3-element Array{Int64,1}:
1
2
3
julia> A === B
false
julia> A === A
true
which may at first seem surprising! How could the program distinguish between the two vectors A and B? Because vectors are mutable, it could modify A, and then it would behave differently from B. But no matter how it modifies A, A will always behave the same as A itself. So A is egal to A, but not egal to B.
Continuing along this vein, observe
julia> C = A
3-element Array{Int64,1}:
1
2
3
julia> A === C
true
By assigning A to C, we say that C has aliased A. That is, it has become just another name for A. Any modifications done to A will be observed by C also. Therefore, there is no way to tell the difference between A and C, so they are egal.
When to use isequal
The difference between == and isequal is very subtle. The biggest difference is in how floating point numbers are handled:
julia> NaN == NaN
false
This possibly surprising result is defined by the IEEE standard for floating point types (IEEE-754). But this is not useful in some cases, such as sorting. isequal is provided for those cases:
julia> isequal(NaN, NaN)
true
On the flip side of the spectrum, == treats IEEE negative zero and positive zero as the same value (also as specified by IEEE-754). These values have distinct representations in memory, however.
julia> 0.0
0.0
julia> -0.0
-0.0
julia> 0.0 == -0.0
true
Again for sorting purposes, isequal distinguishes between them.
julia> isequal(0.0, -0.0)
false
