Fixed Point Classes

group Fixed Point

Typedefs

using decimal32 = fixed_point<int32_t, Radix::BASE_10>

32-bit decimal fixed point

using decimal64 = fixed_point<int64_t, Radix::BASE_10>

64-bit decimal fixed point

using decimal128 = fixed_point<__int128_t, Radix::BASE_10>

128-bit decimal fixed point

Enums

enum scale_type

The scale type for fixed_point.

Values:

enum class Radix : int32_t

Scoped enumerator to use when constructing fixed_point

Examples:

using decimal32 = fixed_point<int32_t, Radix::BASE_10>;
using binary64  = fixed_point<int64_t, Radix::BASE_2>;

Values:

enumerator BASE_2

enumerator BASE_10

Functions

template<typename Fixed, typename Floating>
Fixed convert_floating_to_fixed(Floating floating, numeric::scale_type scale)

Convert a floating-point value to fixed point.

Note

This conversion was moved from fixed-point member functions to free functions. This is so that the complex conversion code is not included into many parts of the code base that don’t need it, and so that it’s more obvious to pinpoint where these conversions are occurring.

Template Parameters:

• Fixed – The fixed-point type to convert to

• Floating – The floating-point type to convert from

Parameters:

• floating – The floating-point value to convert

• scale – The desired scale of the fixed-point value

Returns:

The converted fixed-point value

template<typename Floating, typename Fixed>
Floating convert_fixed_to_floating(Fixed fixed)

Convert a fixed-point value to floating point.

Note

This conversion was moved from fixed-point member functions to free functions. This is so that the complex conversion code is not included into many parts of the code base that don’t need it, and so that it’s more obvious to pinpoint where these conversions are occurring.

Template Parameters:

• Floating – The floating-point type to convert to

• Fixed – The fixed-point type to convert from

Parameters:

fixed – The fixed-point value to convert

Returns:

The converted floating-point value

template<typename Floating, typename Input>
Floating convert_to_floating(Input input)

Convert a value to floating point.

Template Parameters:

• Floating – The floating-point type to convert to

• Input – The input type to convert from

Parameters:

input – The input value to convert

Returns:

The converted floating-point value

template<typename T>
inline constexpr auto is_supported_representation_type()

Returns true if the representation type is supported by fixed_point

Template Parameters:

T – The representation type

Returns:

true if the type is supported by fixed_point implementation

template<typename Rep, typename T>
inline auto addition_overflow(T lhs, T rhs)

Function for identifying integer overflow when adding.

Template Parameters:

• Rep – Type of integer to check for overflow on

• T – Types of lhs and rhs (ensures they are the same type)

Parameters:

• lhs – Left hand side of addition

• rhs – Right hand side of addition

Returns:

true if addition causes overflow, false otherwise

template<typename Rep, typename T>
inline auto subtraction_overflow(T lhs, T rhs)

Function for identifying integer overflow when subtracting.

Template Parameters:

• Rep – Type of integer to check for overflow on

• T – Types of lhs and rhs (ensures they are the same type)

Parameters:

• lhs – Left hand side of subtraction

• rhs – Right hand side of subtraction

Returns:

true if subtraction causes overflow, false otherwise

template<typename Rep, typename T>
inline auto division_overflow(T lhs, T rhs)

Function for identifying integer overflow when dividing.

Template Parameters:

• Rep – Type of integer to check for overflow on

• T – Types of lhs and rhs (ensures they are the same type)

Parameters:

• lhs – Left hand side of division

• rhs – Right hand side of division

Returns:

true if division causes overflow, false otherwise

template<typename Rep, typename T>
inline auto multiplication_overflow(T lhs, T rhs)

Function for identifying integer overflow when multiplying.

Template Parameters:

• Rep – Type of integer to check for overflow on

• T – Types of lhs and rhs (ensures they are the same type)

Parameters:

• lhs – Left hand side of multiplication

• rhs – Right hand side of multiplication

Returns:

true if multiplication causes overflow, false otherwise

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> operator+(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are added. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are added.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point sum

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> operator-(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are subtracted. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are subtracted.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point difference

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> operator*(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

_scales are added and _values are multiplied.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point product

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> operator/(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

_scales are subtracted and _values are divided.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point quotient

template<typename Rep1, Radix Rad1>
inline bool operator==(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs and rhs are equal, false if not

template<typename Rep1, Radix Rad1>
inline bool operator!=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs and rhs are not equal, false if not

template<typename Rep1, Radix Rad1>
inline bool operator<=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs less than or equal to rhs, false if not

template<typename Rep1, Radix Rad1>
inline bool operator>=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs greater than or equal to rhs, false if not

template<typename Rep1, Radix Rad1>
inline bool operator<(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs less than rhs, false if not

template<typename Rep1, Radix Rad1>
inline bool operator>(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs greater than rhs, false if not

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> operator%(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

If _scales are equal, the modulus is computed directly. If _scales are not equal, the number with larger _scale is shifted to the smaller _scale, and then the modulus is computed.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point number

template<typename Rep, typename cuda::std::enable_if_t<is_supported_representation_type<Rep>()>* = nullptr>
struct scaled_integer

#include <fixed_point.hpp>

Helper struct for constructing fixed_point when value is already shifted.

Example:

using decimal32 = fixed_point<int32_t, Radix::BASE_10>;
auto n = decimal32{scaled_integer{1001, 3}}; // n = 1.001

Template Parameters:

Rep – The representation type (either int32_t or int64_t)

Public Functions

inline explicit scaled_integer(Rep v, scale_type s)

Constructor for scaled_integer

Parameters:

• v – The value of the fixed point number

• s – The scale of the value

Public Members

Rep value

The value of the fixed point number.

scale_type scale

The scale of the value.

template<typename Rep, Radix Rad>
class fixed_point

#include <fixed_point.hpp>

A type for representing a number with a fixed amount of precision.

Currently, only binary and decimal fixed_point numbers are supported. Binary operations can only be performed with other fixed_point numbers

Template Parameters:

• Rep – The representation type (either int32_t or int64_t)

• Rad – The radix/base (either Radix::BASE_2 or Radix::BASE_10)

Public Types

using rep = Rep

The representation type.

Public Functions

template<typename T>
inline explicit fixed_point(T const &value, scale_type const &scale)

Constructor that will perform shifting to store value appropriately (from integral types)

Template Parameters:

T – The integral type that you are constructing from

Parameters:

• value – The value that will be constructed from

• scale – The exponent that is applied to Rad to perform shifting

inline explicit fixed_point(scaled_integer<Rep> s)

Constructor that will not perform shifting (assumes value already shifted)

Parameters:

s – scaled_integer that contains scale and already shifted value

template<typename T>
inline fixed_point(T const &value)

“Scale-less” constructor that constructs fixed_point number with a specified value and scale of zero

Template Parameters:

T – The value type being constructing from

Parameters:

value – The value that will be constructed from

inline fixed_point()

Default constructor that constructs fixed_point number with a value and scale of zero.

template<typename U>
inline explicit constexpr operator U() const

Explicit conversion operator for casting to integral types.

Template Parameters:

U – The integral type that is being explicitly converted to

Returns:

The fixed_point number in base 10 (aka human readable format)

inline operator scaled_integer<Rep>() const

Converts the fixed_point number to a scaled_integer

Returns:

The scaled_integer representation of the fixed_point number

inline rep value() const

Method that returns the underlying value of the fixed_point number.

Returns:

The underlying value of the fixed_point number

inline scale_type scale() const

Method that returns the scale of the fixed_point number.

Returns:

The scale of the fixed_point number

inline explicit constexpr operator bool() const

Explicit conversion operator to bool

Returns:

The fixed_point value as a boolean (zero is false, nonzero is true)

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> &operator+=(fixed_point<Rep1, Rad1> const &rhs)

operator +=

Template Parameters:

• Rep1 – Representation type of the operand rhs

• Rad1 – Radix (base) type of the operand rhs

Parameters:

rhs – The number being added to this

Returns:

The sum

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> &operator*=(fixed_point<Rep1, Rad1> const &rhs)

operator *=

Template Parameters:

• Rep1 – Representation type of the operand rhs

• Rad1 – Radix (base) type of the operand rhs

Parameters:

rhs – The number being multiplied to this

Returns:

The product

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> &operator-=(fixed_point<Rep1, Rad1> const &rhs)

operator -=

Template Parameters:

• Rep1 – Representation type of the operand rhs

• Rad1 – Radix (base) type of the operand rhs

Parameters:

rhs – The number being subtracted from this

Returns:

The difference

template<typename Rep1, Radix Rad1>
inline fixed_point<Rep1, Rad1> &operator/=(fixed_point<Rep1, Rad1> const &rhs)

operator /=

Template Parameters:

• Rep1 – Representation type of the operand rhs

• Rad1 – Radix (base) type of the operand rhs

Parameters:

rhs – The number being divided from this

Returns:

The quotient

inline fixed_point<Rep, Rad> &operator++()

operator ++ (post-increment)

Returns:

The incremented result

inline fixed_point<Rep, Rad> rescaled(scale_type scale) const

Method for creating a fixed_point number with a new scale

The fixed_point number returned will have the same value, underlying representation and radix as this, the only thing changed is the scale.

Parameters:

scale – The scale of the returned fixed_point number

Returns:

fixed_point number with a new scale

inline explicit operator std::string() const

Returns a string representation of the fixed_point value.

Public Static Attributes

static constexpr auto rad = Rad

The base.

Friends

template<typename Rep1, Radix Rad1>
inline friend fixed_point<Rep1, Rad1> operator+(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator + (for adding two fixed_point numbers)

If _scales are equal, _values are added. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are added.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point sum

template<typename Rep1, Radix Rad1>
inline friend fixed_point<Rep1, Rad1> operator-(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator - (for subtracting two fixed_point numbers)

If _scales are equal, _values are subtracted. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are subtracted.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point difference

template<typename Rep1, Radix Rad1>
inline friend fixed_point<Rep1, Rad1> operator*(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator * (for multiplying two fixed_point numbers)

_scales are added and _values are multiplied.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point product

template<typename Rep1, Radix Rad1>
inline friend fixed_point<Rep1, Rad1> operator/(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator / (for dividing two fixed_point numbers)

_scales are subtracted and _values are divided.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point quotient

template<typename Rep1, Radix Rad1>
inline friend fixed_point<Rep1, Rad1> operator%(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator % (for computing the modulo operation of two fixed_point numbers)

If _scales are equal, the modulus is computed directly. If _scales are not equal, the number with larger _scale is shifted to the smaller _scale, and then the modulus is computed.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

The resulting fixed_point number

template<typename Rep1, Radix Rad1>
inline friend bool operator==(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator == (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs and rhs are equal, false if not

template<typename Rep1, Radix Rad1>
inline friend bool operator!=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator != (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs and rhs are not equal, false if not

template<typename Rep1, Radix Rad1>
inline friend bool operator<=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator <= (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs less than or equal to rhs, false if not

template<typename Rep1, Radix Rad1>
inline friend bool operator>=(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator >= (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs greater than or equal to rhs, false if not

template<typename Rep1, Radix Rad1>
inline friend bool operator<(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator < (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs less than rhs, false if not

template<typename Rep1, Radix Rad1>
inline friend bool operator>(fixed_point<Rep1, Rad1> const &lhs, fixed_point<Rep1, Rad1> const &rhs)

operator > (for comparing two fixed_point numbers)

If _scales are equal, _values are compared. If _scales are not equal, the number with the larger _scale is shifted to the smaller _scale, and then the _values are compared.

Template Parameters:

• Rep1 – Representation type of the operand lhs and rhs

• Rad1 – Radix (base) type of the operand lhs and rhs

Parameters:

• lhs – The left hand side operand

• rhs – The right hand side operand

Returns:

true if lhs greater than rhs, false if not