Compile-time rational arithmetic (since C++11)

From cppreference.com

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


	represents exact rational fraction (class template) [edit]

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

Defined in header `<ratio>`
Type	Definition
`quecto` (since C++26)	`std::ratio<1, 1000000000000000000000000000000>` (10^-30)^[1]
`ronto` (since C++26)	`std::ratio<1, 1000000000000000000000000000>` (10^-27)^[1]
`yocto` (since C++11)	`std::ratio<1, 1000000000000000000000000>` (10^-24)^[1]
`zepto` (since C++11)	`std::ratio<1, 1000000000000000000000>` (10^-21)^[1]
`atto` (since C++11)	`std::ratio<1, 1000000000000000000>` (10^-18)
`femto` (since C++11)	`std::ratio<1, 1000000000000000>` (10^-15)
`pico` (since C++11)	`std::ratio<1, 1000000000000>` (10^-12)
`nano` (since C++11)	`std::ratio<1, 1000000000>` (10^-9)
`micro` (since C++11)	`std::ratio<1, 1000000>` (10^-6)
`milli` (since C++11)	`std::ratio<1, 1000>` (10^-3)
`centi` (since C++11)	`std::ratio<1, 100>` (10^-2)
`deci` (since C++11)	`std::ratio<1, 10>` (10^-1)
`deca` (since C++11)	`std::ratio<10, 1>` (10¹)
`hecto` (since C++11)	`std::ratio<100, 1>` (10²)
`kilo` (since C++11)	`std::ratio<1000, 1>` (10³)
`mega` (since C++11)	`std::ratio<1000000, 1>` (10⁶)
`giga` (since C++11)	`std::ratio<1000000000, 1>` (10⁹)
`tera` (since C++11)	`std::ratio<1000000000000, 1>` (10¹²)
`peta` (since C++11)	`std::ratio<1000000000000000, 1>` (10¹⁵)
`exa` (since C++11)	`std::ratio<1000000000000000000, 1>` (10¹⁸)
`zetta` (since C++11)	`std::ratio<1000000000000000000000, 1>` (10²¹)^[2]
`yotta` (since C++11)	`std::ratio<1000000000000000000000000, 1>` (10²⁴)^[2]
`ronna` (since C++26)	`std::ratio<1000000000000000000000000000, 1>` (10²⁷)^[2]
`quetta` (since C++26)	`std::ratio<1000000000000000000000000000000, 1>` (10³⁰)^[2]

↑ ^1.0 ^1.1 ^1.2 ^1.3 These typedefs are only declared if std::intmax_t can represent the denominator.
↑ ^2.0 ^2.1 ^2.2 ^2.3 These typedefs are only declared 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.

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) [edit]
ratio_not_equal (C++11)	compares two `ratio` objects for inequality at compile-time (class template) [edit]
ratio_less (C++11)	compares two `ratio` objects for less than at compile-time (class template) [edit]
ratio_less_equal (C++11)	compares two `ratio` objects for less than or equal to at compile-time (class template) [edit]
ratio_greater (C++11)	compares two `ratio` objects for greater than at compile-time (class template) [edit]
ratio_greater_equal (C++11)	compares two `ratio` objects for greater than or equal to at compile-time (class template) [edit]