Half Struct

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Rappresenta un numero a virgola mobile e precisione a metà.

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>, IUtf8SpanFormattable, 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>, IUtf8SpanFormattable, 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 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>
    interface IUtf8SpanFormattable

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), IUtf8SpanFormattable

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

Commenti

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

Si tratta di un tipo conforme a float16 IEEE 754.

Proprietà

E	Ottiene la costante ematematica .
Epsilon	Rappresenta il valore Half positivo più piccolo 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 valore non numerico.
NegativeInfinity	Rappresenta l'infinito negativo.
NegativeOne	Ottiene il valore -1 per il tipo.
NegativeZero	Ottiene un valore che rappresenta un valore negativo zero.
One	Ottiene il valore 1 per il tipo.
Pi	Ottiene la costante pimatematica .
PositiveInfinity	Rappresenta l'infinito positivo.
Tau	Ottiene la costante taumatematica .
Zero	Ottiene il valore 0 per il tipo.

Metodi

Abs(Half)	Calcola l'assoluto di un valore.
Acos(Half)	Calcola il cosno arco di un valore.
Acosh(Half)	Calcola il cosno dell'arco iperbolico di un valore.
AcosPi(Half)	Calcola il cosno arco di un valore e divide il risultato in base pia .
Asin(Half)	Calcola il sine arco di un valore.
Asinh(Half)	Calcola il sine dell'arco iperbolico di un valore.
AsinPi(Half)	Calcola il sine arc di un valore e divide il risultato in base pia .
Atan(Half)	Calcola la tangente arco di un valore.
Atan2(Half, Half)	Calcola la tangente arc-tangente del quoziente di due valori.
Atan2Pi(Half, Half)	Calcola la tangente arc-tangente per il quoziente di due valori e divide il risultato in base pia .
Atanh(Half)	Calcola la tangente dell'arco iperbolico di un valore.
AtanPi(Half)	Calcola la tangente arc-tangente di un valore e divide il risultato in base a pi.
BitDecrement(Half)	Decrementa un valore al valore più piccolo che confronta meno di un valore specificato.
BitIncrement(Half)	Incrementa un valore al valore più piccolo che confronta maggiore di un determinato valore.
Cbrt(Half)	Calcola la radice del cubo di un valore.
Ceiling(Half)	Calcola il soffitto 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 in mezza precisione specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero a virgola mobile in mezza precisione specificato.
CompareTo(Object)	Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore rispetto al valore dell'oggetto specificato.
CopySign(Half, Half)	Copia il segno di un valore nel segno di un altro valore.
Cos(Half)	Calcola il cosno di un valore.
Cosh(Half)	Calcola il cosno iperbolico di un valore.
CosPi(Half)	Calcola il cosno 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 rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.
CreateSaturating<TOther>(TOther)	Crea un'istanza del tipo corrente da un valore, saturazione di tutti i valori che rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.
CreateTruncating<TOther>(TOther)	Crea un'istanza del tipo corrente da un valore, troncando tutti i valori che rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.
Equals(Half)	Verifica l'uguaglianza di questa istanza con other.
Equals(Object)	Restituisce un valore che indica se l'istanza è uguale all’oggetto obj specificato.
Exp(Half)	Calcoli E generati a una determinata potenza.
Exp10(Half)	Calcoli 10 generati a una determinata potenza.
Exp10M1(Half)	I calcoli 10 generati a una determinata potenza e sottraggono uno.
Exp2(Half)	Calcoli 2 generati a una determinata potenza.
Exp2M1(Half)	I calcoli 2 generati a una determinata potenza e sottraggono uno.
ExpM1(Half)	I calcoli E generati a una determinata potenza e sottraggono uno.
Floor(Half)	Calcola il piano di un valore.
FusedMultiplyAdd(Half, Half, Half)	Calcola l'aggiunta moltiplicata di tre valori fusi.
GetHashCode()	Restituisce il codice hash per l'istanza.
Hypot(Half, Half)	Calcola l'ipotenuse dato due valori che rappresentano le lunghezze dei lati più brevi in un triangolo a 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, subnormale o normale).
IsInfinity(Half)	Restituisce un valore che indica se il numero specificato restituisce l'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 è subnormale.
Lerp(Half, Half, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
Log(Half)	Calcola il logaritmo naturalebase-E 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 di base-10 di un valore più uno.
Log2(Half)	Calcola il log2 di un valore.
Log2P1(Half)	Calcola il logaritmo di 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 per calcolare che è maggiore.
MaxMagnitude(Half, Half)	Confronta due valori per calcolare che è maggiore.
MaxMagnitudeNumber(Half, Half)	Confronta due valori per calcolare che ha la grandezza maggiore e restituisce l'altro valore se un input è NaN.
MaxNumber(Half, Half)	Confronta due valori per calcolare che è maggiore e restituisce l'altro valore se un input è NaN.
Min(Half, Half)	Confronta due valori per calcolare che è minore.
MinMagnitude(Half, Half)	Confronta due valori per calcolare che è minore.
MinMagnitudeNumber(Half, Half)	Confronta due valori per calcolare che ha la grandezza minore e restituisce l'altro valore se un input è NaN.
MinNumber(Half, Half)	Confronta due valori per calcolare che è minore e restituisce l'altro valore se un input è NaN.
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 rispettivo numero a virgola mobile in mezza precisione equivalente.
Parse(String, IFormatProvider)	Converte la rappresentazione di stringa di un numero in un determinato formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente.
Parse(String, NumberStyles)	Converte la rappresentazione di stringa di un numero in uno stile specificato nel rispettivo 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.
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 radix di base 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 multiplo da pi.
ToString()	Converte il valore numerico dell'istanza nella rappresentazione di stringa equivalente.
ToString(IFormatProvider)	Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente usando le informazioni di formato specifiche delle impostazioni cultura.
ToString(String)	Converte il valore numerico di questa istanza nell'equivalente rappresentazione di stringa usando il formato specificato.
ToString(String, IFormatProvider)	Converte il valore numerico dell'istanza nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura.
Truncate(Half)	Tronca un valore.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Rappresenta un numero a virgola mobile e precisione a metà.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Prova a formattare il valore dell'istanza Half corrente nell'intervallo di caratteri specificato.
TryParse(ReadOnlySpan<Char>, Half)	Converte la rappresentazione di un intervallo di un numero nel rispettivo numero a virgola mobile in mezza precisione equivalente. Un valore restituito indica se la conversione è riuscita o meno.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Half)	Tenta di analizzare un intervallo di caratteri in un valore.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Half)	Converte la rappresentazione di un intervallo di un numero nel rispettivo numero a virgola mobile in mezza precisione equivalente. Un valore restituito indica se la conversione è riuscita o meno.
TryParse(String, Half)	Converte la rappresentazione di stringa di un numero nel rispettivo numero a virgola mobile in mezza precisione equivalente. Un valore restituito indica se la conversione è riuscita o meno.
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 rispettivo numero a virgola mobile in mezza precisione equivalente. Un valore restituito indica se la conversione è riuscita o meno.

Operatori

Addition(Half, Half)	Aggiunge due valori insieme per calcolare la somma.
CheckedExplicit(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
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 Half specificati sono uguali.
Explicit(Char to Half)	Converte in modo esplicito un Char valore nel valore a virgola mobile più vicina.
Explicit(Decimal to Half)	Converte in modo esplicito un Decimal valore nel valore a virgola mobile più vicina.
Explicit(Double to Half)	Operatore esplicito per convertire un valore Double in un valore Half.
Explicit(Half to Byte)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Byte più vicino.
Explicit(Half to Char)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Char più vicino.
Explicit(Half to Decimal)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Decimal più vicino.
Explicit(Half to Double)	Operatore esplicito per convertire un valore Half in un valore Double.
Explicit(Half to Int128)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore più vicino rappresentabile Int128.
Explicit(Half to Int16)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Int16 più vicino.
Explicit(Half to Int32)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Int32 più vicino.
Explicit(Half to Int64)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile Int64 più vicino.
Explicit(Half to IntPtr)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile IntPtr più vicino.
Explicit(Half to SByte)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile SByte più vicino.
Explicit(Half to Single)	Operatore esplicito per convertire un valore Half in un valore Single.
Explicit(Half to UInt128)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentato UInt128più vicino.
Explicit(Half to UInt16)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile UInt16 più vicino.
Explicit(Half to UInt32)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile UInt32 più vicino.
Explicit(Half to UInt64)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile UInt64 più vicino.
Explicit(Half to UIntPtr)	Converte in modo esplicito un valore a virgola mobile a metà precisione nel valore rappresentabile UIntPtr più vicino.
Explicit(Int16 to Half)	Converte in modo esplicito un Int16 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(Int32 to Half)	Converte in modo esplicito un Int32 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(Int64 to Half)	Converte in modo esplicito un Int64 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(IntPtr to Half)	Converte in modo esplicito un IntPtr valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(Single to Half)	Operatore esplicito per convertire un valore Single in un valore Half.
Explicit(UInt16 to Half)	Converte in modo esplicito un UInt16 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(UInt32 to Half)	Converte in modo esplicito un UInt32 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(UInt64 to Half)	Converte in modo esplicito un UInt64 valore nel valore a virgola mobile a metà precisione più vicino.
Explicit(UIntPtr to Half)	Converte in modo esplicito un UIntPtr valore nel valore a virgola mobile a metà precisione più vicino.
GreaterThan(Half, Half)	Restituisce un valore che indica se un valore Halfspecificato è maggiore di un altro valore Half specificato.
GreaterThanOrEqual(Half, Half)	Restituisce un valore che indica se un valore left è maggiore o uguale a un valore right.
Implicit(Byte to Half)	Converte in modo implicito un Byte valore nel valore a virgola mobile a metà precisione più vicino.
Implicit(SByte to Half)	Converte in modo implicito un SByte valore 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 Half specificati non sono uguali.
LessThan(Half, Half)	Restituisce un valore che indica se il valore Half specificato è minore o uguale a 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 segno più unario di un valore.

Implementazioni dell'interfaccia esplicita

IAdditiveIdentity<Half,Half>.AdditiveIdentity	Rappresenta un numero a virgola mobile e precisione a metà.
IBinaryNumber<Half>.AllBitsSet	Rappresenta un numero a virgola mobile e precisione a metà.
IBitwiseOperators<Half,Half,Half>.BitwiseAnd(Half, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
IBitwiseOperators<Half,Half,Half>.BitwiseOr(Half, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
IBitwiseOperators<Half,Half,Half>.ExclusiveOr(Half, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
IBitwiseOperators<Half,Half,Half>.OnesComplement(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
IFloatingPoint<Half>.GetExponentByteCount()	Ottiene il numero di byte che verranno scritti come parte di TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Half>.GetExponentShortestBitLength()	Ottiene la lunghezza, in bit, della rappresentazione di complemento più breve di due 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)	Tenta di scrivere l'esponente corrente, in formato big-endian, in un determinato intervallo.
IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Tenta di scrivere l'esponente corrente, in formato little-endian, in un determinato intervallo.
IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Tenta di scrivere il significando corrente, in formato big-endian, in un determinato intervallo.
IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Tenta di scrivere il significando corrente, in formato little-endian, in un determinato intervallo.
INumberBase<Half>.IsCanonical(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.IsComplexNumber(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.IsImaginaryNumber(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.IsZero(Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.Radix	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertFromChecked<TOther>(TOther, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther, Half)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertToChecked<TOther>(Half, TOther)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertToSaturating<TOther>(Half, TOther)	Rappresenta un numero a virgola mobile e precisione a metà.
INumberBase<Half>.TryConvertToTruncating<TOther>(Half, TOther)	Rappresenta un numero a virgola mobile e precisione a metà.

Vedi anche

• Single