OpenVDB 13.0.0

Loading...
Searching...
No Matches
half Class Reference

`#include <openvdb/math/Half.h>`

## Public Types
using | uif = imath_half_uif

## Public Member Functions
| operator float () const noexcept
| Conversion to float.
constexpr half | round (unsigned int n) const noexcept
Constructors
| half () noexcept=default
| half (float f) noexcept
| Construct from float.
constexpr | half (FromBitsTag, uint16_t bits) noexcept
| Construct from bit-vector.
constexpr | half (const half &) noexcept=default
| Copy constructor.
constexpr | half (half &&) noexcept=default
| Move constructor.
| ~half () noexcept=default
| Destructor.
Basic Algebra
constexpr half | operator- () const noexcept
| Unary minus.
half & | operator= (const half &h) noexcept=default
| Assignment.
half & | operator= (half &&h) noexcept=default
| Move assignment.
half & | operator= (float f) noexcept
| Assignment from float.
half & | operator+= (half h) noexcept
| Addition assignment.
half & | operator+= (float f) noexcept
| Addition assignment from float.
half & | operator-= (half h) noexcept
| Subtraction assignment.
half & | operator-= (float f) noexcept
| Subtraction assignment from float.
half & | operator*= (half h) noexcept
| Multiplication assignment.
half & | operator*= (float f) noexcept
| Multiplication assignment from float.
half & | operator/= (half h) noexcept
| Division assignment.
half & | operator/= (float f) noexcept
| Division assignment from float.
Classification
constexpr bool | isFinite () const noexcept
constexpr bool | isNormalized () const noexcept
| Return true if a normalized number.
constexpr bool | isDenormalized () const noexcept
| Return true if a denormalized number.
constexpr bool | isZero () const noexcept
| Return true if zero.
constexpr bool | isNan () const noexcept
| Return true if NAN.
constexpr bool | isInfinity () const noexcept
| Return true if a positive or a negative infinity.
constexpr bool | isNegative () const noexcept
| Return true if the sign bit is set (negative).
Access to the internal representation
constexpr uint16_t | bits () const noexcept
| Return the bit pattern.
constexpr void | setBits (uint16_t bits) noexcept
| Set the bit pattern.

## Static Public Member Functions
Special values
static constexpr half | posInf () noexcept
| Return +infinity.
static constexpr half | negInf () noexcept
| Return -infinity.
static constexpr half | qNan () noexcept
| Returns a NAN with the bit pattern 0111111111111111.
static constexpr half | sNan () noexcept
| Return a NAN with the bit pattern 0111110111111111.

## Detailed Description

class half – 16-bit floating point number

Type half can represent positive and negative numbers whose magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative error of 9.8e-4; numbers smaller than 6.1e-5 can be represented with an absolute error of 6.0e-8. All integers from -2048 to +2048 can be represented exactly.

Type half behaves (almost) like the built-in C++ floating point types. In arithmetic expressions, half, float and double can be mixed freely. Here are a few examples:

    half a (3.5);
    float b (a + sqrt (a));
    a += b;
    b += a;
    b = a + 7;

Conversions from half to float are lossless; all half numbers are exactly representable as floats.

Conversions from float to half may not preserve a float's value exactly. If a float is not representable as a half, then the float value is rounded to the nearest representable half. If a float value is exactly in the middle between the two closest representable half values, then the float value is rounded to the closest half whose least significant bit is zero.

Overflows during float-to-half conversions cause arithmetic exceptions. An overflow occurs when the float value to be converted is too large to be represented as a half, or if the float value is an infinity or a NAN.

The implementation of type half makes the following assumptions about the implementation of the built-in C++ types:

- float is an IEEE 754 single-precision number
- sizeof (float) == 4
- sizeof (unsigned int) == sizeof (float)
- alignof (unsigned int) == alignof (float)
- sizeof (uint16_t) == 2

## Member Typedef Documentation

## ◆ uif

using uif = imath_half_uif

## Constructor & Destructor Documentation

## ◆ half() [1/5]

half | ( |  | ) |
| default noexcept

Default construction provides no initialization (hence it is not constexpr).

## ◆ half() [2/5]

half | ( | float | f | ) |
| inline noexcept

Construct from float.

## ◆ half() [3/5]

half | ( | FromBitsTag | ,
|  | uint16_t | bits )
| inline constexpr noexcept

Construct from bit-vector.

## ◆ half() [4/5]

half | ( | const half & |  | ) |
| constexpr default noexcept

Copy constructor.

## ◆ half() [5/5]

half | ( | half && |  | ) |
| constexpr default noexcept

Move constructor.

## ◆ ~half()

~half | ( |  | ) |
| default noexcept

Destructor.

## Member Function Documentation

## ◆ bits()

uint16_t bits | ( |  | ) | const
| inline constexpr noexcept

Return the bit pattern.

## ◆ isDenormalized()

bool isDenormalized | ( |  | ) | const
| inline constexpr noexcept

Return true if a denormalized number.

## ◆ isFinite()

bool isFinite | ( |  | ) | const
| inline constexpr noexcept

Return true if a normalized number, a denormalized number, or zero.

## ◆ isInfinity()

bool isInfinity | ( |  | ) | const
| inline constexpr noexcept

Return true if a positive or a negative infinity.

## ◆ isNan()

bool isNan | ( |  | ) | const
| inline constexpr noexcept

Return true if NAN.

## ◆ isNegative()

bool isNegative | ( |  | ) | const
| inline constexpr noexcept

Return true if the sign bit is set (negative).

## ◆ isNormalized()

bool isNormalized | ( |  | ) | const
| inline constexpr noexcept

Return true if a normalized number.

## ◆ isZero()

bool isZero | ( |  | ) | const
| inline constexpr noexcept

Return true if zero.

## ◆ negInf()

half negInf | ( |  | ) |
| inline static constexpr noexcept

Return -infinity.

## ◆ operator float()

operator float | ( |  | ) | const
| inline noexcept

Conversion to float.

## ◆ operator*=() [1/2]

half & operator*= | ( | float | f | ) |
| inline noexcept

Multiplication assignment from float.

## ◆ operator*=() [2/2]

half & operator*= | ( | half | h | ) |
| inline noexcept

Multiplication assignment.

## ◆ operator+=() [1/2]

half & operator+= | ( | float | f | ) |
| inline noexcept

Addition assignment from float.

## ◆ operator+=() [2/2]

half & operator+= | ( | half | h | ) |
| inline noexcept

Addition assignment.

## ◆ operator-()

half operator- | ( |  | ) | const
| inline constexpr noexcept

Unary minus.

## ◆ operator-=() [1/2]

half & operator-= | ( | float | f | ) |
| inline noexcept

Subtraction assignment from float.

## ◆ operator-=() [2/2]

half & operator-= | ( | half | h | ) |
| inline noexcept

Subtraction assignment.

## ◆ operator/=() [1/2]

half & operator/= | ( | float | f | ) |
| inline noexcept

Division assignment from float.

## ◆ operator/=() [2/2]

half & operator/= | ( | half | h | ) |
| inline noexcept

Division assignment.

## ◆ operator=() [1/3]

half & operator= | ( | const half & | h | ) |
| default noexcept

Assignment.

## ◆ operator=() [2/3]

half & operator= | ( | float | f | ) |
| inline noexcept

Assignment from float.

## ◆ operator=() [3/3]

half & operator= | ( | half && | h | ) |
| default noexcept

Move assignment.

## ◆ posInf()

half posInf | ( |  | ) |
| inline static constexpr noexcept

Return +infinity.

## ◆ qNan()

half qNan | ( |  | ) |
| inline static constexpr noexcept

Returns a NAN with the bit pattern 0111111111111111.

## ◆ round()

half round | ( | unsigned int | n | ) | const
| inline constexpr noexcept

Round to n-bit precision (n should be between 0 and 10). After rounding, the significand's 10-n least significant bits will be zero.

## ◆ setBits()

void setBits | ( | uint16_t | bits | ) |
| inline constexpr noexcept

Set the bit pattern.

## ◆ sNan()

half sNan | ( |  | ) |
| inline static constexpr noexcept

Return a NAN with the bit pattern 0111110111111111.