Half Structure

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Source:
Half.cs
Source:
Half.cs
Source:
Half.cs
Source:
Half.cs
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 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)
Héritage
Object
ValueType
Half
Implémente
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>

Remarques

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

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

Propriétés

Nom Description
E

Obtient la constante emathématique .
Epsilon

Représente la plus petite valeur positive Half 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 pas 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

Nom Description
Abs(Half)

Calcule l’absolu d’une valeur.
Acos(Half)

Calcule le cosinus arc d’une valeur.
Acosh(Half)

Calcule le cosinus d’arc hyperbolique d’une valeur.
AcosPi(Half)

Calcule le cosinus arc d’une valeur et divise le résultat par pi.
Asin(Half)

Calcule le sinus arc d’une valeur.
Asinh(Half)

Calcule le sinus d’arc hyperbolique d’une valeur.
AsinPi(Half)

Calcule le sinus d’arc 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 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 une valeur 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)

Limite une valeur à une valeur minimale et maximale inclusive.
ClampNative(Half, Half, Half)

Limite une valeur à une valeur minimale et maximale inclusive à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.
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 à la valeur 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é.
ConvertToInteger<TInteger>(Half)

Convertit une valeur en type entier spécifié à l’aide de la saturation sur le dépassement de capacité
ConvertToIntegerNative<TInteger>(Half)

Convertit une valeur en type entier spécifié à l’aide d’un comportement spécifique à la plateforme sur le dépassement de capacité.
CopySign(Half, Half)

Copie le signe d’une valeur au 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ésentée du type actuel.
CreateSaturating<TOther>(TOther)

Crée une instance du type actuel à partir d’une valeur, en saturant toutes les valeurs qui se trouvent en dehors de la plage représentée 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ésentée du type actuel.
DegreesToRadians(Half)

Convertit une valeur donnée de degrés en radians.
Equals(Half)

Compare cette instance pour l’égalité avec other.
Equals(Object)

Retourne une valeur qui indique si cette instance est égale à la valeur spécifiée obj.
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 un.
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 un.
ExpM1(Half)

Calculs déclenchés E à une puissance donnée et en soustrait un.
Floor(Half)

Calcule le plancher d’une valeur.
FusedMultiplyAdd(Half, Half, Half)

Calcule l’addition multipliée fusionnée de trois valeurs.
GetHashCode()

Retourne le code de hachage pour 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 de deux valeurs, comme spécifié par IEEE 754.
ILogB(Half)

Calcule le logarithme 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, subnormal ou normal).
IsInfinity(Half)

Retourne une valeur indiquant si le nombre spécifié est évalué à 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 l’infini négatif.
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 l’infini positif.
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 subnormale.
Lerp(Half, Half, Half)

Effectue une interpolation linéaire entre deux valeurs en fonction du poids donné.
Log(Half, Half)

Calcule le logarithme d’une valeur dans la base spécifiée.
Log(Half)

Calcule le logarithme naturel d’unebase-E valeur.
Log10(Half)

Calcule le logarithme de base 10 d’une valeur.
Log10P1(Half)

Calcule le logarithme de base 10 d’une valeur plus une.
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.
MaxNative(Half, Half)

Compare deux valeurs au calcul qui est plus grande à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.
MaxNumber(Half, Half)

Compare deux valeurs au calcul qui est supérieure et retourne 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 dont la magnitude est inférieure et retourne l’autre valeur si une entrée est NaN.
MinNative(Half, Half)

Compare deux valeurs au calcul, ce qui est inférieur à l’utilisation du comportement spécifique à la plateforme pour NaN et NegativeZero.
MinNumber(Half, Half)

Compare deux valeurs au calcul, ce qui est inférieur et retourne l’autre valeur si une entrée est NaN.
MultiplyAddEstimate(Half, Half, Half)

Calcule une estimation de (left * right) + addend.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analyse une étendue de caractères en une valeur.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante simple précision équivalent.
Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en nombre à virgule flottante simple précision équivalent.
Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante simple précision équivalent.
Parse(String, NumberStyles)

Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié en son équivalent à virgule flottante simple précision.
Parse(String)

Convertit la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante demi-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, Int32, MidpointRounding)

Arrondit une valeur à un nombre spécifié de chiffres fractionnaires à 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, MidpointRounding)

Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi spécifié.
Round(Half)

Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi par défaut (ToEven).
ScaleB(Half, Int32)

Calcule le produit d’une valeur et son rayon 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 multipliée par pi.
Sinh(Half)

Calcule le sinus hyperbolique d’une valeur.
SinPi(Half)

Calcule le sinus d’une valeur 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é multiple par pi.
ToString()

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente.
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 spécifiées.
ToString(String, 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 et au format spécifiés.
ToString(String)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente, à l’aide du format spécifié.
Truncate(Half)

Tronque une valeur.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tente de mettre en forme la valeur de l’instance actuelle en UTF-8 dans l’étendue fournie d’octets.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tente de mettre en forme la valeur de l’instance actuelle Half dans l’étendue fournie de caractères.
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 demi-précision équivalent.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)

Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)

Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Char>, Half)

Convertit la représentation d’étendue d’un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Tente d’analyser une étendue de caractères en une valeur.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Convertit la représentation d’étendue d’un nombre en nombre à virgule flottante demi-précision équivalent. Une valeur de retour indique si la conversion a réussi ou é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 é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 échoué.

Opérateurs

Nom Description
Addition(Half, Half)

Ajoute deux valeurs ensemble pour calculer leur somme.
CheckedExplicit(Half to Byte)

Représente un nombre à virgule flottante demi-précision.
Decrement(Half)

Décrémente une valeur.
Division(Half, Half)

Divise deux valeurs ensemble pour calculer leur quotient.
Equality(Half, Half)

Retourne une valeur qui indique si deux valeurs spécifiées sont égales Half .
Explicit(Char to Half)

Convertit explicitement une Char valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(Decimal to Half)

Convertit explicitement une Decimal valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(Double to Half)

Opérateur explicite pour convertir une Double valeur en .Half
Explicit(Half to Byte)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Byte plus proche.
Explicit(Half to Char)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Char plus proche.
Explicit(Half to Decimal)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Decimal plus proche.
Explicit(Half to Double)

Opérateur explicite pour convertir une Half valeur en .Double
Explicit(Half to Int128)

Convertit explicitement une valeur à virgule flottante demi-précision en sa représentation la Int128plus proche.
Explicit(Half to Int16)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Int16 plus proche.
Explicit(Half to Int32)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Int32 plus proche.
Explicit(Half to Int64)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la Int64 plus proche.
Explicit(Half to IntPtr)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la IntPtr plus proche.
Explicit(Half to SByte)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la SByte plus proche.
Explicit(Half to Single)

Opérateur explicite pour convertir une Half valeur en .Single
Explicit(Half to UInt128)

Convertit explicitement une valeur à virgule flottante demi-précision en sa représentation la UInt128plus proche.
Explicit(Half to UInt16)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la UInt16 plus proche.
Explicit(Half to UInt32)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la UInt32 plus proche.
Explicit(Half to UInt64)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la UInt64 plus proche.
Explicit(Half to UIntPtr)

Convertit explicitement une valeur à virgule flottante demi-précision en sa valeur représentée la UIntPtr plus proche.
Explicit(Int16 to Half)

Convertit explicitement une Int16 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(Int32 to Half)

Convertit explicitement une Int32 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(Int64 to Half)

Convertit explicitement une Int64 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(IntPtr to Half)

Convertit explicitement une IntPtr valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(Single to Half)

Opérateur explicite pour convertir une Single valeur en .Half
Explicit(UInt16 to Half)

Convertit explicitement une UInt16 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(UInt32 to Half)

Convertit explicitement une UInt32 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(UInt64 to Half)

Convertit explicitement une UInt64 valeur en sa valeur à virgule flottante demi-précision la plus proche.
Explicit(UIntPtr to Half)

Convertit explicitement une UIntPtr valeur en sa valeur à virgule flottante demi-précision la plus proche.
GreaterThan(Half, Half)

Retourne une valeur qui indique si une valeur spécifiée Half est supérieure à une autre valeur spécifiée Half .
GreaterThanOrEqual(Half, Half)

Retourne une valeur qui indique si left elle est supérieure ou égale à right.
Implicit(Byte to Half)

Convertit implicitement une Byte valeur en sa valeur à virgule flottante demi-précision la plus proche.
Implicit(SByte to Half)

Convertit implicitement une SByte valeur en sa valeur à virgule flottante demi-précision la plus proche.
Increment(Half)

Incrémente une valeur.
Inequality(Half, Half)

Retourne une valeur qui indique si deux valeurs spécifiées ne sont pas égales Half .
LessThan(Half, Half)

Retourne une valeur qui indique si une valeur spécifiée Half est inférieure à une autre valeur spécifiée Half .
LessThanOrEqual(Half, Half)

Retourne une valeur qui indique si une valeur spécifiée Half est inférieure ou égale à une autre valeur spécifiée Half .
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

Nom Description
IAdditiveIdentity<Half,Half>.AdditiveIdentity

Obtient l’identité additive du type actuel.
IBinaryNumber<Half>.AllBitsSet

Obtient une instance du type binaire dans laquelle 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 les valeurs 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 complète 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ète des deux plus courtes de l’exposant actuel.
IFloatingPoint<Half>.GetSignificandBitLength()

Obtient la longueur, en bits, du signe actuel.
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 le significand actuel, au format big-endian, dans une étendue donnée.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Tente d’écrire le significand actuel, 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 le radix, ou 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ésentée 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ésentée 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ésentée du type actuel.

S’applique à

Voir aussi