@Garry - try this
Dim d As Double
d = 0 // where d = 0.000000000000001
If d.Equals(0.0, 5) Then // x is MaxUIps from the docs
// d is zero.
Break
End If
Break
That doesn’t work if you set d to the tiny value that he wants equal to 0.
Sure it does
MaxUIPS is … well … document weird to say the least
Dim d As Double
d = 0 // where d = 0.000000000000001
If d.Equals(0.0, 1) Then // x is MaxUIps from the docs
// d is zero.
Break
End If
Break
this usage would permit .000000000000001 to .000000000000006 to be considered “equal”
maxUIPS is the amoubt between the last digits
Dim d As Double
d = 0.000000000000001
If d.Equals(0.000000000000003, 1) Then // x is MaxUIps from the docs
// d is zero.
Break
End If
Break
since I set the “equals” call to permit a range of 0.000000000000001 to 0.000000000000002 (1 difference of 1 in the right most digit) is restricts equalness to a tiny range
I understand it should work, but does your example with .00_01 and .00_03 actually work for you? It doesn’t for me. 2020r1 on Mac.
.000_01 and .000_03 should NOT work - thats the point
The call to Equals says “treat .000_03 as equal to d IF the very last digit is within 1” and .0003 ISNT
Its 2 away from .00_001
Alter that code to use 2 and it will break treating them as if they are equal
Its why I say the docs are enormously unclear on how it works
Should this work? (edit: should it break as if they are equal?)
Dim d As Double = 0.01
dim d2 as Double = 0.02
If d.Equals(d2 ,1 ) Then // x is MaxUIps from the docs
// equal
Break
End If
BreakI dont believe so and this is why I say “the docs suck”
maxUIPS isnt really “the right most digit” - its “the right most byte” as far as I understand" - and not a “tolerance” like what would probably be better and more useful generally
For maxUIps, the last position refers to the the last byte in the binary representation of the mantissa. maxUIps is the amount of difference between the last byte of the 2 numbers that is still acceptable.
The link on the page for Equals is a good read on how this is supposed to work and it is not intuitive at all
It really limits you to the last byte which is always very very very tiny differences since its the last 8 bits of the mantissa
Yeah, I read the link and get that it’s the last byte, but didn’t see why it wasn’t working for numbers below 1. I should have read the other thread linked to learn why. Also to read a workaround/solution by some Norman Palardy guy. LOL
This is too complicated.
This isn’t working:
Var d As Double = 0.0000000000000001
If d.Equals(0.0, 1) Then Break // Never breaks
If d.Equals(0.0, 2) Then Break // Never breaks
If d.Equals(0.0, 3) Then Break // Never breaks
If d.Equals(0.0, 4) Then Break // Never breaks
If d.Equals(0.0, 5) Then Break // Never breaks
If d.Equals(0.0, 6) Then Break // Never breaks
I’ve always thought how this worked should have been more a “tolerance” but thats not whats is there
Its close but not intuitive at all
You almost have to look at what the bytes are for the double by dumping them into a memory block and examining them
Dim mb As New memoryblock(8)
mb.LittleEndian = False
mb.DoubleValue(0) = 0.0000000000000001
break
that gives a result of
3c 9c d2 b2 97 d8 89 bc
odd but ok
so if the tolerance is 1 then that _should permit values from
3c 9c d2 b2 97 d8 89 bb
to
3c 9c d2 b2 97 d8 89 bd
to be “equal”
but the debugger in Xojo says
3c 9c d2 b2 97 d8 89 bb
is 0.0000000000000001 ???
and
3c 9c d2 b2 97 d8 89 bd
is … is 0.0000000000000001 ???
so it seems “something” is broken
however since a double CAN be dumped into a memory block and bytes compared Equals could probably be made to work using our own Xojo code
A “CloseEnoughWithTolerance” method that allows you to specify a tolerance that is as precise as a double allows seems plausible but there will be inaccuracies because doubles have limited accuracy (but huge range)
Or you just use Bob Delaneys plugins and get infinite precision ?
1 Like
I figured something must be broken here. 
I took a look at Bob’s plugin page - some really good stuff on there. I think I want to stick to using Doubles rather than his Decimal type as this is for a physics engine that I want to run on iOS.
So far what I’m doing is first computing the machine epsilon of the system the engine is running on and caching it:
// Computes an approximation of machine epsilon.
Var e As Double = 0.5
While (1.0 + e > 1.0)
e = e * 0.5
Wend
Return e
This gives me (on my current machine) a value of 0.0000000000000001.
I have a computed property (Tolerance) that returns episilon + 0.00000001. This gives me my tolerance above zero I’m happy with (0.0000000100000001 in this case).
I then have the following method to test if a Double should be considered zero:
If Abs(0 - d) <= Tolerance Then
Return True
Else
Return False
End If
This works. Annoyingly I only have to do this because Xojo’s built-in Sign method doesn’t work for tiny tiny Doubles (it returns 1 for 0.000000000000001).
I’m just paranoid about performance as this function is called repeatedly in collision detection algorithms (and other areas) so gets hammered a lot.
So after a little bit more testing, I’ve settled on a suggestion by Graham Busch on the Xojo Inc forum and modified my method to the following:
Protected Function IsZero(d As Double) as Boolean
If Round(d * Pow(10, 6)) = 0 Then
Return True
Else
Return False
End If
End Function
Seems reasonably performant. The 6 is the number of decimal places of accuracy.
You could rewrite Sign for double since the IEEE 754 FP format is well defined
Plop the double in and MB and a few bit ANDS and ORS and off you go
I love how easily binary mathematics comes to you Norm 
But sign returns -1 for negative, 0 for 0, 1 for positive
So for a tiny value like that it should say “positive”
No ?
Correct although I guess it would be nice if there was a Sign method that also accepted a “tolerance” value.
Well we could write one 
here’s the sign function
Static mb As memoryblock
If mb Is Nil Then
mb = New memoryblock(8)
mb.LittleEndian = False
End If
// returns -1 For negative, +1 For positive (fwiw 0 is "positive in IEEE754 formats)
mb.DoubleValue(0) = d
If ((mb.Byte(0) And &h7F) = 0) And ((mb.Byte(1) And &hFF) = 0) And ((mb.Byte(2) And &hFF) = 0) And ((mb.Byte(3) And &hFF) = 0) _
And ((mb.Byte(4) And &hFF) = 0) And ((mb.Byte(5) And &hFF) = 0) And ((mb.Byte(6) And &hFF) = 0) And ((mb.Byte(7) And &hFF) = 0) then
return 0
Elseif (mb.Byte(0) And &h80) = 0 Then
Return 1
Else
Return -1
End If
1 Like