Half Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

Half.cs

Stellt eine Gleitkommazahl mit halber Genauigkeit dar.

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)

Vererbung

Object

ValueType

Half

Implementiert

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>

Hinweise

Der werttyp Half stellt eine 16-Bit-Zahl mit halber Genauigkeit mit Werten zwischen negativen 65.504 und positiven 65.504 sowie positiven oder negativen Nullen, PositiveInfinity, NegativeInfinityund keine Zahl (NaN) dar.

Dies ist ein IEEE 754-kompatibler float16 Typ.

Eigenschaften

E	Ruft die mathematische Konstante eab.
Epsilon	Stellt den kleinsten positiven Half Wert dar, der größer als Null ist.
MaxValue	Stellt den größten möglichen Wert von Halfdar.
MinValue	Stellt den kleinsten möglichen Wert von Halfdar.
MultiplicativeIdentity	Ruft die multiplizierte Identität des aktuellen Typs ab.
NaN	Stellt keine Zahl dar.
NegativeInfinity	Stellt negative Unendlichkeit dar.
NegativeOne	Ruft den Wert -1 für den Typ ab.
NegativeZero	Ruft einen Wert ab, der negative zerodarstellt.
One	Ruft den Wert 1 für den Typ ab.
Pi	Ruft die mathematische Konstante piab.
PositiveInfinity	Stellt positive Unendlichkeit dar.
Tau	Ruft die mathematische Konstante tauab.
Zero	Ruft den Wert 0 für den Typ ab.

Methoden

Abs(Half)	Berechnet den absoluten Wert.
Acos(Half)	Berechnet den Arkuskosinus eines Werts.
Acosh(Half)	Berechnet den hyperbolischen Arkuskosinus eines Werts.
AcosPi(Half)	Berechnet den Arkuskosinus eines Werts und dividiert das Ergebnis durch pi.
Asin(Half)	Berechnet den Arkussinus eines Werts.
Asinh(Half)	Berechnet den hyperbolischen Arkussinus eines Werts.
AsinPi(Half)	Berechnet den Arkussinus 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 zweier Werte.
Atan2Pi(Half, Half)	Berechnet den Bogen-Tangens für den Quotienten zweier Werte und dividiert 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)	Dekrementiert 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 Minimal- und Maximalwert.
CompareTo(Half)	Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit halber Genauigkeit und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert der angegebenen Gleitkommazahl mit halber Genauigkeit ist.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert des angegebenen Objekts ist.
CopySign(Half, Half)	Kopiert das Vorzeichen eines Werts in das Vorzeichen 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 pimultiziert wurde.
CreateChecked<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte gesättigt werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
DegreesToRadians(Half)	Wandelt einen bestimmten Wert von Grad in Bogenmaß um.
Equals(Half)	Vergleicht diese Instanz für die Gleichheit mit other.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz dem angegebenen objentspricht.
Exp(Half)	Berechnet E auf eine bestimmte Leistung erhöht.
Exp10(Half)	Berechnet 10 auf eine bestimmte Leistung erhöht.
Exp10M1(Half)	Berechnet 10 auf eine bestimmte Potenz ausgelöst und subtrahiert eine.
Exp2(Half)	Berechnet 2 auf eine bestimmte Leistung erhöht.
Exp2M1(Half)	Berechnet 2 auf eine bestimmte Potenz ausgelöst und subtrahiert eine.
ExpM1(Half)	Berechnet E auf eine bestimmte Potenz ausgelöst 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 rechtwinkligen Dreieck darstellen.
Ieee754Remainder(Half, Half)	Berechnet den Rest von zwei Werten gemäß IEEE 754.
ILogB(Half)	Berechnet den ganzzahligen Logarithmus eines Werts.
IsEvenInteger(Half)	Bestimmt, ob ein Wert eine gerade integrale Zahl darstellt.
IsFinite(Half)	Bestimmt, ob der angegebene Wert endlich ist (Null, Unternormal oder Normal).
IsInfinity(Half)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl als positive Unendlichkeit ausgewertet wird.
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 negative Unendlichkeit 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 positive Unendlichkeit ist.
IsPow2(Half)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
IsRealNumber(Half)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
IsSubnormal(Half)	Bestimmt, ob der angegebene Wert subnormal ist.
Lerp(Half, Half, Half)	Führt eine lineare Interpolation zwischen zwei Werten basierend auf der angegebenen Gewichtung aus.
Log(Half)	Berechnet den natürlichen (base-E Logarithmus eines Werts.
Log(Half, Half)	Berechnet den Logarithmus eines Werts in der angegebenen Basis.
Log10(Half)	Berechnet den Logarithmus der Basis 10 eines Werts.
Log10P1(Half)	Berechnet den Logarithmus der Basis 10 eines Werts plus 1.
Log2(Half)	Berechnet das Protokoll2 eines Werts.
Log2P1(Half)	Berechnet den Logarithmus der Basis-2 eines Werts plus 1.
LogP1(Half)	Berechnet den natürlichen (base-E) Logarithmus eines Werts plus 1.
Max(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
MaxMagnitude(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
MaxMagnitudeNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
MaxNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
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 NaNist.
MinNumber(Half, Half)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die Gleitkommazahläquivalent mit halber Genauigkeit.
Parse(String, IFormatProvider)	Wandelt die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit um.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit.
Pow(Half, Half)	Berechnet einen Wert, der auf eine bestimmte Leistung erhöht wird.
RadiansToDegrees(Half)	Wandelt einen bestimmten Wert von Bogenmaß in Grad um.
ReciprocalEstimate(Half)	Berechnet eine Schätzung des Kehrwerts eines Werts.
ReciprocalSqrtEstimate(Half)	Berechnet eine Schätzung der gegenseitigen Quadratwurzel eines Werts.
RootN(Half, Int32)	Berechnet die n-th-Stammebene eines Werts.
Round(Half)	Rundet einen Wert auf die nächste ganze Zahl mit dem Standardmäßigen Rundungsmodus (ToEven).
Round(Half, Int32)	Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mit dem standardmäßigen Rundungsmodus (ToEven).
Round(Half, Int32, MidpointRounding)	Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mit dem standardmäßigen Rundungsmodus (ToEven).
Round(Half, MidpointRounding)	Rundet einen Wert mithilfe des angegebenen Rundungsmodus auf die nächste ganze Zahl.
ScaleB(Half, Int32)	Berechnet das Produkt eines Werts und dessen Basisradiix, das auf die angegebene Leistung angehoben wird.
Sign(Half)	Berechnet das Vorzeichen eines Werts.
Sin(Half)	Berechnet den Sinus eines Werts.
SinCos(Half)	Berechnet den Sinus und kosinus eines Werts.
SinCosPi(Half)	Berechnet den Sinus und Kosinus eines Werts, der mit pimultipliziert wurde.
Sinh(Half)	Berechnet den hyperbolischen Sinus eines Werts.
SinPi(Half)	Berechnet den Sinus eines Werts, der mit pimultipliziert wurde.
Sqrt(Half)	Berechnet die Quadratwurzel eines Werts.
Tan(Half)	Berechnet den Tangens eines Werts.
Tanh(Half)	Berechnet den hyperbolischen Tangens eines Werts.
TanPi(Half)	Berechnet den Tangens eines Werts, der von pimultiziert wurde.
ToString()	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um.
ToString(String)	Wandelt den numerischen Wert dieser Instanz mithilfe des angegebenen Formats in die entsprechende Zeichenfolgendarstellung um.
ToString(String, IFormatProvider)	Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um.
Truncate(Half)	Schneidet einen Wert ab.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz als UTF-8 in die bereitgestellte Bytespanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Half Instanz in die bereitgestellte Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Byte>, Half)	Versucht, einen UTF-8-Zeichenbereich zu konvertieren, der die Zeichenfolgendarstellung einer Zahl in dessen Gleitkommazahlenäquivalent mit halber Genauigkeit enthält.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)	Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)	Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, Half)	Konvertiert die Spandarstellung einer Zahl in die Gleitkommazahläquivalent mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Konvertiert die Spandarstellung einer Zahl in die Gleitkommazahläquivalent mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.
TryParse(String, Half)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die Gleitkommazahläquivalent mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.
TryParse(String, IFormatProvider, Half)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, NumberStyles, IFormatProvider, Half)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die Gleitkommazahläquivalent mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.

Operatoren

Addition(Half, Half)	Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
CheckedExplicit(Half)	Stellt eine Gleitkommazahl mit halber Genauigkeit dar.
Decrement(Half)	Erhöht einen Wert.
Division(Half, Half)	Dividiert 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 den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(Decimal to Half)	Wandelt einen Decimal Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(Double to Half)	Ein expliziter Operator zum Konvertieren eines Double-Werts in eine Half.
Explicit(Half to Byte)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Byte Wert um.
Explicit(Half to Char)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Char Wert um.
Explicit(Half to Decimal)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Decimal Wert um.
Explicit(Half to Double)	Ein expliziter Operator zum Konvertieren eines Half-Werts in eine Double.
Explicit(Half to Int128)	Wandelt explizit einen Gleitkommawert mit halber Genauigkeit in das nächste darstellbare Int128um.
Explicit(Half to Int16)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Int16 Wert um.
Explicit(Half to Int32)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Int32 Wert um.
Explicit(Half to Int64)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren Int64 Wert um.
Explicit(Half to IntPtr)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren IntPtr Wert um.
Explicit(Half to SByte)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren SByte Wert um.
Explicit(Half to Single)	Ein expliziter Operator zum Konvertieren eines Half-Werts in eine Single.
Explicit(Half to UInt128)	Wandelt explizit einen Gleitkommawert mit halber Genauigkeit in das nächste darstellbare UInt128um.
Explicit(Half to UInt16)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren UInt16 Wert um.
Explicit(Half to UInt32)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren UInt32 Wert um.
Explicit(Half to UInt64)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren UInt64 Wert um.
Explicit(Half to UIntPtr)	Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächstgelegenen darstellbaren UIntPtr Wert um.
Explicit(Int16 to Half)	Wandelt einen Int16 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(Int32 to Half)	Wandelt einen Int32 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(Int64 to Half)	Wandelt einen Int64 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(IntPtr to Half)	Wandelt einen IntPtr Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(Single to Half)	Ein expliziter Operator zum Konvertieren eines Single-Werts in eine Half.
Explicit(UInt16 to Half)	Wandelt einen UInt16 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(UInt32 to Half)	Wandelt einen UInt32 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(UInt64 to Half)	Wandelt einen UInt64 Wert explizit in den nächstgelegenen wert mit halber Genauigkeit gleitkommawert um.
Explicit(UIntPtr to Half)	Wandelt einen UIntPtr Wert explizit in den nächstgelegenen wert mit halber Genauigkeit 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 oder gleich rightist.
Implicit(Byte to Half)	Wandelt einen Byte-Wert implizit in den nächstgelegenen wert mit halber Genauigkeit um.
Implicit(SByte to Half)	Wandelt einen SByte-Wert implizit in den nächstgelegenen wert mit halber Genauigkeit um.
Increment(Half)	Erhöht einen Wert.
Inequality(Half, Half)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Half Werte nicht gleich sind.
LessThan(Half, Half)	Gibt einen Wert zurück, der angibt, ob ein angegebener Half Wert kleiner 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 zusammen, um deren Modul oder 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 unäre Negation eines Werts.
UnaryPlus(Half)	Berechnet das unäre Pluszeichen eines Werts.

Explizite Schnittstellenimplementierungen

IAdditiveIdentity<Half,Half>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryNumber<Half>.AllBitsSet	Ruft eine Instanz des binären Typs ab, in der alle Bits festgelegt sind.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)	Berechnet die bitweise und von zwei Werten.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)	Berechnet die bitweise oder zwei Werte.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)	Berechnet die exklusiven oder zwei Werte.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)	Berechnet die Darstellung eines bestimmten Werts.
IFloatingPoint<Half>.GetExponentByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32)geschrieben werden.
IFloatingPoint<Half>.GetExponentShortestBitLength()	Ruft die Länge in Bits der kürzesten zwei 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)geschrieben werden.
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 Endenformat 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 little-endian-Format in eine bestimmte Spanne zu schreiben.
INumberBase<Half>.IsCanonical(Half)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Half>.IsComplexNumber(Half)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Half>.IsImaginaryNumber(Half)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Half>.IsZero(Half)	Bestimmt, ob ein Wert null ist.
INumberBase<Half>.Radix	Ruft das Radix oder die Basis für den Typ ab.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)	Stellt eine Gleitkommazahl mit halber Genauigkeit dar.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)	Stellt eine Gleitkommazahl mit halber Genauigkeit dar.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)	Stellt eine Gleitkommazahl mit halber Genauigkeit dar.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und alle Werte zu sättigungen, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

Weitere Informationen

• Single