std::ratio

 

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)

 

Defined in header <ratio>
template<     std::intmax_t Num,     std::intmax_t Denom = 1 > class ratio;		(since C++11)

The class template std::ratio provides compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number as long as its numerator Num and denominator Denom are representable as compile-time constants of type std::intmax_t. In addition, Denom may not be zero and may not be equal to the most negative value.

The static data members num and den representing the numerator and denominator are calculated by dividing Num and Denom by their greatest common divisor. However, two std::ratio with different Num or Denom are distinct types even if they represent the same rational number (after reduction). A ratio type can be reduced to the lowest terms via its type member: std::ratio<3, 6>::type is std::ratio<1, 2>.

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

Member types

Member type	Definition
type	std::ratio<num, den>

Member objects

constexpr intmax_t num [static]	constexpr value of type std::intmax_t equal to sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom) (public static member constant)
constexpr intmax_t den [static]	constexpr value of type std::intmax_t equal to abs(Denom) / gcd(Num, Denom) (public static member constant)

See also

Mathematical constants (C++20)

provides several mathematical constants, such as std::numbers::e for e