Half

Kotlin |Java

class Half : Number, Comparable<Half!>

kotlin.Any
↳	kotlin.Number
	↳	android.util.Half

The Half class is a wrapper and a utility class to manipulate half-precision 16-bit IEEE 754 floating point data types (also called fp16 or binary16). A half-precision float can be created from or converted to single-precision floats, and is stored in a short data type. To distinguish short values holding half-precision floats from regular short values, it is recommended to use the @HalfFloat annotation.

The IEEE 754 standard specifies an fp16 as having the following format:

Sign bit: 1 bit
Exponent width: 5 bits
Significand: 10 bits

The format is laid out as follows:

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

Half-precision floating points can be useful to save memory and/or bandwidth at the expense of range and precision when compared to single-precision floating points (fp32).

To help you decide whether fp16 is the right storage type for you need, please refer to the table below that shows the available precision throughout the range of possible values. The precision column indicates the step size between two consecutive numbers in a specific part of the range.

Range start	Precision
0	1 ⁄ 16,777,216
1 ⁄ 16,384	1 ⁄ 16,777,216
1 ⁄ 8,192	1 ⁄ 8,388,608
1 ⁄ 4,096	1 ⁄ 4,194,304
1 ⁄ 2,048	1 ⁄ 2,097,152
1 ⁄ 1,024	1 ⁄ 1,048,576
1 ⁄ 512	1 ⁄ 524,288
1 ⁄ 256	1 ⁄ 262,144
1 ⁄ 128	1 ⁄ 131,072
1 ⁄ 64	1 ⁄ 65,536
1 ⁄ 32	1 ⁄ 32,768
1 ⁄ 16	1 ⁄ 16,384
1 ⁄ 8	1 ⁄ 8,192
1 ⁄ 4	1 ⁄ 4,096
1 ⁄ 2	1 ⁄ 2,048
1	1 ⁄ 1,024
2	1 ⁄ 512
4	1 ⁄ 256
8	1 ⁄ 128
16	1 ⁄ 64
32	1 ⁄ 32
64	1 ⁄ 16
128	1 ⁄ 8
256	1 ⁄ 4
512	1 ⁄ 2
1,024	1
2,048	2
4,096	4
8,192	8
16,384	16
32,768	32

This table shows that numbers higher than 1024 lose all fractional precision.

Summary

Constants
static Short	`EPSILON` Epsilon is the difference between 1.
static Short	`LOWEST_VALUE` Smallest negative value a half-precision float may have.
static Int	`MAX_EXPONENT` Maximum exponent a finite half-precision float may have.
static Short	`MAX_VALUE` Maximum positive finite value a half-precision float may have.
static Int	`MIN_EXPONENT` Minimum exponent a normalized half-precision float may have.
static Short	`MIN_NORMAL` Smallest positive normal value a half-precision float may have.
static Short	`MIN_VALUE` Smallest positive non-zero value a half-precision float may have.
static Short	`NEGATIVE_INFINITY` Negative infinity of type half-precision float.
static Short	`NEGATIVE_ZERO` Negative 0 of type half-precision float.
static Short	`NaN` A Not-a-Number representation of a half-precision float.
static Short	`POSITIVE_INFINITY` Positive infinity of type half-precision float.
static Short	`POSITIVE_ZERO` Positive 0 of type half-precision float.
static Int	`SIZE` The number of bits used to represent a half-precision float value.

Public constructors
`Half(value: Short)` Constructs a newly allocated `Half` object that represents the half-precision float type argument.
`Half(value: Float)` Constructs a newly allocated `Half` object that represents the argument converted to a half-precision float.
`Half(value: Double)` Constructs a newly allocated `Half` object that represents the argument converted to a half-precision float.
`Half(value: String)` Constructs a newly allocated `Half` object that represents the half-precision float value represented by the string.

Public methods
static Short	`abs(h: Short)` Returns the absolute value of the specified half-precision float.
static Short	`ceil(h: Short)` Returns the smallest half-precision float value toward negative infinity greater than or equal to the specified half-precision float value.
static Int	`compare(x: Short, y: Short)` Compares the two specified half-precision float values.
Int	`compareTo(other: Half)` Compares the two specified half-precision float values.
static Short	`copySign(magnitude: Short, sign: Short)` Returns the first parameter with the sign of the second parameter.
Boolean	`equals(other: Any?)` Compares this object against the specified object.
static Boolean	`equals(x: Short, y: Short)` Returns true if the two half-precision float values are equal.
static Short	`floor(h: Short)` Returns the largest half-precision float value toward positive infinity less than or equal to the specified half-precision float value.
static Int	`getExponent(h: Short)` Returns the unbiased exponent used in the representation of the specified half-precision float value.
static Int	`getSign(h: Short)` Returns the sign of the specified half-precision float.
static Int	`getSignificand(h: Short)` Returns the significand, or mantissa, used in the representation of the specified half-precision float value.
static Boolean	`greater(x: Short, y: Short)` Returns true if the first half-precision float value is greater (larger toward positive infinity) than the second half-precision float value.
static Boolean	`greaterEquals(x: Short, y: Short)` Returns true if the first half-precision float value is greater (larger toward positive infinity) than or equal to the second half-precision float value.
static Int	`halfToIntBits(h: Short)` Returns a representation of the specified half-precision float value according to the bit layout described in `Half`.
static Int	`halfToRawIntBits(h: Short)` Returns a representation of the specified half-precision float value according to the bit layout described in `Half`.
static Short	`halfToShortBits(h: Short)` Returns a representation of the specified half-precision float value according to the bit layout described in `Half`.
Short	`halfValue()` Returns the half-precision value of this `Half` as a `short` containing the bit representation described in `Half`.
Int	`hashCode()` Returns a hash code for this `Half` object.
static Int	`hashCode(h: Short)` Returns a hash code for a half-precision float value.
static Short	`intBitsToHalf(bits: Int)` Returns the half-precision float value corresponding to a given bit representation.
static Boolean	`isInfinite(h: Short)` Returns true if the specified half-precision float value represents infinity, false otherwise.
Boolean	`isNaN()` Returns true if this `Half` value represents a Not-a-Number, false otherwise.
static Boolean	`isNaN(h: Short)` Returns true if the specified half-precision float value represents a Not-a-Number, false otherwise.
static Boolean	`isNormalized(h: Short)` Returns true if the specified half-precision float value is normalized (does not have a subnormal representation).
static Boolean	`less(x: Short, y: Short)` Returns true if the first half-precision float value is less (smaller toward negative infinity) than the second half-precision float value.
static Boolean	`lessEquals(x: Short, y: Short)` Returns true if the first half-precision float value is less (smaller toward negative infinity) than or equal to the second half-precision float value.
static Short	`max(x: Short, y: Short)` Returns the larger of two half-precision float values (the value closest to positive infinity).
static Short	`min(x: Short, y: Short)` Returns the smaller of two half-precision float values (the value closest to negative infinity).
static Short	`parseHalf(s: String)` Returns the half-precision float value represented by the specified string.
static Short	`round(h: Short)` Returns the closest integral half-precision float value to the specified half-precision float value.
Byte	`toByte()` Returns the value of this `Half` as a `byte` after a narrowing primitive conversion.
Double	`toDouble()` Returns the value of this `Half` as a `double` after a widening primitive conversion.
Float	`toFloat()` Returns the value of this `Half` as a `float` after a widening primitive conversion.
static Float	`toFloat(h: Short)` Converts the specified half-precision float value into a single-precision float value.
static Short	`toHalf(f: Float)` Converts the specified single-precision float value into a half-precision float value.
static String	`toHexString(h: Short)` Returns a hexadecimal string representation of the specified half-precision float value.
Int	`toInt()` Returns the value of this `Half` as a `int` after a narrowing primitive conversion.
Long	`toLong()` Returns the value of this `Half` as a `long` after a narrowing primitive conversion.
Short	`toShort()` Returns the value of this `Half` as a `short` after a narrowing primitive conversion.
String	`toString()` Returns a string representation of the specified half-precision float value.
static String	`toString(h: Short)` Returns a string representation of the specified half-precision float value.
static Short	`trunc(h: Short)` Returns the truncated half-precision float value of the specified half-precision float value.
static Half	`valueOf(h: Short)` Returns a `Half` instance representing the specified half-precision float value.
static Half	`valueOf(f: Float)` Returns a `Half` instance representing the specified float value.
static Half	`valueOf(s: String)` Returns a `Half` instance representing the specified string value.

Parameters
`x`	Short: The first half-precision float value to compare.
`y`	Short: The second half-precision float value to compare

Parameters
`o`	the object to be compared.
`h`	The half-precision float value to compare to the half-precision value represented by this `Half` object This value cannot be `null`.

Exceptions
`java.lang.NullPointerException`	if the specified object is null
`java.lang.ClassCastException`	if the specified object's type prevents it from being compared to this object.

Parameters
`magnitude`	Short: A half-precision float value providing the magnitude of the result
`sign`	Short: A half-precision float value providing the sign of the result

Parameters
`obj`	the reference object with which to compare.
`o`	The object to compare This value may be `null`.

Parameters
`x`	Short: The first half-precision value
`y`	Short: The second half-precision value

Half

Summary

Constants

EPSILON

LOWEST_VALUE

MAX_EXPONENT

MAX_VALUE

MIN_EXPONENT

MIN_NORMAL

MIN_VALUE

NEGATIVE_INFINITY

NEGATIVE_ZERO

NaN

POSITIVE_INFINITY

POSITIVE_ZERO

SIZE

Public constructors

Half

Half

Half

Half

Public methods

abs

ceil

compare

compareTo

copySign

equals

equals

floor

getExponent

getSign

getSignificand

greater

greaterEquals

halfToIntBits

halfToRawIntBits

halfToShortBits

halfValue

hashCode

hashCode

intBitsToHalf

isInfinite

isNaN

isNaN

isNormalized

less

lessEquals

max

min

parseHalf

round

toByte

toDouble

toFloat

toFloat

toHalf

toHexString

toInt

toLong

toShort

toString

toString

trunc

valueOf

valueOf

valueOf