Half Estructura

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Source:
Half.cs
Source:
Half.cs
Source:
Half.cs

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

public value class Half : IComparable, IComparable<Half>, IEquatable<Half>, IFormattable
public value class Half : IComparable, IComparable<Half>, IEquatable<Half>, ISpanFormattable
public value class Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, System::Numerics::IAdditionOperators<Half, Half, Half>, System::Numerics::IAdditiveIdentity<Half, Half>, System::Numerics::IBinaryFloatingPointIeee754<Half>, System::Numerics::IBinaryNumber<Half>, System::Numerics::IBitwiseOperators<Half, Half, Half>, System::Numerics::IComparisonOperators<Half, Half, bool>, System::Numerics::IDecrementOperators<Half>, System::Numerics::IDivisionOperators<Half, Half, Half>, System::Numerics::IEqualityOperators<Half, Half, bool>, System::Numerics::IExponentialFunctions<Half>, System::Numerics::IFloatingPoint<Half>, System::Numerics::IFloatingPointConstants<Half>, System::Numerics::IFloatingPointIeee754<Half>, System::Numerics::IHyperbolicFunctions<Half>, System::Numerics::IIncrementOperators<Half>, System::Numerics::ILogarithmicFunctions<Half>, System::Numerics::IMinMaxValue<Half>, System::Numerics::IModulusOperators<Half, Half, Half>, System::Numerics::IMultiplicativeIdentity<Half, Half>, System::Numerics::IMultiplyOperators<Half, Half, Half>, System::Numerics::INumber<Half>, System::Numerics::INumberBase<Half>, System::Numerics::IPowerFunctions<Half>, System::Numerics::IRootFunctions<Half>, System::Numerics::ISignedNumber<Half>, System::Numerics::ISubtractionOperators<Half, Half, Half>, System::Numerics::ITrigonometricFunctions<Half>, System::Numerics::IUnaryNegationOperators<Half, Half>, System::Numerics::IUnaryPlusOperators<Half, Half>
public value class Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, IUtf8SpanParsable<Half>, System::Numerics::IAdditionOperators<Half, Half, Half>, System::Numerics::IAdditiveIdentity<Half, Half>, System::Numerics::IBinaryFloatingPointIeee754<Half>, System::Numerics::IBinaryNumber<Half>, System::Numerics::IBitwiseOperators<Half, Half, Half>, System::Numerics::IComparisonOperators<Half, Half, bool>, System::Numerics::IDecrementOperators<Half>, System::Numerics::IDivisionOperators<Half, Half, Half>, System::Numerics::IEqualityOperators<Half, Half, bool>, System::Numerics::IExponentialFunctions<Half>, System::Numerics::IFloatingPoint<Half>, System::Numerics::IFloatingPointConstants<Half>, System::Numerics::IFloatingPointIeee754<Half>, System::Numerics::IHyperbolicFunctions<Half>, System::Numerics::IIncrementOperators<Half>, System::Numerics::ILogarithmicFunctions<Half>, System::Numerics::IMinMaxValue<Half>, System::Numerics::IModulusOperators<Half, Half, Half>, System::Numerics::IMultiplicativeIdentity<Half, Half>, System::Numerics::IMultiplyOperators<Half, Half, Half>, System::Numerics::INumber<Half>, System::Numerics::INumberBase<Half>, System::Numerics::IPowerFunctions<Half>, System::Numerics::IRootFunctions<Half>, System::Numerics::ISignedNumber<Half>, System::Numerics::ISubtractionOperators<Half, Half, Half>, System::Numerics::ITrigonometricFunctions<Half>, System::Numerics::IUnaryNegationOperators<Half, Half>, System::Numerics::IUnaryPlusOperators<Half, Half>
public readonly struct Half : IComparable, IComparable<Half>, IEquatable<Half>, IFormattable
public readonly struct Half : IComparable, IComparable<Half>, IEquatable<Half>, ISpanFormattable
public readonly struct Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, System.Numerics.IAdditionOperators<Half,Half,Half>, System.Numerics.IAdditiveIdentity<Half,Half>, System.Numerics.IBinaryFloatingPointIeee754<Half>, System.Numerics.IBinaryNumber<Half>, System.Numerics.IBitwiseOperators<Half,Half,Half>, System.Numerics.IComparisonOperators<Half,Half,bool>, System.Numerics.IDecrementOperators<Half>, System.Numerics.IDivisionOperators<Half,Half,Half>, System.Numerics.IEqualityOperators<Half,Half,bool>, System.Numerics.IExponentialFunctions<Half>, System.Numerics.IFloatingPoint<Half>, System.Numerics.IFloatingPointConstants<Half>, System.Numerics.IFloatingPointIeee754<Half>, System.Numerics.IHyperbolicFunctions<Half>, System.Numerics.IIncrementOperators<Half>, System.Numerics.ILogarithmicFunctions<Half>, System.Numerics.IMinMaxValue<Half>, System.Numerics.IModulusOperators<Half,Half,Half>, System.Numerics.IMultiplicativeIdentity<Half,Half>, System.Numerics.IMultiplyOperators<Half,Half,Half>, System.Numerics.INumber<Half>, System.Numerics.INumberBase<Half>, System.Numerics.IPowerFunctions<Half>, System.Numerics.IRootFunctions<Half>, System.Numerics.ISignedNumber<Half>, System.Numerics.ISubtractionOperators<Half,Half,Half>, System.Numerics.ITrigonometricFunctions<Half>, System.Numerics.IUnaryNegationOperators<Half,Half>, System.Numerics.IUnaryPlusOperators<Half,Half>
public readonly struct Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, IUtf8SpanParsable<Half>, System.Numerics.IAdditionOperators<Half,Half,Half>, System.Numerics.IAdditiveIdentity<Half,Half>, System.Numerics.IBinaryFloatingPointIeee754<Half>, System.Numerics.IBinaryNumber<Half>, System.Numerics.IBitwiseOperators<Half,Half,Half>, System.Numerics.IComparisonOperators<Half,Half,bool>, System.Numerics.IDecrementOperators<Half>, System.Numerics.IDivisionOperators<Half,Half,Half>, System.Numerics.IEqualityOperators<Half,Half,bool>, System.Numerics.IExponentialFunctions<Half>, System.Numerics.IFloatingPoint<Half>, System.Numerics.IFloatingPointConstants<Half>, System.Numerics.IFloatingPointIeee754<Half>, System.Numerics.IHyperbolicFunctions<Half>, System.Numerics.IIncrementOperators<Half>, System.Numerics.ILogarithmicFunctions<Half>, System.Numerics.IMinMaxValue<Half>, System.Numerics.IModulusOperators<Half,Half,Half>, System.Numerics.IMultiplicativeIdentity<Half,Half>, System.Numerics.IMultiplyOperators<Half,Half,Half>, System.Numerics.INumber<Half>, System.Numerics.INumberBase<Half>, System.Numerics.IPowerFunctions<Half>, System.Numerics.IRootFunctions<Half>, System.Numerics.ISignedNumber<Half>, System.Numerics.ISubtractionOperators<Half,Half,Half>, System.Numerics.ITrigonometricFunctions<Half>, System.Numerics.IUnaryNegationOperators<Half,Half>, System.Numerics.IUnaryPlusOperators<Half,Half>
type Half = struct
    interface IFormattable
type Half = struct
    interface ISpanFormattable
    interface IFormattable
type Half = struct
    interface IFormattable
    interface IParsable<Half>
    interface ISpanFormattable
    interface ISpanParsable<Half>
    interface IAdditionOperators<Half, Half, Half>
    interface IAdditiveIdentity<Half, Half>
    interface IBinaryFloatingPointIeee754<Half>
    interface IBinaryNumber<Half>
    interface IBitwiseOperators<Half, Half, Half>
    interface IComparisonOperators<Half, Half, bool>
    interface IEqualityOperators<Half, Half, bool>
    interface IDecrementOperators<Half>
    interface IDivisionOperators<Half, Half, Half>
    interface IIncrementOperators<Half>
    interface IModulusOperators<Half, Half, Half>
    interface IMultiplicativeIdentity<Half, Half>
    interface IMultiplyOperators<Half, Half, Half>
    interface INumber<Half>
    interface INumberBase<Half>
    interface ISubtractionOperators<Half, Half, Half>
    interface IUnaryNegationOperators<Half, Half>
    interface IUnaryPlusOperators<Half, Half>
    interface IExponentialFunctions<Half>
    interface IFloatingPointConstants<Half>
    interface IFloatingPoint<Half>
    interface ISignedNumber<Half>
    interface IFloatingPointIeee754<Half>
    interface IHyperbolicFunctions<Half>
    interface ILogarithmicFunctions<Half>
    interface IPowerFunctions<Half>
    interface IRootFunctions<Half>
    interface ITrigonometricFunctions<Half>
    interface IMinMaxValue<Half>
type Half = struct
    interface IFormattable
    interface IParsable<Half>
    interface ISpanFormattable
    interface ISpanParsable<Half>
    interface IAdditionOperators<Half, Half, Half>
    interface IAdditiveIdentity<Half, Half>
    interface IBinaryFloatingPointIeee754<Half>
    interface IBinaryNumber<Half>
    interface IBitwiseOperators<Half, Half, Half>
    interface IComparisonOperators<Half, Half, bool>
    interface IEqualityOperators<Half, Half, bool>
    interface IDecrementOperators<Half>
    interface IDivisionOperators<Half, Half, Half>
    interface IIncrementOperators<Half>
    interface IModulusOperators<Half, Half, Half>
    interface IMultiplicativeIdentity<Half, Half>
    interface IMultiplyOperators<Half, Half, Half>
    interface INumber<Half>
    interface INumberBase<Half>
    interface ISubtractionOperators<Half, Half, Half>
    interface IUnaryNegationOperators<Half, Half>
    interface IUnaryPlusOperators<Half, Half>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<Half>
    interface IExponentialFunctions<Half>
    interface IFloatingPointConstants<Half>
    interface IFloatingPoint<Half>
    interface ISignedNumber<Half>
    interface IFloatingPointIeee754<Half>
    interface IHyperbolicFunctions<Half>
    interface ILogarithmicFunctions<Half>
    interface IPowerFunctions<Half>
    interface IRootFunctions<Half>
    interface ITrigonometricFunctions<Half>
    interface IMinMaxValue<Half>
type Half = struct
    interface IFormattable
    interface IParsable<Half>
    interface ISpanFormattable
    interface ISpanParsable<Half>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<Half>
    interface IAdditionOperators<Half, Half, Half>
    interface IAdditiveIdentity<Half, Half>
    interface IBinaryFloatingPointIeee754<Half>
    interface IBinaryNumber<Half>
    interface IBitwiseOperators<Half, Half, Half>
    interface IComparisonOperators<Half, Half, bool>
    interface IEqualityOperators<Half, Half, bool>
    interface IDecrementOperators<Half>
    interface IDivisionOperators<Half, Half, Half>
    interface IIncrementOperators<Half>
    interface IModulusOperators<Half, Half, Half>
    interface IMultiplicativeIdentity<Half, Half>
    interface IMultiplyOperators<Half, Half, Half>
    interface INumber<Half>
    interface INumberBase<Half>
    interface ISubtractionOperators<Half, Half, Half>
    interface IUnaryNegationOperators<Half, Half>
    interface IUnaryPlusOperators<Half, Half>
    interface IExponentialFunctions<Half>
    interface IFloatingPointConstants<Half>
    interface IFloatingPoint<Half>
    interface ISignedNumber<Half>
    interface IFloatingPointIeee754<Half>
    interface IHyperbolicFunctions<Half>
    interface ILogarithmicFunctions<Half>
    interface IPowerFunctions<Half>
    interface IRootFunctions<Half>
    interface ITrigonometricFunctions<Half>
    interface IMinMaxValue<Half>
Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), IFormattable
Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), ISpanFormattable
Public Structure Half
Implements IAdditionOperators(Of Half, Half, Half), IAdditiveIdentity(Of Half, Half), IBinaryFloatingPointIeee754(Of Half), IBinaryNumber(Of Half), IBitwiseOperators(Of Half, Half, Half), IComparable(Of Half), IComparisonOperators(Of Half, Half, Boolean), IDecrementOperators(Of Half), IDivisionOperators(Of Half, Half, Half), IEqualityOperators(Of Half, Half, Boolean), IEquatable(Of Half), IExponentialFunctions(Of Half), IFloatingPoint(Of Half), IFloatingPointConstants(Of Half), IFloatingPointIeee754(Of Half), IHyperbolicFunctions(Of Half), IIncrementOperators(Of Half), ILogarithmicFunctions(Of Half), IMinMaxValue(Of Half), IModulusOperators(Of Half, Half, Half), IMultiplicativeIdentity(Of Half, Half), IMultiplyOperators(Of Half, Half, Half), INumber(Of Half), INumberBase(Of Half), IParsable(Of Half), IPowerFunctions(Of Half), IRootFunctions(Of Half), ISignedNumber(Of Half), ISpanParsable(Of Half), ISubtractionOperators(Of Half, Half, Half), ITrigonometricFunctions(Of Half), IUnaryNegationOperators(Of Half, Half), IUnaryPlusOperators(Of Half, Half)
Public Structure Half
Implements IAdditionOperators(Of Half, Half, Half), IAdditiveIdentity(Of Half, Half), IBinaryFloatingPointIeee754(Of Half), IBinaryNumber(Of Half), IBitwiseOperators(Of Half, Half, Half), IComparable(Of Half), IComparisonOperators(Of Half, Half, Boolean), IDecrementOperators(Of Half), IDivisionOperators(Of Half, Half, Half), IEqualityOperators(Of Half, Half, Boolean), IEquatable(Of Half), IExponentialFunctions(Of Half), IFloatingPoint(Of Half), IFloatingPointConstants(Of Half), IFloatingPointIeee754(Of Half), IHyperbolicFunctions(Of Half), IIncrementOperators(Of Half), ILogarithmicFunctions(Of Half), IMinMaxValue(Of Half), IModulusOperators(Of Half, Half, Half), IMultiplicativeIdentity(Of Half, Half), IMultiplyOperators(Of Half, Half, Half), INumber(Of Half), INumberBase(Of Half), IParsable(Of Half), IPowerFunctions(Of Half), IRootFunctions(Of Half), ISignedNumber(Of Half), ISpanParsable(Of Half), ISubtractionOperators(Of Half, Half, Half), ITrigonometricFunctions(Of Half), IUnaryNegationOperators(Of Half, Half), IUnaryPlusOperators(Of Half, Half), IUtf8SpanParsable(Of Half)
Herencia
Object
ValueType
Half
Implementaciones
IComparable IComparable<Half> IEquatable<Half> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Half> IParsable<TSelf> ISpanParsable<Half> ISpanParsable<TSelf> IAdditionOperators<Half,Half,Half> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Half,Half> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Half> IBinaryNumber<Half> IBinaryNumber<TSelf> IBitwiseOperators<Half,Half,Half> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Half,Half,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Half> IDecrementOperators<TSelf> IDivisionOperators<Half,Half,Half> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Half,Half,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Half> IExponentialFunctions<TSelf> IFloatingPoint<Half> IFloatingPoint<TSelf> IFloatingPointConstants<Half> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Half> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Half> IHyperbolicFunctions<TSelf> IIncrementOperators<Half> IIncrementOperators<TSelf> ILogarithmicFunctions<Half> ILogarithmicFunctions<TSelf> IMinMaxValue<Half> IModulusOperators<Half,Half,Half> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Half,Half> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Half,Half,Half> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Half> INumber<TSelf> INumberBase<Half> INumberBase<TSelf> IPowerFunctions<Half> IPowerFunctions<TSelf> IRootFunctions<Half> IRootFunctions<TSelf> ISignedNumber<Half> ISignedNumber<TSelf> ISubtractionOperators<Half,Half,Half> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Half> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Half,Half> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Half,Half> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Half> IUtf8SpanParsable<TSelf>

Comentarios

El tipo de valor de Half representa un número de 16 bits de precisión media con valores que van de 65 504 a 65 504 positivos o negativos, PositiveInfinity, NegativeInfinityy no un número (NaN).

Se trata de un tipo de float16 compatible con IEEE 754.

Propiedades

E

Obtiene la constante matemática e.
Epsilon

Representa el valor de Half positivo más pequeño que es mayor que cero.
MaxValue

Representa el valor más grande posible de Half.
MinValue

Representa el valor más pequeño posible de Half.
MultiplicativeIdentity

Obtiene la identidad multiplicativa del tipo actual.
NaN

Representa no un número.
NegativeInfinity

Representa infinito negativo.
NegativeOne

Obtiene el valor -1 para el tipo.
NegativeZero

Obtiene un valor que representa un zeronegativo.
One

Obtiene el valor 1 para el tipo.
Pi

Obtiene la constante matemática pi.
PositiveInfinity

Representa infinito positivo.
Tau

Obtiene la constante matemática tau.
Zero

Obtiene el valor 0 para el tipo.

Métodos

Abs(Half)

Calcula el valor absoluto de un valor.
Acos(Half)

Calcula el arco-coseno de un valor.
Acosh(Half)

Calcula el coseno de arco hiperbólico de un valor.
AcosPi(Half)

Calcula el arco-coseno de un valor y divide el resultado por pi.
Asin(Half)

Calcula el arco seno de un valor.
Asinh(Half)

Calcula el arco-seno hiperbólico de un valor.
AsinPi(Half)

Calcula el arco-seno de un valor y divide el resultado por pi.
Atan(Half)

Calcula la tangente de arco de un valor.
Atan2(Half, Half)

Calcula la tangente de arco del cociente de dos valores.
Atan2Pi(Half, Half)

Calcula la tangente de arco para el cociente de dos valores y divide el resultado por pi.
Atanh(Half)

Calcula la tangente de arco hiperbólico de un valor.
AtanPi(Half)

Calcula la tangente de arco de un valor y divide el resultado por pi.
BitDecrement(Half)

Disminuye un valor al valor más pequeño que compara menos que un valor determinado.
BitIncrement(Half)

Incrementa un valor al valor más pequeño que compara mayor que un valor determinado.
Cbrt(Half)

Calcula la raíz del cubo de un valor.
Ceiling(Half)

Calcula el límite máximo de un valor.
Clamp(Half, Half, Half)

Fija un valor en un valor mínimo inclusivo y máximo.
CompareTo(Half)

Compara esta instancia con un número de punto flotante de precisión media 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 media especificado.
CompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del objeto especificado.
ConvertToInteger<TInteger>(Half)

Convierte un valor en un tipo entero especificado mediante saturación en desbordamiento.
ConvertToIntegerNative<TInteger>(Half)

Convierte un valor en un tipo entero especificado mediante el comportamiento específico de la plataforma en el desbordamiento.
CopySign(Half, Half)

Copia el signo de un valor en el signo de otro valor.
Cos(Half)

Calcula el coseno de un valor.
Cosh(Half)

Calcula el coseno hiperbólico de un valor.
CosPi(Half)

Calcula el coseno de un valor que ha sido multipledido por pi.
CreateChecked<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateSaturating<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateTruncating<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
DegreesToRadians(Half)

Convierte un valor determinado de grados a radianes.
Equals(Half)

Compara esta instancia para obtener igualdad con other.
Equals(Object)

Devuelve un valor que indica si esta instancia es igual al objespecificado.
Exp(Half)

Calcula E elevado a una potencia determinada.
Exp10(Half)

Calcula 10 elevado a una potencia determinada.
Exp10M1(Half)

Calcula 10 elevado a una potencia determinada y resta uno.
Exp2(Half)

Calcula 2 elevado a una potencia determinada.
Exp2M1(Half)

Calcula 2 elevado a una potencia determinada y resta uno.
ExpM1(Half)

Calcula E elevado a una potencia determinada y resta uno.
Floor(Half)

Calcula el piso de un valor.
FusedMultiplyAdd(Half, Half, Half)

Calcula la multiplicación fusionada de tres valores.
GetHashCode()

Devuelve el código hash de esta instancia.
Hypot(Half, Half)

Calcula la hipotenusa dadas dos valores que representan las longitudes de los lados más cortos en un triángulo con ángulo derecho.
Ieee754Remainder(Half, Half)

Calcula el resto de dos valores especificados por IEEE 754.
ILogB(Half)

Calcula el logaritmo entero de un valor.
IsEvenInteger(Half)

Determina si un valor representa un número entero par.
IsFinite(Half)

Determina si el valor especificado es finito (cero, subnormal o normal).
IsInfinity(Half)

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

Determina si un valor representa un valor entero.
IsNaN(Half)

Determina si el valor especificado no es un número.
IsNegative(Half)

Determina si el valor especificado es negativo.
IsNegativeInfinity(Half)

Determina si el valor especificado es infinito negativo.
IsNormal(Half)

Determina si el valor especificado es normal.
IsOddInteger(Half)

Determina si un valor representa un número entero impar.
IsPositive(Half)

Determina si un valor es positivo.
IsPositiveInfinity(Half)

Determina si el valor especificado es infinito positivo.
IsPow2(Half)

Determina si un valor es una potencia de dos.
IsRealNumber(Half)

Determina si un valor representa un número real.
IsSubnormal(Half)

Determina si el valor especificado es subnormal.
Lerp(Half, Half, Half)

Realiza una interpolación lineal entre dos valores en función del peso especificado.
Log(Half)

Calcula el logaritmo natural (base-E de un valor.
Log(Half, Half)

Calcula el logaritmo de un valor en la base especificada.
Log10(Half)

Calcula el logaritmo base-10 de un valor.
Log10P1(Half)

Calcula el logaritmo base-10 de un valor más uno.
Log2(Half)

Calcula el registro2 de un valor.
Log2P1(Half)

Calcula el logaritmo base-2 de un valor más uno.
LogP1(Half)

Calcula el logaritmo natural (base-E) de un valor más uno.
Max(Half, Half)

Compara dos valores con el proceso, que es mayor.
MaxMagnitude(Half, Half)

Compara dos valores con el proceso, que es mayor.
MaxMagnitudeNumber(Half, Half)

Compara dos valores con el proceso que tiene la magnitud mayor y devuelve el otro valor si una entrada es NaN.
MaxNumber(Half, Half)

Compara dos valores con el proceso, que es mayor y devuelve el otro valor si una entrada es NaN.
Min(Half, Half)

Compara dos valores con el proceso, que es menor.
MinMagnitude(Half, Half)

Compara dos valores con el proceso, que es menor.
MinMagnitudeNumber(Half, Half)

Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es NaN.
MinNumber(Half, Half)

Compara dos valores con el proceso, que es menor y devuelve el otro valor si una entrada es NaN.
MultiplyAddEstimate(Half, Half, Half)

Calcula una estimación de (left * right) + addend.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su número de punto flotante de precisión sencilla equivalente.
Parse(String)

Convierte la representación de cadena de un número en su número de punto flotante de precisión media equivalente.
Parse(String, IFormatProvider)

Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado en su número de punto flotante de precisión sencilla equivalente.
Parse(String, NumberStyles)

Convierte la representación de cadena de un número en un estilo especificado en su número de punto flotante de precisión sencilla equivalente.
Parse(String, NumberStyles, IFormatProvider)

Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su número de punto flotante de precisión sencilla equivalente.
Pow(Half, Half)

Calcula un valor elevado a una potencia determinada.
RadiansToDegrees(Half)

Convierte un valor determinado de radianes en grados.
ReciprocalEstimate(Half)

Calcula una estimación de la recíproca de un valor.
ReciprocalSqrtEstimate(Half)

Calcula una estimación de la raíz cuadrada recíproca de un valor.
RootN(Half, Int32)

Calcula la n-ª raíz de un valor.
Round(Half)

Redondea un valor al entero más cercano mediante el modo de redondeo predeterminado (ToEven).
Round(Half, Int32)

Redondea un valor a un número especificado de dígitos fraccionarios mediante el modo de redondeo predeterminado (ToEven).
Round(Half, Int32, MidpointRounding)

Redondea un valor a un número especificado de dígitos fraccionarios mediante el modo de redondeo predeterminado (ToEven).
Round(Half, MidpointRounding)

Redondea un valor al entero más cercano mediante el modo de redondeo especificado.
ScaleB(Half, Int32)

Calcula el producto de un valor y su base-radix elevado a la potencia especificada.
Sign(Half)

Calcula el signo de un valor.
Sin(Half)

Calcula el seno de un valor.
SinCos(Half)

Calcula el seno y el coseno de un valor.
SinCosPi(Half)

Calcula el seno y el coseno de un valor multiplicado por pi.
Sinh(Half)

Calcula el seno hiperbólico de un valor.
SinPi(Half)

Calcula el seno de un valor que se ha multiplicado por pi.
Sqrt(Half)

Calcula la raíz cuadrada de un valor.
Tan(Half)

Calcula la tangente de un valor.
Tanh(Half)

Calcula la tangente hiperbólica de un valor.
TanPi(Half)

Calcula la tangente de un valor que ha sido multipledido por pi.
ToString()

Convierte el valor numérico de esta instancia en su representación de cadena equivalente.
ToString(IFormatProvider)

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante la información de formato específica de la referencia cultural especificada.
ToString(String)

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado.
ToString(String, IFormatProvider)

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado y la información de formato específica de la referencia cultural.
Truncate(Half)

Trunca un valor.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Intenta dar formato al valor de la instancia de Half actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Byte>, Half)

Intenta convertir un intervalo de caracteres UTF-8 que contiene la representación de cadena de un número en su número de punto flotante de precisión media equivalente.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)

Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)

Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Char>, Half)

Convierte la representación de intervalo de un número en su número de punto flotante de precisión media equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Intenta analizar un intervalo de caracteres en un valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Convierte la representación de intervalo de un número en su número de punto flotante de precisión media equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no.
TryParse(String, Half)

Convierte la representación de cadena de un número en su número de punto flotante de precisión media equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no.
TryParse(String, IFormatProvider, Half)

Intenta analizar una cadena en un valor.
TryParse(String, NumberStyles, IFormatProvider, Half)

Convierte la representación de cadena de un número en su número de punto flotante de precisión media equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no.

Operadores

Addition(Half, Half)

Agrega dos valores juntos para calcular su suma.
CheckedExplicit(Half)

Representa un número de punto flotante de precisión media.
Decrement(Half)

Disminuye un valor.
Division(Half, Half)

Divide dos valores juntos para calcular su cociente.
Equality(Half, Half)

Devuelve un valor que indica si dos valores de Half especificados son iguales.
Explicit(Char to Half)

Convierte explícitamente un valor de Char en su valor de punto flotante de precisión media más cercano.
Explicit(Decimal to Half)

Convierte explícitamente un valor de Decimal en su valor de punto flotante de precisión media más cercano.
Explicit(Double to Half)

Operador explícito para convertir un valor de Double en un Half.
Explicit(Half to Byte)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Byte.
Explicit(Half to Char)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Char.
Explicit(Half to Decimal)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Decimal.
Explicit(Half to Double)

Operador explícito para convertir un valor de Half en un Double.
Explicit(Half to Int128)

Convierte explícitamente un valor de punto flotante de precisión media en su Int128más cercano.
Explicit(Half to Int16)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Int16.
Explicit(Half to Int32)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Int32.
Explicit(Half to Int64)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar Int64.
Explicit(Half to IntPtr)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar IntPtr.
Explicit(Half to SByte)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar SByte.
Explicit(Half to Single)

Operador explícito para convertir un valor de Half en un Single.
Explicit(Half to UInt128)

Convierte explícitamente un valor de punto flotante de precisión media en su UInt128más cercano.
Explicit(Half to UInt16)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar UInt16.
Explicit(Half to UInt32)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar UInt32.
Explicit(Half to UInt64)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar UInt64.
Explicit(Half to UIntPtr)

Convierte explícitamente un valor de punto flotante de precisión media en su valor de punto flotante más cercano que se puede representar UIntPtr.
Explicit(Int16 to Half)

Convierte explícitamente un valor de Int16 en su valor de punto flotante de precisión media más cercano.
Explicit(Int32 to Half)

Convierte explícitamente un valor de Int32 en su valor de punto flotante de precisión media más cercano.
Explicit(Int64 to Half)

Convierte explícitamente un valor de Int64 en su valor de punto flotante de precisión media más cercano.
Explicit(IntPtr to Half)

Convierte explícitamente un valor de IntPtr en su valor de punto flotante de precisión media más cercano.
Explicit(Single to Half)

Operador explícito para convertir un valor de Single en un Half.
Explicit(UInt16 to Half)

Convierte explícitamente un valor de UInt16 en su valor de punto flotante de precisión media más cercano.
Explicit(UInt32 to Half)

Convierte explícitamente un valor de UInt32 en su valor de punto flotante de precisión media más cercano.
Explicit(UInt64 to Half)

Convierte explícitamente un valor de UInt64 en su valor de punto flotante de precisión media más cercano.
Explicit(UIntPtr to Half)

Convierte explícitamente un valor de UIntPtr en su valor de punto flotante de precisión media más cercano.
GreaterThan(Half, Half)

Devuelve un valor que indica si un valor de Half especificado es mayor que otro valor de Half especificado.
GreaterThanOrEqual(Half, Half)

Devuelve un valor que indica si left es mayor o igual que right.
Implicit(Byte to Half)

Convierte implícitamente un valor de Byte en su valor de punto flotante de precisión media más cercano.
Implicit(SByte to Half)

Convierte implícitamente un valor de SByte en su valor de punto flotante de precisión media más cercano.
Increment(Half)

Incrementa un valor.
Inequality(Half, Half)

Devuelve un valor que indica si dos valores de Half especificados no son iguales.
LessThan(Half, Half)

Devuelve un valor que indica si un valor de Half especificado es menor que otro valor de Half especificado.
LessThanOrEqual(Half, Half)

Devuelve un valor que indica si un valor de Half especificado es menor o igual que otro valor de Half especificado.
Modulus(Half, Half)

Divide dos valores juntos para calcular su módulo o resto.
Multiply(Half, Half)

Multiplica dos valores juntos para calcular su producto.
Subtraction(Half, Half)

Resta dos valores para calcular su diferencia.
UnaryNegation(Half)

Calcula la negación unaria de un valor.
UnaryPlus(Half)

Calcula la unaria más de un valor.

Implementaciones de interfaz explícitas

IAdditiveIdentity<Half,Half>.AdditiveIdentity

Obtiene la identidad de suma del tipo actual.
IBinaryNumber<Half>.AllBitsSet

Obtiene una instancia del tipo binario en el que se establecen todos los bits.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)

Calcula los valores bit a bit y de dos valores.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)

Calcula el bit a bit o de dos valores.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)

Calcula el valor exclusivo o de dos valores.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)

Calcula la representación ones-complement de un valor determinado.
IFloatingPoint<Half>.GetExponentByteCount()

Obtiene el número de bytes que se escribirán como parte de TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()

Obtiene la longitud, en bits, de la representación complementaria de dos más corta del exponente actual.
IFloatingPoint<Half>.GetSignificandBitLength()

Obtiene la longitud, en bits, del significado actual.
IFloatingPoint<Half>.GetSignificandByteCount()

Obtiene el número de bytes que se escribirán como parte de TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)

Intenta escribir el exponente actual, en formato big-endian, en un intervalo determinado.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)

Intenta escribir el exponente actual, en formato little-endian, en un intervalo determinado.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)

Intenta escribir el significado actual, en formato big-endian, en un intervalo determinado.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Intenta escribir el significado actual, en formato little-endian, en un intervalo determinado.
INumberBase<Half>.IsCanonical(Half)

Determina si un valor está en su representación canónica.
INumberBase<Half>.IsComplexNumber(Half)

Determina si un valor representa un número complejo.
INumberBase<Half>.IsImaginaryNumber(Half)

Determina si un valor representa un número imaginario puro.
INumberBase<Half>.IsZero(Half)

Determina si un valor es cero.
INumberBase<Half>.Radix

Obtiene el radix, o base, para el tipo .
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)

Representa un número de punto flotante de precisión media.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)

Representa un número de punto flotante de precisión media.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)

Representa un número de punto flotante de precisión media.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)

Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)

Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)

Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.

Se aplica a

Consulte también