Numerical constants

Numerical constants#

#include <heyoka/number.hpp>

The number class#

class number#

This class is used to represent numerical constants in heyoka’s expression system.

It consists of a union of several floating-point types.

using value_type = std::variant<float, double, long double, mppp::real128, mppp::real>#

Note

mppp::real128 and mppp::real are supported only if heyoka was built with support for the mp++ library (see the installation instructions).

The union of floating-point types.

number() noexcept#

The default constructor initialises the internal union with the 0. literal.

number(const number&)#
number(number&&) noexcept#
number &operator=(const number&)#
number &operator=(number&&) noexcept#
~number()#

Numbers are copy/move constructible, copy/move assignable and destructible.

Moved-from numbers are guaranteed to be in the default-constructed state.

Exception:

any exception thrown by the copy constructor/copy assignment operator of mppp::real.

explicit number(float x) noexcept#
explicit number(double x) noexcept#
explicit number(long double x) noexcept#
explicit number(mppp::real128 x) noexcept#
explicit number(mppp::real x)#

Note

The mppp::real128 and mppp::real overloads are available only if heyoka was built with support for the mp++ library (see the installation instructions).

Numbers can be initialised from values of the supported floating-point types.

Parameters:

x – the construction argument.

Exception:

any exception raised by the copy constructor of mppp::real.

[[nodiscard]] const value_type &value() const noexcept#

Value getter.

Returns:

a reference to the internal union of floating-point types.

Functions#

void swap(number &a, number &b) noexcept#

Swap primitive.

This function will efficiently swap a and b.

Parameters:

  • a – the first number.

  • b – the second number.

std::ostream &operator<<(std::ostream &os, const number &n)#

Stream operator.

Parameters:

  • os – the output stream.

  • n – the input number.

Returns:

a reference to os.

Exception:

any exception thrown by streaming the value of n.

Operators#

number operator+(number n)#
number operator-(const number &n)#

The number class supports the identity and negation operators.

Parameters:

n – the input argument.

Returns:

n or its negation.

Exception:

any exception raised by the constructors of number.

number operator+(const number &x, const number &y)#
number operator-(const number &x, const number &y)#
number operator*(const number &x, const number &y)#
number operator/(const number &x, const number &y)#

The number class supports elementary binary arithmetics.

If the active floating-point types of x and y differ, the active type of the result will be the wider among the operands’ types.

Parameters:

  • x – the first operand.

  • y – the second operand.

Returns:

the result of the binary operation.

Exception:

any exception raised by the constructors of number or by the implementation of the underlying arithmetic operation.

Throws:

std::invalid_argument – if the active types of x and y differ and they don’t support mixed-mode airthmetics.

bool operator==(const number &x, const number &y) noexcept#
bool operator!=(const number &x, const number &y) noexcept#

Equality comparison operators.

Two numbers are considered equal if:

  • their active types are equal, and

  • their values are equal.

Two NaN values are considered equivalent by these comparison operators.

Parameters:

  • x – the first operand.

  • y – the second operand.

Returns:

the result of the comparison.

bool operator<(const number &x, const number &y) noexcept#

Less-than comparison operator.

x is less than y if:

  • the active type of x is narrower than the active type of y, or

  • the active types of x and y are the same, and the value of x is less than the value of y.

NaN values are considered greater than non-NaN values by this operator.

Parameters:

  • x – the first operand.

  • y – the second operand.

Returns:

the result of the comparison.

Standard library specialisations#

template<>
struct std::hash<heyoka::number>#

Specialisation of std::hash for heyoka::number.

The hash value of NaNs depends only on the active floating-point type. That is, all NaNs of a floating-point type hash to the same value.

std::size_t operator()(const heyoka::number &n) const noexcept#
Parameters:

n – the input heyoka::number.

Returns:

a hash value for n.