Half Structure

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Source:

Half.cs

Représente un nombre à virgule flottante demi-précision.

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

Héritage

Object

ValueType

Half

Implémente

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>

Remarques

Le Half type de valeur représente un nombre 16 bits à demi-précision avec des valeurs allant de 65 504 négatifs à 65 504 positifs, ainsi que zéro positif ou négatif, PositiveInfinity, NegativeInfinityet non un nombre (NaN).

Il s’agit d’un type conforme à float16 IEEE 754.

Propriétés

E	Obtient la constante emathématique .
Epsilon	Représente la valeur Half positive la plus petite qui est supérieure à zéro.
MaxValue	Représente la plus grande valeur possible de Half.
MinValue	Représente la plus petite valeur possible de Half.
MultiplicativeIdentity	Obtient l’identité multiplicative du type actuel.
NaN	Représente une valeur autre qu'un nombre.
NegativeInfinity	Représente l'infini négatif.
NegativeOne	Obtient la valeur -1 du type .
NegativeZero	Obtient une valeur qui représente négatif zero.
One	Obtient la valeur 1 du type .
Pi	Obtient la constante pimathématique .
PositiveInfinity	Représente l'infini positif.
Tau	Obtient la constante taumathématique .
Zero	Obtient la valeur 0 du type .

Méthodes

Abs(Half)	Calcule l’absolu d’une valeur.
Acos(Half)	Calcule l’arc cosinus d’une valeur.
Acosh(Half)	Calcule l’arc-cosinus hyperbolique d’une valeur.
AcosPi(Half)	Calcule l’arc cosinus d’une valeur et divise le résultat par pi.
Asin(Half)	Calcule l’arc-sinus d’une valeur.
Asinh(Half)	Calcule l’arc-sinus hyperbolique d’une valeur.
AsinPi(Half)	Calcule l’arc-sinus d’une valeur et divise le résultat par pi.
Atan(Half)	Calcule la tangente arc d’une valeur.
Atan2(Half, Half)	Calcule la tangente arc du quotient de deux valeurs.
Atan2Pi(Half, Half)	Calcule la tangente d’arc pour le quotient de deux valeurs et divise le résultat par pi.
Atanh(Half)	Calcule la tangente d’arc hyperbolique d’une valeur.
AtanPi(Half)	Calcule la tangente arc d’une valeur et divise le résultat par pi.
BitDecrement(Half)	Décrémente une valeur à la plus petite valeur qui compare moins qu’une valeur donnée.
BitIncrement(Half)	Incrémente une valeur à la plus petite valeur qui compare supérieure à une valeur donnée.
Cbrt(Half)	Calcule la racine du cube d’une valeur.
Ceiling(Half)	Calcule le plafond d’une valeur.
Clamp(Half, Half, Half)	Fixe une valeur à une valeur minimale et maximale inclusive.
CompareTo(Half)	Compare cette instance à un nombre à virgule flottante demi-précision spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à celle du nombre à virgule flottante demi-précision spécifié.
CompareTo(Object)	Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.
CopySign(Half, Half)	Copie le signe d’une valeur dans le signe d’une autre valeur.
Cos(Half)	Calcule le cosinus d’une valeur.
Cosh(Half)	Calcule le cosinus hyperbolique d’une valeur.
CosPi(Half)	Calcule le cosinus d’une valeur qui a été multiple par pi.
CreateChecked<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, lève une exception de dépassement de capacité pour toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.
CreateSaturating<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, saturant toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.
CreateTruncating<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, tronqué toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.
DegreesToRadians(Half)	Convertit une valeur donnée des degrés en radians.
Equals(Half)	Compare cette instance pour déterminer si elle est égale à other.
Equals(Object)	Retourne une valeur indiquant si cette instance est égale au obj spécifié.
Exp(Half)	Calculs déclenchés E à une puissance donnée.
Exp10(Half)	Calculs déclenchés 10 à une puissance donnée.
Exp10M1(Half)	Calculs déclenchés 10 à une puissance donnée et en soustrait une.
Exp2(Half)	Calculs déclenchés 2 à une puissance donnée.
Exp2M1(Half)	Calculs déclenchés 2 à une puissance donnée et en soustrait une.
ExpM1(Half)	Calculs déclenchés E à une puissance donnée et en soustrait une.
Floor(Half)	Calcule le plancher d’une valeur.
FusedMultiplyAdd(Half, Half, Half)	Calcule la multiplication-ajout fusionnée de trois valeurs.
GetHashCode()	Retourne le code de hachage de cette instance.
Hypot(Half, Half)	Calcule l’hypotenuse donnée deux valeurs représentant les longueurs des côtés les plus courts dans un triangle à angle droit.
Ieee754Remainder(Half, Half)	Calcule le reste des deux valeurs spécifiées par IEEE 754.
ILogB(Half)	Calcule le logarithme d’entier d’une valeur.
IsEvenInteger(Half)	Détermine si une valeur représente un nombre intégral pair.
IsFinite(Half)	Détermine si la valeur spécifiée est finie (zéro, inférieure à la normale ou normale).
IsInfinity(Half)	Retourne une valeur indiquant si le nombre spécifié est équivalent à l'infini positif.
IsInteger(Half)	Détermine si une valeur représente une valeur intégrale.
IsNaN(Half)	Détermine si la valeur spécifiée n’est pas un nombre.
IsNegative(Half)	Détermine si la valeur spécifiée est négative.
IsNegativeInfinity(Half)	Détermine si la valeur spécifiée est une infinie négative.
IsNormal(Half)	Détermine si la valeur spécifiée est normale.
IsOddInteger(Half)	Détermine si une valeur représente un nombre intégral impair.
IsPositive(Half)	Détermine si une valeur est positive.
IsPositiveInfinity(Half)	Détermine si la valeur spécifiée est une infinie positive.
IsPow2(Half)	Détermine si une valeur est une puissance de deux.
IsRealNumber(Half)	Détermine si une valeur représente un nombre réel.
IsSubnormal(Half)	Détermine si la valeur spécifiée est inférieure à la normale.
Lerp(Half, Half, Half)	Effectue une interpolation linéaire entre deux valeurs en fonction de la pondération donnée.
Log(Half)	Calcule le logarithme naturel d’unebase-E valeur.
Log(Half, Half)	Calcule le logarithme d’une valeur dans la base spécifiée.
Log10(Half)	Calcule le logarithme de base 10 d’une valeur.
Log10P1(Half)	Calcule le logarithme de base 10 d’une valeur plus un.
Log2(Half)	Calcule le journal2 d’une valeur.
Log2P1(Half)	Calcule le logarithme de base 2 d’une valeur plus un.
LogP1(Half)	Calcule le logarithme naturel (base-E) d’une valeur plus un.
Max(Half, Half)	Compare deux valeurs au calcul, ce qui est supérieur.
MaxMagnitude(Half, Half)	Compare deux valeurs au calcul, ce qui est supérieur.
MaxMagnitudeNumber(Half, Half)	Compare deux valeurs au calcul qui a la plus grande magnitude et retourne l’autre valeur si une entrée est NaN.
MaxNumber(Half, Half)	Compare deux valeurs pour calculer ce qui est supérieur et renvoyer l’autre valeur si une entrée est NaN.
Min(Half, Half)	Compare deux valeurs au calcul, ce qui est inférieur.
MinMagnitude(Half, Half)	Compare deux valeurs au calcul, ce qui est inférieur.
MinMagnitudeNumber(Half, Half)	Compare deux valeurs au calcul qui a la moindre magnitude et retourne l’autre valeur si une entrée est NaN.
MinNumber(Half, Half)	Compare deux valeurs pour calculer ce qui est inférieur et retourner l’autre valeur si une entrée est NaN.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères dans une valeur.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit la chaîne d'un nombre dans un style et un format propres à la culture spécifiés en nombre à virgule flottante simple précision équivalent.
Parse(String)	Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante demi-précision équivalent.
Parse(String, IFormatProvider)	Convertit la chaîne d'un nombre dans un format propre à la culture spécifiée en nombre à virgule flottante simple précision équivalent.
Parse(String, NumberStyles)	Convertit la chaîne d'un nombre dans un style spécifié en nombre à virgule flottante simple précision équivalent.
Parse(String, NumberStyles, IFormatProvider)	Convertit la chaîne d'un nombre dans un style et un format propres à la culture spécifiés en nombre à virgule flottante simple précision équivalent.
Pow(Half, Half)	Calcule une valeur élevée à une puissance donnée.
RadiansToDegrees(Half)	Convertit une valeur donnée de radians en degrés.
ReciprocalEstimate(Half)	Calcule une estimation de la réciproque d’une valeur.
ReciprocalSqrtEstimate(Half)	Calcule une estimation de la racine carrée réciproque d’une valeur.
RootN(Half, Int32)	Calcule la n-ième racine d’une valeur.
Round(Half)	Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi par défaut (ToEven).
Round(Half, Int32)	Arrondit une valeur à un nombre spécifié de chiffres fractionnaires à l’aide du mode d’arrondi par défaut (ToEven).
Round(Half, Int32, MidpointRounding)	Arrondit une valeur à un nombre spécifié de chiffres fractionnaires à l’aide du mode d’arrondi par défaut (ToEven).
Round(Half, MidpointRounding)	Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi spécifié.
ScaleB(Half, Int32)	Calcule le produit d’une valeur et son radix de base élevé à la puissance spécifiée.
Sign(Half)	Calcule le signe d’une valeur.
Sin(Half)	Calcule le sinus d’une valeur.
SinCos(Half)	Calcule le sinus et le cosinus d’une valeur.
SinCosPi(Half)	Calcule le sinus et le cosinus d’une valeur qui a été multipliée par pi.
Sinh(Half)	Calcule le sinus hyperbolique d’une valeur.
SinPi(Half)	Calcule le sinus d’une valeur qui a été multipliée par pi.
Sqrt(Half)	Calcule la racine carrée d’une valeur.
Tan(Half)	Calcule la tangente d’une valeur.
Tanh(Half)	Calcule la tangente hyperbolique d’une valeur.
TanPi(Half)	Calcule la tangente d’une valeur qui a été multipledée par pi.
ToString()	Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.
ToString(IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.
ToString(String)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
ToString(String, IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.
Truncate(Half)	Tronque une valeur.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de la instance actuelle en UTF-8 dans l’étendue d’octets fournie.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance Half actuelle dans la plage de caractères fournie.
TryParse(ReadOnlySpan<Byte>, Half)	Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante de demi-précision.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)	Tente d’analyser une étendue de caractères UTF-8 dans une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)	Tente d’analyser une étendue de caractères UTF-8 dans une valeur.
TryParse(ReadOnlySpan<Char>, Half)	Convertit l’étendue sous forme de chaîne d'un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Tente d’analyser une étendue de caractères dans une valeur.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Convertit l’étendue sous forme de chaîne d'un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.
TryParse(String, Half)	Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.
TryParse(String, IFormatProvider, Half)	Tente d’analyser une chaîne en une valeur.
TryParse(String, NumberStyles, IFormatProvider, Half)	Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

Opérateurs

Addition(Half, Half)	Ajoute deux valeurs ensemble pour calculer leur somme.
CheckedExplicit(Half)	Représente un nombre à virgule flottante demi-précision.
Decrement(Half)	Décrémente une valeur.
Division(Half, Half)	Divise deux valeurs pour calculer leur quotient.
Equality(Half, Half)	Retourne une valeur qui indique si deux valeurs Half spécifiées sont égales.
Explicit(Char to Half)	Convertit explicitement une Char valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(Decimal to Half)	Convertit explicitement une Decimal valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(Double to Half)	Opérateur explicite pour convertir une valeur Double en Half.
Explicit(Half to Byte)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Byte la plus proche.
Explicit(Half to Char)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Char la plus proche.
Explicit(Half to Decimal)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Decimal la plus proche.
Explicit(Half to Double)	Opérateur explicite pour convertir une valeur Half en Double.
Explicit(Half to Int128)	Convertit explicitement une valeur à virgule flottante demi-précision en sa plus proche représentable Int128.
Explicit(Half to Int16)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Int16 la plus proche.
Explicit(Half to Int32)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Int32 la plus proche.
Explicit(Half to Int64)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable Int64 la plus proche.
Explicit(Half to IntPtr)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable IntPtr la plus proche.
Explicit(Half to SByte)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable SByte la plus proche.
Explicit(Half to Single)	Opérateur explicite pour convertir une valeur Half en Single.
Explicit(Half to UInt128)	Convertit explicitement une valeur à virgule flottante demi-précision en sa plus proche représentable UInt128.
Explicit(Half to UInt16)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable UInt16 la plus proche.
Explicit(Half to UInt32)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable UInt32 la plus proche.
Explicit(Half to UInt64)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable UInt64 la plus proche.
Explicit(Half to UIntPtr)	Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentable UIntPtr la plus proche.
Explicit(Int16 to Half)	Convertit explicitement une Int16 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(Int32 to Half)	Convertit explicitement une Int32 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(Int64 to Half)	Convertit explicitement une Int64 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(IntPtr to Half)	Convertit explicitement une IntPtr valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(Single to Half)	Opérateur explicite pour convertir une valeur Single en Half.
Explicit(UInt16 to Half)	Convertit explicitement une UInt16 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(UInt32 to Half)	Convertit explicitement une UInt32 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(UInt64 to Half)	Convertit explicitement une UInt64 valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
Explicit(UIntPtr to Half)	Convertit explicitement une UIntPtr valeur en sa valeur à virgule flottante de demi-précision représentable la plus proche.
GreaterThan(Half, Half)	Retourne une valeur qui indique si une valeur Half spécifique est supérieure à une autre valeur Half spécifique.
GreaterThanOrEqual(Half, Half)	Retourne une valeur qui indique si left est supérieure ou égale à right.
Implicit(Byte to Half)	Convertit implicitement une Byte valeur en sa valeur à virgule flottante de demi-précision représentante la plus proche.
Implicit(SByte to Half)	Convertit implicitement une SByte valeur en sa valeur à virgule flottante de demi-précision représentante la plus proche.
Increment(Half)	Incrémente une valeur.
Inequality(Half, Half)	Retourne une valeur qui indique si deux valeurs Half spécifiées sont différentes.
LessThan(Half, Half)	Retourne une valeur qui indique si une valeur Half spécifique est inférieure à une autre valeur Half spécifique.
LessThanOrEqual(Half, Half)	Retourne une valeur qui indique si une valeur Half spécifique est inférieure ou égale à une autre valeur Half spécifique.
Modulus(Half, Half)	Divise deux valeurs ensemble pour calculer leur module ou leur reste.
Multiply(Half, Half)	Multiplie deux valeurs ensemble pour calculer leur produit.
Subtraction(Half, Half)	Soustrait deux valeurs pour calculer leur différence.
UnaryNegation(Half)	Calcule la négation unaire d’une valeur.
UnaryPlus(Half)	Calcule le plus unaire d’une valeur.

Implémentations d’interfaces explicites

IAdditiveIdentity<Half,Half>.AdditiveIdentity	Obtient l’identité additive du type actuel.
IBinaryNumber<Half>.AllBitsSet	Obtient une instance du type binaire dans lequel tous les bits sont définis.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)	Calcule les valeurs au niveau du bit et de deux valeurs.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)	Calcule au niveau du bit ou de deux valeurs.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)	Calcule les valeurs exclusives ou de deux valeurs.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)	Calcule la représentation du complément des uns d’une valeur donnée.
IFloatingPoint<Half>.GetExponentByteCount()	Obtient le nombre d’octets qui seront écrits dans le cadre de TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()	Obtient la longueur, en bits, de la représentation complémentaire des deux plus courtes de l’exposant actuel.
IFloatingPoint<Half>.GetSignificandBitLength()	Obtient la longueur, en bits, de la significande actuelle.
IFloatingPoint<Half>.GetSignificandByteCount()	Obtient le nombre d’octets qui seront écrits dans le cadre de TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Tente d’écrire l’exposant actuel, au format big-endian, dans une étendue donnée.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Tente d’écrire l’exposant actuel, au format little-endian, dans une étendue donnée.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Tente d’écrire la significande actuelle, au format big-endian, dans une étendue donnée.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Tente d’écrire la significificet actuelle, au format little-endian, dans une étendue donnée.
INumberBase<Half>.IsCanonical(Half)	Détermine si une valeur se trouve dans sa représentation canonique.
INumberBase<Half>.IsComplexNumber(Half)	Détermine si une valeur représente un nombre complexe.
INumberBase<Half>.IsImaginaryNumber(Half)	Détermine si une valeur représente un nombre imaginaire pur.
INumberBase<Half>.IsZero(Half)	Détermine si une valeur est égale à zéro.
INumberBase<Half>.Radix	Obtient la base pour le type.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)	Représente un nombre à virgule flottante demi-précision.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)	Représente un nombre à virgule flottante demi-précision.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)	Représente un nombre à virgule flottante demi-précision.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)	Tente de convertir une instance du type actuel en un autre type, lève une exception de dépassement de capacité pour toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)	Tente de convertir une instance du type actuel en un autre type, en saturant toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)	Tente de convertir une instance du type actuel en un autre type, en tronqué toutes les valeurs qui se trouvent en dehors de la plage représentable du type actuel.

Voir aussi

• Single