# isequal

isequal(x, y)

Similar to `==`, except treats all floating-point `NaN` values as equal to each other, and treats `-0.0` as unequal to `0.0`. The default implementation of `isequal` calls `==`, so if you have a type that doesn't have these floating-point subtleties then you probably only need to define `==`.

`isequal` is the comparison function used by hash tables (`Dict`). `isequal(x,y)` must imply that `hash(x) == hash(y)`.

This typically means that if you define your own `==` function then you must define a corresponding `hash` (and vice versa). Collections typically implement `isequal` by calling `isequal` recursively on all contents.

Scalar types generally do not need to implement `isequal` separate from `==`, unless they represent floating-point numbers amenable to a more efficient implementation than that provided as a generic fallback (based on `isnan`, `signbit`, and `==`).

## Examples

In the Julia programming language, the function `isequal(x, y)` is used to compare two values for equality. It is similar to the `==` operator but has some additional behavior for floating-point numbers. Here are some examples of how to use the `isequal` function:

1. Compare integers:

``````julia> isequal(10, 10)
true

julia> isequal(10, 20)
false``````
2. Compare floating-point numbers:

``````julia> isequal(1.0, 1.0)
true

julia> isequal(1.0, 1.000001)
false``````

The `isequal` function treats all floating-point `NaN` values as equal to each other and considers `-0.0` as unequal to `0.0`.

3. Compare strings:

``````julia> isequal("hello", "hello")
true

julia> isequal("hello", "world")
false``````
4. Custom types: If you define your own custom types, you may need to implement both `==` and `isequal` functions. The default implementation of `isequal` calls `==`, so if your type doesn't have any special floating-point behavior, defining `==` should be sufficient.

Note: `isequal(x, y)` implies that `hash(x) == hash(y)`. If you define your own `==` function, you should also define a corresponding `hash` function.

Collections typically implement `isequal` by calling `isequal` recursively on all their elements.

Common mistake example:

``````julia> isequal(1, 1.0)
false``````

In this example, the mistake is comparing an integer (`1`) with a floating-point number (`1.0`). It's important to ensure that the types of the values being compared are compatible to get accurate results with `isequal`.