System.Double.CompareTo-metoder

Anmärkning

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

CompareTo(Double) metod

Värdena måste vara identiska för att anses vara lika. Särskilt när flyttalsvärden är beroende av flera matematiska operationer är det vanligt att de förlorar precision och att deras värden är nästan identiska förutom de minst signifikanta siffrorna. På grund av detta kan returvärdet för CompareTo-metoden ibland verka överraskande. Till exempel bör multiplikation med ett visst värde följt av division med samma värde generera det ursprungliga värdet. I följande exempel visar sig dock det beräknade värdet vara större än det ursprungliga värdet. Om du visar alla signifikanta siffror av de två värdena genom att använda 'R'-standardformatsträngen i numeriskt format, visar det att det beräknade värdet skiljer sig från det ursprungliga värdet i dess minst signifikanta siffror. Information om hur du hanterar sådana jämförelser finns i avsnittet Anmärkningar i metoden Equals(Double).

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

Den här metoden implementerar System.IComparable<T>-gränssnittet och fungerar något bättre än metoden Double.CompareTo eftersom den inte behöver konvertera parametern value till ett objekt.

Observera att även om ett objekt vars värde är NaN inte anses vara lika med ett annat objekt vars värde är NaN (till och med sig självt), kräver IComparable<T>-gränssnittet att A.CompareTo(A) returnera noll.

CompareTo(Object) metod

Parametern value måste vara null eller en instans av Double. annars utlöses ett undantag. Alla instanser av Double, oavsett dess värde, anses vara större än 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

Den här metoden implementeras för att stödja IComparable-gränssnittet. Observera att även om en NaN inte anses vara lika med en annan NaN (även sig själv), kräver IComparable-gränssnittet att A.CompareTo(A) returnera noll.

Bredda konverteringar

Beroende på programmeringsspråket kan det vara möjligt att koda en CompareTo metod där parametertypen har färre bitar (är smalare) än instanstypen. Detta är möjligt eftersom vissa programmeringsspråk utför en implicit breddningskonvertering som representerar parametern som en typ med så många bitar som instansen.

Anta till exempel att instanstypen är Double och att parametertypen är Int32. Microsoft C#-kompilatorn genererar instruktioner för att representera värdet för parametern som ett Double-objekt och genererar sedan en Double.CompareTo(Double)-metod som jämför instansens värden och den vidgade representationen av parametern.

Läs dokumentationen för programmeringsspråket för att avgöra om kompilatorn utför implicita breddningskonverteringar av numeriska typer. Mer information finns i avsnittet Typkonverteringstabeller.

Precision i jämförelser

Precisionen för flyttalsnummer utöver den dokumenterade precisionen är specifik för implementeringen och versionen av .NET. Därför kan en jämförelse av två specifika tal ändras mellan versioner av .NET eftersom precisionen i talens interna representation kan ändras.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-03-30