Half Struct

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Origine:
Half.cs
Origine:
Half.cs
Origine:
Half.cs

Rappresenta un numero a virgola mobile a metà precisione.

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

Commenti

Il tipo valore Half rappresenta un numero a metà precisione a 16 bit con valori compresi tra 65.504 negativi e 65.504 positivi, nonché zero positivo o negativo, PositiveInfinity, NegativeInfinitye non un numero (NaN).

Si tratta di un tipo di float16 conforme a IEEE 754.

Proprietà

E

Ottiene la costante matematica e.
Epsilon

Rappresenta il valore positivo più piccolo Half maggiore di zero.
MaxValue

Rappresenta il valore massimo possibile di Half.
MinValue

Rappresenta il valore più piccolo possibile di Half.
MultiplicativeIdentity

Ottiene l'identità moltiplicativa del tipo corrente.
NaN

Rappresenta un numero.
NegativeInfinity

Rappresenta l'infinito negativo.
NegativeOne

Ottiene il valore -1 per il tipo.
NegativeZero

Ottiene un valore che rappresenta zeronegativo.
One

Ottiene il valore 1 per il tipo.
Pi

Ottiene la costante matematica pi.
PositiveInfinity

Rappresenta l'infinito positivo.
Tau

Ottiene la costante matematica tau.
Zero

Ottiene il valore 0 per il tipo.

Metodi

Abs(Half)

Calcola l'assoluto di un valore.
Acos(Half)

Calcola l'arco-coseno di un valore.
Acosh(Half)

Calcola l'arco-coseno iperbolico di un valore.
AcosPi(Half)

Calcola l'arco coseno di un valore e divide il risultato per pi.
Asin(Half)

Calcola il seno arco di un valore.
Asinh(Half)

Calcola il seno dell'arco iperbolico di un valore.
AsinPi(Half)

Calcola il seno arco di un valore e divide il risultato per pi.
Atan(Half)

Calcola l'arco-tangente di un valore.
Atan2(Half, Half)

Calcola l'arco tangente del quoziente di due valori.
Atan2Pi(Half, Half)

Calcola l'arco-tangente per il quoziente di due valori e divide il risultato per pi.
Atanh(Half)

Calcola l'arco-tangente iperbolica di un valore.
AtanPi(Half)

Calcola l'arco-tangente di un valore e divide il risultato per pi.
BitDecrement(Half)

Decrementa un valore con il valore più piccolo che confronta meno di un valore specificato.
BitIncrement(Half)

Incrementa un valore al valore più piccolo che confronta un valore maggiore di un valore specificato.
Cbrt(Half)

Calcola la radice del cubo di un valore.
Ceiling(Half)

Calcola il limite massimo di un valore.
Clamp(Half, Half, Half)

Blocca un valore a un valore minimo e massimo inclusivo.
CompareTo(Half)

Confronta questa istanza con un numero a virgola mobile a metà precisione specificato e restituisce un numero intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero a virgola mobile a metà precisione specificato.
CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un numero intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'oggetto specificato.
ConvertToInteger<TInteger>(Half)

Converte un valore in un tipo integer specificato utilizzando la saturazione in caso di overflow
ConvertToIntegerNative<TInteger>(Half)

Converte un valore in un tipo integer specificato utilizzando un comportamento specifico della piattaforma in caso di overflow.
CopySign(Half, Half)

Copia il segno di un valore nel segno di un altro valore.
Cos(Half)

Calcola il coseno di un valore.
Cosh(Half)

Calcola il coseno iperbolico di un valore.
CosPi(Half)

Calcola il coseno di un valore che è stato multiplo da pi.
CreateChecked<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
CreateSaturating<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, saturando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
CreateTruncating<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
DegreesToRadians(Half)

Converte un valore specificato da gradi a radianti.
Equals(Half)

Confronta questa istanza per verificare l'uguaglianza con other.
Equals(Object)

Restituisce un valore che indica se questa istanza è uguale alla objspecificata.
Exp(Half)

Calcola E elevato a una determinata potenza.
Exp10(Half)

Calcola 10 elevato a una determinata potenza.
Exp10M1(Half)

Calcola 10 elevato a una determinata potenza e ne sottrae uno.
Exp2(Half)

Calcola 2 elevato a una determinata potenza.
Exp2M1(Half)

Calcola 2 elevato a una determinata potenza e ne sottrae uno.
ExpM1(Half)

Calcola E elevato a una determinata potenza e ne sottrae uno.
Floor(Half)

Calcola il piano di un valore.
FusedMultiplyAdd(Half, Half, Half)

Calcola il moltiplicatore fuso di tre valori.
GetHashCode()

Restituisce il codice hash per questa istanza.
Hypot(Half, Half)

Calcola l'ipotenusa data due valori che rappresentano le lunghezze dei lati più corti in un triangolo con angolo destro.
Ieee754Remainder(Half, Half)

Calcola il resto di due valori come specificato da IEEE 754.
ILogB(Half)

Calcola il logaritmo intero di un valore.
IsEvenInteger(Half)

Determina se un valore rappresenta un numero integrale pari.
IsFinite(Half)

Determina se il valore specificato è finito (zero, sottonormato o normale).
IsInfinity(Half)

Restituisce un valore che indica se il numero specificato restituisce un infinito positivo.
IsInteger(Half)

Determina se un valore rappresenta un valore integrale.
IsNaN(Half)

Determina se il valore specificato non è un numero.
IsNegative(Half)

Determina se il valore specificato è negativo.
IsNegativeInfinity(Half)

Determina se il valore specificato è infinito negativo.
IsNormal(Half)

Determina se il valore specificato è normale.
IsOddInteger(Half)

Determina se un valore rappresenta un numero integrale dispari.
IsPositive(Half)

Determina se un valore è positivo.
IsPositiveInfinity(Half)

Determina se il valore specificato è infinito positivo.
IsPow2(Half)

Determina se un valore è una potenza di due.
IsRealNumber(Half)

Determina se un valore rappresenta un numero reale.
IsSubnormal(Half)

Determina se il valore specificato è sottonormaale.
Lerp(Half, Half, Half)

Esegue un'interpolazione lineare tra due valori in base al peso specificato.
Log(Half)

Calcola il logaritmo naturale (base-E logaritmo di un valore.
Log(Half, Half)

Calcola il logaritmo di un valore nella base specificata.
Log10(Half)

Calcola il logaritmo di base 10 di un valore.
Log10P1(Half)

Calcola il logaritmo in base 10 di un valore più uno.
Log2(Half)

Calcola il log2 di un valore.
Log2P1(Half)

Calcola il logaritmo in base 2 di un valore più uno.
LogP1(Half)

Calcola il logaritmo naturale (base-E) di un valore più uno.
Max(Half, Half)

Confronta due valori con il calcolo maggiore.
MaxMagnitude(Half, Half)

Confronta due valori con il calcolo maggiore.
MaxMagnitudeNumber(Half, Half)

Confronta due valori con il calcolo con la grandezza maggiore e restituendo l'altro valore se un input è NaN.
MaxNumber(Half, Half)

Confronta due valori con il calcolo che è maggiore e restituisce l'altro valore se un input è NaN.
Min(Half, Half)

Confronta due valori con il calcolo minore.
MinMagnitude(Half, Half)

Confronta due valori con il calcolo minore.
MinMagnitudeNumber(Half, Half)

Confronta due valori con il calcolo con la grandezza minore e restituendo l'altro valore se un input è NaN.
MinNumber(Half, Half)

Confronta due valori con il calcolo minore e restituendo l'altro valore se un input è NaN.
MultiplyAddEstimate(Half, Half, Half)

Calcola una stima di (left * right) + addend.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizza un intervallo di caratteri in un valore.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente.
Parse(String)

Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a metà precisione equivalente.
Parse(String, IFormatProvider)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nel relativo numero a virgola mobile e precisione singola equivalente.
Parse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nel numero a virgola mobile a precisione singola equivalente.
Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente.
Pow(Half, Half)

Calcola un valore elevato a una determinata potenza.
RadiansToDegrees(Half)

Converte un determinato valore da radianti a gradi.
ReciprocalEstimate(Half)

Calcola una stima del reciproco di un valore.
ReciprocalSqrtEstimate(Half)

Calcola una stima della radice quadrata reciproca di un valore.
RootN(Half, Int32)

Calcola la radice n-th di un valore.
Round(Half)

Arrotonda un valore all'intero più vicino usando la modalità di arrotondamento predefinita (ToEven).
Round(Half, Int32)

Arrotonda un valore a un numero specificato di cifre frazionarie usando la modalità di arrotondamento predefinita (ToEven).
Round(Half, Int32, MidpointRounding)

Arrotonda un valore a un numero specificato di cifre frazionarie usando la modalità di arrotondamento predefinita (ToEven).
Round(Half, MidpointRounding)

Arrotonda un valore all'intero più vicino utilizzando la modalità di arrotondamento specificata.
ScaleB(Half, Int32)

Calcola il prodotto di un valore e il relativo base-radix elevato alla potenza specificata.
Sign(Half)

Calcola il segno di un valore.
Sin(Half)

Calcola il seno di un valore.
SinCos(Half)

Calcola il seno e il coseno di un valore.
SinCosPi(Half)

Calcola il seno e il coseno di un valore moltiplicato per pi.
Sinh(Half)

Calcola il seno iperbolico di un valore.
SinPi(Half)

Calcola il seno di un valore moltiplicato per pi.
Sqrt(Half)

Calcola la radice quadrata di un valore.
Tan(Half)

Calcola la tangente di un valore.
Tanh(Half)

Calcola la tangente iperbolica di un valore.
TanPi(Half)

Calcola la tangente di un valore che è stato multiplo da pi.
ToString()

Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente.
ToString(IFormatProvider)

Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente usando le informazioni sul formato specifiche delle impostazioni cultura specificate.
ToString(String)

Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente utilizzando il formato specificato.
ToString(String, IFormatProvider)

Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente utilizzando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura.
Truncate(Half)

Tronca un valore.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Prova a formattare il valore dell'istanza corrente come UTF-8 nell'intervallo di byte specificato.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta di formattare il valore dell'istanza di Half corrente nell'intervallo di caratteri specificato.
TryParse(ReadOnlySpan<Byte>, Half)

Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nel numero a virgola mobile a metà precisione equivalente.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Half)

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Half)

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Char>, Half)

Converte la rappresentazione dell'intervallo di un numero nell'equivalente numero a virgola mobile a metà precisione. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)

Tenta di analizzare un intervallo di caratteri in un valore.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)

Converte la rappresentazione dell'intervallo di un numero nell'equivalente numero a virgola mobile a metà precisione. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(String, Half)

Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a metà precisione equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(String, IFormatProvider, Half)

Tenta di analizzare una stringa in un valore.
TryParse(String, NumberStyles, IFormatProvider, Half)

Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a metà precisione equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

Operatori

Addition(Half, Half)

Aggiunge due valori insieme per calcolare la somma.
CheckedExplicit(Half)

Rappresenta un numero a virgola mobile a metà precisione.
Decrement(Half)

Decrementa un valore.
Division(Half, Half)

Divide due valori insieme per calcolare il quoziente.
Equality(Half, Half)

Restituisce un valore che indica se due valori di Half specificati sono uguali.
Explicit(Char to Half)

Converte in modo esplicito un valore Char nel valore a virgola mobile a metà precisione più vicino.
Explicit(Decimal to Half)

Converte in modo esplicito un valore Decimal nel valore a virgola mobile a metà precisione più vicino.
Explicit(Double to Half)

Operatore esplicito per convertire un valore Double in un Half.
Explicit(Half to Byte)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Byte rappresentabile più vicino.
Explicit(Half to Char)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Char rappresentabile più vicino.
Explicit(Half to Decimal)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Decimal rappresentabile più vicino.
Explicit(Half to Double)

Operatore esplicito per convertire un valore Half in un Double.
Explicit(Half to Int128)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel relativo Int128rappresentabile più vicino.
Explicit(Half to Int16)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Int16 rappresentabile più vicino.
Explicit(Half to Int32)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Int32 rappresentabile più vicino.
Explicit(Half to Int64)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore Int64 rappresentabile più vicino.
Explicit(Half to IntPtr)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore IntPtr rappresentabile più vicino.
Explicit(Half to SByte)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore SByte rappresentabile più vicino.
Explicit(Half to Single)

Operatore esplicito per convertire un valore Half in un Single.
Explicit(Half to UInt128)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel relativo UInt128rappresentabile più vicino.
Explicit(Half to UInt16)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore UInt16 rappresentabile più vicino.
Explicit(Half to UInt32)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore UInt32 rappresentabile più vicino.
Explicit(Half to UInt64)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore UInt64 rappresentabile più vicino.
Explicit(Half to UIntPtr)

Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore UIntPtr rappresentabile più vicino.
Explicit(Int16 to Half)

Converte in modo esplicito un valore Int16 nel valore a virgola mobile a metà precisione più vicino.
Explicit(Int32 to Half)

Converte in modo esplicito un valore Int32 nel valore a virgola mobile a metà precisione più vicino.
Explicit(Int64 to Half)

Converte in modo esplicito un valore Int64 nel valore a virgola mobile a metà precisione più vicino.
Explicit(IntPtr to Half)

Converte in modo esplicito un valore IntPtr nel valore a virgola mobile a metà precisione più vicino.
Explicit(Single to Half)

Operatore esplicito per convertire un valore Single in un Half.
Explicit(UInt16 to Half)

Converte in modo esplicito un valore UInt16 nel valore a virgola mobile a metà precisione più vicino.
Explicit(UInt32 to Half)

Converte in modo esplicito un valore UInt32 nel valore a virgola mobile a metà precisione più vicino.
Explicit(UInt64 to Half)

Converte in modo esplicito un valore UInt64 nel valore a virgola mobile a metà precisione più vicino.
Explicit(UIntPtr to Half)

Converte in modo esplicito un valore UIntPtr nel valore a virgola mobile a metà precisione più vicino.
GreaterThan(Half, Half)

Restituisce un valore che indica se un valore di Half specificato è maggiore di un altro valore Half specificato.
GreaterThanOrEqual(Half, Half)

Restituisce un valore che indica se left è maggiore o uguale a right.
Implicit(Byte to Half)

Converte in modo implicito un valore Byte nel valore a virgola mobile a metà precisione più vicino.
Implicit(SByte to Half)

Converte in modo implicito un valore SByte nel valore a virgola mobile a metà precisione più vicino.
Increment(Half)

Incrementa un valore.
Inequality(Half, Half)

Restituisce un valore che indica se due valori di Half specificati non sono uguali.
LessThan(Half, Half)

Restituisce un valore che indica se un valore Half specificato è minore di un altro valore Half specificato.
LessThanOrEqual(Half, Half)

Restituisce un valore che indica se un valore Half specificato è minore o uguale a un altro valore Half specificato.
Modulus(Half, Half)

Divide due valori insieme per calcolare il modulo o il resto.
Multiply(Half, Half)

Moltiplica due valori insieme per calcolare il prodotto.
Subtraction(Half, Half)

Sottrae due valori per calcolare la differenza.
UnaryNegation(Half)

Calcola la negazione unaria di un valore.
UnaryPlus(Half)

Calcola il plus unario di un valore.

Implementazioni dell'interfaccia esplicita

IAdditiveIdentity<Half,Half>.AdditiveIdentity

Ottiene l'identità aggiuntiva del tipo corrente.
IBinaryNumber<Half>.AllBitsSet

Ottiene un'istanza del tipo binario in cui vengono impostati tutti i bit.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)

Calcola i valori bit per bit e di due valori.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)

Calcola i valori bit per bit o di due valori.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)

Calcola il valore esclusivo o di due valori.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)

Calcola la rappresentazione di complemento di un determinato valore.
IFloatingPoint<Half>.GetExponentByteCount()

Ottiene il numero di byte che verranno scritti come parte di TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()

Ottiene la lunghezza, espressa in bit, della rappresentazione di complemento più breve dell'esponente corrente.
IFloatingPoint<Half>.GetSignificandBitLength()

Ottiene la lunghezza, espressa in bit, del significando corrente.
IFloatingPoint<Half>.GetSignificandByteCount()

Ottiene il numero di byte che verranno scritti come parte di TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<Byte>, Int32)

Prova a scrivere l'esponente corrente, in formato big-endian, in un determinato intervallo.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)

Prova a scrivere l'esponente corrente, in formato little-endian, in un intervallo specificato.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)

Prova a scrivere il significando corrente, in formato big-endian, in un intervallo specificato.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)

Prova a scrivere il significando corrente, in formato little-endian, in un intervallo specificato.
INumberBase<Half>.IsCanonical(Half)

Determina se un valore è nella relativa rappresentazione canonica.
INumberBase<Half>.IsComplexNumber(Half)

Determina se un valore rappresenta un numero complesso.
INumberBase<Half>.IsImaginaryNumber(Half)

Determina se un valore rappresenta un numero immaginario puro.
INumberBase<Half>.IsZero(Half)

Determina se un valore è zero.
INumberBase<Half>.Radix

Ottiene il radix o la base per il tipo .
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)

Rappresenta un numero a virgola mobile a metà precisione.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)

Rappresenta un numero a virgola mobile a metà precisione.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)

Rappresenta un numero a virgola mobile a metà precisione.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, saturando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.

Si applica a

Vedi anche