Half Struct

Definitie

Naamruimte:
System
Assembly:
System.Runtime.dll
Bron:
Half.cs
Bron:
Half.cs
Bron:
Half.cs
Bron:
Half.cs
Bron:
Half.cs

Vertegenwoordigt een drijvendekommagetal met halve precisie.

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)
Overname
Object
ValueType
Half
Implementeringen
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>

Opmerkingen

Het Half waardetype vertegenwoordigt een halfprecisie 16-bits getal met waarden tussen negatieve 65.504 en positieve 65.504, plus positieve of negatieve nul, PositiveInfinityen NegativeInfinitygeen getal (NaN).

Dit is een IEEE 754-compatibel float16 type.

Eigenschappen

Name Description
E

Hiermee haalt u de wiskundige constante eop.
Epsilon

Vertegenwoordigt de kleinste positieve Half waarde die groter is dan nul.
MaxValue

Vertegenwoordigt de grootst mogelijke waarde van Half.
MinValue

Vertegenwoordigt de kleinste mogelijke waarde van Half.
MultiplicativeIdentity

Hiermee haalt u de vermenigvuldigende identiteit van het huidige type op.
NaN

Vertegenwoordigt geen getal.
NegativeInfinity

Geeft een negatief oneindigheid aan.
NegativeOne

Hiermee haalt u de waarde -1 voor het type op.
NegativeZero

Hiermee wordt een waarde opgehaald die een negatieve zerowaarde vertegenwoordigt.
One

Hiermee haalt u de waarde 1 voor het type op.
Pi

Hiermee haalt u de wiskundige constante piop.
PositiveInfinity

Geeft positieve oneindigheid aan.
Tau

Hiermee haalt u de wiskundige constante tauop.
Zero

Hiermee haalt u de waarde 0 voor het type op.

Methoden

Name Description
Abs(Half)

Berekent de absolute waarde van een waarde.
Acos(Half)

Berekent de boogcosinus van een waarde.
Acosh(Half)

Berekent de hyperbolische boogcosinus van een waarde.
AcosPi(Half)

Berekent de boogcosinus van een waarde en deelt het resultaat door pi.
Asin(Half)

Berekent de boogsinus van een waarde.
Asinh(Half)

Berekent de sinus hyperbolische boog van een waarde.
AsinPi(Half)

Berekent de boogsinus van een waarde en deelt het resultaat door pi.
Atan(Half)

Berekent de boogtangens van een waarde.
Atan2(Half, Half)

Berekent de boogtangens van het quotiënt van twee waarden.
Atan2Pi(Half, Half)

Berekent de boogtangens voor het quotiënt van twee waarden en deelt het resultaat door pi.
Atanh(Half)

Berekent de hyperbolische boogtangens van een waarde.
AtanPi(Half)

Berekent de boogtangens van een waarde en deelt het resultaat door pi.
BitDecrement(Half)

Hiermee wordt een waarde afgekoppeld van de kleinste waarde die kleiner is dan een bepaalde waarde.
BitIncrement(Half)

Hiermee wordt een waarde verhoogd naar de kleinste waarde die groter is dan een bepaalde waarde.
Cbrt(Half)

Berekent de kubushoofdmap van een waarde.
Ceiling(Half)

Berekent het maximum van een waarde.
Clamp(Half, Half, Half)

Klemmen een waarde tot een inclusieve minimum- en maximumwaarde.
ClampNative(Half, Half, Half)

Klemmen een waarde tot een inclusieve minimum- en maximumwaarde met behulp van platformspecifiek gedrag voor NaN en NegativeZero.
CompareTo(Half)

Vergelijkt dit exemplaar met een opgegeven drijvendekommagetal met halve precisie en retourneert een geheel getal dat aangeeft of de waarde van dit exemplaar kleiner is dan, gelijk is aan of groter is dan de waarde van het opgegeven drijvendekommagetal met halve precisie.
CompareTo(Object)

Vergelijkt dit exemplaar met een opgegeven object en retourneert een geheel getal dat aangeeft of de waarde van dit exemplaar kleiner is dan, gelijk is aan of groter is dan de waarde van het opgegeven object.
ConvertToInteger<TInteger>(Half)

Converteert een waarde naar een opgegeven geheel getal met behulp van verzadiging bij overloop
ConvertToIntegerNative<TInteger>(Half)

Converteert een waarde naar een opgegeven geheel getaltype met behulp van platformspecifiek gedrag bij overloop.
CopySign(Half, Half)

Kopieert het teken van een waarde naar het teken van een andere waarde.
Cos(Half)

Berekent de cosinus van een waarde.
Cosh(Half)

Berekent de cosinus hyperbolicus van een waarde.
CosPi(Half)

Berekent de cosinus van een waarde die is vermenigvuldigd door pi.
CreateChecked<TOther>(TOther)

Hiermee maakt u een exemplaar van het huidige type op basis van een waarde en genereert u een overloopuitzondering voor waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen.
CreateSaturating<TOther>(TOther)

Hiermee maakt u een exemplaar van het huidige type op basis van een waarde, waarbij alle waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen, worden verzadiging weergegeven.
CreateTruncating<TOther>(TOther)

Hiermee maakt u een exemplaar van het huidige type op basis van een waarde, waarbij alle waarden worden afgekapt die buiten het vertegenwoordigbare bereik van het huidige type vallen.
DegreesToRadians(Half)

Converteert een bepaalde waarde van graden naar radialen.
Equals(Half)

Vergelijkt dit exemplaar voor gelijkheid met other.
Equals(Object)

Retourneert een waarde die aangeeft of dit exemplaar gelijk is aan de opgegeven obj.
Exp(Half)

Berekeningen E die tot een bepaalde macht zijn verheven.
Exp10(Half)

Berekeningen 10 die tot een bepaalde macht zijn verheven.
Exp10M1(Half)

Berekeningen 10 die tot een bepaalde macht zijn verheven en één aftrekken.
Exp2(Half)

Berekeningen 2 die tot een bepaalde macht zijn verheven.
Exp2M1(Half)

Berekeningen 2 die tot een bepaalde macht zijn verheven en één aftrekken.
ExpM1(Half)

Berekeningen E die tot een bepaalde macht zijn verheven en één aftrekken.
Floor(Half)

Berekent de vloer van een waarde.
FusedMultiplyAdd(Half, Half, Half)

Berekent de samenvoeging van drie waarden.
GetHashCode()

Retourneert de hash-code voor dit exemplaar.
Hypot(Half, Half)

Berekent de hypotenuse op basis van twee waarden die de lengten van de kortere zijden in een driehoek met een rechte hoek vertegenwoordigen.
Ieee754Remainder(Half, Half)

Berekent de rest van twee waarden, zoals opgegeven door IEEE 754.
ILogB(Half)

Berekent de logaritme van een geheel getal van een waarde.
IsEvenInteger(Half)

Bepaalt of een waarde een even integraal getal vertegenwoordigt.
IsFinite(Half)

Bepaalt of de opgegeven waarde eindig is (nul, subnormaal of normaal).
IsInfinity(Half)

Retourneert een waarde die aangeeft of het opgegeven getal positief oneindig is.
IsInteger(Half)

Bepaalt of een waarde een integrale waarde vertegenwoordigt.
IsNaN(Half)

Bepaalt of de opgegeven waarde geen getal is.
IsNegative(Half)

Bepaalt of de opgegeven waarde negatief is.
IsNegativeInfinity(Half)

Bepaalt of de opgegeven waarde een negatief oneindigheid is.
IsNormal(Half)

Bepaalt of de opgegeven waarde normaal is.
IsOddInteger(Half)

Bepaalt of een waarde een oneven integraal getal vertegenwoordigt.
IsPositive(Half)

Bepaalt of een waarde positief is.
IsPositiveInfinity(Half)

Bepaalt of de opgegeven waarde positief oneindig is.
IsPow2(Half)

Bepaalt of een waarde een macht van twee is.
IsRealNumber(Half)

Bepaalt of een waarde een reëel getal vertegenwoordigt.
IsSubnormal(Half)

Bepaalt of de opgegeven waarde subnormaal is.
Lerp(Half, Half, Half)

Hiermee wordt een lineaire interpolatie tussen twee waarden uitgevoerd op basis van het opgegeven gewicht.
Log(Half, Half)

Berekent de logaritme van een waarde in de opgegeven basis.
Log(Half)

Berekent de natuurlijke (base-E logaritme van een waarde).
Log10(Half)

Berekent de logaritme met grondtal 10 van een waarde.
Log10P1(Half)

Berekent de logaritme met grondtal 10 van een waarde plus één.
Log2(Half)

Berekent het logboek2 van een waarde.
Log2P1(Half)

Berekent de logaritme met grondtal 2 van een waarde plus één.
LogP1(Half)

Berekent de natuurlijke logaritmebase-E van een waarde plus één.
Max(Half, Half)

Vergelijkt twee waarden met berekeningen die groter zijn.
MaxMagnitude(Half, Half)

Vergelijkt twee waarden met berekeningen die groter zijn.
MaxMagnitudeNumber(Half, Half)

Vergelijkt twee waarden met berekeningen die de grotere grootte hebben en de andere waarde retourneren als een invoer is NaN.
MaxNative(Half, Half)

Vergelijkt twee waarden met berekeningen die groter zijn met behulp van platformspecifiek gedrag voor NaN en NegativeZero.
MaxNumber(Half, Half)

Vergelijkt twee waarden met berekeningen die groter zijn en de andere waarde retourneren als een invoer is NaN.
Min(Half, Half)

Vergelijkt twee waarden met berekeningen die kleiner zijn.
MinMagnitude(Half, Half)

Vergelijkt twee waarden met berekeningen die kleiner zijn.
MinMagnitudeNumber(Half, Half)

Vergelijkt twee waarden met berekeningen die de lagere grootte hebben en de andere waarde retourneren als een invoer is NaN.
MinNative(Half, Half)

Vergelijkt twee waarden met berekeningen die minder gebruikmaken van platformspecifiek gedrag voor NaN en NegativeZero.
MinNumber(Half, Half)

Vergelijkt twee waarden met berekeningen die kleiner zijn en de andere waarde retourneren als een invoer is NaN.
MultiplyAddEstimate(Half, Half, Half)

Berekent een schatting van (left * right) + addend.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parseert een reeks UTF-8 tekens in een waarde.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parseert een reeks UTF-8 tekens in een waarde.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Parseert een reeks tekens in een waarde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van drijvendekommagetal met één precisie.
Parse(String, IFormatProvider)

Converteert de tekenreeksweergave van een getal in een opgegeven cultuurspecifieke notatie naar het equivalent van een drijvendekommagetal met één precisie.
Parse(String, NumberStyles, IFormatProvider)

Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van drijvendekommagetal met één precisie.
Parse(String, NumberStyles)

Converteert de tekenreeksweergave van een getal in een opgegeven stijl naar het equivalent van een drijvendekommagetal met één precisie.
Parse(String)

Converteert de tekenreeksweergave van een getal naar het equivalent van een getal met halve precisie.
Pow(Half, Half)

Berekent een waarde die is verhoogd tot een bepaalde macht.
RadiansToDegrees(Half)

Converteert een bepaalde waarde van radialen naar graden.
ReciprocalEstimate(Half)

Berekent een schatting van de wederkerigheid van een waarde.
ReciprocalSqrtEstimate(Half)

Berekent een schatting van de wederzijdse vierkantswortel van een waarde.
RootN(Half, Int32)

Berekent de n-th-hoofdmap van een waarde.
Round(Half, Int32, MidpointRounding)

Rondt een waarde af op een opgegeven aantal fractionele cijfers met behulp van de standaard afgeronde modus (ToEven).
Round(Half, Int32)

Rondt een waarde af op een opgegeven aantal fractionele cijfers met behulp van de standaard afgeronde modus (ToEven).
Round(Half, MidpointRounding)

Rondt een waarde af op het dichtstbijzijnde gehele getal met behulp van de opgegeven afrondingsmodus.
Round(Half)

Rondt een waarde af op het dichtstbijzijnde gehele getal met behulp van de standaard afrondingsmodus (ToEven).
ScaleB(Half, Int32)

Berekent het product van een waarde en de basis-radix die tot de opgegeven macht zijn verheven.
Sign(Half)

Berekent het teken van een waarde.
Sin(Half)

Berekent de sinus van een waarde.
SinCos(Half)

Berekent de sinus en cosinus van een waarde.
SinCosPi(Half)

Berekent de sinus en cosinus van een waarde die is vermenigvuldigd met pi.
Sinh(Half)

Berekent de sinus hyperbolicus van een waarde.
SinPi(Half)

Berekent de sinus van een waarde die is vermenigvuldigd met pi.
Sqrt(Half)

Berekent de vierkantswortel van een waarde.
Tan(Half)

Berekent de tangens van een waarde.
Tanh(Half)

Berekent de tangens hyperbolicus van een waarde.
TanPi(Half)

Berekent de tangens van een waarde die is vermenigvuldigd door pi.
ToString()

Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave.
ToString(IFormatProvider)

Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave met behulp van de opgegeven cultuurspecifieke notatiegegevens.
ToString(String, IFormatProvider)

Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave met behulp van de opgegeven indeling en cultuurspecifieke notatiegegevens.
ToString(String)

Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave, met behulp van de opgegeven indeling.
Truncate(Half)

Kapt een waarde af.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Probeert de waarde van het huidige exemplaar op te maken als UTF-8 in het opgegeven bereik van bytes.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Probeert de waarde van het huidige Half exemplaar op te maken in de opgegeven reeks tekens.
TryParse(ReadOnlySpan<Byte>, Half)

Hiermee wordt geprobeerd een UTF-8-tekenbereik te converteren dat de tekenreeksweergave van een getal bevat naar het equivalent van een drijvendekommagetal met halve precisie.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)

Probeert een reeks UTF-8 tekens te parseren in een waarde.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)

Probeert een reeks UTF-8 tekens te parseren in een waarde.
TryParse(ReadOnlySpan<Char>, Half)

Converteert de spanweergave van een getal naar het equivalent van een getal met halve precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Probeert een reeks tekens te parseren in een waarde.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Converteert de spanweergave van een getal naar het equivalent van een getal met halve precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.
TryParse(String, Half)

Converteert de tekenreeksweergave van een getal naar het equivalent van een getal met halve precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.
TryParse(String, IFormatProvider, Half)

Probeert een tekenreeks te parseren in een waarde.
TryParse(String, NumberStyles, IFormatProvider, Half)

Converteert de tekenreeksweergave van een getal naar het equivalent van een getal met halve precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.

Operators

Name Description
Addition(Half, Half)

Voegt twee waarden samen om de som te berekenen.
CheckedExplicit(Half to Byte)

Vertegenwoordigt een drijvendekommagetal met halve precisie.
Decrement(Half)

Een waarde verlagen.
Division(Half, Half)

Verdeelt twee waarden samen om hun quotiënt te berekenen.
Equality(Half, Half)

Retourneert een waarde die aangeeft of twee opgegeven Half waarden gelijk zijn.
Explicit(Char to Half)

Converteert expliciet een Char waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(Decimal to Half)

Converteert expliciet een Decimal waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(Double to Half)

Een expliciete operator om een Double waarde te converteren naar een Half.
Explicit(Half to Byte)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Byte waarde.
Explicit(Half to Char)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Char waarde.
Explicit(Half to Decimal)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Decimal waarde.
Explicit(Half to Double)

Een expliciete operator om een Half waarde te converteren naar een Double.
Explicit(Half to Int128)

Converteert expliciet een drijvendekommawaarde met een halve precisie naar het dichtstbijzijnde vertegenwoordigbare Int128getal.
Explicit(Half to Int16)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Int16 waarde.
Explicit(Half to Int32)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Int32 waarde.
Explicit(Half to Int64)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare Int64 waarde.
Explicit(Half to IntPtr)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare IntPtr waarde.
Explicit(Half to SByte)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare SByte waarde.
Explicit(Half to Single)

Een expliciete operator om een Half waarde te converteren naar een Single.
Explicit(Half to UInt128)

Converteert expliciet een drijvendekommawaarde met een halve precisie naar het dichtstbijzijnde vertegenwoordigbare UInt128getal.
Explicit(Half to UInt16)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare UInt16 waarde.
Explicit(Half to UInt32)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare UInt32 waarde.
Explicit(Half to UInt64)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare UInt64 waarde.
Explicit(Half to UIntPtr)

Converteert expliciet een drijvendekommawaarde met halve precisie naar de dichtstbijzijnde vertegenwoordigbare UIntPtr waarde.
Explicit(Int16 to Half)

Converteert expliciet een Int16 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(Int32 to Half)

Converteert expliciet een Int32 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(Int64 to Half)

Converteert expliciet een Int64 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(IntPtr to Half)

Converteert expliciet een IntPtr waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(Single to Half)

Een expliciete operator om een Single waarde te converteren naar een Half.
Explicit(UInt16 to Half)

Converteert expliciet een UInt16 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(UInt32 to Half)

Converteert expliciet een UInt32 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(UInt64 to Half)

Converteert expliciet een UInt64 waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Explicit(UIntPtr to Half)

Converteert expliciet een UIntPtr waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
GreaterThan(Half, Half)

Retourneert een waarde die aangeeft of een opgegeven Half waarde groter is dan een andere opgegeven Half waarde.
GreaterThanOrEqual(Half, Half)

Retourneert een waarde die aangeeft of left deze groter is dan of gelijk is aan right.
Implicit(Byte to Half)

Converteert impliciet een Byte waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Implicit(SByte to Half)

Converteert impliciet een SByte waarde naar de dichtstbijzijnde vertegenwoordigbare drijvendekommawaarde met halve precisie.
Increment(Half)

Hiermee wordt een waarde verhoogd.
Inequality(Half, Half)

Retourneert een waarde die aangeeft of twee opgegeven Half waarden niet gelijk zijn.
LessThan(Half, Half)

Retourneert een waarde die aangeeft of een opgegeven Half waarde kleiner is dan een andere opgegeven Half waarde.
LessThanOrEqual(Half, Half)

Retourneert een waarde die aangeeft of een opgegeven Half waarde kleiner is dan of gelijk is aan een andere opgegeven Half waarde.
Modulus(Half, Half)

Verdeelt twee waarden samen om hun modulus of restgetal te berekenen.
Multiply(Half, Half)

Vermenigvuldigt twee waarden samen om het product te berekenen.
Subtraction(Half, Half)

Trekt twee waarden af om het verschil te berekenen.
UnaryNegation(Half)

Berekent de unaire negatie van een waarde.
UnaryPlus(Half)

Berekent het unaire plusteken van een waarde.

Expliciete interface-implementaties

Name Description
IAdditiveIdentity<Half,Half>.AdditiveIdentity

Hiermee haalt u de additieve identiteit van het huidige type op.
IBinaryNumber<Half>.AllBitsSet

Hiermee haalt u een exemplaar op van het binaire type waarin alle bits zijn ingesteld.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)

Berekent de bitsgewijze en van twee waarden.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)

Berekent de bitsgewijze of twee waarden.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)

Berekent de exclusieve of twee waarden.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)

Berekent de een-complementweergave van een bepaalde waarde.
IFloatingPoint<Half>.GetExponentByteCount()

Hiermee haalt u het aantal bytes op dat wordt geschreven als onderdeel van TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()

Hiermee haalt u de lengte, in bits, van de kortste twee's complementweergave van de huidige exponent.
IFloatingPoint<Half>.GetSignificandBitLength()

Hiermee wordt de lengte, in bits, van de huidige significand.
IFloatingPoint<Half>.GetSignificandByteCount()

Hiermee haalt u het aantal bytes op dat wordt geschreven als onderdeel van TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)

Probeert de huidige exponent, in big-endian-indeling, naar een bepaalde periode te schrijven.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)

Probeert de huidige exponent, in little-endian-indeling, naar een bepaalde periode te schrijven.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)

Probeert het huidige teken te schrijven, in big-endian-indeling, naar een bepaalde periode.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Probeert het huidige teken te schrijven, in little-endian-indeling, naar een bepaalde periode.
INumberBase<Half>.IsCanonical(Half)

Bepaalt of een waarde zich in de canonieke weergave bevindt.
INumberBase<Half>.IsComplexNumber(Half)

Bepaalt of een waarde een complex getal vertegenwoordigt.
INumberBase<Half>.IsImaginaryNumber(Half)

Bepaalt of een waarde een puur imaginair getal vertegenwoordigt.
INumberBase<Half>.IsZero(Half)

Bepaalt of een waarde nul is.
INumberBase<Half>.Radix

Bepaalt de radix of basis voor een type.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)

Vertegenwoordigt een drijvendekommagetal met halve precisie.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)

Vertegenwoordigt een drijvendekommagetal met halve precisie.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)

Vertegenwoordigt een drijvendekommagetal met halve precisie.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)

Probeert een exemplaar van het huidige type te converteren naar een ander type, waardoor een overloop-uitzondering wordt gegenereerd voor waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)

Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen, worden verzadigingswaarden weergegeven.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)

Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden worden afgekapt die buiten het vertegenwoordigbare bereik van het huidige type vallen.

Van toepassing op

Zie ook