Approximate equality: Difference between revisions

 

__TOC__

 

=={{header|AWK}}==

# syntax: GAWK -f APPROXIMATE_EQUALITY.AWK

# converted from C#

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

=={{header|C}}==

{{trans|Java}}

#include <stdbool.h>

#include <stdio.h>

test(3.14159265358979323846, 3.14159265358979324);

return 0;

{{out}}

<pre>100000000000000.015625, 100000000000000.015625 => 1

 

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

 

public static class Program

 

public static bool ApproxEquals(this double value, double other, double epsilon) => Math.Abs(value - other) < epsilon;

{{out}}

<pre>

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

{{trans|C}}

#include <iostream>

#include <cmath>

test(3.14159265358979323846, 3.14159265358979324);

return 0;

{{out}}

<pre>100000000000000.015625, 100000000000000.015625 => 1

-2.00000000000000044409, -2 => 0

3.141592653589793116, 3.141592653589793116 => 1</pre>

 

=={{header|D}}==

{{trans|C#}}

import std.stdio;

 

test(-sqrt(2.0) * sqrt(2.0), -2.0);

test(3.14159265358979323846, 3.14159265358979324);

{{out}}

<pre>100000000000000.015620000000000000, 100000000000000.015620000000000000 => true

{{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;

 

end.

 

 

{{out}}

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

 

[ 2dup -1e-15 ~ "%+47.30f %+47.30f -1e-15 ~ : %u\n" printf ]

{{out}}

<pre>

-2.000000000000000444089209850063 -2.000000000000000000000000000000 -1e-15 ~ : t

+3.141592653589793115997963468544 +3.141592653589793115997963468544 -1e-15 ~ : t

</pre>

 

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

 

end function

 

{{out}}

<pre> 1.000000000000000156E+14 == 1.000000000000000156E+14 ? T

=={{header|FreeBASIC}}==

{{trans|AWK}}

 

Dim Shared As Double epsilon = 1

eq_approx(3.14159265358979323846, 3.14159265358979324)

 

 

 

=={{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 (

fmt.Printf("% 21.19g %s %- 21.19g\n", pair[0], s, pair[1])

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

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

return Math.abs(value - other) < epsilon

test(3.14159265358979323846, 3.14159265358979324)

}

{{out}}

<pre>100000000000000.020000, 100000000000000.020000 => true

-2.000000, -2.000000 => false

3.141593, 3.141593 => true</pre>

 

=={{header|J}}==

 

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

|domain error

| 2(= !.1e_8)9

 

=={{header|Java}}==

{{trans|Kotlin}}

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

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

test(3.14159265358979323846, 3.14159265358979324);

}

{{out}}

<pre>100000000000000.020000, 100000000000000.020000 => true

-2.000000, -2.000000 => false

3.141593, 3.141593 => true</pre>

 

=={{header|Julia}}==

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],

println(rpad(x, 21), " ≈ ", lpad(y, 22), ": ", x ≈ y)

end

<pre>

1.0000000000000002e14 ≈ 1.0000000000000002e14: true

=={{header|Kotlin}}==

{{trans|C#}}

import kotlin.math.sqrt

 

test(-sqrt(2.0) * sqrt(2.0), -2.0)

test(3.14159265358979323846, 3.14159265358979324)

{{out}}

<pre>1.0000000000000002E14, 1.0000000000000002E14 => true

=={{header|Lobster}}==

{{trans|Rust}}

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

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

for(tv) t:

print concat_string([string(t.x), if isclose(t.x, t.y, 1.0e-9): """ ≈ """ else: """ ≉ """, string(t.y)], "")

{{out}}

<pre>

=={{header|Lua}}==

{{trans|C}}

return math.abs(value - other) < epsilon

end

end

 

{{out}}

<pre>100000000000000.020000, 100000000000000.020000 => true

-2.000000, -2.000000 => false

3.141593, 3.141593 => true</pre>

 

=={{header|Nim}}==

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

compare("sqrt(2) * sqrt(2)", sqrt(2.0) * sqrt(2.0), "2.0")

compare("-sqrt(2) * sqrt(2)", -sqrt(2.0) * sqrt(2.0), "-2.0")

 

{{out}}

-sqrt(2) * sqrt(2) ~= -2.0 is true

3.14159265358979323846 ~= 3.14159265358979324 is true</pre>

 

=={{header|Perl}}==

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

use warnings;

 

my $real_pi = 2 * atan2(1, 0);

my $roman_pi = 22/7;

{{out}}

<pre>True 100000000000000.0 ≅ 100000000000000.0

=={{header|Phix}}==

Traditionally I have always just used sprintf() to compare floating point atoms in phix.<br>

It proved much harder to get decent-looking output than perform the tests, hence I allowed both the compare (cfmt) and display (dfmt) formats to be overridden.<br>

{{out}}

64 bit (implied by some of the accuracies specified for this task):

<pre>

</pre>

32 bit (in fact a couple of them, the first and last pairs, are actually genuinely identical):

<pre>

</pre>

 

only close to themselves.

</pre>

from math import isclose

 

print(x, maybenot, "approximately equal to ", y)

 

<pre>

100000000000000.02 is approximately equal to 100000000000000.02

3.141592653589793 is approximately equal to 3.141592653589793

</pre>

 

=={{header|Racket}}==

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])

(match-define (list a b) test)

(printf "~a ~a: ~a\n" (format-num a) (format-num b) (≈ a b)))

 

{{out}}

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,

my $*TOLERANCE = .001;

say 22/7, " ≅ ", π, ": ", 22/7 ≅ π;

{{out}}

<pre>100000000000000.01 ≅ 100000000000000.011: True

3.142857 ≅ 3.141592653589793: False

3.142857 ≅ 3.141592653589793: True</pre>

 

=={{header|REXX}}==

 

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. */

numeric form; m.=9; parse value format(x,2,1,,0) 'E0' with g "E" _ .; g=g *.5'e'_ %2

do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

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],

puts "#{a} #{a.close_to?(b) ? '≈' : '≉'} #{b}"

end

{{out}}

<pre>100000000000000.02 ≈ 100000000000000.02

 

=={{header|Rust}}==

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

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

test!(-sqrt(2.0) * sqrt(2.0), -2.0);

test!(3.14159265358979323846, 3.14159265358979324);

{{out}}

<pre> 100000000000000.01 ≈ 100000000000000.011

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

 

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

 

test(BigDecimal(-Math.sqrt(2) * Math.sqrt(2)), BigDecimal(-2.0), false)

test(BigDecimal("3.14159265358979323846"), BigDecimal("3.14159265358979324"), true)

 

=={{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,

].each_slice(2, {|a,b|

say ("#{a} ≅ #{b}: ", a ≅ b)

{{out}}

<pre>

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

 

# Rounding at 2 and 3 decimal places, respectively

say (round(a, -2) == round(b, -2)) # true

 

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

 

say ("22/7 ≅ π at 2 decimals: ", approx_cmp(a, b, -2) == 0)

 

{{out}}

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

 

 

Rational approximations illustrated for substrings of PI:

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

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

{{out}}

<pre>

rat_approx(3.14159265358979323) = 1726375805/549522486

</pre>

 

=={{header|Swift}}==

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 {

for testCase in testCases {

print("\(testCase.0), \(testCase.1) => \(testCase.0.isAlmostEqual(to: testCase.1))")

 

{{out}}

===Using decimal library===

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

 

namespace eval test_almost_equal_decimal {

}

}

<pre>Is 100000000000000.01 ≈ 100000000000000.011 ? Yes.

Is 100.01 ≈ 100.011 ? No.

 

===Using string manipulation===

 

namespace eval test_almost_equal_string {

}

}

{{out}}

<pre>Is 100000000000000.01 ≈ 100000000000000.011 ? Yes.

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

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>100000000000000, 100000000000000 => True

 

=={{header|Wren}}==

var pairs = [

[100000000000000.01, 100000000000000.011],

i = i + 1

System.print(" %(i) -> %((pair[0] - pair[1]).abs < tol)")

 

{{out}}

8 -> 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),

maybeNot:=( if(x.closeTo(y,tolerance)) " \u2248" else "!\u2248" );

println("% 25.19g %s %- 25.19g %g".fmt(x,maybeNot,y, (x-y).abs()));

 

{{out}}