Namespaces
namespace	bigint
namespace	linalg

Classes
class	FixedSigned
	A fixed-width signed integer. More...
class	FixedUnsigned
	A fixed-width unsigned integer. More...
class	Checked
struct	NumericLimits
struct	NumericLimits< T >
struct	NumericLimits< float >
struct	NumericLimits< double >
struct	NumericLimits< long double >
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>