Half Struktur

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Quelle:
Half.cs
Quelle:
Half.cs
Quelle:
Half.cs
Quelle:
Half.cs
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 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)
Vererbung
Object
ValueType
Half
Implementiert
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>

Hinweise

Der Half Werttyp stellt eine 16-Bit-Zahl mit halber Genauigkeit mit Werten dar, die von negativen 65.504 bis positiven 65.504 reichen, sowie positive oder negative Null, PositiveInfinityNegativeInfinityund keine Zahl (NaN).

Dies ist ein IEEE 754-kompatibler float16 Typ.

Eigenschaften

Name Beschreibung
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 Half.
MinValue

Stellt den kleinsten möglichen Wert von Half.
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

Name Beschreibung
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.
ClampNative(Half, Half, Half)

Klammert einen Wert auf einen inklusiven Minimal- und Maximalwert unter Verwendung plattformspezifischer Verhaltensweisen für NaN und NegativeZero.
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.
ConvertToInteger<TInteger>(Half)

Konvertiert einen Wert in einen angegebenen ganzzahligen Typ unter Verwendung der Sättigung beim Überlauf.
ConvertToIntegerNative<TInteger>(Half)

Wandelt einen Wert in einen angegebenen ganzzahligen Typ um, wobei das plattformspezifische Verhalten beim Überlauf verwendet wird.
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 pi.
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 gleichheit mit other.
Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz dem angegebenen objWert entspricht.
Exp(Half)

E Berechnet, die auf eine bestimmte Leistung ausgelöst wird.
Exp10(Half)

10 Berechnet, die auf eine bestimmte Leistung ausgelöst wird.
Exp10M1(Half)

10 Berechnet eine bestimmte Potenz und subtrahiert eins.
Exp2(Half)

2 Berechnet, die auf eine bestimmte Leistung ausgelöst wird.
Exp2M1(Half)

2 Berechnet eine bestimmte Potenz und subtrahiert eins.
ExpM1(Half)

E Berechnet eine bestimmte Potenz und subtrahiert eins.
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 diesen instance 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, Half)

Berechnet den Logarithmus eines Werts in der angegebenen Basis.
Log(Half)

Berechnet den natürlichen (base-E Logarithmus eines Werts).
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, um zu berechnen, die die größere Größe aufweisen und den anderen Wert zurückgeben, wenn eine Eingabe ist NaN.
MaxNative(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die mit plattformspezifischem Verhalten für NaN und NegativeZero.
MaxNumber(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe ist NaN.
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 ist NaN.
MinNative(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die mit plattformspezifischem Verhalten für NaN und NegativeZero.
MinNumber(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist und den anderen Wert zurückgibt, wenn eine Eingabe ist NaN.
MultiplyAddEstimate(Half, Half, Half)

Berechnet eine Schätzung von (left * right) + . addend
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, IFormatProvider)

Wandelt die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit um.
Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit.
Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in dessen Gleitkommazahlenentsprechung mit einfacher Genauigkeit.
Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die Gleitkommazahläquivalent mit halber 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, Int32, MidpointRounding)

Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mithilfe des standardmäßigen Rundungsmodus (ToEven).
Round(Half, Int32)

Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mithilfe des standardmäßigen Rundungsmodus (ToEven).
Round(Half, MidpointRounding)

Rundet einen Wert mithilfe des angegebenen Rundungsmodus auf die nächste ganze Zahl.
Round(Half)

Rundet einen Wert mithilfe des standardmäßigen Rundungsmodus (ToEven) auf die nächste ganze Zahl ab.
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 multipliziert wurde.pi
Sinh(Half)

Berechnet den hyperbolischen Sinus eines Werts.
SinPi(Half)

Berechnet den Sinus eines Werts, der multipliziert wurde.pi
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 pi.
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, IFormatProvider)

Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um.
ToString(String)

Wandelt den numerischen Wert dieser Instanz mithilfe des angegebenen Formats 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

Name Beschreibung
Addition(Half, Half)

Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
CheckedExplicit(Half to Byte)

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 darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(Decimal to Half)

Wandelt einen Decimal Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(Double to Half)

Ein expliziter Operator zum Konvertieren eines Double Werts in ein Half.
Explicit(Half to Byte)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Byte Wert um.
Explicit(Half to Char)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Char Wert um.
Explicit(Half to Decimal)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Decimal Wert um.
Explicit(Half to Double)

Ein expliziter Operator zum Konvertieren eines Half Werts in ein Double.
Explicit(Half to Int128)

Wandelt explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Int128Wert um.
Explicit(Half to Int16)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Int16 Wert um.
Explicit(Half to Int32)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Int32 Wert um.
Explicit(Half to Int64)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren Int64 Wert um.
Explicit(Half to IntPtr)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren IntPtr Wert um.
Explicit(Half to SByte)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren SByte Wert um.
Explicit(Half to Single)

Ein expliziter Operator zum Konvertieren eines Half Werts in ein Single.
Explicit(Half to UInt128)

Wandelt explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UInt128Wert um.
Explicit(Half to UInt16)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren UInt16 Wert um.
Explicit(Half to UInt32)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren UInt32 Wert um.
Explicit(Half to UInt64)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren UInt64 Wert um.
Explicit(Half to UIntPtr)

Wandelt einen Gleitkommawert mit halber Genauigkeit explizit in den nächsten darstellbaren UIntPtr Wert um.
Explicit(Int16 to Half)

Wandelt einen Int16 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(Int32 to Half)

Wandelt einen Int32 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(Int64 to Half)

Wandelt einen Int64 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(IntPtr to Half)

Wandelt einen IntPtr Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(Single to Half)

Ein expliziter Operator zum Konvertieren eines Single Werts in ein Half.
Explicit(UInt16 to Half)

Wandelt einen UInt16 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(UInt32 to Half)

Wandelt einen UInt32 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(UInt64 to Half)

Wandelt einen UInt64 Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit um.
Explicit(UIntPtr to Half)

Wandelt einen UIntPtr Wert explizit in den nächstgelegenen darstellbaren Gleitkommawert mit halber Genauigkeit 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 seinen nächsten darstellbaren Gleitkommawert mit halber Genauigkeit um.
Implicit(SByte to Half)

Wandelt einen SByte Wert implizit in seinen nächsten darstellbaren Gleitkommawert 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

Name Beschreibung
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).
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).
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 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.

Gilt für:

Weitere Informationen