CODEWITHSUNDEEP
c#listcontainsfloating-accuracy
ogilberry
ogilberry

Reputation: 73

C# accuracy when checking float in List<float> with Contains method

I have a list of floats and want to check if it already contains a particular value with the List.Contains() method. I know that for float equality tests you often can't use == but something like myFloat - value < 0.001.

My question is, does the Contains method account for this or I do I need to use a method that accounts for float precision errors for testing if the float is in the list?

Upvotes: 6

Views: 1734

Answers (3)

DavidG
DavidG

Reputation: 119016

From the docs for List(T).Contains:

This method determines equality by using the default equality comparer, as defined by the object's implementation of the IEquatable<T>.Equals method for T (the type of values in the list).

So you will need to handle comparison with a threshold yourself. For example, you can use your own custom equality comparer. Something like this:

public class FloatThresholdComparer : IEqualityComparer<float>
{
    private readonly float _threshold;
    public FloatThresholdComparer(float threshold)
    {
        _threshold = threshold;
    }

    public bool Equals(float x, float y)
    {
        return Math.Abs(x-y) < _threshold;
    }

    public int GetHashCode(float f)
    {
        throw new NotImplementedException("Unable to generate a hash code for thresholds, do not use this for grouping");
    }
}

And use it:

var result = floatList.Contains(100f, new FloatThresholdComparer(0.01f))

Upvotes: 9

Corwin62
Corwin62

Reputation: 111

The other answers are correct, but if you want an alternative quick-and-dirty solution without writing a new equality comparer, you could use the List.Exists Method:

bool found = list.Exists(num => Math.Abs(num - valueToFind) < 0.001);

Edit: My original answer said the above was Linq, however the Exists method is part of the List class. The same concept using Linq is below, using IEnumerable.Any:

bool found = list.Any(num => Math.Abs(num - valueToFind) < 0.001);

Upvotes: 1

Jeff Mercado
Jeff Mercado

Reputation: 134521

It just uses the default equality comparison for objects contained in the list. It will be the equivalent of calling object.Equals() when performing the comparisons.

If you need a different equality implementation, you could use the linq Contains() overload that accepts an equality comparer. Then you'd just have to implement that comparison and pass it in. This should perform roughly the same but ultimately slower.

Upvotes: 2

Related Questions