Half Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine halbgenaue Gleitkommazahl dar.

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>, System::Numerics::IDecrementOperators<Half>, System::Numerics::IDivisionOperators<Half, Half, Half>, System::Numerics::IEqualityOperators<Half, Half>, System::Numerics::IExponentialFunctions<Half>, System::Numerics::IFloatingPoint<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>, System.Numerics.IDecrementOperators<Half>, System.Numerics.IDivisionOperators<Half,Half,Half>, System.Numerics.IEqualityOperators<Half,Half>, System.Numerics.IExponentialFunctions<Half>, System.Numerics.IFloatingPoint<Half>, System.Numerics.IFloatingPointIeee754<Half>, System.Numerics.IHyperbolicFunctions<Half>, System.Numerics.IIncrementOperators<Half>, System.Numerics.ILogarithmicFunctions<Half>, System.Numerics.IMinMaxValue<Half>, System.Numerics.IModulusOperators<Half,Half,Half>, System.Numerics.IMultiplicativeIdentity<Half,Half>, System.Numerics.IMultiplyOperators<Half,Half,Half>, System.Numerics.INumber<Half>, System.Numerics.INumberBase<Half>, System.Numerics.IPowerFunctions<Half>, System.Numerics.IRootFunctions<Half>, System.Numerics.ISignedNumber<Half>, System.Numerics.ISubtractionOperators<Half,Half,Half>, System.Numerics.ITrigonometricFunctions<Half>, System.Numerics.IUnaryNegationOperators<Half,Half>, System.Numerics.IUnaryPlusOperators<Half,Half>

type Half = struct
    interface IFormattable

type Half = struct
    interface ISpanFormattable
    interface IFormattable

type Half = struct
    interface IFormattable
    interface IParsable<Half>
    interface ISpanFormattable
    interface ISpanParsable<Half>
    interface IAdditionOperators<Half, Half, Half>
    interface IAdditiveIdentity<Half, Half>
    interface IBinaryFloatingPointIeee754<Half>
    interface IBinaryNumber<Half>
    interface IBitwiseOperators<Half, Half, Half>
    interface IComparisonOperators<Half, Half>
    interface IEqualityOperators<Half, Half>
    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 IFloatingPoint<Half>
    interface ISignedNumber<Half>
    interface IFloatingPointIeee754<Half>
    interface IHyperbolicFunctions<Half>
    interface ILogarithmicFunctions<Half>
    interface IPowerFunctions<Half>
    interface IRootFunctions<Half>
    interface ITrigonometricFunctions<Half>
    interface IMinMaxValue<Half>

Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), IFormattable

Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), ISpanFormattable

Public Structure Half
Implements IAdditionOperators(Of Half, Half, Half), IAdditiveIdentity(Of Half, Half), IBinaryFloatingPointIeee754(Of Half), IBinaryNumber(Of Half), IBitwiseOperators(Of Half, Half, Half), IComparable(Of Half), IComparisonOperators(Of Half, Half), IDecrementOperators(Of Half), IDivisionOperators(Of Half, Half, Half), IEqualityOperators(Of Half, Half), IEquatable(Of Half), IExponentialFunctions(Of Half), IFloatingPoint(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)

Vererbung

Object

ValueType

Half

Implementiert

IComparable IComparable<Half> IEquatable<Half> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<Half,Half> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<Half> IDecrementOperators<TSelf> IDivisionOperators<Half,Half,Half> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<Half,Half> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> IExponentialFunctions<Half> IExponentialFunctions<TSelf> IFloatingPoint<Half> IFloatingPoint<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>

Hinweise

Der Half Werttyp stellt eine halbgenaue 16-Bit-Zahl mit Werten dar, die zwischen negativen 65.504 und positiven 65.504 und positiven oder negativen NullenPositiveInfinityNegativeInfinity, und nicht einer Zahl (NaN) reichen.

Dies ist ein IEEE 754-kompatibler float16 Typ.

Eigenschaften

E	Ruft die mathematische Konstante e ab.
Epsilon	Stellt den kleinsten positiven Half-Wert dar, der größer als 0 (null) ist.
MaxValue	Stellt den größtmöglichen Wert von Half dar.
MinValue	Stellt den kleinstmöglichen Wert von Half dar.
MultiplicativeIdentity	Ruft die multipliplizierte Identität des aktuellen Typs ab.
NaN	Stellt keine Zahl dar.
NegativeInfinity	Stellt minus unendlich dar.
NegativeOne	Ruft den Wert -1 für den Typ ab.
NegativeZero	Ruft einen Wert ab, der negative Null darstellt.
One	Ruft den Wert 1 für den Typ ab.
Pi	Ruft die mathematische Konstante pi ab.
PositiveInfinity	Stellt plus unendlich dar.
Tau	Ruft die mathematische Konstante tau ab.
Zero	Ruft den Wert 0 für den Typ ab.

Methoden

Abs(Half)	Berechnet das Absolute eines Werts.
Acos(Half)	Berechnet den Bogenkosinus eines Werts.
Acosh(Half)	Berechnet den hyperbolischen Bogenkosinus eines Werts.
AcosPi(Half)	Berechnet den Bogenkosinus eines Werts und dividiert das Ergebnis durch pi.
Asin(Half)	Berechnet den Bogensinus eines Werts.
Asinh(Half)	Berechnet den hyperbolischen Bogensinus eines Werts.
AsinPi(Half)	Berechnet den Bogensinus eines Werts und dividiert das Ergebnis durch pi.
Atan(Half)	Berechnet den Bogen-Tangens eines Werts.
Atan2(Half, Half)	Berechnet den Bogen-Tangens des Quotienten von zwei Werten.
Atan2Pi(Half, Half)	Berechnet den Bogen-Tangens für den Quotienten von zwei Werten und teilt das Ergebnis durch pi.
Atanh(Half)	Berechnet den hyperbolischen Bogen-Tangens eines Werts.
AtanPi(Half)	Berechnet den Bogen-Tangens eines Werts und dividiert das Ergebnis durch pi.
BitDecrement(Half)	Erhöht einen Wert auf den kleinsten Wert, der kleiner als ein gegebener Wert vergleicht.
BitIncrement(Half)	Erhöht einen Wert auf den kleinsten Wert, der größer als ein gegebener Wert ist.
Cbrt(Half)	Berechnet den Cubestamm eines Werts.
Ceiling(Half)	Berechnet die Obergrenze eines Werts.
Clamp(Half, Half, Half)	Klammert einen Wert auf einen inklusiven Mindest- und Höchstwert.
CompareTo(Half)	Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit halber Genauigkeit und gibt eine Ganzzahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der angegebenen Gleitkommazahl mit halber Genauigkeit ist oder mit dieser übereinstimmt.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
CopySign(Half, Half)	Kopiert das Zeichen eines Werts in das Zeichen eines anderen Werts.
Cos(Half)	Berechnet den Kosinus eines Werts.
Cosh(Half)	Berechnet den hyperbolischen Kosinus eines Werts.
CosPi(Half)	Berechnet den Kosinus eines Werts, der von pi multiziert wurde.
Equals(Half)	Vergleicht diese Instanz auf Gleichheit mit other.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich dem angegebenen obj ist.
Exp(Half)	Berechnet E auf eine bestimmte Leistung.
Exp10(Half)	Berechnet 10 , der auf eine bestimmte Leistung ausgelöst wird.
Exp10M1(Half)	Berechnet 10 , die auf eine bestimmte Leistung ausgelöst werden, und subtrahiert eine.
Exp2(Half)	Berechnet 2 , die auf eine bestimmte Leistung ausgelöst wird.
Exp2M1(Half)	Berechnet 2 , der auf eine bestimmte Leistung ausgelöst wird, und subtrahiert eine.
ExpM1(Half)	Berechnet E , der auf eine bestimmte Leistung ausgelöst wird, und subtrahiert eine.
Floor(Half)	Berechnet den Boden eines Werts.
FusedMultiplyAdd(Half, Half, Half)	Berechnet das fused multiplizierte Add von drei Werten.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
Hypot(Half, Half)	Berechnet die Hypotenuse mit zwei Werten, die die Längen der kürzeren Seiten in einem rechtswinkeligen Dreieck darstellen.
Ieee754Remainder(Half, Half)	Berechnet den Rest von zwei Werten, wie durch IEEE 754 angegeben.
ILogB(Half)	Berechnet den ganzzahligen Logarithmus eines Werts.
IsEvenInteger(Half)	Bestimmt, ob ein Wert eine gerade integrale Zahl darstellt.
IsFinite(Half)	Diese Methode bestimmt, ob der Wert endlich ist (Null, subnormal oder normal).
IsInfinity(Half)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.
IsInteger(Half)	Bestimmt, ob ein Wert einen integralen Wert darstellt.
IsNaN(Half)	Bestimmt, ob der angegebene Wert keine Zahl ist.
IsNegative(Half)	Bestimmt, ob der angegebene Wert negativ ist.
IsNegativeInfinity(Half)	Bestimmt, ob der angegebene Wert negativ unendlich ist.
IsNormal(Half)	Bestimmt, ob der angegebene Wert normal ist.
IsOddInteger(Half)	Bestimmt, ob ein Wert eine ungerade integrale Zahl darstellt.
IsPositive(Half)	Bestimmt, ob ein Wert positiv ist.
IsPositiveInfinity(Half)	Bestimmt, ob der angegebene Wert positiv unendlich ist.
IsPow2(Half)	Bestimmt, ob ein Wert eine Leistung von zwei ist.
IsRealNumber(Half)	Bestimmt, ob ein Wert eine echte Zahl darstellt.
IsSubnormal(Half)	Bestimmt, ob der angegebene Wert subnormal ist.
Log(Half)	Berechnet den natürlichen (Basis-E-Logarithmus eines Werts).
Log(Half, Half)	Berechnet den Logarithmus eines Werts in der angegebenen Basis.
Log10(Half)	Berechnet den Basis-10-Logarithmus eines Werts.
Log10P1(Half)	Berechnet den Basis-10-Logarithmus eines Werts plus eins.
Log2(Half)	Berechnet das Protokoll2 eines Werts.
Log2P1(Half)	Berechnet den Basis-2-Logarithmus eines Werts plus eins.
LogP1(Half)	Berechnet den natürlichen (Basis-E)-Logarithmus eines Werts plus einem Wert.
Max(Half, Half)	Vergleicht zwei Werte, um zu berechnen, was größer ist.
MaxMagnitude(Half, Half)	Vergleicht zwei Werte, um zu berechnen, was größer ist.
MaxMagnitudeNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die über die größere Größe verfügt und den anderen Wert zurückgibt, wenn eine Eingabe NaN ist.
MaxNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaN ist.
Min(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitudeNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist und den anderen Wert zurückgibt, wenn eine Eingabe NaN ist.
MinNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist und den anderen Wert zurückgibt, wenn eine Eingabe NaN ist.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert einen Bereich von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Pow(Half, Half)	Berechnet einen Wert, der auf eine bestimmte Leistung ausgelöst wird.
ReciprocalEstimate(Half)	Berechnet eine Schätzung der Gegenseitigkeit eines Werts.
ReciprocalSqrtEstimate(Half)	Berechnet eine Schätzung der gegenseitigen Quadratwurzel eines Werts.
Round(Half)	Rundet einen Wert auf die nächste ganze Zahl mit dem Standardrundenmodus (ToEven).
Round(Half, Int32)	Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven).
Round(Half, Int32, MidpointRounding)	Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven).
Round(Half, MidpointRounding)	Rundet einen Wert mit dem angegebenen Rundungsmodus auf die nächste ganze Zahl ab.
ScaleB(Half, Int32)	Berechnet das Produkt eines Werts und dessen Basisradix auf die angegebene Leistung.
Sign(Half)	Berechnet das Zeichen eines Werts.
Sin(Half)	Berechnet den Sinus eines Werts.
SinCos(Half)	Berechnet den Sinus und den Kosinus eines Werts.
Sinh(Half)	Berechnet den hyperbolischen Sinus eines Werts.
SinPi(Half)	Berechnet den Sinus eines Werts, der mit pi multipliziert wurde.
Sqrt(Half)	Berechnet die Quadratwurzel eines Werts.
Tan(Half)	Berechnet den Tangenten eines Werts.
Tanh(Half)	Berechnet den hyperbolischen Tangens eines Werts.
TanPi(Half)	Berechnet den Tangenten eines Werts, der von pi multiziert wurde.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Truncate(Half)	Schneidet einen Wert ab.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Half-Instanz in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Char>, Half)	Konvertiert die Bereichsdarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Konvertiert die Bereichsdarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, Half)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, IFormatProvider, Half)
TryParse(String, NumberStyles, IFormatProvider, Half)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Operatoren

Addition(Half, Half)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
CheckedExplicit(Half)
Decrement(Half)	Erhöht einen Wert.
Division(Half, Half)	Teilt zwei Werte zusammen, um ihren Quotienten zu berechnen.
Equality(Half, Half)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Half-Werte gleich sind.
Explicit(Char to Half)	Wandelt einen Char Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(Decimal to Half)	Wandelt einen Decimal Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(Double to Half)	Ein expliziter Operator zum Konvertieren eines Double-Werts in einen Half-Wert.
Explicit(Half to Byte)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Byte Wert.
Explicit(Half to Char)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Char Wert.
Explicit(Half to Decimal)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Decimal Wert.
Explicit(Half to Double)	Ein expliziter Operator zum Konvertieren eines Half-Werts in einen Double-Wert.
Explicit(Half to Int128)	Konvertiert explizit einen halbgenauen Gleitkommawert in seine nächste Darstellung Int128.
Explicit(Half to Int16)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Int16 Wert.
Explicit(Half to Int32)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Int32 Wert.
Explicit(Half to Int64)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen Int64 Wert.
Explicit(Half to IntPtr)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen IntPtr Wert.
Explicit(Half to SByte)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen SByte Wert.
Explicit(Half to Single)	Ein expliziter Operator zum Konvertieren eines Half-Werts in einen Single-Wert.
Explicit(Half to UInt128)	Konvertiert explizit einen halbgenauen Gleitkommawert in seine nächste Darstellung UInt128.
Explicit(Half to UInt16)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen UInt16 Wert.
Explicit(Half to UInt32)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen UInt32 Wert.
Explicit(Half to UInt64)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen UInt64 Wert.
Explicit(Half to UIntPtr)	Konvertiert explizit einen halbgenauen Gleitkommawert in den nächsten repräsentativen UIntPtr Wert.
Explicit(Int16 to Half)	Wandelt einen Int16 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(Int32 to Half)	Wandelt einen Int32 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(Int64 to Half)	Wandelt einen Int64 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(IntPtr to Half)	Wandelt einen IntPtr Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(Single to Half)	Ein expliziter Operator zum Konvertieren eines Single-Werts in einen Half-Wert.
Explicit(UInt16 to Half)	Wandelt einen UInt16 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(UInt32 to Half)	Wandelt einen UInt32 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(UInt64 to Half)	Wandelt einen UInt64 Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
Explicit(UIntPtr to Half)	Wandelt einen UIntPtr Wert explizit in seinen nächsten repräsentativen halbgenauen Gleitkommawert um.
GreaterThan(Half, Half)	Gibt einen Wert zurück, der angibt, ob ein angegebener Half-Wert größer als ein anderer angegebener Half-Wert ist.
GreaterThanOrEqual(Half, Half)	Gibt einen Wert zurück, der angibt, ob left größer als right oder gleich groß ist.
Implicit(Byte to Half)	Wandelt implizit einen Byte Wert in seinen nächstgelegenen, bestellbaren gleitkommagenauen Gleitkommawert um.
Implicit(SByte to Half)	Wandelt implizit einen SByte Wert in seinen nächstgelegenen, bestellbaren gleitkommagenauen Gleitkommawert um.
Increment(Half)	Erhöht einen Wert.
Inequality(Half, Half)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Half-Werte gleich sind.
LessThan(Half, Half)	Gibt einen Wert zurück, der angibt, ob ein angegebener Half-Wert größer als ein anderer angegebener Half-Wert ist.
LessThanOrEqual(Half, Half)	Gibt einen Wert zurück, der angibt, ob ein angegebener Half -Wert kleiner oder gleich einem anderen angegebenen Half-Wert ist.
Modulus(Half, Half)	Dividiert zwei Werte, um das Modul oder den Rest zu berechnen.
Multiply(Half, Half)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
Subtraction(Half, Half)	Subtrahiert zwei Werte, um ihre Differenz zu berechnen.
UnaryNegation(Half)	Berechnet die nichtäre Negation eines Werts.
UnaryPlus(Half)	Berechnet das unäre Plus eines Werts.

Explizite Schnittstellenimplementierungen

IFloatingPoint<Half>.GetExponentByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()	Ruft die Länge in Bits der kürzesten Ergänzungsdarstellung des aktuellen Exponenten ab.
IFloatingPoint<Half>.GetSignificandBitLength()	Ruft die Länge des aktuellen Zeichens in Bits ab.
IFloatingPoint<Half>.GetSignificandByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten im Big-End-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten in einem kleinen endischen Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Versucht, das aktuelle Significand im Big-End-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Versucht, das aktuelle Significand in einem kleinen endischen Format in eine bestimmte Spanne zu schreiben.

Siehe auch

• Single