Comparison module

OpenSEFA.ComparisonModule — Module

Convenience functions to compare numerical values up to some user-controlled precision.

Reference implementation: https://github.com/JuliaReach/ReachabilityBase.jl/tree/master

source
OpenSEFA.ComparisonModule.Tolerance — Type

Type that represents the tolerances for a given numeric type.

Notes

The type Tolerance, parametric in the numeric type N, is used to store default values for numeric comparisons. It is mutable and setting the value of a field affects the getter functions hence it can be used to globally fix the tolerance.

Default values are defined for the most commonly used numeric types, and for those cases when other numeric types are needed one can extend the default values as explained next.

The cases Float64 and Rational are special in the sense that they are the most commonly used types in applications. Getting and setting default tolerances is achieved with the functions get_rtol and set_rtol (and similarly for the other tolerances); the implementation creates an instance of Tolerance{Float64} (resp. Tolerance{Rational}) and sets some default values. Since Tolerance is mutable, setting a value is possible e.g. set_rtol(Type{Float64}, ε) for some floating-point ε.

For all other cases, a dictionary mapping numeric types to instances of Tolerance for that numeric type is used. For floating-point types, a default value has been defined through default_tolerance as follows:

default_tolerance(N::Type{<:AbstractFloat}) = Tolerance(Base.rtoldefault(N), N(10) * sqrt(eps(N)), zero(N))

Hence to set a single tolerance (either rtol, ztol or atol) for a given floating-point type, use the corresponding set_rtol function, while the values which have not been set will be pulled from default_tolerance. If you would like to define the three default values at once, or are computing with a non floating-point numeric type, you can just extend default_tolerance(N::Type{<:Number}).

source
OpenSEFA.ComparisonModule.relaxed_isapprox — Method

Determine if x is approximately equal to y.

Algorithm

We first check if x and y are both approximately zero, using isapproxzero(x) && isapproxzero(y). If that fails, we check if x ≈ y, using Julia's isapprox(x, y). In the latter check we use atol absolute tolerance and rtol relative tolerance.

Comparing to zero with default tolerances is a special case in Julia's isapprox, see the last paragraph in ?isapprox. This function tries to combine isapprox with its default values and a branch for x ≈ 0 ≈ y which includes x == 0 == y but also admits a tolerance ztol.

Note that if x = ztol and y = -ztol, then |x-y| = 2*ztol and still relaxed_isapprox returns true.

source
OpenSEFA.ComparisonModule.relaxed_leq — Method

Determine if x is smaller than or approximately equal to y.

The x <= y comparison is split into x < y or x ≈ y; the latter is implemented by extending Julia's built-in isapprox(x, y) with an absolute tolerance that is used to compare against zero.

source