Half Struct-datatyp

Definition

Namnområde:: System

Sammansättning:: System.Runtime.dll

Källa:: Half.cs

Källa:: Half.cs

Källa:: Half.cs

Källa:: Half.cs

Källa:: Half.cs

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Representerar ett flyttal med halv precision.

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)

Arv: Object

ValueType
Half

Implementeringar: 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>

Kommentarer

Värdetypen Half representerar ett halvprecisionsnummer på 16 bitar med värden som sträcker sig från negativa 65 504 till positiva 65 504, samt positiv eller negativ noll, PositiveInfinity, , NegativeInfinityoch inte ett tal (NaN).

Det här är en IEEE 754-kompatibel float16 typ.

Egenskaper

Name	Description
E	Hämtar den matematiska konstanten `e`.
Epsilon	Representerar det minsta positiva Half värdet som är större än noll.
MaxValue	Representerar det största möjliga värdet för Half.
MinValue	Representerar det minsta möjliga värdet för Half.
MultiplicativeIdentity	Hämtar den multiplicativa identiteten för den aktuella typen.
NaN	Representerar inte ett tal.
NegativeInfinity	Representerar negativ oändlighet.
NegativeOne	Hämtar värdet `-1` för typen.
NegativeZero	Hämtar ett värde som representerar negativt `zero`.
One	Hämtar värdet `1` för typen.
Pi	Hämtar den matematiska konstanten `pi`.
PositiveInfinity	Representerar positiv oändlighet.
Tau	Hämtar den matematiska konstanten `tau`.
Zero	Hämtar värdet `0` för typen.

Metoder

Name	Description
Abs(Half)	Beräknar det absoluta värdet.
Acos(Half)	Beräknar arc-cosinus för ett värde.
Acosh(Half)	Beräknar hyperbolisk arc-cosinus för ett värde.
AcosPi(Half)	Beräknar arc-cosinus för ett värde och delar resultatet `pi`med .
Asin(Half)	Beräknar arc-sinus för ett värde.
Asinh(Half)	Beräknar hyperbolisk arc-sinus för ett värde.
AsinPi(Half)	Beräknar arc-sinus för ett värde och delar resultatet `pi`med .
Atan(Half)	Beräknar arc-tangenten för ett värde.
Atan2(Half, Half)	Beräknar arc-tangenten för kvoten för två värden.
Atan2Pi(Half, Half)	Beräknar arc-tangenten för kvoten för två värden och delar resultatet `pi`med .
Atanh(Half)	Beräknar hyperbolisk arc-tangens för ett värde.
AtanPi(Half)	Beräknar arc-tangenten för ett värde och delar resultatet med pi.
BitDecrement(Half)	Minskar ett värde till det minsta värdet som jämför mindre än ett angivet värde.
BitIncrement(Half)	Ökar ett värde till det minsta värde som jämför större än ett angivet värde.
Cbrt(Half)	Beräknar kubroten för ett värde.
Ceiling(Half)	Beräknar taket för ett värde.
Clamp(Half, Half, Half)	Klämmer fast ett värde till ett inkluderande lägsta och högsta värde.
ClampNative(Half, Half, Half)	Klämmer fast ett värde till ett inkluderande lägsta och högsta värde med hjälp av plattformsspecifikt beteende för `NaN` och `NegativeZero`.
CompareTo(Half)	Jämför den här instansen med ett angivet flyttal med halv precision och returnerar ett heltal som anger om värdet för den här instansen är mindre än, lika med eller större än värdet för det angivna flyttalsnumret med halv precision.
CompareTo(Object)	Jämför den här instansen med ett angivet objekt och returnerar ett heltal som anger om värdet för den här instansen är mindre än, lika med eller större än värdet för det angivna objektet.
ConvertToInteger<TInteger>(Half)	Konverterar ett värde till en angiven heltalstyp med mättnad vid spill
ConvertToIntegerNative<TInteger>(Half)	Konverterar ett värde till en angiven heltalstyp med plattformsspecifikt beteende vid spill.
CopySign(Half, Half)	Kopierar tecknet för ett värde till tecknet för ett annat värde.
Cos(Half)	Beräknar cosininen för ett värde.
Cosh(Half)	Beräknar hyperbolisk cosiné för ett värde.
CosPi(Half)	Beräknar cosininen för ett värde som har multiplats av `pi`.
CreateChecked<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateSaturating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde som mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateTruncating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
DegreesToRadians(Half)	Konverterar ett givet värde från grader till radianer.
Equals(Half)	Jämför den här instansen för likhet med `other`.
Equals(Object)	Returnerar ett värde som anger om den här instansen är lika med den angivna `obj`.
Exp(Half)	Beräkningar som har genererats `E` till en viss effekt.
Exp10(Half)	Beräkningar som har genererats `10` till en viss effekt.
Exp10M1(Half)	Beräkningar som genereras `10` till en viss effekt och subtraherar en.
Exp2(Half)	Beräkningar som har genererats `2` till en viss effekt.
Exp2M1(Half)	Beräkningar som genereras `2` till en viss effekt och subtraherar en.
ExpM1(Half)	Beräkningar som genereras `E` till en viss effekt och subtraherar en.
Floor(Half)	Beräknar golvet i ett värde.
FusedMultiplyAdd(Half, Half, Half)	Beräknar det sammansvetsade multiplikationstillägget med tre värden.
GetHashCode()	Returnerar hash-koden för den här instansen.
Hypot(Half, Half)	Beräknar hypotenuse med två värden som representerar längden på de kortare sidorna i en högervinklad triangel.
Ieee754Remainder(Half, Half)	Beräknar resten av två värden enligt IEEE 754.
ILogB(Half)	Beräknar heltalsloggaritmen för ett värde.
IsEvenInteger(Half)	Avgör om ett värde representerar ett jämnt heltal.
IsFinite(Half)	Avgör om det angivna värdet är begränsat (noll, subnormalt eller normalt).
IsInfinity(Half)	Returnerar ett värde som anger om det angivna talet utvärderas till positiv oändlighet.
IsInteger(Half)	Avgör om ett värde representerar ett integralvärde.
IsNaN(Half)	Avgör om det angivna värdet inte är ett tal.
IsNegative(Half)	Avgör om det angivna värdet är negativt.
IsNegativeInfinity(Half)	Avgör om det angivna värdet är negativ oändlighet.
IsNormal(Half)	Avgör om det angivna värdet är normalt.
IsOddInteger(Half)	Avgör om ett värde representerar ett udda integraltal.
IsPositive(Half)	Avgör om ett värde är positivt.
IsPositiveInfinity(Half)	Avgör om det angivna värdet är positiv oändlighet.
IsPow2(Half)	Avgör om ett värde är en kraft på två.
IsRealNumber(Half)	Avgör om ett värde representerar ett verkligt tal.
IsSubnormal(Half)	Avgör om det angivna värdet är subnormalt.
Lerp(Half, Half, Half)	Utför en linjär interpolering mellan två värden baserat på den angivna vikten.
Log(Half, Half)	Beräknar logaritmen för ett värde i den angivna basen.
Log(Half)	Beräknar det naturliga (`base-E` logaritmen för ett värde.
Log10(Half)	Beräknar base-10-logaritmen för ett värde.
Log10P1(Half)	Beräknar logaritmen base-10 för ett värde plus ett.
Log2(Half)	Beräknar log2 för ett värde.
Log2P1(Half)	Beräknar base-2-logaritmen för ett värde plus ett.
LogP1(Half)	Beräknar den naturliga (`base-E`) logaritmen för ett värde plus ett.
Max(Half, Half)	Jämför två värden med beräkning som är större.
MaxMagnitude(Half, Half)	Jämför två värden med beräkning som är större.
MaxMagnitudeNumber(Half, Half)	Jämför två värden med beräkning som har större storlek och returnerar det andra värdet om en indata är `NaN`.
MaxNative(Half, Half)	Jämför två värden med beräkning som är större med plattformsspecifikt beteende för `NaN` och `NegativeZero`.
MaxNumber(Half, Half)	Jämför två värden med beräkning som är större och returnerar det andra värdet om en indata är `NaN`.
Min(Half, Half)	Jämför två värden med beräkning som är mindre.
MinMagnitude(Half, Half)	Jämför två värden med beräkning som är mindre.
MinMagnitudeNumber(Half, Half)	Jämför två värden med beräkning som har mindre storlek och returnerar det andra värdet om en indata är `NaN`.
MinNative(Half, Half)	Jämför två värden med beräkning som är mindre med plattformsspecifikt beteende för `NaN` och `NegativeZero`.
MinNumber(Half, Half)	Jämför två värden med beräkning som är mindre och returnerar det andra värdet om en indata är `NaN`.
MultiplyAddEstimate(Half, Half, Half)	Beräknar en uppskattning av (`left` * `right`) + `addend`.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess flytande punktnummer med enkel precision.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess flytande punktnummer med enkel precision.
Parse(String)	Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med halv precision.
Pow(Half, Half)	Beräknar ett värde som har upphöjts till en viss effekt.
RadiansToDegrees(Half)	Konverterar ett givet värde från radianer till grader.
ReciprocalEstimate(Half)	Beräknar en uppskattning av ett värdes ömsesidiga värde.
ReciprocalSqrtEstimate(Half)	Beräknar en uppskattning av den ömsesidiga kvadratroten för ett värde.
RootN(Half, Int32)	Beräknar den n:e roten för ett värde.
Round(Half, Int32, MidpointRounding)	Avrundar ett värde till ett angivet antal bråksiffror med standard avrundningsläget (ToEven).
Round(Half, Int32)	Avrundar ett värde till ett angivet antal bråksiffror med standard avrundningsläget (ToEven).
Round(Half, MidpointRounding)	Avrundar ett värde till närmaste heltal med det angivna avrundningsläget.
Round(Half)	Avrundar ett värde till närmaste heltal med standard avrundningsläget (ToEven).
ScaleB(Half, Int32)	Beräknar produkten av ett värde och dess basradix upphöjt till den angivna kraften.
Sign(Half)	Beräknar tecknet för ett värde.
Sin(Half)	Beräknar sinus för ett värde.
SinCos(Half)	Beräknar sinus och cosinus för ett värde.
SinCosPi(Half)	Beräknar sinus och cosinus för ett värde som har multiplicerats `pi`med .
Sinh(Half)	Beräknar hyperbolisk sinus för ett värde.
SinPi(Half)	Beräknar sinus för ett värde som har multiplicerats `pi`med .
Sqrt(Half)	Beräknar kvadratroten för ett värde.
Tan(Half)	Beräknar tangensen för ett värde.
Tanh(Half)	Beräknar hyperbolisk tangens för ett värde.
TanPi(Half)	Beräknar tangensen för ett värde som har multipelts av `pi`.
ToString()	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.
ToString(IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.
ToString(String, IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.
ToString(String)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.
Truncate(Half)	Trunkerar ett värde.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen som UTF-8 i det angivna byteintervallet.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella Half instansen till det angivna intervallet med tecken.
TryParse(ReadOnlySpan<Byte>, Half)	Försöker konvertera ett UTF-8-teckensintervall som innehåller strängrepresentationen av ett tal till dess flyttalsnummer med halv precision.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Char>, Half)	Konverterar spännviddsrepresentationen av ett tal till dess flyttal med halv precision. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Försöker parsa ett teckenintervall till ett värde.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Konverterar spännviddsrepresentationen av ett tal till dess flyttal med halv precision. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(String, Half)	Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med halv precision. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(String, IFormatProvider, Half)	Försöker parsa en sträng till ett värde.
TryParse(String, NumberStyles, IFormatProvider, Half)	Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med halv precision. Ett returvärde anger om konverteringen lyckades eller misslyckades.

Operatorer

Name	Description
Addition(Half, Half)	Lägger till två värden tillsammans för att beräkna summan.
CheckedExplicit(Half to Byte)	Representerar ett flyttal med halv precision.
Decrement(Half)	Minskar ett värde.
Division(Half, Half)	Delar upp två värden för att beräkna deras kvot.
Equality(Half, Half)	Returnerar ett värde som anger om två angivna Half värden är lika med.
Explicit(Char to Half)	Konverterar uttryckligen ett Char värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(Decimal to Half)	Konverterar uttryckligen ett Decimal värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(Double to Half)	En explicit operator för att konvertera ett Double värde till en Half.
Explicit(Half to Byte)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Byte värde.
Explicit(Half to Char)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Char värde.
Explicit(Half to Decimal)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Decimal värde.
Explicit(Half to Double)	En explicit operator för att konvertera ett Half värde till en Double.
Explicit(Half to Int128)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Int128.
Explicit(Half to Int16)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Int16 värde.
Explicit(Half to Int32)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Int32 värde.
Explicit(Half to Int64)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande Int64 värde.
Explicit(Half to IntPtr)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande IntPtr värde.
Explicit(Half to SByte)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande SByte värde.
Explicit(Half to Single)	En explicit operator för att konvertera ett Half värde till en Single.
Explicit(Half to UInt128)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande UInt128.
Explicit(Half to UInt16)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande UInt16 värde.
Explicit(Half to UInt32)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande UInt32 värde.
Explicit(Half to UInt64)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande UInt64 värde.
Explicit(Half to UIntPtr)	Konverterar uttryckligen ett flyttal med halv precision till närmaste representerande UIntPtr värde.
Explicit(Int16 to Half)	Konverterar uttryckligen ett Int16 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(Int32 to Half)	Konverterar uttryckligen ett Int32 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(Int64 to Half)	Konverterar uttryckligen ett Int64 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(IntPtr to Half)	Konverterar uttryckligen ett IntPtr värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(Single to Half)	En explicit operator för att konvertera ett Single värde till en Half.
Explicit(UInt16 to Half)	Konverterar uttryckligen ett UInt16 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(UInt32 to Half)	Konverterar uttryckligen ett UInt32 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(UInt64 to Half)	Konverterar uttryckligen ett UInt64 värde till dess närmaste representerande flyttalsvärde med halv precision.
Explicit(UIntPtr to Half)	Konverterar uttryckligen ett UIntPtr värde till dess närmaste representerande flyttalsvärde med halv precision.
GreaterThan(Half, Half)	Returnerar ett värde som anger om ett angivet Half värde är större än ett annat angivet Half värde.
GreaterThanOrEqual(Half, Half)	Returnerar ett värde som anger om `left` är större än eller lika med `right`.
Implicit(Byte to Half)	Konverterar implicit ett Byte värde till dess närmaste representerande flyttalsvärde med halv precision.
Implicit(SByte to Half)	Konverterar implicit ett SByte värde till dess närmaste representerande flyttalsvärde med halv precision.
Increment(Half)	Ökar ett värde.
Inequality(Half, Half)	Returnerar ett värde som anger om två angivna Half värden inte är lika med.
LessThan(Half, Half)	Returnerar ett värde som anger om ett angivet Half värde är mindre än ett annat angivet Half värde.
LessThanOrEqual(Half, Half)	Returnerar ett värde som anger om ett angivet Half värde är mindre än eller lika med ett annat angivet Half värde.
Modulus(Half, Half)	Delar upp två värden för att beräkna deras modulus eller rest.
Multiply(Half, Half)	Multiplicerar två värden tillsammans för att beräkna produkten.
Subtraction(Half, Half)	Subtraherar två värden för att beräkna skillnaden.
UnaryNegation(Half)	Beräknar en oharisk negation av ett värde.
UnaryPlus(Half)	Beräknar det unary plus av ett värde.

Explicita gränssnittsimplementeringar

Name	Description
IAdditiveIdentity<Half,Half>.AdditiveIdentity	Hämtar den aktuella typens additiva identitet.
IBinaryNumber<Half>.AllBitsSet	Hämtar en instans av den binära typen där alla bitar anges.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)	Beräknar bitvis och av två värden.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)	Beräknar bitvis eller två värden.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)	Beräknar uteslutande eller av två värden.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)	Beräknar enkomplementrepresentationen av ett visst värde.
IFloatingPoint<Half>.GetExponentByteCount()	Hämtar antalet byte som ska skrivas som en del av TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()	Hämtar längden, i bitar, på de kortaste tvås komplementrepresentation av den aktuella exponenten.
IFloatingPoint<Half>.GetSignificandBitLength()	Hämtar längden, i bitar, på den aktuella significanden.
IFloatingPoint<Half>.GetSignificandByteCount()	Hämtar antalet byte som ska skrivas som en del av TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Försöker skriva den aktuella exponenten, i stor endianskt format, till ett givet spann.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Försöker skriva den aktuella exponenten, i lite endianskt format, till ett givet spann.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Försöker skriva den aktuella significand, i big-endian format, till ett visst spann.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Försöker skriva den aktuella significand, i lite-endian format, till ett givet spann.
INumberBase<Half>.IsCanonical(Half)	Avgör om ett värde finns i dess kanoniska representation.
INumberBase<Half>.IsComplexNumber(Half)	Avgör om ett värde representerar ett komplext tal.
INumberBase<Half>.IsImaginaryNumber(Half)	Avgör om ett värde representerar ett rent imaginärt tal.
INumberBase<Half>.IsZero(Half)	Avgör om ett värde är noll.
INumberBase<Half>.Radix	Hämtar radixet, eller basen, för typen.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)	Representerar ett flyttal med halv precision.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)	Representerar ett flyttal med halv precision.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)	Representerar ett flyttal med halv precision.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.

Gäller för

Se även

Single

Feedback

Var den här sidan till hjälp?