Half Estrutura

Definição

Espaço de Nomes:
System
Assemblagem:
System.Runtime.dll
Origem:
Half.cs
Origem:
Half.cs
Origem:
Half.cs
Origem:
Half.cs
Origem:
Half.cs

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>

Observações

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

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

Propriedades

Name Description
E

Obtém a constante ematemática .
Epsilon

Representa o menor valor positivo Half que seja 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 pimatemática .
PositiveInfinity

Representa o infinito positivo.
Tau

Obtém a constante taumatemática .
Zero

Obtém o valor 0 do tipo.

Métodos

Name Description
Abs(Half)

Calcula o absoluto de um valor.
Acos(Half)

Calcula o arc-cosseno de um valor.
Acosh(Half)

Calcula o arc-cosseno hiperbólico de um valor.
AcosPi(Half)

Calcula o arc-cosseno de um valor e divide o resultado por pi.
Asin(Half)

Calcula o seno de arco 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 o arco tangente 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 hiperbólica de arco de um valor.
AtanPi(Half)

Calcula o arco tangente de um valor e divide o resultado por pi.
BitDecrement(Half)

Diminui um valor ao menor valor que se compara a menos de um dado valor.
BitIncrement(Half)

Incrementa um valor até ao menor valor que se compara a um dado valor.
Cbrt(Half)

Calcula a raiz cúbica de um valor.
Ceiling(Half)

Calcula o teto de um valor.
Clamp(Half, Half, Half)

Fixa um valor a um valor mínimo e máximo inclusivo.
ClampNative(Half, Half, Half)

Fixa um valor a um valor mínimo e máximo inclusivo usando comportamentos específicos da plataforma para NaN e NegativeZero.
CompareTo(Half)

Compara esta instância com um número de ponto flutuante de meia precisão especificado e devolve um inteiro que indica se o valor desta instância é menor, igual ou superior ao valor do número de ponto flutuante de meia precisão especificado.
CompareTo(Object)

Compara esta instância com um objeto especificado e devolve um inteiro que indica se o valor desta instância é menor, igual ou superior ao valor do objeto especificado.
ConvertToInteger<TInteger>(Half)

Converte um valor para um tipo inteiro especificado usando saturação no overflow
ConvertToIntegerNative<TInteger>(Half)

Converte um valor para um tipo inteiro especificado usando o comportamento específico da plataforma no overflow.
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 multiplicado por pi.
CreateChecked<TOther>(TOther)

Cria uma instância do tipo atual a partir de um valor, lançando uma exceção de overflow para quaisquer valores que estejam fora do intervalo representável do tipo atual.
CreateSaturating<TOther>(TOther)

Cria uma instância do tipo atual a partir de um valor, saturando quaisquer valores que estejam fora do intervalo representável do tipo atual.
CreateTruncating<TOther>(TOther)

Cria uma instância do tipo atual a partir de um valor, truncando quaisquer valores que estejam fora do intervalo representável do tipo atual.
DegreesToRadians(Half)

Converte um dado valor de graus para radianos.
Equals(Half)

Compara esta instância para igualdade com other.
Equals(Object)

Devolve um valor que indica se esta instância é igual ao especificado obj.
Exp(Half)

Computações E elevadas a uma dada potência.
Exp10(Half)

Computações 10 elevadas a uma dada potência.
Exp10M1(Half)

Calcula 10 para uma dada potência e subtrai uma.
Exp2(Half)

Computações 2 elevadas a uma dada potência.
Exp2M1(Half)

Calcula 2 para uma dada potência e subtrai uma.
ExpM1(Half)

Calcula E para uma dada potência e subtrai uma.
Floor(Half)

Calcula o mínimo de um valor.
FusedMultiplyAdd(Half, Half, Half)

Calcula a multiplicação-soma fundida de três valores.
GetHashCode()

Devolve o código de hash para esta instância.
Hypot(Half, Half)

Calcula a hipotenusa dados dois valores que representam os comprimentos dos lados mais curtos num triângulo retângulo.
Ieee754Remainder(Half, Half)

Calcula os restantes dois valores especificados pelo IEEE 754.
ILogB(Half)

Calcula o logaritmo inteiro de um valor.
IsEvenInteger(Half)

Determina se um valor representa um número inteiro par.
IsFinite(Half)

Determina se o valor especificado é finito (zero, subnormal ou normal).
IsInfinity(Half)

Devolve um valor que indica se o número especificado equivale a 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 é menos infinito.
IsNormal(Half)

Determina se o valor especificado é normal.
IsOddInteger(Half)

Determina se um valor representa um número inteiro í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)

Realiza uma interpolação linear entre dois valores com base no peso dado.
Log(Half, Half)

Calcula o logaritmo de um valor na base especificada.
Log(Half)

Calcula o logaritmo naturalbase-E de um valor.
Log10(Half)

Calcula o logaritmo em base 10 de um valor.
Log10P1(Half)

Calcula o logaritmo em base 10 de um valor mais um.
Log2(Half)

Calcula o log2 de um valor.
Log2P1(Half)

Calcula o logaritmo em 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 para calcular qual é maior.
MaxMagnitude(Half, Half)

Compara dois valores para calcular qual é maior.
MaxMagnitudeNumber(Half, Half)

Compara dois valores para calcular qual tem maior magnitude e devolve o outro valor se uma entrada for NaN.
MaxNative(Half, Half)

Compara dois valores para calcular qual é maior usando comportamento específico da plataforma para NaN e NegativeZero.
MaxNumber(Half, Half)

Compara dois valores para calcular qual é maior e devolve o outro valor se uma entrada for NaN.
Min(Half, Half)

Compara dois valores para calcular qual é menor.
MinMagnitude(Half, Half)

Compara dois valores para calcular qual é menor.
MinMagnitudeNumber(Half, Half)

Compara dois valores para calcular que tem a magnitude menor e devolve o outro valor se uma entrada for NaN.
MinNative(Half, Half)

Compara dois valores para calcular qual é menor usando comportamento específico da plataforma para NaN e NegativeZero.
MinNumber(Half, Half)

Compara dois valores para calcular qual é menor e devolve 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 num valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analisa um intervalo de caracteres UTF-8 num valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Divide um intervalo de caracteres num valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte a representação de cadeias de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples.
Parse(String, IFormatProvider)

Converte a representação da cadeia de um número num formato específico de cultura para o seu equivalente de número de ponto flutuante de precisão simples.
Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeias de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples.
Parse(String, NumberStyles)

Converte a representação de cadeias de um número num estilo especificado para o seu equivalente numérico de ponto flutuante de precisão simples.
Parse(String)

Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de meia precisão.
Pow(Half, Half)

Calcula um valor elevado para uma dada potência.
RadiansToDegrees(Half)

Converte um dado valor de radianos em graus.
ReciprocalEstimate(Half)

Calcula uma estimativa do recíproco de um valor.
ReciprocalSqrtEstimate(Half)

Calcula uma estimativa da raiz quadrada recíproca de um valor.
RootN(Half, Int32)

Calcula a raiz n-ésima 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 número inteiro mais próximo usando o modo de arredondamento especificado.
Round(Half)

Arredonda um valor para o número inteiro mais próximo usando o modo de arredondamento padrão (ToEven).
ScaleB(Half, Int32)

Calcula o produto de um valor e da sua base raix elevada para a 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 cosseno de um valor que foi 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 multiplicado por pi.
ToString()

Converte o valor numérico desta instância para a sua representação equivalente em cadeias.
ToString(IFormatProvider)

Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando a informação de formato específica da cultura especificada.
ToString(String, IFormatProvider)

Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando o formato especificado e a informação específica de formato da cultura.
ToString(String)

Converte o valor numérico desta instância para a sua representação equivalente em cadeias, 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 fornecido de bytes.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta formatar o valor da instância atual Half no intervalo fornecido de caracteres.
TryParse(ReadOnlySpan<Byte>, Half)

Tenta converter um espaço de caracteres UTF-8 contendo a representação de cadeias de um número para o seu equivalente de número de ponto flutuante de meia precisão.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)

Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)

Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Char>, Half)

Converte a representação de um número em ponto flutuante para o seu equivalente em ponto flutuante de meia precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Tenta separar um intervalo de caracteres num valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Converte a representação de um número em ponto flutuante para o seu equivalente em ponto flutuante de meia precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(String, Half)

Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de meia precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(String, IFormatProvider, Half)

Tenta analisar uma cadeia num valor.
TryParse(String, NumberStyles, IFormatProvider, Half)

Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de meia precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou.

Operadores

Name Description
Addition(Half, Half)

Soma dois valores para calcular a sua soma.
CheckedExplicit(Half to Byte)

Representa um número de ponto flutuante de meia precisão.
Decrement(Half)

Diminui um valor.
Division(Half, Half)

Divide dois valores para calcular o seu quociente.
Equality(Half, Half)

Devolve um valor que indica se dois valores especificados Half são iguais.
Explicit(Char to Half)

Converte explicitamente um Char valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(Decimal to Half)

Converte explicitamente um Decimal valor para o 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 .Half
Explicit(Half to Byte)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Byte mais próximo.
Explicit(Half to Char)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Char mais próximo.
Explicit(Half to Decimal)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Decimal mais próximo.
Explicit(Half to Double)

Um operador explícito para converter um Half valor em .Double
Explicit(Half to Int128)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu representável Int128mais próximo .
Explicit(Half to Int16)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Int16 mais próximo.
Explicit(Half to Int32)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Int32 mais próximo.
Explicit(Half to Int64)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável Int64 mais próximo.
Explicit(Half to IntPtr)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável IntPtr mais próximo.
Explicit(Half to SByte)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável SByte mais próximo.
Explicit(Half to Single)

Um operador explícito para converter um Half valor em .Single
Explicit(Half to UInt128)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu representável UInt128mais próximo .
Explicit(Half to UInt16)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável UInt16 mais próximo.
Explicit(Half to UInt32)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável UInt32 mais próximo.
Explicit(Half to UInt64)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável UInt64 mais próximo.
Explicit(Half to UIntPtr)

Converte explicitamente um valor de ponto flutuante de meia precisão para o seu valor representável UIntPtr mais próximo.
Explicit(Int16 to Half)

Converte explicitamente um Int16 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(Int32 to Half)

Converte explicitamente um Int32 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(Int64 to Half)

Converte explicitamente um Int64 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(IntPtr to Half)

Converte explicitamente um IntPtr valor para o 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 .Half
Explicit(UInt16 to Half)

Converte explicitamente um UInt16 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(UInt32 to Half)

Converte explicitamente um UInt32 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(UInt64 to Half)

Converte explicitamente um UInt64 valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Explicit(UIntPtr to Half)

Converte explicitamente um UIntPtr valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
GreaterThan(Half, Half)

Devolve um valor que indica se um valor especificado Half é maior do que outro valor especificado Half .
GreaterThanOrEqual(Half, Half)

Devolve um valor que indica se left é maior ou igual a right.
Implicit(Byte to Half)

Converte implicitamente um Byte valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Implicit(SByte to Half)

Converte implicitamente um SByte valor para o valor de ponto flutuante de meia-precisão representável mais próximo.
Increment(Half)

Incrementa um valor.
Inequality(Half, Half)

Devolve um valor que indica se dois valores especificados Half não são iguais.
LessThan(Half, Half)

Devolve um valor que indica se um valor especificado Half é inferior a outro valor especificado Half .
LessThanOrEqual(Half, Half)

Devolve um valor que indica se um valor especificado Half é menor ou igual a outro valor especificado Half .
Modulus(Half, Half)

Divide dois valores para calcular o seu módulo ou resto.
Multiply(Half, Half)

Multiplica dois valores juntos para calcular o seu produto.
Subtraction(Half, Half)

Subtrai dois valores para calcular a sua diferença.
UnaryNegation(Half)

Calcula a negação unária de um valor.
UnaryPlus(Half)

Calcula o plus unário de um valor.

Implementações de Interface Explícita

Name 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 em que todos os bits estão definidos.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)

Calcula o bit a bit de dois valores.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)

Calcula o bit-or-ou de dois valores.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)

Calcula o ou exclusivo de dois valores.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)

Calcula a representação de um complemento de um dado valor.
IFloatingPoint<Half>.GetExponentByteCount()

Obtém o número de bytes que serão escritos como parte de TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()

Obtém o comprimento, em bits, da representação do complemento dos dois mais curtos do expoente atual.
IFloatingPoint<Half>.GetSignificandBitLength()

Obtém o comprimento, em pedaços, do significado atual.
IFloatingPoint<Half>.GetSignificandByteCount()

Obtém o número de bytes que serão escritos como parte de TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)

Tenta escrever o expoente atual, em formato big-endian, para um determinado intervalo.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)

Tenta escrever o expoente atual, em formato little-endian, para um determinado intervalo.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)

Tenta escrever o significado atual, em formato big-endian, para um determinado intervalo.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Tenta escrever o significado atual, em formato little-endian, para um determinado intervalo.
INumberBase<Half>.IsCanonical(Half)

Determina se um valor está na 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 puramente imaginário.
INumberBase<Half>.IsZero(Half)

Determina se um valor é zero.
INumberBase<Half>.Radix

Obtém a raiz, ou 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 para outro tipo, lançando uma exceção de overflow para quaisquer valores que estejam fora do intervalo representável do tipo atual.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)

Tenta converter uma instância do tipo atual para outro tipo, saturando quaisquer valores que estejam fora do intervalo representável do tipo atual.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)

Tenta converter uma instância do tipo atual para outro tipo, truncando quaisquer valores que estejam fora do intervalo representável do tipo atual.

Aplica-se a

Ver também