Compile-time rational arithmetic

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical specifications

Symbols index

External libraries

 

Numerics library

Common mathematical functions

Mathematical special functions (C++17)

Mathematical constants (C++20)

Floating-point environment (C++11)

Complex numbers

Numeric arrays

Pseudo-random number generation

Compile-time rational arithmetic (C++11)

Factor operations

gcd (C++17)

lcm (C++17)

Interpolations

midpoint (C++20)

lerp (C++20)

Generic numeric operations

iota (C++11)

accumulate

inner_product

adjacent_difference

partial_sum

reduce (C++17)

transform_reduce (C++17)

inclusive_scan (C++17)

exclusive_scan (C++17)

transform_inclusive_scan (C++17)

transform_exclusive_scan (C++17)

Bit operations

bit_cast (C++20)

byteswap (C++23)

has_single_bit (C++20)

bit_ceil (C++20)

bit_floor (C++20)

bit_width (C++20)

rotl (C++20)

rotr (C++20)

countl_zero (C++20)

countl_one (C++20)

countr_zero (C++20)

countr_one (C++20)

popcount (C++20)

endian (C++20)

 

Compile time rational arithmetic

ratio (C++11)

Arithmetic

ratio_add (C++11)

ratio_subtract (C++11)

ratio_multiply (C++11)

ratio_divide (C++11)

Comparison

ratio_equal (C++11)

ratio_not_equal (C++11)

ratio_less (C++11)

ratio_less_equal (C++11)

ratio_greater (C++11)

ratio_greater_equal (C++11)

 

The class template std::ratio and associated templates provide compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number.

Compile-time fractions

Defined in header <ratio>
ratio (C++11)	represents exact rational fraction (class template)

Several convenience typedefs that correspond to the SI ratios are provided by the standard library:

Defined in header <ratio>
Type	Definition
yocto	std::ratio<1, 1000000000000000000000000>, if std::intmax_t can represent the denominator
zepto	std::ratio<1, 1000000000000000000000>, if std::intmax_t can represent the denominator
atto	std::ratio<1, 1000000000000000000>
femto	std::ratio<1, 1000000000000000>
pico	std::ratio<1, 1000000000000>
nano	std::ratio<1, 1000000000>
micro	std::ratio<1, 1000000>
milli	std::ratio<1, 1000>
centi	std::ratio<1, 100>
deci	std::ratio<1, 10>
deca	std::ratio<10, 1>
hecto	std::ratio<100, 1>
kilo	std::ratio<1000, 1>
mega	std::ratio<1000000, 1>
giga	std::ratio<1000000000, 1>
tera	std::ratio<1000000000000, 1>
peta	std::ratio<1000000000000000, 1>
exa	std::ratio<1000000000000000000, 1>
zetta	std::ratio<1000000000000000000000, 1>, if std::intmax_t can represent the numerator
yotta	std::ratio<1000000000000000000000000, 1>, if std::intmax_t can represent the numerator

Compile-time rational arithmetic

Several alias templates, that perform arithmetic operations on ratio objects at compile-time are provided.

Defined in header <ratio>
ratio_add (C++11)	adds two ratio objects at compile-time (alias template)
ratio_subtract (C++11)	subtracts two ratio objects at compile-time (alias template)
ratio_multiply (C++11)	multiplies two ratio objects at compile-time (alias template)
ratio_divide (C++11)	divides two ratio objects at compile-time (alias template)

Compile-time rational comparison

Several class templates, that perform comparison operations on ratio objects at compile-time are provided.

Defined in header <ratio>
ratio_equal (C++11)	compares two ratio objects for equality at compile-time (class template)
ratio_not_equal (C++11)	compares two ratio objects for inequality at compile-time (class template)
ratio_less (C++11)	compares two ratio objects for less than at compile-time (class template)
ratio_less_equal (C++11)	compares two ratio objects for less than or equal to at compile-time (class template)
ratio_greater (C++11)	compares two ratio objects for greater than at compile-time (class template)
ratio_greater_equal (C++11)	compares two ratio objects for greater than or equal to at compile-time (class template)