Approximate equality: Difference between revisions

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Numerics.Generic_Elementary_Functions;

=={{header|ALGOL 68}}==

{{Trans|Kotlin}}

# returns TRUE if value is approximately equal to other, FALSE otherwide #

PROC approx equals = ( REAL value, REAL other, REAL epsilon )BOOL: ABS ( value - other ) < epsilon;

 

=={{header|AWK}}==

# syntax: GAWK -f APPROXIMATE_EQUALITY.AWK

# converted from C#

=={{header|C}}==

{{trans|Java}}

#include <stdbool.h>

#include <stdio.h>

 

=={{header|C sharp|C#}}==

 

public static class Program

=={{header|C++}}==

{{trans|C}}

#include <iostream>

#include <cmath>

This solution compares the normalized (i.e. between 0.5 and 1 on implementations which use binary floating point) significands of the floating point numbers, correcting each significand by half the difference in the exponents so that the corrected numbers used for comparison have the same difference in order of magnitude as the original numbers and are stable when the order of the arguments is changed. Unlike the metric of comparing the difference to some fraction of the numbers' size, this approach only requires two floating point operations (the subtraction and comparison at the end), and more directly maps to the fundamental issue which leads to the need for floating-point comparisons, i.e. the limited precision of the significand.

 

(defun approx-equal (float1 float2 &optional (threshold 0.000001))

"Determine whether float1 and float2 are equal; THRESHOLD is the

=={{header|D}}==

{{trans|C#}}

import std.stdio;

 

{{libheader| System.Math}}

The Delphi has a Math.SameValue function for compare, but all float operations use by default Extended (High precision), we need use double cast for every operation, like division, multiply and square tree.

program Approximate_Equality;

 

The <code>~</code> word takes three arguments: the two values to be compared, and an epsilon value representing the allowed distance between the two values. A positive epsilon performs an absolute distance test, an epsilon of zero performs an exact comparison, and a negative epsilon performs a relative distance test (as required by this task).

{{works with|Factor|0.99 development version 2019-07-10}}

 

100000000000000.01 100000000000000.011

f~ ( r1 r2 r3 – flag ) float-ext “f-proximate”

ANS Forth medley for comparing r1 and r2 for equality: r3>0: f~abs; r3=0: bitwise comparison; r3<0:

: test-f~ ( f1 f2 -- )

1e-18 \ epsilon

Compare against the Python function documented at https://www.python.org/dev/peps/pep-0485/#proposed-implementation,

and with the discussion at https://stackoverflow.com/questions/5595425/what-is-the-best-way-to-compare-floats-for-almost-equality-in-python#

implicit none

 

=={{header|FreeBASIC}}==

{{trans|AWK}}

 

Dim Shared As Double epsilon = 1

Sleep</syntaxhighlight>

 

 

=={{header|Go}}==

Go's float64 type is limited to 15 or 16 digits of precision. As there are some numbers in this task which have more digits than this I've used big.Float instead.

 

import (

=={{header|Groovy}}==

{{trans|Java}}

private static boolean approxEquals(double value, double other, double epsilon) {

return Math.abs(value - other) < epsilon

 

=={{header|Haskell}}==

eps :: a

 

Assignment

 

test = [(100000000000000.01, 100000000000000.011)

,(100.01, 100.011)

 

J includes a "customization" conjunction ( !. ) that delivers variants of some verbs. Comparisons are tolerant by default, and their tolerance can be customized to some level. Specifying =!.0 specifies "no tolerance". Specifying a tolerance of 1e_8 is a domain error because that's no longer math. Write your own verb if you need this.

NB. default comparison tolerance matches the python result

".;._2]0 :0

=={{header|Java}}==

{{trans|Kotlin}}

private static boolean approxEquals(double value, double other, double epsilon) {

return Math.abs(value - other) < epsilon;

=={{header|jq}}==

{{trans|Lobster}}

# Closeness is determined by the `epsilon` parameter -

# the numbers are considered close if the difference between them

{{out}}

Using jq 1.6:

100.01 ≉ 100.011

1000000000.0000002 ≈ 1000000000.0000001

Julia has an infix operator, ≈, which corresponds to Julia's buitin isapprox() function.

{{trans|Python}}

[100.01, 100.011],

[10000000000000.001 / 10000.0, 1000000000.0000001000],

=={{header|Kotlin}}==

{{trans|C#}}

import kotlin.math.sqrt

 

=={{header|Lobster}}==

{{trans|Rust}}

// Return whether the two numbers `a` and `b` are close.

// Closeness is determined by the `epsilon` parameter -

=={{header|Lua}}==

{{trans|C}}

return math.abs(value - other) < epsilon

end

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

CloseEnough[a_, b_, tol_] := Chop[a - b, tol] == 0

numbers = {

In order to display the values “a” and “b” as provided, without any rounding, we transmit them as strings to a comparison procedure which compute the floating point values. If the first value “a” is provided as an operation, we use a comparison procedure which accepts the computed value of “a” as second parameter. Here, “b” is never provided as an operation and can always be transmitted as a string.

 

import strformat

import strutils

 

=={{header|OCaml}}==

Float.abs (v1 -. v2) < epsilon

 

The constants <tt>minReal</tt>, <tt>maxReal</tt> and <tt>epsReal</tt> are defined by the ISO standard 10206 (“Extended Pascal”).

However, their specific values are “implementation defined”, i.&nbsp;e. it is up to the compiler vendors to assign concrete values to them.

 

{

=={{header|Perl}}==

Passes task tests, but use the module <code>Test::Number::Delta</code> for anything of real importance.

use warnings;

 

I got a different result for test 4 to everyone else, but simply setting the cfmt to "%.10f" got it the NOT.<br>

Likewise something similar for the trickier/ambiguous test 5, for which "0.000000" is as good as anything I can do, and both now show how to get either a true or false result.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">dfmt</span><span style="color: #0000FF;">=</span><span style="color: #008000;">"%g"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cfmt</span><span style="color: #0000FF;">=</span><span style="color: #008000;">"%g"</span><span style="color: #0000FF;">)</span>

3.1415926535897931 and

3.1415926535897931 are approximately equal

</pre>

 

only close to themselves.

</pre>

from math import isclose

 

=={{header|R}}==

The base library has the function all.equal() for this task. However, when the numbers are not equal, rather than return FALSE, it tries to explain the difference. To fix this, we use isTRUE(all.equal(....)) instead.

tests <- rbind(c(100000000000000.01, 100000000000000.011),

c(100.01, 100.011),

In Racket, a number literal with decimal point is considered a flonum, an inexact number which could be either 30 or 62 bits depending on machines. By prefixing the literal with <code>#e</code>, it is now considered an exact, rational number. In this task, we test the approximate equality on both variants:

 

 

(define (≈ a b [tolerance 1e-9])

For example, in Raku, the sum of .1, .2, .3, & .4 is ''identically'' equal to 1.

 

 

It's also ''approximately'' equal to 1 but... ¯\_(ツ)_/¯

 

100000000000000.01, 100000000000000.011,

100.01, 100.011,

 

=={{header|ReScript}}==

abs_float (v1 -. v2) < epsilon

}

 

The choosing of the number of decimal digits is performed via the REXX statement: &nbsp; '''numeric digits &nbsp; ''nnn'' '''

numeric digits 15 /*what other FP hardware normally uses.*/

@.= /*assign default for the @ array. */

B= 100000000000000004.0

A approximately equal to B? true

</pre>

 

=={{header|Ruby}}==

Most work went into handling weird Float values like NaN and Infinity.

 

testvalues = [[100000000000000.01, 100000000000000.011],

 

=={{header|Rust}}==

/// Closeness is determined by the `epsilon` parameter -

/// the numbers are considered close if the difference between them

{{Out}}Best seen running in your browser by [https://scastie.scala-lang.org/kxD9xQuIQEGpABXnsE6BiQ Scastie (remote JVM)].

 

val (ok, notOk, ε) = ("👌", "❌", 1e-18d)

 

=={{header|Sidef}}==

Two values can be compared for approximate equality by using the built-in operator '''≅''', available in ASCII as '''=~=''', which does approximate comparison by rounding both operands at '''(PREC>>2)-1''' decimals. However, by default, Sidef uses a floating-point precision of 192 bits.

100000000000000.01, 100000000000000.011,

100.01, 100.011,

The Number '''n.round(-k)''' can be used for rounding the number ''n'' to ''k'' decimal places. A positive argument can be used for rounding before the decimal point.

 

var b = 100000000000000.011

 

There is also the built-in '''approx_cmp(a, b, k)''' method, which is equivalent with '''a.round(k) <=> b.round(k)'''.

 

var b = Num.pi

 

Additionally, the '''rat_approx''' method can be used for computing a very good rational approximation to a given real value:

 

say (zeta(-5).rat_approx == -1/252) # true</syntaxhighlight>

 

Rational approximations illustrated for substrings of PI:

var r = Str(Num.pi).first(k)

say ("rat_approx(#{r}) = ", Num(r).rat_approx.as_frac)

There are slight differences in how this is named in the various dialects &sup1;. If required, you have to add a forwarding alias method to Number.

{{works with|Smalltalk/X}}

#(100.01 100.011) .

{10000000000000.001 / 10000.0 . 1000000000.0000001000} .

Using the solution proposed as an addition to the Swift standard library in SE-0259. Currently this is not accepted, but is likely to be included in the Swift Numerics module.

 

 

extension FloatingPoint {

===Using decimal library===

Uses tcllib's decimal library. Using a tolerance of 9 significant digits.

 

namespace eval test_almost_equal_decimal {

 

===Using string manipulation===

 

namespace eval test_almost_equal_string {

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

 

=={{header|Wren}}==

var pairs = [

[100000000000000.01, 100000000000000.011],

 

=={{header|XPL0}}==

real A, B;

real Epsilon;

8. 3.1415926535897900E+000 3.1415926535897900E+000 true

</pre>

 

=={{header|zkl}}==

and tolerance. If the tolerance is >=0, comparison is absolute.

If tolerance is <0 (and x!=0 and y!=0), the comparison is relative.

T(100000000000000.01,100000000000000.011),

T(100.01, 100.011),