Half Struktur

Definition

Stellt eine halbgenaue Gleitkommanummer dar.

public value class Half : IComparable, IComparable<Half>, IEquatable<Half>, IFormattable
public value class Half : IComparable, IComparable<Half>, IEquatable<Half>, ISpanFormattable
public value class Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, System::Numerics::IAdditionOperators<Half, Half, Half>, System::Numerics::IAdditiveIdentity<Half, Half>, System::Numerics::IBinaryFloatingPointIeee754<Half>, System::Numerics::IBinaryNumber<Half>, System::Numerics::IBitwiseOperators<Half, Half, Half>, System::Numerics::IComparisonOperators<Half, Half>, System::Numerics::IDecrementOperators<Half>, System::Numerics::IDivisionOperators<Half, Half, Half>, System::Numerics::IEqualityOperators<Half, Half>, System::Numerics::IExponentialFunctions<Half>, System::Numerics::IFloatingPoint<Half>, System::Numerics::IFloatingPointIeee754<Half>, System::Numerics::IHyperbolicFunctions<Half>, System::Numerics::IIncrementOperators<Half>, System::Numerics::ILogarithmicFunctions<Half>, System::Numerics::IMinMaxValue<Half>, System::Numerics::IModulusOperators<Half, Half, Half>, System::Numerics::IMultiplicativeIdentity<Half, Half>, System::Numerics::IMultiplyOperators<Half, Half, Half>, System::Numerics::INumber<Half>, System::Numerics::INumberBase<Half>, System::Numerics::IPowerFunctions<Half>, System::Numerics::IRootFunctions<Half>, System::Numerics::ISignedNumber<Half>, System::Numerics::ISubtractionOperators<Half, Half, Half>, System::Numerics::ITrigonometricFunctions<Half>, System::Numerics::IUnaryNegationOperators<Half, Half>, System::Numerics::IUnaryPlusOperators<Half, Half>
public readonly struct Half : IComparable, IComparable<Half>, IEquatable<Half>, IFormattable
public readonly struct Half : IComparable, IComparable<Half>, IEquatable<Half>, ISpanFormattable
public readonly struct Half : IComparable<Half>, IEquatable<Half>, IParsable<Half>, ISpanParsable<Half>, System.Numerics.IAdditionOperators<Half,Half,Half>, System.Numerics.IAdditiveIdentity<Half,Half>, System.Numerics.IBinaryFloatingPointIeee754<Half>, System.Numerics.IBinaryNumber<Half>, System.Numerics.IBitwiseOperators<Half,Half,Half>, System.Numerics.IComparisonOperators<Half,Half>, System.Numerics.IDecrementOperators<Half>, System.Numerics.IDivisionOperators<Half,Half,Half>, System.Numerics.IEqualityOperators<Half,Half>, System.Numerics.IExponentialFunctions<Half>, System.Numerics.IFloatingPoint<Half>, System.Numerics.IFloatingPointIeee754<Half>, System.Numerics.IHyperbolicFunctions<Half>, System.Numerics.IIncrementOperators<Half>, System.Numerics.ILogarithmicFunctions<Half>, System.Numerics.IMinMaxValue<Half>, System.Numerics.IModulusOperators<Half,Half,Half>, System.Numerics.IMultiplicativeIdentity<Half,Half>, System.Numerics.IMultiplyOperators<Half,Half,Half>, System.Numerics.INumber<Half>, System.Numerics.INumberBase<Half>, System.Numerics.IPowerFunctions<Half>, System.Numerics.IRootFunctions<Half>, System.Numerics.ISignedNumber<Half>, System.Numerics.ISubtractionOperators<Half,Half,Half>, System.Numerics.ITrigonometricFunctions<Half>, System.Numerics.IUnaryNegationOperators<Half,Half>, System.Numerics.IUnaryPlusOperators<Half,Half>
type Half = struct
    interface IFormattable
type Half = struct
    interface ISpanFormattable
    interface IFormattable
type Half = struct
    interface IFormattable
    interface IParsable<Half>
    interface ISpanFormattable
    interface ISpanParsable<Half>
    interface IAdditionOperators<Half, Half, Half>
    interface IAdditiveIdentity<Half, Half>
    interface IBinaryFloatingPointIeee754<Half>
    interface IBinaryNumber<Half>
    interface IBitwiseOperators<Half, Half, Half>
    interface IComparisonOperators<Half, Half>
    interface IEqualityOperators<Half, Half>
    interface IDecrementOperators<Half>
    interface IDivisionOperators<Half, Half, Half>
    interface IIncrementOperators<Half>
    interface IModulusOperators<Half, Half, Half>
    interface IMultiplicativeIdentity<Half, Half>
    interface IMultiplyOperators<Half, Half, Half>
    interface INumber<Half>
    interface INumberBase<Half>
    interface ISubtractionOperators<Half, Half, Half>
    interface IUnaryNegationOperators<Half, Half>
    interface IUnaryPlusOperators<Half, Half>
    interface IExponentialFunctions<Half>
    interface IFloatingPoint<Half>
    interface ISignedNumber<Half>
    interface IFloatingPointIeee754<Half>
    interface IHyperbolicFunctions<Half>
    interface ILogarithmicFunctions<Half>
    interface IPowerFunctions<Half>
    interface IRootFunctions<Half>
    interface ITrigonometricFunctions<Half>
    interface IMinMaxValue<Half>
Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), IFormattable
Public Structure Half
Implements IComparable, IComparable(Of Half), IEquatable(Of Half), ISpanFormattable
Public Structure Half
Implements IAdditionOperators(Of Half, Half, Half), IAdditiveIdentity(Of Half, Half), IBinaryFloatingPointIeee754(Of Half), IBinaryNumber(Of Half), IBitwiseOperators(Of Half, Half, Half), IComparable(Of Half), IComparisonOperators(Of Half, Half), IDecrementOperators(Of Half), IDivisionOperators(Of Half, Half, Half), IEqualityOperators(Of Half, Half), IEquatable(Of Half), IExponentialFunctions(Of Half), IFloatingPoint(Of Half), IFloatingPointIeee754(Of Half), IHyperbolicFunctions(Of Half), IIncrementOperators(Of Half), ILogarithmicFunctions(Of Half), IMinMaxValue(Of Half), IModulusOperators(Of Half, Half, Half), IMultiplicativeIdentity(Of Half, Half), IMultiplyOperators(Of Half, Half, Half), INumber(Of Half), INumberBase(Of Half), IParsable(Of Half), IPowerFunctions(Of Half), IRootFunctions(Of Half), ISignedNumber(Of Half), ISpanParsable(Of Half), ISubtractionOperators(Of Half, Half, Half), ITrigonometricFunctions(Of Half), IUnaryNegationOperators(Of Half, Half), IUnaryPlusOperators(Of Half, Half)
Vererbung
Implementiert
IComparable IComparable<Half> IEquatable<Half> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> IEquatable<TSelf> IParsable<Half> IParsable<TSelf> ISpanParsable<Half> ISpanParsable<TSelf> IAdditionOperators<Half,Half,Half> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Half,Half> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Half> IBinaryNumber<Half> IBinaryNumber<TSelf> IBitwiseOperators<Half,Half,Half> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Half,Half> IComparisonOperators<TSelf,TSelf> IDecrementOperators<Half> IDecrementOperators<TSelf> IDivisionOperators<Half,Half,Half> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Half,Half> IEqualityOperators<TSelf,TOther> IEqualityOperators<TSelf,TSelf> IExponentialFunctions<Half> IExponentialFunctions<TSelf> IFloatingPoint<Half> IFloatingPoint<TSelf> IFloatingPointIeee754<Half> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Half> IHyperbolicFunctions<TSelf> IIncrementOperators<Half> IIncrementOperators<TSelf> ILogarithmicFunctions<Half> ILogarithmicFunctions<TSelf> IMinMaxValue<Half> IModulusOperators<Half,Half,Half> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Half,Half> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Half,Half,Half> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Half> INumber<TSelf> INumberBase<Half> INumberBase<TSelf> IPowerFunctions<Half> IPowerFunctions<TSelf> IRootFunctions<Half> IRootFunctions<TSelf> ISignedNumber<Half> ISignedNumber<TSelf> ISubtractionOperators<Half,Half,Half> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Half> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Half,Half> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Half,Half> IUnaryPlusOperators<TSelf,TSelf>

Hinweise

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

Dies ist ein IEEE 754-kompatibler float16 Typ.

Eigenschaften

E

Ruft die mathematische Konstante e ab.

Epsilon

Stellt den kleinsten positiven Half-Wert dar, der größer als 0 (null) ist.

MaxValue

Stellt den größtmöglichen Wert von Half dar.

MinValue

Stellt den kleinstmöglichen Wert von Half dar.

MultiplicativeIdentity

Ruft die multipliplizierte Identität des aktuellen Typs ab.

NaN

Stellt keine Zahl dar.

NegativeInfinity

Stellt minus unendlich dar.

NegativeZero

Ruft einen Wert ab, der negative Null darstellt.

Pi

Ruft die mathematische Konstante pi ab.

PositiveInfinity

Stellt plus unendlich dar.

Tau

Ruft die mathematische Konstante tau ab.

Methoden

Abs(Half)

Berechnet das Absolute eines Werts.

Acos(Half)

Berechnet den Arc-Cosine eines Werts.

Acosh(Half)

Berechnet den hyperbolischen Arc-Cosine eines Werts.

Asin(Half)

Berechnet den Bogensine eines Werts.

Asinh(Half)

Berechnet den hyperbolischen Arc-Sine eines Werts.

Atan(Half)

Berechnet den Arc-Tangent eines Werts.

Atan2(Half, Half)

Berechnet den Arc-Tangent des Quotienten von zwei Werten.

Atanh(Half)

Berechnet den hyperbolischen Arc-Tangent eines Werts.

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 Mindest- und Maximalwert.

CompareTo(Half)

Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit halber Genauigkeit und gibt eine Ganzzahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der angegebenen Gleitkommazahl mit halber Genauigkeit ist oder mit dieser übereinstimmt.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.

CopySign(Half, Half)

Kopiert das Zeichen eines Werts in das Zeichen eines anderen Werts..

Cos(Half)

Berechnet die Kosine eines Werts.

Cosh(Half)

Berechnet die hyperbolische Cosine eines Werts.

CreateChecked<TOther>(TOther)

Erstellt eine Instanz des aktuellen Typs aus einem Wert, indem eine Überlaufausnahme für alle Werte ausgelöst wird, die außerhalb des repräsentativen Bereichs des aktuellen Typs liegen.

CreateSaturating<TOther>(TOther)

Erstellt eine Instanz des aktuellen Typs aus einem Wert, Sättigung aller Werte, die außerhalb des repräsentativen Bereichs des aktuellen Typs liegen.

CreateTruncating<TOther>(TOther)

Erstellt eine Instanz des aktuellen Typs aus einem Wert, die alle Werte abschneiden, die außerhalb des repräsentativen Bereichs des aktuellen Typs liegen.

Equals(Half)

Vergleicht diese Instanz auf Gleichheit mit other.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich dem angegebenen obj ist.

Exp(Half)

Berechnet E , die auf eine bestimmte Leistung ausgelöst wird.

Floor(Half)

Berechnet den Boden eines Werts.

FusedMultiplyAdd(Half, Half, Half)

Berechnet das verfügete multiplizierte Add von drei Werten.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

Ieee754Remainder(Half, Half)

Berechnet den Rest von zwei Werten, wie von IEEE 754 angegeben.

ILogB(Half)

Berechnet den ganzzahligen Logarithmus eines Werts.

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.

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.

IsPositiveInfinity(Half)

Bestimmt, ob der angegebene Wert positiv unendlich ist.

IsPow2(Half)

Bestimmt, ob ein Wert eine Leistung von zwei ist.

IsSubnormal(Half)

Bestimmt, ob der angegebene Wert subnormal ist.

Log(Half)

Berechnet den natürlichen (Basis-E-Logarithmus eines Werts).

Log(Half, Half)

Berechnet den Logarithmus eines Werts in der angegebenen Basis.

Log10(Half)

Berechnet den Basis-10-Logarithmus eines Werts.

Log2(Half)

Berechnet das Protokoll2 eines Werts.

Max(Half, Half)

Vergleicht zwei Werte, um zu berechnen, was größer ist.

MaxMagnitude(Half, Half)

Vergleicht zwei Werte, um zu berechnen, was größer ist.

Min(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist.

MinMagnitude(Half, Half)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analysiert einen Bereich von Zeichen in einen Wert.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

Pow(Half, Half)

Berechnet einen Wert, der auf eine bestimmte Leistung ausgelöst wird.

ReciprocalEstimate(Half)

Berechnet eine Schätzung des gegenseitigen Werts.

ReciprocalSqrtEstimate(Half)

Berechnet eine Schätzung der gegenseitigen Quadratwurzel eines Werts.

Round(Half)

Rundet einen Wert auf die nächste ganze Zahl mit dem Standardrundenmodus (ToEven) ab.

Round(Half, Int32)

Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven) ab.

Round(Half, Int32, MidpointRounding)

Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven) ab.

Round(Half, MidpointRounding)

Rundet einen Wert auf die nächste ganze Zahl mit dem angegebenen Rundungsmodus ab.

ScaleB(Half, Int32)

Berechnet das Produkt eines Werts und dessen Basisradix auf die angegebene Leistung.

Sign(Half)

Berechnet das Zeichen eines Werts.

Sin(Half)

Berechnet den Sinus eines Werts.

SinCos(Half)

Berechnet die Sine und cosine eines Werts.

Sinh(Half)

Berechnet den hyperbolischen Sine eines Werts.

Sqrt(Half)

Berechnet die Quadratwurzel eines Werts.

Tan(Half)

Berechnet die Tangente eines Werts.

Tanh(Half)

Berechnet den hyperbolischen Tangent eines Werts.

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)

Geschnitten einen Wert.

TryCreate<TOther>(TOther, Half)

Versucht, eine Instanz des aktuellen Typs aus einem Wert zu erstellen.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Half-Instanz in die angegebene Zeichenspanne zu formatieren.

TryParse(ReadOnlySpan<Char>, Half)

Konvertiert die Bereichsdarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Konvertiert die Bereichsdarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

TryParse(String, Half)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

TryParse(String, IFormatProvider, Half)
TryParse(String, NumberStyles, IFormatProvider, Half)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit halber Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Operatoren

Addition(Half, Half)

Fügt zwei Werte zusammen, um ihre Summe zu berechnen.

Decrement(Half)

Erhöht einen Wert.

Division(Half, Half)

Teilt zwei Werte zusammen, um ihren Quotienten zu berechnen.

Equality(Half, Half)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Half-Werte gleich sind.

Explicit(Double to Half)

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

Explicit(Half to Double)

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

Explicit(Half to Single)

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

Explicit(Single to Half)

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

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.

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)

Teilt zwei Werte zusammen, um ihr Modul oder ihren Rest zu berechnen.

Multiply(Half, Half)

Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.

Subtraction(Half, Half)

Subtrahiert zwei Werte, um den Unterschied zu berechnen.

UnaryNegation(Half)

Berechnet die unary Negation eines Werts.

UnaryPlus(Half)

Berechnet das unary Plus eines Werts.

Explizite Schnittstellenimplementierungen

IFloatingPoint<Half>.GetExponentByteCount()

Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32).

IFloatingPoint<Half>.GetExponentShortestBitLength()

Ruft die Länge in Bits der kürzesten zwei Ergänzungsdarstellung des aktuellen Exponent ab.

IFloatingPoint<Half>.GetSignificandBitLength()

Ruft die Länge in Bits des aktuellen Significand ab.

IFloatingPoint<Half>.GetSignificandByteCount()

Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32).

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

Versucht, den aktuellen Exponent in kleinem Endenformat in einen bestimmten Bereich zu schreiben.

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

Versucht, das aktuelle Significand, im klein-endischen Format, in einen bestimmten Bereich zu schreiben.

Gilt für:

Siehe auch