The Podman wrote:
> As some point, I'm asking Ruby to assert_equal(a,b), where a and b are
> Vectors (from the matrix.rb file). Unfortunatley one test fails,
> specifically in the case where Vector[27.8, 0.0] does not equal
> Vector[27.8, 0.0]. After much head scratching and playing about with the
> debugger, I realised it's the age old problem of floating point
> comparison. For some reason I just didn't expect to have to worry about
> this in Ruby! Annoyingly, I don't know how to go about "fixing" my
> problem. and my problem is this:
>   
You may find something like this useful. Its based on the tolerant 
compare function used in APL where it is used as the definition of 
equality for floating point numbers. Note that in APL fuzz is actually a 
special global that can be set as necessary to change the relative 
tolerance.  Note that this is quick and dirty code and does not handle 
the special case when one of the arguments is zero. This value of fuzz 
would be appropriate for "equality within 10 decimal places". 

Ruby has a variety of means to extend or modify assert_equal to work 
this way.

--------------------------------

def fuzzy_equals( x, y )
    fuzz = 1.0E-10
    max = [x.abs, y.abs].max
    ( x - y ).abs / max < fuzz
end

class TC_Fuzzy < Test::Unit::TestCase
    def test_01
        assert( fuzzy_equals( 17 + 1.0E-10, 17 ) )
        assert( fuzzy_equals( 1.7 + 1.0E-10, 1.7 ) )
        assert( ! fuzzy_equals( 0.7 + 1.0E-10, 0.7 ) )

        assert( fuzzy_equals( 17 - 1.0E-10, 17 ) )
        assert( fuzzy_equals( 1.7 - 1.0E-10, 1.7 ) )
        assert( ! fuzzy_equals( 0.7 - 1.0E-10, 0.7 ) )

        assert( fuzzy_equals( -17 + 1.0E-10, -17 ) )
        assert( fuzzy_equals( -1.7 + 1.0E-10, -1.7 ) )
        assert( ! fuzzy_equals( -0.7 + 1.0E-10, -0.7 ) )

        assert( fuzzy_equals( -17 - 1.0E-10, -17 ) )
        assert( fuzzy_equals( -1.7 - 1.0E-10, -1.7 ) )
        assert( ! fuzzy_equals( -0.7 - 1.0E-10, -0.7 ) )
    end
end

----------------------------------

Bill Rutiser