```Issue #15811 has been updated by duerst (Martin D=FCrst).

Ruby is an object-oriented language. So I think this should be something li=
ke:
```
a.close_to?(b, abs_tolerance: t)
```
or so, not a function with two main numbers.

----------------------------------------
Feature #15811: Propsing new method for comparing equality of 2 (float) num=
bers relatively
https://bugs.ruby-lang.org/issues/15811#change-77834

* Author: yennguyenh (yen nguyen)
* Status: Open
* Priority: Normal
* Assignee: =

* Target version: =

----------------------------------------
# Background

Equal comparison method between 2 float numbers returns unexpected results =
sometimes. Therefore, a relative comparison method is needed!

# Proposal

A relative equal comparison method has been written based on a Python proje=
ct! This method gives the approximation for the equal comparison based on t=
wo values: realative tolerance and absolute tolerance. Near zero value will=
also be considered carefully!

# Implementation

The function for that would be called close?
`close?(a, b, rel_tol, abs_tol)`

`a` and `b`: are the two values to be tested to relative closeness

`rel_tol`: is the relative tolerance -- it is the amount of error allowed, =
relative to the larger absolute value of a or b. For example, to set a tole=
rance of 5%, pass tol=3D0.05. The default tolerance is 1E-9, which assures =
that the two values are the same within about 9 decimal digits. rel_tol mus=
t be greater than 0.0

`abs_tol`: is a minimum absolute tolerance level -- useful for comparisons =
near zero.

# Evaluation of your implementation

By default, relative tolerance is 1E-9 which is relatively precise enough t=
o compare two float numbers. However it can also be adjusted in case higher=
accuracy is requested. The absolute tolerance is by default 0.0 and need t=
o be set in case of near-zero numbers.

# Discussion

There are some test cases available for the method which has approved the a=
ccuracy of the method. BigNumbers and integers are also tested. However, mo=
re test cases are still needed to assure even better the accuracy of the me=
thod.

# Gist =

Relative equal comparison

Test cases

https://gist.github.com/yennguyenh/2e81dc72b310cb9d886a82faf3d536ef

-- =

https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=3Dunsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>
```