System.Double.CompareTo-methoden

Opmerking

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

CompareTo(Double) methode

Waarden moeten identiek zijn om als gelijk te worden beschouwd. Met name wanneer drijvendekommawaarden afhankelijk zijn van meerdere wiskundige bewerkingen, is het gebruikelijk dat ze precisie verliezen en dat hun waarden bijna identiek zijn, met uitzondering van hun minst significante cijfers. Daarom kan de retourwaarde van de CompareTo methode soms verrassend lijken. Vermenigvuldigen met een bepaalde waarde gevolgd door de verdeling door dezelfde waarde moet bijvoorbeeld de oorspronkelijke waarde opleveren. In het volgende voorbeeld blijkt de berekende waarde echter groter te zijn dan de oorspronkelijke waarde. Alle significante cijfers van de twee waarden weergeven met behulp van de standaardtekenreeks voor numerieke R-notatie geeft aan dat de berekende waarde verschilt van de oorspronkelijke waarde in de minst significante cijfers. Zie de sectie Opmerkingen van de Equals(Double) methode voor informatie over het verwerken van dergelijke vergelijkingen.

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Double = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

Deze methode implementeert de System.IComparable<T> interface en presteert iets beter dan de Double.CompareTo methode omdat deze de value parameter niet hoeft te converteren naar een object.

Houd er rekening mee dat, hoewel een object waarvan de waarde NaN niet wordt beschouwd als gelijk aan een ander object waarvan de waarde (zelfs zelf) is NaN , de IComparable<T> interface vereist dat A.CompareTo(A) nul retourneert.

CompareTo(Object) methode

De value-parameter moet null zijn of een instantie van Double; anders wordt er een uitzondering opgeworpen. Elk exemplaar van Double, ongeacht de waarde, wordt beschouwd als groter dan null.

using System;

public class Example3
{
    public static void Main()
    {
        double value1 = 6.185;
        object value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1 |> box
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example2
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Object = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

Deze methode wordt geïmplementeerd ter ondersteuning van de IComparable interface. Houd er rekening mee dat, hoewel een NaN niet wordt beschouwd als gelijk aan een andere NaN (zelfs zelf), de IComparable interface vereist dat A.CompareTo(A) nul wordt geretourneerd.

Uitbreidende conversies

Afhankelijk van uw programmeertaal is het mogelijk om een CompareTo methode te codeeren waarbij het parametertype minder bits heeft (is smaller) dan het exemplaartype. Dit is mogelijk omdat sommige programmeertalen een impliciete widening conversie uitvoeren die de parameter vertegenwoordigt als een type met zoveel bits als het exemplaar.

Stel dat het exemplaartype is Double en het parametertype is Int32. De Microsoft C#-compiler genereert instructies voor het weergeven van de waarde van de parameter als een Double object en genereert vervolgens een Double.CompareTo(Double) methode waarmee de waarden van het exemplaar en de uitgebreide weergave van de parameter worden vergeleken.

Raadpleeg de documentatie van uw programmeertaal om te bepalen of de compiler impliciete widening conversies van numerieke typen uitvoert. Zie het onderwerp Type conversietabellen voor meer informatie.

Precisie in vergelijkingen

De precisie van drijvendekommagetallen buiten de gedocumenteerde precisie is specifiek voor de implementatie en versie van .NET. Een vergelijking van twee bepaalde getallen kan dus veranderen tussen versies van .NET, omdat de precisie van de interne weergave van de getallen kan veranderen.

Feedback

Is deze pagina nuttig?

Last updated on 2024-01-30