Métodos System.Single.CompareTo

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

Los valores deben ser idénticos para considerarse iguales. Especialmente cuando los valores de punto flotante dependen de varias operaciones matemáticas, es habitual que pierdan precisión y que sus valores sean casi idénticos, excepto por sus dígitos menos significativos. Debido a esto, el valor devuelto del CompareTo método puede parecer sorprendente en ocasiones. Por ejemplo, la multiplicación por un valor determinado seguido de la división por el mismo valor debe generar el valor original, pero en el ejemplo siguiente, el valor calculado resulta ser mayor que el valor original. Mostrar todos los dígitos significativos de los dos valores mediante la cadena de formato numérico estándar "R" indica que el valor calculado difiere del valor original en sus dígitos menos significativos. Para obtener información sobre cómo controlar estas comparaciones, vea la sección Comentarios del Equals(Single) método .

Aunque un objeto cuyo valor no se NaN considera igual a otro objeto cuyo valor es NaN (incluso en sí mismo), la IComparable<T> interfaz requiere que A.CompareTo(A) devuelva cero.

CompareTo(System.Object)

El value parámetro debe ser null o una instancia de Single; de lo contrario, se produce una excepción. Cualquier instancia de Single, independientemente de su valor, se considera mayor que null.

using System;

public class Example
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       object value2 = value1 * operand / operand;
       Console.WriteLine("Comparing {0} and {1}: {2}\n",
                         value1, value2, value1.CompareTo(value2));
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2));
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = box (value1 * operand / operand)
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 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example2
    Public Sub Main()
        Dim value1 As Single = 16.5457
        Dim value2 As Object = value1 * CSng(3.8899982) / CSng(3.8899982)
        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 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Este método se implementa para admitir la IComparable interfaz .

CompareTo(System.Single)

Este método implementa la System.IComparable<T> interfaz y funciona ligeramente mejor que la Single.CompareTo(Object) sobrecarga porque no tiene que convertir el value parámetro en un objeto.

using System;

public class Example2
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       float value2 = value1 * operand / operand;
       Console.WriteLine("Comparing {0} and {1}: {2}\n",
                         value1, value2, value1.CompareTo(value2));
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2));
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = value1 * operand / operand
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 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example
   Public Sub Main()
       Dim value1 As Single = 16.5457
       Dim value2 As Single = value1 * CSng(3.8899982) / CSng(3.8899982)
       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 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Conversiones de ampliación

En función del lenguaje de programación, puede ser posible codificar un CompareTo método en el que el tipo de parámetro tenga menos bits (es más estrecho) que el tipo de instancia. Esto es posible porque algunos lenguajes de programación realizan una conversión de ampliación implícita que representa el parámetro como un tipo con tantos bits como la instancia.

Por ejemplo, supongamos que el tipo de instancia es Single y el tipo de parámetro es Int32. El compilador de Microsoft C# genera instrucciones para representar el valor del parámetro como un Single objeto y, a continuación, genera un Single.CompareTo(Single) método que compara los valores de la instancia y la representación ampliada del parámetro.

Consulte la documentación del lenguaje de programación para determinar si su compilador realiza conversiones implícitas de ampliación de tipos numéricos. Para obtener más información, vea el tema Tablas de conversión de tipos.

Precisión en comparaciones

La precisión de los números de punto flotante más allá de la precisión documentada es específica de la implementación y la versión de .NET. Por lo tanto, una comparación de dos números concretos podría cambiar entre versiones de .NET porque la precisión de la representación interna de los números podría cambiar.