Single Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

netstandard.dll

Ensamblado:

mscorlib.dll

Representa un número de punto flotante de precisión sencilla.

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable

public value class float : IComparable, IConvertible, IFormattable

public value class float : IComparable, IComparable<float>, IEquatable<float>, IFormattable

public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable

[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable

type single = struct
    interface IConvertible
    interface IFormattable

type single = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type single = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type single = struct
    interface IFormattable
    interface IConvertible

type single = struct
    interface IFormattable

Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable

Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), ISpanFormattable

Public Structure Single
Implements IComparable, IConvertible, IFormattable

Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable

Herencia

Object

ValueType

Single

Atributos

SerializableAttribute ComVisibleAttribute

Implementaciones

IComparable IComparable<Single> IConvertible IEquatable<Single> IFormattable ISpanFormattable

Comentarios

El tipo de valor representa un número de 32 bits de precisión sencilla con valores que van de Single negativos 3,402823e38 a positivos de 3,402823e38, así como cero positivo o negativo, , y no PositiveInfinity un número ( NegativeInfinity NaN ). Está diseñado para representar valores extremadamente grandes (como distancias entre planetas o demonios) o extremadamente pequeños (por ejemplo, la masa química de una esencia en los animales) y que a menudo son imprecisos (como la distancia desde la tierra a otro sistema solar). El tipo cumple con el estándar Single IEC 60559:1989 (IEEE 754) para aritmética de punto flotante binario.

Este artículo consta de las secciones siguientes:

• Representación y precisión de punto flotante

• Pruebas de igualdad

• Excepciones y valores de punto flotante

• Conversión de tipos y estructura única

• Funcionalidad de punto flotante

System.Single proporciona métodos para comparar instancias de este tipo, convertir el valor de una instancia en su representación de cadena y convertir la representación de cadena de un número en una instancia de este tipo. Para obtener información sobre cómo los códigos de especificación de formato controlan la representación de cadena de tipos de valor, vea Tipos de formato ,Cadenas de formato numérico estándar y Cadenasde formato numérico personalizado.

Representación y precisión de punto flotante

El tipo de datos almacena valores de punto flotante de precisión sencilla en un formato binario de 32 bits, como se Single muestra en la tabla siguiente:

Parte	Bits
Significando o mantisa	0-22
Exponente	23-30
Signo (0 = positivo, 1 = negativo)	31

Del mismo modo que las fracciones decimales no pueden representar con precisión algunos valores fraccionales (como 1/3 o ), las fracciones binarias no pueden representar algunos Math.PI valores fraccionales. Por ejemplo, 2/10, representado exactamente por .2 como una fracción decimal, se representa mediante .0011111001001100 como una fracción binaria, con el patrón "1100" repitiendo al infinito. En este caso, el valor de punto flotante proporciona una representación imprecisa del número que representa. La realización de operaciones matemáticas adicionales en el valor de punto flotante original a menudo aumenta su falta de precisión. Por ejemplo, si compara los resultados de multiplicar .3 por 10 y agregar .3 a .3 nueve veces, verá que la suma produce el resultado menos preciso, ya que implica ocho operaciones más que la multiplicación. Tenga en cuenta que esta disparidad solo es evidente si se muestran los dos valores mediante la cadena de formato numérico estándar "R", que, si es necesario, muestra los 9 dígitos de precisión admitidos por el Single Single tipo.

using System;

public class Example
{
   public static void Main()
   {
      Single value = .2f;
      Single result1 = value * 10f;
      Single result2 = 0f;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

Module Example
   Public Sub Main()
      Dim value As Single = .2
      Dim result1 As Single = value * 10
      Dim result2 As Single
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".2 * 10:           {0:R}", result1)
      Console.WriteLine(".2 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

Dado que algunos números no se pueden representar exactamente como valores binarios fraccionales, los números de punto flotante solo pueden aproximarse a números reales.

Todos los números de punto flotante tienen un número limitado de dígitos significativos, lo que también determina la precisión con la que un valor de punto flotante se aproxima a un número real. Un Single valor tiene hasta 7 dígitos decimales de precisión, aunque se mantiene internamente un máximo de 9 dígitos. Esto significa que algunas operaciones de punto flotante pueden carecer de precisión para cambiar un valor de punto flotante. En el ejemplo siguiente se define un valor de punto flotante de precisión sencilla grande y, a continuación, se agrega el producto de Single.Epsilon y un cuatrimendo a él. Sin embargo, el producto es demasiado pequeño para modificar el valor de punto flotante original. Su dígito menos significativo es milésimas, mientras que el dígito más significativo del producto es de 10^{a 30}.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123.456f;
      Single additional = Single.Epsilon * 1e15f;
      Console.WriteLine($"{value} + {additional} = {value + additional}");
   }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

La precisión limitada de un número de punto flotante tiene varias consecuencias:

• Dos números de coma flotante que parecen iguales para una precisión determinada podrían no compararse como iguales porque sus dígitos menos significativos sean diferentes. En el ejemplo siguiente, se agregan una serie de números y su total se compara con el total esperado. Aunque los dos valores parecen ser los mismos, una llamada al Equals método indica que no lo son.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
        Single result = 27.65f;
        Single total = 0f;
        foreach (var value in values)
           total += value;
  
        if (total.Equals(result))
           Console.WriteLine("The sum of the values equals the total.");
        else
           Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                             total, result); 
     }
  }
  // The example displays the following output:
  //      The sum of the values (27.65) does not equal the total (27.65).   
  //
  // If the index items in the Console.WriteLine statement are changed to {0:R},
  // the example displays the following output:
  //       The sum of the values (27.6500015) does not equal the total (27.65).
  

  Module Example
     Public Sub Main()
        Dim values() As Single = { 10.01, 2.88, 2.88, 2.88, 9.0 }
        Dim result As Single = 27.65
        Dim total As Single
        For Each value In values
           total += value
        Next
        If total.Equals(result) Then
           Console.WriteLine("The sum of the values equals the total.")
        Else
           Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                             total, result) 
        End If     
     End Sub
  End Module
  ' The example displays the following output:
  '      The sum of the values (27.65) does not equal the total (27.65).   
  '
  ' If the index items in the Console.WriteLine statement are changed to {0:R},
  ' the example displays the following output:
  '       The sum of the values (27.639999999999997) does not equal the total (27.64).
  

  Si cambia los elementos de formato de la instrucción de y a y para mostrar todos los dígitos significativos de los dos valores, está claro que los dos valores no son iguales debido a una pérdida de precisión durante las operaciones de Console.WriteLine(String, Object, Object) {0} {1} {0:R} {1:R} Single suma. En este caso, el problema se puede resolver llamando al método para redondear los valores a la precisión Math.Round(Double, Int32) deseada antes de realizar la Single comparación.

• Una operación matemática o de comparación que usa un número de punto flotante podría no producir el mismo resultado si se usa un número decimal, porque es posible que el número de punto flotante binario no sea igual al número decimal. En un ejemplo anterior se ilustra esto mostrando el resultado de multiplicar .3 por 10 y agregar .3 a .3 nueve veces.

  Cuando sea importante la precisión en las operaciones numéricas con valores fraccionales, use el Decimal tipo en lugar del tipo Single . Cuando sea importante la precisión en las operaciones numéricas con valores enteros más allá del intervalo de los tipos Int64 o , use el tipo UInt64 BigInteger .

• Un valor podría no ser de ida y vuelta si hay un número de punto flotante implicado. Se dice que un valor es de ida y vuelta si una operación convierte un número de punto flotante original en otro formulario, una operación inversa transforma el formulario convertido de nuevo en un número de punto flotante y el número de punto flotante final es igual al número de punto flotante original. El recorrido de ida y vuelta puede producir un error porque uno o varios dígitos menos significativos se pierden o cambian en una conversión. En el ejemplo siguiente, tres Single valores se convierten en cadenas y se guardan en un archivo. Como se muestra en la salida, aunque los valores parezcan ser idénticos, los valores restaurados no son iguales a los valores originales.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\Singles.dat");
        Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++) {
           sw.Write(values[ctr].ToString());
           if (ctr != values.Length - 1)
              sw.Write("|");
        }      
        sw.Close();
        
        Single[] restoredValues = new Single[values.Length];
        StreamReader sr = new StreamReader(@".\Singles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
           restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
  
        for (int ctr = 0; ctr < values.Length; ctr++)
           Console.WriteLine("{0} {2} {1}", values[ctr], 
                             restoredValues[ctr],
                             values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
     }
  }
  // The example displays the following output:
  //       2.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Singles.dat")
        Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write(values(ctr).ToString())
           If ctr <> values.Length - 1 Then sw.Write("|")
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Single
        Dim sr As New StreamReader(".\Singles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '        2.882883 <> 2.882883
  '        0.3333333 <> 0.3333333
  '        3.141593 <> 3.141593
  

  En este caso, los valores se pueden redondear correctamente mediante la cadena de formato numérico estándar "G9" para conservar la precisión completa de los valores, como se muestra en el ejemplo Single siguiente.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\Singles.dat");
        Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++) 
           sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
        
        sw.Close();
        
        Single[] restoredValues = new Single[values.Length];
        StreamReader sr = new StreamReader(@".\Singles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
           restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
  
        for (int ctr = 0; ctr < values.Length; ctr++)
           Console.WriteLine("{0} {2} {1}", values[ctr], 
                             restoredValues[ctr],
                             values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
     }
  }
  // The example displays the following output:
  //       2.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Singles.dat")
        Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write("{0:G9}{1}", values(ctr), 
                    If(ctr < values.Length - 1, "|", ""))
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Single
        Dim sr As New StreamReader(".\Singles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.882883 = 2.882883
  '       0.3333333 = 0.3333333
  '       3.141593 = 3.141593
  

• Single los valores tienen menos precisión que Double los valores. Un valor que se convierte en un aparentemente equivalente a menudo no es igual al Single valor debido a Double Double diferencias en la precisión. En el ejemplo siguiente, el resultado de operaciones de división idénticas se asigna a un Double valor y a un Single valor. Una vez Single que el valor se convierte en , una comparación de los dos valores muestra que no son Double iguales.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Double value1 = 1/3.0;
        Single sValue2 = 1/3.0f;
        Double value2 = (Double) sValue2;
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                                            value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1/3
        Dim sValue2 As Single = 1/3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

  Para evitar este problema, use el tipo de datos en lugar del tipo de datos o use el método para que ambos valores Double Single tengan la misma Round precisión.

Pruebas de igualdad

Para que se considere igual, dos Single valores deben representar valores idénticos. Sin embargo, debido a las diferencias de precisión entre valores o a una pérdida de precisión de uno o ambos valores, los valores de punto flotante que se espera que sean idénticos suelen ser distintos debido a diferencias en sus dígitos menos significativos. Como resultado, llama al método para determinar si dos valores son iguales o llama al método para determinar la relación entre dos valores, a menudo produce resultados Equals CompareTo Single inesperados. Esto es evidente en el ejemplo siguiente, donde dos valores aparentemente iguales no son iguales, porque el primer valor tiene 7 dígitos de precisión, mientras que el segundo valor tiene Single 9.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

Module Example
   Public Sub Main()
      Dim value1 As Single = .3333333
      Dim value2 As Single = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

Los valores calculados que siguen rutas de acceso de código diferentes y que se manipulan de maneras diferentes a menudo demuestran ser distintos. En el ejemplo siguiente, un valor se al cuadrado y, a continuación, se calcula la raíz cuadrada Single para restaurar el valor original. Un segundo se multiplica por 3,51 y se al cuadrado antes de que la raíz cuadrada del resultado se divida Single entre 3,51 para restaurar el valor original. Aunque los dos valores parecen ser idénticos, una llamada al método indica Equals(Single) que no son iguales. El uso de la cadena de formato estándar "G9" para devolver una cadena de resultado que muestra todos los dígitos significativos de cada valor muestra que el segundo valor es .0000000000001 menor que Single el primero.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Module Example
   Public Sub Main()
      Dim value1 As Single = 10.201438
      value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
      Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
      value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

En los casos en los que es probable que una pérdida de precisión afecte al resultado de una comparación, puede usar las técnicas siguientes en lugar de llamar al Equals método CompareTo o :

• Llame al Math.Round método para asegurarse de que ambos valores tienen la misma precisión. En el ejemplo siguiente se modifica un ejemplo anterior para usar este enfoque de modo que dos valores fraccionarios sean equivalentes.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = .3333333f;
        float value2 = 1.0f/3;
        int precision = 7;
        value1 = (float) Math.Round(value1, precision);
        value2 = (float) Math.Round(value2, precision);
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = .3333333
        Dim value2 As Single = 1/3
        Dim precision As Integer = 7
        value1 = CSng(Math.Round(value1, precision))
        value2 = CSng(Math.Round(value2, precision))
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  El problema de precisión todavía se aplica al redondeo de valores de punto medio. Para obtener más información, vea el método Math.Round(Double, Int32, MidpointRounding).

• Pruebe la igualdad aproximada en lugar de la igualdad. Esta técnica requiere que defina una cantidad absoluta en la que los dos valores puedan diferir pero seguir siendo iguales, o que defina una cantidad relativa por la que el valor más pequeño pueda diferir del valor mayor.

  Advertencia

  Single.Epsilon a veces se usa como medida absoluta de la distancia entre dos Single valores al probar la igualdad. Sin embargo, mide el valor más pequeño posible que se puede agregar o restar a un cuyo Single.Epsilon valor es Single cero. Para la mayoría de los valores Single positivos y negativos, el valor de Single.Epsilon es demasiado pequeño para detectarse. Por lo tanto, a excepción de los valores que son cero, no se recomienda su uso en las pruebas de igualdad.

  En el ejemplo siguiente se usa el último enfoque para definir un IsApproximatelyEqual método que prueba la diferencia relativa entre dos valores. También contrasta el resultado de las llamadas al IsApproximatelyEqual método y al método Equals(Single) .

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float one1 = .1f * 10;
        float one2 = 0f;
        for (int ctr = 1; ctr <= 10; ctr++)
           one2 += .1f;
  
        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                          one1, one2, 
                          IsApproximatelyEqual(one1, one2, .000001f));   
     }
  
     static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
     {
        // If they are equal anyway, just return True.
        if (value1.Equals(value2))
           return true;
  
        // Handle NaN, Infinity.
        if (Double.IsInfinity(value1) | Double.IsNaN(value1))
           return value1.Equals(value2);
        else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
           return value1.Equals(value2);
  
        // Handle zero to avoid division by zero
        double divisor = Math.Max(value1, value2);
        if (divisor.Equals(0)) 
           divisor = Math.Min(value1, value2);
        
        return Math.Abs(value1 - value2)/divisor <= epsilon;           
     } 
  }
  // The example displays the following output:
  //       1 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  Module Example
     Public Sub Main()
        Dim one1 As Single = .1 * 10
        Dim one2 As Single = 0
        For ctr As Integer = 1 To 10
           one2 += CSng(.1)
        Next
        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                          one1, one2, 
                          IsApproximatelyEqual(one1, one2, .000001))   
     End Sub
  
     Function IsApproximatelyEqual(value1 As Single, value2 As Single, 
                                   epsilon As Single) As Boolean
        ' If they are equal anyway, just return True.
        If value1.Equals(value2) Then Return True
        
        ' Handle NaN, Infinity.
        If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
           Return value1.Equals(value2)
        Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
           Return value1.Equals(value2)
        End If
        
        ' Handle zero to avoid division by zero
        Dim divisor As Single = Math.Max(value1, value2)
        If divisor.Equals(0) Then
           divisor = Math.Min(value1, value2)
        End If 
        
        Return Math.Abs(value1 - value2)/divisor <= epsilon           
     End Function
  End Module
  ' The example displays the following output:
  '       1 = 1.00000012: False
  '       1 is approximately equal to 1.00000012: True
  

Excepciones y valores de punto flotante

Las operaciones con valores de punto flotante no inician excepciones, a diferencia de las operaciones con tipos enteros, que inician excepciones en casos de operaciones no válidos, como división por cero o desbordamiento. En su lugar, en estas situaciones, el resultado de una operación de punto flotante es cero, infinito positivo, infinito negativo o no un número (NaN):

• Si el resultado de una operación de punto flotante es demasiado pequeño para el formato de destino, el resultado es cero. Esto puede ocurrir cuando se multiplican dos números de punto flotante muy pequeños, como se muestra en el ejemplo siguiente.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = 1.163287e-36f;
        float value2 = 9.164234e-25f;
        float result = value1 * value2;
        Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
     }
  }
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = 1.163287e-36
        Dim value2 As Single = 9.164234e-25
        Dim result As Single = value1 * value2
        Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
     End Sub
  End Module
  ' The example displays the following output:
  '       1.163287E-36 * 9.164234E-25 = 0
  '       0 = 0: True
  

• Si la magnitud del resultado de una operación de punto flotante supera el intervalo del formato de destino, el resultado de la operación es o , según corresponda para el signo PositiveInfinity NegativeInfinity del resultado. El resultado de una operación que se desborda es y el resultado de una operación que desborda es , como se muestra Single.MaxValue PositiveInfinity en el ejemplo Single.MinValue NegativeInfinity siguiente.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = 3.065e35f;
        float value2 = 6.9375e32f;
        float result = value1 * value2;
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}\n", 
                          Single.IsNegativeInfinity(result));
  
        value1 = -value1;
        result = value1 * value2;
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result));
     }
  }                                                                 
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = 3.065e35
        Dim value2 As Single = 6.9375e32
        Dim result As Single = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result))
        Console.WriteLine()                  
        value1 = -value1
        result = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result))
     End Sub
  End Module
  ' The example displays the following output:
  '       PositiveInfinity: True
  '       NegativeInfinity: False
  '       
  '       PositiveInfinity: False
  '       NegativeInfinity: True
  

  PositiveInfinity también es resultado de una división por cero con un dividendo positivo y de una NegativeInfinity división por cero con un dividendo negativo.

• Si una operación de punto flotante no es válida, el resultado de la operación es NaN . Por ejemplo, NaN los resultados de las siguientes operaciones:

  • División por cero con un dividendo de cero. Tenga en cuenta que otros casos de división por cero tienen como resultado PositiveInfinity o NegativeInfinity .

  • Cualquier operación de punto flotante con entrada no válida. Por ejemplo, al intentar encontrar la raíz cuadrada de un valor negativo se devuelve NaN .

  • Cualquier operación con un argumento cuyo valor es Single.NaN .

Conversiones de tipos y la estructura Single

La estructura no define ningún operador de conversión explícito o implícito; en su lugar, el compilador Single implementa las conversiones.

En la tabla siguiente se enumeran las posibles conversiones de un valor de los otros tipos numéricos primitivos a un valor; también indica si la conversión se está ampliando o estrechando y si el resultado puede tener menos precisión que el Single Single valor original.

Conversión de	Ampliación y reducción	Posible pérdida de precisión
Byte	Widening	No
Decimal	Widening Tenga en cuenta que C# requiere un operador de conversión.	Sí. Decimal admite 29 dígitos decimales de precisión; Single admite 9.
Double	Restringir; Los valores fuera del intervalo se convierten en Double.NegativeInfinity o Double.PositiveInfinity .	Sí. Double admite 17 dígitos decimales de precisión; Single admite 9.
Int16	Widening	No
Int32	Widening	Sí. Int32 admite 10 dígitos decimales de precisión; Single admite 9.
Int64	Widening	Sí. Int64 admite 19 dígitos decimales de precisión; Single admite 9.
SByte	Widening	No
UInt16	Widening	No
UInt32	Widening	Sí. UInt32 admite 10 dígitos decimales de precisión; Single admite 9.
UInt64	Widening	Sí. Int64 admite 20 dígitos decimales de precisión; Single admite 9.

En el ejemplo siguiente se convierte el valor mínimo o máximo de otros tipos numéricos primitivos en un Single valor .

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      float sngValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal) ||
             value.GetType() == typeof(Double))
            sngValue = (float) value;
         else
            sngValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim sngValue As Single
      For Each value In values
         If value.GetType() = GetType(Double) Then
            sngValue = CSng(value)
         Else
            sngValue = value
         End If
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Además, los Double valores , y se Double.NaN Double.PositiveInfinity Double.NegativeInfinity convierten en , y , Single.NaN Single.PositiveInfinity Single.NegativeInfinity respectivamente.

Tenga en cuenta que la conversión del valor de algunos tipos numéricos en un Single valor puede implicar una pérdida de precisión. Como se muestra en el ejemplo, es posible una pérdida de precisión al convertir valores Decimal , , , , y en valores Double Int32 Int64 UInt32 UInt64 Single .

La conversión de un Single valor en es una conversión de Double ampliación. La conversión puede provocar una pérdida de precisión si el Double tipo no tiene una representación precisa para el Single valor.

La conversión de un valor en un valor de cualquier tipo de datos numérico primitivo distinto de es una conversión de limitación y requiere un operador de conversión (en C#) o un método de conversión Single Double (en Visual Basic). Los valores que están fuera del intervalo del tipo de datos de destino, definidos por las propiedades y del tipo de destino, se comportan como se muestra MinValue MaxValue en la tabla siguiente.

Tipo de destino	Resultado
Cualquier tipo entero	Excepción OverflowException si la conversión se produce en un contexto activado. Si la conversión se produce en un contexto no desactivado (el valor predeterminado en C#), la operación de conversión se realiza correctamente, pero el valor se desborda.
Decimal	Una OverflowException excepción,

Además, , y inician un para las conversiones a enteros en un contexto activado, pero estos valores se desbordan cuando se convierten en enteros en un Single.NaN Single.PositiveInfinity contexto no Single.NegativeInfinity OverflowException comprobado. En el caso de las Decimal conversiones a , siempre inician una OverflowException excepción . Para las conversiones a Double , se convierten en Double.NaN , y , Double.PositiveInfinity Double.NegativeInfinity respectivamente.

Tenga en cuenta que una pérdida de precisión puede deberse a la conversión de Single un valor a otro tipo numérico. En el caso de convertir valores no enteros, como se muestra en la salida del ejemplo, el componente fraccionrio se pierde cuando el valor se redondea (como en Visual Basic) o se trunca (como en Single Single C#). Para las conversiones a Decimal valores, es Single posible que el valor no tenga una representación precisa en el tipo de datos de destino.

En el ejemplo siguiente se convierten varios Single valores en otros tipos numéricos. Las conversiones se producen en un contexto activado en Visual Basic (valor predeterminado) y en C# (debido a la palabra clave checked). La salida del ejemplo muestra el resultado de las conversiones en un contexto no comprobado activado. Puede realizar conversiones en un contexto no desactivado en Visual Basic compilando con el modificador del compilador y en C# comentando /removeintchecks+ la checked instrucción .

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Long = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try

         Dim dblValue As Double = value
         Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

Para obtener más información sobre la conversión de tipos numéricos, vea Conversión de tipos en las tablas .NET Framework y Conversión de tipos.

Funcionalidad de punto flotante

La Single estructura y los tipos relacionados proporcionan métodos para realizar las siguientes categorías de operaciones:

• Comparación de valores. Puede llamar al método para determinar si dos valores son iguales o el método Equals para determinar la relación entre dos Single CompareTo valores.

  La Single estructura también admite un conjunto completo de operadores de comparación. Por ejemplo, puede probar la igualdad o la desigualdad, o determinar si un valor es mayor o igual que otro valor. Si uno de los operandos es Double , el valor se convierte en un antes de realizar la Single Double comparación. Si uno de los operandos es un tipo entero, se convierte en un antes Single de realizar la comparación. Aunque se trata de conversiones de ampliación, pueden implicar una pérdida de precisión.

  Advertencia

  Debido a las diferencias de precisión, dos valores que espera que sean iguales pueden resultar desiguales, lo que afecta al Single resultado de la comparación. Consulte la sección Pruebas de igualdad para obtener más información sobre cómo comparar dos Single valores.

  También puede llamar a los métodos , , y para IsNaN probar estos valores IsInfinity IsPositiveInfinity IsNegativeInfinity especiales.

• Operaciones matemáticas. Las operaciones aritméticas comunes, como la suma, resta, multiplicación y división, se implementan mediante compiladores de lenguaje e instrucciones de lenguaje intermedio común (CIL) en lugar de por Single métodos. Si el otro operando de una operación matemática es , se convierte en un antes de realizar la operación y el resultado de la operación Double Single también es un Double Double valor. Si el otro operando es un tipo entero, se convierte en un antes de realizar la operación y el resultado de la operación Single también es un Single valor.

  Puede realizar otras operaciones matemáticas llamando a static métodos ( Shared en Visual Basic) de la System.Math clase . Estos incluyen métodos adicionales que se usan normalmente para operaciones aritméticas (como , y ), geometry (como y ) y Math.Abs Math.Sign Math.Sqrt Math.Cos Math.Sin calculus (como Math.Log ). En todos los Single casos, el valor se convierte en Double .

  También puede manipular los bits individuales de un Single valor. El BitConverter.GetBytes(Single) método devuelve su patrón de bits en una matriz de bytes. Al pasar esa matriz de bytes al método , también puede conservar el patrón de bits del valor en un entero BitConverter.ToInt32 Single de 32 bits.

• Redondear. El redondeo se suele usar como técnica para reducir el impacto de las diferencias entre los valores causados por problemas de precisión y representación de punto flotante. Puede redondear Single un valor llamando al método Math.Round . Sin embargo, tenga en cuenta que el valor se convierte en un antes de llamar al método y que la conversión puede implicar Single Double una pérdida de precisión.

• Dar formato a. Puede convertir un valor en Single su representación de cadena llamando al método o usando la característica de ToString formato compuesto. Para obtener información sobre cómo las cadenas de formato controlan la representación de cadena de valores de punto flotante, vea los temas Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.

• Analizar cadenas. Puede convertir la representación de cadena de un valor de punto flotante en un Single valor llamando al método o Parse TryParse . Si se produce un error en la operación de análisis, Parse el método produce una excepción, mientras que el método devuelve TryParse false .

• Conversión de tipos. La estructura proporciona una implementación de interfaz explícita para la interfaz , que admite la conversión entre dos tipos de Single IConvertible datos .NET Framework estándar. Los compiladores de lenguaje también admiten la conversión implícita de valores para todos los demás tipos numéricos estándar, excepto para la conversión de Double a Single valores. La conversión de un valor de cualquier tipo numérico estándar distinto de a es una conversión de ampliación y no requiere el uso de un operador de conversión o Double Single un método de conversión.

  Sin embargo, la conversión de valores enteros de 32 y 64 bits puede implicar una pérdida de precisión. En la tabla siguiente se enumeran las diferencias en la precisión de los tipos de 32 bits, 64 Double bits y :

  Tipo	Precisión máxima (en dígitos decimales)	Precisión interna (en dígitos decimales)
  Double	15	17
  Int32 y UInt32	10	10
  Int64 y UInt64	19	19
  Single	7	9

  El problema de precisión afecta con mayor frecuencia a Single los valores que se convierten en Double valores. En el ejemplo siguiente, dos valores generados por operaciones de división idénticas no son iguales, porque uno de los valores es un valor de punto flotante de precisión sencilla que se convierte en Double .

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Double value1 = 1/3.0;
        Single sValue2 = 1/3.0f;
        Double value2 = (Double) sValue2;
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                            value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1/3
        Dim sValue2 As Single = 1/3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

Campos

Epsilon	Representa el menor valor Single positivo mayor que cero. Este campo es constante.
MaxValue	Representa el mayor valor posible de Single. Este campo es constante.
MinValue	Representa el menor valor posible de Single. Este campo es constante.
NaN	Representa un valor no numérico (NaN). Este campo es constante.
NegativeInfinity	Representa infinito negativo. Este campo es constante.
PositiveInfinity	Representa infinito positivo. Este campo es constante.

Métodos

CompareTo(Object)	Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es mayor, igual o menor que el valor del objeto especificado.
CompareTo(Single)	Compara esta instancia con un número de punto flotante de precisión sencilla especificado y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del número de punto flotante de precisión sencilla especificado.
Equals(Object)	Devuelve un valor que indica si esta instancia equivale a un objeto especificado.
Equals(Single)	Devuelve un valor que indica si esta instancia y un objeto Single especificado representan el mismo valor.
GetHashCode()	Devuelve el código hash de esta instancia.
GetTypeCode()	Devuelve el TypeCode para el tipo de valor Single.
IsFinite(Single)	Determina si el valor especificado es limitado (cero, no normal o normal).
IsInfinity(Single)	Devuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo.
IsNaN(Single)	Devuelve un valor que indica si el valor especificado no es un número (NaN).
IsNegative(Single)	Determina si el valor especificado es negativo.
IsNegativeInfinity(Single)	Devuelve un valor que indica si el número especificado se evalúa como infinito negativo.
IsNormal(Single)	Determina si el valor especificado es normal.
IsPositiveInfinity(Single)	Devuelve un valor que indica si el número especificado se evalúa como infinito positivo.
IsSubnormal(Single)	Determina si el valor especificado no es normal.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte el intervalo de caracteres que contiene la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión sencilla equivalente.
Parse(String)	Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión sencilla equivalente.
Parse(String, IFormatProvider)	Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión sencilla equivalente.
Parse(String, NumberStyles)	Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión sencilla equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión sencilla equivalente.
ToString()	Convierte el valor numérico de esta instancia en la representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.
ToString(String)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.
ToString(String, IFormatProvider)	Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato y la información de formato específica de la referencia cultural que se especificaran.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia del número flotante actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Convierte la representación de intervalo de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión sencilla equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.
TryParse(ReadOnlySpan<Char>, Single)	Convierte la representación de cadena de un número de un intervalo de caracteres a su número de punto flotante de precisión sencilla equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.
TryParse(String, NumberStyles, IFormatProvider, Single)	Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión sencilla equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.
TryParse(String, Single)	Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión sencilla equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.

Operadores

Equality(Single, Single)	Devuelve un valor que indica si dos valores Single especificados son iguales.
GreaterThan(Single, Single)	Devuelve un valor que indica si un valor Single especificado es mayor que otro valor Single especificado.
GreaterThanOrEqual(Single, Single)	Devuelve un valor que indica si un valor Single especificado es mayor o igual que otro valor Single especificado.
Inequality(Single, Single)	Devuelve un valor que indica si dos valores Single especificados no son iguales.
LessThan(Single, Single)	Devuelve un valor que indica si un valor Single especificado es menor que otro valor Single especificado.
LessThanOrEqual(Single, Single)	Devuelve un valor que indica si un valor Single especificado es menor o igual que otro valor Single especificado.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
IConvertible.GetTypeCode()	Devuelve el TypeCode para esta instancia.
IConvertible.ToBoolean(IFormatProvider)	Para obtener una descripción de este miembro, vea ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Para obtener una descripción de este miembro, vea ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Para obtener una descripción de este miembro, vea ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Para obtener una descripción de este miembro, vea ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Para obtener una descripción de este miembro, vea ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt64(IFormatProvider).

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de la instancia devuelven realmente una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo debe protegerse mediante un bloqueo para garantizar la seguridad de los subprocesos.

Consulte también

• Decimal
• Double