Merge branch 'release/0.9.1'

include/dimensional/arithmetic.hpp

@@ -19,7 +19,7 @@ constexpr auto
 operator+(L &&lhs, R &&rhs)
 {
     using result_type = std::common_type_t<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>;
-    return quantity_t<mitamagic::scaled_demension_t<typename std::decay_t<L>::dimension_type, typename std::decay_t<R>::dimension_type>, result_type>
+    return quantity_t<mitamagic::scaled_dimension_t<typename std::decay_t<L>::dimension_type, typename std::decay_t<R>::dimension_type>, result_type>
         {
             mitamagic::scaled_value(std::forward<L>(lhs), std::forward<R>(rhs), [](auto a, auto b){ return a + b; })
         };
@@ -35,7 +35,7 @@ constexpr auto
 operator-(L &&lhs, R &&rhs)
 {
     using result_type = std::common_type_t<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>;
-    return quantity_t<mitamagic::scaled_demension_t<typename std::decay_t<L>::dimension_type, typename std::decay_t<R>::dimension_type>, result_type>
+    return quantity_t<mitamagic::scaled_dimension_t<typename std::decay_t<L>::dimension_type, typename std::decay_t<R>::dimension_type>, result_type>
         {
             mitamagic::scaled_value(std::forward<L>(lhs), std::forward<R>(rhs), [](auto a, auto b){ return a - b; })
         };
@@ -123,7 +123,7 @@ constexpr auto
 operator/(typename std::decay_t<R>::value_type const& lhs, R&& rhs)
 {
     return quantity_t<
-            si_base_units_repr<mitamagic::inverse_t<typename std::decay_t<R>::dimension_type>>,
+            si_base_units<mitamagic::inverse_t<typename std::decay_t<R>::dimension_type>>,
             typename std::decay_t<R>::value_type
         >
         { lhs / std::forward<R>(rhs).value() };

include/dimensional/derived_units/absorbed_dose.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct absorbed_dose_repr{};
-using absorbed_dose_t = make_synonym_t<absorbed_dose_repr, decltype(meter<2> * second<-2>)>;
+template<class> struct absorbed_dose_synonym{};
+using absorbed_dose_t = make_synonym_t<absorbed_dose_synonym, decltype(meter<2> * second<-2>)>;
 
 inline constexpr absorbed_dose_t gray{};
 using absorbed_dose_r = make_refinement_symbol_t<absorbed_dose_t>;

include/dimensional/derived_units/absorbed_dose_rate.hpp

@@ -7,9 +7,9 @@
 #include "absorbed_dose.hpp"
 
 namespace mitama::si {
-template < class > struct absorbed_dose_rate_repr{};
+template < class > struct absorbed_dose_rate_synonym{};
 
-using absorbed_dose_rate_t = make_synonym_t<absorbed_dose_rate_repr, decltype(gray / second<>)>;
+using absorbed_dose_rate_t = make_synonym_t<absorbed_dose_rate_synonym, decltype(gray / second<>)>;
 
 inline constexpr absorbed_dose_rate_t absorbed_dose_rate{};
 using absorbed_dose_rate_r = make_refinement_symbol_t<absorbed_dose_rate_t>;

include/dimensional/derived_units/acceleration.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct acceleration_repr{};
-using acceleration_t = make_synonym_t<acceleration_repr, decltype(meters * second<-2>)>;
+template<class> struct acceleration_synonym{};
+using acceleration_t = make_synonym_t<acceleration_synonym, decltype(meters * second<-2>)>;
 
 inline constexpr acceleration_t acceleration{};
 using acceleration_r = make_refinement_symbol_t<acceleration_t>;

include/dimensional/derived_units/action.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct action_repr{};
-using action_t = make_synonym_t<action_repr, decltype(meter<2> * kilogram<> * second<-1>)>;
+template<class> struct action_synonym{};
+using action_t = make_synonym_t<action_synonym, decltype(meter<2> * kilogram<> * second<-1>)>;
 
 inline constexpr action_t action{};
 using action_r = make_refinement_symbol_t<action_t>;

include/dimensional/derived_units/angular_acceleration.hpp

@@ -7,8 +7,8 @@
 #include "angle.hpp"
 
 namespace mitama::si {
-template<class> struct angular_acceleration_repr{};
-using angular_acceleration_t = make_synonym_t<angular_acceleration_repr, decltype(radian / second<2>)>;
+template<class> struct angular_acceleration_synonym{};
+using angular_acceleration_t = make_synonym_t<angular_acceleration_synonym, decltype(radian / second<2>)>;
 
 inline constexpr angular_acceleration_t angular_acceleration{};
 using angular_acceleration_r = make_refinement_symbol_t<angular_acceleration_t>;

include/dimensional/derived_units/angular_momentum.hpp

@@ -6,8 +6,8 @@
 #include "../refinement.hpp"
 
 namespace mitama::si {
-template<class> struct angular_momentum_repr{};
-using angular_momentum_t = make_synonym_t<angular_momentum_repr, decltype(meter<2> * kilogram<> * second<-1>)>;
+template<class> struct angular_momentum_synonym{};
+using angular_momentum_t = make_synonym_t<angular_momentum_synonym, decltype(meter<2> * kilogram<> * second<-1>)>;
 
 inline constexpr angular_momentum_t angular_momentum{};
 using angular_momentum_r = make_refinement_symbol_t<angular_momentum_t>;

include/dimensional/derived_units/angular_velocity.hpp

@@ -8,8 +8,8 @@
 
 
 namespace mitama::si {
-template<class> struct angular_velocity_repr{};
-using angular_velocity_t = make_synonym_t<angular_velocity_repr, decltype(radian / seconds)>;
+template<class> struct angular_velocity_synonym{};
+using angular_velocity_t = make_synonym_t<angular_velocity_synonym, decltype(radian / seconds)>;
 
 inline constexpr angular_velocity_t angular_velocity{};
 using angular_velocity_r = make_refinement_symbol_t<angular_velocity_t>;

include/dimensional/derived_units/area_density.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct area_density_repr{};
-using area_density_t = make_synonym_t<area_density_repr, decltype(meter<-2> * kilogram<>)>;
+template<class> struct area_density_synonym{};
+using area_density_t = make_synonym_t<area_density_synonym, decltype(meter<-2> * kilogram<>)>;
 
 inline constexpr area_density_t area_density{};
 using area_density_r = make_refinement_symbol_t<area_density_t>;

include/dimensional/derived_units/capacitance.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct capacitance_repr{};
-using capacitance_t = make_synonym_t<capacitance_repr, decltype(kilogram<-1> * meter<-2> * second<4> * ampere<2>)>;
+template<class> struct capacitance_synonym{};
+using capacitance_t = make_synonym_t<capacitance_synonym, decltype(kilogram<-1> * meter<-2> * second<4> * ampere<2>)>;
 
 inline constexpr capacitance_t farad{};
 using capacitance_r = make_refinement_symbol_t<capacitance_t>;

include/dimensional/derived_units/catalytic_activity.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct catalytic_activity_repr{};
-using catalytic_activity_t = make_synonym_t<catalytic_activity_repr, decltype(second<-1> * mol<>)>;
+template<class> struct catalytic_activity_synonym{};
+using catalytic_activity_t = make_synonym_t<catalytic_activity_synonym, decltype(second<-1> * mol<>)>;
 
 inline constexpr catalytic_activity_t katal{};
 using catalytic_activity_r = make_refinement_symbol_t<catalytic_activity_t>;

include/dimensional/derived_units/catalytic_efficiency.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct catalytic_efficiency_repr{};
-using catalytic_efficiency_t = make_synonym_t<catalytic_efficiency_repr, decltype(meter<3> / (mol<> * second<>))>;
+template<class> struct catalytic_efficiency_synonym{};
+using catalytic_efficiency_t = make_synonym_t<catalytic_efficiency_synonym, decltype(meter<3> / (mol<> * second<>))>;
 
 inline constexpr catalytic_efficiency_t catalytic_efficiency{};
 using catalytic_efficiency_r = make_refinement_symbol_t<catalytic_efficiency_t>;

include/dimensional/derived_units/compressibility.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct compressibility_repr{};
-using compressibility_t = make_synonym_t<compressibility_repr, decltype(meter<> * kilogram<-1> * second<2>)>;
+template<class> struct compressibility_synonym{};
+using compressibility_t = make_synonym_t<compressibility_synonym, decltype(meter<> * kilogram<-1> * second<2>)>;
 
 inline constexpr compressibility_t compressibility{};
 using compressibility_r = make_refinement_symbol_t<compressibility_t>;

include/dimensional/derived_units/conductance.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct conductance_repr{};
-using conductance_t = make_synonym_t<conductance_repr, decltype(kilogram<-1> * meter<-2> * second<3> * ampere<2>)>;
+template<class> struct conductance_synonym{};
+using conductance_t = make_synonym_t<conductance_synonym, decltype(kilogram<-1> * meter<-2> * second<3> * ampere<2>)>;
 
 inline constexpr conductance_t siemens{};
 using conductance_r = make_refinement_symbol_t<conductance_t>;

include/dimensional/derived_units/crackle.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct crackle_repr{};
-using crackle_t = make_synonym_t<crackle_repr, decltype(meters * second<-5>)>;
+template<class> struct crackle_synonym{};
+using crackle_t = make_synonym_t<crackle_synonym, decltype(meters * second<-5>)>;
 
 inline constexpr crackle_t crackle{};
 using crackle_r = make_refinement_symbol_t<crackle_t>;

include/dimensional/derived_units/density.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct density_repr{};
-using density_t = make_synonym_t<density_repr, decltype(meter<-3> * kilogram<>)>;
+template<class> struct density_synonym{};
+using density_t = make_synonym_t<density_synonym, decltype(meter<-3> * kilogram<>)>;
 
 inline constexpr density_t density{};
 using density_r = make_refinement_symbol_t<density_t>;

include/dimensional/derived_units/diffusion_coefficient.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct diffusion_coefficient_repr{};
-using diffusion_coefficient_t = make_synonym_t<diffusion_coefficient_repr, decltype(meter<2> / second<1>)>;
+template<class> struct diffusion_coefficient_synonym{};
+using diffusion_coefficient_t = make_synonym_t<diffusion_coefficient_synonym, decltype(meter<2> / second<1>)>;
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_THERMAL_DIFFUSIVITY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_KINEMATIC_VISCOSITY_HPP)
 inline constexpr diffusion_coefficient_t diffusion_coefficient{};

include/dimensional/derived_units/dynamic_viscosity.hpp

@@ -7,8 +7,8 @@
 #include "pressure.hpp"
 
 namespace mitama::si {
-template<class> struct dynamic_viscosity_repr{};
-using dynamic_viscosity_t = make_synonym_t<dynamic_viscosity_repr, decltype(pascal * seconds)>;
+template<class> struct dynamic_viscosity_synonym{};
+using dynamic_viscosity_t = make_synonym_t<dynamic_viscosity_synonym, decltype(pascal * seconds)>;
 
 inline constexpr dynamic_viscosity_t dynamic_viscosity{};
 using dynamic_viscosity_r = make_refinement_symbol_t<dynamic_viscosity_t>;

include/dimensional/derived_units/electric_charge.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct electric_charge_repr{};
-using electric_charge_t = make_synonym_t<electric_charge_repr, decltype(second<> * ampere<>)>;
+template<class> struct electric_charge_synonym{};
+using electric_charge_t = make_synonym_t<electric_charge_synonym, decltype(second<> * ampere<>)>;
 
 inline constexpr electric_charge_t coulomb{};
 using electric_charge_r = make_refinement_symbol_t<electric_charge_t>;

include/dimensional/derived_units/electric_charge_density.hpp

@@ -7,8 +7,8 @@
 #include "electric_charge.hpp"
 
 namespace mitama::si {
-template<class> struct electric_charge_density_repr{};
-using electric_charge_density_t = make_synonym_t<electric_charge_density_repr, decltype(coulomb / meter<3>)>;
+template<class> struct electric_charge_density_synonym{};
+using electric_charge_density_t = make_synonym_t<electric_charge_density_synonym, decltype(coulomb / meter<3>)>;
 
 inline constexpr electric_charge_density_t electric_charge_density{};
 using electric_charge_density_r = make_refinement_symbol_t<electric_charge_density_t>;

include/dimensional/derived_units/electric_current_density.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct electric_current_density_repr{};
-using electric_current_density_t = make_synonym_t<electric_current_density_repr, decltype(ampere<> / meter<2>)>;
+template<class> struct electric_current_density_synonym{};
+using electric_current_density_t = make_synonym_t<electric_current_density_synonym, decltype(ampere<> / meter<2>)>;
 
 inline constexpr electric_current_density_t electric_current_density{};
 using electric_current_density_r = make_refinement_symbol_t<electric_current_density_t>;

include/dimensional/derived_units/electric_displacement_field.hpp

@@ -7,8 +7,8 @@
 #include "electric_charge.hpp"
 
 namespace mitama::si {
-template<class> struct electric_displacement_field_repr{};
-using electric_displacement_field_t = make_synonym_t<electric_displacement_field_repr, decltype(coulomb / meter<2>)>;
+template<class> struct electric_displacement_field_synonym{};
+using electric_displacement_field_t = make_synonym_t<electric_displacement_field_synonym, decltype(coulomb / meter<2>)>;
 
 inline constexpr electric_displacement_field_t electric_displacement_field{};
 using electric_displacement_field_r = make_refinement_symbol_t<electric_displacement_field_t>;

include/dimensional/derived_units/electric_field_strength.hpp

@@ -7,8 +7,8 @@
 #include "voltage.hpp"
 
 namespace mitama::si {
-template<class> struct electric_field_strength_repr{};
-using electric_field_strength_t = make_synonym_t<electric_field_strength_repr, decltype(volts / meters)>;
+template<class> struct electric_field_strength_synonym{};
+using electric_field_strength_t = make_synonym_t<electric_field_strength_synonym, decltype(volts / meters)>;
 
 inline constexpr electric_field_strength_t electric_field_strength{};
 using electric_field_strength_r = make_refinement_symbol_t<electric_field_strength_t>;

include/dimensional/derived_units/electric_potential.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct electric_potential_repr{};
-using electric_potential_t = make_synonym_t<electric_potential_repr, decltype(kilogram<> * meter<2> * second<-3> * ampere<-1>)>;
+template<class> struct electric_potential_synonym{};
+using electric_potential_t = make_synonym_t<electric_potential_synonym, decltype(kilogram<> * meter<2> * second<-3> * ampere<-1>)>;
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_VOLTAGE_HPP
 inline constexpr electric_potential_t volts{};

include/dimensional/derived_units/electrical_conductivity.hpp

@@ -7,8 +7,8 @@
 #include "conductance.hpp"
 
 namespace mitama::si {
-template<class> struct electrical_conductivity_repr{};
-using electrical_conductivity_t = make_synonym_t<electrical_conductivity_repr, decltype(siemens / meter<>)>;
+template<class> struct electrical_conductivity_synonym{};
+using electrical_conductivity_t = make_synonym_t<electrical_conductivity_synonym, decltype(siemens / meter<>)>;
 
 inline constexpr electrical_conductivity_t electrical_conductivity{};
 using electrical_conductivity_r = make_refinement_symbol_t<electrical_conductivity_t>;

include/dimensional/derived_units/electron_mobility.hpp

@@ -7,8 +7,8 @@
 #include "voltage.hpp"
 
 namespace mitama::si {
-template<class> struct electron_mobility_repr{};
-using electron_mobility_t = make_synonym_t<electron_mobility_repr, decltype( meter<2> * volt<-1> * second<-1> )>;
+template<class> struct electron_mobility_synonym{};
+using electron_mobility_t = make_synonym_t<electron_mobility_synonym, decltype( meter<2> * volt<-1> * second<-1> )>;
 
 inline constexpr electron_mobility_t electron_mobility{};
 using electron_mobility_r = make_refinement_symbol_t<electron_mobility_t>;

include/dimensional/derived_units/energy.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct energy_repr{};
-using energy_t = make_synonym_t<energy_repr, decltype(kilogram<> * meter<2> * second<-2>)>;
+template<class> struct energy_synonym{};
+using energy_t = make_synonym_t<energy_synonym, decltype(kilogram<> * meter<2> * second<-2>)>;
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
 inline constexpr energy_t joule{};

include/dimensional/derived_units/energy_density.hpp

@@ -7,8 +7,8 @@
 #include "energy.hpp"
 
 namespace mitama::si {
-template<class> struct energy_density_repr{};
-using energy_density_t = make_synonym_t<energy_density_repr, decltype(joule / meter<3>)>;
+template<class> struct energy_density_synonym{};
+using energy_density_t = make_synonym_t<energy_density_synonym, decltype(joule / meter<3>)>;
 
 inline constexpr energy_density_t energy_density{};
 using energy_density_r = make_refinement_symbol_t<energy_density_t>;

include/dimensional/derived_units/energy_flux_density.hpp

@@ -7,8 +7,8 @@
 #include "energy.hpp"
 
 namespace mitama::si {
-template<class> struct energy_flux_density_repr{};
-using energy_flux_density_t = make_synonym_t<energy_flux_density_repr, decltype( joule * meter<-2> * second<-1> )>;
+template<class> struct energy_flux_density_synonym{};
+using energy_flux_density_t = make_synonym_t<energy_flux_density_synonym, decltype( joule * meter<-2> * second<-1> )>;
 
 inline constexpr energy_flux_density_t energy_flux_density{};
 using energy_flux_density_r = make_refinement_symbol_t<energy_flux_density_t>;

include/dimensional/derived_units/entropy.hpp

@@ -7,8 +7,8 @@
 #include "energy.hpp"
 
 namespace mitama::si {
-template<class> struct entropy_repr{};
-using entropy_t = make_synonym_t<entropy_repr, decltype(joule / kelvins)>;
+template<class> struct entropy_synonym{};
+using entropy_t = make_synonym_t<entropy_synonym, decltype(joule / kelvins)>;
 
 inline constexpr entropy_t entropy{};
 using entropy_r = make_refinement_symbol_t<entropy_t>;

include/dimensional/derived_units/exposure.hpp

@@ -7,8 +7,8 @@
 #include "electric_charge.hpp"
 
 namespace mitama::si {
-template<class> struct exposure_repr{};
-using exposure_t = make_synonym_t<exposure_repr, decltype(coulomb / kilogram<>)>;
+template<class> struct exposure_synonym{};
+using exposure_t = make_synonym_t<exposure_synonym, decltype(coulomb / kilogram<>)>;
 
 inline constexpr exposure_t exposure{};
 using exposure_r = make_refinement_symbol_t<exposure_t>;

include/dimensional/derived_units/force.hpp

@@ -6,8 +6,8 @@
 #include "../refinement.hpp"
 
 namespace mitama::si {
-template<class> struct force_repr{};
-using force_t = make_synonym_t<force_repr, decltype(kilogram<> * meter<> * second<-2>)>;
+template<class> struct force_synonym{};
+using force_t = make_synonym_t<force_synonym, decltype(kilogram<> * meter<> * second<-2>)>;
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_WEIGHT_HPP
 inline constexpr force_t newton{};
 using force_r = make_refinement_symbol_t<force_t>;

include/dimensional/derived_units/fuel_efficiency.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct fuel_efficiency_repr{};
-using fuel_efficiency_t = make_synonym_t<fuel_efficiency_repr, decltype(meter<-2>)>;
+template<class> struct fuel_efficiency_synonym{};
+using fuel_efficiency_t = make_synonym_t<fuel_efficiency_synonym, decltype(meter<-2>)>;
 
 inline constexpr fuel_efficiency_t fuel_efficiency{};
 using fuel_efficiency_r = make_refinement_symbol_t<fuel_efficiency_t>;

include/dimensional/derived_units/heat.hpp

@@ -7,8 +7,8 @@
 
 
 namespace mitama::si {
-template<class> struct heat_repr{};
-using heat_t = make_synonym_t<heat_repr, decltype(kilogram<> * meter<2> * second<-2>)>;
+template<class> struct heat_synonym{};
+using heat_t = make_synonym_t<heat_synonym, decltype(kilogram<> * meter<2> * second<-2>)>;
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_ENERGY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
 inline constexpr heat_t joule{};