Half Estrutura

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Origem:: Half.cs

Origem:: Half.cs

Origem:: Half.cs

Origem:: Half.cs

Origem:: Half.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa um número de ponto flutuante de meia precisão.

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 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 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>

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>

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>

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>

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)

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)

Herança: Object

ValueType
Half

Implementações: IComparable IComparable<Half> IComparable<TSelf> IEquatable<Half> IEquatable<TSelf> IFormattable IParsable<Half> IParsable<TSelf> ISpanFormattable ISpanParsable<Half> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Half> IUtf8SpanParsable<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>

Comentários

O Half tipo de valor representa um número de meia precisão de 16 bits com valores que variam de 65.504 negativos a 65.504 positivos, bem como zero positivo ou negativo, PositiveInfinity NegativeInfinitye não um número (NaN).

Este é um tipo compatível com float16 IEEE 754.

Propriedades

Nome	Description
E	Obtém a constante `e`matemática.
Epsilon	Representa o menor valor positivo Half que é maior que zero.
MaxValue	Representa o maior valor possível de Half.
MinValue	Representa o menor valor possível de Half.
MultiplicativeIdentity	Obtém a identidade multiplicativa do tipo atual.
NaN	Não representa um número.
NegativeInfinity	Representa o infinito negativo.
NegativeOne	Obtém o valor `-1` do tipo.
NegativeZero	Obtém um valor que representa negativo `zero`.
One	Obtém o valor `1` do tipo.
Pi	Obtém a constante `pi`matemática.
PositiveInfinity	Representa infinito positivo.
Tau	Obtém a constante `tau`matemática.
Zero	Obtém o valor `0` do tipo.

Métodos

Nome	Description
Abs(Half)	Calcula o absoluto de um valor.
Acos(Half)	Calcula o arco-cosseno de um valor.
Acosh(Half)	Calcula o arco-cosseno hiperbólico de um valor.
AcosPi(Half)	Calcula o arco-cosseno de um valor e divide o resultado por `pi`.
Asin(Half)	Calcula o arco-seno de um valor.
Asinh(Half)	Calcula o arco-seno hiperbólico de um valor.
AsinPi(Half)	Calcula o arco-seno de um valor e divide o resultado por `pi`.
Atan(Half)	Calcula a tangente de arco de um valor.
Atan2(Half, Half)	Calcula a tangente de arco do quociente de dois valores.
Atan2Pi(Half, Half)	Calcula a tangente de arco para o quociente de dois valores e divide o resultado por `pi`.
Atanh(Half)	Calcula a tangente de arco hiperbólico de um valor.
AtanPi(Half)	Calcula a tangente de arco de um valor e divide o resultado por pi.
BitDecrement(Half)	Decrementa um valor com o menor valor que compara menos que um determinado valor.
BitIncrement(Half)	Incrementa um valor para o menor valor que compara maior que um determinado valor.
Cbrt(Half)	Calcula a raiz do cubo de um valor.
Ceiling(Half)	Calcula o teto de um valor.
Clamp(Half, Half, Half)	Fixa um valor a um valor mínimo inclusivo e máximo.
ClampNative(Half, Half, Half)	Fixa um valor a um valor mínimo inclusivo e máximo usando o comportamento específico da plataforma para `NaN` e `NegativeZero`.
CompareTo(Half)	Compara essa instância a um número de ponto flutuante de meia precisão especificado e retorna um inteiro que indica se o valor dessa instância é menor que, igual ou maior que o valor do número de ponto flutuante de meia precisão especificado.
CompareTo(Object)	Compara essa instância a um objeto especificado e retorna um inteiro que indica se o valor dessa instância é menor que, igual ou maior que o valor do objeto especificado.
ConvertToInteger<TInteger>(Half)	Converte um valor em um tipo inteiro especificado usando saturação no estouro
ConvertToIntegerNative<TInteger>(Half)	Converte um valor em um tipo inteiro especificado usando o comportamento específico da plataforma no estouro.
CopySign(Half, Half)	Copia o sinal de um valor para o sinal de outro valor.
Cos(Half)	Calcula o cosseno de um valor.
Cosh(Half)	Calcula o cosseno hiperbólico de um valor.
CosPi(Half)	Calcula o cosseno de um valor que foi múltiplo por `pi`.
CreateChecked<TOther>(TOther)	Cria uma instância do tipo atual de um valor, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
CreateSaturating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, saturando todos os valores que estão fora do intervalo representável do tipo atual.
CreateTruncating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, truncando todos os valores que estão fora do intervalo representável do tipo atual.
DegreesToRadians(Half)	Converte um determinado valor de graus em radianos.
Equals(Half)	Compara essa instância de igualdade com `other`.
Equals(Object)	Retorna um valor que indica se essa instância é igual à especificada `obj`.
Exp(Half)	Cálculos elevados `E` a um determinado poder.
Exp10(Half)	Cálculos elevados `10` a um determinado poder.
Exp10M1(Half)	Os cálculos gerados `10` para um determinado poder e subtrai um.
Exp2(Half)	Cálculos elevados `2` a um determinado poder.
Exp2M1(Half)	Os cálculos gerados `2` para um determinado poder e subtrai um.
ExpM1(Half)	Os cálculos gerados `E` para um determinado poder e subtrai um.
Floor(Half)	Calcula o piso de um valor.
FusedMultiplyAdd(Half, Half, Half)	Calcula a multiplicação fundida de três valores.
GetHashCode()	Retorna o código hash dessa instância.
Hypot(Half, Half)	Calcula a hipotenusa dado dois valores que representam os comprimentos dos lados mais curtos em um triângulo com ângulo reto.
Ieee754Remainder(Half, Half)	Calcula o restante de dois valores, conforme especificado pelo IEEE 754.
ILogB(Half)	Calcula o logaritmo inteiro de um valor.
IsEvenInteger(Half)	Determina se um valor representa um número integral par.
IsFinite(Half)	Determina se o valor especificado é finito (zero, subnormal ou normal).
IsInfinity(Half)	Retorna um valor que indica se o número especificado é avaliado como infinito positivo.
IsInteger(Half)	Determina se um valor representa um valor integral.
IsNaN(Half)	Determina se o valor especificado não é um número.
IsNegative(Half)	Determina se o valor especificado é negativo.
IsNegativeInfinity(Half)	Determina se o valor especificado é infinito negativo.
IsNormal(Half)	Determina se o valor especificado é normal.
IsOddInteger(Half)	Determina se um valor representa um número integral ímpar.
IsPositive(Half)	Determina se um valor é positivo.
IsPositiveInfinity(Half)	Determina se o valor especificado é infinito positivo.
IsPow2(Half)	Determina se um valor é uma potência de dois.
IsRealNumber(Half)	Determina se um valor representa um número real.
IsSubnormal(Half)	Determina se o valor especificado é subnormal.
Lerp(Half, Half, Half)	Executa uma interpolação linear entre dois valores com base no peso fornecido.
Log(Half, Half)	Calcula o logaritmo de um valor na base especificada.
Log(Half)	Calcula o natural (`base-E` logaritmo de um valor.
Log10(Half)	Calcula o logaritmo de base 10 de um valor.
Log10P1(Half)	Calcula o logaritmo de base 10 de um valor mais um.
Log2(Half)	Calcula o log2 de um valor.
Log2P1(Half)	Calcula o logaritmo de base 2 de um valor mais um.
LogP1(Half)	Calcula o logaritmo natural (`base-E`) de um valor mais um.
Max(Half, Half)	Compara dois valores com a computação que é maior.
MaxMagnitude(Half, Half)	Compara dois valores com a computação que é maior.
MaxMagnitudeNumber(Half, Half)	Compara dois valores com a computação que tem maior magnitude e retorna o outro valor se uma entrada for `NaN`.
MaxNative(Half, Half)	Compara dois valores com a computação, que é maior usando o comportamento específico da plataforma para `NaN` e `NegativeZero`.
MaxNumber(Half, Half)	Compara dois valores com a computação, que é maior e retorna o outro valor se uma entrada for `NaN`.
Min(Half, Half)	Compara dois valores com a computação menor.
MinMagnitude(Half, Half)	Compara dois valores com a computação menor.
MinMagnitudeNumber(Half, Half)	Compara dois valores com a computação que tem a menor magnitude e retorna o outro valor se uma entrada for `NaN`.
MinNative(Half, Half)	Compara dois valores com a computação que é menor usando o comportamento específico da plataforma para `NaN` e `NegativeZero`.
MinNumber(Half, Half)	Compara dois valores com a computação que é menor e retorna o outro valor se uma entrada for `NaN`.
MultiplyAddEstimate(Half, Half, Half)	Calcula uma estimativa de (`left` * `right`) + . `addend`
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String, NumberStyles, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String, NumberStyles)	Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String)	Converte a representação de cadeia de caracteres de um número em seu equivalente de ponto flutuante de meia precisão.
Pow(Half, Half)	Calcula um valor elevado a um determinado poder.
RadiansToDegrees(Half)	Converte um determinado valor de radianos em graus.
ReciprocalEstimate(Half)	Calcula uma estimativa da recíproca de um valor.
ReciprocalSqrtEstimate(Half)	Calcula uma estimativa da raiz quadrada recíproca de um valor.
RootN(Half, Int32)	Calcula a raiz n-th de um valor.
Round(Half, Int32, MidpointRounding)	Arredonda um valor para um número especificado de dígitos fracionários usando o modo de arredondamento padrão (ToEven).
Round(Half, Int32)	Arredonda um valor para um número especificado de dígitos fracionários usando o modo de arredondamento padrão (ToEven).
Round(Half, MidpointRounding)	Arredonda um valor para o inteiro mais próximo usando o modo de arredondamento especificado.
Round(Half)	Arredonda um valor para o inteiro mais próximo usando o modo de arredondamento padrão (ToEven).
ScaleB(Half, Int32)	Calcula o produto de um valor e seu radix base elevado à potência especificada.
Sign(Half)	Calcula o sinal de um valor.
Sin(Half)	Calcula o seno de um valor.
SinCos(Half)	Calcula o seno e o cosseno de um valor.
SinCosPi(Half)	Calcula o seno e o cosseno de um valor multiplicado por `pi`.
Sinh(Half)	Calcula o seno hiperbólico de um valor.
SinPi(Half)	Calcula o seno de um valor que foi multiplicado por `pi`.
Sqrt(Half)	Calcula a raiz quadrada de um valor.
Tan(Half)	Calcula a tangente de um valor.
Tanh(Half)	Calcula a tangente hiperbólica de um valor.
TanPi(Half)	Calcula a tangente de um valor que foi múltiplo por `pi`.
ToString()	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente.
ToString(IFormatProvider)	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificadas.
ToString(String, IFormatProvider)	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura.
ToString(String)	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado.
Truncate(Half)	Trunca um valor.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual como UTF-8 no intervalo de bytes fornecido.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual Half no intervalo de caracteres fornecido.
TryParse(ReadOnlySpan<Byte>, Half)	Tenta converter um intervalo de caracteres UTF-8 que contém a representação de cadeia de caracteres de um número em seu equivalente de ponto flutuante de meia precisão.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Char>, Half)	Converte a representação de intervalo de um número em seu equivalente de ponto flutuante de meia precisão. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Converte a representação de intervalo de um número em seu equivalente de ponto flutuante de meia precisão. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(String, Half)	Converte a representação de cadeia de caracteres de um número em seu equivalente de ponto flutuante de meia precisão. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(String, IFormatProvider, Half)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(String, NumberStyles, IFormatProvider, Half)	Converte a representação de cadeia de caracteres de um número em seu equivalente de ponto flutuante de meia precisão. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

Operadores

Nome	Description
Addition(Half, Half)	Adiciona dois valores juntos para calcular sua soma.
CheckedExplicit(Half to Byte)	Representa um número de ponto flutuante de meia precisão.
Decrement(Half)	Decrementa um valor.
Division(Half, Half)	Divide dois valores juntos para calcular seu quociente.
Equality(Half, Half)	Retorna um valor que indica se dois valores especificados Half são iguais.
Explicit(Char to Half)	Converte explicitamente um Char valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(Decimal to Half)	Converte explicitamente um Decimal valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(Double to Half)	Um operador explícito para converter um Double valor em um Half.
Explicit(Half to Byte)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Byte mais próximo.
Explicit(Half to Char)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Char mais próximo.
Explicit(Half to Decimal)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Decimal mais próximo.
Explicit(Half to Double)	Um operador explícito para converter um Half valor em um Double.
Explicit(Half to Int128)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu representável Int128mais próximo.
Explicit(Half to Int16)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Int16 mais próximo.
Explicit(Half to Int32)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Int32 mais próximo.
Explicit(Half to Int64)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável Int64 mais próximo.
Explicit(Half to IntPtr)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável IntPtr mais próximo.
Explicit(Half to SByte)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável SByte mais próximo.
Explicit(Half to Single)	Um operador explícito para converter um Half valor em um Single.
Explicit(Half to UInt128)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu representável UInt128mais próximo.
Explicit(Half to UInt16)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável UInt16 mais próximo.
Explicit(Half to UInt32)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável UInt32 mais próximo.
Explicit(Half to UInt64)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável UInt64 mais próximo.
Explicit(Half to UIntPtr)	Converte explicitamente um valor de ponto flutuante de meia precisão em seu valor representável UIntPtr mais próximo.
Explicit(Int16 to Half)	Converte explicitamente um Int16 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(Int32 to Half)	Converte explicitamente um Int32 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(Int64 to Half)	Converte explicitamente um Int64 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(IntPtr to Half)	Converte explicitamente um IntPtr valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(Single to Half)	Um operador explícito para converter um Single valor em um Half.
Explicit(UInt16 to Half)	Converte explicitamente um UInt16 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(UInt32 to Half)	Converte explicitamente um UInt32 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(UInt64 to Half)	Converte explicitamente um UInt64 valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Explicit(UIntPtr to Half)	Converte explicitamente um UIntPtr valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
GreaterThan(Half, Half)	Retorna um valor que indica se um valor especificado Half é maior que outro valor especificado Half .
GreaterThanOrEqual(Half, Half)	Retorna um valor que indica se `left` é maior ou igual a `right`.
Implicit(Byte to Half)	Converte implicitamente um Byte valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Implicit(SByte to Half)	Converte implicitamente um SByte valor em seu valor de ponto flutuante de meia precisão representável mais próximo.
Increment(Half)	Incrementa um valor.
Inequality(Half, Half)	Retorna um valor que indica se dois valores especificados Half não são iguais.
LessThan(Half, Half)	Retorna um valor que indica se um valor especificado Half é menor que outro valor especificado Half .
LessThanOrEqual(Half, Half)	Retorna um valor que indica se um valor especificado Half é menor ou igual a outro valor especificado Half .
Modulus(Half, Half)	Divide dois valores juntos para calcular seu módulo ou restante.
Multiply(Half, Half)	Multiplica dois valores juntos para calcular seu produto.
Subtraction(Half, Half)	Subtrai dois valores para calcular a diferença.
UnaryNegation(Half)	Calcula a negação unária de um valor.
UnaryPlus(Half)	Calcula a adição unária de um valor.

Implantações explícitas de interface

Nome	Description
IAdditiveIdentity<Half,Half>.AdditiveIdentity	Obtém a identidade aditiva do tipo atual.
IBinaryNumber<Half>.AllBitsSet	Obtém uma instância do tipo binário na qual todos os bits são definidos.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)	Calcula o bit a bit e dois valores.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)	Calcula o bit a bit ou de dois valores.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)	Calcula o exclusivo ou de dois valores.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)	Calcula a representação ones-complement de um determinado valor.
IFloatingPoint<Half>.GetExponentByteCount()	Obtém o número de bytes que serão gravados como parte de TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()	Obtém o comprimento, em bits, da representação complementar dos dois mais curtos do expoente atual.
IFloatingPoint<Half>.GetSignificandBitLength()	Obtém o comprimento, em bits, do significand atual.
IFloatingPoint<Half>.GetSignificandByteCount()	Obtém o número de bytes que serão gravados como parte de TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Tenta gravar o expoente atual, no formato big-endian, em um determinado intervalo.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Tenta gravar o expoente atual, em formato little-endian, em um determinado intervalo.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Tenta gravar o significand atual, no formato big-endian, em um determinado intervalo.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Tenta gravar o significand atual, em formato little-endian, em um determinado intervalo.
INumberBase<Half>.IsCanonical(Half)	Determina se um valor está em sua representação canônica.
INumberBase<Half>.IsComplexNumber(Half)	Determina se um valor representa um número complexo.
INumberBase<Half>.IsImaginaryNumber(Half)	Determina se um valor representa um número imaginário puro.
INumberBase<Half>.IsZero(Half)	Determina se um valor é zero.
INumberBase<Half>.Radix	Obtém a base para o tipo.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)	Representa um número de ponto flutuante de meia precisão.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)	Representa um número de ponto flutuante de meia precisão.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)	Representa um número de ponto flutuante de meia precisão.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)	Tenta converter uma instância do tipo atual em outro tipo, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)	Tenta converter uma instância do tipo atual em outro tipo, saturando todos os valores que estão fora do intervalo representável do tipo atual.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)	Tenta converter uma instância do tipo atual em outro tipo, truncando todos os valores que estejam fora do intervalo representável do tipo atual.

Aplica-se a

Confira também

Single

Comentários

Esta página foi útil?