Namespaces
namespace	bigint

namespace	linalg

Classes
class	Checked

class	FixedSigned
	A fixed-width signed integer. More...

class	FixedUnsigned
	A fixed-width unsigned integer. More...

struct	NumericLimits

struct	NumericLimits< double >

struct	NumericLimits< float >

struct	NumericLimits< long double >

struct	NumericLimits< T >

struct	Ratio

class	Rational

Typedefs
using	i128_fallback = FixedSigned<128>

using	i256 = FixedSigned<256>

using	u128_fallback = FixedUnsigned<128>

using	u256 = FixedUnsigned<256>

using	ratio_intmax_t = i64

template<Rational< ratio_intmax_t > rational>
using	RatioFromRational = Ratio<rational.numerator(), rational.denominator()>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioAdd = RatioFromRational<A::rational + B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioSubtract = RatioFromRational<A::rational - B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioMultiply = RatioFromRational<A::rational * B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioDivide = RatioFromRational<A::rational / B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioEqual = Constexpr<A::rational == B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioNotEqual = Constexpr<A::rational != B::rational>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioLess = Constexpr<(A::rational < B::rational)>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioLessEqual = Constexpr<(A::rational <= B::rational)>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioGreater = Constexpr<(A::rational > B::rational)>

template<detail::IsRatio A, detail::IsRatio B>
using	RatioGreaterEqual = Constexpr<(A::rational >= B::rational)>

using	Atto = Ratio<1, 1000000000000000000>

using	Femto = Ratio<1, 1000000000000000>

using	Pico = Ratio<1, 1000000000000>

using	Nano = Ratio<1, 1000000000>

using	Micro = Ratio<1, 1000000>

using	Milli = Ratio<1, 1000>

using	Centi = Ratio<1, 100>

using	Deci = Ratio<1, 10>

using	Deca = Ratio<10>

using	Hecto = Ratio<100>

using	Kilo = Ratio<1000>

using	Mega = Ratio<1000000>

using	Giga = Ratio<1000000000>

using	Tera = Ratio<1000000000000>

using	Peta = Ratio<1000000000000000>

using	Exa = Ratio<1000000000000000000>

template<umax size>
using	SmallestUnsignedType = decltype(detail::smallest_unsigned_type_helper(c_<size>))

Functions
template<typename T, typename U>
	Rational (T, U) -> Rational< meta::CommonType< T, U > >

Variables
constexpr auto	abs = detail::AbsFunction {}

constexpr auto	abs_diff = function::curry_back(detail::AbsDiffFunction {}, meta::c_<2ZU>)

constexpr auto	abs_unsigned = detail::AbsUnsignedFunction {}

constexpr auto	align_down = function::curry_back(detail::AlignDownFunction {}, meta::c_<2ZU>)

constexpr auto	align_up = function::curry_back(detail::AlignUpFunction {}, meta::c_<2ZU>)

constexpr auto	divide_round_up = function::curry_back(detail::DivideRoundUpFunction {}, meta::c_<2ZU>)

constexpr auto	gcd = detail::GcdFunction {}

constexpr auto	cmp_equal = detail::CmpEqualFunction {}

constexpr auto	cmp_greater = detail::CmpGreaterFunction {}

constexpr auto	cmp_greater_equal = detail::CmpGreaterEqualFunction {}

constexpr auto	cmp_less = detail::CmpLessFunction {}

constexpr auto	cmp_less_equal = detail::CmpLessEqualFunction {}

constexpr auto	cmp_not_equal = detail::CmpNotEqualFunction {}

constexpr auto	cmp_three_way = detail::CmpThreeWayFunction {}

template<concepts::Integer T>
constexpr auto	representable_as = detail::RepresentableAsFunction<T> {}

constexpr auto	lcm = detail::LcmFunction {}

constexpr auto	midpoint = function::curry_back(detail::MidpointFunction {}, meta::c_<2ZU>)

constexpr auto	to_signed = detail::ToSignedFunction {}

constexpr auto	to_unsigned = detail::ToUnsignedFunction {}

Typedef Documentation

◆ Atto

using di::math::Atto = Ratio<1, 1000000000000000000>

◆ Centi

using di::math::Centi = Ratio<1, 100>

◆ Deca

using di::math::Deca = Ratio<10>

◆ Deci

using di::math::Deci = Ratio<1, 10>

◆ Exa

using di::math::Exa = Ratio<1000000000000000000>

◆ Femto

using di::math::Femto = Ratio<1, 1000000000000000>

◆ Giga

using di::math::Giga = Ratio<1000000000>

◆ Hecto

using di::math::Hecto = Ratio<100>

◆ i128_fallback

using di::math::i128_fallback = FixedSigned<128>

◆ i256

using di::math::i256 = FixedSigned<256>

◆ Kilo

using di::math::Kilo = Ratio<1000>

◆ Mega

using di::math::Mega = Ratio<1000000>

◆ Micro

using di::math::Micro = Ratio<1, 1000000>

◆ Milli

using di::math::Milli = Ratio<1, 1000>

◆ Nano

using di::math::Nano = Ratio<1, 1000000000>

◆ Peta

using di::math::Peta = Ratio<1000000000000000>

◆ Pico

using di::math::Pico = Ratio<1, 1000000000000>