half  2.2
IEEE 754-based half-precision floating-point library
half Class Reference

Half-precision floating-point type. More...

Public Member Functions

Construction and assignment
constexpr half () noexcept
 Default constructor. More...
 
 half (float rhs)
 Conversion constructor. More...
 
 operator float () const
 Conversion to single-precision. More...
 
halfoperator= (float rhs)
 Assignment operator. More...
 
Arithmetic updates
halfoperator+= (half rhs)
 Arithmetic assignment. More...
 
halfoperator-= (half rhs)
 Arithmetic assignment. More...
 
halfoperator*= (half rhs)
 Arithmetic assignment. More...
 
halfoperator/= (half rhs)
 Arithmetic assignment. More...
 
halfoperator+= (float rhs)
 Arithmetic assignment. More...
 
halfoperator-= (float rhs)
 Arithmetic assignment. More...
 
halfoperator*= (float rhs)
 Arithmetic assignment. More...
 
halfoperator/= (float rhs)
 Arithmetic assignment. More...
 
Increment and decrement
halfoperator++ ()
 Prefix increment. More...
 
halfoperator-- ()
 Prefix decrement. More...
 
half operator++ (int)
 Postfix increment. More...
 
half operator-- (int)
 Postfix decrement. More...
 

Detailed Description

Half-precision floating-point type.

This class implements an IEEE-conformant half-precision floating-point type with the usual arithmetic operators and conversions. It is implicitly convertible to single-precision floating-point, which makes artihmetic expressions and functions with mixed-type operands to be of the most precise operand type.

According to the C++98/03 definition, the half type is not a POD type. But according to C++11's less strict and extended definitions it is both a standard layout type and a trivially copyable type (even if not a POD type), which means it can be standard-conformantly copied using raw binary copies. But in this context some more words about the actual size of the type. Although the half is representing an IEEE 16-bit type, it does not neccessarily have to be of exactly 16-bits size. But on any reasonable implementation the actual binary representation of this type will most probably not ivolve any additional "magic" or padding beyond the simple binary representation of the underlying 16-bit IEEE number, even if not strictly guaranteed by the standard. But even then it only has an actual size of 16 bits if your C++ implementation supports an unsigned integer type of exactly 16 bits width. But this should be the case on nearly any reasonable platform.

So if your C++ implementation is not totally exotic or imposes special alignment requirements, it is a reasonable assumption that the data of a half is just comprised of the 2 bytes of the underlying IEEE representation.

Constructor & Destructor Documentation

◆ half() [1/2]

constexpr half ( )
inlineconstexprnoexcept

Default constructor.

This initializes the half to 0. Although this does not match the builtin types' default-initialization semantics and may be less efficient than no initialization, it is needed to provide proper value-initialization semantics.

◆ half() [2/2]

half ( float  rhs)
inlineexplicit

Conversion constructor.

Parameters
rhsfloat to convert
Exceptions
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

Member Function Documentation

◆ operator float()

operator float ( ) const
inline

Conversion to single-precision.

Returns
single precision value representing expression value

◆ operator=()

half& operator= ( float  rhs)
inline

Assignment operator.

Parameters
rhssingle-precision value to copy from
Returns
reference to this half
Exceptions
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ operator+=() [1/2]

half& operator+= ( half  rhs)
inline

Arithmetic assignment.

Template Parameters
Ttype of concrete half expression
Parameters
rhshalf expression to add
Returns
reference to this half
Exceptions
FE_...according to operator+(half,half)

◆ operator-=() [1/2]

half& operator-= ( half  rhs)
inline

Arithmetic assignment.

Template Parameters
Ttype of concrete half expression
Parameters
rhshalf expression to subtract
Returns
reference to this half
Exceptions
FE_...according to operator-(half,half)

◆ operator*=() [1/2]

half& operator*= ( half  rhs)
inline

Arithmetic assignment.

Template Parameters
Ttype of concrete half expression
Parameters
rhshalf expression to multiply with
Returns
reference to this half
Exceptions
FE_...according to operator*(half,half)

◆ operator/=() [1/2]

half& operator/= ( half  rhs)
inline

Arithmetic assignment.

Template Parameters
Ttype of concrete half expression
Parameters
rhshalf expression to divide by
Returns
reference to this half
Exceptions
FE_...according to operator/(half,half)

◆ operator+=() [2/2]

half& operator+= ( float  rhs)
inline

Arithmetic assignment.

Parameters
rhssingle-precision value to add
Returns
reference to this half
Exceptions
FE_...according to operator=()

◆ operator-=() [2/2]

half& operator-= ( float  rhs)
inline

Arithmetic assignment.

Parameters
rhssingle-precision value to subtract
Returns
reference to this half
Exceptions
FE_...according to operator=()

◆ operator*=() [2/2]

half& operator*= ( float  rhs)
inline

Arithmetic assignment.

Parameters
rhssingle-precision value to multiply with
Returns
reference to this half
Exceptions
FE_...according to operator=()

◆ operator/=() [2/2]

half& operator/= ( float  rhs)
inline

Arithmetic assignment.

Parameters
rhssingle-precision value to divide by
Returns
reference to this half
Exceptions
FE_...according to operator=()

◆ operator++() [1/2]

half& operator++ ( )
inline

Prefix increment.

Returns
incremented half value
Exceptions
FE_...according to operator+(half,half)

◆ operator--() [1/2]

half& operator-- ( )
inline

Prefix decrement.

Returns
decremented half value
Exceptions
FE_...according to operator-(half,half)

◆ operator++() [2/2]

half operator++ ( int  )
inline

Postfix increment.

Returns
non-incremented half value
Exceptions
FE_...according to operator+(half,half)

◆ operator--() [2/2]

half operator-- ( int  )
inline

Postfix decrement.

Returns
non-decremented half value
Exceptions
FE_...according to operator-(half,half)

The documentation for this class was generated from the following file: