Half Struktur

Definition

Stellt eine Gleitkommazahl mit halber Genauigkeit 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, 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<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>
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
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>
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>
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)
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
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 Half Werttyp stellt eine 16-Bit-Zahl mit halber Genauigkeit mit Werten von negativer 65.504 bis positiver 65.504 sowie positiver oder negativer Null, PositiveInfinity, , NegativeInfinityund nicht einer Zahl (NaN) dar.

Dies ist ein IEEE 754-konformer float16 Typ.

Eigenschaften

E

Ruft die mathematische Konstante eab.

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 multiplikative 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 das negative zerodarstellt.

One

Ruft den Wert 1 für den Typ ab.

Pi

Ruft die mathematische Konstante piab.

PositiveInfinity

Stellt plus unendlich dar.

Tau

Ruft die mathematische Konstante tauab.

Zero

Ruft den Wert 0 für den Typ ab.

Methoden

Abs(Half)

Berechnet das Absolute eines Werts.

Acos(Half)

Berechnet den Arc-Kosinus eines Werts.

Acosh(Half)

Berechnet den hyperbolischen Arc-Kosinus eines Werts.

AcosPi(Half)

Berechnet den Arc-Kosinus eines Werts und dividiert das Ergebnis durch pi.

Asin(Half)

Berechnet den Arc-Sinus eines Werts.

Asinh(Half)

Berechnet den hyperbolischen Arc-Sinus eines Werts.

AsinPi(Half)

Berechnet den Arc-Sinus eines Werts und dividiert das Ergebnis durch pi.

Atan(Half)

Berechnet den Arc-Tangens eines Werts.

Atan2(Half, Half)

Berechnet den Arc-Tangens des Quotienten von zwei Werten.

Atan2Pi(Half, Half)

Berechnet den Arc-Tangens für den Quotienten zweier Werte und dividiert das Ergebnis durch pi.

Atanh(Half)

Berechnet den hyperbolischen Arc-Tangens eines Werts.

AtanPi(Half)

Berechnet den Arc-Tangens eines Werts und dividiert das Ergebnis durch pi.

BitDecrement(Half)

Dekrementiert einen Wert auf den kleinsten Wert, der kleiner als ein gegebener Wert ist.

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)

Klemmt einen Wert auf einen inklusiven Minimal- 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 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 mit pimultimultiziert wurde.

CreateChecked<TOther>(TOther)

Erstellt eine instance 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 instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

CreateTruncating<TOther>(TOther)

Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

DegreesToRadians(Half)

Konvertiert einen angegebenen Wert von Grad in Bogenmaß.

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)

Computevorgänge werden E auf eine bestimmte Leistung angehoben.

Exp10(Half)

Computevorgänge werden 10 auf eine bestimmte Leistung angehoben.

Exp10M1(Half)

10 Berechnet auf eine bestimmte Leistung und subtrahiert eine.

Exp2(Half)

Computevorgänge werden 2 auf eine bestimmte Leistung angehoben.

Exp2M1(Half)

2 Berechnet auf eine bestimmte Leistung und subtrahiert eine.

ExpM1(Half)

E Berechnet auf eine bestimmte Leistung und subtrahiert eine.

Floor(Half)

Berechnet den Boden eines Werts.

FusedMultiplyAdd(Half, Half, Half)

Berechnet die verschmolzene Multiplikation 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, wie in IEEE 754 angegeben.

ILogB(Half)

Berechnet den ganzzahligen Logarithmus eines Werts.

IsEvenInteger(Half)

Bestimmt, ob ein Wert eine gerade ganzzahlige 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 ganzzahlige 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 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 Basis-10-Logarithmus eines Werts.

Log10P1(Half)

Berechnet den Basis-10-Logarithmus eines Werts plus 1.

Log2(Half)

Berechnet das Protokoll2 eines Werts.

Log2P1(Half)

Berechnet den Basis-2-Logarithmus eines Werts plus eins.

LogP1(Half)

Berechnet den natürlichen Logarithmus (base-E) eines Werts plus eins.

Max(Half, Half)

Vergleicht zwei Werte mit einem höheren Computewert.

MaxMagnitude(Half, Half)

Vergleicht zwei Werte mit einem höheren Computewert.

MaxMagnitudeNumber(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die die größere Größe hat, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

MaxNumber(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, 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 einer Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

MinNumber(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

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 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 angehoben wird.

RadiansToDegrees(Half)

Konvertiert einen angegebenen Wert vom Bogenmaß in Grad.

ReciprocalEstimate(Half)

Berechnet eine Schätzung des Kehrwerts eines Werts.

ReciprocalSqrtEstimate(Half)

Berechnet eine Schätzung der reziproken Quadratwurzel eines Werts.

RootN(Half, Int32)

Berechnet den n-ten Stamm eines Werts.

Round(Half)

Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf die nächste ganze Zahl.

Round(Half, Int32)

Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.

Round(Half, Int32, MidpointRounding)

Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.

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 Basisradix, der 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 den 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 mit pimultimultiziert 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<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert des aktuellen instance 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 angegebene Zeichenspanne zu formatieren.

TryParse(ReadOnlySpan<Byte>, Half)

Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in die entsprechende Gleitkommazahl mit halber Genauigkeit zu konvertieren.

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 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, eine Spanne 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)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

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 deren Summe zu berechnen.

CheckedExplicit(Half)

Stellt eine Gleitkommazahl mit halber Genauigkeit dar.

Decrement(Half)

Verringert einen Wert.

Division(Half, Half)

Dividiert zwei Werte, 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)

Konvertiert einen Char Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(Decimal to Half)

Konvertiert einen Decimal Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(Double to Half)

Ein expliziter Operator zum Konvertieren eines Double-Werts in einen Half-Wert.

Explicit(Half to Byte)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Byte Wert.

Explicit(Half to Char)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Char Wert.

Explicit(Half to Decimal)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren 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 Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Int128.

Explicit(Half to Int16)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Int16 Wert.

Explicit(Half to Int32)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Int32 Wert.

Explicit(Half to Int64)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren Int64 Wert.

Explicit(Half to IntPtr)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren IntPtr Wert.

Explicit(Half to SByte)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren 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 Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UInt128.

Explicit(Half to UInt16)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UInt16 Wert.

Explicit(Half to UInt32)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UInt32 Wert.

Explicit(Half to UInt64)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UInt64 Wert.

Explicit(Half to UIntPtr)

Konvertiert explizit einen Gleitkommawert mit halber Genauigkeit in den nächsten darstellbaren UIntPtr Wert.

Explicit(Int16 to Half)

Konvertiert einen Int16 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(Int32 to Half)

Konvertiert einen Int32 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(Int64 to Half)

Konvertiert einen Int64 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(IntPtr to Half)

Konvertiert einen IntPtr Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(Single to Half)

Ein expliziter Operator zum Konvertieren eines Single-Werts in einen Half-Wert.

Explicit(UInt16 to Half)

Konvertiert einen UInt16 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(UInt32 to Half)

Konvertiert einen UInt32 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(UInt64 to Half)

Konvertiert einen UInt64 Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Explicit(UIntPtr to Half)

Konvertiert einen UIntPtr Wert explizit in den nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

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)

Konvertiert einen Wert implizit in den Byte nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

Implicit(SByte to Half)

Konvertiert einen Wert implizit in den SByte nächsten darstellbaren Gleitkommawert mit halber Genauigkeit.

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 ihren Modulus oder Rest zu berechnen.

Multiply(Half, Half)

Multipliziert zwei Werte, um ihr Produkt zu berechnen.

Subtraction(Half, Half)

Subtrahiert zwei Werte, um deren Differenz zu berechnen.

UnaryNegation(Half)

Berechnet die unäre Negation eines Werts.

UnaryPlus(Half)

Berechnet das unäre Plus eines Werts.

Explizite Schnittstellenimplementierungen

IAdditiveIdentity<Half,Half>.AdditiveIdentity

Ruft die additive Identität des aktuellen Typs ab.

IBinaryNumber<Half>.AllBitsSet

Ruft eine instance des binären Typs ab, in dem alle Bits festgelegt sind.

IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)

Berechnet das bitweise und von zwei Werten.

IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)

Berechnet das bitweise oder von zwei Werten.

IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)

Berechnet den exklusiven oder von zwei Werten.

IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)

Berechnet die Eins-Komplement-Darstellung eines angegebenen 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 der Komplementdarstellung des aktuellen Exponenten in Bits ab.

IFloatingPoint<Half>.GetSignificandBitLength()

Ruft die Länge des aktuellen Significand 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-Endian-Format in eine bestimmte Spanne zu schreiben.

IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)

Versucht, den aktuellen Exponenten im Little-Endian-Format in eine bestimmte Spanne zu schreiben.

IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)

Versucht, die aktuelle Significand im Big-Endian-Format in eine bestimmte Spanne zu schreiben.

IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Versucht, den aktuellen Significand im 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 0 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 instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch eine Überlaufausnahme für alle Werte ausgelöst wird, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)

Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen, gesättigt werden.

INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)

Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

Gilt für:

Weitere Informationen