Half
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 is the difference between 1. |
static Short |
Smallest negative value a half-precision float may have. |
static Int |
Maximum exponent a finite half-precision float may have. |
static Short |
Maximum positive finite value a half-precision float may have. |
static Int |
Minimum exponent a normalized half-precision float may have. |
static Short |
Smallest positive normal value a half-precision float may have. |
static Short |
Smallest positive non-zero value a half-precision float may have. |
static Short |
Negative infinity of type half-precision float. |
static Short |
Negative 0 of type half-precision float. |
static Short |
A Not-a-Number representation of a half-precision float. |
static Short |
Positive infinity of type half-precision float. |
static Short |
Positive 0 of type half-precision float. |
static Int |
The number of bits used to represent a half-precision float value. |
Public constructors | |
---|---|
Constructs a newly allocated |
|
Constructs a newly allocated |
|
Constructs a newly allocated |
|
Constructs a newly allocated |
Public methods | |
---|---|
static Short |
Returns the absolute value of the specified half-precision float. |
static Short |
Returns the smallest half-precision float value toward negative infinity greater than or equal to the specified half-precision float value. |
static Int |
Compares the two specified half-precision float values. |
Int |
Compares the two specified half-precision float values. |
static Short |
Returns the first parameter with the sign of the second parameter. |
Boolean |
Compares this object against the specified object. |
static Boolean |
Returns true if the two half-precision float values are equal. |
static 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 |
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 |
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 |
static Int |
Returns a representation of the specified half-precision float value according to the bit layout described in |
static Short |
halfToShortBits(h: Short) Returns a representation of the specified half-precision float value according to the bit layout described in |
Short |
Returns the half-precision value of this |
Int |
hashCode() Returns a hash code for this |
static Int |
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 |
static Boolean |
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 |
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 |
Returns the larger of two half-precision float values (the value closest to positive infinity). |
static Short |
Returns the smaller of two half-precision float values (the value closest to negative infinity). |
static Short |
Returns the half-precision float value represented by the specified string. |
static Short |
Returns the closest integral half-precision float value to the specified half-precision float value. |
Byte |
toByte() Returns the value of this |
Double |
toDouble() Returns the value of this |
Float |
toFloat() Returns the value of this |
static Float |
Converts the specified half-precision float value into a single-precision float value. |
static Short |
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 |
Long |
toLong() Returns the value of this |
Short |
toShort() Returns the value of this |
String |
toString() Returns a string representation of the specified half-precision float value. |
static String |
Returns a string representation of the specified half-precision float value. |
static Short |
Returns the truncated half-precision float value of the specified half-precision float value. |
static Half |
Returns a |
static Half |
Returns a |
static Half |
Returns a |
Constants
EPSILON
static val EPSILON: Short
Epsilon is the difference between 1.0 and the next value representable by a half-precision floating-point.
Value: 5120
LOWEST_VALUE
static val LOWEST_VALUE: Short
Smallest negative value a half-precision float may have.
Value: -1025
MAX_EXPONENT
static val MAX_EXPONENT: Int
Maximum exponent a finite half-precision float may have.
Value: 15
MAX_VALUE
static val MAX_VALUE: Short
Maximum positive finite value a half-precision float may have.
Value: 31743
MIN_EXPONENT
static val MIN_EXPONENT: Int
Minimum exponent a normalized half-precision float may have.
Value: -14
MIN_NORMAL
static val MIN_NORMAL: Short
Smallest positive normal value a half-precision float may have.
Value: 1024
MIN_VALUE
static val MIN_VALUE: Short
Smallest positive non-zero value a half-precision float may have.
Value: 1
NEGATIVE_INFINITY
static val NEGATIVE_INFINITY: Short
Negative infinity of type half-precision float.
Value: -1024
NEGATIVE_ZERO
static val NEGATIVE_ZERO: Short
Negative 0 of type half-precision float.
Value: -32768
NaN
static val NaN: Short
A Not-a-Number representation of a half-precision float.
Value: 32256
POSITIVE_INFINITY
static val POSITIVE_INFINITY: Short
Positive infinity of type half-precision float.
Value: 31744
POSITIVE_ZERO
static val POSITIVE_ZERO: Short
Positive 0 of type half-precision float.
Value: 0
SIZE
static val SIZE: Int
The number of bits used to represent a half-precision float value.
Value: 16
Public constructors
Half
Half(value: Short)
Constructs a newly allocated Half
object that represents the half-precision float type argument.
Parameters | |
---|---|
value |
Short: The value to be represented by the Half |
Half
Half(value: Float)
Constructs a newly allocated Half
object that represents the argument converted to a half-precision float.
Parameters | |
---|---|
value |
Float: The value to be represented by the Half |
See Also
Half
Half(value: Double)
Constructs a newly allocated Half
object that represents the argument converted to a half-precision float.
Parameters | |
---|---|
value |
Double: The value to be represented by the Half |
See Also
Half
Half(value: String)
Constructs a newly allocated Half
object that represents the half-precision float value represented by the string. The string is converted to a half-precision float value as if by the valueOf(java.lang.String)
method.
Calling this constructor is equivalent to calling:
new Half(Float.parseFloat(value))
Parameters | |
---|---|
value |
String: A string to be converted to a Half This value cannot be null . |
Exceptions | |
---|---|
java.lang.NumberFormatException |
if the string does not contain a parsable number |
Public methods
abs
static fun abs(h: Short): Short
Returns the absolute value of the specified half-precision float. Special values are handled in the following ways:
- If the specified half-precision float is NaN, the result is NaN
- If the specified half-precision float is zero (negative or positive), the result is positive zero (see
POSITIVE_ZERO
) - If the specified half-precision float is infinity (negative or positive), the result is positive infinity (see
POSITIVE_INFINITY
)
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The absolute value of the specified half-precision float |
ceil
static fun ceil(h: Short): Short
Returns the smallest half-precision float value toward negative infinity greater than or equal to the specified half-precision float value. Special values are handled in the following ways:
- If the specified half-precision float is NaN, the result is NaN
- If the specified half-precision float is infinity (negative or positive), the result is infinity (with the same sign)
- If the specified half-precision float is zero (negative or positive), the result is zero (with the same sign)
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The smallest half-precision float value toward negative infinity greater than or equal to the specified half-precision float value |
compare
static fun compare(
x: Short,
y: Short
): Int
Compares the two specified half-precision float values. The following conditions apply during the comparison:
NaN
is considered by this method to be equal to itself and greater than all other half-precision float values (includingPOSITIVE_INFINITY
)POSITIVE_ZERO
is considered by this method to be greater thanNEGATIVE_ZERO
.
Parameters | |
---|---|
x |
Short: The first half-precision float value to compare. |
y |
Short: The second half-precision float value to compare |
Return | |
---|---|
Int |
The value 0 if x is numerically equal to y , a value less than 0 if x is numerically less than y , and a value greater than 0 if x is numerically greater than y |
compareTo
fun compareTo(other: Half): Int
Compares the two specified half-precision float values. The following conditions apply during the comparison:
NaN
is considered by this method to be equal to itself and greater than all other half-precision float values (includingPOSITIVE_INFINITY
)POSITIVE_ZERO
is considered by this method to be greater thanNEGATIVE_ZERO
.
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 . |
Return | |
---|---|
Int |
The value 0 if x is numerically equal to y ; a value less than 0 if x is numerically less than y ; and a value greater than 0 if x is numerically greater than y |
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. |
copySign
static fun copySign(
magnitude: Short,
sign: Short
): Short
Returns the first parameter with the sign of the second parameter. This method treats NaNs as having a sign.
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 |
Return | |
---|---|
Short |
A value with the magnitude of the first parameter and the sign of the second parameter |
equals
fun equals(other: Any?): Boolean
Compares this object against the specified object. The result is true
if and only if the argument is not null
and is a Half
object that represents the same half-precision value as the this object. Two half-precision values are considered to be the same if and only if the method halfToIntBits(short)
returns an identical int
value for both.
Parameters | |
---|---|
obj |
the reference object with which to compare. |
o |
The object to compare This value may be null . |
Return | |
---|---|
Boolean |
True if the objects are the same, false otherwise |
See Also
equals
static fun equals(
x: Short,
y: Short
): Boolean
Returns true if the two half-precision float values are equal. If either of the values is NaN, the result is false. POSITIVE_ZERO
and NEGATIVE_ZERO
are considered equal.
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Boolean |
True if x is equal to y, false otherwise |
floor
static fun floor(h: Short): Short
Returns the largest half-precision float value toward positive infinity less than or equal to the specified half-precision float value. Special values are handled in the following ways:
- If the specified half-precision float is NaN, the result is NaN
- If the specified half-precision float is infinity (negative or positive), the result is infinity (with the same sign)
- If the specified half-precision float is zero (negative or positive), the result is zero (with the same sign)
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The largest half-precision float value toward positive infinity less than or equal to the specified half-precision float value |
getExponent
static fun getExponent(h: Short): Int
Returns the unbiased exponent used in the representation of the specified half-precision float value. if the value is NaN or infinite, this* method returns MAX_EXPONENT
+ 1. If the argument is 0 or a subnormal representation, this method returns MIN_EXPONENT
- 1.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Int |
The unbiased exponent of the specified value |
getSign
static fun getSign(h: Short): Int
Returns the sign of the specified half-precision float.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Int |
1 if the value is positive, -1 if the value is negative |
getSignificand
static fun getSignificand(h: Short): Int
Returns the significand, or mantissa, used in the representation of the specified half-precision float value.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Int |
The significand, or significand, of the specified vlaue |
greater
static fun greater(
x: Short,
y: Short
): Boolean
Returns true if the first half-precision float value is greater (larger toward positive infinity) than the second half-precision float value. If either of the values is NaN, the result is false.
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Boolean |
True if x is greater than y, false otherwise |
greaterEquals
static fun greaterEquals(
x: Short,
y: Short
): Boolean
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. If either of the values is NaN, the result is false.
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Boolean |
True if x is greater than y, false otherwise |
halfToIntBits
static fun halfToIntBits(h: Short): Int
Returns a representation of the specified half-precision float value according to the bit layout described in Half
.
Unlike halfToRawIntBits(short)
, this method collapses all possible Not-a-Number values to a single canonical Not-a-Number value defined by NaN
.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Int |
The bits that represent the half-precision float value |
halfToRawIntBits
static fun halfToRawIntBits(h: Short): Int
Returns a representation of the specified half-precision float value according to the bit layout described in Half
.
The argument is considered to be a representation of a half-precision float value according to the bit layout described in Half
. The 16 most significant bits of the returned value are set to 0.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Int |
The bits that represent the half-precision float value |
See Also
halfToShortBits
static fun halfToShortBits(h: Short): Short
Returns a representation of the specified half-precision float value according to the bit layout described in Half
.
Similar to halfToIntBits(short)
, this method collapses all possible Not-a-Number values to a single canonical Not-a-Number value defined by NaN
.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The bits that represent the half-precision float value |
See Also
halfValue
fun halfValue(): Short
Returns the half-precision value of this Half
as a short
containing the bit representation described in Half
.
Return | |
---|---|
Short |
The half-precision float value represented by this object |
hashCode
fun hashCode(): Int
Returns a hash code for this Half
object. The result is the integer bit representation, exactly as produced by the method halfToIntBits(short)
, of the primitive half-precision float value represented by this Half
object.
Return | |
---|---|
Int |
A hash code value for this object |
hashCode
static fun hashCode(h: Short): Int
Returns a hash code for a half-precision float value.
Parameters | |
---|---|
h |
Short: The value to hash |
Return | |
---|---|
Int |
A hash code value for a half-precision float value |
intBitsToHalf
static fun intBitsToHalf(bits: Int): Short
Returns the half-precision float value corresponding to a given bit representation.
The argument is considered to be a representation of a half-precision float value according to the bit layout described in Half
. The 16 most significant bits of the argument are ignored.
Parameters | |
---|---|
bits |
Int: An integer |
Return | |
---|---|
Short |
The half-precision float value with the same bit pattern |
isInfinite
static fun isInfinite(h: Short): Boolean
Returns true if the specified half-precision float value represents infinity, false otherwise.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Boolean |
True if the value is positive infinity or negative infinity, false otherwise |
isNaN
fun isNaN(): Boolean
Returns true if this Half
value represents a Not-a-Number, false otherwise.
Return | |
---|---|
Boolean |
True if the value is a NaN, false otherwise |
isNaN
static fun isNaN(h: Short): Boolean
Returns true if the specified half-precision float value represents a Not-a-Number, false otherwise.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Boolean |
True if the value is a NaN, false otherwise |
isNormalized
static fun isNormalized(h: Short): Boolean
Returns true if the specified half-precision float value is normalized (does not have a subnormal representation). If the specified value is POSITIVE_INFINITY
, NEGATIVE_INFINITY
, POSITIVE_ZERO
, NEGATIVE_ZERO
, NaN or any subnormal number, this method returns false.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Boolean |
True if the value is normalized, false otherwise |
less
static fun less(
x: Short,
y: Short
): Boolean
Returns true if the first half-precision float value is less (smaller toward negative infinity) than the second half-precision float value. If either of the values is NaN, the result is false.
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Boolean |
True if x is less than y, false otherwise |
lessEquals
static fun lessEquals(
x: Short,
y: Short
): Boolean
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. If either of the values is NaN, the result is false.
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Boolean |
True if x is less than or equal to y, false otherwise |
max
static fun max(
x: Short,
y: Short
): Short
Returns the larger of two half-precision float values (the value closest to positive infinity). Special values are handled in the following ways:
- If either value is NaN, the result is NaN
POSITIVE_ZERO
is greater thanNEGATIVE_ZERO
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Short |
The larger of the two specified half-precision values |
min
static fun min(
x: Short,
y: Short
): Short
Returns the smaller of two half-precision float values (the value closest to negative infinity). Special values are handled in the following ways:
- If either value is NaN, the result is NaN
NEGATIVE_ZERO
is smaller thanPOSITIVE_ZERO
Parameters | |
---|---|
x |
Short: The first half-precision value |
y |
Short: The second half-precision value |
Return | |
---|---|
Short |
The smaller of the two specified half-precision values |
parseHalf
static fun parseHalf(s: String): Short
Returns the half-precision float value represented by the specified string. Calling this method is equivalent to calling toHalf(Float.parseString(h))
. See Float#valueOf(String)
for more information on the format of the string representation.
Parameters | |
---|---|
s |
String: The string to be parsed This value cannot be null . |
Return | |
---|---|
Short |
A half-precision float value represented by the string |
Exceptions | |
---|---|
java.lang.NumberFormatException |
if the string does not contain a parsable half-precision float value |
round
static fun round(h: Short): Short
Returns the closest integral half-precision float value to the specified half-precision float value. Special values are handled in the following ways:
- If the specified half-precision float is NaN, the result is NaN
- If the specified half-precision float is infinity (negative or positive), the result is infinity (with the same sign)
- If the specified half-precision float is zero (negative or positive), the result is zero (with the same sign)
Note: Unlike the identically named int java.lang.Math.round(float)
method, this returns a Half value stored in a short, not an actual short integer result.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The value of the specified half-precision float rounded to the nearest half-precision float value |
toByte
fun toByte(): Byte
Returns the value of this Half
as a byte
after a narrowing primitive conversion.
Return | |
---|---|
Byte |
The half-precision float value represented by this object converted to type byte |
toDouble
fun toDouble(): Double
Returns the value of this Half
as a double
after a widening primitive conversion.
Return | |
---|---|
Double |
The half-precision float value represented by this object converted to type double |
toFloat
fun toFloat(): Float
Returns the value of this Half
as a float
after a widening primitive conversion.
Return | |
---|---|
Float |
The half-precision float value represented by this object converted to type float |
toFloat
static fun toFloat(h: Short): Float
Converts the specified half-precision float value into a single-precision float value. The following special cases are handled:
- If the input is
NaN
, the returned value isFloat#NaN
- If the input is
POSITIVE_INFINITY
orNEGATIVE_INFINITY
, the returned value is respectivelyFloat#POSITIVE_INFINITY
orFloat#NEGATIVE_INFINITY
- If the input is 0 (positive or negative), the returned value is +/-0.0f
- Otherwise, the returned value is a normalized single-precision float value
Parameters | |
---|---|
h |
Short: The half-precision float value to convert to single-precision |
Return | |
---|---|
Float |
A normalized single-precision float value |
toHalf
static fun toHalf(f: Float): Short
Converts the specified single-precision float value into a half-precision float value. The following special cases are handled:
- If the input is NaN (see
Float#isNaN(float)
), the returned value isNaN
- If the input is
Float#POSITIVE_INFINITY
orFloat#NEGATIVE_INFINITY
, the returned value is respectivelyPOSITIVE_INFINITY
orNEGATIVE_INFINITY
- If the input is 0 (positive or negative), the returned value is
POSITIVE_ZERO
orNEGATIVE_ZERO
- If the input is a less than
MIN_VALUE
, the returned value is flushed toPOSITIVE_ZERO
orNEGATIVE_ZERO
- If the input is a less than
MIN_NORMAL
, the returned value is a denorm half-precision float - Otherwise, the returned value is rounded to the nearest representable half-precision float value
Parameters | |
---|---|
f |
Float: The single-precision float value to convert to half-precision |
Return | |
---|---|
Short |
A half-precision float value |
toHexString
static fun toHexString(h: Short): String
Returns a hexadecimal string representation of the specified half-precision float value. If the value is a NaN, the result is "NaN"
, otherwise the result follows this format:
- If the sign is positive, no sign character appears in the result
- If the sign is negative, the first character is
'-'
- If the value is inifinity, the string is
"Infinity"
- If the value is 0, the string is
"0x0.0p0"
- If the value has a normalized representation, the exponent and significand are represented in the string in two fields. The significand starts with
"0x1."
followed by its lowercase hexadecimal representation. Trailing zeroes are removed unless all digits are 0, then a single zero is used. The significand representation is followed by the exponent, represented by"p"
, itself followed by a decimal string of the unbiased exponent - If the value has a subnormal representation, the significand starts with
"0x0."
followed by its lowercase hexadecimal representation. Trailing zeroes are removed unless all digits are 0, then a single zero is used. The significand representation is followed by the exponent, represented by"p-14"
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
String |
A hexadecimal string representation of the specified value This value cannot be null . |
toInt
fun toInt(): Int
Returns the value of this Half
as a int
after a narrowing primitive conversion.
Return | |
---|---|
Int |
The half-precision float value represented by this object converted to type int |
toLong
fun toLong(): Long
Returns the value of this Half
as a long
after a narrowing primitive conversion.
Return | |
---|---|
Long |
The half-precision float value represented by this object converted to type long |
toShort
fun toShort(): Short
Returns the value of this Half
as a short
after a narrowing primitive conversion.
Return | |
---|---|
Short |
The half-precision float value represented by this object converted to type short |
toString
fun toString(): String
Returns a string representation of the specified half-precision float value. See toString(short)
for more information.
Return | |
---|---|
String |
A string representation of this Half object This value cannot be null . |
toString
static fun toString(h: Short): String
Returns a string representation of the specified half-precision float value. Calling this method is equivalent to calling Float.toString(toFloat(h))
. See Float#toString(float)
for more information on the format of the string representation.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
String |
A string representation of the specified value This value cannot be null . |
trunc
static fun trunc(h: Short): Short
Returns the truncated half-precision float value of the specified half-precision float value. Special values are handled in the following ways:
- If the specified half-precision float is NaN, the result is NaN
- If the specified half-precision float is infinity (negative or positive), the result is infinity (with the same sign)
- If the specified half-precision float is zero (negative or positive), the result is zero (with the same sign)
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Short |
The truncated half-precision float value of the specified half-precision float value |
valueOf
static fun valueOf(h: Short): Half
Returns a Half
instance representing the specified half-precision float value.
Parameters | |
---|---|
h |
Short: A half-precision float value |
Return | |
---|---|
Half |
a Half instance representing h This value cannot be null . |
valueOf
static fun valueOf(f: Float): Half
Returns a Half
instance representing the specified float value.
Parameters | |
---|---|
f |
Float: A float value |
Return | |
---|---|
Half |
a Half instance representing f This value cannot be null . |
valueOf
static fun valueOf(s: String): Half
Returns a Half
instance representing the specified string value. Calling this method is equivalent to calling toHalf(Float.parseString(h))
. See Float#valueOf(String)
for more information on the format of the string representation.
Parameters | |
---|---|
s |
String: The string to be parsed This value cannot be null . |
Return | |
---|---|
Half |
a Half instance representing h This value cannot be null . |
Exceptions | |
---|---|
java.lang.NumberFormatException |
if the string does not contain a parsable half-precision float value |