Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura Single

 

Publicado: octubre de 2016

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

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Single : IComparable, IFormattable, IConvertible, 
	IComparable<float>, IEquatable<float>

NombreDescripción
System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodEquals(Single)

Devuelve un valor que indica si esta instancia y un objeto Single especificado representan el mismo valor.

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodGetTypeCode()

Devuelve el TypeCode para el tipo de valor Single.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Single)

Devuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo.

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Single)

Devuelve un valor que indica si el valor especificado no es un número (NaN).

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Single)

Devuelve un valor que indica si el número especificado se evalúa como infinito negativo.

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Single)

Devuelve un valor que indica si el número especificado se evalúa como infinito positivo.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodToString()

Convierte el valor numérico de esta instancia en la representación de cadena equivalente.(Invalida ValueType.ToString()).

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodToString(String)

Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

Representa el menor valor Single positivo mayor que cero. Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Representa el mayor valor posible de Single. Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Representa el menor valor posible de Single. Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticNaN

Representa un valor no numérico (NaN). Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

Representa infinito negativo. Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

Representa infinito positivo. Este campo es constante.

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticEquality(Single, Single)

Devuelve un valor que indica si dos valores Single especificados son iguales.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Single, Single)

Devuelve un valor que indica si un valor Single especificado es mayor que otro valor Single especificado.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Single, Single)

Devuelve un valor que indica si un valor Single especificado es mayor o igual que otro valor Single especificado.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Single, Single)

Devuelve un valor que indica si dos valores Single especificados no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Single, Single)

Devuelve un valor que indica si un valor Single especificado es menor que otro valor Single especificado.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Single, Single)

Devuelve un valor que indica si un valor Single especificado es menor o igual que otro valor Single especificado.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt64.

El Single tipo de valor representa un número de 32 bits de precisión sencilla con valores comprendidos entre negativo 3. 402823e38 al positivo 3. 402823e38, así como el cero positivo o negativo, PositiveInfinity, NegativeInfinity, y no un número (NaN). Está pensado para representar los valores que son extremadamente grandes (por ejemplo, las distancias entre los planetas o galaxias) o muy pequeños (por ejemplo, el peso molecular de una sustancia en kilogramos) y que a menudo son precisos (como la distancia desde la tierra a otro sistema solar). El Single tipo cumple la IEC 60559: 1989 (IEEE 754) estándar para aritmética binaria de punto flotante.

Este tema consta de las siguientes secciones:

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 acerca de cómo los códigos de especificación de formato controlan la representación de cadena de tipos de valor, vea Aplicar formato a tipos en .NET Framework, Cadenas con formato numérico estándar, y Cadenas con formato numérico personalizado.

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

Parte

Bits

Exponentes o mantisa

0-22

Exponente

23-30

Inicio de sesión (0 = positivo, 1 = negativo)

31

Tal como fracciones decimales son no se puede representar con precisión los valores fraccionarios (por ejemplo, 1/3 o Math.PI), fracciones binarias son no puede representar algunos valores fraccionarios. Por ejemplo, 2/10, que se representa con precisión,.2 como una fracción decimal, se representa mediante.0011111001001100 como una fracción binaria con el patrón "1100" de repetición infinito. En este caso, el valor de punto flotante proporciona una representación imprecisa del número que representa. Realizar 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á esta adición genera el resultado de la menos preciso, dado que implica más de ocho operaciones de multiplicación. Tenga en cuenta que esta disparidad aparente sólo si se muestran las dos Single valores mediante la "R" cadena de formato numérico estándar, que, si es necesario, muestra todos los 9 dígitos de precisión admitida por el 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

Dado que algunos números no se puede representar exactamente como valores binarios fracciones, números de punto flotante pueden sólo números aproximados de real.

Todos los números de punto flotante tienen un número limitado de dígitos significativos, que también determina la precisión con 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 internamente se mantiene un máximo de 9 dígitos. Esto significa que algunas operaciones de punto flotante pueden carecer de la 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, agrega el producto de Single.Epsilon y mil billones a él. Sin embargo, el producto es demasiado pequeño para modificar el valor de punto flotante original. Sus dígitos menos significativos es milésimas, mientras que el dígito más significativo en el producto es 1-312.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123456789e4f;
      Single additional = Single.Epsilon * 1e12f;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    1.234568E+12 + 1.401298E-33 = 1.234568E+12

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

  • Dos números de punto flotante que parecen iguales para una precisión determinada podrían no son iguales porque sus dígitos menos significativos son diferentes. En el ejemplo siguiente, se suman una serie de números y el total se compara con el total esperado. Aunque los dos valores parecen ser el mismo, una llamada a la Equals método indica que no están.

    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:R}) does not equal the total ({1:R}).",
                               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).   
    

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

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

    Cuando la precisión en las operaciones numéricas con valores fraccionarios es importante, utilice la Decimal Escriba en lugar de la Single tipo. Cuando la precisión en las operaciones numéricas con valores enteros más allá del intervalo de la Int64 o UInt64 tipos es importante, utilice la BigInteger tipo.

  • Un valor podría no ida y vuelta si está implicado un número de punto flotante. Un valor se dice que acudir si una operación convierte a un número de punto flotante original a otro formulario, una operación inversa transforma el formato convertido a un número de punto flotante y el último número de punto flotante es igual al número de punto flotante original. Puede producir un error en la ida y vuelta porque uno o más dígitos menos significativos se pierden o cambian durante 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 parecen ser idénticas, 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
    

    En este caso, los valores pueden ser la ida y vuelta correctamente mediante el uso de la "R" cadena de formato numérico estándar para conservar la precisión completa de Single valores, como se muestra en el ejemplo 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:R}{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
    
  • Single valores tienen menor precisión que Double valores. Un Single valor que se convierte en un equivalente aparentemente Double a menudo no es igual a la Double valor debido a diferencias en la precisión. En el ejemplo siguiente, se asigna el resultado de operaciones de división idéntico a un Double valor y un Single valor. Después de la Single valor se convierte en un Double, se muestra una comparación de los dos valores que son 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
    

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

Para considerarse iguales, dos Single valores deben representar valores idénticos. Sin embargo, debido a diferencias en precisión entre valores, o debido a una pérdida de precisión por uno o ambos valores, valores de punto flotante que se esperan que sean idénticos a menudo resultan para ser distintos debido a las diferencias en sus dígitos menos significativos. Como resultado, las llamadas a la Equals método para determinar si dos valores son iguales, o llamadas a la CompareTo método para determinar la relación entre dos Single valores, a menudo producen resultados inesperados. Esto es evidente en el ejemplo siguiente, donde dos igual aparentemente Single valores resultan para ser desigual, porque el primer valor tiene 7 dígitos de precisión, mientras que el segundo valor tiene 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

Los valores calculados que siguen diferentes rutas de código y que se manipulan de maneras diferentes a menudo resultar desiguales. En el ejemplo siguiente, un Single se eleva al cuadrado el valor y, a continuación, se calcula la raíz cuadrada para restaurar el valor original. Un segundo Single se multiplica por 3.51 y cuadrado antes de la raíz cuadrada del resultado se divide por 3.51 para restaurar el valor original. Aunque los dos valores parecen ser idénticas, una llamada a la Equals(Single) método indica que no son iguales. Usar la cadena de formato estándar "R" para devolver una cadena de resultado que muestra todos los dígitos significativos de cada Single valor muestra que el segundo valor es.0000000000001 menor que 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:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

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

  • Llame a la 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 utilizar este enfoque para que dos valores fraccionarios son 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
    

    Tenga en cuenta que el problema de precisión sigue siendo aplicable al redondeo de valores de punto medio. Para obtener más información, vea el método Math.Round(Double, Int32, MidpointRounding).

  • Comprobar la igualdad aproximada en lugar de igualdad. Esta técnica requiere que se defina en absoluto cantidad por la que los dos valores pueden diferir pero todavía sea igual o definir una cantidad relativa por el que el valor más pequeño puede diferir del valor mayor.

    System_CAPS_warningAdvertencia

    Single.Epsilon a veces se utiliza como una medida de la distancia entre dos absoluta Single al probar la igualdad de los valores. Sin embargo, Single.Epsilon mide el menor valor posible que se puede sumar o restar, un Single cuyo valor es cero. Para la mayoría de valores positivos y negativos Single valores, el valor de Single.Epsilon es demasiado pequeño para que lo detecte. Por lo tanto, salvo los valores que son iguales a cero, no se recomienda su uso en las pruebas de igualdad.

    En el ejemplo siguiente se utiliza el último enfoque para definir una IsApproximatelyEqual método que comprueba la diferencia relativa entre dos valores. También se compara el resultado de las llamadas a la IsApproximatelyEqual (método) y Equals(Single) (método).

    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
    

Operaciones con valores de punto flotante no producen excepciones, a diferencia de las operaciones con tipos integrales, que producen excepciones en casos de operaciones ilegales, como la 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 es 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
    
  • 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 PositiveInfinity o NegativeInfinity, según corresponda para el signo del resultado. El resultado de una operación que se desborda Single.MaxValue es PositiveInfinity, y el resultado de una operación que se desborda Single.MinValue es NegativeInfinity, como se muestra en el ejemplo 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
    

    PositiveInfinity También se produce de una división por cero con dividendo positivo, y NegativeInfinity como resultado de una división por cero con dividendo negativo.

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

    • División por cero con dividendos de cero. Tenga en cuenta que otros casos de división por cero generan una PositiveInfinity o NegativeInfinity.

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

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

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

En la tabla siguiente se enumera las conversiones posibles de un valor de los otros tipos numéricos primitivos a una Single valor, también indica si la conversión es de ampliación o de restricción y si resultante Single tenga menor precisión que el valor original.

Conversión de

Ampliación de restricció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 es compatible con 29 dígitos decimales de precisión; Single admite 9.

Double

De restricción; 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 para 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)

Además, el Double valores Double.NaN, Double.PositiveInfinity, y Double.NegativeInfinity convertir a Single.NaN, Single.PositiveInfinity, y Single.NegativeInfinity, respectivamente.

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

La conversión de un Single valor a una Double es una conversión de ampliación. La conversión puede producir 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 Single valor distinto de un valor de cualquier tipo numérico primitivo una Double es una conversión de restricción y requiere un operador de conversión (en C#) o un método de conversión (en Visual Basic). Valores que están fuera del intervalo del tipo de datos de destino, que están definidos por el tipo de destino MinValue y MaxValue se comportan de propiedades, como se muestra en la tabla siguiente.

Tipo de destino

Resultado

Cualquier tipo entero

Un OverflowException excepción si la conversión se realiza en un contexto comprobado.

Si la conversión se produce en un contexto no comprobado (el valor predeterminado en C#), la operación de conversión se realiza correctamente pero se desborda el valor.

Decimal

Un OverflowException excepción,

Además, Single.NaN, Single.PositiveInfinity, y Single.NegativeInfinity producir una OverflowException para las conversiones de enteros en un contexto comprobado, pero estos desbordamiento valores cuando se convierten en enteros en un contexto no comprobado. Para las conversiones a Decimal, siempre producen un OverflowException. Para las conversiones a Double, se convierten a Double.NaN, Double.PositiveInfinity, y Double.NegativeInfinity, respectivamente.

Tenga en cuenta que puede producir una pérdida de precisión en la conversión de un Single valor a otro tipo numérico. En el caso de conversión no integrales Double valores, como se muestra en el resultado del ejemplo, el componente fraccionario se pierde cuando el Single valor se redondea (como en Visual Basic) o se truncan (como en C#). Para las conversiones a Decimal y Single valores, la Double valor no puede tener una representación precisa en el tipo de datos de destino.

En el ejemplo siguiente se convierte un número de Single valores de otros tipos numéricos. Las conversiones se producen en un contexto comprobado en Visual Basic (predeterminado) y en C# (porque el comprueban palabra clave). El resultado del ejemplo muestra el resultado para las conversiones en ambos un comprobado un contexto no comprobado. Puede realizar conversiones en un contexto no comprobado en Visual Basic al compilar con la /removeintchecks+ conmutador de compilador y en C# como comentario el 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)

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

El Single estructura y los tipos relacionados proporcionan métodos para llevar a cabo las siguientes categorías de operaciones:

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

    El Single estructura también admite un conjunto completo de operadores de comparación. Por ejemplo, puede comprobar la igualdad o desigualdad o determinar si un valor es mayor o igual que otro valor. Si uno de los operandos es una Double, la Single valor se convierte en un Double antes de realizar la comparación. Si uno de los operandos es de un tipo integral, se convierte en un Single antes de realizar la comparación. Aunque estos son conversiones de ampliación, puede conllevar una pérdida de precisión.

    System_CAPS_warningAdvertencia

    Debido a las diferencias en precisión, dos Single valores que se esperan que sea igual que resultó para ser desigual, que afecta al resultado de la comparación. Consulte la comprobación de igualdad sección para obtener más información acerca de cómo comparar dos Single valores.

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

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

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

    También puede manipular los bits individuales en un Single valor. El BitConverter.GetBytes(Single) método devuelve su patrón de bits en una matriz de bytes. Pasando una matriz de bytes a la BitConverter.ToInt32 (método), también puede conservar la Single valor de patrón de bits en un entero de 32 bits.

  • Redondeo. Redondeo a menudo se utiliza como una técnica para reducir el impacto de las diferencias entre los valores que se deben a problemas de representación de punto flotante y precisión. Se puede redondear un Single valor llamando el Math.Round método. Sin embargo, tenga en cuenta que el Single valor se convierte en un Double antes de llama al método y la conversión puede conllevar una pérdida de precisión.

  • Formato. Puede convertir un Single valor en su representación de cadena mediante una llamada a la ToString método o mediante el formatos compuestos característica. Para obtener información sobre la forma en que las cadenas de formato controlan la representación de cadena de valores de punto flotante, consulte el Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado temas.

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

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

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

    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 con más frecuencia afecta Single valores que se convierten en Double valores. En el ejemplo siguiente, dos valores generados por operaciones de división idénticos no son iguales, porque uno de los valores es un valor de punto flotante de precisión sencilla que se convierte en un 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
    

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que aparecen modificar el estado de instancia realmente devuelven una nueva instancia inicializada con el nuevo valor. Como con cualquier otro tipo, leer y escribir en una variable compartida que contiene una instancia de este tipo deben estar protegidos por un bloqueo para garantizar la seguridad para subprocesos.

Volver al principio
Mostrar: