Langue

Half Classe

Définition

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

[Android.Runtime.Register("android/util/Half", ApiSince=26, DoNotGenerateAcw=true)]
public sealed class Half : Java.Lang.Number, IDisposable, Java.Lang.IComparable
[<Android.Runtime.Register("android/util/Half", ApiSince=26, DoNotGenerateAcw=true)>]
type Half = class
    inherit Number
    interface IComparable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
Héritage
Attributs
Implémente

Remarques

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16). Un float de demi-précision peut être créé à partir ou converti en floats à précision unique et est stocké dans un type de données court. Pour distinguer les valeurs courtes contenant des floats de demi-précision à partir de valeurs courtes régulières, il est recommandé d’utiliser l’annotation @HalfFloat .

La norme IEEE 754 spécifie un fp16 comme ayant le format suivant :

<ul>li Sign bit : 1 bit</li><>Exponent width : 5 bits</li li><Significand> : 10 bits</li></ul><>

Le format est présenté comme suit :

1   11111   1111111111
            ^   --^--   -----^----
            sign  |          |_______ significand
                  |
                  -- exponent

Les virgules flottantes demi-précision peuvent être utiles pour économiser de la mémoire et/ou de la bande passante au détriment de la plage et de la précision par rapport aux virgules flottantes simple précision (fp32).

Pour vous aider à déterminer si fp16 est le bon type de stockage dont vous avez besoin, reportez-vous au tableau ci-dessous qui indique la précision disponible dans toute la plage de valeurs possibles. La <colonne em>precision</em> indique la taille de l’étape entre deux nombres consécutifs dans une partie spécifique de la plage.

<table summary="Precision of fp16 across the range">tr th Range start</th><>th Precision</th></tr tr><><td>0</td td><>1 &frasl ; 16 777 216</td></tr tr><><td>1 &frasl ; 16 384</td td><>1 &frasl ; 16 777,216</td></tr><tr><td>1 &frasl ; 8,192</td td><>1 &frasl ; 8,388,608</td></tr tr><><><><td>1 &frasl ; 4 096</td td><>1 &frasl ; 4 194 304</td></tr tr><><>1 &frasl ; 2 048</td td><>1 &frasl ; 2 097 152</td></tr tr><td><>1 &frasl ; 1 024</td td><>1 &frasl ; 1 048 576</td></tr tr><tr><>1 &frasl ; 512</td td><>1 &frasl ; 524 288</td></tr tr><><>tr 1 &frasl ; 256</td td><>1 &frasl ; 262 144</td></tr td><><>1 &frasl ; 128</td td><>1 &frasl ; 131 072</td></tr tr><td><>1 &frasl ; 64</td td><>1 &frasl ; 65 536</td></tr tr><tr><td>1 &frasl ; 32</td td><>1 &frasl ; 32,768</td></tr tr><><td>1 &frasl ; 16</td td 1><> &frasl ; 16 384/td/tr tr tr<><><1 &frasl ; 8></td td><1 &frasl ; 8 192></td>/tr tr<><>td<1 &frasl ; 4></td td><1 &frasl ; 4 096></td>/tr tr<><><1 &frasl ; 2></td td><1 &frasl ; 2 048></td>/tr<><><td 1></td><1 &frasl ; 1 024></td>/tr<><><tr><td>2/<td td><1 &frasl ; 512>/td</tr><>tr<td><4>/td td<><1 &frasl ; 256></td></tr tr><><>td 8</td td><>1 &frasl ; 128</td></tr><><>16</td><>1 &frasl ; 64</td></tr tr><><td>32/td<><1 &frasl ; 32></td></tr tr><><td>64</td td><>1 &frasl ; 16</td></tr tr><><td>128</td><>1 &frasl ; 8</td></tr tr><><>td 256</td td><>1 &frasl ; 4</td></tr><tr><td>512</td td><>1 &frasl ; 2</td></tr><tr><td>1,024</td><td 1/td>/tr tr<><>td<2 048></td td><2></td>/tr<><td><4 096></td td><4/td 4></td>/tr<><tr><8 192></td td><8/td 8></td>/tr tr<><><16 384></td td><16/td 16></td>/tr<><tr>td<32,768></td td>32/td 32</td><><></tr></table>

Ce tableau montre que les nombres supérieurs à 1024 perdent toutes les précisions fractionnaires.

Java documentation pour android.util.Half.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.

Constructeurs

Nom Description
Half(Double)

Construit un objet nouvellement alloué Half qui représente l’argument converti en float demi-précision.

Half(Int16)

Construit un objet nouvellement alloué Half qui représente l’argument de type float demi-précision.

Half(Single)

Construit un objet nouvellement alloué Half qui représente l’argument converti en float demi-précision.

Half(String)

Construit un objet nouvellement alloué Half qui représente la valeur float demi-précision représentée par la chaîne.

Champs

Nom Description
Epsilon

Epsilon est la différence entre 1.

LowestValue

La valeur négative la plus petite qu’un float demi-précision peut avoir.

MaxExponent

L’exposant maximal d’un flotteur à demi-précision fini peut avoir.

MaxValue

La valeur finie maximale positive qu’un float demi-précision peut avoir.

MinExponent

L’exposant minimal d’un flotteur de demi-précision normalisé peut avoir.

MinNormal

La plus petite valeur normale positive qu’un float demi-précision peut avoir.

MinValue

La plus petite valeur positive non nulle une valeur flottante de demi-précision peut avoir.

NaN

Représentation non numérique d’un float demi-précision.

NegativeInfinity

Infini négatif du type float demi-précision.

NegativeZero

Valeur flottante de type demi-précision négative.

PositiveInfinity

Infini positif de type float demi-précision.

PositiveZero

Positif 0 de type demi-précision float.

Size

Nombre de bits utilisés pour représenter une valeur float demi-précision.

Propriétés

Nom Description
Class

Retourne la classe runtime de ce Object.

(Hérité de Object)
Handle

Handle de l’instance Android sous-jacente.

(Hérité de Object)
IsNaN

Retourne la valeur true si cette Half valeur représente une valeur Not-a-Number, false dans le cas contraire.

JniIdentityHashCode

Obtient le code de hachage d’identité affecté à cet homologue Java par le runtime d’interopérabilité.

(Hérité de Object)
JniManagedPeerState

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
JniPeerMembers

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

PeerReference

Obtient la référence d’objet JNI pour cet homologue Java.

(Hérité de Object)
ThresholdClass

Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.

(Hérité de Number)
ThresholdType

Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.

(Hérité de Number)

Méthodes

Nom Description
Abs(Int16)

Retourne la valeur absolue du float demi-précision spécifié.

ByteValue()

Retourne la valeur du nombre spécifié en tant que byte.

(Hérité de Number)
Ceil(Int16)

Retourne la plus petite valeur flottante demi-précision vers l’infini négatif supérieur ou égal à la valeur flottante demi-précision spécifiée.

Clone()

Crée et retourne une copie de cet objet.

(Hérité de Object)
Compare(Int16, Int16)

Compare les deux valeurs float demi-précision spécifiées.

CompareTo(Half)

Compare les deux valeurs float demi-précision spécifiées.

Construct(JniObjectReference, JniObjectReferenceOptions)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
CopySign(Int16, Int16)

Retourne le premier paramètre avec le signe du deuxième paramètre.

Dispose()

Libère les ressources détenues par cet homologue Java.

(Hérité de Object)
Dispose(Boolean)

Libère les ressources détenues par cet homologue Java.

(Hérité de Object)
DisposeUnlessReferenced()

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
DoubleValue()

Retourne la valeur de ceci Half sous la forme d’une double conversion primitive étendue.

Equals(Int16, Int16)

Retourne true si les deux valeurs float de demi-précision sont égales.

Equals(Object)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
Equals(Object)

Indique si un autre objet est « égal à » celui-ci.

(Hérité de Object)
FloatValue()

Retourne la valeur de ceci Half sous la forme d’une float conversion primitive étendue.

Floor(Int16)

Retourne la plus grande valeur flottante de demi-précision vers l’infini positif inférieur ou égal à la valeur flottante demi-précision spécifiée.

GetExponent(Int16)

Retourne l’exposant non biaisé utilisé dans la représentation de la valeur flottante demi-précision spécifiée.

GetHashCode()

Retourne une valeur de code de hachage pour l’objet.

(Hérité de Object)
GetSign(Int16)

Retourne le signe du float demi-précision spécifié.

GetSignificand(Int16)

Retourne le significand, ou mantissa, utilisé dans la représentation de la valeur flottante demi-précision spécifiée.

Greater(Int16, Int16)

Retourne true si la valeur flottante de la première demi-précision est supérieure (plus grande vers l’infini positif) que la deuxième valeur flottante de demi-précision.

GreaterEquals(Int16, Int16)

Retourne true si la valeur flottante de la première demi-précision est supérieure (supérieure à l’infini positif) ou égale à la deuxième valeur flottante de demi-précision.

HalfToIntBits(Int16)

Retourne une représentation de la valeur flottante demi-précision spécifiée en fonction de la disposition de bits décrite dans Half.

HalfToRawIntBits(Int16)

Retourne une représentation de la valeur flottante demi-précision spécifiée en fonction de la disposition de bits décrite dans Half.

HalfToShortBits(Int16)

Retourne une représentation de la valeur flottante demi-précision spécifiée en fonction de la disposition de bits décrite dans Half.

HalfValue()

Retourne la valeur de demi-précision de cette Half valeur sous la forme d’une short représentation binaire contenant la représentation binaire décrite dans Half.

HashCode(Int16)

Retourne un code de hachage pour une valeur float demi-précision.

IntBitsToHalf(Int32)

Retourne la valeur flottante de demi-précision correspondant à une représentation de bits donnée.

IntValue()

Retourne la valeur de ceci Half sous la forme d’une int conversion primitive étroite.

InvokeIsNaN(Int16)

Retourne la valeur true si la valeur float de demi-précision spécifiée représente un nombre not-a-number, false sinon.

IsInfinite(Int16)

Retourne true si la valeur flottante demi-précision spécifiée représente l’infini, false sinon.

IsNormalized(Int16)

Retourne la valeur true si la valeur float de demi-précision spécifiée est normalisée (n’a pas de représentation subnormale).

JavaFinalize()

Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet.

(Hérité de Object)
Less(Int16, Int16)

Retourne true si la valeur flottante de la première demi-précision est inférieure (plus petite vers l’infini négatif) que la deuxième valeur flottante de demi-précision.

LessEquals(Int16, Int16)

Retourne true si la valeur flottante de la première demi-précision est inférieure (plus petite vers l’infini négatif) ou égale à la deuxième valeur flottante de demi-précision.

LongValue()

Retourne la valeur de ceci Half sous la forme d’une long conversion primitive étroite.

Max(Int16, Int16)

Retourne la plus grande de deux valeurs float de demi-précision (la valeur la plus proche de l’infini positif).

Min(Int16, Int16)

Retourne la plus petite de deux valeurs flottantes de demi-précision (la valeur la plus proche de l’infini négatif).

Notify()

Réveille un thread unique qui attend le moniteur de cet objet.

(Hérité de Object)
NotifyAll()

Réveille tous les threads qui attendent le moniteur de cet objet.

(Hérité de Object)
ParseHalf(String)

Retourne la valeur flottante demi-précision représentée par la chaîne spécifiée.

Round(Int16)

Retourne la valeur flottante de demi-précision la plus proche à la valeur flottante demi-précision spécifiée.

SetHandle(IntPtr, JniHandleOwnership)

Définit la propriété Handle.

(Hérité de Object)
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
ShortValue()

Retourne la valeur du nombre spécifié en tant que short.

(Hérité de Number)
ToArray<T>()

Crée un tableau managé à partir de ce wrapper de tableau Java.

(Hérité de Object)
ToFloat(Int16)

Convertit la valeur flottante de demi-précision spécifiée en valeur flottante à précision unique.

ToHalf(Single)

Convertit la valeur flottante à précision unique spécifiée en valeur float demi-précision.

ToHexString(Int16)

Retourne une représentation sous forme de chaîne hexadécimale de la valeur float demi-précision spécifiée.

ToString()

Retourne une représentation sous forme de chaîne de l’objet.

(Hérité de Object)
ToString(Int16)

Retourne une représentation sous forme de chaîne de la valeur float demi-précision spécifiée.

Trunc(Int16)

Retourne la valeur flottante demi-précision tronquée de la valeur flottante demi-précision spécifiée.

UnregisterFromRuntime()

Annule l’inscription de cet homologue Java à partir du runtime d’interopérabilité.

(Hérité de Object)
ValueOf(Int16)

Retourne une Half instance représentant la valeur flottante demi-précision spécifiée.

ValueOf(Single)

Retourne une Half instance représentant la valeur float spécifiée.

ValueOf(String)

Retourne une Half instance représentant la valeur de chaîne spécifiée.

Wait()

Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<>

(Hérité de Object)
Wait(Int64, Int32)

Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée.

(Hérité de Object)
Wait(Int64)

Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée.

(Hérité de Object)

Implémentations d’interfaces explicites

Nom Description
IComparable.CompareTo(Object)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

IJavaPeerable.Disposed()

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.Finalized()

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

(Hérité de JavaObject)
IJavaPeerable.UnregisterFromRuntime()

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

Méthodes d’extension

Nom Description
GetJniTypeName(IJavaPeerable)

Obtient le nom JNI du type de l’instance self.

JavaAs<TResult>(IJavaPeerable)

Essayez de forcer self le typeTResult, en vérifiant que le forçage est valide côté Java.

JavaCast<TResult>(IJavaObject)

Effectue une conversion de type vérifiée par le runtime Android.

JavaCast<TResult>(IJavaObject)

La Half classe est un wrapper et une classe utilitaire pour manipuler des types de données à virgule flottante IEEE 754 demi-précision 754 (également appelés fp16 ou binary16).

TryJavaCast<TResult>(IJavaPeerable, TResult)

Essayez de forcer self le typeTResult, en vérifiant que le forçage est valide côté Java.

S’applique à