# Magnum::Math::Half class#include <Magnum/Math/Half.h>

Half-precision float literal.

Represents a floating-point value in the `binary16` format.

The sole purpose of this type is to make creation, conversion and visualization of half-float values easier. By design it doesn't support any arithmetic operations as not all CPU architecture have native support for half-floats and thus the operations would be done faster in a regular single-precision Float.

The class provides explicit conversion from and to Float, equality comparison with correct treatment of NaN values, promotion and negation operator, an operator""_h() literal and an operator<<(Debug&, Half) debug operator. Internally the class uses packHalf() and unpackHalf(). Example usage:

```using namespace Math::Literals;

Half a = 3.14159_h;
Debug{} << a;                   // Prints 3.14159
Debug{} << Float(a);            // Prints 3.14159
Debug{} << UnsignedShort(a);    // Prints 25675```

Note that it is also possible to use this type inside Vector classes, though, again, only for passing data around and converting them, without any arithmetic operations:

```Vector3h a{3.14159_h, -1.4142_h, 1.618_h};
Vector3 b{a};                   // converts to 32-bit floats
Debug{} << a;                   // prints {3.14159, -1.4142, 1.618}
Debug{} << Vector3us{a};        // prints {16968, 48552, 15993}```

## Constructors, destructors, conversion operators

Half() constexpr noexcept
Default constructor.
Half(ZeroInitT) explicit constexpr noexcept
Construct a zero value.
Half(UnsignedShort data) explicit constexpr noexcept
Construct a half value from underlying 16-bit representation.
Half(Float value) explicit noexcept
Construct a half value from a 32-bit float representation.
Half(Double value) explicit noexcept
Construct a half value from a 64-bit float representation.
Half(Magnum::NoInitT) explicit noexcept
Construct without initializing the contents.
) const explicit constexpr
Conversion to underlying representation.
) const explicit
Conversion to 32-bit float representation.

## Public functions

auto operator==(Half other) const -> bool constexpr
Equality comparison.
auto operator!=(Half other) const -> bool constexpr
Non-equality comparison.
auto operator+() const -> Half constexpr
Promotion.
auto operator-() const -> Half constexpr
Negation.
auto data() const -> UnsignedShort constexpr
Underlying representation.

## Function documentation

### Magnum::Math::Half::Half() constexpr noexcept

Default constructor.

Equivalent to Half(ZeroInitT).

### Magnum::Math::Half::Half(Float value) explicit noexcept

Construct a half value from a 32-bit float representation.

### Magnum::Math::Half::Half(Double value) explicit noexcept

Construct a half value from a 64-bit float representation.

Present only to aid generic code so e.g. `T(1.0)` works without being ambigous.

### Magnum::Math::Half::operator UnsignedShort() const explicit constexpr

Conversion to underlying representation.

### Magnum::Math::Half::operator Float() const explicit

Conversion to 32-bit float representation.

### bool Magnum::Math::Half::operator==(Half other) const constexpr

Equality comparison.

Returns `false` if one of the values is half-float representation of NaN, otherwise does bitwise comparison.

### bool Magnum::Math::Half::operator!=(Half other) const constexpr

Non-equality comparison.

Simply negates the result of operator==().

### Half Magnum::Math::Half::operator+() const constexpr

Promotion.

Returns the value as-is.

### UnsignedShort Magnum::Math::Half::data() const constexpr

Underlying representation.

### Half operator""_h(long double value)

Half-float literal.