SI Namespace Reference

Namespaces
	detail
	Namespace containing implementation details for SI.
	literals

Classes
struct	unit_symbol< 'D', std::ratio< 1 > >
struct	unit_symbol< 'D', _ratio >
struct	unit_symbol< 'a', std::ratio< 1 > >
struct	unit_symbol< 'a', _ratio >
struct	unit_symbol< 'r', std::ratio< 1 > >
struct	unit_symbol< 'r', std::ratio< 100000000, 5729577951308232 > >
struct	unit_symbol< 'r', std::ratio< 100000000000, 5729577951308232 > >
struct	unit_symbol< 'r', std::ratio< 100000000000000, 5729577951308232 > >
struct	unit_symbol< 'r', _ratio >
struct	unit_symbol< 'L', std::ratio< 1 >, std::ratio< 2 > >
struct	unit_symbol< 'L', std::ratio< 1, 10000 >, std::ratio< 2 > >
struct	unit_symbol< 'L', std::micro, std::ratio< 2 > >
struct	unit_symbol< 'L', std::ratio< 1 >, std::ratio< 3 > >
struct	unit_symbol< 'L', std::ratio< 1, 1000000 >, std::ratio< 3 > >
struct	unit_symbol< 'L', std::nano, std::ratio< 3 > >
struct	unit_symbol< 'K', std::ratio< 1 > >
struct	unit_symbol< 'K', _ratio >
struct	unit_symbol
	Base struct. Unusable needs template overloading. More...
struct	unit_symbol< 'C', std::ratio< 1 > >
struct	unit_symbol< 'C', _ratio >
struct	unit_symbol< 'Q', std::ratio< 1 > >
struct	unit_symbol< 'Q', _ratio >
struct	unit_symbol< 'G', std::ratio< 1 > >
struct	unit_symbol< 'G', _ratio >
struct	unit_symbol< 'I', std::ratio< 1 > >
struct	unit_symbol< 'I', _ratio >
struct	unit_symbol< 'U', std::ratio< 1 > >
struct	unit_symbol< 'U', _ratio >
struct	unit_symbol< 'O', std::ratio< 1 > >
struct	unit_symbol< 'O', _ratio >
struct	unit_symbol< 'E', std::ratio< 1 > >
struct	unit_symbol< 'E', _ratio >
struct	unit_symbol< 'H', std::ratio< 1 > >
struct	unit_symbol< 'H', _ratio >
struct	unit_symbol< 'F', std::ratio< 1 > >
struct	unit_symbol< 'F', _ratio >
struct	unit_symbol< 'T', std::ratio< 1 >, std::ratio<-1 > >
struct	unit_symbol< 'T', _ratio, std::ratio<-1 > >
struct	unit_symbol< 'i', std::ratio< 1 > >
struct	unit_symbol< 'i', _ratio >
struct	unit_symbol< 'l', std::ratio< 1 > >
struct	unit_symbol< 'l', _ratio >
struct	unit_symbol< 'L', std::ratio< 1 > >
struct	unit_symbol< 'L', _ratio >
struct	unit_symbol< 'J', std::ratio< 1 > >
struct	unit_symbol< 'J', _ratio >
struct	unit_symbol< 'm', std::ratio< 1 > >
struct	unit_symbol< 'm', _ratio >
struct	unit_symbol< 'B', std::ratio< 1 > >
struct	unit_symbol< 'B', _ratio >
struct	unit_symbol< 'f', std::ratio< 1 > >
struct	unit_symbol< 'f', _ratio >
struct	unit_symbol< 'M', std::ratio< 1 > >
struct	unit_symbol< 'M', std::milli >
struct	unit_symbol< 'M', std::kilo >
struct	unit_symbol< 'M', std::exa >
struct	unit_symbol< 'M', _ratio >
struct	unit_symbol< 'P', std::ratio< 1 > >
struct	unit_symbol< 'P', _ratio >
struct	unit_symbol< 'p', std::ratio< 1 > >
struct	unit_symbol< 'p', _ratio >
struct	unit_symbol< 'A', std::ratio< 1 > >
struct	unit_symbol< 'A', _ratio >
struct	unit_symbol< 'R', std::ratio< 1 > >
struct	unit_symbol< 'R', _ratio >
struct	unit_symbol< 'N', std::ratio< 1 > >
struct	unit_symbol< 'N', _ratio >
struct	unit_symbol< 't', std::ratio< 1 > >
struct	unit_symbol< 't', _ratio >
struct	unit_symbol< 'T', std::ratio< 1 > >
struct	unit_symbol< 'T', std::ratio< 60, 1 > >
struct	unit_symbol< 'T', std::ratio< 3600, 1 > >
struct	unit_symbol< 'T', _ratio >
struct	unit_symbol< 'v', std::ratio< 1 > >
struct	unit_symbol< 'v', std::ratio_divide< std::kilo, std::ratio< 3600, 1 > >::type >
struct	unit_symbol< 'v', _ratio >

Typedefs
template<typename _type , class _ratio = std::ratio<1>>
using	absorbed_dose_t = detail::unit_t< 'D', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_gray_t = absorbed_dose_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_gray_t = absorbed_dose_t< _type, std::femto >
template<typename _type >
using	pico_gray_t = absorbed_dose_t< _type, std::pico >
template<typename _type >
using	nano_gray_t = absorbed_dose_t< _type, std::nano >
template<typename _type >
using	micro_gray_t = absorbed_dose_t< _type, std::micro >
template<typename _type >
using	milli_gray_t = absorbed_dose_t< _type, std::milli >
template<typename _type >
using	gray_t = absorbed_dose_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_gray_t = absorbed_dose_t< _type, std::kilo >
template<typename _type >
using	mega_gray_t = absorbed_dose_t< _type, std::mega >
template<typename _type >
using	giga_gray_t = absorbed_dose_t< _type, std::giga >
template<typename _type >
using	tera_gray_t = absorbed_dose_t< _type, std::tera >
template<typename _type >
using	peta_gray_t = absorbed_dose_t< _type, std::peta >
template<typename _type >
using	exa_gray_t = absorbed_dose_t< _type, std::exa >
template<typename _type , typename _ratio >
using	acceleration_t = detail::unit_t< 'a', std::ratio< 1 >, _type, _ratio >
	Type for acceleration a = v / t or a = L / t^2. More...
template<typename _type , typename _ratio >
using	angle_t = detail::unit_t< 'r', std::ratio< 1 >, _type, _ratio >
	Type for angle (which should be buildable from m/m (sin/cos)) More...
template<typename _type >
using	atto_radian_t = angle_t< _type, std::atto >
template<typename _type >
using	femto_radian_t = angle_t< _type, std::femto >
template<typename _type >
using	pico_radian_t = angle_t< _type, std::pico >
template<typename _type >
using	nano_radian_t = angle_t< _type, std::nano >
template<typename _type >
using	micro_radian_t = angle_t< _type, std::micro >
template<typename _type >
using	milli_radian_t = angle_t< _type, std::milli >
template<typename _type >
using	radian_t = angle_t< _type, std::ratio< 1 > >
template<typename _type >
using	micro_degree_t = angle_t< _type, std::ratio< 100000000, 5729577951308232 > >
template<typename _type >
using	milli_degree_t = angle_t< _type, std::ratio< 100000000000, 5729577951308232 > >
template<typename _type >
using	degree_t = angle_t< _type, std::ratio< 100000000000000, 5729577951308232 > >
template<typename _type , typename _ratio >
using	angular_frequency_t = detail::unit_t< 'w', std::ratio< 1 >, _type, _ratio >
	Type for velocity where w = r / T. More...
template<typename _type , typename _ratio >
using	area_t = detail::unit_t< 'L', std::ratio< 2 >, _type, _ratio >
template<typename _type >
using	square_metre_t = area_t< _type, std::ratio< 1 > >
template<typename _type >
using	square_centi_metre_t = area_t< _type, std::ratio_multiply< std::centi, std::centi > >
template<typename _type >
using	square_milli_metre_t = area_t< _type, std::ratio_multiply< std::milli, std::milli > >
template<typename _type , typename _ratio >
using	volume_t = detail::unit_t< 'L', std::ratio< 3 >, _type, _ratio >
template<typename _type >
using	cubic_metre_t = volume_t< _type, std::ratio< 1 > >
template<typename _type >
using	cubic_centi_metre_t = volume_t< _type, std::ratio< 1, 1000000 > >
template<typename _type >
using	cubic_milli_metre_t = volume_t< _type, std::nano >
template<typename _type >
using	astronomic_unit_t = length_t< _type, std::ratio< 149597870691, 1 > >
template<typename _type >
using	lightyear_t = length_t< _type, std::ratio< 9460730777119564, 1 > >
template<typename _type >
using	parsec_t = length_t< _type, std::ratio< 30856775814913700, 1 > >
template<typename _type , class _ratio = std::ratio<1>>
using	catalytic_activity_t = detail::unit_t< 'K', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_katal_t = catalytic_activity_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_katal_t = catalytic_activity_t< _type, std::femto >
template<typename _type >
using	pico_katal_t = catalytic_activity_t< _type, std::pico >
template<typename _type >
using	nano_katal_t = catalytic_activity_t< _type, std::nano >
template<typename _type >
using	micro_katal_t = catalytic_activity_t< _type, std::micro >
template<typename _type >
using	milli_katal_t = catalytic_activity_t< _type, std::milli >
template<typename _type >
using	katal_t = catalytic_activity_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_katal_t = catalytic_activity_t< _type, std::kilo >
template<typename _type >
using	mega_katal_t = catalytic_activity_t< _type, std::mega >
template<typename _type >
using	giga_katal_t = catalytic_activity_t< _type, std::giga >
template<typename _type >
using	tera_katal_t = catalytic_activity_t< _type, std::tera >
template<typename _type >
using	peta_katal_t = catalytic_activity_t< _type, std::peta >
template<typename _type >
using	exa_katal_t = catalytic_activity_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	electric_capacity_t = detail::unit_t< 'C', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_farad_t = electric_capacity_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_farad_t = electric_capacity_t< _type, std::femto >
template<typename _type >
using	pico_farad_t = electric_capacity_t< _type, std::pico >
template<typename _type >
using	nano_farad_t = electric_capacity_t< _type, std::nano >
template<typename _type >
using	micro_farad_t = electric_capacity_t< _type, std::micro >
template<typename _type >
using	milli_farad_t = electric_capacity_t< _type, std::milli >
template<typename _type >
using	farad_t = electric_capacity_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_farad_t = electric_capacity_t< _type, std::kilo >
template<typename _type >
using	mega_farad_t = electric_capacity_t< _type, std::mega >
template<typename _type >
using	giga_farad_t = electric_capacity_t< _type, std::giga >
template<typename _type >
using	tera_farad_t = electric_capacity_t< _type, std::tera >
template<typename _type >
using	peta_farad_t = electric_capacity_t< _type, std::peta >
template<typename _type >
using	exa_farad_t = electric_capacity_t< _type, std::exa >
template<typename _type , typename _ratio >
using	electric_charge_t = detail::unit_t< 'Q', std::ratio< 1 >, _type, _ratio >
	unit for electric charge 'Q' where Q = T * I More...
template<typename _type >
using	atto_coulomb_t = electric_charge_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_coulomb_t = electric_charge_t< _type, std::femto >
template<typename _type >
using	pico_coulomb_t = electric_charge_t< _type, std::pico >
template<typename _type >
using	nano_coulomb_t = electric_charge_t< _type, std::nano >
template<typename _type >
using	micro_coulomb_t = electric_charge_t< _type, std::micro >
template<typename _type >
using	milli_coulomb_t = electric_charge_t< _type, std::milli >
template<typename _type >
using	coulomb_t = electric_charge_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_coulomb_t = electric_charge_t< _type, std::kilo >
template<typename _type >
using	mega_coulomb_t = electric_charge_t< _type, std::mega >
template<typename _type >
using	giga_coulomb_t = electric_charge_t< _type, std::giga >
template<typename _type >
using	tera_coulomb_t = electric_charge_t< _type, std::tera >
template<typename _type >
using	peta_coulomb_t = electric_charge_t< _type, std::peta >
template<typename _type >
using	exa_coulomb_t = electric_charge_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	electric_conductance_t = detail::unit_t< 'G', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_siemens_t = electric_conductance_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_siemens_t = electric_conductance_t< _type, std::femto >
template<typename _type >
using	pico_siemens_t = electric_conductance_t< _type, std::pico >
template<typename _type >
using	nano_siemens_t = electric_conductance_t< _type, std::nano >
template<typename _type >
using	micro_siemens_t = electric_conductance_t< _type, std::micro >
template<typename _type >
using	milli_siemens_t = electric_conductance_t< _type, std::milli >
template<typename _type >
using	siemens_t = electric_conductance_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_siemens_t = electric_conductance_t< _type, std::kilo >
template<typename _type >
using	mega_siemens_t = electric_conductance_t< _type, std::mega >
template<typename _type >
using	giga_siemens_t = electric_conductance_t< _type, std::giga >
template<typename _type >
using	tera_siemens_t = electric_conductance_t< _type, std::tera >
template<typename _type >
using	peta_siemens_t = electric_conductance_t< _type, std::peta >
template<typename _type >
using	exa_siemens_t = electric_conductance_t< _type, std::exa >
template<typename _type , typename _ratio >
using	electric_current_t = detail::unit_t< 'I', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_ampere_t = electric_current_t< _type, std::atto >
template<typename _type >
using	femto_ampere_t = electric_current_t< _type, std::femto >
template<typename _type >
using	pico_ampere_t = electric_current_t< _type, std::pico >
template<typename _type >
using	nano_ampere_t = electric_current_t< _type, std::nano >
template<typename _type >
using	micro_ampere_t = electric_current_t< _type, std::micro >
template<typename _type >
using	milli_ampere_t = electric_current_t< _type, std::milli >
template<typename _type >
using	ampere_t = electric_current_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_ampere_t = electric_current_t< _type, std::kilo >
template<typename _type >
using	mega_ampere_t = electric_current_t< _type, std::mega >
template<typename _type >
using	giga_ampere_t = electric_current_t< _type, std::giga >
template<typename _type >
using	tera_ampere_t = electric_current_t< _type, std::tera >
template<typename _type >
using	peta_ampere_t = electric_current_t< _type, std::peta >
template<typename _type >
using	exa_ampere_t = electric_current_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	electric_potential_t = detail::unit_t< 'U', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_volt_t = electric_potential_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_volt_t = electric_potential_t< _type, std::femto >
template<typename _type >
using	pico_volt_t = electric_potential_t< _type, std::pico >
template<typename _type >
using	nano_volt_t = electric_potential_t< _type, std::nano >
template<typename _type >
using	micro_volt_t = electric_potential_t< _type, std::micro >
template<typename _type >
using	milli_volt_t = electric_potential_t< _type, std::milli >
template<typename _type >
using	volt_t = electric_potential_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_volt_t = electric_potential_t< _type, std::kilo >
template<typename _type >
using	mega_volt_t = electric_potential_t< _type, std::mega >
template<typename _type >
using	giga_volt_t = electric_potential_t< _type, std::giga >
template<typename _type >
using	tera_volt_t = electric_potential_t< _type, std::tera >
template<typename _type >
using	peta_volt_t = electric_potential_t< _type, std::peta >
template<typename _type >
using	exa_volt_t = electric_potential_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	electric_resistance_t = detail::unit_t< 'O', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_ohm_t = electric_resistance_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_ohm_t = electric_resistance_t< _type, std::femto >
template<typename _type >
using	pico_ohm_t = electric_resistance_t< _type, std::pico >
template<typename _type >
using	nano_ohm_t = electric_resistance_t< _type, std::nano >
template<typename _type >
using	micro_ohm_t = electric_resistance_t< _type, std::micro >
template<typename _type >
using	milli_ohm_t = electric_resistance_t< _type, std::milli >
template<typename _type >
using	ohm_t = electric_resistance_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_ohm_t = electric_resistance_t< _type, std::kilo >
template<typename _type >
using	mega_ohm_t = electric_resistance_t< _type, std::mega >
template<typename _type >
using	giga_ohm_t = electric_resistance_t< _type, std::giga >
template<typename _type >
using	tera_ohm_t = electric_resistance_t< _type, std::tera >
template<typename _type >
using	peta_ohm_t = electric_resistance_t< _type, std::peta >
template<typename _type >
using	exa_ohm_t = electric_resistance_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	energy_t = detail::unit_t< 'E', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_joule_t = energy_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_joule_t = energy_t< _type, std::femto >
template<typename _type >
using	pico_joule_t = energy_t< _type, std::pico >
template<typename _type >
using	nano_joule_t = energy_t< _type, std::nano >
template<typename _type >
using	micro_joule_t = energy_t< _type, std::micro >
template<typename _type >
using	milli_joule_t = energy_t< _type, std::milli >
template<typename _type >
using	joule_t = energy_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_joule_t = energy_t< _type, std::kilo >
template<typename _type >
using	mega_joule_t = energy_t< _type, std::mega >
template<typename _type >
using	giga_joule_t = energy_t< _type, std::giga >
template<typename _type >
using	tera_joule_t = energy_t< _type, std::tera >
template<typename _type >
using	peta_joule_t = energy_t< _type, std::peta >
template<typename _type >
using	exa_joule_t = energy_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	equivalent_dose_t = detail::unit_t< 'H', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_sievert_t = equivalent_dose_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_sievert_t = equivalent_dose_t< _type, std::femto >
template<typename _type >
using	pico_sievert_t = equivalent_dose_t< _type, std::pico >
template<typename _type >
using	nano_sievert_t = equivalent_dose_t< _type, std::nano >
template<typename _type >
using	micro_sievert_t = equivalent_dose_t< _type, std::micro >
template<typename _type >
using	milli_sievert_t = equivalent_dose_t< _type, std::milli >
template<typename _type >
using	sievert_t = equivalent_dose_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_sievert_t = equivalent_dose_t< _type, std::kilo >
template<typename _type >
using	mega_sievert_t = equivalent_dose_t< _type, std::mega >
template<typename _type >
using	giga_sievert_t = equivalent_dose_t< _type, std::giga >
template<typename _type >
using	tera_sievert_t = equivalent_dose_t< _type, std::tera >
template<typename _type >
using	peta_sievert_t = equivalent_dose_t< _type, std::peta >
template<typename _type >
using	exa_sievert_t = equivalent_dose_t< _type, std::exa >
template<typename _type , typename _ratio >
using	surface_flow_t = detail::unit_t< 's', std::ratio< 1 >, _type, _ratio >
template<typename _type , typename _ratio >
using	volumetric_flow_t = detail::unit_t< 'V', std::ratio< 1 >, _type, _ratio >
template<typename _type , class _ratio = std::ratio<1>>
using	force_t = detail::unit_t< 'F', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_newton_t = force_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_newton_t = force_t< _type, std::femto >
template<typename _type >
using	pico_newton_t = force_t< _type, std::pico >
template<typename _type >
using	nano_newton_t = force_t< _type, std::nano >
template<typename _type >
using	micro_newton_t = force_t< _type, std::micro >
template<typename _type >
using	milli_newton_t = force_t< _type, std::milli >
template<typename _type >
using	newton_t = force_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_newton_t = force_t< _type, std::kilo >
template<typename _type >
using	mega_newton_t = force_t< _type, std::mega >
template<typename _type >
using	giga_newton_t = force_t< _type, std::giga >
template<typename _type >
using	tera_newton_t = force_t< _type, std::tera >
template<typename _type >
using	peta_newton_t = force_t< _type, std::peta >
template<typename _type >
using	exa_newton_t = force_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	frequency_t = detail::time_base_t< std::ratio<-1 >, _type, _ratio >
template<typename _type >
using	atto_hertz_t = frequency_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_hertz_t = frequency_t< _type, std::femto >
template<typename _type >
using	pico_hertz_t = frequency_t< _type, std::pico >
template<typename _type >
using	nano_hertz_t = frequency_t< _type, std::nano >
template<typename _type >
using	micro_hertz_t = frequency_t< _type, std::micro >
template<typename _type >
using	milli_hertz_t = frequency_t< _type, std::milli >
template<typename _type >
using	hertz_t = frequency_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_hertz_t = frequency_t< _type, std::kilo >
template<typename _type >
using	mega_hertz_t = frequency_t< _type, std::mega >
template<typename _type >
using	giga_hertz_t = frequency_t< _type, std::giga >
template<typename _type >
using	tera_hertz_t = frequency_t< _type, std::tera >
template<typename _type >
using	peta_hertz_t = frequency_t< _type, std::peta >
template<typename _type >
using	exa_hertz_t = frequency_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	illuminance_t = detail::unit_t< 'i', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_lux_t = illuminance_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_lux_t = illuminance_t< _type, std::femto >
template<typename _type >
using	pico_lux_t = illuminance_t< _type, std::pico >
template<typename _type >
using	nano_lux_t = illuminance_t< _type, std::nano >
template<typename _type >
using	micro_lux_t = illuminance_t< _type, std::micro >
template<typename _type >
using	milli_lux_t = illuminance_t< _type, std::milli >
template<typename _type >
using	lux_t = illuminance_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_lux_t = illuminance_t< _type, std::kilo >
template<typename _type >
using	mega_lux_t = illuminance_t< _type, std::mega >
template<typename _type >
using	giga_lux_t = illuminance_t< _type, std::giga >
template<typename _type >
using	tera_lux_t = illuminance_t< _type, std::tera >
template<typename _type >
using	peta_lux_t = illuminance_t< _type, std::peta >
template<typename _type >
using	exa_lux_t = illuminance_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	inductance_t = detail::unit_t< 'l', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_henry_t = inductance_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_henry_t = inductance_t< _type, std::femto >
template<typename _type >
using	pico_henry_t = inductance_t< _type, std::pico >
template<typename _type >
using	nano_henry_t = inductance_t< _type, std::nano >
template<typename _type >
using	micro_henry_t = inductance_t< _type, std::micro >
template<typename _type >
using	milli_henry_t = inductance_t< _type, std::milli >
template<typename _type >
using	henry_t = inductance_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_henry_t = inductance_t< _type, std::kilo >
template<typename _type >
using	mega_henry_t = inductance_t< _type, std::mega >
template<typename _type >
using	giga_henry_t = inductance_t< _type, std::giga >
template<typename _type >
using	tera_henry_t = inductance_t< _type, std::tera >
template<typename _type >
using	peta_henry_t = inductance_t< _type, std::peta >
template<typename _type >
using	exa_henry_t = inductance_t< _type, std::exa >
template<typename _type , typename _ratio >
using	length_t = detail::unit_t< 'L', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_metre_t = length_t< _type, std::atto >
template<typename _type >
using	femto_metre_t = length_t< _type, std::femto >
template<typename _type >
using	pico_metre_t = length_t< _type, std::pico >
template<typename _type >
using	nano_metre_t = length_t< _type, std::nano >
template<typename _type >
using	micro_metre_t = length_t< _type, std::micro >
template<typename _type >
using	milli_metre_t = length_t< _type, std::milli >
template<typename _type >
using	centi_metre_t = length_t< _type, std::centi >
template<typename _type >
using	metre_t = length_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_metre_t = length_t< _type, std::kilo >
template<typename _type >
using	mega_metre_t = length_t< _type, std::mega >
template<typename _type >
using	giga_metre_t = length_t< _type, std::giga >
template<typename _type >
using	tera_metre_t = length_t< _type, std::tera >
template<typename _type >
using	peta_metre_t = length_t< _type, std::peta >
template<typename _type >
using	exa_metre_t = length_t< _type, std::exa >
template<typename _type , typename _ratio >
using	luminosity_t = detail::unit_t< 'J', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_candela_t = luminosity_t< _type, std::atto >
template<typename _type >
using	femto_candela_t = luminosity_t< _type, std::femto >
template<typename _type >
using	pico_candela_t = luminosity_t< _type, std::pico >
template<typename _type >
using	nano_candela_t = luminosity_t< _type, std::nano >
template<typename _type >
using	micro_candela_t = luminosity_t< _type, std::micro >
template<typename _type >
using	milli_candela_t = luminosity_t< _type, std::milli >
template<typename _type >
using	candela_t = luminosity_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_candela_t = luminosity_t< _type, std::kilo >
template<typename _type >
using	mega_candela_t = luminosity_t< _type, std::mega >
template<typename _type >
using	giga_candela_t = luminosity_t< _type, std::giga >
template<typename _type >
using	tera_candela_t = luminosity_t< _type, std::tera >
template<typename _type >
using	peta_candela_t = luminosity_t< _type, std::peta >
template<typename _type >
using	exa_candela_t = luminosity_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	luminous_flux_t = detail::unit_t< 'm', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_lumen_t = luminous_flux_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_lumen_t = luminous_flux_t< _type, std::femto >
template<typename _type >
using	pico_lumen_t = luminous_flux_t< _type, std::pico >
template<typename _type >
using	nano_lumen_t = luminous_flux_t< _type, std::nano >
template<typename _type >
using	micro_lumen_t = luminous_flux_t< _type, std::micro >
template<typename _type >
using	milli_lumen_t = luminous_flux_t< _type, std::milli >
template<typename _type >
using	lumen_t = luminous_flux_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_lumen_t = luminous_flux_t< _type, std::kilo >
template<typename _type >
using	mega_lumen_t = luminous_flux_t< _type, std::mega >
template<typename _type >
using	giga_lumen_t = luminous_flux_t< _type, std::giga >
template<typename _type >
using	tera_lumen_t = luminous_flux_t< _type, std::tera >
template<typename _type >
using	peta_lumen_t = luminous_flux_t< _type, std::peta >
template<typename _type >
using	exa_lumen_t = luminous_flux_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	magnetic_field_t = detail::unit_t< 'B', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_tesla_t = magnetic_field_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_tesla_t = magnetic_field_t< _type, std::femto >
template<typename _type >
using	pico_tesla_t = magnetic_field_t< _type, std::pico >
template<typename _type >
using	nano_tesla_t = magnetic_field_t< _type, std::nano >
template<typename _type >
using	micro_tesla_t = magnetic_field_t< _type, std::micro >
template<typename _type >
using	milli_tesla_t = magnetic_field_t< _type, std::milli >
template<typename _type >
using	tesla_t = magnetic_field_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_tesla_t = magnetic_field_t< _type, std::kilo >
template<typename _type >
using	mega_tesla_t = magnetic_field_t< _type, std::mega >
template<typename _type >
using	giga_tesla_t = magnetic_field_t< _type, std::giga >
template<typename _type >
using	tera_tesla_t = magnetic_field_t< _type, std::tera >
template<typename _type >
using	peta_tesla_t = magnetic_field_t< _type, std::peta >
template<typename _type >
using	exa_tesla_t = magnetic_field_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	magnetic_flux_t = detail::unit_t< 'f', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_weber_t = magnetic_flux_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_weber_t = magnetic_flux_t< _type, std::femto >
template<typename _type >
using	pico_weber_t = magnetic_flux_t< _type, std::pico >
template<typename _type >
using	nano_weber_t = magnetic_flux_t< _type, std::nano >
template<typename _type >
using	micro_weber_t = magnetic_flux_t< _type, std::micro >
template<typename _type >
using	milli_weber_t = magnetic_flux_t< _type, std::milli >
template<typename _type >
using	weber_t = magnetic_flux_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_weber_t = magnetic_flux_t< _type, std::kilo >
template<typename _type >
using	mega_weber_t = magnetic_flux_t< _type, std::mega >
template<typename _type >
using	giga_weber_t = magnetic_flux_t< _type, std::giga >
template<typename _type >
using	tera_weber_t = magnetic_flux_t< _type, std::tera >
template<typename _type >
using	peta_weber_t = magnetic_flux_t< _type, std::peta >
template<typename _type >
using	exa_weber_t = magnetic_flux_t< _type, std::exa >
template<typename _type , typename _ratio >
using	mass_t = detail::unit_t< 'M', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	femto_gram_t = mass_t< _type, std::atto >
template<typename _type >
using	pico_gram_t = mass_t< _type, std::femto >
template<typename _type >
using	nano_gram_t = mass_t< _type, std::pico >
template<typename _type >
using	micro_gram_t = mass_t< _type, std::nano >
template<typename _type >
using	milli_gram_t = mass_t< _type, std::micro >
template<typename _type >
using	gram_t = mass_t< _type, std::milli >
template<typename _type >
using	kilo_gram_t = mass_t< _type, std::ratio< 1 > >
template<typename _type >
using	ton_t = mass_t< _type, std::kilo >
template<typename _type >
using	mega_gram_t = ton_t< _type >
template<typename _type >
using	kilo_ton_t = mass_t< _type, std::mega >
template<typename _type >
using	giga_gram_t = kilo_ton_t< _type >
template<typename _type >
using	mega_ton_t = mass_t< _type, std::giga >
template<typename _type >
using	tera_gram_t = mega_ton_t< _type >
template<typename _type >
using	giga_ton_t = mass_t< _type, std::tera >
template<typename _type >
using	peta_gram_t = giga_ton_t< _type >
template<typename _type >
using	tera_ton_t = mass_t< _type, std::peta >
template<typename _type >
using	exa_gram_t = tera_ton_t< _type >
template<typename _type >
using	peta_ton_t = mass_t< _type, std::exa >
template<typename _type >
using	zetta_gram_t = peta_ton_t< _type >
template<typename _type , typename _ratio >
using	momentum_t = detail::unit_t< 'o', std::ratio< 1 >, _type, _ratio >
	Type for momentum where o = v * M. More...
template<typename _type , class _ratio = std::ratio<1>>
using	power_t = detail::unit_t< 'P', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_watt_t = power_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_watt_t = power_t< _type, std::femto >
template<typename _type >
using	pico_watt_t = power_t< _type, std::pico >
template<typename _type >
using	nano_watt_t = power_t< _type, std::nano >
template<typename _type >
using	micro_watt_t = power_t< _type, std::micro >
template<typename _type >
using	milli_watt_t = power_t< _type, std::milli >
template<typename _type >
using	watt_t = power_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_watt_t = power_t< _type, std::kilo >
template<typename _type >
using	mega_watt_t = power_t< _type, std::mega >
template<typename _type >
using	giga_watt_t = power_t< _type, std::giga >
template<typename _type >
using	tera_watt_t = power_t< _type, std::tera >
template<typename _type >
using	peta_watt_t = power_t< _type, std::peta >
template<typename _type >
using	exa_watt_t = power_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	pressure_t = detail::unit_t< 'p', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_pascal_t = pressure_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_pascal_t = pressure_t< _type, std::femto >
template<typename _type >
using	pico_pascal_t = pressure_t< _type, std::pico >
template<typename _type >
using	nano_pascal_t = pressure_t< _type, std::nano >
template<typename _type >
using	micro_pascal_t = pressure_t< _type, std::micro >
template<typename _type >
using	milli_pascal_t = pressure_t< _type, std::milli >
template<typename _type >
using	pascal_t = pressure_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_pascal_t = pressure_t< _type, std::kilo >
template<typename _type >
using	mega_pascal_t = pressure_t< _type, std::mega >
template<typename _type >
using	giga_pascal_t = pressure_t< _type, std::giga >
template<typename _type >
using	tera_pascal_t = pressure_t< _type, std::tera >
template<typename _type >
using	peta_pascal_t = pressure_t< _type, std::peta >
template<typename _type >
using	exa_pascal_t = pressure_t< _type, std::exa >
template<typename _type , class _ratio = std::ratio<1>>
using	radioactivity_t = detail::unit_t< 'A', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_becquerel_t = radioactivity_t< _type, std::atto >
	specific units More...
template<typename _type >
using	femto_becquerel_t = radioactivity_t< _type, std::femto >
template<typename _type >
using	pico_becquerel_t = radioactivity_t< _type, std::pico >
template<typename _type >
using	nano_becquerel_t = radioactivity_t< _type, std::nano >
template<typename _type >
using	micro_becquerel_t = radioactivity_t< _type, std::micro >
template<typename _type >
using	milli_becquerel_t = radioactivity_t< _type, std::milli >
template<typename _type >
using	becquerel_t = radioactivity_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_becquerel_t = radioactivity_t< _type, std::kilo >
template<typename _type >
using	mega_becquerel_t = radioactivity_t< _type, std::mega >
template<typename _type >
using	giga_becquerel_t = radioactivity_t< _type, std::giga >
template<typename _type >
using	tera_becquerel_t = radioactivity_t< _type, std::tera >
template<typename _type >
using	peta_becquerel_t = radioactivity_t< _type, std::peta >
template<typename _type >
using	exa_becquerel_t = radioactivity_t< _type, std::exa >
template<typename _type , typename _ratio >
using	solid_angle_t = detail::unit_t< 'R', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_steradian_t = solid_angle_t< _type, std::atto >
template<typename _type >
using	femto_steradian_t = solid_angle_t< _type, std::femto >
template<typename _type >
using	pico_steradian_t = solid_angle_t< _type, std::pico >
template<typename _type >
using	nano_steradian_t = solid_angle_t< _type, std::nano >
template<typename _type >
using	micro_steradian_t = solid_angle_t< _type, std::micro >
template<typename _type >
using	milli_steradian_t = solid_angle_t< _type, std::milli >
template<typename _type >
using	steradian_t = solid_angle_t< _type, std::ratio< 1 > >
template<typename _type , typename _ratio >
using	substance_t = detail::unit_t< 'N', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_mol_t = substance_t< _type, std::atto >
template<typename _type >
using	femto_mol_t = substance_t< _type, std::femto >
template<typename _type >
using	pico_mol_t = substance_t< _type, std::pico >
template<typename _type >
using	nano_mol_t = substance_t< _type, std::nano >
template<typename _type >
using	micro_mol_t = substance_t< _type, std::micro >
template<typename _type >
using	milli_mol_t = substance_t< _type, std::milli >
template<typename _type >
using	mol_t = substance_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_mol_t = substance_t< _type, std::kilo >
template<typename _type >
using	mega_mol_t = substance_t< _type, std::mega >
template<typename _type >
using	giga_mol_t = substance_t< _type, std::giga >
template<typename _type >
using	tera_mol_t = substance_t< _type, std::tera >
template<typename _type >
using	peta_mol_t = substance_t< _type, std::peta >
template<typename _type >
using	exa_mol_t = substance_t< _type, std::exa >
template<typename _type , typename _ratio >
using	temperature_t = detail::unit_t< 't', std::ratio< 1 >, _type, _ratio >
template<typename _type >
using	atto_kelvin_t = temperature_t< _type, std::atto >
template<typename _type >
using	femto_kelvin_t = temperature_t< _type, std::femto >
template<typename _type >
using	pico_kelvin_t = temperature_t< _type, std::pico >
template<typename _type >
using	nano_kelvin_t = temperature_t< _type, std::nano >
template<typename _type >
using	micro_kelvin_t = temperature_t< _type, std::micro >
template<typename _type >
using	milli_kelvin_t = temperature_t< _type, std::milli >
template<typename _type >
using	kelvin_t = temperature_t< _type, std::ratio< 1 > >
template<typename _type >
using	kilo_kelvin_t = temperature_t< _type, std::kilo >
template<typename _type >
using	mega_kelvin_t = temperature_t< _type, std::mega >
template<typename _type >
using	giga_kelvin_t = temperature_t< _type, std::giga >
template<typename _type >
using	tera_kelvin_t = temperature_t< _type, std::tera >
template<typename _type >
using	peta_kelvin_t = temperature_t< _type, std::peta >
template<typename _type >
using	exa_kelvin_t = temperature_t< _type, std::exa >
template<typename _type , typename _ratio >
using	time_t = detail::time_base_t< std::ratio< 1 >, _type, _ratio >
template<typename _type , typename _ratio >
using	time_squared_t = detail::time_base_t< std::ratio< 2 >, _type, _ratio >
template<typename _type >
using	atto_seconds_t = time_t< _type, std::atto >
template<typename _type >
using	femto_seconds_t = time_t< _type, std::femto >
template<typename _type >
using	pico_seconds_t = time_t< _type, std::pico >
template<typename _type >
using	nano_seconds_t = time_t< _type, std::nano >
template<typename _type >
using	micro_seconds_t = time_t< _type, std::chrono::microseconds::period >
template<typename _type >
using	milli_seconds_t = time_t< _type, std::chrono::milliseconds::period >
template<typename _type >
using	seconds_t = time_t< _type, std::ratio< 1 > >
template<typename _type >
using	minutes_t = time_t< _type, std::chrono::minutes::period >
template<typename _type >
using	hours_t = time_t< _type, std::chrono::hours::period >
template<typename _type , typename _ratio >
using	velocity_t = detail::unit_t< 'v', std::ratio< 1 >, _type, _ratio >
	Type for velocity where v = L / T. More...
template<typename _type , typename _ratio >
using	velocity_squared_t = detail::unit_t< 'v', std::ratio< 2 >, _type, _ratio >
template<typename _type >
using	metre_per_second_t = velocity_t< _type, std::ratio< 1 >::type >
template<typename _type >
using	kilometre_per_hour_t = velocity_t< _type, std::ratio_divide< std::kilo, std::ratio< 3600, 1 > >::type >
template<typename _type >
using	speed_of_light_t = velocity_t< _type, std::ratio< 299792458, 1 >::type >

Functions
template<char... _digits>
constexpr atto_gray_t< int64_t >	operator""_aGy ()
template<char... _digits>
constexpr femto_gray_t< int64_t >	operator""_fGy ()
template<char... _digits>
constexpr pico_gray_t< int64_t >	operator""_pGy ()
template<char... _digits>
constexpr nano_gray_t< int64_t >	operator""_nGy ()
template<char... _digits>
constexpr micro_gray_t< int64_t >	operator""_uGy ()
template<char... _digits>
constexpr milli_gray_t< int64_t >	operator""_mGy ()
template<char... _digits>
constexpr gray_t< int64_t >	operator""_Gy ()
template<char... _digits>
constexpr kilo_gray_t< int64_t >	operator""_kGy ()
template<char... _digits>
constexpr mega_gray_t< int64_t >	operator""_MGy ()
template<char... _digits>
constexpr giga_gray_t< int64_t >	operator""_GGy ()
template<char... _digits>
constexpr tera_gray_t< int64_t >	operator""_TGy ()
template<char... _digits>
constexpr peta_gray_t< int64_t >	operator""_PGy ()
template<char... _digits>
constexpr exa_gray_t< int64_t >	operator""_EGy ()
constexpr atto_gray_t< long double >	operator""_aGy (long double value)
constexpr femto_gray_t< long double >	operator""_fGy (long double value)
constexpr pico_gray_t< long double >	operator""_pGy (long double value)
constexpr nano_gray_t< long double >	operator""_nGy (long double value)
constexpr micro_gray_t< long double >	operator""_uGy (long double value)
constexpr milli_gray_t< long double >	operator""_mGy (long double value)
constexpr gray_t< long double >	operator""_Gy (long double value)
constexpr kilo_gray_t< long double >	operator""_kGy (long double value)
constexpr mega_gray_t< long double >	operator""_MGy (long double value)
constexpr giga_gray_t< long double >	operator""_GGy (long double value)
constexpr tera_gray_t< long double >	operator""_TGy (long double value)
constexpr peta_gray_t< long double >	operator""_PGy (long double value)
constexpr exa_gray_t< long double >	operator""_EGy (long double value)
template<char... _digits>
constexpr atto_radian_t< int64_t >	operator""_arad ()
template<char... _digits>
constexpr femto_radian_t< int64_t >	operator""_frad ()
template<char... _digits>
constexpr pico_radian_t< int64_t >	operator""_prad ()
template<char... _digits>
constexpr nano_radian_t< int64_t >	operator""_nrad ()
template<char... _digits>
constexpr micro_radian_t< int64_t >	operator""_urad ()
template<char... _digits>
constexpr milli_radian_t< int64_t >	operator""_mrad ()
template<char... _digits>
constexpr radian_t< int64_t >	operator""_rad ()
constexpr atto_radian_t< long double >	operator""_arad (long double value)
constexpr femto_radian_t< long double >	operator""_frad (long double value)
constexpr pico_radian_t< long double >	operator""_prad (long double value)
constexpr nano_radian_t< long double >	operator""_nrad (long double value)
constexpr micro_radian_t< long double >	operator""_urad (long double value)
constexpr milli_radian_t< long double >	operator""_mrad (long double value)
constexpr radian_t< long double >	operator""_rad (long double value)
template<char... _digits>
constexpr micro_degree_t< int64_t >	operator""_udeg ()
template<char... _digits>
constexpr milli_degree_t< int64_t >	operator""_mdeg ()
template<char... _digits>
constexpr degree_t< int64_t >	operator""_deg ()
constexpr micro_degree_t< long double >	operator""_udeg (long double value)
constexpr milli_degree_t< long double >	operator""_mdeg (long double value)
constexpr degree_t< long double >	operator""_deg (long double value)
template<char... _digits>
constexpr square_metre_t< int64_t >	operator""_m2 ()
constexpr square_metre_t< long double >	operator""_m2 (long double m)
template<char... _digits>
constexpr square_centi_metre_t< int64_t >	operator""_cm2 ()
constexpr square_centi_metre_t< long double >	operator""_cm2 (long double cm)
template<char... _digits>
constexpr square_milli_metre_t< int64_t >	operator""_mm2 ()
constexpr square_milli_metre_t< long double >	operator""_mm2 (long double mm)
template<char... _digits>
constexpr cubic_metre_t< int64_t >	operator""_m3 ()
constexpr cubic_metre_t< long double >	operator""_m3 (long double m)
template<char... _digits>
constexpr cubic_centi_metre_t< int64_t >	operator""_cm3 ()
constexpr cubic_centi_metre_t< long double >	operator""_cm3 (long double cm)
template<char... _digits>
constexpr cubic_milli_metre_t< int64_t >	operator""_mm3 ()
constexpr cubic_milli_metre_t< long double >	operator""_mm3 (long double mm)
template<char... _digits>
constexpr astronomic_unit_t< int64_t >	operator""_AU ()
template<char... _digits>
constexpr lightyear_t< int64_t >	operator""_ly ()
template<char... _digits>
constexpr parsec_t< int64_t >	operator""_pc ()
constexpr astronomic_unit_t< long double >	operator""_AU (long double value)
constexpr lightyear_t< long double >	operator""_ly (long double value)
constexpr parsec_t< long double >	operator""_pc (long double value)
template<char... _digits>
constexpr atto_katal_t< int64_t >	operator""_akat ()
template<char... _digits>
constexpr femto_katal_t< int64_t >	operator""_fkat ()
template<char... _digits>
constexpr pico_katal_t< int64_t >	operator""_pkat ()
template<char... _digits>
constexpr nano_katal_t< int64_t >	operator""_nkat ()
template<char... _digits>
constexpr micro_katal_t< int64_t >	operator""_ukat ()
template<char... _digits>
constexpr milli_katal_t< int64_t >	operator""_mkat ()
template<char... _digits>
constexpr katal_t< int64_t >	operator""_kat ()
template<char... _digits>
constexpr kilo_katal_t< int64_t >	operator""_kkat ()
template<char... _digits>
constexpr mega_katal_t< int64_t >	operator""_Mkat ()
template<char... _digits>
constexpr giga_katal_t< int64_t >	operator""_Gkat ()
template<char... _digits>
constexpr tera_katal_t< int64_t >	operator""_Tkat ()
template<char... _digits>
constexpr peta_katal_t< int64_t >	operator""_Pkat ()
template<char... _digits>
constexpr exa_katal_t< int64_t >	operator""_Ekat ()
constexpr atto_katal_t< long double >	operator""_akat (long double value)
constexpr femto_katal_t< long double >	operator""_fkat (long double value)
constexpr pico_katal_t< long double >	operator""_pkat (long double value)
constexpr nano_katal_t< long double >	operator""_nkat (long double value)
constexpr micro_katal_t< long double >	operator""_ukat (long double value)
constexpr milli_katal_t< long double >	operator""_mkat (long double value)
constexpr katal_t< long double >	operator""_kat (long double value)
constexpr kilo_katal_t< long double >	operator""_kkat (long double value)
constexpr mega_katal_t< long double >	operator""_Mkat (long double value)
constexpr giga_katal_t< long double >	operator""_Gkat (long double value)
constexpr tera_katal_t< long double >	operator""_Tkat (long double value)
constexpr peta_katal_t< long double >	operator""_Pkat (long double value)
constexpr exa_katal_t< long double >	operator""_Ekat (long double value)
template<char... _digits>
constexpr atto_farad_t< int64_t >	operator""_aF ()
template<char... _digits>
constexpr femto_farad_t< int64_t >	operator""_fF ()
template<char... _digits>
constexpr pico_farad_t< int64_t >	operator""_pF ()
template<char... _digits>
constexpr nano_farad_t< int64_t >	operator""_nF ()
template<char... _digits>
constexpr micro_farad_t< int64_t >	operator""_uF ()
template<char... _digits>
constexpr milli_farad_t< int64_t >	operator""_mF ()
template<char... _digits>
constexpr farad_t< int64_t >	operator""_F ()
template<char... _digits>
constexpr kilo_farad_t< int64_t >	operator""_kF ()
template<char... _digits>
constexpr mega_farad_t< int64_t >	operator""_MF ()
template<char... _digits>
constexpr giga_farad_t< int64_t >	operator""_GF ()
template<char... _digits>
constexpr tera_farad_t< int64_t >	operator""_TF ()
template<char... _digits>
constexpr peta_farad_t< int64_t >	operator""_PF ()
template<char... _digits>
constexpr exa_farad_t< int64_t >	operator""_EF ()
constexpr atto_farad_t< long double >	operator""_aF (long double value)
constexpr femto_farad_t< long double >	operator""_fF (long double value)
constexpr pico_farad_t< long double >	operator""_pF (long double value)
constexpr nano_farad_t< long double >	operator""_nF (long double value)
constexpr micro_farad_t< long double >	operator""_uF (long double value)
constexpr milli_farad_t< long double >	operator""_mF (long double value)
constexpr farad_t< long double >	operator""_F (long double value)
constexpr kilo_farad_t< long double >	operator""_kF (long double value)
constexpr mega_farad_t< long double >	operator""_MF (long double value)
constexpr giga_farad_t< long double >	operator""_GF (long double value)
constexpr tera_farad_t< long double >	operator""_TF (long double value)
constexpr peta_farad_t< long double >	operator""_PF (long double value)
constexpr exa_farad_t< long double >	operator""_EF (long double value)
template<char... _digits>
constexpr atto_coulomb_t< int64_t >	operator""_aC ()
template<char... _digits>
constexpr femto_coulomb_t< int64_t >	operator""_fC ()
template<char... _digits>
constexpr pico_coulomb_t< int64_t >	operator""_pC ()
template<char... _digits>
constexpr nano_coulomb_t< int64_t >	operator""_nC ()
template<char... _digits>
constexpr micro_coulomb_t< int64_t >	operator""_uC ()
template<char... _digits>
constexpr milli_coulomb_t< int64_t >	operator""_mC ()
template<char... _digits>
constexpr coulomb_t< int64_t >	operator""_C ()
template<char... _digits>
constexpr kilo_coulomb_t< int64_t >	operator""_kC ()
template<char... _digits>
constexpr mega_coulomb_t< int64_t >	operator""_MC ()
template<char... _digits>
constexpr giga_coulomb_t< int64_t >	operator""_GC ()
template<char... _digits>
constexpr tera_coulomb_t< int64_t >	operator""_TC ()
template<char... _digits>
constexpr peta_coulomb_t< int64_t >	operator""_PC ()
template<char... _digits>
constexpr exa_coulomb_t< int64_t >	operator""_EC ()
constexpr atto_coulomb_t< long double >	operator""_aC (long double value)
constexpr femto_coulomb_t< long double >	operator""_fC (long double value)
constexpr pico_coulomb_t< long double >	operator""_pC (long double value)
constexpr nano_coulomb_t< long double >	operator""_nC (long double value)
constexpr micro_coulomb_t< long double >	operator""_uC (long double value)
constexpr milli_coulomb_t< long double >	operator""_mC (long double value)
constexpr coulomb_t< long double >	operator""_C (long double value)
constexpr kilo_coulomb_t< long double >	operator""_kC (long double value)
constexpr mega_coulomb_t< long double >	operator""_MC (long double value)
constexpr giga_coulomb_t< long double >	operator""_GC (long double value)
constexpr tera_coulomb_t< long double >	operator""_TC (long double value)
constexpr peta_coulomb_t< long double >	operator""_PC (long double value)
constexpr exa_coulomb_t< long double >	operator""_EC (long double value)
template<char... _digits>
constexpr atto_siemens_t< int64_t >	operator""_aS ()
template<char... _digits>
constexpr femto_siemens_t< int64_t >	operator""_fS ()
template<char... _digits>
constexpr pico_siemens_t< int64_t >	operator""_pS ()
template<char... _digits>
constexpr nano_siemens_t< int64_t >	operator""_nS ()
template<char... _digits>
constexpr micro_siemens_t< int64_t >	operator""_uS ()
template<char... _digits>
constexpr milli_siemens_t< int64_t >	operator""_mS ()
template<char... _digits>
constexpr siemens_t< int64_t >	operator""_S ()
template<char... _digits>
constexpr kilo_siemens_t< int64_t >	operator""_kS ()
template<char... _digits>
constexpr mega_siemens_t< int64_t >	operator""_MS ()
template<char... _digits>
constexpr giga_siemens_t< int64_t >	operator""_GS ()
template<char... _digits>
constexpr tera_siemens_t< int64_t >	operator""_TS ()
template<char... _digits>
constexpr peta_siemens_t< int64_t >	operator""_PS ()
template<char... _digits>
constexpr exa_siemens_t< int64_t >	operator""_ES ()
constexpr atto_siemens_t< long double >	operator""_aS (long double value)
constexpr femto_siemens_t< long double >	operator""_fS (long double value)
constexpr pico_siemens_t< long double >	operator""_pS (long double value)
constexpr nano_siemens_t< long double >	operator""_nS (long double value)
constexpr micro_siemens_t< long double >	operator""_uS (long double value)
constexpr milli_siemens_t< long double >	operator""_mS (long double value)
constexpr siemens_t< long double >	operator""_S (long double value)
constexpr kilo_siemens_t< long double >	operator""_kS (long double value)
constexpr mega_siemens_t< long double >	operator""_MS (long double value)
constexpr giga_siemens_t< long double >	operator""_GS (long double value)
constexpr tera_siemens_t< long double >	operator""_TS (long double value)
constexpr peta_siemens_t< long double >	operator""_PS (long double value)
constexpr exa_siemens_t< long double >	operator""_ES (long double value)
template<char... _digits>
constexpr atto_ampere_t< int64_t >	operator""_aA ()
template<char... _digits>
constexpr femto_ampere_t< int64_t >	operator""_fA ()
template<char... _digits>
constexpr pico_ampere_t< int64_t >	operator""_pA ()
template<char... _digits>
constexpr nano_ampere_t< int64_t >	operator""_nA ()
template<char... _digits>
constexpr micro_ampere_t< int64_t >	operator""_uA ()
template<char... _digits>
constexpr milli_ampere_t< int64_t >	operator""_mA ()
template<char... _digits>
constexpr ampere_t< int64_t >	operator""_A ()
template<char... _digits>
constexpr kilo_ampere_t< int64_t >	operator""_kA ()
template<char... _digits>
constexpr mega_ampere_t< int64_t >	operator""_MA ()
template<char... _digits>
constexpr giga_ampere_t< int64_t >	operator""_GA ()
template<char... _digits>
constexpr tera_ampere_t< int64_t >	operator""_TA ()
template<char... _digits>
constexpr peta_ampere_t< int64_t >	operator""_PA ()
template<char... _digits>
constexpr exa_ampere_t< int64_t >	operator""_EA ()
constexpr atto_ampere_t< long double >	operator""_aA (long double value)
constexpr femto_ampere_t< long double >	operator""_fA (long double value)
constexpr pico_ampere_t< long double >	operator""_pA (long double value)
constexpr nano_ampere_t< long double >	operator""_nA (long double value)
constexpr micro_ampere_t< long double >	operator""_uA (long double value)
constexpr milli_ampere_t< long double >	operator""_mA (long double value)
constexpr ampere_t< long double >	operator""_A (long double value)
constexpr kilo_ampere_t< long double >	operator""_kA (long double value)
constexpr mega_ampere_t< long double >	operator""_MA (long double value)
constexpr giga_ampere_t< long double >	operator""_GA (long double value)
constexpr tera_ampere_t< long double >	operator""_TA (long double value)
constexpr peta_ampere_t< long double >	operator""_PA (long double value)
constexpr exa_ampere_t< long double >	operator""_EA (long double value)
template<char... _digits>
constexpr atto_volt_t< int64_t >	operator""_aV ()
template<char... _digits>
constexpr femto_volt_t< int64_t >	operator""_fV ()
template<char... _digits>
constexpr pico_volt_t< int64_t >	operator""_pV ()
template<char... _digits>
constexpr nano_volt_t< int64_t >	operator""_nV ()
template<char... _digits>
constexpr micro_volt_t< int64_t >	operator""_uV ()
template<char... _digits>
constexpr milli_volt_t< int64_t >	operator""_mV ()
template<char... _digits>
constexpr volt_t< int64_t >	operator""_V ()
template<char... _digits>
constexpr kilo_volt_t< int64_t >	operator""_kV ()
template<char... _digits>
constexpr mega_volt_t< int64_t >	operator""_MV ()
template<char... _digits>
constexpr giga_volt_t< int64_t >	operator""_GV ()
template<char... _digits>
constexpr tera_volt_t< int64_t >	operator""_TV ()
template<char... _digits>
constexpr peta_volt_t< int64_t >	operator""_PV ()
template<char... _digits>
constexpr exa_volt_t< int64_t >	operator""_EV ()
constexpr atto_volt_t< long double >	operator""_aV (long double value)
constexpr femto_volt_t< long double >	operator""_fV (long double value)
constexpr pico_volt_t< long double >	operator""_pV (long double value)
constexpr nano_volt_t< long double >	operator""_nV (long double value)
constexpr micro_volt_t< long double >	operator""_uV (long double value)
constexpr milli_volt_t< long double >	operator""_mV (long double value)
constexpr volt_t< long double >	operator""_V (long double value)
constexpr kilo_volt_t< long double >	operator""_kV (long double value)
constexpr mega_volt_t< long double >	operator""_MV (long double value)
constexpr giga_volt_t< long double >	operator""_GV (long double value)
constexpr tera_volt_t< long double >	operator""_TV (long double value)
constexpr peta_volt_t< long double >	operator""_PV (long double value)
constexpr exa_volt_t< long double >	operator""_EV (long double value)
template<char... _digits>
constexpr atto_ohm_t< int64_t >	operator""_aOhm ()
template<char... _digits>
constexpr femto_ohm_t< int64_t >	operator""_fOhm ()
template<char... _digits>
constexpr pico_ohm_t< int64_t >	operator""_pOhm ()
template<char... _digits>
constexpr nano_ohm_t< int64_t >	operator""_nOhm ()
template<char... _digits>
constexpr micro_ohm_t< int64_t >	operator""_uOhm ()
template<char... _digits>
constexpr milli_ohm_t< int64_t >	operator""_mOhm ()
template<char... _digits>
constexpr ohm_t< int64_t >	operator""_Ohm ()
template<char... _digits>
constexpr kilo_ohm_t< int64_t >	operator""_kOhm ()
template<char... _digits>
constexpr mega_ohm_t< int64_t >	operator""_MOhm ()
template<char... _digits>
constexpr giga_ohm_t< int64_t >	operator""_GOhm ()
template<char... _digits>
constexpr tera_ohm_t< int64_t >	operator""_TOhm ()
template<char... _digits>
constexpr peta_ohm_t< int64_t >	operator""_POhm ()
template<char... _digits>
constexpr exa_ohm_t< int64_t >	operator""_EOhm ()
constexpr atto_ohm_t< long double >	operator""_aOhm (long double value)
constexpr femto_ohm_t< long double >	operator""_fOhm (long double value)
constexpr pico_ohm_t< long double >	operator""_pOhm (long double value)
constexpr nano_ohm_t< long double >	operator""_nOhm (long double value)
constexpr micro_ohm_t< long double >	operator""_uOhm (long double value)
constexpr milli_ohm_t< long double >	operator""_mOhm (long double value)
constexpr ohm_t< long double >	operator""_Ohm (long double value)
constexpr kilo_ohm_t< long double >	operator""_kOhm (long double value)
constexpr mega_ohm_t< long double >	operator""_MOhm (long double value)
constexpr giga_ohm_t< long double >	operator""_GOhm (long double value)
constexpr tera_ohm_t< long double >	operator""_TOhm (long double value)
constexpr peta_ohm_t< long double >	operator""_POhm (long double value)
constexpr exa_ohm_t< long double >	operator""_EOhm (long double value)
template<char... _digits>
constexpr atto_joule_t< int64_t >	operator""_aJ ()
template<char... _digits>
constexpr femto_joule_t< int64_t >	operator""_fJ ()
template<char... _digits>
constexpr pico_joule_t< int64_t >	operator""_pJ ()
template<char... _digits>
constexpr nano_joule_t< int64_t >	operator""_nJ ()
template<char... _digits>
constexpr micro_joule_t< int64_t >	operator""_uJ ()
template<char... _digits>
constexpr milli_joule_t< int64_t >	operator""_mJ ()
template<char... _digits>
constexpr joule_t< int64_t >	operator""_J ()
template<char... _digits>
constexpr kilo_joule_t< int64_t >	operator""_kJ ()
template<char... _digits>
constexpr mega_joule_t< int64_t >	operator""_MJ ()
template<char... _digits>
constexpr giga_joule_t< int64_t >	operator""_GJ ()
template<char... _digits>
constexpr tera_joule_t< int64_t >	operator""_TJ ()
template<char... _digits>
constexpr peta_joule_t< int64_t >	operator""_PJ ()
template<char... _digits>
constexpr exa_joule_t< int64_t >	operator""_EJ ()
constexpr atto_joule_t< long double >	operator""_aJ (long double value)
constexpr femto_joule_t< long double >	operator""_fJ (long double value)
constexpr pico_joule_t< long double >	operator""_pJ (long double value)
constexpr nano_joule_t< long double >	operator""_nJ (long double value)
constexpr micro_joule_t< long double >	operator""_uJ (long double value)
constexpr milli_joule_t< long double >	operator""_mJ (long double value)
constexpr joule_t< long double >	operator""_J (long double value)
constexpr kilo_joule_t< long double >	operator""_kJ (long double value)
constexpr mega_joule_t< long double >	operator""_MJ (long double value)
constexpr giga_joule_t< long double >	operator""_GJ (long double value)
constexpr tera_joule_t< long double >	operator""_TJ (long double value)
constexpr peta_joule_t< long double >	operator""_PJ (long double value)
constexpr exa_joule_t< long double >	operator""_EJ (long double value)
template<char... _digits>
constexpr atto_sievert_t< int64_t >	operator""_aSv ()
template<char... _digits>
constexpr femto_sievert_t< int64_t >	operator""_fSv ()
template<char... _digits>
constexpr pico_sievert_t< int64_t >	operator""_pSv ()
template<char... _digits>
constexpr nano_sievert_t< int64_t >	operator""_nSv ()
template<char... _digits>
constexpr micro_sievert_t< int64_t >	operator""_uSv ()
template<char... _digits>
constexpr milli_sievert_t< int64_t >	operator""_mSv ()
template<char... _digits>
constexpr sievert_t< int64_t >	operator""_Sv ()
template<char... _digits>
constexpr kilo_sievert_t< int64_t >	operator""_kSv ()
template<char... _digits>
constexpr mega_sievert_t< int64_t >	operator""_MSv ()
template<char... _digits>
constexpr giga_sievert_t< int64_t >	operator""_GSv ()
template<char... _digits>
constexpr tera_sievert_t< int64_t >	operator""_TSv ()
template<char... _digits>
constexpr peta_sievert_t< int64_t >	operator""_PSv ()
template<char... _digits>
constexpr exa_sievert_t< int64_t >	operator""_ESv ()
constexpr atto_sievert_t< long double >	operator""_aSv (long double value)
constexpr femto_sievert_t< long double >	operator""_fSv (long double value)
constexpr pico_sievert_t< long double >	operator""_pSv (long double value)
constexpr nano_sievert_t< long double >	operator""_nSv (long double value)
constexpr micro_sievert_t< long double >	operator""_uSv (long double value)
constexpr milli_sievert_t< long double >	operator""_mSv (long double value)
constexpr sievert_t< long double >	operator""_Sv (long double value)
constexpr kilo_sievert_t< long double >	operator""_kSv (long double value)
constexpr mega_sievert_t< long double >	operator""_MSv (long double value)
constexpr giga_sievert_t< long double >	operator""_GSv (long double value)
constexpr tera_sievert_t< long double >	operator""_TSv (long double value)
constexpr peta_sievert_t< long double >	operator""_PSv (long double value)
constexpr exa_sievert_t< long double >	operator""_ESv (long double value)
template<char... _digits>
constexpr atto_newton_t< int64_t >	operator""_aN ()
template<char... _digits>
constexpr femto_newton_t< int64_t >	operator""_fN ()
template<char... _digits>
constexpr pico_newton_t< int64_t >	operator""_pN ()
template<char... _digits>
constexpr nano_newton_t< int64_t >	operator""_nN ()
template<char... _digits>
constexpr micro_newton_t< int64_t >	operator""_uN ()
template<char... _digits>
constexpr milli_newton_t< int64_t >	operator""_mN ()
template<char... _digits>
constexpr newton_t< int64_t >	operator""_N ()
template<char... _digits>
constexpr kilo_newton_t< int64_t >	operator""_kN ()
template<char... _digits>
constexpr mega_newton_t< int64_t >	operator""_MN ()
template<char... _digits>
constexpr giga_newton_t< int64_t >	operator""_GN ()
template<char... _digits>
constexpr tera_newton_t< int64_t >	operator""_TN ()
template<char... _digits>
constexpr peta_newton_t< int64_t >	operator""_PN ()
template<char... _digits>
constexpr exa_newton_t< int64_t >	operator""_EN ()
constexpr atto_newton_t< long double >	operator""_aN (long double value)
constexpr femto_newton_t< long double >	operator""_fN (long double value)
constexpr pico_newton_t< long double >	operator""_pN (long double value)
constexpr nano_newton_t< long double >	operator""_nN (long double value)
constexpr micro_newton_t< long double >	operator""_uN (long double value)
constexpr milli_newton_t< long double >	operator""_mN (long double value)
constexpr newton_t< long double >	operator""_N (long double value)
constexpr kilo_newton_t< long double >	operator""_kN (long double value)
constexpr mega_newton_t< long double >	operator""_MN (long double value)
constexpr giga_newton_t< long double >	operator""_GN (long double value)
constexpr tera_newton_t< long double >	operator""_TN (long double value)
constexpr peta_newton_t< long double >	operator""_PN (long double value)
constexpr exa_newton_t< long double >	operator""_EN (long double value)
template<char... _digits>
constexpr atto_hertz_t< int64_t >	operator""_aHz ()
template<char... _digits>
constexpr femto_hertz_t< int64_t >	operator""_fHz ()
template<char... _digits>
constexpr pico_hertz_t< int64_t >	operator""_pHz ()
template<char... _digits>
constexpr nano_hertz_t< int64_t >	operator""_nHz ()
template<char... _digits>
constexpr micro_hertz_t< int64_t >	operator""_uHz ()
template<char... _digits>
constexpr milli_hertz_t< int64_t >	operator""_mHz ()
template<char... _digits>
constexpr hertz_t< int64_t >	operator""_Hz ()
template<char... _digits>
constexpr kilo_hertz_t< int64_t >	operator""_kHz ()
template<char... _digits>
constexpr mega_hertz_t< int64_t >	operator""_MHz ()
template<char... _digits>
constexpr giga_hertz_t< int64_t >	operator""_GHz ()
template<char... _digits>
constexpr tera_hertz_t< int64_t >	operator""_THz ()
template<char... _digits>
constexpr peta_hertz_t< int64_t >	operator""_PHz ()
template<char... _digits>
constexpr exa_hertz_t< int64_t >	operator""_EHz ()
constexpr atto_hertz_t< long double >	operator""_aHz (long double value)
constexpr femto_hertz_t< long double >	operator""_fHz (long double value)
constexpr pico_hertz_t< long double >	operator""_pHz (long double value)
constexpr nano_hertz_t< long double >	operator""_nHz (long double value)
constexpr micro_hertz_t< long double >	operator""_uHz (long double value)
constexpr milli_hertz_t< long double >	operator""_mHz (long double value)
constexpr hertz_t< long double >	operator""_Hz (long double value)
constexpr kilo_hertz_t< long double >	operator""_kHz (long double value)
constexpr mega_hertz_t< long double >	operator""_MHz (long double value)
constexpr giga_hertz_t< long double >	operator""_GHz (long double value)
constexpr tera_hertz_t< long double >	operator""_THz (long double value)
constexpr peta_hertz_t< long double >	operator""_PHz (long double value)
constexpr exa_hertz_t< long double >	operator""_EHz (long double value)
template<char... _digits>
constexpr atto_lux_t< int64_t >	operator""_alx ()
template<char... _digits>
constexpr femto_lux_t< int64_t >	operator""_flx ()
template<char... _digits>
constexpr pico_lux_t< int64_t >	operator""_plx ()
template<char... _digits>
constexpr nano_lux_t< int64_t >	operator""_nlx ()
template<char... _digits>
constexpr micro_lux_t< int64_t >	operator""_ulx ()
template<char... _digits>
constexpr milli_lux_t< int64_t >	operator""_mlx ()
template<char... _digits>
constexpr lux_t< int64_t >	operator""_lx ()
template<char... _digits>
constexpr kilo_lux_t< int64_t >	operator""_klx ()
template<char... _digits>
constexpr mega_lux_t< int64_t >	operator""_Mlx ()
template<char... _digits>
constexpr giga_lux_t< int64_t >	operator""_Glx ()
template<char... _digits>
constexpr tera_lux_t< int64_t >	operator""_Tlx ()
template<char... _digits>
constexpr peta_lux_t< int64_t >	operator""_Plx ()
template<char... _digits>
constexpr exa_lux_t< int64_t >	operator""_Elx ()
constexpr atto_lux_t< long double >	operator""_alx (long double value)
constexpr femto_lux_t< long double >	operator""_flx (long double value)
constexpr pico_lux_t< long double >	operator""_plx (long double value)
constexpr nano_lux_t< long double >	operator""_nlx (long double value)
constexpr micro_lux_t< long double >	operator""_ulx (long double value)
constexpr milli_lux_t< long double >	operator""_mlx (long double value)
constexpr lux_t< long double >	operator""_lx (long double value)
constexpr kilo_lux_t< long double >	operator""_klx (long double value)
constexpr mega_lux_t< long double >	operator""_Mlx (long double value)
constexpr giga_lux_t< long double >	operator""_Glx (long double value)
constexpr tera_lux_t< long double >	operator""_Tlx (long double value)
constexpr peta_lux_t< long double >	operator""_Plx (long double value)
constexpr exa_lux_t< long double >	operator""_Elx (long double value)
template<char... _digits>
constexpr atto_henry_t< int64_t >	operator""_aH ()
template<char... _digits>
constexpr femto_henry_t< int64_t >	operator""_fH ()
template<char... _digits>
constexpr pico_henry_t< int64_t >	operator""_pH ()
template<char... _digits>
constexpr nano_henry_t< int64_t >	operator""_nH ()
template<char... _digits>
constexpr micro_henry_t< int64_t >	operator""_uH ()
template<char... _digits>
constexpr milli_henry_t< int64_t >	operator""_mH ()
template<char... _digits>
constexpr henry_t< int64_t >	operator""_H ()
template<char... _digits>
constexpr kilo_henry_t< int64_t >	operator""_kH ()
template<char... _digits>
constexpr mega_henry_t< int64_t >	operator""_MH ()
template<char... _digits>
constexpr giga_henry_t< int64_t >	operator""_GH ()
template<char... _digits>
constexpr tera_henry_t< int64_t >	operator""_TH ()
template<char... _digits>
constexpr peta_henry_t< int64_t >	operator""_PH ()
template<char... _digits>
constexpr exa_henry_t< int64_t >	operator""_EH ()
constexpr atto_henry_t< long double >	operator""_aH (long double value)
constexpr femto_henry_t< long double >	operator""_fH (long double value)
constexpr pico_henry_t< long double >	operator""_pH (long double value)
constexpr nano_henry_t< long double >	operator""_nH (long double value)
constexpr micro_henry_t< long double >	operator""_uH (long double value)
constexpr milli_henry_t< long double >	operator""_mH (long double value)
constexpr henry_t< long double >	operator""_H (long double value)
constexpr kilo_henry_t< long double >	operator""_kH (long double value)
constexpr mega_henry_t< long double >	operator""_MH (long double value)
constexpr giga_henry_t< long double >	operator""_GH (long double value)
constexpr tera_henry_t< long double >	operator""_TH (long double value)
constexpr peta_henry_t< long double >	operator""_PH (long double value)
constexpr exa_henry_t< long double >	operator""_EH (long double value)
template<char... _digits>
constexpr atto_metre_t< int64_t >	operator""_am ()
template<char... _digits>
constexpr femto_metre_t< int64_t >	operator""_fm ()
template<char... _digits>
constexpr pico_metre_t< int64_t >	operator""_pm ()
template<char... _digits>
constexpr nano_metre_t< int64_t >	operator""_nm ()
template<char... _digits>
constexpr micro_metre_t< int64_t >	operator""_um ()
template<char... _digits>
constexpr milli_metre_t< int64_t >	operator""_mm ()
template<char... _digits>
constexpr centi_metre_t< int64_t >	operator""_cm ()
template<char... _digits>
constexpr metre_t< int64_t >	operator""_m ()
template<char... _digits>
constexpr kilo_metre_t< int64_t >	operator""_km ()
template<char... _digits>
constexpr mega_metre_t< int64_t >	operator""_Mm ()
template<char... _digits>
constexpr giga_metre_t< int64_t >	operator""_Gm ()
template<char... _digits>
constexpr tera_metre_t< int64_t >	operator""_Tm ()
template<char... _digits>
constexpr peta_metre_t< int64_t >	operator""_Pm ()
template<char... _digits>
constexpr exa_metre_t< int64_t >	operator""_Em ()
constexpr atto_metre_t< long double >	operator""_am (long double value)
constexpr femto_metre_t< long double >	operator""_fm (long double value)
constexpr pico_metre_t< long double >	operator""_pm (long double value)
constexpr nano_metre_t< long double >	operator""_nm (long double value)
constexpr micro_metre_t< long double >	operator""_um (long double value)
constexpr milli_metre_t< long double >	operator""_mm (long double value)
constexpr centi_metre_t< long double >	operator""_cm (long double value)
constexpr metre_t< long double >	operator""_m (long double value)
constexpr kilo_metre_t< long double >	operator""_km (long double value)
constexpr mega_metre_t< long double >	operator""_Mm (long double value)
constexpr giga_metre_t< long double >	operator""_Gm (long double value)
constexpr tera_metre_t< long double >	operator""_Tm (long double value)
constexpr peta_metre_t< long double >	operator""_Pm (long double value)
constexpr exa_metre_t< long double >	operator""_Em (long double value)
template<char... _digits>
constexpr atto_candela_t< int64_t >	operator""_acd ()
template<char... _digits>
constexpr femto_candela_t< int64_t >	operator""_fcd ()
template<char... _digits>
constexpr pico_candela_t< int64_t >	operator""_pcd ()
template<char... _digits>
constexpr nano_candela_t< int64_t >	operator""_ncd ()
template<char... _digits>
constexpr micro_candela_t< int64_t >	operator""_ucd ()
template<char... _digits>
constexpr milli_candela_t< int64_t >	operator""_mcd ()
template<char... _digits>
constexpr candela_t< int64_t >	operator""_cd ()
template<char... _digits>
constexpr kilo_candela_t< int64_t >	operator""_kcd ()
template<char... _digits>
constexpr mega_candela_t< int64_t >	operator""_Mcd ()
template<char... _digits>
constexpr giga_candela_t< int64_t >	operator""_Gcd ()
template<char... _digits>
constexpr tera_candela_t< int64_t >	operator""_Tcd ()
template<char... _digits>
constexpr peta_candela_t< int64_t >	operator""_Pcd ()
template<char... _digits>
constexpr exa_candela_t< int64_t >	operator""_Ecd ()
constexpr atto_candela_t< long double >	operator""_acd (long double value)
constexpr femto_candela_t< long double >	operator""_fcd (long double value)
constexpr pico_candela_t< long double >	operator""_pcd (long double value)
constexpr nano_candela_t< long double >	operator""_ncd (long double value)
constexpr micro_candela_t< long double >	operator""_ucd (long double value)
constexpr milli_candela_t< long double >	operator""_mcd (long double value)
constexpr candela_t< long double >	operator""_cd (long double value)
constexpr kilo_candela_t< long double >	operator""_kcd (long double value)
constexpr mega_candela_t< long double >	operator""_Mcd (long double value)
constexpr giga_candela_t< long double >	operator""_Gcd (long double value)
constexpr tera_candela_t< long double >	operator""_Tcd (long double value)
constexpr peta_candela_t< long double >	operator""_Pcd (long double value)
constexpr exa_candela_t< long double >	operator""_Ecd (long double value)
template<char... _digits>
constexpr atto_lumen_t< int64_t >	operator""_alm ()
template<char... _digits>
constexpr femto_lumen_t< int64_t >	operator""_flm ()
template<char... _digits>
constexpr pico_lumen_t< int64_t >	operator""_plm ()
template<char... _digits>
constexpr nano_lumen_t< int64_t >	operator""_nlm ()
template<char... _digits>
constexpr micro_lumen_t< int64_t >	operator""_ulm ()
template<char... _digits>
constexpr milli_lumen_t< int64_t >	operator""_mlm ()
template<char... _digits>
constexpr lumen_t< int64_t >	operator""_lm ()
template<char... _digits>
constexpr kilo_lumen_t< int64_t >	operator""_klm ()
template<char... _digits>
constexpr mega_lumen_t< int64_t >	operator""_Mlm ()
template<char... _digits>
constexpr giga_lumen_t< int64_t >	operator""_Glm ()
template<char... _digits>
constexpr tera_lumen_t< int64_t >	operator""_Tlm ()
template<char... _digits>
constexpr peta_lumen_t< int64_t >	operator""_Plm ()
template<char... _digits>
constexpr exa_lumen_t< int64_t >	operator""_Elm ()
constexpr atto_lumen_t< long double >	operator""_alm (long double value)
constexpr femto_lumen_t< long double >	operator""_flm (long double value)
constexpr pico_lumen_t< long double >	operator""_plm (long double value)
constexpr nano_lumen_t< long double >	operator""_nlm (long double value)
constexpr micro_lumen_t< long double >	operator""_ulm (long double value)
constexpr milli_lumen_t< long double >	operator""_mlm (long double value)
constexpr lumen_t< long double >	operator""_lm (long double value)
constexpr kilo_lumen_t< long double >	operator""_klm (long double value)
constexpr mega_lumen_t< long double >	operator""_Mlm (long double value)
constexpr giga_lumen_t< long double >	operator""_Glm (long double value)
constexpr tera_lumen_t< long double >	operator""_Tlm (long double value)
constexpr peta_lumen_t< long double >	operator""_Plm (long double value)
constexpr exa_lumen_t< long double >	operator""_Elm (long double value)
template<char... _digits>
constexpr atto_tesla_t< int64_t >	operator""_aT ()
template<char... _digits>
constexpr femto_tesla_t< int64_t >	operator""_fT ()
template<char... _digits>
constexpr pico_tesla_t< int64_t >	operator""_pT ()
template<char... _digits>
constexpr nano_tesla_t< int64_t >	operator""_nT ()
template<char... _digits>
constexpr micro_tesla_t< int64_t >	operator""_uT ()
template<char... _digits>
constexpr milli_tesla_t< int64_t >	operator""_mT ()
template<char... _digits>
constexpr tesla_t< int64_t >	operator""_T ()
template<char... _digits>
constexpr kilo_tesla_t< int64_t >	operator""_kT ()
template<char... _digits>
constexpr mega_tesla_t< int64_t >	operator""_MT ()
template<char... _digits>
constexpr giga_tesla_t< int64_t >	operator""_GT ()
template<char... _digits>
constexpr tera_tesla_t< int64_t >	operator""_TT ()
template<char... _digits>
constexpr peta_tesla_t< int64_t >	operator""_PT ()
template<char... _digits>
constexpr exa_tesla_t< int64_t >	operator""_ET ()
constexpr atto_tesla_t< long double >	operator""_aT (long double value)
constexpr femto_tesla_t< long double >	operator""_fT (long double value)
constexpr pico_tesla_t< long double >	operator""_pT (long double value)
constexpr nano_tesla_t< long double >	operator""_nT (long double value)
constexpr micro_tesla_t< long double >	operator""_uT (long double value)
constexpr milli_tesla_t< long double >	operator""_mT (long double value)
constexpr tesla_t< long double >	operator""_T (long double value)
constexpr kilo_tesla_t< long double >	operator""_kT (long double value)
constexpr mega_tesla_t< long double >	operator""_MT (long double value)
constexpr giga_tesla_t< long double >	operator""_GT (long double value)
constexpr tera_tesla_t< long double >	operator""_TT (long double value)
constexpr peta_tesla_t< long double >	operator""_PT (long double value)
constexpr exa_tesla_t< long double >	operator""_ET (long double value)
template<char... _digits>
constexpr atto_weber_t< int64_t >	operator""_aWb ()
template<char... _digits>
constexpr femto_weber_t< int64_t >	operator""_fWb ()
template<char... _digits>
constexpr pico_weber_t< int64_t >	operator""_pWb ()
template<char... _digits>
constexpr nano_weber_t< int64_t >	operator""_nWb ()
template<char... _digits>
constexpr micro_weber_t< int64_t >	operator""_uWb ()
template<char... _digits>
constexpr milli_weber_t< int64_t >	operator""_mWb ()
template<char... _digits>
constexpr weber_t< int64_t >	operator""_Wb ()
template<char... _digits>
constexpr kilo_weber_t< int64_t >	operator""_kWb ()
template<char... _digits>
constexpr mega_weber_t< int64_t >	operator""_MWb ()
template<char... _digits>
constexpr giga_weber_t< int64_t >	operator""_GWb ()
template<char... _digits>
constexpr tera_weber_t< int64_t >	operator""_TWb ()
template<char... _digits>
constexpr peta_weber_t< int64_t >	operator""_PWb ()
template<char... _digits>
constexpr exa_weber_t< int64_t >	operator""_EWb ()
constexpr atto_weber_t< long double >	operator""_aWb (long double value)
constexpr femto_weber_t< long double >	operator""_fWb (long double value)
constexpr pico_weber_t< long double >	operator""_pWb (long double value)
constexpr nano_weber_t< long double >	operator""_nWb (long double value)
constexpr micro_weber_t< long double >	operator""_uWb (long double value)
constexpr milli_weber_t< long double >	operator""_mWb (long double value)
constexpr weber_t< long double >	operator""_Wb (long double value)
constexpr kilo_weber_t< long double >	operator""_kWb (long double value)
constexpr mega_weber_t< long double >	operator""_MWb (long double value)
constexpr giga_weber_t< long double >	operator""_GWb (long double value)
constexpr tera_weber_t< long double >	operator""_TWb (long double value)
constexpr peta_weber_t< long double >	operator""_PWb (long double value)
constexpr exa_weber_t< long double >	operator""_EWb (long double value)
template<char... _digits>
constexpr femto_gram_t< int64_t >	operator""_fg ()
template<char... _digits>
constexpr pico_gram_t< int64_t >	operator""_pg ()
template<char... _digits>
constexpr nano_gram_t< int64_t >	operator""_ng ()
template<char... _digits>
constexpr micro_gram_t< int64_t >	operator""_ug ()
template<char... _digits>
constexpr milli_gram_t< int64_t >	operator""_mg ()
template<char... _digits>
constexpr gram_t< int64_t >	operator""_g ()
template<char... _digits>
constexpr kilo_gram_t< int64_t >	operator""_kg ()
template<char... _digits>
constexpr ton_t< int64_t >	operator""_t ()
template<char... _digits>
constexpr kilo_ton_t< int64_t >	operator""_kt ()
template<char... _digits>
constexpr mega_ton_t< int64_t >	operator""_Mt ()
template<char... _digits>
constexpr giga_ton_t< int64_t >	operator""_Gt ()
template<char... _digits>
constexpr tera_ton_t< int64_t >	operator""_Tt ()
template<char... _digits>
constexpr peta_ton_t< int64_t >	operator""_Pt ()
template<char... _digits>
constexpr mega_gram_t< int64_t >	operator""_Mg ()
template<char... _digits>
constexpr giga_gram_t< int64_t >	operator""_Gg ()
template<char... _digits>
constexpr tera_gram_t< int64_t >	operator""_Tg ()
template<char... _digits>
constexpr peta_gram_t< int64_t >	operator""_Pg ()
template<char... _digits>
constexpr exa_gram_t< int64_t >	operator""_Eg ()
template<char... _digits>
constexpr zetta_gram_t< int64_t >	operator""_Zg ()
constexpr femto_gram_t< long double >	operator""_fg (long double value)
constexpr pico_gram_t< long double >	operator""_pg (long double value)
constexpr nano_gram_t< long double >	operator""_ng (long double value)
constexpr micro_gram_t< long double >	operator""_ug (long double value)
constexpr milli_gram_t< long double >	operator""_mg (long double mg)
constexpr gram_t< long double >	operator""_g (long double g)
constexpr kilo_gram_t< long double >	operator""_kg (long double kg)
constexpr ton_t< long double >	operator""_t (long double t)
constexpr kilo_ton_t< long double >	operator""_kt (long double t)
constexpr mega_ton_t< long double >	operator""_Mt (long double t)
constexpr giga_ton_t< long double >	operator""_Gt (long double t)
constexpr tera_ton_t< long double >	operator""_Tt (long double t)
constexpr peta_ton_t< long double >	operator""_Pt (long double t)
constexpr mega_gram_t< long double >	operator""_Mg (long double value)
constexpr giga_gram_t< long double >	operator""_Gg (long double value)
constexpr tera_gram_t< long double >	operator""_Tg (long double value)
constexpr peta_gram_t< long double >	operator""_Pg (long double value)
constexpr exa_gram_t< long double >	operator""_Eg (long double value)
constexpr zetta_gram_t< long double >	operator""_Zg (long double value)
template<char... _digits>
constexpr atto_watt_t< int64_t >	operator""_aW ()
template<char... _digits>
constexpr femto_watt_t< int64_t >	operator""_fW ()
template<char... _digits>
constexpr pico_watt_t< int64_t >	operator""_pW ()
template<char... _digits>
constexpr nano_watt_t< int64_t >	operator""_nW ()
template<char... _digits>
constexpr micro_watt_t< int64_t >	operator""_uW ()
template<char... _digits>
constexpr milli_watt_t< int64_t >	operator""_mW ()
template<char... _digits>
constexpr watt_t< int64_t >	operator""_W ()
template<char... _digits>
constexpr kilo_watt_t< int64_t >	operator""_kW ()
template<char... _digits>
constexpr mega_watt_t< int64_t >	operator""_MW ()
template<char... _digits>
constexpr giga_watt_t< int64_t >	operator""_GW ()
template<char... _digits>
constexpr tera_watt_t< int64_t >	operator""_TW ()
template<char... _digits>
constexpr peta_watt_t< int64_t >	operator""_PW ()
template<char... _digits>
constexpr exa_watt_t< int64_t >	operator""_EW ()
constexpr atto_watt_t< long double >	operator""_aW (long double value)
constexpr femto_watt_t< long double >	operator""_fW (long double value)
constexpr pico_watt_t< long double >	operator""_pW (long double value)
constexpr nano_watt_t< long double >	operator""_nW (long double value)
constexpr micro_watt_t< long double >	operator""_uW (long double value)
constexpr milli_watt_t< long double >	operator""_mW (long double value)
constexpr watt_t< long double >	operator""_W (long double value)
constexpr kilo_watt_t< long double >	operator""_kW (long double value)
constexpr mega_watt_t< long double >	operator""_MW (long double value)
constexpr giga_watt_t< long double >	operator""_GW (long double value)
constexpr tera_watt_t< long double >	operator""_TW (long double value)
constexpr peta_watt_t< long double >	operator""_PW (long double value)
constexpr exa_watt_t< long double >	operator""_EW (long double value)
template<char... _digits>
constexpr atto_pascal_t< int64_t >	operator""_apa ()
template<char... _digits>
constexpr femto_pascal_t< int64_t >	operator""_fpa ()
template<char... _digits>
constexpr pico_pascal_t< int64_t >	operator""_ppa ()
template<char... _digits>
constexpr nano_pascal_t< int64_t >	operator""_npa ()
template<char... _digits>
constexpr micro_pascal_t< int64_t >	operator""_upa ()
template<char... _digits>
constexpr milli_pascal_t< int64_t >	operator""_mpa ()
template<char... _digits>
constexpr pascal_t< int64_t >	operator""_pa ()
template<char... _digits>
constexpr kilo_pascal_t< int64_t >	operator""_kpa ()
template<char... _digits>
constexpr mega_pascal_t< int64_t >	operator""_Mpa ()
template<char... _digits>
constexpr giga_pascal_t< int64_t >	operator""_Gpa ()
template<char... _digits>
constexpr tera_pascal_t< int64_t >	operator""_Tpa ()
template<char... _digits>
constexpr peta_pascal_t< int64_t >	operator""_Ppa ()
template<char... _digits>
constexpr exa_pascal_t< int64_t >	operator""_Epa ()
constexpr atto_pascal_t< long double >	operator""_apa (long double value)
constexpr femto_pascal_t< long double >	operator""_fpa (long double value)
constexpr pico_pascal_t< long double >	operator""_ppa (long double value)
constexpr nano_pascal_t< long double >	operator""_npa (long double value)
constexpr micro_pascal_t< long double >	operator""_upa (long double value)
constexpr milli_pascal_t< long double >	operator""_mpa (long double value)
constexpr pascal_t< long double >	operator""_pa (long double value)
constexpr kilo_pascal_t< long double >	operator""_kpa (long double value)
constexpr mega_pascal_t< long double >	operator""_Mpa (long double value)
constexpr giga_pascal_t< long double >	operator""_Gpa (long double value)
constexpr tera_pascal_t< long double >	operator""_Tpa (long double value)
constexpr peta_pascal_t< long double >	operator""_Ppa (long double value)
constexpr exa_pascal_t< long double >	operator""_Epa (long double value)
template<char... _digits>
constexpr atto_becquerel_t< int64_t >	operator""_aBq ()
template<char... _digits>
constexpr femto_becquerel_t< int64_t >	operator""_fBq ()
template<char... _digits>
constexpr pico_becquerel_t< int64_t >	operator""_pBq ()
template<char... _digits>
constexpr nano_becquerel_t< int64_t >	operator""_nBq ()
template<char... _digits>
constexpr micro_becquerel_t< int64_t >	operator""_uBq ()
template<char... _digits>
constexpr milli_becquerel_t< int64_t >	operator""_mBq ()
template<char... _digits>
constexpr becquerel_t< int64_t >	operator""_Bq ()
template<char... _digits>
constexpr kilo_becquerel_t< int64_t >	operator""_kBq ()
template<char... _digits>
constexpr mega_becquerel_t< int64_t >	operator""_MBq ()
template<char... _digits>
constexpr giga_becquerel_t< int64_t >	operator""_GBq ()
template<char... _digits>
constexpr tera_becquerel_t< int64_t >	operator""_TBq ()
template<char... _digits>
constexpr peta_becquerel_t< int64_t >	operator""_PBq ()
template<char... _digits>
constexpr exa_becquerel_t< int64_t >	operator""_EBq ()
constexpr atto_becquerel_t< long double >	operator""_aBq (long double value)
constexpr femto_becquerel_t< long double >	operator""_fBq (long double value)
constexpr pico_becquerel_t< long double >	operator""_pBq (long double value)
constexpr nano_becquerel_t< long double >	operator""_nBq (long double value)
constexpr micro_becquerel_t< long double >	operator""_uBq (long double value)
constexpr milli_becquerel_t< long double >	operator""_mBq (long double value)
constexpr becquerel_t< long double >	operator""_Bq (long double value)
constexpr kilo_becquerel_t< long double >	operator""_kBq (long double value)
constexpr mega_becquerel_t< long double >	operator""_MBq (long double value)
constexpr giga_becquerel_t< long double >	operator""_GBq (long double value)
constexpr tera_becquerel_t< long double >	operator""_TBq (long double value)
constexpr peta_becquerel_t< long double >	operator""_PBq (long double value)
constexpr exa_becquerel_t< long double >	operator""_EBq (long double value)
template<char... _digits>
constexpr atto_steradian_t< int64_t >	operator""_asr ()
template<char... _digits>
constexpr femto_steradian_t< int64_t >	operator""_fsr ()
template<char... _digits>
constexpr pico_steradian_t< int64_t >	operator""_psr ()
template<char... _digits>
constexpr nano_steradian_t< int64_t >	operator""_nsr ()
template<char... _digits>
constexpr micro_steradian_t< int64_t >	operator""_usr ()
template<char... _digits>
constexpr milli_steradian_t< int64_t >	operator""_msr ()
template<char... _digits>
constexpr steradian_t< int64_t >	operator""_sr ()
constexpr atto_steradian_t< long double >	operator""_asr (long double value)
constexpr femto_steradian_t< long double >	operator""_fsr (long double value)
constexpr pico_steradian_t< long double >	operator""_psr (long double value)
constexpr nano_steradian_t< long double >	operator""_nsr (long double value)
constexpr micro_steradian_t< long double >	operator""_usr (long double value)
constexpr milli_steradian_t< long double >	operator""_msr (long double value)
constexpr steradian_t< long double >	operator""_sr (long double value)
template<char _symbol, typename _exponent , typename _type , typename _ratio >
std::string	to_string (const SI::detail::unit_t< _symbol, _exponent, _type, _ratio > &value)
template<char... _digits>
constexpr atto_mol_t< int64_t >	operator""_amol ()
template<char... _digits>
constexpr femto_mol_t< int64_t >	operator""_fmol ()
template<char... _digits>
constexpr pico_mol_t< int64_t >	operator""_pmol ()
template<char... _digits>
constexpr nano_mol_t< int64_t >	operator""_nmol ()
template<char... _digits>
constexpr micro_mol_t< int64_t >	operator""_umol ()
template<char... _digits>
constexpr milli_mol_t< int64_t >	operator""_mmol ()
template<char... _digits>
constexpr mol_t< int64_t >	operator""_mol ()
template<char... _digits>
constexpr kilo_mol_t< int64_t >	operator""_kmol ()
template<char... _digits>
constexpr mega_mol_t< int64_t >	operator""_Mmol ()
template<char... _digits>
constexpr giga_mol_t< int64_t >	operator""_Gmol ()
template<char... _digits>
constexpr tera_mol_t< int64_t >	operator""_Tmol ()
template<char... _digits>
constexpr peta_mol_t< int64_t >	operator""_Pmol ()
template<char... _digits>
constexpr exa_mol_t< int64_t >	operator""_Emol ()
constexpr atto_mol_t< long double >	operator""_amol (long double value)
constexpr femto_mol_t< long double >	operator""_fmol (long double value)
constexpr pico_mol_t< long double >	operator""_pmol (long double value)
constexpr nano_mol_t< long double >	operator""_nmol (long double value)
constexpr micro_mol_t< long double >	operator""_umol (long double value)
constexpr milli_mol_t< long double >	operator""_mmol (long double value)
constexpr mol_t< long double >	operator""_mol (long double value)
constexpr kilo_mol_t< long double >	operator""_kmol (long double value)
constexpr mega_mol_t< long double >	operator""_Mmol (long double value)
constexpr giga_mol_t< long double >	operator""_Gmol (long double value)
constexpr tera_mol_t< long double >	operator""_Tmol (long double value)
constexpr peta_mol_t< long double >	operator""_Pmol (long double value)
constexpr exa_mol_t< long double >	operator""_Emol (long double value)
template<char... _digits>
constexpr atto_kelvin_t< int64_t >	operator""_aK ()
template<char... _digits>
constexpr femto_kelvin_t< int64_t >	operator""_fK ()
template<char... _digits>
constexpr pico_kelvin_t< int64_t >	operator""_pK ()
template<char... _digits>
constexpr nano_kelvin_t< int64_t >	operator""_nK ()
template<char... _digits>
constexpr micro_kelvin_t< int64_t >	operator""_uK ()
template<char... _digits>
constexpr milli_kelvin_t< int64_t >	operator""_mK ()
template<char... _digits>
constexpr kelvin_t< int64_t >	operator""_K ()
template<char... _digits>
constexpr kilo_kelvin_t< int64_t >	operator""_kK ()
template<char... _digits>
constexpr mega_kelvin_t< int64_t >	operator""_MK ()
template<char... _digits>
constexpr giga_kelvin_t< int64_t >	operator""_GK ()
template<char... _digits>
constexpr tera_kelvin_t< int64_t >	operator""_TK ()
template<char... _digits>
constexpr peta_kelvin_t< int64_t >	operator""_PK ()
template<char... _digits>
constexpr exa_kelvin_t< int64_t >	operator""_EK ()
constexpr atto_kelvin_t< long double >	operator""_aK (long double value)
constexpr femto_kelvin_t< long double >	operator""_fK (long double value)
constexpr pico_kelvin_t< long double >	operator""_pK (long double value)
constexpr nano_kelvin_t< long double >	operator""_nK (long double value)
constexpr micro_kelvin_t< long double >	operator""_uK (long double value)
constexpr milli_kelvin_t< long double >	operator""_mK (long double value)
constexpr kelvin_t< long double >	operator""_K (long double value)
constexpr kilo_kelvin_t< long double >	operator""_kK (long double value)
constexpr mega_kelvin_t< long double >	operator""_MK (long double value)
constexpr giga_kelvin_t< long double >	operator""_GK (long double value)
constexpr tera_kelvin_t< long double >	operator""_TK (long double value)
constexpr peta_kelvin_t< long double >	operator""_PK (long double value)
constexpr exa_kelvin_t< long double >	operator""_EK (long double value)
template<char... _digits>
constexpr atto_seconds_t< int64_t >	operator""_as ()
template<char... _digits>
constexpr femto_seconds_t< int64_t >	operator""_fs ()
template<char... _digits>
constexpr pico_seconds_t< int64_t >	operator""_ps ()
template<char... _digits>
constexpr nano_seconds_t< int64_t >	operator""_ns ()
template<char... _digits>
constexpr SI::micro_seconds_t< int64_t >	operator""_us ()
template<char... _digits>
constexpr SI::milli_seconds_t< int64_t >	operator""_ms ()
template<char... _digits>
constexpr SI::seconds_t< int64_t >	operator""_s ()
template<char... _digits>
constexpr SI::minutes_t< int64_t >	operator""_min ()
template<char... _digits>
constexpr hours_t< int64_t >	operator""_h ()
constexpr atto_seconds_t< long double >	operator""_as (long double value)
constexpr femto_seconds_t< long double >	operator""_fs (long double value)
constexpr pico_seconds_t< long double >	operator""_ps (long double value)
constexpr nano_seconds_t< long double >	operator""_ns (long double value)
constexpr SI::micro_seconds_t< long double >	operator""_us (long double us)
constexpr SI::milli_seconds_t< long double >	operator""_ms (long double ms)
constexpr SI::seconds_t< long double >	operator""_s (long double s)
constexpr SI::minutes_t< long double >	operator""_min (long double min)
constexpr SI::hours_t< long double >	operator""_h (long double h)
template<char... _digits>
constexpr speed_of_light_t< int64_t >	operator""_c ()
constexpr speed_of_light_t< long double >	operator""_c (long double value)
template<char... _digits>
constexpr metre_per_second_t< int64_t >	operator""_m_p_s ()
template<char... _digits>
constexpr kilometre_per_hour_t< int64_t >	operator""_km_p_h ()
constexpr metre_per_second_t< long double >	operator""_m_p_s (long double value)
constexpr kilometre_per_hour_t< long double >	operator""_km_p_h (long double value)

Detailed Description

This file is part of "SI" version 2.5.4 A header only c++ library that provides type safety and user defined literals for handling physical values defined in the International System of Units

https://github.com/bernedom/SI

SPDX-License-Identifier: MIT

Typedef Documentation

absorbed_dose_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::absorbed_dose_t = typedef detail::unit_t<'D', std::ratio<1>, _type, _ratio>

acceleration_t

template<typename _type , typename _ratio >

using SI::acceleration_t = typedef detail::unit_t<'a', std::ratio<1>, _type, _ratio>

Type for acceleration a = v / t or a = L / t^2.

ampere_t

template<typename _type >

using SI::ampere_t = typedef electric_current_t<_type, std::ratio<1> >

angle_t

template<typename _type , typename _ratio >

using SI::angle_t = typedef detail::unit_t<'r', std::ratio<1>, _type, _ratio>

Type for angle (which should be buildable from m/m (sin/cos))

angular_frequency_t

template<typename _type , typename _ratio >

using SI::angular_frequency_t = typedef detail::unit_t<'w', std::ratio<1>, _type, _ratio>

Type for velocity where w = r / T.

area_t

template<typename _type , typename _ratio >

using SI::area_t = typedef detail::unit_t<'L', std::ratio<2>, _type, _ratio>

astronomic_unit_t

template<typename _type >

using SI::astronomic_unit_t = typedef length_t<_type, std::ratio<149597870691, 1> >

Astronomic units are not part of the SI standard but are accepted for use within

atto_ampere_t

template<typename _type >

using SI::atto_ampere_t = typedef electric_current_t<_type, std::atto>

atto_becquerel_t

template<typename _type >

using SI::atto_becquerel_t = typedef radioactivity_t<_type, std::atto>

specific units

atto_candela_t

template<typename _type >

using SI::atto_candela_t = typedef luminosity_t<_type, std::atto>

atto_coulomb_t

template<typename _type >

using SI::atto_coulomb_t = typedef electric_charge_t<_type, std::atto>

specific units

atto_farad_t

template<typename _type >

using SI::atto_farad_t = typedef electric_capacity_t<_type, std::atto>

specific units

atto_gray_t

template<typename _type >

using SI::atto_gray_t = typedef absorbed_dose_t<_type, std::atto>

specific units

atto_henry_t

template<typename _type >

using SI::atto_henry_t = typedef inductance_t<_type, std::atto>

specific units

atto_hertz_t

template<typename _type >

using SI::atto_hertz_t = typedef frequency_t<_type, std::atto>

specific units

atto_joule_t

template<typename _type >

using SI::atto_joule_t = typedef energy_t<_type, std::atto>

specific units

atto_katal_t

template<typename _type >

using SI::atto_katal_t = typedef catalytic_activity_t<_type, std::atto>

specific units

atto_kelvin_t

template<typename _type >

using SI::atto_kelvin_t = typedef temperature_t<_type, std::atto>

atto_lumen_t

template<typename _type >

using SI::atto_lumen_t = typedef luminous_flux_t<_type, std::atto>

specific units

atto_lux_t

template<typename _type >

using SI::atto_lux_t = typedef illuminance_t<_type, std::atto>

specific units

atto_metre_t

template<typename _type >

using SI::atto_metre_t = typedef length_t<_type, std::atto>

atto_mol_t

template<typename _type >

using SI::atto_mol_t = typedef substance_t<_type, std::atto>

atto_newton_t

template<typename _type >

using SI::atto_newton_t = typedef force_t<_type, std::atto>

specific units

atto_ohm_t

template<typename _type >

using SI::atto_ohm_t = typedef electric_resistance_t<_type, std::atto>

specific units

atto_pascal_t

template<typename _type >

using SI::atto_pascal_t = typedef pressure_t<_type, std::atto>

specific units

atto_radian_t

template<typename _type >

using SI::atto_radian_t = typedef angle_t<_type, std::atto>

atto_seconds_t

template<typename _type >

using SI::atto_seconds_t = typedef time_t<_type, std::atto>

atto_siemens_t

template<typename _type >

using SI::atto_siemens_t = typedef electric_conductance_t<_type, std::atto>

specific units

atto_sievert_t

template<typename _type >

using SI::atto_sievert_t = typedef equivalent_dose_t<_type, std::atto>

specific units

atto_steradian_t

template<typename _type >

using SI::atto_steradian_t = typedef solid_angle_t<_type, std::atto>

atto_tesla_t

template<typename _type >

using SI::atto_tesla_t = typedef magnetic_field_t<_type, std::atto>

specific units

atto_volt_t

template<typename _type >

using SI::atto_volt_t = typedef electric_potential_t<_type, std::atto>

specific units

atto_watt_t

template<typename _type >

using SI::atto_watt_t = typedef power_t<_type, std::atto>

specific units

atto_weber_t

template<typename _type >

using SI::atto_weber_t = typedef magnetic_flux_t<_type, std::atto>

specific units

becquerel_t

template<typename _type >

using SI::becquerel_t = typedef radioactivity_t<_type, std::ratio<1> >

candela_t

template<typename _type >

using SI::candela_t = typedef luminosity_t<_type, std::ratio<1> >

catalytic_activity_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::catalytic_activity_t = typedef detail::unit_t<'K', std::ratio<1>, _type, _ratio>

centi_metre_t

template<typename _type >

using SI::centi_metre_t = typedef length_t<_type, std::centi>

coulomb_t

template<typename _type >

using SI::coulomb_t = typedef electric_charge_t<_type, std::ratio<1> >

cubic_centi_metre_t

template<typename _type >

using SI::cubic_centi_metre_t = typedef volume_t<_type, std::ratio<1, 1000000> >

cubic_metre_t

template<typename _type >

using SI::cubic_metre_t = typedef volume_t<_type, std::ratio<1> >

cubic_milli_metre_t

template<typename _type >

using SI::cubic_milli_metre_t = typedef volume_t<_type, std::nano>

degree_t

template<typename _type >

using SI::degree_t = typedef angle_t<_type, std::ratio<100000000000000, 5729577951308232> >

electric_capacity_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::electric_capacity_t = typedef detail::unit_t<'C', std::ratio<1>, _type, _ratio>

electric_charge_t

template<typename _type , typename _ratio >

using SI::electric_charge_t = typedef detail::unit_t<'Q', std::ratio<1>, _type, _ratio>

unit for electric charge 'Q' where Q = T * I

electric_conductance_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::electric_conductance_t = typedef detail::unit_t<'G', std::ratio<1>, _type, _ratio>

electric_current_t

template<typename _type , typename _ratio >

using SI::electric_current_t = typedef detail::unit_t<'I', std::ratio<1>, _type, _ratio>

electric_potential_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::electric_potential_t = typedef detail::unit_t<'U', std::ratio<1>, _type, _ratio>

electric_resistance_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::electric_resistance_t = typedef detail::unit_t<'O', std::ratio<1>, _type, _ratio>

Todo:

find a way to use Ohm as dimension symbol or switch to R (occupied by solid angle)

energy_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::energy_t = typedef detail::unit_t<'E', std::ratio<1>, _type, _ratio>

equivalent_dose_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::equivalent_dose_t = typedef detail::unit_t<'H', std::ratio<1>, _type, _ratio>

exa_ampere_t

template<typename _type >

using SI::exa_ampere_t = typedef electric_current_t<_type, std::exa>

exa_becquerel_t

template<typename _type >

using SI::exa_becquerel_t = typedef radioactivity_t<_type, std::exa>

exa_candela_t

template<typename _type >

using SI::exa_candela_t = typedef luminosity_t<_type, std::exa>

exa_coulomb_t

template<typename _type >

using SI::exa_coulomb_t = typedef electric_charge_t<_type, std::exa>

exa_farad_t

template<typename _type >

using SI::exa_farad_t = typedef electric_capacity_t<_type, std::exa>

exa_gram_t

template<typename _type >

using SI::exa_gram_t = typedef tera_ton_t<_type>

exa_gray_t

template<typename _type >

using SI::exa_gray_t = typedef absorbed_dose_t<_type, std::exa>

exa_henry_t

template<typename _type >

using SI::exa_henry_t = typedef inductance_t<_type, std::exa>

exa_hertz_t

template<typename _type >

using SI::exa_hertz_t = typedef frequency_t<_type, std::exa>

exa_joule_t

template<typename _type >

using SI::exa_joule_t = typedef energy_t<_type, std::exa>

exa_katal_t

template<typename _type >

using SI::exa_katal_t = typedef catalytic_activity_t<_type, std::exa>

exa_kelvin_t

template<typename _type >

using SI::exa_kelvin_t = typedef temperature_t<_type, std::exa>

exa_lumen_t

template<typename _type >

using SI::exa_lumen_t = typedef luminous_flux_t<_type, std::exa>

exa_lux_t

template<typename _type >

using SI::exa_lux_t = typedef illuminance_t<_type, std::exa>

exa_metre_t

template<typename _type >

using SI::exa_metre_t = typedef length_t<_type, std::exa>

exa_mol_t

template<typename _type >

using SI::exa_mol_t = typedef substance_t<_type, std::exa>

exa_newton_t

template<typename _type >

using SI::exa_newton_t = typedef force_t<_type, std::exa>

exa_ohm_t

template<typename _type >

using SI::exa_ohm_t = typedef electric_resistance_t<_type, std::exa>

exa_pascal_t

template<typename _type >

using SI::exa_pascal_t = typedef pressure_t<_type, std::exa>

exa_siemens_t

template<typename _type >

using SI::exa_siemens_t = typedef electric_conductance_t<_type, std::exa>

exa_sievert_t

template<typename _type >

using SI::exa_sievert_t = typedef equivalent_dose_t<_type, std::exa>

exa_tesla_t

template<typename _type >

using SI::exa_tesla_t = typedef magnetic_field_t<_type, std::exa>

exa_volt_t

template<typename _type >

using SI::exa_volt_t = typedef electric_potential_t<_type, std::exa>

exa_watt_t

template<typename _type >

using SI::exa_watt_t = typedef power_t<_type, std::exa>

exa_weber_t

template<typename _type >

using SI::exa_weber_t = typedef magnetic_flux_t<_type, std::exa>

farad_t

template<typename _type >

using SI::farad_t = typedef electric_capacity_t<_type, std::ratio<1> >

femto_ampere_t

template<typename _type >

using SI::femto_ampere_t = typedef electric_current_t<_type, std::femto>

femto_becquerel_t

template<typename _type >

using SI::femto_becquerel_t = typedef radioactivity_t<_type, std::femto>

femto_candela_t

template<typename _type >

using SI::femto_candela_t = typedef luminosity_t<_type, std::femto>

femto_coulomb_t

template<typename _type >

using SI::femto_coulomb_t = typedef electric_charge_t<_type, std::femto>

femto_farad_t

template<typename _type >

using SI::femto_farad_t = typedef electric_capacity_t<_type, std::femto>

femto_gram_t

template<typename _type >

using SI::femto_gram_t = typedef mass_t<_type, std::atto>

femto_gray_t

template<typename _type >

using SI::femto_gray_t = typedef absorbed_dose_t<_type, std::femto>

femto_henry_t

template<typename _type >

using SI::femto_henry_t = typedef inductance_t<_type, std::femto>

femto_hertz_t

template<typename _type >

using SI::femto_hertz_t = typedef frequency_t<_type, std::femto>

femto_joule_t

template<typename _type >

using SI::femto_joule_t = typedef energy_t<_type, std::femto>

femto_katal_t

template<typename _type >

using SI::femto_katal_t = typedef catalytic_activity_t<_type, std::femto>

femto_kelvin_t

template<typename _type >

using SI::femto_kelvin_t = typedef temperature_t<_type, std::femto>

femto_lumen_t

template<typename _type >

using SI::femto_lumen_t = typedef luminous_flux_t<_type, std::femto>

femto_lux_t

template<typename _type >

using SI::femto_lux_t = typedef illuminance_t<_type, std::femto>

femto_metre_t

template<typename _type >

using SI::femto_metre_t = typedef length_t<_type, std::femto>

femto_mol_t

template<typename _type >

using SI::femto_mol_t = typedef substance_t<_type, std::femto>

femto_newton_t

template<typename _type >

using SI::femto_newton_t = typedef force_t<_type, std::femto>

femto_ohm_t

template<typename _type >

using SI::femto_ohm_t = typedef electric_resistance_t<_type, std::femto>

femto_pascal_t

template<typename _type >

using SI::femto_pascal_t = typedef pressure_t<_type, std::femto>

femto_radian_t

template<typename _type >

using SI::femto_radian_t = typedef angle_t<_type, std::femto>

femto_seconds_t

template<typename _type >

using SI::femto_seconds_t = typedef time_t<_type, std::femto>

femto_siemens_t

template<typename _type >

using SI::femto_siemens_t = typedef electric_conductance_t<_type, std::femto>

femto_sievert_t

template<typename _type >

using SI::femto_sievert_t = typedef equivalent_dose_t<_type, std::femto>

femto_steradian_t

template<typename _type >

using SI::femto_steradian_t = typedef solid_angle_t<_type, std::femto>

femto_tesla_t

template<typename _type >

using SI::femto_tesla_t = typedef magnetic_field_t<_type, std::femto>

femto_volt_t

template<typename _type >

using SI::femto_volt_t = typedef electric_potential_t<_type, std::femto>

femto_watt_t

template<typename _type >

using SI::femto_watt_t = typedef power_t<_type, std::femto>

femto_weber_t

template<typename _type >

using SI::femto_weber_t = typedef magnetic_flux_t<_type, std::femto>

force_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::force_t = typedef detail::unit_t<'F', std::ratio<1>, _type, _ratio>

frequency_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::frequency_t = typedef detail::time_base_t<std::ratio<-1>, _type, _ratio>

Todo:

find a way to add alternative dimension symbol (f) to frequency

giga_ampere_t

template<typename _type >

using SI::giga_ampere_t = typedef electric_current_t<_type, std::giga>

giga_becquerel_t

template<typename _type >

using SI::giga_becquerel_t = typedef radioactivity_t<_type, std::giga>

giga_candela_t

template<typename _type >

using SI::giga_candela_t = typedef luminosity_t<_type, std::giga>

giga_coulomb_t

template<typename _type >

using SI::giga_coulomb_t = typedef electric_charge_t<_type, std::giga>

giga_farad_t

template<typename _type >

using SI::giga_farad_t = typedef electric_capacity_t<_type, std::giga>

giga_gram_t

template<typename _type >

using SI::giga_gram_t = typedef kilo_ton_t<_type>

giga_gray_t

template<typename _type >

using SI::giga_gray_t = typedef absorbed_dose_t<_type, std::giga>

giga_henry_t

template<typename _type >

using SI::giga_henry_t = typedef inductance_t<_type, std::giga>

giga_hertz_t

template<typename _type >

using SI::giga_hertz_t = typedef frequency_t<_type, std::giga>

giga_joule_t

template<typename _type >

using SI::giga_joule_t = typedef energy_t<_type, std::giga>

giga_katal_t

template<typename _type >

using SI::giga_katal_t = typedef catalytic_activity_t<_type, std::giga>

giga_kelvin_t

template<typename _type >

using SI::giga_kelvin_t = typedef temperature_t<_type, std::giga>

giga_lumen_t

template<typename _type >

using SI::giga_lumen_t = typedef luminous_flux_t<_type, std::giga>

giga_lux_t

template<typename _type >

using SI::giga_lux_t = typedef illuminance_t<_type, std::giga>

giga_metre_t

template<typename _type >

using SI::giga_metre_t = typedef length_t<_type, std::giga>

giga_mol_t

template<typename _type >

using SI::giga_mol_t = typedef substance_t<_type, std::giga>

giga_newton_t

template<typename _type >

using SI::giga_newton_t = typedef force_t<_type, std::giga>

giga_ohm_t

template<typename _type >

using SI::giga_ohm_t = typedef electric_resistance_t<_type, std::giga>

giga_pascal_t

template<typename _type >

using SI::giga_pascal_t = typedef pressure_t<_type, std::giga>

giga_siemens_t

template<typename _type >

using SI::giga_siemens_t = typedef electric_conductance_t<_type, std::giga>

giga_sievert_t

template<typename _type >

using SI::giga_sievert_t = typedef equivalent_dose_t<_type, std::giga>

giga_tesla_t

template<typename _type >

using SI::giga_tesla_t = typedef magnetic_field_t<_type, std::giga>

giga_ton_t

template<typename _type >

using SI::giga_ton_t = typedef mass_t<_type, std::tera>

giga_volt_t

template<typename _type >

using SI::giga_volt_t = typedef electric_potential_t<_type, std::giga>

giga_watt_t

template<typename _type >

using SI::giga_watt_t = typedef power_t<_type, std::giga>

giga_weber_t

template<typename _type >

using SI::giga_weber_t = typedef magnetic_flux_t<_type, std::giga>

gram_t

template<typename _type >

using SI::gram_t = typedef mass_t<_type, std::milli>

gray_t

template<typename _type >

using SI::gray_t = typedef absorbed_dose_t<_type, std::ratio<1> >

henry_t

template<typename _type >

using SI::henry_t = typedef inductance_t<_type, std::ratio<1> >

hertz_t

template<typename _type >

using SI::hertz_t = typedef frequency_t<_type, std::ratio<1> >

hours_t

template<typename _type >

using SI::hours_t = typedef time_t<_type, std::chrono::hours::period>

illuminance_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::illuminance_t = typedef detail::unit_t<'i', std::ratio<1>, _type, _ratio>

inductance_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::inductance_t = typedef detail::unit_t<'l', std::ratio<1>, _type, _ratio>

joule_t

template<typename _type >

using SI::joule_t = typedef energy_t<_type, std::ratio<1> >

katal_t

template<typename _type >

using SI::katal_t = typedef catalytic_activity_t<_type, std::ratio<1> >

kelvin_t

template<typename _type >

using SI::kelvin_t = typedef temperature_t<_type, std::ratio<1> >

kilo_ampere_t

template<typename _type >

using SI::kilo_ampere_t = typedef electric_current_t<_type, std::kilo>

kilo_becquerel_t

template<typename _type >

using SI::kilo_becquerel_t = typedef radioactivity_t<_type, std::kilo>

kilo_candela_t

template<typename _type >

using SI::kilo_candela_t = typedef luminosity_t<_type, std::kilo>

kilo_coulomb_t

template<typename _type >

using SI::kilo_coulomb_t = typedef electric_charge_t<_type, std::kilo>

kilo_farad_t

template<typename _type >

using SI::kilo_farad_t = typedef electric_capacity_t<_type, std::kilo>

kilo_gram_t

template<typename _type >

using SI::kilo_gram_t = typedef mass_t<_type, std::ratio<1> >

kilo_gray_t

template<typename _type >

using SI::kilo_gray_t = typedef absorbed_dose_t<_type, std::kilo>

kilo_henry_t

template<typename _type >

using SI::kilo_henry_t = typedef inductance_t<_type, std::kilo>

kilo_hertz_t

template<typename _type >

using SI::kilo_hertz_t = typedef frequency_t<_type, std::kilo>

kilo_joule_t

template<typename _type >

using SI::kilo_joule_t = typedef energy_t<_type, std::kilo>

kilo_katal_t

template<typename _type >

using SI::kilo_katal_t = typedef catalytic_activity_t<_type, std::kilo>

kilo_kelvin_t

template<typename _type >

using SI::kilo_kelvin_t = typedef temperature_t<_type, std::kilo>

kilo_lumen_t

template<typename _type >

using SI::kilo_lumen_t = typedef luminous_flux_t<_type, std::kilo>

kilo_lux_t

template<typename _type >

using SI::kilo_lux_t = typedef illuminance_t<_type, std::kilo>

kilo_metre_t

template<typename _type >

using SI::kilo_metre_t = typedef length_t<_type, std::kilo>

kilo_mol_t

template<typename _type >

using SI::kilo_mol_t = typedef substance_t<_type, std::kilo>

kilo_newton_t

template<typename _type >

using SI::kilo_newton_t = typedef force_t<_type, std::kilo>

kilo_ohm_t

template<typename _type >

using SI::kilo_ohm_t = typedef electric_resistance_t<_type, std::kilo>

kilo_pascal_t

template<typename _type >

using SI::kilo_pascal_t = typedef pressure_t<_type, std::kilo>

kilo_siemens_t

template<typename _type >

using SI::kilo_siemens_t = typedef electric_conductance_t<_type, std::kilo>

kilo_sievert_t

template<typename _type >

using SI::kilo_sievert_t = typedef equivalent_dose_t<_type, std::kilo>

kilo_tesla_t

template<typename _type >

using SI::kilo_tesla_t = typedef magnetic_field_t<_type, std::kilo>

kilo_ton_t

template<typename _type >

using SI::kilo_ton_t = typedef mass_t<_type, std::mega>

kilo_volt_t

template<typename _type >

using SI::kilo_volt_t = typedef electric_potential_t<_type, std::kilo>

kilo_watt_t

template<typename _type >

using SI::kilo_watt_t = typedef power_t<_type, std::kilo>

kilo_weber_t

template<typename _type >

using SI::kilo_weber_t = typedef magnetic_flux_t<_type, std::kilo>

kilometre_per_hour_t

template<typename _type >

using SI::kilometre_per_hour_t = typedef velocity_t<_type, std::ratio_divide<std::kilo, std::ratio<3600, 1> >::type>

length_t

template<typename _type , typename _ratio >

using SI::length_t = typedef detail::unit_t<'L', std::ratio<1>, _type, _ratio>

lightyear_t

template<typename _type >

using SI::lightyear_t = typedef length_t<_type, std::ratio<9460730777119564, 1> >

lumen_t

template<typename _type >

using SI::lumen_t = typedef luminous_flux_t<_type, std::ratio<1> >

luminosity_t

template<typename _type , typename _ratio >

using SI::luminosity_t = typedef detail::unit_t<'J', std::ratio<1>, _type, _ratio>

luminous_flux_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::luminous_flux_t = typedef detail::unit_t<'m', std::ratio<1>, _type, _ratio>

lux_t

template<typename _type >

using SI::lux_t = typedef illuminance_t<_type, std::ratio<1> >

magnetic_field_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::magnetic_field_t = typedef detail::unit_t<'B', std::ratio<1>, _type, _ratio>

Todo:

find a way to encapsulate phi

magnetic_flux_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::magnetic_flux_t = typedef detail::unit_t<'f', std::ratio<1>, _type, _ratio>

Todo:

find a way to encapsulate phi

mass_t

template<typename _type , typename _ratio >

using SI::mass_t = typedef detail::unit_t<'M', std::ratio<1>, _type, _ratio>

mega_ampere_t

template<typename _type >

using SI::mega_ampere_t = typedef electric_current_t<_type, std::mega>

mega_becquerel_t

template<typename _type >

using SI::mega_becquerel_t = typedef radioactivity_t<_type, std::mega>

mega_candela_t

template<typename _type >

using SI::mega_candela_t = typedef luminosity_t<_type, std::mega>

mega_coulomb_t

template<typename _type >

using SI::mega_coulomb_t = typedef electric_charge_t<_type, std::mega>

mega_farad_t

template<typename _type >

using SI::mega_farad_t = typedef electric_capacity_t<_type, std::mega>

mega_gram_t

template<typename _type >

using SI::mega_gram_t = typedef ton_t<_type>

mega_gray_t

template<typename _type >

using SI::mega_gray_t = typedef absorbed_dose_t<_type, std::mega>

mega_henry_t

template<typename _type >

using SI::mega_henry_t = typedef inductance_t<_type, std::mega>

mega_hertz_t

template<typename _type >

using SI::mega_hertz_t = typedef frequency_t<_type, std::mega>

mega_joule_t

template<typename _type >

using SI::mega_joule_t = typedef energy_t<_type, std::mega>

mega_katal_t

template<typename _type >

using SI::mega_katal_t = typedef catalytic_activity_t<_type, std::mega>

mega_kelvin_t

template<typename _type >

using SI::mega_kelvin_t = typedef temperature_t<_type, std::mega>

mega_lumen_t

template<typename _type >

using SI::mega_lumen_t = typedef luminous_flux_t<_type, std::mega>

mega_lux_t

template<typename _type >

using SI::mega_lux_t = typedef illuminance_t<_type, std::mega>

mega_metre_t

template<typename _type >

using SI::mega_metre_t = typedef length_t<_type, std::mega>

mega_mol_t

template<typename _type >

using SI::mega_mol_t = typedef substance_t<_type, std::mega>

mega_newton_t

template<typename _type >

using SI::mega_newton_t = typedef force_t<_type, std::mega>

mega_ohm_t

template<typename _type >

using SI::mega_ohm_t = typedef electric_resistance_t<_type, std::mega>

mega_pascal_t

template<typename _type >

using SI::mega_pascal_t = typedef pressure_t<_type, std::mega>

mega_siemens_t

template<typename _type >

using SI::mega_siemens_t = typedef electric_conductance_t<_type, std::mega>

mega_sievert_t

template<typename _type >

using SI::mega_sievert_t = typedef equivalent_dose_t<_type, std::mega>

mega_tesla_t

template<typename _type >

using SI::mega_tesla_t = typedef magnetic_field_t<_type, std::mega>

mega_ton_t

template<typename _type >

using SI::mega_ton_t = typedef mass_t<_type, std::giga>

mega_volt_t

template<typename _type >

using SI::mega_volt_t = typedef electric_potential_t<_type, std::mega>

mega_watt_t

template<typename _type >

using SI::mega_watt_t = typedef power_t<_type, std::mega>

mega_weber_t

template<typename _type >

using SI::mega_weber_t = typedef magnetic_flux_t<_type, std::mega>

metre_per_second_t

template<typename _type >

using SI::metre_per_second_t = typedef velocity_t<_type, std::ratio<1>::type>

metre_t

template<typename _type >

using SI::metre_t = typedef length_t<_type, std::ratio<1> >

micro_ampere_t

template<typename _type >

using SI::micro_ampere_t = typedef electric_current_t<_type, std::micro>

micro_becquerel_t

template<typename _type >

using SI::micro_becquerel_t = typedef radioactivity_t<_type, std::micro>

micro_candela_t

template<typename _type >

using SI::micro_candela_t = typedef luminosity_t<_type, std::micro>

micro_coulomb_t

template<typename _type >

using SI::micro_coulomb_t = typedef electric_charge_t<_type, std::micro>

micro_degree_t

template<typename _type >

using SI::micro_degree_t = typedef angle_t<_type, std::ratio<100000000, 5729577951308232> >

micro_farad_t

template<typename _type >

using SI::micro_farad_t = typedef electric_capacity_t<_type, std::micro>

micro_gram_t

template<typename _type >

using SI::micro_gram_t = typedef mass_t<_type, std::nano>

micro_gray_t

template<typename _type >

using SI::micro_gray_t = typedef absorbed_dose_t<_type, std::micro>

micro_henry_t

template<typename _type >

using SI::micro_henry_t = typedef inductance_t<_type, std::micro>

micro_hertz_t

template<typename _type >

using SI::micro_hertz_t = typedef frequency_t<_type, std::micro>

micro_joule_t

template<typename _type >

using SI::micro_joule_t = typedef energy_t<_type, std::micro>

micro_katal_t

template<typename _type >

using SI::micro_katal_t = typedef catalytic_activity_t<_type, std::micro>

micro_kelvin_t

template<typename _type >

using SI::micro_kelvin_t = typedef temperature_t<_type, std::micro>

micro_lumen_t

template<typename _type >

using SI::micro_lumen_t = typedef luminous_flux_t<_type, std::micro>

micro_lux_t

template<typename _type >

using SI::micro_lux_t = typedef illuminance_t<_type, std::micro>

micro_metre_t

template<typename _type >

using SI::micro_metre_t = typedef length_t<_type, std::micro>

micro_mol_t

template<typename _type >

using SI::micro_mol_t = typedef substance_t<_type, std::micro>

micro_newton_t

template<typename _type >

using SI::micro_newton_t = typedef force_t<_type, std::micro>

micro_ohm_t

template<typename _type >

using SI::micro_ohm_t = typedef electric_resistance_t<_type, std::micro>

micro_pascal_t

template<typename _type >

using SI::micro_pascal_t = typedef pressure_t<_type, std::micro>

micro_radian_t

template<typename _type >

using SI::micro_radian_t = typedef angle_t<_type, std::micro>

micro_seconds_t

template<typename _type >

using SI::micro_seconds_t = typedef time_t<_type, std::chrono::microseconds::period>

micro_siemens_t

template<typename _type >

using SI::micro_siemens_t = typedef electric_conductance_t<_type, std::micro>

micro_sievert_t

template<typename _type >

using SI::micro_sievert_t = typedef equivalent_dose_t<_type, std::micro>

micro_steradian_t

template<typename _type >

using SI::micro_steradian_t = typedef solid_angle_t<_type, std::micro>

micro_tesla_t

template<typename _type >

using SI::micro_tesla_t = typedef magnetic_field_t<_type, std::micro>

micro_volt_t

template<typename _type >

using SI::micro_volt_t = typedef electric_potential_t<_type, std::micro>

micro_watt_t

template<typename _type >

using SI::micro_watt_t = typedef power_t<_type, std::micro>

micro_weber_t

template<typename _type >

using SI::micro_weber_t = typedef magnetic_flux_t<_type, std::micro>

milli_ampere_t

template<typename _type >

using SI::milli_ampere_t = typedef electric_current_t<_type, std::milli>

milli_becquerel_t

template<typename _type >

using SI::milli_becquerel_t = typedef radioactivity_t<_type, std::milli>

milli_candela_t

template<typename _type >

using SI::milli_candela_t = typedef luminosity_t<_type, std::milli>

milli_coulomb_t

template<typename _type >

using SI::milli_coulomb_t = typedef electric_charge_t<_type, std::milli>

milli_degree_t

template<typename _type >

using SI::milli_degree_t = typedef angle_t<_type, std::ratio<100000000000, 5729577951308232> >

milli_farad_t

template<typename _type >

using SI::milli_farad_t = typedef electric_capacity_t<_type, std::milli>

milli_gram_t

template<typename _type >

using SI::milli_gram_t = typedef mass_t<_type, std::micro>

milli_gray_t

template<typename _type >

using SI::milli_gray_t = typedef absorbed_dose_t<_type, std::milli>

milli_henry_t

template<typename _type >

using SI::milli_henry_t = typedef inductance_t<_type, std::milli>

milli_hertz_t

template<typename _type >

using SI::milli_hertz_t = typedef frequency_t<_type, std::milli>

milli_joule_t

template<typename _type >

using SI::milli_joule_t = typedef energy_t<_type, std::milli>

milli_katal_t

template<typename _type >

using SI::milli_katal_t = typedef catalytic_activity_t<_type, std::milli>

milli_kelvin_t

template<typename _type >

using SI::milli_kelvin_t = typedef temperature_t<_type, std::milli>

milli_lumen_t

template<typename _type >

using SI::milli_lumen_t = typedef luminous_flux_t<_type, std::milli>

milli_lux_t

template<typename _type >

using SI::milli_lux_t = typedef illuminance_t<_type, std::milli>

milli_metre_t

template<typename _type >

using SI::milli_metre_t = typedef length_t<_type, std::milli>

milli_mol_t

template<typename _type >

using SI::milli_mol_t = typedef substance_t<_type, std::milli>

milli_newton_t

template<typename _type >

using SI::milli_newton_t = typedef force_t<_type, std::milli>

milli_ohm_t

template<typename _type >

using SI::milli_ohm_t = typedef electric_resistance_t<_type, std::milli>

milli_pascal_t

template<typename _type >

using SI::milli_pascal_t = typedef pressure_t<_type, std::milli>

milli_radian_t

template<typename _type >

using SI::milli_radian_t = typedef angle_t<_type, std::milli>

milli_seconds_t

template<typename _type >

using SI::milli_seconds_t = typedef time_t<_type, std::chrono::milliseconds::period>

milli_siemens_t

template<typename _type >

using SI::milli_siemens_t = typedef electric_conductance_t<_type, std::milli>

milli_sievert_t

template<typename _type >

using SI::milli_sievert_t = typedef equivalent_dose_t<_type, std::milli>

milli_steradian_t

template<typename _type >

using SI::milli_steradian_t = typedef solid_angle_t<_type, std::milli>

milli_tesla_t

template<typename _type >

using SI::milli_tesla_t = typedef magnetic_field_t<_type, std::milli>

milli_volt_t

template<typename _type >

using SI::milli_volt_t = typedef electric_potential_t<_type, std::milli>

milli_watt_t

template<typename _type >

using SI::milli_watt_t = typedef power_t<_type, std::milli>

milli_weber_t

template<typename _type >

using SI::milli_weber_t = typedef magnetic_flux_t<_type, std::milli>

minutes_t

template<typename _type >

using SI::minutes_t = typedef time_t<_type, std::chrono::minutes::period>

mol_t

template<typename _type >

using SI::mol_t = typedef substance_t<_type, std::ratio<1> >

momentum_t

template<typename _type , typename _ratio >

using SI::momentum_t = typedef detail::unit_t<'o', std::ratio<1>, _type, _ratio>

Type for momentum where o = v * M.

nano_ampere_t

template<typename _type >

using SI::nano_ampere_t = typedef electric_current_t<_type, std::nano>

nano_becquerel_t

template<typename _type >

using SI::nano_becquerel_t = typedef radioactivity_t<_type, std::nano>

nano_candela_t

template<typename _type >

using SI::nano_candela_t = typedef luminosity_t<_type, std::nano>

nano_coulomb_t

template<typename _type >

using SI::nano_coulomb_t = typedef electric_charge_t<_type, std::nano>

nano_farad_t

template<typename _type >

using SI::nano_farad_t = typedef electric_capacity_t<_type, std::nano>

nano_gram_t

template<typename _type >

using SI::nano_gram_t = typedef mass_t<_type, std::pico>

nano_gray_t

template<typename _type >

using SI::nano_gray_t = typedef absorbed_dose_t<_type, std::nano>

nano_henry_t

template<typename _type >

using SI::nano_henry_t = typedef inductance_t<_type, std::nano>

nano_hertz_t

template<typename _type >

using SI::nano_hertz_t = typedef frequency_t<_type, std::nano>

nano_joule_t

template<typename _type >

using SI::nano_joule_t = typedef energy_t<_type, std::nano>

nano_katal_t

template<typename _type >

using SI::nano_katal_t = typedef catalytic_activity_t<_type, std::nano>

nano_kelvin_t

template<typename _type >

using SI::nano_kelvin_t = typedef temperature_t<_type, std::nano>

nano_lumen_t

template<typename _type >

using SI::nano_lumen_t = typedef luminous_flux_t<_type, std::nano>

nano_lux_t

template<typename _type >

using SI::nano_lux_t = typedef illuminance_t<_type, std::nano>

nano_metre_t

template<typename _type >

using SI::nano_metre_t = typedef length_t<_type, std::nano>

nano_mol_t

template<typename _type >

using SI::nano_mol_t = typedef substance_t<_type, std::nano>

nano_newton_t

template<typename _type >

using SI::nano_newton_t = typedef force_t<_type, std::nano>

nano_ohm_t

template<typename _type >

using SI::nano_ohm_t = typedef electric_resistance_t<_type, std::nano>

nano_pascal_t

template<typename _type >

using SI::nano_pascal_t = typedef pressure_t<_type, std::nano>

nano_radian_t

template<typename _type >

using SI::nano_radian_t = typedef angle_t<_type, std::nano>

nano_seconds_t

template<typename _type >

using SI::nano_seconds_t = typedef time_t<_type, std::nano>

nano_siemens_t

template<typename _type >

using SI::nano_siemens_t = typedef electric_conductance_t<_type, std::nano>

nano_sievert_t

template<typename _type >

using SI::nano_sievert_t = typedef equivalent_dose_t<_type, std::nano>

nano_steradian_t

template<typename _type >

using SI::nano_steradian_t = typedef solid_angle_t<_type, std::nano>

nano_tesla_t

template<typename _type >

using SI::nano_tesla_t = typedef magnetic_field_t<_type, std::nano>

nano_volt_t

template<typename _type >

using SI::nano_volt_t = typedef electric_potential_t<_type, std::nano>

nano_watt_t

template<typename _type >

using SI::nano_watt_t = typedef power_t<_type, std::nano>

nano_weber_t

template<typename _type >

using SI::nano_weber_t = typedef magnetic_flux_t<_type, std::nano>

newton_t

template<typename _type >

using SI::newton_t = typedef force_t<_type, std::ratio<1> >

ohm_t

template<typename _type >

using SI::ohm_t = typedef electric_resistance_t<_type, std::ratio<1> >

parsec_t

template<typename _type >

using SI::parsec_t = typedef length_t<_type, std::ratio<30856775814913700, 1> >

pascal_t

template<typename _type >

using SI::pascal_t = typedef pressure_t<_type, std::ratio<1> >

peta_ampere_t

template<typename _type >

using SI::peta_ampere_t = typedef electric_current_t<_type, std::peta>

peta_becquerel_t

template<typename _type >

using SI::peta_becquerel_t = typedef radioactivity_t<_type, std::peta>

peta_candela_t

template<typename _type >

using SI::peta_candela_t = typedef luminosity_t<_type, std::peta>

peta_coulomb_t

template<typename _type >

using SI::peta_coulomb_t = typedef electric_charge_t<_type, std::peta>

peta_farad_t

template<typename _type >

using SI::peta_farad_t = typedef electric_capacity_t<_type, std::peta>

peta_gram_t

template<typename _type >

using SI::peta_gram_t = typedef giga_ton_t<_type>

peta_gray_t

template<typename _type >

using SI::peta_gray_t = typedef absorbed_dose_t<_type, std::peta>

peta_henry_t

template<typename _type >

using SI::peta_henry_t = typedef inductance_t<_type, std::peta>

peta_hertz_t

template<typename _type >

using SI::peta_hertz_t = typedef frequency_t<_type, std::peta>

peta_joule_t

template<typename _type >

using SI::peta_joule_t = typedef energy_t<_type, std::peta>

peta_katal_t

template<typename _type >

using SI::peta_katal_t = typedef catalytic_activity_t<_type, std::peta>

peta_kelvin_t

template<typename _type >

using SI::peta_kelvin_t = typedef temperature_t<_type, std::peta>

peta_lumen_t

template<typename _type >

using SI::peta_lumen_t = typedef luminous_flux_t<_type, std::peta>

peta_lux_t

template<typename _type >

using SI::peta_lux_t = typedef illuminance_t<_type, std::peta>

peta_metre_t

template<typename _type >

using SI::peta_metre_t = typedef length_t<_type, std::peta>

peta_mol_t

template<typename _type >

using SI::peta_mol_t = typedef substance_t<_type, std::peta>

peta_newton_t

template<typename _type >

using SI::peta_newton_t = typedef force_t<_type, std::peta>

peta_ohm_t

template<typename _type >

using SI::peta_ohm_t = typedef electric_resistance_t<_type, std::peta>

peta_pascal_t

template<typename _type >

using SI::peta_pascal_t = typedef pressure_t<_type, std::peta>

peta_siemens_t

template<typename _type >

using SI::peta_siemens_t = typedef electric_conductance_t<_type, std::peta>

peta_sievert_t

template<typename _type >

using SI::peta_sievert_t = typedef equivalent_dose_t<_type, std::peta>

peta_tesla_t

template<typename _type >

using SI::peta_tesla_t = typedef magnetic_field_t<_type, std::peta>

peta_ton_t

template<typename _type >

using SI::peta_ton_t = typedef mass_t<_type, std::exa>

peta_volt_t

template<typename _type >

using SI::peta_volt_t = typedef electric_potential_t<_type, std::peta>

peta_watt_t

template<typename _type >

using SI::peta_watt_t = typedef power_t<_type, std::peta>

peta_weber_t

template<typename _type >

using SI::peta_weber_t = typedef magnetic_flux_t<_type, std::peta>

pico_ampere_t

template<typename _type >

using SI::pico_ampere_t = typedef electric_current_t<_type, std::pico>

pico_becquerel_t

template<typename _type >

using SI::pico_becquerel_t = typedef radioactivity_t<_type, std::pico>

pico_candela_t

template<typename _type >

using SI::pico_candela_t = typedef luminosity_t<_type, std::pico>

pico_coulomb_t

template<typename _type >

using SI::pico_coulomb_t = typedef electric_charge_t<_type, std::pico>

pico_farad_t

template<typename _type >

using SI::pico_farad_t = typedef electric_capacity_t<_type, std::pico>

pico_gram_t

template<typename _type >

using SI::pico_gram_t = typedef mass_t<_type, std::femto>

pico_gray_t

template<typename _type >

using SI::pico_gray_t = typedef absorbed_dose_t<_type, std::pico>

pico_henry_t

template<typename _type >

using SI::pico_henry_t = typedef inductance_t<_type, std::pico>

pico_hertz_t

template<typename _type >

using SI::pico_hertz_t = typedef frequency_t<_type, std::pico>

pico_joule_t

template<typename _type >

using SI::pico_joule_t = typedef energy_t<_type, std::pico>

pico_katal_t

template<typename _type >

using SI::pico_katal_t = typedef catalytic_activity_t<_type, std::pico>

pico_kelvin_t

template<typename _type >

using SI::pico_kelvin_t = typedef temperature_t<_type, std::pico>

pico_lumen_t

template<typename _type >

using SI::pico_lumen_t = typedef luminous_flux_t<_type, std::pico>

pico_lux_t

template<typename _type >

using SI::pico_lux_t = typedef illuminance_t<_type, std::pico>

pico_metre_t

template<typename _type >

using SI::pico_metre_t = typedef length_t<_type, std::pico>

pico_mol_t

template<typename _type >

using SI::pico_mol_t = typedef substance_t<_type, std::pico>

pico_newton_t

template<typename _type >

using SI::pico_newton_t = typedef force_t<_type, std::pico>

pico_ohm_t

template<typename _type >

using SI::pico_ohm_t = typedef electric_resistance_t<_type, std::pico>

pico_pascal_t

template<typename _type >

using SI::pico_pascal_t = typedef pressure_t<_type, std::pico>

pico_radian_t

template<typename _type >

using SI::pico_radian_t = typedef angle_t<_type, std::pico>

pico_seconds_t

template<typename _type >

using SI::pico_seconds_t = typedef time_t<_type, std::pico>

pico_siemens_t

template<typename _type >

using SI::pico_siemens_t = typedef electric_conductance_t<_type, std::pico>

pico_sievert_t

template<typename _type >

using SI::pico_sievert_t = typedef equivalent_dose_t<_type, std::pico>

pico_steradian_t

template<typename _type >

using SI::pico_steradian_t = typedef solid_angle_t<_type, std::pico>

pico_tesla_t

template<typename _type >

using SI::pico_tesla_t = typedef magnetic_field_t<_type, std::pico>

pico_volt_t

template<typename _type >

using SI::pico_volt_t = typedef electric_potential_t<_type, std::pico>

pico_watt_t

template<typename _type >

using SI::pico_watt_t = typedef power_t<_type, std::pico>

pico_weber_t

template<typename _type >

using SI::pico_weber_t = typedef magnetic_flux_t<_type, std::pico>

power_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::power_t = typedef detail::unit_t<'P', std::ratio<1>, _type, _ratio>

pressure_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::pressure_t = typedef detail::unit_t<'p', std::ratio<1>, _type, _ratio>

radian_t

template<typename _type >

using SI::radian_t = typedef angle_t<_type, std::ratio<1> >

radioactivity_t

template<typename _type , class _ratio = std::ratio<1>>

using SI::radioactivity_t = typedef detail::unit_t<'A', std::ratio<1>, _type, _ratio>

Todo:

check how to make this the same/an alias of hertz

think of how this can be built from 1/T (probably goes along with making it an alias of hertz)

seconds_t

template<typename _type >

using SI::seconds_t = typedef time_t<_type, std::ratio<1> >

siemens_t

template<typename _type >

using SI::siemens_t = typedef electric_conductance_t<_type, std::ratio<1> >

sievert_t

template<typename _type >

using SI::sievert_t = typedef equivalent_dose_t<_type, std::ratio<1> >

solid_angle_t

template<typename _type , typename _ratio >

using SI::solid_angle_t = typedef detail::unit_t<'R', std::ratio<1>, _type, _ratio>

speed_of_light_t

template<typename _type >

using SI::speed_of_light_t = typedef velocity_t<_type, std::ratio<299792458, 1>::type>

square_centi_metre_t

template<typename _type >

using SI::square_centi_metre_t = typedef area_t<_type, std::ratio_multiply<std::centi, std::centi> >

square_metre_t

template<typename _type >

using SI::square_metre_t = typedef area_t<_type, std::ratio<1> >

square_milli_metre_t

template<typename _type >

using SI::square_milli_metre_t = typedef area_t<_type, std::ratio_multiply<std::milli, std::milli> >

steradian_t

template<typename _type >

using SI::steradian_t = typedef solid_angle_t<_type, std::ratio<1> >

substance_t

template<typename _type , typename _ratio >

using SI::substance_t = typedef detail::unit_t<'N', std::ratio<1>, _type, _ratio>

surface_flow_t

template<typename _type , typename _ratio >

using SI::surface_flow_t = typedef detail::unit_t<'s', std::ratio<1>, _type, _ratio>

temperature_t

template<typename _type , typename _ratio >

using SI::temperature_t = typedef detail::unit_t<'t', std::ratio<1>, _type, _ratio>

Todo:

find a way to encapuslate unit symbol Theta

consider adding Celsius and fahrenheit

tera_ampere_t

template<typename _type >

using SI::tera_ampere_t = typedef electric_current_t<_type, std::tera>

tera_becquerel_t

template<typename _type >

using SI::tera_becquerel_t = typedef radioactivity_t<_type, std::tera>

tera_candela_t

template<typename _type >

using SI::tera_candela_t = typedef luminosity_t<_type, std::tera>

tera_coulomb_t

template<typename _type >

using SI::tera_coulomb_t = typedef electric_charge_t<_type, std::tera>

tera_farad_t

template<typename _type >

using SI::tera_farad_t = typedef electric_capacity_t<_type, std::tera>

tera_gram_t

template<typename _type >

using SI::tera_gram_t = typedef mega_ton_t<_type>

tera_gray_t

template<typename _type >

using SI::tera_gray_t = typedef absorbed_dose_t<_type, std::tera>

tera_henry_t

template<typename _type >

using SI::tera_henry_t = typedef inductance_t<_type, std::tera>

tera_hertz_t

template<typename _type >

using SI::tera_hertz_t = typedef frequency_t<_type, std::tera>

tera_joule_t

template<typename _type >

using SI::tera_joule_t = typedef energy_t<_type, std::tera>

tera_katal_t

template<typename _type >

using SI::tera_katal_t = typedef catalytic_activity_t<_type, std::tera>

tera_kelvin_t

template<typename _type >

using SI::tera_kelvin_t = typedef temperature_t<_type, std::tera>

tera_lumen_t

template<typename _type >

using SI::tera_lumen_t = typedef luminous_flux_t<_type, std::tera>

tera_lux_t

template<typename _type >

using SI::tera_lux_t = typedef illuminance_t<_type, std::tera>

tera_metre_t

template<typename _type >

using SI::tera_metre_t = typedef length_t<_type, std::tera>

tera_mol_t

template<typename _type >

using SI::tera_mol_t = typedef substance_t<_type, std::tera>

tera_newton_t

template<typename _type >

using SI::tera_newton_t = typedef force_t<_type, std::tera>

tera_ohm_t

template<typename _type >

using SI::tera_ohm_t = typedef electric_resistance_t<_type, std::tera>

tera_pascal_t

template<typename _type >

using SI::tera_pascal_t = typedef pressure_t<_type, std::tera>

tera_siemens_t

template<typename _type >

using SI::tera_siemens_t = typedef electric_conductance_t<_type, std::tera>

tera_sievert_t

template<typename _type >

using SI::tera_sievert_t = typedef equivalent_dose_t<_type, std::tera>

tera_tesla_t

template<typename _type >

using SI::tera_tesla_t = typedef magnetic_field_t<_type, std::tera>

tera_ton_t

template<typename _type >

using SI::tera_ton_t = typedef mass_t<_type, std::peta>

tera_volt_t

template<typename _type >

using SI::tera_volt_t = typedef electric_potential_t<_type, std::tera>

tera_watt_t

template<typename _type >

using SI::tera_watt_t = typedef power_t<_type, std::tera>

tera_weber_t

template<typename _type >

using SI::tera_weber_t = typedef magnetic_flux_t<_type, std::tera>

tesla_t

template<typename _type >

using SI::tesla_t = typedef magnetic_field_t<_type, std::ratio<1> >

time_squared_t

template<typename _type , typename _ratio >

using SI::time_squared_t = typedef detail::time_base_t<std::ratio<2>, _type, _ratio>

time_t

template<typename _type , typename _ratio >

using SI::time_t = typedef detail::time_base_t<std::ratio<1>, _type, _ratio>

ton_t

template<typename _type >

using SI::ton_t = typedef mass_t<_type, std::kilo>

velocity_squared_t

template<typename _type , typename _ratio >

using SI::velocity_squared_t = typedef detail::unit_t<'v', std::ratio<2>, _type, _ratio>

velocity_t

template<typename _type , typename _ratio >

using SI::velocity_t = typedef detail::unit_t<'v', std::ratio<1>, _type, _ratio>

Type for velocity where v = L / T.

volt_t

template<typename _type >

using SI::volt_t = typedef electric_potential_t<_type, std::ratio<1> >

volume_t

template<typename _type , typename _ratio >

using SI::volume_t = typedef detail::unit_t<'L', std::ratio<3>, _type, _ratio>

volumetric_flow_t

template<typename _type , typename _ratio >

using SI::volumetric_flow_t = typedef detail::unit_t<'V', std::ratio<1>, _type, _ratio>

watt_t

template<typename _type >

using SI::watt_t = typedef power_t<_type, std::ratio<1> >

weber_t

template<typename _type >

using SI::weber_t = typedef magnetic_flux_t<_type, std::ratio<1> >

zetta_gram_t

template<typename _type >

using SI::zetta_gram_t = typedef peta_ton_t<_type>

Function Documentation

to_string()

template<char _symbol, typename _exponent , typename _type , typename _ratio >

std::string SI::to_string

(

const SI::detail::unit_t< _symbol, _exponent, _type, _ratio > &

value

)