FloatingPointApproximation

A correct way to determine if two floating-point numbers are approximately equal to one another.

This functionality is discussed in Chapter 3 of Flight School Guide to Swift Numbers.

• Swift 4.0+

Add the FloatingPointApproximation package to your target dependencies in Package.swift:

import PackageDescription

let package = Package(
  name: "YourProject",
  dependencies: [
    .package(
        url: "https://github.com/Flight-School/FloatingPointApproximation",
        from: "1.0.0"
    ),
  ]
)

Then run the swift build command to build your project.

To use FloatingPointApproximation in your Xcode project using Carthage, specify it in Cartfile:

github "Flight-School/FloatingPointApproximation" ~> 1.0.0

Then run the carthage update command to build the framework, and drag the built FloatingPointApproximation.framework into your Xcode project.

Floating-point arithmetic can produce unexpected results, such as 0.1 + 0.2 != 0.3. The reason for this is that many fractional numbers, including 0.1, 0.2, and 0.3, cannot be precisely expressed in a binary number representation.

A common mistake is to use an arbitrarily small constant (such as .ulpOfOne) to determine whether two floating-point numbers are approximately equal. For example:

let actual = 0.1 + 0.2
let expected = 0.3
abs(expected - actual) < .ulpOfOne // true

However, this doesn't work for large scale numbers:

let actual = 1e25 + 2e25
let expected = 3e25
abs(expected - actual) < .ulpOfOne // false

A better approach for determining approximate equality would be to count how many representable values, or ULPs, exist between two floating-point numbers.

The ==~ operator (and its complement, !=~) defined by this package returns a Boolean value indicating whether two floating-point numbers are approximately equal.

import FloatingPointApproximation

0.1 + 0.2 == 0.3 // false
0.1 + 0.2 ==~ 0.3 // true

Floating-point numbers are defined to be approximately equal if they are within one unit of least precision, or ULP, of one another.

Because of how Swift implements floating-point numbers, the implementation of the ==~ operator is quite simple:

func ==~<T> (lhs: T, rhs: T) -> Bool where T: FloatingPoint  {
    return lhs == rhs || lhs.nextDown == rhs || lhs.nextUp == rhs
}

A more complete approach combines both absolute and relative comparisons. The isApproximatelyEqual(to:within:maximumULPs:) method determines whether a floating-point number is approximately equal to another value by first checking to see if it is within a given absolute margin, if provided, and then checking to see if it falls within a given number of ULPs:

import FloatingPointApproximation

(0.1 + 0.2).isApproximatelyEqual(to: 0.3, within: 1e-12, maximumULPs: 2)

Ultimately, it's your responsibility to determine how to compare two floating-point numbers for approximate equality based on the requirements of your domain.

MIT

Mattt (@mattt)